@vercel/sdk 14.0.0-canary.4 → 14.0.0-canary.6

package/esm/models/operations/updateprojectdatacache.d.ts

@@ -0,0 +1,4570 @@
+import * as z from "zod";
+import { ClosedEnum } from "../../types/enums.js";
+import { ACLAction } from "../components/aclaction.js";
+export type UpdateProjectDataCacheRequestBody = {
+    /**
+     * Enable or disable data cache for the project - default: false
+     */
+    disabled?: boolean | undefined;
+};
+export type UpdateProjectDataCacheRequest = {
+    /**
+     * The unique project identifier
+     */
+    projectId: string;
+    /**
+     * The Team identifier to perform the request on behalf of.
+     */
+    teamId?: string | undefined;
+    /**
+     * The Team slug to perform the request on behalf of.
+     */
+    slug?: string | undefined;
+    requestBody?: UpdateProjectDataCacheRequestBody | undefined;
+};
+export type Analytics = {
+    id: string;
+    canceledAt?: number | null | undefined;
+    disabledAt: number;
+    enabledAt: number;
+    paidAt?: number | undefined;
+    sampleRatePercent?: number | null | undefined;
+    spendLimitInDollars?: number | null | undefined;
+};
+export type SpeedInsights = {
+    id: string;
+    enabledAt?: number | undefined;
+    disabledAt?: number | undefined;
+    canceledAt?: number | undefined;
+    hasData?: boolean | undefined;
+    paidAt?: number | undefined;
+};
+export type Definitions = {
+    /**
+     * The hostname that should be used.
+     */
+    host: string;
+    /**
+     * The path that should be called for the cronjob.
+     */
+    path: string;
+    /**
+     * The cron expression.
+     */
+    schedule: string;
+};
+export type Crons = {
+    /**
+     * The time the feature was enabled for this project. Note: It enables automatically with the first Deployment that outputs cronjobs.
+     */
+    enabledAt: number;
+    /**
+     * The time the feature was disabled for this project.
+     */
+    disabledAt: number | null;
+    updatedAt: number;
+    /**
+     * The ID of the Deployment from which the definitions originated.
+     */
+    deploymentId: string | null;
+    definitions: Array<Definitions>;
+};
+export type DataCache = {
+    userDisabled: boolean;
+    storageSizeBytes?: number | null | undefined;
+    unlimited?: boolean | undefined;
+};
+export type DeploymentExpiration = {
+    expirationDays?: number | undefined;
+    expirationDaysProduction?: number | undefined;
+    expirationDaysCanceled?: number | undefined;
+    expirationDaysErrored?: number | undefined;
+    deploymentsToKeep?: number | undefined;
+};
+export declare const UpdateProjectDataCacheTarget2: {
+    readonly Production: "production";
+    readonly Preview: "preview";
+    readonly Development: "development";
+};
+export type UpdateProjectDataCacheTarget2 = ClosedEnum<typeof UpdateProjectDataCacheTarget2>;
+export declare const UpdateProjectDataCacheTarget1: {
+    readonly Production: "production";
+    readonly Preview: "preview";
+    readonly Development: "development";
+};
+export type UpdateProjectDataCacheTarget1 = ClosedEnum<typeof UpdateProjectDataCacheTarget1>;
+export type UpdateProjectDataCacheTarget = Array<UpdateProjectDataCacheTarget1> | UpdateProjectDataCacheTarget2;
+export declare const UpdateProjectDataCacheProjectsResponse200Type: {
+    readonly Secret: "secret";
+    readonly System: "system";
+    readonly Encrypted: "encrypted";
+    readonly Plain: "plain";
+    readonly Sensitive: "sensitive";
+};
+export type UpdateProjectDataCacheProjectsResponse200Type = ClosedEnum<typeof UpdateProjectDataCacheProjectsResponse200Type>;
+export declare const UpdateProjectDataCacheContentHintProjectsResponse200ApplicationJSONResponseBodyEnv15Type: {
+    readonly FlagsConnectionString: "flags-connection-string";
+};
+export type UpdateProjectDataCacheContentHintProjectsResponse200ApplicationJSONResponseBodyEnv15Type = ClosedEnum<typeof UpdateProjectDataCacheContentHintProjectsResponse200ApplicationJSONResponseBodyEnv15Type>;
+export type Fifteen = {
+    type: UpdateProjectDataCacheContentHintProjectsResponse200ApplicationJSONResponseBodyEnv15Type;
+    projectId: string;
+};
+export declare const UpdateProjectDataCacheContentHintProjectsResponse200ApplicationJSONResponseBodyEnv14Type: {
+    readonly IntegrationStoreSecret: "integration-store-secret";
+};
+export type UpdateProjectDataCacheContentHintProjectsResponse200ApplicationJSONResponseBodyEnv14Type = ClosedEnum<typeof UpdateProjectDataCacheContentHintProjectsResponse200ApplicationJSONResponseBodyEnv14Type>;
+export type Fourteen = {
+    type: UpdateProjectDataCacheContentHintProjectsResponse200ApplicationJSONResponseBodyEnv14Type;
+    storeId: string;
+    integrationId: string;
+    integrationProductId: string;
+    integrationConfigurationId: string;
+};
+export declare const UpdateProjectDataCacheContentHintProjectsResponse200ApplicationJSONResponseBodyEnv13Type: {
+    readonly PostgresUrlNoSsl: "postgres-url-no-ssl";
+};
+export type UpdateProjectDataCacheContentHintProjectsResponse200ApplicationJSONResponseBodyEnv13Type = ClosedEnum<typeof UpdateProjectDataCacheContentHintProjectsResponse200ApplicationJSONResponseBodyEnv13Type>;
+export type Thirteen = {
+    type: UpdateProjectDataCacheContentHintProjectsResponse200ApplicationJSONResponseBodyEnv13Type;
+    storeId: string;
+};
+export declare const UpdateProjectDataCacheContentHintProjectsResponse200ApplicationJSONResponseBodyEnv12Type: {
+    readonly PostgresDatabase: "postgres-database";
+};
+export type UpdateProjectDataCacheContentHintProjectsResponse200ApplicationJSONResponseBodyEnv12Type = ClosedEnum<typeof UpdateProjectDataCacheContentHintProjectsResponse200ApplicationJSONResponseBodyEnv12Type>;
+export type Twelve = {
+    type: UpdateProjectDataCacheContentHintProjectsResponse200ApplicationJSONResponseBodyEnv12Type;
+    storeId: string;
+};
+export declare const UpdateProjectDataCacheContentHintProjectsResponse200ApplicationJSONResponseBodyEnv11Type: {
+    readonly PostgresPassword: "postgres-password";
+};
+export type UpdateProjectDataCacheContentHintProjectsResponse200ApplicationJSONResponseBodyEnv11Type = ClosedEnum<typeof UpdateProjectDataCacheContentHintProjectsResponse200ApplicationJSONResponseBodyEnv11Type>;
+export type UpdateProjectDataCacheContentHint11 = {
+    type: UpdateProjectDataCacheContentHintProjectsResponse200ApplicationJSONResponseBodyEnv11Type;
+    storeId: string;
+};
+export declare const UpdateProjectDataCacheContentHintProjectsResponse200ApplicationJSONResponseBodyEnv10Type: {
+    readonly PostgresHost: "postgres-host";
+};
+export type UpdateProjectDataCacheContentHintProjectsResponse200ApplicationJSONResponseBodyEnv10Type = ClosedEnum<typeof UpdateProjectDataCacheContentHintProjectsResponse200ApplicationJSONResponseBodyEnv10Type>;
+export type ContentHint10 = {
+    type: UpdateProjectDataCacheContentHintProjectsResponse200ApplicationJSONResponseBodyEnv10Type;
+    storeId: string;
+};
+export declare const UpdateProjectDataCacheContentHintProjectsResponse200ApplicationJSONResponseBodyEnv9Type: {
+    readonly PostgresUser: "postgres-user";
+};
+export type UpdateProjectDataCacheContentHintProjectsResponse200ApplicationJSONResponseBodyEnv9Type = ClosedEnum<typeof UpdateProjectDataCacheContentHintProjectsResponse200ApplicationJSONResponseBodyEnv9Type>;
+export type ContentHint9 = {
+    type: UpdateProjectDataCacheContentHintProjectsResponse200ApplicationJSONResponseBodyEnv9Type;
+    storeId: string;
+};
+export declare const UpdateProjectDataCacheContentHintProjectsResponse200ApplicationJSONResponseBodyEnvType: {
+    readonly PostgresPrismaUrl: "postgres-prisma-url";
+};
+export type UpdateProjectDataCacheContentHintProjectsResponse200ApplicationJSONResponseBodyEnvType = ClosedEnum<typeof UpdateProjectDataCacheContentHintProjectsResponse200ApplicationJSONResponseBodyEnvType>;
+export type ContentHint8 = {
+    type: UpdateProjectDataCacheContentHintProjectsResponse200ApplicationJSONResponseBodyEnvType;
+    storeId: string;
+};
+export declare const UpdateProjectDataCacheContentHintProjectsResponse200ApplicationJSONResponseBodyType: {
+    readonly PostgresUrlNonPooling: "postgres-url-non-pooling";
+};
+export type UpdateProjectDataCacheContentHintProjectsResponse200ApplicationJSONResponseBodyType = ClosedEnum<typeof UpdateProjectDataCacheContentHintProjectsResponse200ApplicationJSONResponseBodyType>;
+export type ContentHint7 = {
+    type: UpdateProjectDataCacheContentHintProjectsResponse200ApplicationJSONResponseBodyType;
+    storeId: string;
+};
+export declare const UpdateProjectDataCacheContentHintProjectsResponse200ApplicationJSONType: {
+    readonly PostgresUrl: "postgres-url";
+};
+export type UpdateProjectDataCacheContentHintProjectsResponse200ApplicationJSONType = ClosedEnum<typeof UpdateProjectDataCacheContentHintProjectsResponse200ApplicationJSONType>;
+export type ContentHint6 = {
+    type: UpdateProjectDataCacheContentHintProjectsResponse200ApplicationJSONType;
+    storeId: string;
+};
+export declare const UpdateProjectDataCacheContentHintProjectsResponse200Type: {
+    readonly BlobReadWriteToken: "blob-read-write-token";
+};
+export type UpdateProjectDataCacheContentHintProjectsResponse200Type = ClosedEnum<typeof UpdateProjectDataCacheContentHintProjectsResponse200Type>;
+export type ContentHint5 = {
+    type: UpdateProjectDataCacheContentHintProjectsResponse200Type;
+    storeId: string;
+};
+export declare const UpdateProjectDataCacheContentHintProjectsResponseType: {
+    readonly RedisRestApiReadOnlyToken: "redis-rest-api-read-only-token";
+};
+export type UpdateProjectDataCacheContentHintProjectsResponseType = ClosedEnum<typeof UpdateProjectDataCacheContentHintProjectsResponseType>;
+export type ContentHint4 = {
+    type: UpdateProjectDataCacheContentHintProjectsResponseType;
+    storeId: string;
+};
+export declare const UpdateProjectDataCacheContentHintProjectsType: {
+    readonly RedisRestApiToken: "redis-rest-api-token";
+};
+export type UpdateProjectDataCacheContentHintProjectsType = ClosedEnum<typeof UpdateProjectDataCacheContentHintProjectsType>;
+export type ContentHint3 = {
+    type: UpdateProjectDataCacheContentHintProjectsType;
+    storeId: string;
+};
+export declare const UpdateProjectDataCacheContentHintType: {
+    readonly RedisRestApiUrl: "redis-rest-api-url";
+};
+export type UpdateProjectDataCacheContentHintType = ClosedEnum<typeof UpdateProjectDataCacheContentHintType>;
+export type ContentHint2 = {
+    type: UpdateProjectDataCacheContentHintType;
+    storeId: string;
+};
+export declare const ContentHintType: {
+    readonly RedisUrl: "redis-url";
+};
+export type ContentHintType = ClosedEnum<typeof ContentHintType>;
+export type ContentHint1 = {
+    type: ContentHintType;
+    storeId: string;
+};
+export type ContentHint = ContentHint1 | ContentHint2 | ContentHint3 | ContentHint4 | ContentHint5 | ContentHint6 | ContentHint7 | ContentHint8 | ContentHint9 | ContentHint10 | UpdateProjectDataCacheContentHint11 | Twelve | Thirteen | Fifteen | Fourteen;
+export declare const UpdateProjectDataCacheProjectsResponse200ApplicationJSONResponseBodyType: {
+    readonly FlagsSecret: "flags-secret";
+};
+export type UpdateProjectDataCacheProjectsResponse200ApplicationJSONResponseBodyType = ClosedEnum<typeof UpdateProjectDataCacheProjectsResponse200ApplicationJSONResponseBodyType>;
+/**
+ * Similar to `contentHints`, but should not be exposed to the user.
+ */
+export type InternalContentHint = {
+    type: UpdateProjectDataCacheProjectsResponse200ApplicationJSONResponseBodyType;
+    /**
+     * Contains the `value` of the env variable, encrypted with a special key to make decryption possible in the subscriber Lambda.
+     */
+    encryptedValue: string;
+};
+export type Env = {
+    target?: Array<UpdateProjectDataCacheTarget1> | UpdateProjectDataCacheTarget2 | undefined;
+    type: UpdateProjectDataCacheProjectsResponse200Type;
+    /**
+     * This is used to identiy variables that have been migrated from type secret to sensitive.
+     */
+    sunsetSecretId?: string | undefined;
+    id?: string | undefined;
+    key: string;
+    value: string;
+    configurationId?: string | null | undefined;
+    createdAt?: number | undefined;
+    updatedAt?: number | undefined;
+    createdBy?: string | null | undefined;
+    updatedBy?: string | null | undefined;
+    gitBranch?: string | undefined;
+    edgeConfigId?: string | null | undefined;
+    edgeConfigTokenId?: string | null | undefined;
+    contentHint?: ContentHint1 | ContentHint2 | ContentHint3 | ContentHint4 | ContentHint5 | ContentHint6 | ContentHint7 | ContentHint8 | ContentHint9 | ContentHint10 | UpdateProjectDataCacheContentHint11 | Twelve | Thirteen | Fifteen | Fourteen | null | undefined;
+    /**
+     * Similar to `contentHints`, but should not be exposed to the user.
+     */
+    internalContentHint?: InternalContentHint | null | undefined;
+    /**
+     * Whether `value` and `vsmValue` are decrypted.
+     */
+    decrypted?: boolean | undefined;
+    comment?: string | undefined;
+    customEnvironmentIds?: Array<string> | undefined;
+    vsmValue?: string | undefined;
+};
+export type CustomEnvironments = {};
+export declare const UpdateProjectDataCacheFramework: {
+    readonly Blitzjs: "blitzjs";
+    readonly Nextjs: "nextjs";
+    readonly Gatsby: "gatsby";
+    readonly Remix: "remix";
+    readonly Astro: "astro";
+    readonly Hexo: "hexo";
+    readonly Eleventy: "eleventy";
+    readonly Docusaurus2: "docusaurus-2";
+    readonly Docusaurus: "docusaurus";
+    readonly Preact: "preact";
+    readonly Solidstart1: "solidstart-1";
+    readonly Solidstart: "solidstart";
+    readonly Dojo: "dojo";
+    readonly Ember: "ember";
+    readonly Vue: "vue";
+    readonly Scully: "scully";
+    readonly IonicAngular: "ionic-angular";
+    readonly Angular: "angular";
+    readonly Polymer: "polymer";
+    readonly Svelte: "svelte";
+    readonly Sveltekit: "sveltekit";
+    readonly Sveltekit1: "sveltekit-1";
+    readonly IonicReact: "ionic-react";
+    readonly CreateReactApp: "create-react-app";
+    readonly Gridsome: "gridsome";
+    readonly Umijs: "umijs";
+    readonly Sapper: "sapper";
+    readonly Saber: "saber";
+    readonly Stencil: "stencil";
+    readonly Nuxtjs: "nuxtjs";
+    readonly Redwoodjs: "redwoodjs";
+    readonly Hugo: "hugo";
+    readonly Jekyll: "jekyll";
+    readonly Brunch: "brunch";
+    readonly Middleman: "middleman";
+    readonly Zola: "zola";
+    readonly Hydrogen: "hydrogen";
+    readonly Vite: "vite";
+    readonly Vitepress: "vitepress";
+    readonly Vuepress: "vuepress";
+    readonly Parcel: "parcel";
+    readonly Fasthtml: "fasthtml";
+    readonly SanityV3: "sanity-v3";
+    readonly Sanity: "sanity";
+    readonly Storybook: "storybook";
+};
+export type UpdateProjectDataCacheFramework = ClosedEnum<typeof UpdateProjectDataCacheFramework>;
+export type IpBuckets = {
+    bucket: string;
+    supportUntil?: number | undefined;
+};
+export type AliasAssigned = number | boolean;
+export type UpdateProjectDataCacheProjectsAliasError = {
+    code: string;
+    message: string;
+};
+export declare const UpdateProjectDataCacheProjectsResponse200ApplicationJSONType: {
+    readonly EndsWith: "endsWith";
+    readonly StartsWith: "startsWith";
+    readonly Equals: "equals";
+};
+export type UpdateProjectDataCacheProjectsResponse200ApplicationJSONType = ClosedEnum<typeof UpdateProjectDataCacheProjectsResponse200ApplicationJSONType>;
+export type BranchMatcher = {
+    type: UpdateProjectDataCacheProjectsResponse200ApplicationJSONType;
+    pattern: string;
+};
+export type UpdateProjectDataCacheProjectsBuilds = {
+    use: string;
+    src?: string | undefined;
+    dest?: string | undefined;
+};
+export declare const UpdateProjectDataCacheProjectsChecksConclusion: {
+    readonly Succeeded: "succeeded";
+    readonly Failed: "failed";
+    readonly Skipped: "skipped";
+    readonly Canceled: "canceled";
+};
+export type UpdateProjectDataCacheProjectsChecksConclusion = ClosedEnum<typeof UpdateProjectDataCacheProjectsChecksConclusion>;
+export declare const UpdateProjectDataCacheProjectsChecksState: {
+    readonly Registered: "registered";
+    readonly Running: "running";
+    readonly Completed: "completed";
+};
+export type UpdateProjectDataCacheProjectsChecksState = ClosedEnum<typeof UpdateProjectDataCacheProjectsChecksState>;
+export type UpdateProjectDataCacheProjectsCreator = {
+    email: string;
+    githubLogin?: string | undefined;
+    gitlabLogin?: string | undefined;
+    uid: string;
+    username: string;
+};
+export type UpdateProjectDataCacheProjectsOidcTokenClaims = {
+    iss: string;
+    sub: string;
+    scope: string;
+    aud: string;
+    owner: string;
+    ownerId: string;
+    project: string;
+    projectId: string;
+    environment: string;
+};
+export declare const UpdateProjectDataCacheProjectsPlan: {
+    readonly Pro: "pro";
+    readonly Enterprise: "enterprise";
+    readonly Hobby: "hobby";
+};
+export type UpdateProjectDataCacheProjectsPlan = ClosedEnum<typeof UpdateProjectDataCacheProjectsPlan>;
+export declare const UpdateProjectDataCacheProjectsReadyState: {
+    readonly Building: "BUILDING";
+    readonly Error: "ERROR";
+    readonly Initializing: "INITIALIZING";
+    readonly Queued: "QUEUED";
+    readonly Ready: "READY";
+    readonly Canceled: "CANCELED";
+};
+export type UpdateProjectDataCacheProjectsReadyState = ClosedEnum<typeof UpdateProjectDataCacheProjectsReadyState>;
+export declare const UpdateProjectDataCacheProjectsReadySubstate: {
+    readonly Staged: "STAGED";
+    readonly Promoted: "PROMOTED";
+};
+export type UpdateProjectDataCacheProjectsReadySubstate = ClosedEnum<typeof UpdateProjectDataCacheProjectsReadySubstate>;
+export declare const UpdateProjectDataCacheType: {
+    readonly Lambdas: "LAMBDAS";
+};
+export type UpdateProjectDataCacheType = ClosedEnum<typeof UpdateProjectDataCacheType>;
+export type LatestDeployments = {
+    id: string;
+    alias?: Array<string> | undefined;
+    aliasAssigned?: number | boolean | null | undefined;
+    aliasError?: UpdateProjectDataCacheProjectsAliasError | null | undefined;
+    aliasFinal?: string | null | undefined;
+    automaticAliases?: Array<string> | undefined;
+    branchMatcher?: BranchMatcher | undefined;
+    buildingAt?: number | undefined;
+    builds?: Array<UpdateProjectDataCacheProjectsBuilds> | undefined;
+    checksConclusion?: UpdateProjectDataCacheProjectsChecksConclusion | undefined;
+    checksState?: UpdateProjectDataCacheProjectsChecksState | undefined;
+    connectBuildsEnabled?: boolean | undefined;
+    connectConfigurationId?: string | undefined;
+    createdAt: number;
+    createdIn: string;
+    creator: UpdateProjectDataCacheProjectsCreator | null;
+    deletedAt?: number | undefined;
+    deploymentHostname: string;
+    forced?: boolean | undefined;
+    name: string;
+    meta?: {
+        [k: string]: string;
+    } | undefined;
+    monorepoManager?: string | null | undefined;
+    oidcTokenClaims?: UpdateProjectDataCacheProjectsOidcTokenClaims | undefined;
+    plan: UpdateProjectDataCacheProjectsPlan;
+    /**
+     * Whether or not preview comments are enabled for the deployment
+     */
+    previewCommentsEnabled?: boolean | undefined;
+    private: boolean;
+    readyAt?: number | undefined;
+    readyState: UpdateProjectDataCacheProjectsReadyState;
+    readySubstate?: UpdateProjectDataCacheProjectsReadySubstate | undefined;
+    requestedAt?: number | undefined;
+    target?: string | null | undefined;
+    teamId?: string | null | undefined;
+    type: UpdateProjectDataCacheType;
+    url: string;
+    userId: string;
+    withCache?: boolean | undefined;
+};
+export declare const UpdateProjectDataCacheLinkProjectsType: {
+    readonly Bitbucket: "bitbucket";
+};
+export type UpdateProjectDataCacheLinkProjectsType = ClosedEnum<typeof UpdateProjectDataCacheLinkProjectsType>;
+export type UpdateProjectDataCacheLinkDeployHooks = {
+    createdAt?: number | undefined;
+    id: string;
+    name: string;
+    ref: string;
+    url: string;
+};
+export type Link3 = {
+    name?: string | undefined;
+    slug?: string | undefined;
+    owner?: string | undefined;
+    type?: UpdateProjectDataCacheLinkProjectsType | undefined;
+    uuid?: string | undefined;
+    workspaceUuid?: string | undefined;
+    createdAt?: number | undefined;
+    deployHooks: Array<UpdateProjectDataCacheLinkDeployHooks>;
+    gitCredentialId?: string | undefined;
+    updatedAt?: number | undefined;
+    sourceless?: boolean | undefined;
+    productionBranch?: string | undefined;
+};
+export declare const UpdateProjectDataCacheLinkType: {
+    readonly Gitlab: "gitlab";
+};
+export type UpdateProjectDataCacheLinkType = ClosedEnum<typeof UpdateProjectDataCacheLinkType>;
+export type LinkDeployHooks = {
+    createdAt?: number | undefined;
+    id: string;
+    name: string;
+    ref: string;
+    url: string;
+};
+export type Link2 = {
+    projectId?: string | undefined;
+    projectName?: string | undefined;
+    projectNameWithNamespace?: string | undefined;
+    projectNamespace?: string | undefined;
+    /**
+     * 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 | undefined;
+    type?: UpdateProjectDataCacheLinkType | undefined;
+    createdAt?: number | undefined;
+    deployHooks: Array<LinkDeployHooks>;
+    gitCredentialId?: string | undefined;
+    updatedAt?: number | undefined;
+    sourceless?: boolean | undefined;
+    productionBranch?: string | undefined;
+};
+export declare const LinkType: {
+    readonly Github: "github";
+};
+export type LinkType = ClosedEnum<typeof LinkType>;
+export type DeployHooks = {
+    createdAt?: number | undefined;
+    id: string;
+    name: string;
+    ref: string;
+    url: string;
+};
+export type Link1 = {
+    org?: string | undefined;
+    /**
+     * 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;
+    type?: LinkType | undefined;
+    createdAt?: number | undefined;
+    deployHooks: Array<DeployHooks>;
+    gitCredentialId?: string | undefined;
+    updatedAt?: number | undefined;
+    sourceless?: boolean | undefined;
+    productionBranch?: string | undefined;
+};
+export type Link = Link1 | Link3 | Link2;
+/**
+ * The group of microfrontends that this project belongs to. Each microfrontend project must belong to a microfrontends group that is the set of microfrontends that are used together.
+ */
+export type Group = {
+    /**
+     * A unique identifier for the group of microfrontends. All related microfrontend projects will share this group ID. Example: mfe_12HKQaOmR5t5Uy6vdcQsNIiZgHGB
+     */
+    id: string;
+    /**
+     * A human readable name for the microfrontends group. This will be used to display the microfrontends group in the UI.
+     */
+    slug: string;
+};
+export type Microfrontends = {
+    /**
+     * Timestamp when the microfrontends settings were last updated.
+     */
+    updatedAt: number;
+    /**
+     * The group of microfrontends that this project belongs to. Each microfrontend project must belong to a microfrontends group that is the set of microfrontends that are used together.
+     */
+    group: Group;
+    /**
+     * Whether microfrontends are enabled for this project.
+     */
+    enabled: boolean;
+    /**
+     * Whether this project is the default application for the microfrontends group. The default application is the one that is used as the top level shell for the microfrontends group and hosts the other microfrontends.
+     */
+    isDefaultApp?: boolean | undefined;
+    /**
+     * A path that is used to take screenshots and as the default path in preview links when a domain for this microfrontend is shown in the UI.
+     */
+    defaultRoute?: string | undefined;
+};
+export declare const UpdateProjectDataCacheNodeVersion: {
+    readonly TwentyTwoX: "22.x";
+    readonly TwentyX: "20.x";
+    readonly EighteenX: "18.x";
+    readonly SixteenX: "16.x";
+    readonly FourteenX: "14.x";
+    readonly TwelveX: "12.x";
+    readonly TenX: "10.x";
+    readonly Eight10X: "8.10.x";
+};
+export type UpdateProjectDataCacheNodeVersion = ClosedEnum<typeof UpdateProjectDataCacheNodeVersion>;
+export type UpdateProjectDataCachePaths = {
+    value: string;
+};
+export type UpdateProjectDataCacheOptionsAllowlist = {
+    paths: Array<UpdateProjectDataCachePaths>;
+};
+export type UpdateProjectDataCachePasswordProtection = {};
+export declare const FunctionDefaultMemoryType: {
+    readonly StandardLegacy: "standard_legacy";
+    readonly Standard: "standard";
+    readonly Performance: "performance";
+};
+export type FunctionDefaultMemoryType = ClosedEnum<typeof FunctionDefaultMemoryType>;
+export type ResourceConfig = {
+    functionDefaultTimeout?: number | undefined;
+    functionDefaultMemoryType?: FunctionDefaultMemoryType | undefined;
+    allowServerlessConcurrency?: boolean | undefined;
+    elasticConcurrencyEnabled?: boolean | undefined;
+};
+export declare const UpdateProjectDataCacheDeploymentType: {
+    readonly Preview: "preview";
+    readonly All: "all";
+    readonly ProdDeploymentUrlsAndAllPreviews: "prod_deployment_urls_and_all_previews";
+};
+export type UpdateProjectDataCacheDeploymentType = ClosedEnum<typeof UpdateProjectDataCacheDeploymentType>;
+export type UpdateProjectDataCacheSsoProtection = {
+    deploymentType: UpdateProjectDataCacheDeploymentType;
+};
+export type UpdateProjectDataCacheAliasAssigned = number | boolean;
+export type UpdateProjectDataCacheAliasError = {
+    code: string;
+    message: string;
+};
+export declare const UpdateProjectDataCacheProjectsResponse200ApplicationJSONResponseBodyTargetsType: {
+    readonly EndsWith: "endsWith";
+    readonly StartsWith: "startsWith";
+    readonly Equals: "equals";
+};
+export type UpdateProjectDataCacheProjectsResponse200ApplicationJSONResponseBodyTargetsType = ClosedEnum<typeof UpdateProjectDataCacheProjectsResponse200ApplicationJSONResponseBodyTargetsType>;
+export type UpdateProjectDataCacheBranchMatcher = {
+    type: UpdateProjectDataCacheProjectsResponse200ApplicationJSONResponseBodyTargetsType;
+    pattern: string;
+};
+export type UpdateProjectDataCacheBuilds = {
+    use: string;
+    src?: string | undefined;
+    dest?: string | undefined;
+};
+export declare const UpdateProjectDataCacheChecksConclusion: {
+    readonly Succeeded: "succeeded";
+    readonly Failed: "failed";
+    readonly Skipped: "skipped";
+    readonly Canceled: "canceled";
+};
+export type UpdateProjectDataCacheChecksConclusion = ClosedEnum<typeof UpdateProjectDataCacheChecksConclusion>;
+export declare const UpdateProjectDataCacheChecksState: {
+    readonly Registered: "registered";
+    readonly Running: "running";
+    readonly Completed: "completed";
+};
+export type UpdateProjectDataCacheChecksState = ClosedEnum<typeof UpdateProjectDataCacheChecksState>;
+export type UpdateProjectDataCacheCreator = {
+    email: string;
+    githubLogin?: string | undefined;
+    gitlabLogin?: string | undefined;
+    uid: string;
+    username: string;
+};
+export type UpdateProjectDataCacheOidcTokenClaims = {
+    iss: string;
+    sub: string;
+    scope: string;
+    aud: string;
+    owner: string;
+    ownerId: string;
+    project: string;
+    projectId: string;
+    environment: string;
+};
+export declare const UpdateProjectDataCachePlan: {
+    readonly Pro: "pro";
+    readonly Enterprise: "enterprise";
+    readonly Hobby: "hobby";
+};
+export type UpdateProjectDataCachePlan = ClosedEnum<typeof UpdateProjectDataCachePlan>;
+export declare const UpdateProjectDataCacheReadyState: {
+    readonly Building: "BUILDING";
+    readonly Error: "ERROR";
+    readonly Initializing: "INITIALIZING";
+    readonly Queued: "QUEUED";
+    readonly Ready: "READY";
+    readonly Canceled: "CANCELED";
+};
+export type UpdateProjectDataCacheReadyState = ClosedEnum<typeof UpdateProjectDataCacheReadyState>;
+export declare const UpdateProjectDataCacheReadySubstate: {
+    readonly Staged: "STAGED";
+    readonly Promoted: "PROMOTED";
+};
+export type UpdateProjectDataCacheReadySubstate = ClosedEnum<typeof UpdateProjectDataCacheReadySubstate>;
+export declare const UpdateProjectDataCacheProjectsType: {
+    readonly Lambdas: "LAMBDAS";
+};
+export type UpdateProjectDataCacheProjectsType = ClosedEnum<typeof UpdateProjectDataCacheProjectsType>;
+export type Targets = {
+    id: string;
+    alias?: Array<string> | undefined;
+    aliasAssigned?: number | boolean | null | undefined;
+    aliasError?: UpdateProjectDataCacheAliasError | null | undefined;
+    aliasFinal?: string | null | undefined;
+    automaticAliases?: Array<string> | undefined;
+    branchMatcher?: UpdateProjectDataCacheBranchMatcher | undefined;
+    buildingAt?: number | undefined;
+    builds?: Array<UpdateProjectDataCacheBuilds> | undefined;
+    checksConclusion?: UpdateProjectDataCacheChecksConclusion | undefined;
+    checksState?: UpdateProjectDataCacheChecksState | undefined;
+    connectBuildsEnabled?: boolean | undefined;
+    connectConfigurationId?: string | undefined;
+    createdAt: number;
+    createdIn: string;
+    creator: UpdateProjectDataCacheCreator | null;
+    deletedAt?: number | undefined;
+    deploymentHostname: string;
+    forced?: boolean | undefined;
+    name: string;
+    meta?: {
+        [k: string]: string;
+    } | undefined;
+    monorepoManager?: string | null | undefined;
+    oidcTokenClaims?: UpdateProjectDataCacheOidcTokenClaims | undefined;
+    plan: UpdateProjectDataCachePlan;
+    /**
+     * Whether or not preview comments are enabled for the deployment
+     */
+    previewCommentsEnabled?: boolean | undefined;
+    private: boolean;
+    readyAt?: number | undefined;
+    readyState: UpdateProjectDataCacheReadyState;
+    readySubstate?: UpdateProjectDataCacheReadySubstate | undefined;
+    requestedAt?: number | undefined;
+    target?: string | null | undefined;
+    teamId?: string | null | undefined;
+    type: UpdateProjectDataCacheProjectsType;
+    url: string;
+    userId: string;
+    withCache?: boolean | undefined;
+};
+export type Permissions = {
+    accessGroup?: Array<ACLAction> | undefined;
+    aliasGlobal?: Array<ACLAction> | undefined;
+    analyticsSampling?: Array<ACLAction> | undefined;
+    analyticsUsage?: Array<ACLAction> | undefined;
+    auditLog?: Array<ACLAction> | undefined;
+    billingAddress?: Array<ACLAction> | undefined;
+    billingInformation?: Array<ACLAction> | undefined;
+    billingInvoice?: Array<ACLAction> | undefined;
+    billingInvoiceEmailRecipient?: Array<ACLAction> | undefined;
+    billingInvoiceLanguage?: Array<ACLAction> | undefined;
+    billingPlan?: Array<ACLAction> | undefined;
+    billingPurchaseOrder?: Array<ACLAction> | undefined;
+    billingTaxId?: Array<ACLAction> | undefined;
+    blob?: Array<ACLAction> | undefined;
+    budget?: Array<ACLAction> | undefined;
+    cacheArtifact?: Array<ACLAction> | undefined;
+    cacheArtifactUsageEvent?: Array<ACLAction> | undefined;
+    codeChecks?: Array<ACLAction> | undefined;
+    concurrentBuilds?: Array<ACLAction> | undefined;
+    connect?: Array<ACLAction> | undefined;
+    connectConfiguration?: Array<ACLAction> | undefined;
+    domain?: Array<ACLAction> | undefined;
+    domainAcceptDelegation?: Array<ACLAction> | undefined;
+    domainAuthCodes?: Array<ACLAction> | undefined;
+    domainCertificate?: Array<ACLAction> | undefined;
+    domainCheckConfig?: Array<ACLAction> | undefined;
+    domainMove?: Array<ACLAction> | undefined;
+    domainPurchase?: Array<ACLAction> | undefined;
+    domainRecord?: Array<ACLAction> | undefined;
+    domainTransferIn?: Array<ACLAction> | undefined;
+    event?: Array<ACLAction> | undefined;
+    ownEvent?: Array<ACLAction> | undefined;
+    sensitiveEnvironmentVariablePolicy?: Array<ACLAction> | undefined;
+    fileUpload?: Array<ACLAction> | undefined;
+    gitRepository?: Array<ACLAction> | undefined;
+    ipBlocking?: Array<ACLAction> | undefined;
+    integration?: Array<ACLAction> | undefined;
+    integrationAccount?: Array<ACLAction> | undefined;
+    integrationConfiguration?: Array<ACLAction> | undefined;
+    integrationConfigurationTransfer?: Array<ACLAction> | undefined;
+    integrationConfigurationProjects?: Array<ACLAction> | undefined;
+    integrationVercelConfigurationOverride?: Array<ACLAction> | undefined;
+    integrationConfigurationRole?: Array<ACLAction> | undefined;
+    integrationResource?: Array<ACLAction> | undefined;
+    integrationEvent?: Array<ACLAction> | undefined;
+    integrationResourceSecrets?: Array<ACLAction> | undefined;
+    integrationDeploymentAction?: Array<ACLAction> | undefined;
+    marketplaceInstallationMember?: Array<ACLAction> | undefined;
+    marketplaceBillingData?: Array<ACLAction> | undefined;
+    marketplaceInvoice?: Array<ACLAction> | undefined;
+    jobGlobal?: Array<ACLAction> | undefined;
+    logDrain?: Array<ACLAction> | undefined;
+    monitoring?: Array<ACLAction> | undefined;
+    monitoringSettings?: Array<ACLAction> | undefined;
+    monitoringQuery?: Array<ACLAction> | undefined;
+    monitoringChart?: Array<ACLAction> | undefined;
+    monitoringAlert?: Array<ACLAction> | undefined;
+    notificationDeploymentFailed?: Array<ACLAction> | undefined;
+    notificationDomainConfiguration?: Array<ACLAction> | undefined;
+    notificationDomainExpire?: Array<ACLAction> | undefined;
+    notificationDomainMoved?: Array<ACLAction> | undefined;
+    notificationDomainPurchase?: Array<ACLAction> | undefined;
+    notificationDomainRenewal?: Array<ACLAction> | undefined;
+    notificationDomainTransfer?: Array<ACLAction> | undefined;
+    notificationDomainUnverified?: Array<ACLAction> | undefined;
+    notificationMonitoringAlert?: Array<ACLAction> | undefined;
+    notificationPaymentFailed?: Array<ACLAction> | undefined;
+    notificationUsageAlert?: Array<ACLAction> | undefined;
+    notificationCustomerBudget?: Array<ACLAction> | undefined;
+    notificationStatementOfReasons?: Array<ACLAction> | undefined;
+    oauth2Connection?: Array<ACLAction> | undefined;
+    openTelemetryEndpoint?: Array<ACLAction> | undefined;
+    paymentMethod?: Array<ACLAction> | undefined;
+    permissions?: Array<ACLAction> | undefined;
+    postgres?: Array<ACLAction> | undefined;
+    previewDeploymentSuffix?: Array<ACLAction> | undefined;
+    proTrialOnboarding?: Array<ACLAction> | undefined;
+    sharedEnvVars?: Array<ACLAction> | undefined;
+    sharedEnvVarsProduction?: Array<ACLAction> | undefined;
+    space?: Array<ACLAction> | undefined;
+    spaceRun?: Array<ACLAction> | undefined;
+    passwordProtectionInvoiceItem?: Array<ACLAction> | undefined;
+    rateLimit?: Array<ACLAction> | undefined;
+    redis?: Array<ACLAction> | undefined;
+    repository?: Array<ACLAction> | undefined;
+    remoteCaching?: Array<ACLAction> | undefined;
+    samlConfig?: Array<ACLAction> | undefined;
+    secret?: Array<ACLAction> | undefined;
+    redisStoreTokenSet?: Array<ACLAction> | undefined;
+    blobStoreTokenSet?: Array<ACLAction> | undefined;
+    postgresStoreTokenSet?: Array<ACLAction> | undefined;
+    integrationStoreTokenSet?: Array<ACLAction> | undefined;
+    integrationResourceReplCommand?: Array<ACLAction> | undefined;
+    storeTransfer?: Array<ACLAction> | undefined;
+    supportCase?: Array<ACLAction> | undefined;
+    supportCaseComment?: Array<ACLAction> | undefined;
+    dataCacheBillingSettings?: Array<ACLAction> | undefined;
+    team?: Array<ACLAction> | undefined;
+    teamAccessRequest?: Array<ACLAction> | undefined;
+    teamFellowMembership?: Array<ACLAction> | undefined;
+    teamGitExclusivity?: Array<ACLAction> | undefined;
+    teamInvite?: Array<ACLAction> | undefined;
+    teamInviteCode?: Array<ACLAction> | undefined;
+    teamJoin?: Array<ACLAction> | undefined;
+    teamOwnMembership?: Array<ACLAction> | undefined;
+    teamOwnMembershipDisconnectSAML?: Array<ACLAction> | undefined;
+    token?: Array<ACLAction> | undefined;
+    usage?: Array<ACLAction> | undefined;
+    usageCycle?: Array<ACLAction> | undefined;
+    user?: Array<ACLAction> | undefined;
+    userConnection?: Array<ACLAction> | undefined;
+    vpcPeeringConnection?: Array<ACLAction> | undefined;
+    webAnalyticsPlan?: Array<ACLAction> | undefined;
+    webAuthn?: Array<ACLAction> | undefined;
+    edgeConfig?: Array<ACLAction> | undefined;
+    edgeConfigItem?: Array<ACLAction> | undefined;
+    edgeConfigSchema?: Array<ACLAction> | undefined;
+    edgeConfigToken?: Array<ACLAction> | undefined;
+    webhook?: Array<ACLAction> | undefined;
+    webhookEvent?: Array<ACLAction> | undefined;
+    endpointVerification?: Array<ACLAction> | undefined;
+    projectTransferIn?: Array<ACLAction> | undefined;
+    oauth2Application?: Array<ACLAction> | undefined;
+    aliasProject?: Array<ACLAction> | undefined;
+    aliasProtectionBypass?: Array<ACLAction> | undefined;
+    productionAliasProtectionBypass?: Array<ACLAction> | undefined;
+    connectConfigurationLink?: Array<ACLAction> | undefined;
+    dataCacheNamespace?: Array<ACLAction> | undefined;
+    deployment?: Array<ACLAction> | undefined;
+    deploymentCheck?: Array<ACLAction> | undefined;
+    deploymentCheckPreview?: Array<ACLAction> | undefined;
+    deploymentCheckReRunFromProductionBranch?: Array<ACLAction> | undefined;
+    deploymentProductionGit?: Array<ACLAction> | undefined;
+    deploymentPreview?: Array<ACLAction> | undefined;
+    deploymentPrivate?: Array<ACLAction> | undefined;
+    deploymentPromote?: Array<ACLAction> | undefined;
+    deploymentRollback?: Array<ACLAction> | undefined;
+    environments?: Array<ACLAction> | undefined;
+    logs?: Array<ACLAction> | undefined;
+    logsPreset?: Array<ACLAction> | undefined;
+    passwordProtection?: Array<ACLAction> | undefined;
+    optionsAllowlist?: Array<ACLAction> | undefined;
+    job?: Array<ACLAction> | undefined;
+    project?: Array<ACLAction> | undefined;
+    projectAccessGroup?: Array<ACLAction> | undefined;
+    projectAnalyticsSampling?: Array<ACLAction> | undefined;
+    projectDeploymentHook?: Array<ACLAction> | undefined;
+    projectDomain?: Array<ACLAction> | undefined;
+    projectDomainMove?: Array<ACLAction> | undefined;
+    projectDomainCheckConfig?: Array<ACLAction> | undefined;
+    projectEnvVars?: Array<ACLAction> | undefined;
+    projectEnvVarsProduction?: Array<ACLAction> | undefined;
+    projectEnvVarsUnownedByIntegration?: Array<ACLAction> | undefined;
+    projectFlags?: Array<ACLAction> | undefined;
+    projectId?: Array<ACLAction> | undefined;
+    projectIntegrationConfiguration?: Array<ACLAction> | undefined;
+    projectLink?: Array<ACLAction> | undefined;
+    projectMember?: Array<ACLAction> | undefined;
+    projectMonitoring?: Array<ACLAction> | undefined;
+    projectPermissions?: Array<ACLAction> | undefined;
+    projectProductionBranch?: Array<ACLAction> | undefined;
+    projectTransfer?: Array<ACLAction> | undefined;
+    projectTransferOut?: Array<ACLAction> | undefined;
+    projectProtectionBypass?: Array<ACLAction> | undefined;
+    projectUsage?: Array<ACLAction> | undefined;
+    projectAnalyticsUsage?: Array<ACLAction> | undefined;
+    projectSupportCase?: Array<ACLAction> | undefined;
+    projectSupportCaseComment?: Array<ACLAction> | undefined;
+    projectDeploymentExpiration?: Array<ACLAction> | undefined;
+    projectTier?: Array<ACLAction> | undefined;
+    seawallConfig?: Array<ACLAction> | undefined;
+    skewProtection?: Array<ACLAction> | undefined;
+    analytics?: Array<ACLAction> | undefined;
+    trustedIps?: Array<ACLAction> | undefined;
+    webAnalytics?: Array<ACLAction> | undefined;
+    sharedEnvVarConnection?: Array<ACLAction> | undefined;
+    sonar?: Array<ACLAction> | undefined;
+};
+export type LastRollbackTarget = {};
+export declare const JobStatus: {
+    readonly Succeeded: "succeeded";
+    readonly Failed: "failed";
+    readonly Skipped: "skipped";
+    readonly Pending: "pending";
+    readonly InProgress: "in-progress";
+};
+export type JobStatus = ClosedEnum<typeof JobStatus>;
+export declare const UpdateProjectDataCacheProjectsResponseType: {
+    readonly Promote: "promote";
+    readonly Rollback: "rollback";
+};
+export type UpdateProjectDataCacheProjectsResponseType = ClosedEnum<typeof UpdateProjectDataCacheProjectsResponseType>;
+export type LastAliasRequest = {
+    fromDeploymentId: string;
+    toDeploymentId: string;
+    jobStatus: JobStatus;
+    requestedAt: number;
+    type: UpdateProjectDataCacheProjectsResponseType;
+};
+export declare const Scope: {
+    readonly AutomationBypass: "automation-bypass";
+};
+export type Scope = ClosedEnum<typeof Scope>;
+export type ProtectionBypass = {
+    createdAt: number;
+    createdBy: string;
+    scope: Scope;
+};
+export declare const UpdateProjectDataCacheTrustedIpsDeploymentType: {
+    readonly Production: "production";
+    readonly Preview: "preview";
+    readonly All: "all";
+    readonly ProdDeploymentUrlsAndAllPreviews: "prod_deployment_urls_and_all_previews";
+};
+export type UpdateProjectDataCacheTrustedIpsDeploymentType = ClosedEnum<typeof UpdateProjectDataCacheTrustedIpsDeploymentType>;
+export type TrustedIps2 = {
+    deploymentType: UpdateProjectDataCacheTrustedIpsDeploymentType;
+};
+export declare const TrustedIpsDeploymentType: {
+    readonly Production: "production";
+    readonly Preview: "preview";
+    readonly All: "all";
+    readonly ProdDeploymentUrlsAndAllPreviews: "prod_deployment_urls_and_all_previews";
+};
+export type TrustedIpsDeploymentType = ClosedEnum<typeof TrustedIpsDeploymentType>;
+export type UpdateProjectDataCacheTrustedIpsAddresses = {
+    value: string;
+    note?: string | undefined;
+};
+export declare const UpdateProjectDataCacheTrustedIpsProtectionMode: {
+    readonly Additional: "additional";
+    readonly Exclusive: "exclusive";
+};
+export type UpdateProjectDataCacheTrustedIpsProtectionMode = ClosedEnum<typeof UpdateProjectDataCacheTrustedIpsProtectionMode>;
+export type TrustedIps1 = {
+    deploymentType: TrustedIpsDeploymentType;
+    addresses: Array<UpdateProjectDataCacheTrustedIpsAddresses>;
+    protectionMode: UpdateProjectDataCacheTrustedIpsProtectionMode;
+};
+export type UpdateProjectDataCacheTrustedIps = TrustedIps2 | TrustedIps1;
+export type GitComments = {
+    /**
+     * Whether the Vercel bot should comment on PRs
+     */
+    onPullRequest: boolean;
+    /**
+     * Whether the Vercel bot should comment on commits
+     */
+    onCommit: boolean;
+};
+export type WebAnalytics = {
+    id: string;
+    disabledAt?: number | undefined;
+    canceledAt?: number | undefined;
+    enabledAt?: number | undefined;
+    hasData?: boolean | undefined;
+};
+export type Src2 = {
+    re?: string | undefined;
+    eq?: string | undefined;
+    neq?: string | undefined;
+    inc?: Array<string> | undefined;
+    ninc?: Array<string> | undefined;
+    pre?: string | undefined;
+    suf?: string | undefined;
+    gt?: number | undefined;
+    gte?: number | undefined;
+    lt?: number | undefined;
+    lte?: number | undefined;
+};
+export type Src = Src2 | string;
+export declare const UpdateProjectDataCacheProjectsResponse200ApplicationJSONResponseBodySecurityType: {
+    readonly Path: "path";
+    readonly Host: "host";
+    readonly Method: "method";
+    readonly Header: "header";
+    readonly Cookie: "cookie";
+    readonly Query: "query";
+    readonly IpAddress: "ip_address";
+    readonly Protocol: "protocol";
+    readonly Scheme: "scheme";
+    readonly Environment: "environment";
+    readonly Region: "region";
+};
+export type UpdateProjectDataCacheProjectsResponse200ApplicationJSONResponseBodySecurityType = ClosedEnum<typeof UpdateProjectDataCacheProjectsResponse200ApplicationJSONResponseBodySecurityType>;
+export type UpdateProjectDataCacheValueProjects2 = {
+    re?: string | undefined;
+    eq?: string | undefined;
+    neq?: string | undefined;
+    inc?: Array<string> | undefined;
+    ninc?: Array<string> | undefined;
+    pre?: string | undefined;
+    suf?: string | undefined;
+    gt?: number | undefined;
+    gte?: number | undefined;
+    lt?: number | undefined;
+    lte?: number | undefined;
+};
+export type UpdateProjectDataCacheProjectsValue = UpdateProjectDataCacheValueProjects2 | string;
+export type Has = {
+    type: UpdateProjectDataCacheProjectsResponse200ApplicationJSONResponseBodySecurityType;
+    key?: string | undefined;
+    value?: UpdateProjectDataCacheValueProjects2 | string | undefined;
+};
+export declare const UpdateProjectDataCacheProjectsResponse200ApplicationJSONResponseBodySecurityFirewallRoutesType: {
+    readonly Path: "path";
+    readonly Host: "host";
+    readonly Method: "method";
+    readonly Header: "header";
+    readonly Cookie: "cookie";
+    readonly Query: "query";
+    readonly IpAddress: "ip_address";
+    readonly Protocol: "protocol";
+    readonly Scheme: "scheme";
+    readonly Environment: "environment";
+    readonly Region: "region";
+};
+export type UpdateProjectDataCacheProjectsResponse200ApplicationJSONResponseBodySecurityFirewallRoutesType = ClosedEnum<typeof UpdateProjectDataCacheProjectsResponse200ApplicationJSONResponseBodySecurityFirewallRoutesType>;
+export type UpdateProjectDataCacheValue2 = {
+    re?: string | undefined;
+    eq?: string | undefined;
+    neq?: string | undefined;
+    inc?: Array<string> | undefined;
+    ninc?: Array<string> | undefined;
+    pre?: string | undefined;
+    suf?: string | undefined;
+    gt?: number | undefined;
+    gte?: number | undefined;
+    lt?: number | undefined;
+    lte?: number | undefined;
+};
+export type UpdateProjectDataCacheValue = UpdateProjectDataCacheValue2 | string;
+export type Missing = {
+    type: UpdateProjectDataCacheProjectsResponse200ApplicationJSONResponseBodySecurityFirewallRoutesType;
+    key?: string | undefined;
+    value?: UpdateProjectDataCacheValue2 | string | undefined;
+};
+export declare const Handle: {
+    readonly Init: "init";
+    readonly Finalize: "finalize";
+};
+export type Handle = ClosedEnum<typeof Handle>;
+export declare const UpdateProjectDataCacheAction: {
+    readonly Deny: "deny";
+    readonly Challenge: "challenge";
+    readonly Log: "log";
+    readonly Bypass: "bypass";
+    readonly RateLimit: "rate_limit";
+    readonly Redirect: "redirect";
+};
+export type UpdateProjectDataCacheAction = ClosedEnum<typeof UpdateProjectDataCacheAction>;
+export declare const UpdateProjectDataCacheAlgo: {
+    readonly FixedWindow: "fixed_window";
+    readonly TokenBucket: "token_bucket";
+};
+export type UpdateProjectDataCacheAlgo = ClosedEnum<typeof UpdateProjectDataCacheAlgo>;
+export type Erl = {
+    algo: UpdateProjectDataCacheAlgo;
+    window: number;
+    limit: number;
+    keys: Array<string>;
+};
+export type UpdateProjectDataCacheMitigate = {
+    action: UpdateProjectDataCacheAction;
+    ruleId: string;
+    ttl?: number | undefined;
+    erl?: Erl | undefined;
+};
+export type FirewallRoutes = {
+    src?: Src2 | string | undefined;
+    has?: Array<Has> | undefined;
+    missing?: Array<Missing> | undefined;
+    dest?: string | undefined;
+    status?: number | undefined;
+    handle?: Handle | undefined;
+    mitigate?: UpdateProjectDataCacheMitigate | undefined;
+};
+export type Security = {
+    attackModeEnabled?: boolean | undefined;
+    attackModeUpdatedAt?: number | undefined;
+    firewallEnabled?: boolean | undefined;
+    firewallUpdatedAt?: number | undefined;
+    attackModeActiveUntil?: number | null | undefined;
+    firewallConfigVersion?: number | undefined;
+    firewallRoutes?: Array<FirewallRoutes> | undefined;
+    firewallSeawallEnabled?: boolean | undefined;
+    ja3Enabled?: boolean | undefined;
+    ja4Enabled?: boolean | undefined;
+};
+/**
+ * - team: `https://oidc.vercel.com/[team_slug]` - global: `https://oidc.vercel.com`
+ */
+export declare const UpdateProjectDataCacheIssuerMode: {
+    readonly Team: "team";
+    readonly Global: "global";
+};
+/**
+ * - team: `https://oidc.vercel.com/[team_slug]` - global: `https://oidc.vercel.com`
+ */
+export type UpdateProjectDataCacheIssuerMode = ClosedEnum<typeof UpdateProjectDataCacheIssuerMode>;
+export type UpdateProjectDataCacheOidcTokenConfig = {
+    enabled: boolean;
+    /**
+     * - team: `https://oidc.vercel.com/[team_slug]` - global: `https://oidc.vercel.com`
+     */
+    issuerMode?: UpdateProjectDataCacheIssuerMode | undefined;
+};
+export declare const Tier: {
+    readonly Standard: "standard";
+    readonly Advanced: "advanced";
+    readonly Critical: "critical";
+};
+export type Tier = ClosedEnum<typeof Tier>;
+export type UpdateProjectDataCacheResponseBody = {
+    accountId: string;
+    analytics?: Analytics | undefined;
+    speedInsights?: SpeedInsights | undefined;
+    autoExposeSystemEnvs?: boolean | undefined;
+    autoAssignCustomDomains?: boolean | undefined;
+    autoAssignCustomDomainsUpdatedBy?: string | undefined;
+    buildCommand?: string | null | undefined;
+    commandForIgnoringBuildStep?: string | null | undefined;
+    connectConfigurationId?: string | null | undefined;
+    connectBuildsEnabled?: boolean | undefined;
+    createdAt?: number | undefined;
+    customerSupportCodeVisibility?: boolean | undefined;
+    crons?: Crons | undefined;
+    dataCache?: DataCache | undefined;
+    deploymentExpiration?: DeploymentExpiration | null | undefined;
+    devCommand?: string | null | undefined;
+    directoryListing: boolean;
+    installCommand?: string | null | undefined;
+    env?: Array<Env> | undefined;
+    customEnvironments?: Array<CustomEnvironments> | undefined;
+    framework?: UpdateProjectDataCacheFramework | null | undefined;
+    gitForkProtection?: boolean | undefined;
+    gitLFS?: boolean | undefined;
+    id: string;
+    ipBuckets?: Array<IpBuckets> | undefined;
+    latestDeployments?: Array<LatestDeployments> | undefined;
+    link?: Link1 | Link3 | Link2 | undefined;
+    microfrontends?: Microfrontends | undefined;
+    name: string;
+    nodeVersion: UpdateProjectDataCacheNodeVersion;
+    optionsAllowlist?: UpdateProjectDataCacheOptionsAllowlist | null | undefined;
+    outputDirectory?: string | null | undefined;
+    passiveConnectConfigurationId?: string | null | undefined;
+    passwordProtection?: UpdateProjectDataCachePasswordProtection | null | undefined;
+    productionDeploymentsFastLane?: boolean | undefined;
+    publicSource?: boolean | null | undefined;
+    resourceConfig?: ResourceConfig | undefined;
+    rootDirectory?: string | null | undefined;
+    serverlessFunctionRegion?: string | null | undefined;
+    serverlessFunctionZeroConfigFailover?: boolean | undefined;
+    skewProtectionBoundaryAt?: number | undefined;
+    skewProtectionMaxAge?: number | undefined;
+    skipGitConnectDuringLink?: boolean | undefined;
+    sourceFilesOutsideRootDirectory?: boolean | undefined;
+    enableAffectedProjectsDeployments?: boolean | undefined;
+    ssoProtection?: UpdateProjectDataCacheSsoProtection | null | undefined;
+    targets?: {
+        [k: string]: Targets;
+    } | undefined;
+    transferCompletedAt?: number | undefined;
+    transferStartedAt?: number | undefined;
+    transferToAccountId?: string | undefined;
+    transferredFromAccountId?: string | undefined;
+    updatedAt?: number | undefined;
+    live?: boolean | undefined;
+    enablePreviewFeedback?: boolean | null | undefined;
+    enableProductionFeedback?: boolean | null | undefined;
+    permissions?: Permissions | undefined;
+    lastRollbackTarget?: LastRollbackTarget | null | undefined;
+    lastAliasRequest?: LastAliasRequest | null | undefined;
+    hasFloatingAliases?: boolean | undefined;
+    protectionBypass?: {
+        [k: string]: ProtectionBypass;
+    } | undefined;
+    hasActiveBranches?: boolean | undefined;
+    trustedIps?: TrustedIps2 | TrustedIps1 | null | undefined;
+    gitComments?: GitComments | undefined;
+    paused?: boolean | undefined;
+    concurrencyBucketName?: string | undefined;
+    webAnalytics?: WebAnalytics | undefined;
+    security?: Security | undefined;
+    oidcTokenConfig?: UpdateProjectDataCacheOidcTokenConfig | undefined;
+    tier?: Tier | undefined;
+};
+/** @internal */
+export declare const UpdateProjectDataCacheRequestBody$inboundSchema: z.ZodType<UpdateProjectDataCacheRequestBody, z.ZodTypeDef, unknown>;
+/** @internal */
+export type UpdateProjectDataCacheRequestBody$Outbound = {
+    disabled?: boolean | undefined;
+};
+/** @internal */
+export declare const UpdateProjectDataCacheRequestBody$outboundSchema: z.ZodType<UpdateProjectDataCacheRequestBody$Outbound, z.ZodTypeDef, UpdateProjectDataCacheRequestBody>;
+/**
+ * @internal
+ * @deprecated This namespace will be removed in future versions. Use schemas and types that are exported directly from this module.
+ */
+export declare namespace UpdateProjectDataCacheRequestBody$ {
+    /** @deprecated use `UpdateProjectDataCacheRequestBody$inboundSchema` instead. */
+    const inboundSchema: z.ZodType<UpdateProjectDataCacheRequestBody, z.ZodTypeDef, unknown>;
+    /** @deprecated use `UpdateProjectDataCacheRequestBody$outboundSchema` instead. */
+    const outboundSchema: z.ZodType<UpdateProjectDataCacheRequestBody$Outbound, z.ZodTypeDef, UpdateProjectDataCacheRequestBody>;
+    /** @deprecated use `UpdateProjectDataCacheRequestBody$Outbound` instead. */
+    type Outbound = UpdateProjectDataCacheRequestBody$Outbound;
+}
+/** @internal */
+export declare const UpdateProjectDataCacheRequest$inboundSchema: z.ZodType<UpdateProjectDataCacheRequest, z.ZodTypeDef, unknown>;
+/** @internal */
+export type UpdateProjectDataCacheRequest$Outbound = {
+    projectId: string;
+    teamId?: string | undefined;
+    slug?: string | undefined;
+    RequestBody?: UpdateProjectDataCacheRequestBody$Outbound | undefined;
+};
+/** @internal */
+export declare const UpdateProjectDataCacheRequest$outboundSchema: z.ZodType<UpdateProjectDataCacheRequest$Outbound, z.ZodTypeDef, UpdateProjectDataCacheRequest>;
+/**
+ * @internal
+ * @deprecated This namespace will be removed in future versions. Use schemas and types that are exported directly from this module.
+ */
+export declare namespace UpdateProjectDataCacheRequest$ {
+    /** @deprecated use `UpdateProjectDataCacheRequest$inboundSchema` instead. */
+    const inboundSchema: z.ZodType<UpdateProjectDataCacheRequest, z.ZodTypeDef, unknown>;
+    /** @deprecated use `UpdateProjectDataCacheRequest$outboundSchema` instead. */
+    const outboundSchema: z.ZodType<UpdateProjectDataCacheRequest$Outbound, z.ZodTypeDef, UpdateProjectDataCacheRequest>;
+    /** @deprecated use `UpdateProjectDataCacheRequest$Outbound` instead. */
+    type Outbound = UpdateProjectDataCacheRequest$Outbound;
+}
+/** @internal */
+export declare const Analytics$inboundSchema: z.ZodType<Analytics, z.ZodTypeDef, unknown>;
+/** @internal */
+export type Analytics$Outbound = {
+    id: string;
+    canceledAt?: number | null | undefined;
+    disabledAt: number;
+    enabledAt: number;
+    paidAt?: number | undefined;
+    sampleRatePercent?: number | null | undefined;
+    spendLimitInDollars?: number | null | undefined;
+};
+/** @internal */
+export declare const Analytics$outboundSchema: z.ZodType<Analytics$Outbound, z.ZodTypeDef, Analytics>;
+/**
+ * @internal
+ * @deprecated This namespace will be removed in future versions. Use schemas and types that are exported directly from this module.
+ */
+export declare namespace Analytics$ {
+    /** @deprecated use `Analytics$inboundSchema` instead. */
+    const inboundSchema: z.ZodType<Analytics, z.ZodTypeDef, unknown>;
+    /** @deprecated use `Analytics$outboundSchema` instead. */
+    const outboundSchema: z.ZodType<Analytics$Outbound, z.ZodTypeDef, Analytics>;
+    /** @deprecated use `Analytics$Outbound` instead. */
+    type Outbound = Analytics$Outbound;
+}
+/** @internal */
+export declare const SpeedInsights$inboundSchema: z.ZodType<SpeedInsights, z.ZodTypeDef, unknown>;
+/** @internal */
+export type SpeedInsights$Outbound = {
+    id: string;
+    enabledAt?: number | undefined;
+    disabledAt?: number | undefined;
+    canceledAt?: number | undefined;
+    hasData?: boolean | undefined;
+    paidAt?: number | undefined;
+};
+/** @internal */
+export declare const SpeedInsights$outboundSchema: z.ZodType<SpeedInsights$Outbound, z.ZodTypeDef, SpeedInsights>;
+/**
+ * @internal
+ * @deprecated This namespace will be removed in future versions. Use schemas and types that are exported directly from this module.
+ */
+export declare namespace SpeedInsights$ {
+    /** @deprecated use `SpeedInsights$inboundSchema` instead. */
+    const inboundSchema: z.ZodType<SpeedInsights, z.ZodTypeDef, unknown>;
+    /** @deprecated use `SpeedInsights$outboundSchema` instead. */
+    const outboundSchema: z.ZodType<SpeedInsights$Outbound, z.ZodTypeDef, SpeedInsights>;
+    /** @deprecated use `SpeedInsights$Outbound` instead. */
+    type Outbound = SpeedInsights$Outbound;
+}
+/** @internal */
+export declare const Definitions$inboundSchema: z.ZodType<Definitions, z.ZodTypeDef, unknown>;
+/** @internal */
+export type Definitions$Outbound = {
+    host: string;
+    path: string;
+    schedule: string;
+};
+/** @internal */
+export declare const Definitions$outboundSchema: z.ZodType<Definitions$Outbound, z.ZodTypeDef, Definitions>;
+/**
+ * @internal
+ * @deprecated This namespace will be removed in future versions. Use schemas and types that are exported directly from this module.
+ */
+export declare namespace Definitions$ {
+    /** @deprecated use `Definitions$inboundSchema` instead. */
+    const inboundSchema: z.ZodType<Definitions, z.ZodTypeDef, unknown>;
+    /** @deprecated use `Definitions$outboundSchema` instead. */
+    const outboundSchema: z.ZodType<Definitions$Outbound, z.ZodTypeDef, Definitions>;
+    /** @deprecated use `Definitions$Outbound` instead. */
+    type Outbound = Definitions$Outbound;
+}
+/** @internal */
+export declare const Crons$inboundSchema: z.ZodType<Crons, z.ZodTypeDef, unknown>;
+/** @internal */
+export type Crons$Outbound = {
+    enabledAt: number;
+    disabledAt: number | null;
+    updatedAt: number;
+    deploymentId: string | null;
+    definitions: Array<Definitions$Outbound>;
+};
+/** @internal */
+export declare const Crons$outboundSchema: z.ZodType<Crons$Outbound, z.ZodTypeDef, Crons>;
+/**
+ * @internal
+ * @deprecated This namespace will be removed in future versions. Use schemas and types that are exported directly from this module.
+ */
+export declare namespace Crons$ {
+    /** @deprecated use `Crons$inboundSchema` instead. */
+    const inboundSchema: z.ZodType<Crons, z.ZodTypeDef, unknown>;
+    /** @deprecated use `Crons$outboundSchema` instead. */
+    const outboundSchema: z.ZodType<Crons$Outbound, z.ZodTypeDef, Crons>;
+    /** @deprecated use `Crons$Outbound` instead. */
+    type Outbound = Crons$Outbound;
+}
+/** @internal */
+export declare const DataCache$inboundSchema: z.ZodType<DataCache, z.ZodTypeDef, unknown>;
+/** @internal */
+export type DataCache$Outbound = {
+    userDisabled: boolean;
+    storageSizeBytes?: number | null | undefined;
+    unlimited?: boolean | undefined;
+};
+/** @internal */
+export declare const DataCache$outboundSchema: z.ZodType<DataCache$Outbound, z.ZodTypeDef, DataCache>;
+/**
+ * @internal
+ * @deprecated This namespace will be removed in future versions. Use schemas and types that are exported directly from this module.
+ */
+export declare namespace DataCache$ {
+    /** @deprecated use `DataCache$inboundSchema` instead. */
+    const inboundSchema: z.ZodType<DataCache, z.ZodTypeDef, unknown>;
+    /** @deprecated use `DataCache$outboundSchema` instead. */
+    const outboundSchema: z.ZodType<DataCache$Outbound, z.ZodTypeDef, DataCache>;
+    /** @deprecated use `DataCache$Outbound` instead. */
+    type Outbound = DataCache$Outbound;
+}
+/** @internal */
+export declare const DeploymentExpiration$inboundSchema: z.ZodType<DeploymentExpiration, z.ZodTypeDef, unknown>;
+/** @internal */
+export type DeploymentExpiration$Outbound = {
+    expirationDays?: number | undefined;
+    expirationDaysProduction?: number | undefined;
+    expirationDaysCanceled?: number | undefined;
+    expirationDaysErrored?: number | undefined;
+    deploymentsToKeep?: number | undefined;
+};
+/** @internal */
+export declare const DeploymentExpiration$outboundSchema: z.ZodType<DeploymentExpiration$Outbound, z.ZodTypeDef, DeploymentExpiration>;
+/**
+ * @internal
+ * @deprecated This namespace will be removed in future versions. Use schemas and types that are exported directly from this module.
+ */
+export declare namespace DeploymentExpiration$ {
+    /** @deprecated use `DeploymentExpiration$inboundSchema` instead. */
+    const inboundSchema: z.ZodType<DeploymentExpiration, z.ZodTypeDef, unknown>;
+    /** @deprecated use `DeploymentExpiration$outboundSchema` instead. */
+    const outboundSchema: z.ZodType<DeploymentExpiration$Outbound, z.ZodTypeDef, DeploymentExpiration>;
+    /** @deprecated use `DeploymentExpiration$Outbound` instead. */
+    type Outbound = DeploymentExpiration$Outbound;
+}
+/** @internal */
+export declare const UpdateProjectDataCacheTarget2$inboundSchema: z.ZodNativeEnum<typeof UpdateProjectDataCacheTarget2>;
+/** @internal */
+export declare const UpdateProjectDataCacheTarget2$outboundSchema: z.ZodNativeEnum<typeof UpdateProjectDataCacheTarget2>;
+/**
+ * @internal
+ * @deprecated This namespace will be removed in future versions. Use schemas and types that are exported directly from this module.
+ */
+export declare namespace UpdateProjectDataCacheTarget2$ {
+    /** @deprecated use `UpdateProjectDataCacheTarget2$inboundSchema` instead. */
+    const inboundSchema: z.ZodNativeEnum<{
+        readonly Production: "production";
+        readonly Preview: "preview";
+        readonly Development: "development";
+    }>;
+    /** @deprecated use `UpdateProjectDataCacheTarget2$outboundSchema` instead. */
+    const outboundSchema: z.ZodNativeEnum<{
+        readonly Production: "production";
+        readonly Preview: "preview";
+        readonly Development: "development";
+    }>;
+}
+/** @internal */
+export declare const UpdateProjectDataCacheTarget1$inboundSchema: z.ZodNativeEnum<typeof UpdateProjectDataCacheTarget1>;
+/** @internal */
+export declare const UpdateProjectDataCacheTarget1$outboundSchema: z.ZodNativeEnum<typeof UpdateProjectDataCacheTarget1>;
+/**
+ * @internal
+ * @deprecated This namespace will be removed in future versions. Use schemas and types that are exported directly from this module.
+ */
+export declare namespace UpdateProjectDataCacheTarget1$ {
+    /** @deprecated use `UpdateProjectDataCacheTarget1$inboundSchema` instead. */
+    const inboundSchema: z.ZodNativeEnum<{
+        readonly Production: "production";
+        readonly Preview: "preview";
+        readonly Development: "development";
+    }>;
+    /** @deprecated use `UpdateProjectDataCacheTarget1$outboundSchema` instead. */
+    const outboundSchema: z.ZodNativeEnum<{
+        readonly Production: "production";
+        readonly Preview: "preview";
+        readonly Development: "development";
+    }>;
+}
+/** @internal */
+export declare const UpdateProjectDataCacheTarget$inboundSchema: z.ZodType<UpdateProjectDataCacheTarget, z.ZodTypeDef, unknown>;
+/** @internal */
+export type UpdateProjectDataCacheTarget$Outbound = Array<string> | string;
+/** @internal */
+export declare const UpdateProjectDataCacheTarget$outboundSchema: z.ZodType<UpdateProjectDataCacheTarget$Outbound, z.ZodTypeDef, UpdateProjectDataCacheTarget>;
+/**
+ * @internal
+ * @deprecated This namespace will be removed in future versions. Use schemas and types that are exported directly from this module.
+ */
+export declare namespace UpdateProjectDataCacheTarget$ {
+    /** @deprecated use `UpdateProjectDataCacheTarget$inboundSchema` instead. */
+    const inboundSchema: z.ZodType<UpdateProjectDataCacheTarget, z.ZodTypeDef, unknown>;
+    /** @deprecated use `UpdateProjectDataCacheTarget$outboundSchema` instead. */
+    const outboundSchema: z.ZodType<UpdateProjectDataCacheTarget$Outbound, z.ZodTypeDef, UpdateProjectDataCacheTarget>;
+    /** @deprecated use `UpdateProjectDataCacheTarget$Outbound` instead. */
+    type Outbound = UpdateProjectDataCacheTarget$Outbound;
+}
+/** @internal */
+export declare const UpdateProjectDataCacheProjectsResponse200Type$inboundSchema: z.ZodNativeEnum<typeof UpdateProjectDataCacheProjectsResponse200Type>;
+/** @internal */
+export declare const UpdateProjectDataCacheProjectsResponse200Type$outboundSchema: z.ZodNativeEnum<typeof UpdateProjectDataCacheProjectsResponse200Type>;
+/**
+ * @internal
+ * @deprecated This namespace will be removed in future versions. Use schemas and types that are exported directly from this module.
+ */
+export declare namespace UpdateProjectDataCacheProjectsResponse200Type$ {
+    /** @deprecated use `UpdateProjectDataCacheProjectsResponse200Type$inboundSchema` instead. */
+    const inboundSchema: z.ZodNativeEnum<{
+        readonly Secret: "secret";
+        readonly System: "system";
+        readonly Encrypted: "encrypted";
+        readonly Plain: "plain";
+        readonly Sensitive: "sensitive";
+    }>;
+    /** @deprecated use `UpdateProjectDataCacheProjectsResponse200Type$outboundSchema` instead. */
+    const outboundSchema: z.ZodNativeEnum<{
+        readonly Secret: "secret";
+        readonly System: "system";
+        readonly Encrypted: "encrypted";
+        readonly Plain: "plain";
+        readonly Sensitive: "sensitive";
+    }>;
+}
+/** @internal */
+export declare const UpdateProjectDataCacheContentHintProjectsResponse200ApplicationJSONResponseBodyEnv15Type$inboundSchema: z.ZodNativeEnum<typeof UpdateProjectDataCacheContentHintProjectsResponse200ApplicationJSONResponseBodyEnv15Type>;
+/** @internal */
+export declare const UpdateProjectDataCacheContentHintProjectsResponse200ApplicationJSONResponseBodyEnv15Type$outboundSchema: z.ZodNativeEnum<typeof UpdateProjectDataCacheContentHintProjectsResponse200ApplicationJSONResponseBodyEnv15Type>;
+/**
+ * @internal
+ * @deprecated This namespace will be removed in future versions. Use schemas and types that are exported directly from this module.
+ */
+export declare namespace UpdateProjectDataCacheContentHintProjectsResponse200ApplicationJSONResponseBodyEnv15Type$ {
+    /** @deprecated use `UpdateProjectDataCacheContentHintProjectsResponse200ApplicationJSONResponseBodyEnv15Type$inboundSchema` instead. */
+    const inboundSchema: z.ZodNativeEnum<{
+        readonly FlagsConnectionString: "flags-connection-string";
+    }>;
+    /** @deprecated use `UpdateProjectDataCacheContentHintProjectsResponse200ApplicationJSONResponseBodyEnv15Type$outboundSchema` instead. */
+    const outboundSchema: z.ZodNativeEnum<{
+        readonly FlagsConnectionString: "flags-connection-string";
+    }>;
+}
+/** @internal */
+export declare const Fifteen$inboundSchema: z.ZodType<Fifteen, z.ZodTypeDef, unknown>;
+/** @internal */
+export type Fifteen$Outbound = {
+    type: string;
+    projectId: string;
+};
+/** @internal */
+export declare const Fifteen$outboundSchema: z.ZodType<Fifteen$Outbound, z.ZodTypeDef, Fifteen>;
+/**
+ * @internal
+ * @deprecated This namespace will be removed in future versions. Use schemas and types that are exported directly from this module.
+ */
+export declare namespace Fifteen$ {
+    /** @deprecated use `Fifteen$inboundSchema` instead. */
+    const inboundSchema: z.ZodType<Fifteen, z.ZodTypeDef, unknown>;
+    /** @deprecated use `Fifteen$outboundSchema` instead. */
+    const outboundSchema: z.ZodType<Fifteen$Outbound, z.ZodTypeDef, Fifteen>;
+    /** @deprecated use `Fifteen$Outbound` instead. */
+    type Outbound = Fifteen$Outbound;
+}
+/** @internal */
+export declare const UpdateProjectDataCacheContentHintProjectsResponse200ApplicationJSONResponseBodyEnv14Type$inboundSchema: z.ZodNativeEnum<typeof UpdateProjectDataCacheContentHintProjectsResponse200ApplicationJSONResponseBodyEnv14Type>;
+/** @internal */
+export declare const UpdateProjectDataCacheContentHintProjectsResponse200ApplicationJSONResponseBodyEnv14Type$outboundSchema: z.ZodNativeEnum<typeof UpdateProjectDataCacheContentHintProjectsResponse200ApplicationJSONResponseBodyEnv14Type>;
+/**
+ * @internal
+ * @deprecated This namespace will be removed in future versions. Use schemas and types that are exported directly from this module.
+ */
+export declare namespace UpdateProjectDataCacheContentHintProjectsResponse200ApplicationJSONResponseBodyEnv14Type$ {
+    /** @deprecated use `UpdateProjectDataCacheContentHintProjectsResponse200ApplicationJSONResponseBodyEnv14Type$inboundSchema` instead. */
+    const inboundSchema: z.ZodNativeEnum<{
+        readonly IntegrationStoreSecret: "integration-store-secret";
+    }>;
+    /** @deprecated use `UpdateProjectDataCacheContentHintProjectsResponse200ApplicationJSONResponseBodyEnv14Type$outboundSchema` instead. */
+    const outboundSchema: z.ZodNativeEnum<{
+        readonly IntegrationStoreSecret: "integration-store-secret";
+    }>;
+}
+/** @internal */
+export declare const Fourteen$inboundSchema: z.ZodType<Fourteen, z.ZodTypeDef, unknown>;
+/** @internal */
+export type Fourteen$Outbound = {
+    type: string;
+    storeId: string;
+    integrationId: string;
+    integrationProductId: string;
+    integrationConfigurationId: string;
+};
+/** @internal */
+export declare const Fourteen$outboundSchema: z.ZodType<Fourteen$Outbound, z.ZodTypeDef, Fourteen>;
+/**
+ * @internal
+ * @deprecated This namespace will be removed in future versions. Use schemas and types that are exported directly from this module.
+ */
+export declare namespace Fourteen$ {
+    /** @deprecated use `Fourteen$inboundSchema` instead. */
+    const inboundSchema: z.ZodType<Fourteen, z.ZodTypeDef, unknown>;
+    /** @deprecated use `Fourteen$outboundSchema` instead. */
+    const outboundSchema: z.ZodType<Fourteen$Outbound, z.ZodTypeDef, Fourteen>;
+    /** @deprecated use `Fourteen$Outbound` instead. */
+    type Outbound = Fourteen$Outbound;
+}
+/** @internal */
+export declare const UpdateProjectDataCacheContentHintProjectsResponse200ApplicationJSONResponseBodyEnv13Type$inboundSchema: z.ZodNativeEnum<typeof UpdateProjectDataCacheContentHintProjectsResponse200ApplicationJSONResponseBodyEnv13Type>;
+/** @internal */
+export declare const UpdateProjectDataCacheContentHintProjectsResponse200ApplicationJSONResponseBodyEnv13Type$outboundSchema: z.ZodNativeEnum<typeof UpdateProjectDataCacheContentHintProjectsResponse200ApplicationJSONResponseBodyEnv13Type>;
+/**
+ * @internal
+ * @deprecated This namespace will be removed in future versions. Use schemas and types that are exported directly from this module.
+ */
+export declare namespace UpdateProjectDataCacheContentHintProjectsResponse200ApplicationJSONResponseBodyEnv13Type$ {
+    /** @deprecated use `UpdateProjectDataCacheContentHintProjectsResponse200ApplicationJSONResponseBodyEnv13Type$inboundSchema` instead. */
+    const inboundSchema: z.ZodNativeEnum<{
+        readonly PostgresUrlNoSsl: "postgres-url-no-ssl";
+    }>;
+    /** @deprecated use `UpdateProjectDataCacheContentHintProjectsResponse200ApplicationJSONResponseBodyEnv13Type$outboundSchema` instead. */
+    const outboundSchema: z.ZodNativeEnum<{
+        readonly PostgresUrlNoSsl: "postgres-url-no-ssl";
+    }>;
+}
+/** @internal */
+export declare const Thirteen$inboundSchema: z.ZodType<Thirteen, z.ZodTypeDef, unknown>;
+/** @internal */
+export type Thirteen$Outbound = {
+    type: string;
+    storeId: string;
+};
+/** @internal */
+export declare const Thirteen$outboundSchema: z.ZodType<Thirteen$Outbound, z.ZodTypeDef, Thirteen>;
+/**
+ * @internal
+ * @deprecated This namespace will be removed in future versions. Use schemas and types that are exported directly from this module.
+ */
+export declare namespace Thirteen$ {
+    /** @deprecated use `Thirteen$inboundSchema` instead. */
+    const inboundSchema: z.ZodType<Thirteen, z.ZodTypeDef, unknown>;
+    /** @deprecated use `Thirteen$outboundSchema` instead. */
+    const outboundSchema: z.ZodType<Thirteen$Outbound, z.ZodTypeDef, Thirteen>;
+    /** @deprecated use `Thirteen$Outbound` instead. */
+    type Outbound = Thirteen$Outbound;
+}
+/** @internal */
+export declare const UpdateProjectDataCacheContentHintProjectsResponse200ApplicationJSONResponseBodyEnv12Type$inboundSchema: z.ZodNativeEnum<typeof UpdateProjectDataCacheContentHintProjectsResponse200ApplicationJSONResponseBodyEnv12Type>;
+/** @internal */
+export declare const UpdateProjectDataCacheContentHintProjectsResponse200ApplicationJSONResponseBodyEnv12Type$outboundSchema: z.ZodNativeEnum<typeof UpdateProjectDataCacheContentHintProjectsResponse200ApplicationJSONResponseBodyEnv12Type>;
+/**
+ * @internal
+ * @deprecated This namespace will be removed in future versions. Use schemas and types that are exported directly from this module.
+ */
+export declare namespace UpdateProjectDataCacheContentHintProjectsResponse200ApplicationJSONResponseBodyEnv12Type$ {
+    /** @deprecated use `UpdateProjectDataCacheContentHintProjectsResponse200ApplicationJSONResponseBodyEnv12Type$inboundSchema` instead. */
+    const inboundSchema: z.ZodNativeEnum<{
+        readonly PostgresDatabase: "postgres-database";
+    }>;
+    /** @deprecated use `UpdateProjectDataCacheContentHintProjectsResponse200ApplicationJSONResponseBodyEnv12Type$outboundSchema` instead. */
+    const outboundSchema: z.ZodNativeEnum<{
+        readonly PostgresDatabase: "postgres-database";
+    }>;
+}
+/** @internal */
+export declare const Twelve$inboundSchema: z.ZodType<Twelve, z.ZodTypeDef, unknown>;
+/** @internal */
+export type Twelve$Outbound = {
+    type: string;
+    storeId: string;
+};
+/** @internal */
+export declare const Twelve$outboundSchema: z.ZodType<Twelve$Outbound, z.ZodTypeDef, Twelve>;
+/**
+ * @internal
+ * @deprecated This namespace will be removed in future versions. Use schemas and types that are exported directly from this module.
+ */
+export declare namespace Twelve$ {
+    /** @deprecated use `Twelve$inboundSchema` instead. */
+    const inboundSchema: z.ZodType<Twelve, z.ZodTypeDef, unknown>;
+    /** @deprecated use `Twelve$outboundSchema` instead. */
+    const outboundSchema: z.ZodType<Twelve$Outbound, z.ZodTypeDef, Twelve>;
+    /** @deprecated use `Twelve$Outbound` instead. */
+    type Outbound = Twelve$Outbound;
+}
+/** @internal */
+export declare const UpdateProjectDataCacheContentHintProjectsResponse200ApplicationJSONResponseBodyEnv11Type$inboundSchema: z.ZodNativeEnum<typeof UpdateProjectDataCacheContentHintProjectsResponse200ApplicationJSONResponseBodyEnv11Type>;
+/** @internal */
+export declare const UpdateProjectDataCacheContentHintProjectsResponse200ApplicationJSONResponseBodyEnv11Type$outboundSchema: z.ZodNativeEnum<typeof UpdateProjectDataCacheContentHintProjectsResponse200ApplicationJSONResponseBodyEnv11Type>;
+/**
+ * @internal
+ * @deprecated This namespace will be removed in future versions. Use schemas and types that are exported directly from this module.
+ */
+export declare namespace UpdateProjectDataCacheContentHintProjectsResponse200ApplicationJSONResponseBodyEnv11Type$ {
+    /** @deprecated use `UpdateProjectDataCacheContentHintProjectsResponse200ApplicationJSONResponseBodyEnv11Type$inboundSchema` instead. */
+    const inboundSchema: z.ZodNativeEnum<{
+        readonly PostgresPassword: "postgres-password";
+    }>;
+    /** @deprecated use `UpdateProjectDataCacheContentHintProjectsResponse200ApplicationJSONResponseBodyEnv11Type$outboundSchema` instead. */
+    const outboundSchema: z.ZodNativeEnum<{
+        readonly PostgresPassword: "postgres-password";
+    }>;
+}
+/** @internal */
+export declare const UpdateProjectDataCacheContentHint11$inboundSchema: z.ZodType<UpdateProjectDataCacheContentHint11, z.ZodTypeDef, unknown>;
+/** @internal */
+export type UpdateProjectDataCacheContentHint11$Outbound = {
+    type: string;
+    storeId: string;
+};
+/** @internal */
+export declare const UpdateProjectDataCacheContentHint11$outboundSchema: z.ZodType<UpdateProjectDataCacheContentHint11$Outbound, z.ZodTypeDef, UpdateProjectDataCacheContentHint11>;
+/**
+ * @internal
+ * @deprecated This namespace will be removed in future versions. Use schemas and types that are exported directly from this module.
+ */
+export declare namespace UpdateProjectDataCacheContentHint11$ {
+    /** @deprecated use `UpdateProjectDataCacheContentHint11$inboundSchema` instead. */
+    const inboundSchema: z.ZodType<UpdateProjectDataCacheContentHint11, z.ZodTypeDef, unknown>;
+    /** @deprecated use `UpdateProjectDataCacheContentHint11$outboundSchema` instead. */
+    const outboundSchema: z.ZodType<UpdateProjectDataCacheContentHint11$Outbound, z.ZodTypeDef, UpdateProjectDataCacheContentHint11>;
+    /** @deprecated use `UpdateProjectDataCacheContentHint11$Outbound` instead. */
+    type Outbound = UpdateProjectDataCacheContentHint11$Outbound;
+}
+/** @internal */
+export declare const UpdateProjectDataCacheContentHintProjectsResponse200ApplicationJSONResponseBodyEnv10Type$inboundSchema: z.ZodNativeEnum<typeof UpdateProjectDataCacheContentHintProjectsResponse200ApplicationJSONResponseBodyEnv10Type>;
+/** @internal */
+export declare const UpdateProjectDataCacheContentHintProjectsResponse200ApplicationJSONResponseBodyEnv10Type$outboundSchema: z.ZodNativeEnum<typeof UpdateProjectDataCacheContentHintProjectsResponse200ApplicationJSONResponseBodyEnv10Type>;
+/**
+ * @internal
+ * @deprecated This namespace will be removed in future versions. Use schemas and types that are exported directly from this module.
+ */
+export declare namespace UpdateProjectDataCacheContentHintProjectsResponse200ApplicationJSONResponseBodyEnv10Type$ {
+    /** @deprecated use `UpdateProjectDataCacheContentHintProjectsResponse200ApplicationJSONResponseBodyEnv10Type$inboundSchema` instead. */
+    const inboundSchema: z.ZodNativeEnum<{
+        readonly PostgresHost: "postgres-host";
+    }>;
+    /** @deprecated use `UpdateProjectDataCacheContentHintProjectsResponse200ApplicationJSONResponseBodyEnv10Type$outboundSchema` instead. */
+    const outboundSchema: z.ZodNativeEnum<{
+        readonly PostgresHost: "postgres-host";
+    }>;
+}
+/** @internal */
+export declare const ContentHint10$inboundSchema: z.ZodType<ContentHint10, z.ZodTypeDef, unknown>;
+/** @internal */
+export type ContentHint10$Outbound = {
+    type: string;
+    storeId: string;
+};
+/** @internal */
+export declare const ContentHint10$outboundSchema: z.ZodType<ContentHint10$Outbound, z.ZodTypeDef, ContentHint10>;
+/**
+ * @internal
+ * @deprecated This namespace will be removed in future versions. Use schemas and types that are exported directly from this module.
+ */
+export declare namespace ContentHint10$ {
+    /** @deprecated use `ContentHint10$inboundSchema` instead. */
+    const inboundSchema: z.ZodType<ContentHint10, z.ZodTypeDef, unknown>;
+    /** @deprecated use `ContentHint10$outboundSchema` instead. */
+    const outboundSchema: z.ZodType<ContentHint10$Outbound, z.ZodTypeDef, ContentHint10>;
+    /** @deprecated use `ContentHint10$Outbound` instead. */
+    type Outbound = ContentHint10$Outbound;
+}
+/** @internal */
+export declare const UpdateProjectDataCacheContentHintProjectsResponse200ApplicationJSONResponseBodyEnv9Type$inboundSchema: z.ZodNativeEnum<typeof UpdateProjectDataCacheContentHintProjectsResponse200ApplicationJSONResponseBodyEnv9Type>;
+/** @internal */
+export declare const UpdateProjectDataCacheContentHintProjectsResponse200ApplicationJSONResponseBodyEnv9Type$outboundSchema: z.ZodNativeEnum<typeof UpdateProjectDataCacheContentHintProjectsResponse200ApplicationJSONResponseBodyEnv9Type>;
+/**
+ * @internal
+ * @deprecated This namespace will be removed in future versions. Use schemas and types that are exported directly from this module.
+ */
+export declare namespace UpdateProjectDataCacheContentHintProjectsResponse200ApplicationJSONResponseBodyEnv9Type$ {
+    /** @deprecated use `UpdateProjectDataCacheContentHintProjectsResponse200ApplicationJSONResponseBodyEnv9Type$inboundSchema` instead. */
+    const inboundSchema: z.ZodNativeEnum<{
+        readonly PostgresUser: "postgres-user";
+    }>;
+    /** @deprecated use `UpdateProjectDataCacheContentHintProjectsResponse200ApplicationJSONResponseBodyEnv9Type$outboundSchema` instead. */
+    const outboundSchema: z.ZodNativeEnum<{
+        readonly PostgresUser: "postgres-user";
+    }>;
+}
+/** @internal */
+export declare const ContentHint9$inboundSchema: z.ZodType<ContentHint9, z.ZodTypeDef, unknown>;
+/** @internal */
+export type ContentHint9$Outbound = {
+    type: string;
+    storeId: string;
+};
+/** @internal */
+export declare const ContentHint9$outboundSchema: z.ZodType<ContentHint9$Outbound, z.ZodTypeDef, ContentHint9>;
+/**
+ * @internal
+ * @deprecated This namespace will be removed in future versions. Use schemas and types that are exported directly from this module.
+ */
+export declare namespace ContentHint9$ {
+    /** @deprecated use `ContentHint9$inboundSchema` instead. */
+    const inboundSchema: z.ZodType<ContentHint9, z.ZodTypeDef, unknown>;
+    /** @deprecated use `ContentHint9$outboundSchema` instead. */
+    const outboundSchema: z.ZodType<ContentHint9$Outbound, z.ZodTypeDef, ContentHint9>;
+    /** @deprecated use `ContentHint9$Outbound` instead. */
+    type Outbound = ContentHint9$Outbound;
+}
+/** @internal */
+export declare const UpdateProjectDataCacheContentHintProjectsResponse200ApplicationJSONResponseBodyEnvType$inboundSchema: z.ZodNativeEnum<typeof UpdateProjectDataCacheContentHintProjectsResponse200ApplicationJSONResponseBodyEnvType>;
+/** @internal */
+export declare const UpdateProjectDataCacheContentHintProjectsResponse200ApplicationJSONResponseBodyEnvType$outboundSchema: z.ZodNativeEnum<typeof UpdateProjectDataCacheContentHintProjectsResponse200ApplicationJSONResponseBodyEnvType>;
+/**
+ * @internal
+ * @deprecated This namespace will be removed in future versions. Use schemas and types that are exported directly from this module.
+ */
+export declare namespace UpdateProjectDataCacheContentHintProjectsResponse200ApplicationJSONResponseBodyEnvType$ {
+    /** @deprecated use `UpdateProjectDataCacheContentHintProjectsResponse200ApplicationJSONResponseBodyEnvType$inboundSchema` instead. */
+    const inboundSchema: z.ZodNativeEnum<{
+        readonly PostgresPrismaUrl: "postgres-prisma-url";
+    }>;
+    /** @deprecated use `UpdateProjectDataCacheContentHintProjectsResponse200ApplicationJSONResponseBodyEnvType$outboundSchema` instead. */
+    const outboundSchema: z.ZodNativeEnum<{
+        readonly PostgresPrismaUrl: "postgres-prisma-url";
+    }>;
+}
+/** @internal */
+export declare const ContentHint8$inboundSchema: z.ZodType<ContentHint8, z.ZodTypeDef, unknown>;
+/** @internal */
+export type ContentHint8$Outbound = {
+    type: string;
+    storeId: string;
+};
+/** @internal */
+export declare const ContentHint8$outboundSchema: z.ZodType<ContentHint8$Outbound, z.ZodTypeDef, ContentHint8>;
+/**
+ * @internal
+ * @deprecated This namespace will be removed in future versions. Use schemas and types that are exported directly from this module.
+ */
+export declare namespace ContentHint8$ {
+    /** @deprecated use `ContentHint8$inboundSchema` instead. */
+    const inboundSchema: z.ZodType<ContentHint8, z.ZodTypeDef, unknown>;
+    /** @deprecated use `ContentHint8$outboundSchema` instead. */
+    const outboundSchema: z.ZodType<ContentHint8$Outbound, z.ZodTypeDef, ContentHint8>;
+    /** @deprecated use `ContentHint8$Outbound` instead. */
+    type Outbound = ContentHint8$Outbound;
+}
+/** @internal */
+export declare const UpdateProjectDataCacheContentHintProjectsResponse200ApplicationJSONResponseBodyType$inboundSchema: z.ZodNativeEnum<typeof UpdateProjectDataCacheContentHintProjectsResponse200ApplicationJSONResponseBodyType>;
+/** @internal */
+export declare const UpdateProjectDataCacheContentHintProjectsResponse200ApplicationJSONResponseBodyType$outboundSchema: z.ZodNativeEnum<typeof UpdateProjectDataCacheContentHintProjectsResponse200ApplicationJSONResponseBodyType>;
+/**
+ * @internal
+ * @deprecated This namespace will be removed in future versions. Use schemas and types that are exported directly from this module.
+ */
+export declare namespace UpdateProjectDataCacheContentHintProjectsResponse200ApplicationJSONResponseBodyType$ {
+    /** @deprecated use `UpdateProjectDataCacheContentHintProjectsResponse200ApplicationJSONResponseBodyType$inboundSchema` instead. */
+    const inboundSchema: z.ZodNativeEnum<{
+        readonly PostgresUrlNonPooling: "postgres-url-non-pooling";
+    }>;
+    /** @deprecated use `UpdateProjectDataCacheContentHintProjectsResponse200ApplicationJSONResponseBodyType$outboundSchema` instead. */
+    const outboundSchema: z.ZodNativeEnum<{
+        readonly PostgresUrlNonPooling: "postgres-url-non-pooling";
+    }>;
+}
+/** @internal */
+export declare const ContentHint7$inboundSchema: z.ZodType<ContentHint7, z.ZodTypeDef, unknown>;
+/** @internal */
+export type ContentHint7$Outbound = {
+    type: string;
+    storeId: string;
+};
+/** @internal */
+export declare const ContentHint7$outboundSchema: z.ZodType<ContentHint7$Outbound, z.ZodTypeDef, ContentHint7>;
+/**
+ * @internal
+ * @deprecated This namespace will be removed in future versions. Use schemas and types that are exported directly from this module.
+ */
+export declare namespace ContentHint7$ {
+    /** @deprecated use `ContentHint7$inboundSchema` instead. */
+    const inboundSchema: z.ZodType<ContentHint7, z.ZodTypeDef, unknown>;
+    /** @deprecated use `ContentHint7$outboundSchema` instead. */
+    const outboundSchema: z.ZodType<ContentHint7$Outbound, z.ZodTypeDef, ContentHint7>;
+    /** @deprecated use `ContentHint7$Outbound` instead. */
+    type Outbound = ContentHint7$Outbound;
+}
+/** @internal */
+export declare const UpdateProjectDataCacheContentHintProjectsResponse200ApplicationJSONType$inboundSchema: z.ZodNativeEnum<typeof UpdateProjectDataCacheContentHintProjectsResponse200ApplicationJSONType>;
+/** @internal */
+export declare const UpdateProjectDataCacheContentHintProjectsResponse200ApplicationJSONType$outboundSchema: z.ZodNativeEnum<typeof UpdateProjectDataCacheContentHintProjectsResponse200ApplicationJSONType>;
+/**
+ * @internal
+ * @deprecated This namespace will be removed in future versions. Use schemas and types that are exported directly from this module.
+ */
+export declare namespace UpdateProjectDataCacheContentHintProjectsResponse200ApplicationJSONType$ {
+    /** @deprecated use `UpdateProjectDataCacheContentHintProjectsResponse200ApplicationJSONType$inboundSchema` instead. */
+    const inboundSchema: z.ZodNativeEnum<{
+        readonly PostgresUrl: "postgres-url";
+    }>;
+    /** @deprecated use `UpdateProjectDataCacheContentHintProjectsResponse200ApplicationJSONType$outboundSchema` instead. */
+    const outboundSchema: z.ZodNativeEnum<{
+        readonly PostgresUrl: "postgres-url";
+    }>;
+}
+/** @internal */
+export declare const ContentHint6$inboundSchema: z.ZodType<ContentHint6, z.ZodTypeDef, unknown>;
+/** @internal */
+export type ContentHint6$Outbound = {
+    type: string;
+    storeId: string;
+};
+/** @internal */
+export declare const ContentHint6$outboundSchema: z.ZodType<ContentHint6$Outbound, z.ZodTypeDef, ContentHint6>;
+/**
+ * @internal
+ * @deprecated This namespace will be removed in future versions. Use schemas and types that are exported directly from this module.
+ */
+export declare namespace ContentHint6$ {
+    /** @deprecated use `ContentHint6$inboundSchema` instead. */
+    const inboundSchema: z.ZodType<ContentHint6, z.ZodTypeDef, unknown>;
+    /** @deprecated use `ContentHint6$outboundSchema` instead. */
+    const outboundSchema: z.ZodType<ContentHint6$Outbound, z.ZodTypeDef, ContentHint6>;
+    /** @deprecated use `ContentHint6$Outbound` instead. */
+    type Outbound = ContentHint6$Outbound;
+}
+/** @internal */
+export declare const UpdateProjectDataCacheContentHintProjectsResponse200Type$inboundSchema: z.ZodNativeEnum<typeof UpdateProjectDataCacheContentHintProjectsResponse200Type>;
+/** @internal */
+export declare const UpdateProjectDataCacheContentHintProjectsResponse200Type$outboundSchema: z.ZodNativeEnum<typeof UpdateProjectDataCacheContentHintProjectsResponse200Type>;
+/**
+ * @internal
+ * @deprecated This namespace will be removed in future versions. Use schemas and types that are exported directly from this module.
+ */
+export declare namespace UpdateProjectDataCacheContentHintProjectsResponse200Type$ {
+    /** @deprecated use `UpdateProjectDataCacheContentHintProjectsResponse200Type$inboundSchema` instead. */
+    const inboundSchema: z.ZodNativeEnum<{
+        readonly BlobReadWriteToken: "blob-read-write-token";
+    }>;
+    /** @deprecated use `UpdateProjectDataCacheContentHintProjectsResponse200Type$outboundSchema` instead. */
+    const outboundSchema: z.ZodNativeEnum<{
+        readonly BlobReadWriteToken: "blob-read-write-token";
+    }>;
+}
+/** @internal */
+export declare const ContentHint5$inboundSchema: z.ZodType<ContentHint5, z.ZodTypeDef, unknown>;
+/** @internal */
+export type ContentHint5$Outbound = {
+    type: string;
+    storeId: string;
+};
+/** @internal */
+export declare const ContentHint5$outboundSchema: z.ZodType<ContentHint5$Outbound, z.ZodTypeDef, ContentHint5>;
+/**
+ * @internal
+ * @deprecated This namespace will be removed in future versions. Use schemas and types that are exported directly from this module.
+ */
+export declare namespace ContentHint5$ {
+    /** @deprecated use `ContentHint5$inboundSchema` instead. */
+    const inboundSchema: z.ZodType<ContentHint5, z.ZodTypeDef, unknown>;
+    /** @deprecated use `ContentHint5$outboundSchema` instead. */
+    const outboundSchema: z.ZodType<ContentHint5$Outbound, z.ZodTypeDef, ContentHint5>;
+    /** @deprecated use `ContentHint5$Outbound` instead. */
+    type Outbound = ContentHint5$Outbound;
+}
+/** @internal */
+export declare const UpdateProjectDataCacheContentHintProjectsResponseType$inboundSchema: z.ZodNativeEnum<typeof UpdateProjectDataCacheContentHintProjectsResponseType>;
+/** @internal */
+export declare const UpdateProjectDataCacheContentHintProjectsResponseType$outboundSchema: z.ZodNativeEnum<typeof UpdateProjectDataCacheContentHintProjectsResponseType>;
+/**
+ * @internal
+ * @deprecated This namespace will be removed in future versions. Use schemas and types that are exported directly from this module.
+ */
+export declare namespace UpdateProjectDataCacheContentHintProjectsResponseType$ {
+    /** @deprecated use `UpdateProjectDataCacheContentHintProjectsResponseType$inboundSchema` instead. */
+    const inboundSchema: z.ZodNativeEnum<{
+        readonly RedisRestApiReadOnlyToken: "redis-rest-api-read-only-token";
+    }>;
+    /** @deprecated use `UpdateProjectDataCacheContentHintProjectsResponseType$outboundSchema` instead. */
+    const outboundSchema: z.ZodNativeEnum<{
+        readonly RedisRestApiReadOnlyToken: "redis-rest-api-read-only-token";
+    }>;
+}
+/** @internal */
+export declare const ContentHint4$inboundSchema: z.ZodType<ContentHint4, z.ZodTypeDef, unknown>;
+/** @internal */
+export type ContentHint4$Outbound = {
+    type: string;
+    storeId: string;
+};
+/** @internal */
+export declare const ContentHint4$outboundSchema: z.ZodType<ContentHint4$Outbound, z.ZodTypeDef, ContentHint4>;
+/**
+ * @internal
+ * @deprecated This namespace will be removed in future versions. Use schemas and types that are exported directly from this module.
+ */
+export declare namespace ContentHint4$ {
+    /** @deprecated use `ContentHint4$inboundSchema` instead. */
+    const inboundSchema: z.ZodType<ContentHint4, z.ZodTypeDef, unknown>;
+    /** @deprecated use `ContentHint4$outboundSchema` instead. */
+    const outboundSchema: z.ZodType<ContentHint4$Outbound, z.ZodTypeDef, ContentHint4>;
+    /** @deprecated use `ContentHint4$Outbound` instead. */
+    type Outbound = ContentHint4$Outbound;
+}
+/** @internal */
+export declare const UpdateProjectDataCacheContentHintProjectsType$inboundSchema: z.ZodNativeEnum<typeof UpdateProjectDataCacheContentHintProjectsType>;
+/** @internal */
+export declare const UpdateProjectDataCacheContentHintProjectsType$outboundSchema: z.ZodNativeEnum<typeof UpdateProjectDataCacheContentHintProjectsType>;
+/**
+ * @internal
+ * @deprecated This namespace will be removed in future versions. Use schemas and types that are exported directly from this module.
+ */
+export declare namespace UpdateProjectDataCacheContentHintProjectsType$ {
+    /** @deprecated use `UpdateProjectDataCacheContentHintProjectsType$inboundSchema` instead. */
+    const inboundSchema: z.ZodNativeEnum<{
+        readonly RedisRestApiToken: "redis-rest-api-token";
+    }>;
+    /** @deprecated use `UpdateProjectDataCacheContentHintProjectsType$outboundSchema` instead. */
+    const outboundSchema: z.ZodNativeEnum<{
+        readonly RedisRestApiToken: "redis-rest-api-token";
+    }>;
+}
+/** @internal */
+export declare const ContentHint3$inboundSchema: z.ZodType<ContentHint3, z.ZodTypeDef, unknown>;
+/** @internal */
+export type ContentHint3$Outbound = {
+    type: string;
+    storeId: string;
+};
+/** @internal */
+export declare const ContentHint3$outboundSchema: z.ZodType<ContentHint3$Outbound, z.ZodTypeDef, ContentHint3>;
+/**
+ * @internal
+ * @deprecated This namespace will be removed in future versions. Use schemas and types that are exported directly from this module.
+ */
+export declare namespace ContentHint3$ {
+    /** @deprecated use `ContentHint3$inboundSchema` instead. */
+    const inboundSchema: z.ZodType<ContentHint3, z.ZodTypeDef, unknown>;
+    /** @deprecated use `ContentHint3$outboundSchema` instead. */
+    const outboundSchema: z.ZodType<ContentHint3$Outbound, z.ZodTypeDef, ContentHint3>;
+    /** @deprecated use `ContentHint3$Outbound` instead. */
+    type Outbound = ContentHint3$Outbound;
+}
+/** @internal */
+export declare const UpdateProjectDataCacheContentHintType$inboundSchema: z.ZodNativeEnum<typeof UpdateProjectDataCacheContentHintType>;
+/** @internal */
+export declare const UpdateProjectDataCacheContentHintType$outboundSchema: z.ZodNativeEnum<typeof UpdateProjectDataCacheContentHintType>;
+/**
+ * @internal
+ * @deprecated This namespace will be removed in future versions. Use schemas and types that are exported directly from this module.
+ */
+export declare namespace UpdateProjectDataCacheContentHintType$ {
+    /** @deprecated use `UpdateProjectDataCacheContentHintType$inboundSchema` instead. */
+    const inboundSchema: z.ZodNativeEnum<{
+        readonly RedisRestApiUrl: "redis-rest-api-url";
+    }>;
+    /** @deprecated use `UpdateProjectDataCacheContentHintType$outboundSchema` instead. */
+    const outboundSchema: z.ZodNativeEnum<{
+        readonly RedisRestApiUrl: "redis-rest-api-url";
+    }>;
+}
+/** @internal */
+export declare const ContentHint2$inboundSchema: z.ZodType<ContentHint2, z.ZodTypeDef, unknown>;
+/** @internal */
+export type ContentHint2$Outbound = {
+    type: string;
+    storeId: string;
+};
+/** @internal */
+export declare const ContentHint2$outboundSchema: z.ZodType<ContentHint2$Outbound, z.ZodTypeDef, ContentHint2>;
+/**
+ * @internal
+ * @deprecated This namespace will be removed in future versions. Use schemas and types that are exported directly from this module.
+ */
+export declare namespace ContentHint2$ {
+    /** @deprecated use `ContentHint2$inboundSchema` instead. */
+    const inboundSchema: z.ZodType<ContentHint2, z.ZodTypeDef, unknown>;
+    /** @deprecated use `ContentHint2$outboundSchema` instead. */
+    const outboundSchema: z.ZodType<ContentHint2$Outbound, z.ZodTypeDef, ContentHint2>;
+    /** @deprecated use `ContentHint2$Outbound` instead. */
+    type Outbound = ContentHint2$Outbound;
+}
+/** @internal */
+export declare const ContentHintType$inboundSchema: z.ZodNativeEnum<typeof ContentHintType>;
+/** @internal */
+export declare const ContentHintType$outboundSchema: z.ZodNativeEnum<typeof ContentHintType>;
+/**
+ * @internal
+ * @deprecated This namespace will be removed in future versions. Use schemas and types that are exported directly from this module.
+ */
+export declare namespace ContentHintType$ {
+    /** @deprecated use `ContentHintType$inboundSchema` instead. */
+    const inboundSchema: z.ZodNativeEnum<{
+        readonly RedisUrl: "redis-url";
+    }>;
+    /** @deprecated use `ContentHintType$outboundSchema` instead. */
+    const outboundSchema: z.ZodNativeEnum<{
+        readonly RedisUrl: "redis-url";
+    }>;
+}
+/** @internal */
+export declare const ContentHint1$inboundSchema: z.ZodType<ContentHint1, z.ZodTypeDef, unknown>;
+/** @internal */
+export type ContentHint1$Outbound = {
+    type: string;
+    storeId: string;
+};
+/** @internal */
+export declare const ContentHint1$outboundSchema: z.ZodType<ContentHint1$Outbound, z.ZodTypeDef, ContentHint1>;
+/**
+ * @internal
+ * @deprecated This namespace will be removed in future versions. Use schemas and types that are exported directly from this module.
+ */
+export declare namespace ContentHint1$ {
+    /** @deprecated use `ContentHint1$inboundSchema` instead. */
+    const inboundSchema: z.ZodType<ContentHint1, z.ZodTypeDef, unknown>;
+    /** @deprecated use `ContentHint1$outboundSchema` instead. */
+    const outboundSchema: z.ZodType<ContentHint1$Outbound, z.ZodTypeDef, ContentHint1>;
+    /** @deprecated use `ContentHint1$Outbound` instead. */
+    type Outbound = ContentHint1$Outbound;
+}
+/** @internal */
+export declare const ContentHint$inboundSchema: z.ZodType<ContentHint, z.ZodTypeDef, unknown>;
+/** @internal */
+export type ContentHint$Outbound = ContentHint1$Outbound | ContentHint2$Outbound | ContentHint3$Outbound | ContentHint4$Outbound | ContentHint5$Outbound | ContentHint6$Outbound | ContentHint7$Outbound | ContentHint8$Outbound | ContentHint9$Outbound | ContentHint10$Outbound | UpdateProjectDataCacheContentHint11$Outbound | Twelve$Outbound | Thirteen$Outbound | Fifteen$Outbound | Fourteen$Outbound;
+/** @internal */
+export declare const ContentHint$outboundSchema: z.ZodType<ContentHint$Outbound, z.ZodTypeDef, ContentHint>;
+/**
+ * @internal
+ * @deprecated This namespace will be removed in future versions. Use schemas and types that are exported directly from this module.
+ */
+export declare namespace ContentHint$ {
+    /** @deprecated use `ContentHint$inboundSchema` instead. */
+    const inboundSchema: z.ZodType<ContentHint, z.ZodTypeDef, unknown>;
+    /** @deprecated use `ContentHint$outboundSchema` instead. */
+    const outboundSchema: z.ZodType<ContentHint$Outbound, z.ZodTypeDef, ContentHint>;
+    /** @deprecated use `ContentHint$Outbound` instead. */
+    type Outbound = ContentHint$Outbound;
+}
+/** @internal */
+export declare const UpdateProjectDataCacheProjectsResponse200ApplicationJSONResponseBodyType$inboundSchema: z.ZodNativeEnum<typeof UpdateProjectDataCacheProjectsResponse200ApplicationJSONResponseBodyType>;
+/** @internal */
+export declare const UpdateProjectDataCacheProjectsResponse200ApplicationJSONResponseBodyType$outboundSchema: z.ZodNativeEnum<typeof UpdateProjectDataCacheProjectsResponse200ApplicationJSONResponseBodyType>;
+/**
+ * @internal
+ * @deprecated This namespace will be removed in future versions. Use schemas and types that are exported directly from this module.
+ */
+export declare namespace UpdateProjectDataCacheProjectsResponse200ApplicationJSONResponseBodyType$ {
+    /** @deprecated use `UpdateProjectDataCacheProjectsResponse200ApplicationJSONResponseBodyType$inboundSchema` instead. */
+    const inboundSchema: z.ZodNativeEnum<{
+        readonly FlagsSecret: "flags-secret";
+    }>;
+    /** @deprecated use `UpdateProjectDataCacheProjectsResponse200ApplicationJSONResponseBodyType$outboundSchema` instead. */
+    const outboundSchema: z.ZodNativeEnum<{
+        readonly FlagsSecret: "flags-secret";
+    }>;
+}
+/** @internal */
+export declare const InternalContentHint$inboundSchema: z.ZodType<InternalContentHint, z.ZodTypeDef, unknown>;
+/** @internal */
+export type InternalContentHint$Outbound = {
+    type: string;
+    encryptedValue: string;
+};
+/** @internal */
+export declare const InternalContentHint$outboundSchema: z.ZodType<InternalContentHint$Outbound, z.ZodTypeDef, InternalContentHint>;
+/**
+ * @internal
+ * @deprecated This namespace will be removed in future versions. Use schemas and types that are exported directly from this module.
+ */
+export declare namespace InternalContentHint$ {
+    /** @deprecated use `InternalContentHint$inboundSchema` instead. */
+    const inboundSchema: z.ZodType<InternalContentHint, z.ZodTypeDef, unknown>;
+    /** @deprecated use `InternalContentHint$outboundSchema` instead. */
+    const outboundSchema: z.ZodType<InternalContentHint$Outbound, z.ZodTypeDef, InternalContentHint>;
+    /** @deprecated use `InternalContentHint$Outbound` instead. */
+    type Outbound = InternalContentHint$Outbound;
+}
+/** @internal */
+export declare const Env$inboundSchema: z.ZodType<Env, z.ZodTypeDef, unknown>;
+/** @internal */
+export type Env$Outbound = {
+    target?: Array<string> | string | undefined;
+    type: string;
+    sunsetSecretId?: string | undefined;
+    id?: string | undefined;
+    key: string;
+    value: string;
+    configurationId?: string | null | undefined;
+    createdAt?: number | undefined;
+    updatedAt?: number | undefined;
+    createdBy?: string | null | undefined;
+    updatedBy?: string | null | undefined;
+    gitBranch?: string | undefined;
+    edgeConfigId?: string | null | undefined;
+    edgeConfigTokenId?: string | null | undefined;
+    contentHint?: ContentHint1$Outbound | ContentHint2$Outbound | ContentHint3$Outbound | ContentHint4$Outbound | ContentHint5$Outbound | ContentHint6$Outbound | ContentHint7$Outbound | ContentHint8$Outbound | ContentHint9$Outbound | ContentHint10$Outbound | UpdateProjectDataCacheContentHint11$Outbound | Twelve$Outbound | Thirteen$Outbound | Fifteen$Outbound | Fourteen$Outbound | null | undefined;
+    internalContentHint?: InternalContentHint$Outbound | null | undefined;
+    decrypted?: boolean | undefined;
+    comment?: string | undefined;
+    customEnvironmentIds?: Array<string> | undefined;
+    vsmValue?: string | undefined;
+};
+/** @internal */
+export declare const Env$outboundSchema: z.ZodType<Env$Outbound, z.ZodTypeDef, Env>;
+/**
+ * @internal
+ * @deprecated This namespace will be removed in future versions. Use schemas and types that are exported directly from this module.
+ */
+export declare namespace Env$ {
+    /** @deprecated use `Env$inboundSchema` instead. */
+    const inboundSchema: z.ZodType<Env, z.ZodTypeDef, unknown>;
+    /** @deprecated use `Env$outboundSchema` instead. */
+    const outboundSchema: z.ZodType<Env$Outbound, z.ZodTypeDef, Env>;
+    /** @deprecated use `Env$Outbound` instead. */
+    type Outbound = Env$Outbound;
+}
+/** @internal */
+export declare const CustomEnvironments$inboundSchema: z.ZodType<CustomEnvironments, z.ZodTypeDef, unknown>;
+/** @internal */
+export type CustomEnvironments$Outbound = {};
+/** @internal */
+export declare const CustomEnvironments$outboundSchema: z.ZodType<CustomEnvironments$Outbound, z.ZodTypeDef, CustomEnvironments>;
+/**
+ * @internal
+ * @deprecated This namespace will be removed in future versions. Use schemas and types that are exported directly from this module.
+ */
+export declare namespace CustomEnvironments$ {
+    /** @deprecated use `CustomEnvironments$inboundSchema` instead. */
+    const inboundSchema: z.ZodType<CustomEnvironments, z.ZodTypeDef, unknown>;
+    /** @deprecated use `CustomEnvironments$outboundSchema` instead. */
+    const outboundSchema: z.ZodType<CustomEnvironments$Outbound, z.ZodTypeDef, CustomEnvironments>;
+    /** @deprecated use `CustomEnvironments$Outbound` instead. */
+    type Outbound = CustomEnvironments$Outbound;
+}
+/** @internal */
+export declare const UpdateProjectDataCacheFramework$inboundSchema: z.ZodNativeEnum<typeof UpdateProjectDataCacheFramework>;
+/** @internal */
+export declare const UpdateProjectDataCacheFramework$outboundSchema: z.ZodNativeEnum<typeof UpdateProjectDataCacheFramework>;
+/**
+ * @internal
+ * @deprecated This namespace will be removed in future versions. Use schemas and types that are exported directly from this module.
+ */
+export declare namespace UpdateProjectDataCacheFramework$ {
+    /** @deprecated use `UpdateProjectDataCacheFramework$inboundSchema` instead. */
+    const inboundSchema: z.ZodNativeEnum<{
+        readonly Blitzjs: "blitzjs";
+        readonly Nextjs: "nextjs";
+        readonly Gatsby: "gatsby";
+        readonly Remix: "remix";
+        readonly Astro: "astro";
+        readonly Hexo: "hexo";
+        readonly Eleventy: "eleventy";
+        readonly Docusaurus2: "docusaurus-2";
+        readonly Docusaurus: "docusaurus";
+        readonly Preact: "preact";
+        readonly Solidstart1: "solidstart-1";
+        readonly Solidstart: "solidstart";
+        readonly Dojo: "dojo";
+        readonly Ember: "ember";
+        readonly Vue: "vue";
+        readonly Scully: "scully";
+        readonly IonicAngular: "ionic-angular";
+        readonly Angular: "angular";
+        readonly Polymer: "polymer";
+        readonly Svelte: "svelte";
+        readonly Sveltekit: "sveltekit";
+        readonly Sveltekit1: "sveltekit-1";
+        readonly IonicReact: "ionic-react";
+        readonly CreateReactApp: "create-react-app";
+        readonly Gridsome: "gridsome";
+        readonly Umijs: "umijs";
+        readonly Sapper: "sapper";
+        readonly Saber: "saber";
+        readonly Stencil: "stencil";
+        readonly Nuxtjs: "nuxtjs";
+        readonly Redwoodjs: "redwoodjs";
+        readonly Hugo: "hugo";
+        readonly Jekyll: "jekyll";
+        readonly Brunch: "brunch";
+        readonly Middleman: "middleman";
+        readonly Zola: "zola";
+        readonly Hydrogen: "hydrogen";
+        readonly Vite: "vite";
+        readonly Vitepress: "vitepress";
+        readonly Vuepress: "vuepress";
+        readonly Parcel: "parcel";
+        readonly Fasthtml: "fasthtml";
+        readonly SanityV3: "sanity-v3";
+        readonly Sanity: "sanity";
+        readonly Storybook: "storybook";
+    }>;
+    /** @deprecated use `UpdateProjectDataCacheFramework$outboundSchema` instead. */
+    const outboundSchema: z.ZodNativeEnum<{
+        readonly Blitzjs: "blitzjs";
+        readonly Nextjs: "nextjs";
+        readonly Gatsby: "gatsby";
+        readonly Remix: "remix";
+        readonly Astro: "astro";
+        readonly Hexo: "hexo";
+        readonly Eleventy: "eleventy";
+        readonly Docusaurus2: "docusaurus-2";
+        readonly Docusaurus: "docusaurus";
+        readonly Preact: "preact";
+        readonly Solidstart1: "solidstart-1";
+        readonly Solidstart: "solidstart";
+        readonly Dojo: "dojo";
+        readonly Ember: "ember";
+        readonly Vue: "vue";
+        readonly Scully: "scully";
+        readonly IonicAngular: "ionic-angular";
+        readonly Angular: "angular";
+        readonly Polymer: "polymer";
+        readonly Svelte: "svelte";
+        readonly Sveltekit: "sveltekit";
+        readonly Sveltekit1: "sveltekit-1";
+        readonly IonicReact: "ionic-react";
+        readonly CreateReactApp: "create-react-app";
+        readonly Gridsome: "gridsome";
+        readonly Umijs: "umijs";
+        readonly Sapper: "sapper";
+        readonly Saber: "saber";
+        readonly Stencil: "stencil";
+        readonly Nuxtjs: "nuxtjs";
+        readonly Redwoodjs: "redwoodjs";
+        readonly Hugo: "hugo";
+        readonly Jekyll: "jekyll";
+        readonly Brunch: "brunch";
+        readonly Middleman: "middleman";
+        readonly Zola: "zola";
+        readonly Hydrogen: "hydrogen";
+        readonly Vite: "vite";
+        readonly Vitepress: "vitepress";
+        readonly Vuepress: "vuepress";
+        readonly Parcel: "parcel";
+        readonly Fasthtml: "fasthtml";
+        readonly SanityV3: "sanity-v3";
+        readonly Sanity: "sanity";
+        readonly Storybook: "storybook";
+    }>;
+}
+/** @internal */
+export declare const IpBuckets$inboundSchema: z.ZodType<IpBuckets, z.ZodTypeDef, unknown>;
+/** @internal */
+export type IpBuckets$Outbound = {
+    bucket: string;
+    supportUntil?: number | undefined;
+};
+/** @internal */
+export declare const IpBuckets$outboundSchema: z.ZodType<IpBuckets$Outbound, z.ZodTypeDef, IpBuckets>;
+/**
+ * @internal
+ * @deprecated This namespace will be removed in future versions. Use schemas and types that are exported directly from this module.
+ */
+export declare namespace IpBuckets$ {
+    /** @deprecated use `IpBuckets$inboundSchema` instead. */
+    const inboundSchema: z.ZodType<IpBuckets, z.ZodTypeDef, unknown>;
+    /** @deprecated use `IpBuckets$outboundSchema` instead. */
+    const outboundSchema: z.ZodType<IpBuckets$Outbound, z.ZodTypeDef, IpBuckets>;
+    /** @deprecated use `IpBuckets$Outbound` instead. */
+    type Outbound = IpBuckets$Outbound;
+}
+/** @internal */
+export declare const AliasAssigned$inboundSchema: z.ZodType<AliasAssigned, z.ZodTypeDef, unknown>;
+/** @internal */
+export type AliasAssigned$Outbound = number | boolean;
+/** @internal */
+export declare const AliasAssigned$outboundSchema: z.ZodType<AliasAssigned$Outbound, z.ZodTypeDef, AliasAssigned>;
+/**
+ * @internal
+ * @deprecated This namespace will be removed in future versions. Use schemas and types that are exported directly from this module.
+ */
+export declare namespace AliasAssigned$ {
+    /** @deprecated use `AliasAssigned$inboundSchema` instead. */
+    const inboundSchema: z.ZodType<AliasAssigned, z.ZodTypeDef, unknown>;
+    /** @deprecated use `AliasAssigned$outboundSchema` instead. */
+    const outboundSchema: z.ZodType<AliasAssigned$Outbound, z.ZodTypeDef, AliasAssigned>;
+    /** @deprecated use `AliasAssigned$Outbound` instead. */
+    type Outbound = AliasAssigned$Outbound;
+}
+/** @internal */
+export declare const UpdateProjectDataCacheProjectsAliasError$inboundSchema: z.ZodType<UpdateProjectDataCacheProjectsAliasError, z.ZodTypeDef, unknown>;
+/** @internal */
+export type UpdateProjectDataCacheProjectsAliasError$Outbound = {
+    code: string;
+    message: string;
+};
+/** @internal */
+export declare const UpdateProjectDataCacheProjectsAliasError$outboundSchema: z.ZodType<UpdateProjectDataCacheProjectsAliasError$Outbound, z.ZodTypeDef, UpdateProjectDataCacheProjectsAliasError>;
+/**
+ * @internal
+ * @deprecated This namespace will be removed in future versions. Use schemas and types that are exported directly from this module.
+ */
+export declare namespace UpdateProjectDataCacheProjectsAliasError$ {
+    /** @deprecated use `UpdateProjectDataCacheProjectsAliasError$inboundSchema` instead. */
+    const inboundSchema: z.ZodType<UpdateProjectDataCacheProjectsAliasError, z.ZodTypeDef, unknown>;
+    /** @deprecated use `UpdateProjectDataCacheProjectsAliasError$outboundSchema` instead. */
+    const outboundSchema: z.ZodType<UpdateProjectDataCacheProjectsAliasError$Outbound, z.ZodTypeDef, UpdateProjectDataCacheProjectsAliasError>;
+    /** @deprecated use `UpdateProjectDataCacheProjectsAliasError$Outbound` instead. */
+    type Outbound = UpdateProjectDataCacheProjectsAliasError$Outbound;
+}
+/** @internal */
+export declare const UpdateProjectDataCacheProjectsResponse200ApplicationJSONType$inboundSchema: z.ZodNativeEnum<typeof UpdateProjectDataCacheProjectsResponse200ApplicationJSONType>;
+/** @internal */
+export declare const UpdateProjectDataCacheProjectsResponse200ApplicationJSONType$outboundSchema: z.ZodNativeEnum<typeof UpdateProjectDataCacheProjectsResponse200ApplicationJSONType>;
+/**
+ * @internal
+ * @deprecated This namespace will be removed in future versions. Use schemas and types that are exported directly from this module.
+ */
+export declare namespace UpdateProjectDataCacheProjectsResponse200ApplicationJSONType$ {
+    /** @deprecated use `UpdateProjectDataCacheProjectsResponse200ApplicationJSONType$inboundSchema` instead. */
+    const inboundSchema: z.ZodNativeEnum<{
+        readonly EndsWith: "endsWith";
+        readonly StartsWith: "startsWith";
+        readonly Equals: "equals";
+    }>;
+    /** @deprecated use `UpdateProjectDataCacheProjectsResponse200ApplicationJSONType$outboundSchema` instead. */
+    const outboundSchema: z.ZodNativeEnum<{
+        readonly EndsWith: "endsWith";
+        readonly StartsWith: "startsWith";
+        readonly Equals: "equals";
+    }>;
+}
+/** @internal */
+export declare const BranchMatcher$inboundSchema: z.ZodType<BranchMatcher, z.ZodTypeDef, unknown>;
+/** @internal */
+export type BranchMatcher$Outbound = {
+    type: string;
+    pattern: string;
+};
+/** @internal */
+export declare const BranchMatcher$outboundSchema: z.ZodType<BranchMatcher$Outbound, z.ZodTypeDef, BranchMatcher>;
+/**
+ * @internal
+ * @deprecated This namespace will be removed in future versions. Use schemas and types that are exported directly from this module.
+ */
+export declare namespace BranchMatcher$ {
+    /** @deprecated use `BranchMatcher$inboundSchema` instead. */
+    const inboundSchema: z.ZodType<BranchMatcher, z.ZodTypeDef, unknown>;
+    /** @deprecated use `BranchMatcher$outboundSchema` instead. */
+    const outboundSchema: z.ZodType<BranchMatcher$Outbound, z.ZodTypeDef, BranchMatcher>;
+    /** @deprecated use `BranchMatcher$Outbound` instead. */
+    type Outbound = BranchMatcher$Outbound;
+}
+/** @internal */
+export declare const UpdateProjectDataCacheProjectsBuilds$inboundSchema: z.ZodType<UpdateProjectDataCacheProjectsBuilds, z.ZodTypeDef, unknown>;
+/** @internal */
+export type UpdateProjectDataCacheProjectsBuilds$Outbound = {
+    use: string;
+    src?: string | undefined;
+    dest?: string | undefined;
+};
+/** @internal */
+export declare const UpdateProjectDataCacheProjectsBuilds$outboundSchema: z.ZodType<UpdateProjectDataCacheProjectsBuilds$Outbound, z.ZodTypeDef, UpdateProjectDataCacheProjectsBuilds>;
+/**
+ * @internal
+ * @deprecated This namespace will be removed in future versions. Use schemas and types that are exported directly from this module.
+ */
+export declare namespace UpdateProjectDataCacheProjectsBuilds$ {
+    /** @deprecated use `UpdateProjectDataCacheProjectsBuilds$inboundSchema` instead. */
+    const inboundSchema: z.ZodType<UpdateProjectDataCacheProjectsBuilds, z.ZodTypeDef, unknown>;
+    /** @deprecated use `UpdateProjectDataCacheProjectsBuilds$outboundSchema` instead. */
+    const outboundSchema: z.ZodType<UpdateProjectDataCacheProjectsBuilds$Outbound, z.ZodTypeDef, UpdateProjectDataCacheProjectsBuilds>;
+    /** @deprecated use `UpdateProjectDataCacheProjectsBuilds$Outbound` instead. */
+    type Outbound = UpdateProjectDataCacheProjectsBuilds$Outbound;
+}
+/** @internal */
+export declare const UpdateProjectDataCacheProjectsChecksConclusion$inboundSchema: z.ZodNativeEnum<typeof UpdateProjectDataCacheProjectsChecksConclusion>;
+/** @internal */
+export declare const UpdateProjectDataCacheProjectsChecksConclusion$outboundSchema: z.ZodNativeEnum<typeof UpdateProjectDataCacheProjectsChecksConclusion>;
+/**
+ * @internal
+ * @deprecated This namespace will be removed in future versions. Use schemas and types that are exported directly from this module.
+ */
+export declare namespace UpdateProjectDataCacheProjectsChecksConclusion$ {
+    /** @deprecated use `UpdateProjectDataCacheProjectsChecksConclusion$inboundSchema` instead. */
+    const inboundSchema: z.ZodNativeEnum<{
+        readonly Succeeded: "succeeded";
+        readonly Failed: "failed";
+        readonly Skipped: "skipped";
+        readonly Canceled: "canceled";
+    }>;
+    /** @deprecated use `UpdateProjectDataCacheProjectsChecksConclusion$outboundSchema` instead. */
+    const outboundSchema: z.ZodNativeEnum<{
+        readonly Succeeded: "succeeded";
+        readonly Failed: "failed";
+        readonly Skipped: "skipped";
+        readonly Canceled: "canceled";
+    }>;
+}
+/** @internal */
+export declare const UpdateProjectDataCacheProjectsChecksState$inboundSchema: z.ZodNativeEnum<typeof UpdateProjectDataCacheProjectsChecksState>;
+/** @internal */
+export declare const UpdateProjectDataCacheProjectsChecksState$outboundSchema: z.ZodNativeEnum<typeof UpdateProjectDataCacheProjectsChecksState>;
+/**
+ * @internal
+ * @deprecated This namespace will be removed in future versions. Use schemas and types that are exported directly from this module.
+ */
+export declare namespace UpdateProjectDataCacheProjectsChecksState$ {
+    /** @deprecated use `UpdateProjectDataCacheProjectsChecksState$inboundSchema` instead. */
+    const inboundSchema: z.ZodNativeEnum<{
+        readonly Registered: "registered";
+        readonly Running: "running";
+        readonly Completed: "completed";
+    }>;
+    /** @deprecated use `UpdateProjectDataCacheProjectsChecksState$outboundSchema` instead. */
+    const outboundSchema: z.ZodNativeEnum<{
+        readonly Registered: "registered";
+        readonly Running: "running";
+        readonly Completed: "completed";
+    }>;
+}
+/** @internal */
+export declare const UpdateProjectDataCacheProjectsCreator$inboundSchema: z.ZodType<UpdateProjectDataCacheProjectsCreator, z.ZodTypeDef, unknown>;
+/** @internal */
+export type UpdateProjectDataCacheProjectsCreator$Outbound = {
+    email: string;
+    githubLogin?: string | undefined;
+    gitlabLogin?: string | undefined;
+    uid: string;
+    username: string;
+};
+/** @internal */
+export declare const UpdateProjectDataCacheProjectsCreator$outboundSchema: z.ZodType<UpdateProjectDataCacheProjectsCreator$Outbound, z.ZodTypeDef, UpdateProjectDataCacheProjectsCreator>;
+/**
+ * @internal
+ * @deprecated This namespace will be removed in future versions. Use schemas and types that are exported directly from this module.
+ */
+export declare namespace UpdateProjectDataCacheProjectsCreator$ {
+    /** @deprecated use `UpdateProjectDataCacheProjectsCreator$inboundSchema` instead. */
+    const inboundSchema: z.ZodType<UpdateProjectDataCacheProjectsCreator, z.ZodTypeDef, unknown>;
+    /** @deprecated use `UpdateProjectDataCacheProjectsCreator$outboundSchema` instead. */
+    const outboundSchema: z.ZodType<UpdateProjectDataCacheProjectsCreator$Outbound, z.ZodTypeDef, UpdateProjectDataCacheProjectsCreator>;
+    /** @deprecated use `UpdateProjectDataCacheProjectsCreator$Outbound` instead. */
+    type Outbound = UpdateProjectDataCacheProjectsCreator$Outbound;
+}
+/** @internal */
+export declare const UpdateProjectDataCacheProjectsOidcTokenClaims$inboundSchema: z.ZodType<UpdateProjectDataCacheProjectsOidcTokenClaims, z.ZodTypeDef, unknown>;
+/** @internal */
+export type UpdateProjectDataCacheProjectsOidcTokenClaims$Outbound = {
+    iss: string;
+    sub: string;
+    scope: string;
+    aud: string;
+    owner: string;
+    owner_id: string;
+    project: string;
+    project_id: string;
+    environment: string;
+};
+/** @internal */
+export declare const UpdateProjectDataCacheProjectsOidcTokenClaims$outboundSchema: z.ZodType<UpdateProjectDataCacheProjectsOidcTokenClaims$Outbound, z.ZodTypeDef, UpdateProjectDataCacheProjectsOidcTokenClaims>;
+/**
+ * @internal
+ * @deprecated This namespace will be removed in future versions. Use schemas and types that are exported directly from this module.
+ */
+export declare namespace UpdateProjectDataCacheProjectsOidcTokenClaims$ {
+    /** @deprecated use `UpdateProjectDataCacheProjectsOidcTokenClaims$inboundSchema` instead. */
+    const inboundSchema: z.ZodType<UpdateProjectDataCacheProjectsOidcTokenClaims, z.ZodTypeDef, unknown>;
+    /** @deprecated use `UpdateProjectDataCacheProjectsOidcTokenClaims$outboundSchema` instead. */
+    const outboundSchema: z.ZodType<UpdateProjectDataCacheProjectsOidcTokenClaims$Outbound, z.ZodTypeDef, UpdateProjectDataCacheProjectsOidcTokenClaims>;
+    /** @deprecated use `UpdateProjectDataCacheProjectsOidcTokenClaims$Outbound` instead. */
+    type Outbound = UpdateProjectDataCacheProjectsOidcTokenClaims$Outbound;
+}
+/** @internal */
+export declare const UpdateProjectDataCacheProjectsPlan$inboundSchema: z.ZodNativeEnum<typeof UpdateProjectDataCacheProjectsPlan>;
+/** @internal */
+export declare const UpdateProjectDataCacheProjectsPlan$outboundSchema: z.ZodNativeEnum<typeof UpdateProjectDataCacheProjectsPlan>;
+/**
+ * @internal
+ * @deprecated This namespace will be removed in future versions. Use schemas and types that are exported directly from this module.
+ */
+export declare namespace UpdateProjectDataCacheProjectsPlan$ {
+    /** @deprecated use `UpdateProjectDataCacheProjectsPlan$inboundSchema` instead. */
+    const inboundSchema: z.ZodNativeEnum<{
+        readonly Pro: "pro";
+        readonly Enterprise: "enterprise";
+        readonly Hobby: "hobby";
+    }>;
+    /** @deprecated use `UpdateProjectDataCacheProjectsPlan$outboundSchema` instead. */
+    const outboundSchema: z.ZodNativeEnum<{
+        readonly Pro: "pro";
+        readonly Enterprise: "enterprise";
+        readonly Hobby: "hobby";
+    }>;
+}
+/** @internal */
+export declare const UpdateProjectDataCacheProjectsReadyState$inboundSchema: z.ZodNativeEnum<typeof UpdateProjectDataCacheProjectsReadyState>;
+/** @internal */
+export declare const UpdateProjectDataCacheProjectsReadyState$outboundSchema: z.ZodNativeEnum<typeof UpdateProjectDataCacheProjectsReadyState>;
+/**
+ * @internal
+ * @deprecated This namespace will be removed in future versions. Use schemas and types that are exported directly from this module.
+ */
+export declare namespace UpdateProjectDataCacheProjectsReadyState$ {
+    /** @deprecated use `UpdateProjectDataCacheProjectsReadyState$inboundSchema` instead. */
+    const inboundSchema: z.ZodNativeEnum<{
+        readonly Building: "BUILDING";
+        readonly Error: "ERROR";
+        readonly Initializing: "INITIALIZING";
+        readonly Queued: "QUEUED";
+        readonly Ready: "READY";
+        readonly Canceled: "CANCELED";
+    }>;
+    /** @deprecated use `UpdateProjectDataCacheProjectsReadyState$outboundSchema` instead. */
+    const outboundSchema: z.ZodNativeEnum<{
+        readonly Building: "BUILDING";
+        readonly Error: "ERROR";
+        readonly Initializing: "INITIALIZING";
+        readonly Queued: "QUEUED";
+        readonly Ready: "READY";
+        readonly Canceled: "CANCELED";
+    }>;
+}
+/** @internal */
+export declare const UpdateProjectDataCacheProjectsReadySubstate$inboundSchema: z.ZodNativeEnum<typeof UpdateProjectDataCacheProjectsReadySubstate>;
+/** @internal */
+export declare const UpdateProjectDataCacheProjectsReadySubstate$outboundSchema: z.ZodNativeEnum<typeof UpdateProjectDataCacheProjectsReadySubstate>;
+/**
+ * @internal
+ * @deprecated This namespace will be removed in future versions. Use schemas and types that are exported directly from this module.
+ */
+export declare namespace UpdateProjectDataCacheProjectsReadySubstate$ {
+    /** @deprecated use `UpdateProjectDataCacheProjectsReadySubstate$inboundSchema` instead. */
+    const inboundSchema: z.ZodNativeEnum<{
+        readonly Staged: "STAGED";
+        readonly Promoted: "PROMOTED";
+    }>;
+    /** @deprecated use `UpdateProjectDataCacheProjectsReadySubstate$outboundSchema` instead. */
+    const outboundSchema: z.ZodNativeEnum<{
+        readonly Staged: "STAGED";
+        readonly Promoted: "PROMOTED";
+    }>;
+}
+/** @internal */
+export declare const UpdateProjectDataCacheType$inboundSchema: z.ZodNativeEnum<typeof UpdateProjectDataCacheType>;
+/** @internal */
+export declare const UpdateProjectDataCacheType$outboundSchema: z.ZodNativeEnum<typeof UpdateProjectDataCacheType>;
+/**
+ * @internal
+ * @deprecated This namespace will be removed in future versions. Use schemas and types that are exported directly from this module.
+ */
+export declare namespace UpdateProjectDataCacheType$ {
+    /** @deprecated use `UpdateProjectDataCacheType$inboundSchema` instead. */
+    const inboundSchema: z.ZodNativeEnum<{
+        readonly Lambdas: "LAMBDAS";
+    }>;
+    /** @deprecated use `UpdateProjectDataCacheType$outboundSchema` instead. */
+    const outboundSchema: z.ZodNativeEnum<{
+        readonly Lambdas: "LAMBDAS";
+    }>;
+}
+/** @internal */
+export declare const LatestDeployments$inboundSchema: z.ZodType<LatestDeployments, z.ZodTypeDef, unknown>;
+/** @internal */
+export type LatestDeployments$Outbound = {
+    id: string;
+    alias?: Array<string> | undefined;
+    aliasAssigned?: number | boolean | null | undefined;
+    aliasError?: UpdateProjectDataCacheProjectsAliasError$Outbound | null | undefined;
+    aliasFinal?: string | null | undefined;
+    automaticAliases?: Array<string> | undefined;
+    branchMatcher?: BranchMatcher$Outbound | undefined;
+    buildingAt?: number | undefined;
+    builds?: Array<UpdateProjectDataCacheProjectsBuilds$Outbound> | undefined;
+    checksConclusion?: string | undefined;
+    checksState?: string | undefined;
+    connectBuildsEnabled?: boolean | undefined;
+    connectConfigurationId?: string | undefined;
+    createdAt: number;
+    createdIn: string;
+    creator: UpdateProjectDataCacheProjectsCreator$Outbound | null;
+    deletedAt?: number | undefined;
+    deploymentHostname: string;
+    forced?: boolean | undefined;
+    name: string;
+    meta?: {
+        [k: string]: string;
+    } | undefined;
+    monorepoManager?: string | null | undefined;
+    oidcTokenClaims?: UpdateProjectDataCacheProjectsOidcTokenClaims$Outbound | undefined;
+    plan: string;
+    previewCommentsEnabled?: boolean | undefined;
+    private: boolean;
+    readyAt?: number | undefined;
+    readyState: string;
+    readySubstate?: string | undefined;
+    requestedAt?: number | undefined;
+    target?: string | null | undefined;
+    teamId?: string | null | undefined;
+    type: string;
+    url: string;
+    userId: string;
+    withCache?: boolean | undefined;
+};
+/** @internal */
+export declare const LatestDeployments$outboundSchema: z.ZodType<LatestDeployments$Outbound, z.ZodTypeDef, LatestDeployments>;
+/**
+ * @internal
+ * @deprecated This namespace will be removed in future versions. Use schemas and types that are exported directly from this module.
+ */
+export declare namespace LatestDeployments$ {
+    /** @deprecated use `LatestDeployments$inboundSchema` instead. */
+    const inboundSchema: z.ZodType<LatestDeployments, z.ZodTypeDef, unknown>;
+    /** @deprecated use `LatestDeployments$outboundSchema` instead. */
+    const outboundSchema: z.ZodType<LatestDeployments$Outbound, z.ZodTypeDef, LatestDeployments>;
+    /** @deprecated use `LatestDeployments$Outbound` instead. */
+    type Outbound = LatestDeployments$Outbound;
+}
+/** @internal */
+export declare const UpdateProjectDataCacheLinkProjectsType$inboundSchema: z.ZodNativeEnum<typeof UpdateProjectDataCacheLinkProjectsType>;
+/** @internal */
+export declare const UpdateProjectDataCacheLinkProjectsType$outboundSchema: z.ZodNativeEnum<typeof UpdateProjectDataCacheLinkProjectsType>;
+/**
+ * @internal
+ * @deprecated This namespace will be removed in future versions. Use schemas and types that are exported directly from this module.
+ */
+export declare namespace UpdateProjectDataCacheLinkProjectsType$ {
+    /** @deprecated use `UpdateProjectDataCacheLinkProjectsType$inboundSchema` instead. */
+    const inboundSchema: z.ZodNativeEnum<{
+        readonly Bitbucket: "bitbucket";
+    }>;
+    /** @deprecated use `UpdateProjectDataCacheLinkProjectsType$outboundSchema` instead. */
+    const outboundSchema: z.ZodNativeEnum<{
+        readonly Bitbucket: "bitbucket";
+    }>;
+}
+/** @internal */
+export declare const UpdateProjectDataCacheLinkDeployHooks$inboundSchema: z.ZodType<UpdateProjectDataCacheLinkDeployHooks, z.ZodTypeDef, unknown>;
+/** @internal */
+export type UpdateProjectDataCacheLinkDeployHooks$Outbound = {
+    createdAt?: number | undefined;
+    id: string;
+    name: string;
+    ref: string;
+    url: string;
+};
+/** @internal */
+export declare const UpdateProjectDataCacheLinkDeployHooks$outboundSchema: z.ZodType<UpdateProjectDataCacheLinkDeployHooks$Outbound, z.ZodTypeDef, UpdateProjectDataCacheLinkDeployHooks>;
+/**
+ * @internal
+ * @deprecated This namespace will be removed in future versions. Use schemas and types that are exported directly from this module.
+ */
+export declare namespace UpdateProjectDataCacheLinkDeployHooks$ {
+    /** @deprecated use `UpdateProjectDataCacheLinkDeployHooks$inboundSchema` instead. */
+    const inboundSchema: z.ZodType<UpdateProjectDataCacheLinkDeployHooks, z.ZodTypeDef, unknown>;
+    /** @deprecated use `UpdateProjectDataCacheLinkDeployHooks$outboundSchema` instead. */
+    const outboundSchema: z.ZodType<UpdateProjectDataCacheLinkDeployHooks$Outbound, z.ZodTypeDef, UpdateProjectDataCacheLinkDeployHooks>;
+    /** @deprecated use `UpdateProjectDataCacheLinkDeployHooks$Outbound` instead. */
+    type Outbound = UpdateProjectDataCacheLinkDeployHooks$Outbound;
+}
+/** @internal */
+export declare const Link3$inboundSchema: z.ZodType<Link3, z.ZodTypeDef, unknown>;
+/** @internal */
+export type Link3$Outbound = {
+    name?: string | undefined;
+    slug?: string | undefined;
+    owner?: string | undefined;
+    type?: string | undefined;
+    uuid?: string | undefined;
+    workspaceUuid?: string | undefined;
+    createdAt?: number | undefined;
+    deployHooks: Array<UpdateProjectDataCacheLinkDeployHooks$Outbound>;
+    gitCredentialId?: string | undefined;
+    updatedAt?: number | undefined;
+    sourceless?: boolean | undefined;
+    productionBranch?: string | undefined;
+};
+/** @internal */
+export declare const Link3$outboundSchema: z.ZodType<Link3$Outbound, z.ZodTypeDef, Link3>;
+/**
+ * @internal
+ * @deprecated This namespace will be removed in future versions. Use schemas and types that are exported directly from this module.
+ */
+export declare namespace Link3$ {
+    /** @deprecated use `Link3$inboundSchema` instead. */
+    const inboundSchema: z.ZodType<Link3, z.ZodTypeDef, unknown>;
+    /** @deprecated use `Link3$outboundSchema` instead. */
+    const outboundSchema: z.ZodType<Link3$Outbound, z.ZodTypeDef, Link3>;
+    /** @deprecated use `Link3$Outbound` instead. */
+    type Outbound = Link3$Outbound;
+}
+/** @internal */
+export declare const UpdateProjectDataCacheLinkType$inboundSchema: z.ZodNativeEnum<typeof UpdateProjectDataCacheLinkType>;
+/** @internal */
+export declare const UpdateProjectDataCacheLinkType$outboundSchema: z.ZodNativeEnum<typeof UpdateProjectDataCacheLinkType>;
+/**
+ * @internal
+ * @deprecated This namespace will be removed in future versions. Use schemas and types that are exported directly from this module.
+ */
+export declare namespace UpdateProjectDataCacheLinkType$ {
+    /** @deprecated use `UpdateProjectDataCacheLinkType$inboundSchema` instead. */
+    const inboundSchema: z.ZodNativeEnum<{
+        readonly Gitlab: "gitlab";
+    }>;
+    /** @deprecated use `UpdateProjectDataCacheLinkType$outboundSchema` instead. */
+    const outboundSchema: z.ZodNativeEnum<{
+        readonly Gitlab: "gitlab";
+    }>;
+}
+/** @internal */
+export declare const LinkDeployHooks$inboundSchema: z.ZodType<LinkDeployHooks, z.ZodTypeDef, unknown>;
+/** @internal */
+export type LinkDeployHooks$Outbound = {
+    createdAt?: number | undefined;
+    id: string;
+    name: string;
+    ref: string;
+    url: string;
+};
+/** @internal */
+export declare const LinkDeployHooks$outboundSchema: z.ZodType<LinkDeployHooks$Outbound, z.ZodTypeDef, LinkDeployHooks>;
+/**
+ * @internal
+ * @deprecated This namespace will be removed in future versions. Use schemas and types that are exported directly from this module.
+ */
+export declare namespace LinkDeployHooks$ {
+    /** @deprecated use `LinkDeployHooks$inboundSchema` instead. */
+    const inboundSchema: z.ZodType<LinkDeployHooks, z.ZodTypeDef, unknown>;
+    /** @deprecated use `LinkDeployHooks$outboundSchema` instead. */
+    const outboundSchema: z.ZodType<LinkDeployHooks$Outbound, z.ZodTypeDef, LinkDeployHooks>;
+    /** @deprecated use `LinkDeployHooks$Outbound` instead. */
+    type Outbound = LinkDeployHooks$Outbound;
+}
+/** @internal */
+export declare const Link2$inboundSchema: z.ZodType<Link2, z.ZodTypeDef, unknown>;
+/** @internal */
+export type Link2$Outbound = {
+    projectId?: string | undefined;
+    projectName?: string | undefined;
+    projectNameWithNamespace?: string | undefined;
+    projectNamespace?: string | undefined;
+    projectOwnerId?: number | undefined;
+    projectUrl?: string | undefined;
+    type?: string | undefined;
+    createdAt?: number | undefined;
+    deployHooks: Array<LinkDeployHooks$Outbound>;
+    gitCredentialId?: string | undefined;
+    updatedAt?: number | undefined;
+    sourceless?: boolean | undefined;
+    productionBranch?: string | undefined;
+};
+/** @internal */
+export declare const Link2$outboundSchema: z.ZodType<Link2$Outbound, z.ZodTypeDef, Link2>;
+/**
+ * @internal
+ * @deprecated This namespace will be removed in future versions. Use schemas and types that are exported directly from this module.
+ */
+export declare namespace Link2$ {
+    /** @deprecated use `Link2$inboundSchema` instead. */
+    const inboundSchema: z.ZodType<Link2, z.ZodTypeDef, unknown>;
+    /** @deprecated use `Link2$outboundSchema` instead. */
+    const outboundSchema: z.ZodType<Link2$Outbound, z.ZodTypeDef, Link2>;
+    /** @deprecated use `Link2$Outbound` instead. */
+    type Outbound = Link2$Outbound;
+}
+/** @internal */
+export declare const LinkType$inboundSchema: z.ZodNativeEnum<typeof LinkType>;
+/** @internal */
+export declare const LinkType$outboundSchema: z.ZodNativeEnum<typeof LinkType>;
+/**
+ * @internal
+ * @deprecated This namespace will be removed in future versions. Use schemas and types that are exported directly from this module.
+ */
+export declare namespace LinkType$ {
+    /** @deprecated use `LinkType$inboundSchema` instead. */
+    const inboundSchema: z.ZodNativeEnum<{
+        readonly Github: "github";
+    }>;
+    /** @deprecated use `LinkType$outboundSchema` instead. */
+    const outboundSchema: z.ZodNativeEnum<{
+        readonly Github: "github";
+    }>;
+}
+/** @internal */
+export declare const DeployHooks$inboundSchema: z.ZodType<DeployHooks, z.ZodTypeDef, unknown>;
+/** @internal */
+export type DeployHooks$Outbound = {
+    createdAt?: number | undefined;
+    id: string;
+    name: string;
+    ref: string;
+    url: string;
+};
+/** @internal */
+export declare const DeployHooks$outboundSchema: z.ZodType<DeployHooks$Outbound, z.ZodTypeDef, DeployHooks>;
+/**
+ * @internal
+ * @deprecated This namespace will be removed in future versions. Use schemas and types that are exported directly from this module.
+ */
+export declare namespace DeployHooks$ {
+    /** @deprecated use `DeployHooks$inboundSchema` instead. */
+    const inboundSchema: z.ZodType<DeployHooks, z.ZodTypeDef, unknown>;
+    /** @deprecated use `DeployHooks$outboundSchema` instead. */
+    const outboundSchema: z.ZodType<DeployHooks$Outbound, z.ZodTypeDef, DeployHooks>;
+    /** @deprecated use `DeployHooks$Outbound` instead. */
+    type Outbound = DeployHooks$Outbound;
+}
+/** @internal */
+export declare const Link1$inboundSchema: z.ZodType<Link1, z.ZodTypeDef, unknown>;
+/** @internal */
+export type Link1$Outbound = {
+    org?: string | undefined;
+    repoOwnerId?: number | undefined;
+    repo?: string | undefined;
+    repoId?: number | undefined;
+    type?: string | undefined;
+    createdAt?: number | undefined;
+    deployHooks: Array<DeployHooks$Outbound>;
+    gitCredentialId?: string | undefined;
+    updatedAt?: number | undefined;
+    sourceless?: boolean | undefined;
+    productionBranch?: string | undefined;
+};
+/** @internal */
+export declare const Link1$outboundSchema: z.ZodType<Link1$Outbound, z.ZodTypeDef, Link1>;
+/**
+ * @internal
+ * @deprecated This namespace will be removed in future versions. Use schemas and types that are exported directly from this module.
+ */
+export declare namespace Link1$ {
+    /** @deprecated use `Link1$inboundSchema` instead. */
+    const inboundSchema: z.ZodType<Link1, z.ZodTypeDef, unknown>;
+    /** @deprecated use `Link1$outboundSchema` instead. */
+    const outboundSchema: z.ZodType<Link1$Outbound, z.ZodTypeDef, Link1>;
+    /** @deprecated use `Link1$Outbound` instead. */
+    type Outbound = Link1$Outbound;
+}
+/** @internal */
+export declare const Link$inboundSchema: z.ZodType<Link, z.ZodTypeDef, unknown>;
+/** @internal */
+export type Link$Outbound = Link1$Outbound | Link3$Outbound | Link2$Outbound;
+/** @internal */
+export declare const Link$outboundSchema: z.ZodType<Link$Outbound, z.ZodTypeDef, Link>;
+/**
+ * @internal
+ * @deprecated This namespace will be removed in future versions. Use schemas and types that are exported directly from this module.
+ */
+export declare namespace Link$ {
+    /** @deprecated use `Link$inboundSchema` instead. */
+    const inboundSchema: z.ZodType<Link, z.ZodTypeDef, unknown>;
+    /** @deprecated use `Link$outboundSchema` instead. */
+    const outboundSchema: z.ZodType<Link$Outbound, z.ZodTypeDef, Link>;
+    /** @deprecated use `Link$Outbound` instead. */
+    type Outbound = Link$Outbound;
+}
+/** @internal */
+export declare const Group$inboundSchema: z.ZodType<Group, z.ZodTypeDef, unknown>;
+/** @internal */
+export type Group$Outbound = {
+    id: string;
+    slug: string;
+};
+/** @internal */
+export declare const Group$outboundSchema: z.ZodType<Group$Outbound, z.ZodTypeDef, Group>;
+/**
+ * @internal
+ * @deprecated This namespace will be removed in future versions. Use schemas and types that are exported directly from this module.
+ */
+export declare namespace Group$ {
+    /** @deprecated use `Group$inboundSchema` instead. */
+    const inboundSchema: z.ZodType<Group, z.ZodTypeDef, unknown>;
+    /** @deprecated use `Group$outboundSchema` instead. */
+    const outboundSchema: z.ZodType<Group$Outbound, z.ZodTypeDef, Group>;
+    /** @deprecated use `Group$Outbound` instead. */
+    type Outbound = Group$Outbound;
+}
+/** @internal */
+export declare const Microfrontends$inboundSchema: z.ZodType<Microfrontends, z.ZodTypeDef, unknown>;
+/** @internal */
+export type Microfrontends$Outbound = {
+    updatedAt: number;
+    group: Group$Outbound;
+    enabled: boolean;
+    isDefaultApp?: boolean | undefined;
+    defaultRoute?: string | undefined;
+};
+/** @internal */
+export declare const Microfrontends$outboundSchema: z.ZodType<Microfrontends$Outbound, z.ZodTypeDef, Microfrontends>;
+/**
+ * @internal
+ * @deprecated This namespace will be removed in future versions. Use schemas and types that are exported directly from this module.
+ */
+export declare namespace Microfrontends$ {
+    /** @deprecated use `Microfrontends$inboundSchema` instead. */
+    const inboundSchema: z.ZodType<Microfrontends, z.ZodTypeDef, unknown>;
+    /** @deprecated use `Microfrontends$outboundSchema` instead. */
+    const outboundSchema: z.ZodType<Microfrontends$Outbound, z.ZodTypeDef, Microfrontends>;
+    /** @deprecated use `Microfrontends$Outbound` instead. */
+    type Outbound = Microfrontends$Outbound;
+}
+/** @internal */
+export declare const UpdateProjectDataCacheNodeVersion$inboundSchema: z.ZodNativeEnum<typeof UpdateProjectDataCacheNodeVersion>;
+/** @internal */
+export declare const UpdateProjectDataCacheNodeVersion$outboundSchema: z.ZodNativeEnum<typeof UpdateProjectDataCacheNodeVersion>;
+/**
+ * @internal
+ * @deprecated This namespace will be removed in future versions. Use schemas and types that are exported directly from this module.
+ */
+export declare namespace UpdateProjectDataCacheNodeVersion$ {
+    /** @deprecated use `UpdateProjectDataCacheNodeVersion$inboundSchema` instead. */
+    const inboundSchema: z.ZodNativeEnum<{
+        readonly TwentyTwoX: "22.x";
+        readonly TwentyX: "20.x";
+        readonly EighteenX: "18.x";
+        readonly SixteenX: "16.x";
+        readonly FourteenX: "14.x";
+        readonly TwelveX: "12.x";
+        readonly TenX: "10.x";
+        readonly Eight10X: "8.10.x";
+    }>;
+    /** @deprecated use `UpdateProjectDataCacheNodeVersion$outboundSchema` instead. */
+    const outboundSchema: z.ZodNativeEnum<{
+        readonly TwentyTwoX: "22.x";
+        readonly TwentyX: "20.x";
+        readonly EighteenX: "18.x";
+        readonly SixteenX: "16.x";
+        readonly FourteenX: "14.x";
+        readonly TwelveX: "12.x";
+        readonly TenX: "10.x";
+        readonly Eight10X: "8.10.x";
+    }>;
+}
+/** @internal */
+export declare const UpdateProjectDataCachePaths$inboundSchema: z.ZodType<UpdateProjectDataCachePaths, z.ZodTypeDef, unknown>;
+/** @internal */
+export type UpdateProjectDataCachePaths$Outbound = {
+    value: string;
+};
+/** @internal */
+export declare const UpdateProjectDataCachePaths$outboundSchema: z.ZodType<UpdateProjectDataCachePaths$Outbound, z.ZodTypeDef, UpdateProjectDataCachePaths>;
+/**
+ * @internal
+ * @deprecated This namespace will be removed in future versions. Use schemas and types that are exported directly from this module.
+ */
+export declare namespace UpdateProjectDataCachePaths$ {
+    /** @deprecated use `UpdateProjectDataCachePaths$inboundSchema` instead. */
+    const inboundSchema: z.ZodType<UpdateProjectDataCachePaths, z.ZodTypeDef, unknown>;
+    /** @deprecated use `UpdateProjectDataCachePaths$outboundSchema` instead. */
+    const outboundSchema: z.ZodType<UpdateProjectDataCachePaths$Outbound, z.ZodTypeDef, UpdateProjectDataCachePaths>;
+    /** @deprecated use `UpdateProjectDataCachePaths$Outbound` instead. */
+    type Outbound = UpdateProjectDataCachePaths$Outbound;
+}
+/** @internal */
+export declare const UpdateProjectDataCacheOptionsAllowlist$inboundSchema: z.ZodType<UpdateProjectDataCacheOptionsAllowlist, z.ZodTypeDef, unknown>;
+/** @internal */
+export type UpdateProjectDataCacheOptionsAllowlist$Outbound = {
+    paths: Array<UpdateProjectDataCachePaths$Outbound>;
+};
+/** @internal */
+export declare const UpdateProjectDataCacheOptionsAllowlist$outboundSchema: z.ZodType<UpdateProjectDataCacheOptionsAllowlist$Outbound, z.ZodTypeDef, UpdateProjectDataCacheOptionsAllowlist>;
+/**
+ * @internal
+ * @deprecated This namespace will be removed in future versions. Use schemas and types that are exported directly from this module.
+ */
+export declare namespace UpdateProjectDataCacheOptionsAllowlist$ {
+    /** @deprecated use `UpdateProjectDataCacheOptionsAllowlist$inboundSchema` instead. */
+    const inboundSchema: z.ZodType<UpdateProjectDataCacheOptionsAllowlist, z.ZodTypeDef, unknown>;
+    /** @deprecated use `UpdateProjectDataCacheOptionsAllowlist$outboundSchema` instead. */
+    const outboundSchema: z.ZodType<UpdateProjectDataCacheOptionsAllowlist$Outbound, z.ZodTypeDef, UpdateProjectDataCacheOptionsAllowlist>;
+    /** @deprecated use `UpdateProjectDataCacheOptionsAllowlist$Outbound` instead. */
+    type Outbound = UpdateProjectDataCacheOptionsAllowlist$Outbound;
+}
+/** @internal */
+export declare const UpdateProjectDataCachePasswordProtection$inboundSchema: z.ZodType<UpdateProjectDataCachePasswordProtection, z.ZodTypeDef, unknown>;
+/** @internal */
+export type UpdateProjectDataCachePasswordProtection$Outbound = {};
+/** @internal */
+export declare const UpdateProjectDataCachePasswordProtection$outboundSchema: z.ZodType<UpdateProjectDataCachePasswordProtection$Outbound, z.ZodTypeDef, UpdateProjectDataCachePasswordProtection>;
+/**
+ * @internal
+ * @deprecated This namespace will be removed in future versions. Use schemas and types that are exported directly from this module.
+ */
+export declare namespace UpdateProjectDataCachePasswordProtection$ {
+    /** @deprecated use `UpdateProjectDataCachePasswordProtection$inboundSchema` instead. */
+    const inboundSchema: z.ZodType<UpdateProjectDataCachePasswordProtection, z.ZodTypeDef, unknown>;
+    /** @deprecated use `UpdateProjectDataCachePasswordProtection$outboundSchema` instead. */
+    const outboundSchema: z.ZodType<UpdateProjectDataCachePasswordProtection$Outbound, z.ZodTypeDef, UpdateProjectDataCachePasswordProtection>;
+    /** @deprecated use `UpdateProjectDataCachePasswordProtection$Outbound` instead. */
+    type Outbound = UpdateProjectDataCachePasswordProtection$Outbound;
+}
+/** @internal */
+export declare const FunctionDefaultMemoryType$inboundSchema: z.ZodNativeEnum<typeof FunctionDefaultMemoryType>;
+/** @internal */
+export declare const FunctionDefaultMemoryType$outboundSchema: z.ZodNativeEnum<typeof FunctionDefaultMemoryType>;
+/**
+ * @internal
+ * @deprecated This namespace will be removed in future versions. Use schemas and types that are exported directly from this module.
+ */
+export declare namespace FunctionDefaultMemoryType$ {
+    /** @deprecated use `FunctionDefaultMemoryType$inboundSchema` instead. */
+    const inboundSchema: z.ZodNativeEnum<{
+        readonly StandardLegacy: "standard_legacy";
+        readonly Standard: "standard";
+        readonly Performance: "performance";
+    }>;
+    /** @deprecated use `FunctionDefaultMemoryType$outboundSchema` instead. */
+    const outboundSchema: z.ZodNativeEnum<{
+        readonly StandardLegacy: "standard_legacy";
+        readonly Standard: "standard";
+        readonly Performance: "performance";
+    }>;
+}
+/** @internal */
+export declare const ResourceConfig$inboundSchema: z.ZodType<ResourceConfig, z.ZodTypeDef, unknown>;
+/** @internal */
+export type ResourceConfig$Outbound = {
+    functionDefaultTimeout?: number | undefined;
+    functionDefaultMemoryType?: string | undefined;
+    allowServerlessConcurrency?: boolean | undefined;
+    elasticConcurrencyEnabled?: boolean | undefined;
+};
+/** @internal */
+export declare const ResourceConfig$outboundSchema: z.ZodType<ResourceConfig$Outbound, z.ZodTypeDef, ResourceConfig>;
+/**
+ * @internal
+ * @deprecated This namespace will be removed in future versions. Use schemas and types that are exported directly from this module.
+ */
+export declare namespace ResourceConfig$ {
+    /** @deprecated use `ResourceConfig$inboundSchema` instead. */
+    const inboundSchema: z.ZodType<ResourceConfig, z.ZodTypeDef, unknown>;
+    /** @deprecated use `ResourceConfig$outboundSchema` instead. */
+    const outboundSchema: z.ZodType<ResourceConfig$Outbound, z.ZodTypeDef, ResourceConfig>;
+    /** @deprecated use `ResourceConfig$Outbound` instead. */
+    type Outbound = ResourceConfig$Outbound;
+}
+/** @internal */
+export declare const UpdateProjectDataCacheDeploymentType$inboundSchema: z.ZodNativeEnum<typeof UpdateProjectDataCacheDeploymentType>;
+/** @internal */
+export declare const UpdateProjectDataCacheDeploymentType$outboundSchema: z.ZodNativeEnum<typeof UpdateProjectDataCacheDeploymentType>;
+/**
+ * @internal
+ * @deprecated This namespace will be removed in future versions. Use schemas and types that are exported directly from this module.
+ */
+export declare namespace UpdateProjectDataCacheDeploymentType$ {
+    /** @deprecated use `UpdateProjectDataCacheDeploymentType$inboundSchema` instead. */
+    const inboundSchema: z.ZodNativeEnum<{
+        readonly Preview: "preview";
+        readonly All: "all";
+        readonly ProdDeploymentUrlsAndAllPreviews: "prod_deployment_urls_and_all_previews";
+    }>;
+    /** @deprecated use `UpdateProjectDataCacheDeploymentType$outboundSchema` instead. */
+    const outboundSchema: z.ZodNativeEnum<{
+        readonly Preview: "preview";
+        readonly All: "all";
+        readonly ProdDeploymentUrlsAndAllPreviews: "prod_deployment_urls_and_all_previews";
+    }>;
+}
+/** @internal */
+export declare const UpdateProjectDataCacheSsoProtection$inboundSchema: z.ZodType<UpdateProjectDataCacheSsoProtection, z.ZodTypeDef, unknown>;
+/** @internal */
+export type UpdateProjectDataCacheSsoProtection$Outbound = {
+    deploymentType: string;
+};
+/** @internal */
+export declare const UpdateProjectDataCacheSsoProtection$outboundSchema: z.ZodType<UpdateProjectDataCacheSsoProtection$Outbound, z.ZodTypeDef, UpdateProjectDataCacheSsoProtection>;
+/**
+ * @internal
+ * @deprecated This namespace will be removed in future versions. Use schemas and types that are exported directly from this module.
+ */
+export declare namespace UpdateProjectDataCacheSsoProtection$ {
+    /** @deprecated use `UpdateProjectDataCacheSsoProtection$inboundSchema` instead. */
+    const inboundSchema: z.ZodType<UpdateProjectDataCacheSsoProtection, z.ZodTypeDef, unknown>;
+    /** @deprecated use `UpdateProjectDataCacheSsoProtection$outboundSchema` instead. */
+    const outboundSchema: z.ZodType<UpdateProjectDataCacheSsoProtection$Outbound, z.ZodTypeDef, UpdateProjectDataCacheSsoProtection>;
+    /** @deprecated use `UpdateProjectDataCacheSsoProtection$Outbound` instead. */
+    type Outbound = UpdateProjectDataCacheSsoProtection$Outbound;
+}
+/** @internal */
+export declare const UpdateProjectDataCacheAliasAssigned$inboundSchema: z.ZodType<UpdateProjectDataCacheAliasAssigned, z.ZodTypeDef, unknown>;
+/** @internal */
+export type UpdateProjectDataCacheAliasAssigned$Outbound = number | boolean;
+/** @internal */
+export declare const UpdateProjectDataCacheAliasAssigned$outboundSchema: z.ZodType<UpdateProjectDataCacheAliasAssigned$Outbound, z.ZodTypeDef, UpdateProjectDataCacheAliasAssigned>;
+/**
+ * @internal
+ * @deprecated This namespace will be removed in future versions. Use schemas and types that are exported directly from this module.
+ */
+export declare namespace UpdateProjectDataCacheAliasAssigned$ {
+    /** @deprecated use `UpdateProjectDataCacheAliasAssigned$inboundSchema` instead. */
+    const inboundSchema: z.ZodType<UpdateProjectDataCacheAliasAssigned, z.ZodTypeDef, unknown>;
+    /** @deprecated use `UpdateProjectDataCacheAliasAssigned$outboundSchema` instead. */
+    const outboundSchema: z.ZodType<UpdateProjectDataCacheAliasAssigned$Outbound, z.ZodTypeDef, UpdateProjectDataCacheAliasAssigned>;
+    /** @deprecated use `UpdateProjectDataCacheAliasAssigned$Outbound` instead. */
+    type Outbound = UpdateProjectDataCacheAliasAssigned$Outbound;
+}
+/** @internal */
+export declare const UpdateProjectDataCacheAliasError$inboundSchema: z.ZodType<UpdateProjectDataCacheAliasError, z.ZodTypeDef, unknown>;
+/** @internal */
+export type UpdateProjectDataCacheAliasError$Outbound = {
+    code: string;
+    message: string;
+};
+/** @internal */
+export declare const UpdateProjectDataCacheAliasError$outboundSchema: z.ZodType<UpdateProjectDataCacheAliasError$Outbound, z.ZodTypeDef, UpdateProjectDataCacheAliasError>;
+/**
+ * @internal
+ * @deprecated This namespace will be removed in future versions. Use schemas and types that are exported directly from this module.
+ */
+export declare namespace UpdateProjectDataCacheAliasError$ {
+    /** @deprecated use `UpdateProjectDataCacheAliasError$inboundSchema` instead. */
+    const inboundSchema: z.ZodType<UpdateProjectDataCacheAliasError, z.ZodTypeDef, unknown>;
+    /** @deprecated use `UpdateProjectDataCacheAliasError$outboundSchema` instead. */
+    const outboundSchema: z.ZodType<UpdateProjectDataCacheAliasError$Outbound, z.ZodTypeDef, UpdateProjectDataCacheAliasError>;
+    /** @deprecated use `UpdateProjectDataCacheAliasError$Outbound` instead. */
+    type Outbound = UpdateProjectDataCacheAliasError$Outbound;
+}
+/** @internal */
+export declare const UpdateProjectDataCacheProjectsResponse200ApplicationJSONResponseBodyTargetsType$inboundSchema: z.ZodNativeEnum<typeof UpdateProjectDataCacheProjectsResponse200ApplicationJSONResponseBodyTargetsType>;
+/** @internal */
+export declare const UpdateProjectDataCacheProjectsResponse200ApplicationJSONResponseBodyTargetsType$outboundSchema: z.ZodNativeEnum<typeof UpdateProjectDataCacheProjectsResponse200ApplicationJSONResponseBodyTargetsType>;
+/**
+ * @internal
+ * @deprecated This namespace will be removed in future versions. Use schemas and types that are exported directly from this module.
+ */
+export declare namespace UpdateProjectDataCacheProjectsResponse200ApplicationJSONResponseBodyTargetsType$ {
+    /** @deprecated use `UpdateProjectDataCacheProjectsResponse200ApplicationJSONResponseBodyTargetsType$inboundSchema` instead. */
+    const inboundSchema: z.ZodNativeEnum<{
+        readonly EndsWith: "endsWith";
+        readonly StartsWith: "startsWith";
+        readonly Equals: "equals";
+    }>;
+    /** @deprecated use `UpdateProjectDataCacheProjectsResponse200ApplicationJSONResponseBodyTargetsType$outboundSchema` instead. */
+    const outboundSchema: z.ZodNativeEnum<{
+        readonly EndsWith: "endsWith";
+        readonly StartsWith: "startsWith";
+        readonly Equals: "equals";
+    }>;
+}
+/** @internal */
+export declare const UpdateProjectDataCacheBranchMatcher$inboundSchema: z.ZodType<UpdateProjectDataCacheBranchMatcher, z.ZodTypeDef, unknown>;
+/** @internal */
+export type UpdateProjectDataCacheBranchMatcher$Outbound = {
+    type: string;
+    pattern: string;
+};
+/** @internal */
+export declare const UpdateProjectDataCacheBranchMatcher$outboundSchema: z.ZodType<UpdateProjectDataCacheBranchMatcher$Outbound, z.ZodTypeDef, UpdateProjectDataCacheBranchMatcher>;
+/**
+ * @internal
+ * @deprecated This namespace will be removed in future versions. Use schemas and types that are exported directly from this module.
+ */
+export declare namespace UpdateProjectDataCacheBranchMatcher$ {
+    /** @deprecated use `UpdateProjectDataCacheBranchMatcher$inboundSchema` instead. */
+    const inboundSchema: z.ZodType<UpdateProjectDataCacheBranchMatcher, z.ZodTypeDef, unknown>;
+    /** @deprecated use `UpdateProjectDataCacheBranchMatcher$outboundSchema` instead. */
+    const outboundSchema: z.ZodType<UpdateProjectDataCacheBranchMatcher$Outbound, z.ZodTypeDef, UpdateProjectDataCacheBranchMatcher>;
+    /** @deprecated use `UpdateProjectDataCacheBranchMatcher$Outbound` instead. */
+    type Outbound = UpdateProjectDataCacheBranchMatcher$Outbound;
+}
+/** @internal */
+export declare const UpdateProjectDataCacheBuilds$inboundSchema: z.ZodType<UpdateProjectDataCacheBuilds, z.ZodTypeDef, unknown>;
+/** @internal */
+export type UpdateProjectDataCacheBuilds$Outbound = {
+    use: string;
+    src?: string | undefined;
+    dest?: string | undefined;
+};
+/** @internal */
+export declare const UpdateProjectDataCacheBuilds$outboundSchema: z.ZodType<UpdateProjectDataCacheBuilds$Outbound, z.ZodTypeDef, UpdateProjectDataCacheBuilds>;
+/**
+ * @internal
+ * @deprecated This namespace will be removed in future versions. Use schemas and types that are exported directly from this module.
+ */
+export declare namespace UpdateProjectDataCacheBuilds$ {
+    /** @deprecated use `UpdateProjectDataCacheBuilds$inboundSchema` instead. */
+    const inboundSchema: z.ZodType<UpdateProjectDataCacheBuilds, z.ZodTypeDef, unknown>;
+    /** @deprecated use `UpdateProjectDataCacheBuilds$outboundSchema` instead. */
+    const outboundSchema: z.ZodType<UpdateProjectDataCacheBuilds$Outbound, z.ZodTypeDef, UpdateProjectDataCacheBuilds>;
+    /** @deprecated use `UpdateProjectDataCacheBuilds$Outbound` instead. */
+    type Outbound = UpdateProjectDataCacheBuilds$Outbound;
+}
+/** @internal */
+export declare const UpdateProjectDataCacheChecksConclusion$inboundSchema: z.ZodNativeEnum<typeof UpdateProjectDataCacheChecksConclusion>;
+/** @internal */
+export declare const UpdateProjectDataCacheChecksConclusion$outboundSchema: z.ZodNativeEnum<typeof UpdateProjectDataCacheChecksConclusion>;
+/**
+ * @internal
+ * @deprecated This namespace will be removed in future versions. Use schemas and types that are exported directly from this module.
+ */
+export declare namespace UpdateProjectDataCacheChecksConclusion$ {
+    /** @deprecated use `UpdateProjectDataCacheChecksConclusion$inboundSchema` instead. */
+    const inboundSchema: z.ZodNativeEnum<{
+        readonly Succeeded: "succeeded";
+        readonly Failed: "failed";
+        readonly Skipped: "skipped";
+        readonly Canceled: "canceled";
+    }>;
+    /** @deprecated use `UpdateProjectDataCacheChecksConclusion$outboundSchema` instead. */
+    const outboundSchema: z.ZodNativeEnum<{
+        readonly Succeeded: "succeeded";
+        readonly Failed: "failed";
+        readonly Skipped: "skipped";
+        readonly Canceled: "canceled";
+    }>;
+}
+/** @internal */
+export declare const UpdateProjectDataCacheChecksState$inboundSchema: z.ZodNativeEnum<typeof UpdateProjectDataCacheChecksState>;
+/** @internal */
+export declare const UpdateProjectDataCacheChecksState$outboundSchema: z.ZodNativeEnum<typeof UpdateProjectDataCacheChecksState>;
+/**
+ * @internal
+ * @deprecated This namespace will be removed in future versions. Use schemas and types that are exported directly from this module.
+ */
+export declare namespace UpdateProjectDataCacheChecksState$ {
+    /** @deprecated use `UpdateProjectDataCacheChecksState$inboundSchema` instead. */
+    const inboundSchema: z.ZodNativeEnum<{
+        readonly Registered: "registered";
+        readonly Running: "running";
+        readonly Completed: "completed";
+    }>;
+    /** @deprecated use `UpdateProjectDataCacheChecksState$outboundSchema` instead. */
+    const outboundSchema: z.ZodNativeEnum<{
+        readonly Registered: "registered";
+        readonly Running: "running";
+        readonly Completed: "completed";
+    }>;
+}
+/** @internal */
+export declare const UpdateProjectDataCacheCreator$inboundSchema: z.ZodType<UpdateProjectDataCacheCreator, z.ZodTypeDef, unknown>;
+/** @internal */
+export type UpdateProjectDataCacheCreator$Outbound = {
+    email: string;
+    githubLogin?: string | undefined;
+    gitlabLogin?: string | undefined;
+    uid: string;
+    username: string;
+};
+/** @internal */
+export declare const UpdateProjectDataCacheCreator$outboundSchema: z.ZodType<UpdateProjectDataCacheCreator$Outbound, z.ZodTypeDef, UpdateProjectDataCacheCreator>;
+/**
+ * @internal
+ * @deprecated This namespace will be removed in future versions. Use schemas and types that are exported directly from this module.
+ */
+export declare namespace UpdateProjectDataCacheCreator$ {
+    /** @deprecated use `UpdateProjectDataCacheCreator$inboundSchema` instead. */
+    const inboundSchema: z.ZodType<UpdateProjectDataCacheCreator, z.ZodTypeDef, unknown>;
+    /** @deprecated use `UpdateProjectDataCacheCreator$outboundSchema` instead. */
+    const outboundSchema: z.ZodType<UpdateProjectDataCacheCreator$Outbound, z.ZodTypeDef, UpdateProjectDataCacheCreator>;
+    /** @deprecated use `UpdateProjectDataCacheCreator$Outbound` instead. */
+    type Outbound = UpdateProjectDataCacheCreator$Outbound;
+}
+/** @internal */
+export declare const UpdateProjectDataCacheOidcTokenClaims$inboundSchema: z.ZodType<UpdateProjectDataCacheOidcTokenClaims, z.ZodTypeDef, unknown>;
+/** @internal */
+export type UpdateProjectDataCacheOidcTokenClaims$Outbound = {
+    iss: string;
+    sub: string;
+    scope: string;
+    aud: string;
+    owner: string;
+    owner_id: string;
+    project: string;
+    project_id: string;
+    environment: string;
+};
+/** @internal */
+export declare const UpdateProjectDataCacheOidcTokenClaims$outboundSchema: z.ZodType<UpdateProjectDataCacheOidcTokenClaims$Outbound, z.ZodTypeDef, UpdateProjectDataCacheOidcTokenClaims>;
+/**
+ * @internal
+ * @deprecated This namespace will be removed in future versions. Use schemas and types that are exported directly from this module.
+ */
+export declare namespace UpdateProjectDataCacheOidcTokenClaims$ {
+    /** @deprecated use `UpdateProjectDataCacheOidcTokenClaims$inboundSchema` instead. */
+    const inboundSchema: z.ZodType<UpdateProjectDataCacheOidcTokenClaims, z.ZodTypeDef, unknown>;
+    /** @deprecated use `UpdateProjectDataCacheOidcTokenClaims$outboundSchema` instead. */
+    const outboundSchema: z.ZodType<UpdateProjectDataCacheOidcTokenClaims$Outbound, z.ZodTypeDef, UpdateProjectDataCacheOidcTokenClaims>;
+    /** @deprecated use `UpdateProjectDataCacheOidcTokenClaims$Outbound` instead. */
+    type Outbound = UpdateProjectDataCacheOidcTokenClaims$Outbound;
+}
+/** @internal */
+export declare const UpdateProjectDataCachePlan$inboundSchema: z.ZodNativeEnum<typeof UpdateProjectDataCachePlan>;
+/** @internal */
+export declare const UpdateProjectDataCachePlan$outboundSchema: z.ZodNativeEnum<typeof UpdateProjectDataCachePlan>;
+/**
+ * @internal
+ * @deprecated This namespace will be removed in future versions. Use schemas and types that are exported directly from this module.
+ */
+export declare namespace UpdateProjectDataCachePlan$ {
+    /** @deprecated use `UpdateProjectDataCachePlan$inboundSchema` instead. */
+    const inboundSchema: z.ZodNativeEnum<{
+        readonly Pro: "pro";
+        readonly Enterprise: "enterprise";
+        readonly Hobby: "hobby";
+    }>;
+    /** @deprecated use `UpdateProjectDataCachePlan$outboundSchema` instead. */
+    const outboundSchema: z.ZodNativeEnum<{
+        readonly Pro: "pro";
+        readonly Enterprise: "enterprise";
+        readonly Hobby: "hobby";
+    }>;
+}
+/** @internal */
+export declare const UpdateProjectDataCacheReadyState$inboundSchema: z.ZodNativeEnum<typeof UpdateProjectDataCacheReadyState>;
+/** @internal */
+export declare const UpdateProjectDataCacheReadyState$outboundSchema: z.ZodNativeEnum<typeof UpdateProjectDataCacheReadyState>;
+/**
+ * @internal
+ * @deprecated This namespace will be removed in future versions. Use schemas and types that are exported directly from this module.
+ */
+export declare namespace UpdateProjectDataCacheReadyState$ {
+    /** @deprecated use `UpdateProjectDataCacheReadyState$inboundSchema` instead. */
+    const inboundSchema: z.ZodNativeEnum<{
+        readonly Building: "BUILDING";
+        readonly Error: "ERROR";
+        readonly Initializing: "INITIALIZING";
+        readonly Queued: "QUEUED";
+        readonly Ready: "READY";
+        readonly Canceled: "CANCELED";
+    }>;
+    /** @deprecated use `UpdateProjectDataCacheReadyState$outboundSchema` instead. */
+    const outboundSchema: z.ZodNativeEnum<{
+        readonly Building: "BUILDING";
+        readonly Error: "ERROR";
+        readonly Initializing: "INITIALIZING";
+        readonly Queued: "QUEUED";
+        readonly Ready: "READY";
+        readonly Canceled: "CANCELED";
+    }>;
+}
+/** @internal */
+export declare const UpdateProjectDataCacheReadySubstate$inboundSchema: z.ZodNativeEnum<typeof UpdateProjectDataCacheReadySubstate>;
+/** @internal */
+export declare const UpdateProjectDataCacheReadySubstate$outboundSchema: z.ZodNativeEnum<typeof UpdateProjectDataCacheReadySubstate>;
+/**
+ * @internal
+ * @deprecated This namespace will be removed in future versions. Use schemas and types that are exported directly from this module.
+ */
+export declare namespace UpdateProjectDataCacheReadySubstate$ {
+    /** @deprecated use `UpdateProjectDataCacheReadySubstate$inboundSchema` instead. */
+    const inboundSchema: z.ZodNativeEnum<{
+        readonly Staged: "STAGED";
+        readonly Promoted: "PROMOTED";
+    }>;
+    /** @deprecated use `UpdateProjectDataCacheReadySubstate$outboundSchema` instead. */
+    const outboundSchema: z.ZodNativeEnum<{
+        readonly Staged: "STAGED";
+        readonly Promoted: "PROMOTED";
+    }>;
+}
+/** @internal */
+export declare const UpdateProjectDataCacheProjectsType$inboundSchema: z.ZodNativeEnum<typeof UpdateProjectDataCacheProjectsType>;
+/** @internal */
+export declare const UpdateProjectDataCacheProjectsType$outboundSchema: z.ZodNativeEnum<typeof UpdateProjectDataCacheProjectsType>;
+/**
+ * @internal
+ * @deprecated This namespace will be removed in future versions. Use schemas and types that are exported directly from this module.
+ */
+export declare namespace UpdateProjectDataCacheProjectsType$ {
+    /** @deprecated use `UpdateProjectDataCacheProjectsType$inboundSchema` instead. */
+    const inboundSchema: z.ZodNativeEnum<{
+        readonly Lambdas: "LAMBDAS";
+    }>;
+    /** @deprecated use `UpdateProjectDataCacheProjectsType$outboundSchema` instead. */
+    const outboundSchema: z.ZodNativeEnum<{
+        readonly Lambdas: "LAMBDAS";
+    }>;
+}
+/** @internal */
+export declare const Targets$inboundSchema: z.ZodType<Targets, z.ZodTypeDef, unknown>;
+/** @internal */
+export type Targets$Outbound = {
+    id: string;
+    alias?: Array<string> | undefined;
+    aliasAssigned?: number | boolean | null | undefined;
+    aliasError?: UpdateProjectDataCacheAliasError$Outbound | null | undefined;
+    aliasFinal?: string | null | undefined;
+    automaticAliases?: Array<string> | undefined;
+    branchMatcher?: UpdateProjectDataCacheBranchMatcher$Outbound | undefined;
+    buildingAt?: number | undefined;
+    builds?: Array<UpdateProjectDataCacheBuilds$Outbound> | undefined;
+    checksConclusion?: string | undefined;
+    checksState?: string | undefined;
+    connectBuildsEnabled?: boolean | undefined;
+    connectConfigurationId?: string | undefined;
+    createdAt: number;
+    createdIn: string;
+    creator: UpdateProjectDataCacheCreator$Outbound | null;
+    deletedAt?: number | undefined;
+    deploymentHostname: string;
+    forced?: boolean | undefined;
+    name: string;
+    meta?: {
+        [k: string]: string;
+    } | undefined;
+    monorepoManager?: string | null | undefined;
+    oidcTokenClaims?: UpdateProjectDataCacheOidcTokenClaims$Outbound | undefined;
+    plan: string;
+    previewCommentsEnabled?: boolean | undefined;
+    private: boolean;
+    readyAt?: number | undefined;
+    readyState: string;
+    readySubstate?: string | undefined;
+    requestedAt?: number | undefined;
+    target?: string | null | undefined;
+    teamId?: string | null | undefined;
+    type: string;
+    url: string;
+    userId: string;
+    withCache?: boolean | undefined;
+};
+/** @internal */
+export declare const Targets$outboundSchema: z.ZodType<Targets$Outbound, z.ZodTypeDef, Targets>;
+/**
+ * @internal
+ * @deprecated This namespace will be removed in future versions. Use schemas and types that are exported directly from this module.
+ */
+export declare namespace Targets$ {
+    /** @deprecated use `Targets$inboundSchema` instead. */
+    const inboundSchema: z.ZodType<Targets, z.ZodTypeDef, unknown>;
+    /** @deprecated use `Targets$outboundSchema` instead. */
+    const outboundSchema: z.ZodType<Targets$Outbound, z.ZodTypeDef, Targets>;
+    /** @deprecated use `Targets$Outbound` instead. */
+    type Outbound = Targets$Outbound;
+}
+/** @internal */
+export declare const Permissions$inboundSchema: z.ZodType<Permissions, z.ZodTypeDef, unknown>;
+/** @internal */
+export type Permissions$Outbound = {
+    accessGroup?: Array<string> | undefined;
+    aliasGlobal?: Array<string> | undefined;
+    analyticsSampling?: Array<string> | undefined;
+    analyticsUsage?: Array<string> | undefined;
+    auditLog?: Array<string> | undefined;
+    billingAddress?: Array<string> | undefined;
+    billingInformation?: Array<string> | undefined;
+    billingInvoice?: Array<string> | undefined;
+    billingInvoiceEmailRecipient?: Array<string> | undefined;
+    billingInvoiceLanguage?: Array<string> | undefined;
+    billingPlan?: Array<string> | undefined;
+    billingPurchaseOrder?: Array<string> | undefined;
+    billingTaxId?: Array<string> | undefined;
+    blob?: Array<string> | undefined;
+    budget?: Array<string> | undefined;
+    cacheArtifact?: Array<string> | undefined;
+    cacheArtifactUsageEvent?: Array<string> | undefined;
+    codeChecks?: Array<string> | undefined;
+    concurrentBuilds?: Array<string> | undefined;
+    connect?: Array<string> | undefined;
+    connectConfiguration?: Array<string> | undefined;
+    domain?: Array<string> | undefined;
+    domainAcceptDelegation?: Array<string> | undefined;
+    domainAuthCodes?: Array<string> | undefined;
+    domainCertificate?: Array<string> | undefined;
+    domainCheckConfig?: Array<string> | undefined;
+    domainMove?: Array<string> | undefined;
+    domainPurchase?: Array<string> | undefined;
+    domainRecord?: Array<string> | undefined;
+    domainTransferIn?: Array<string> | undefined;
+    event?: Array<string> | undefined;
+    ownEvent?: Array<string> | undefined;
+    sensitiveEnvironmentVariablePolicy?: Array<string> | undefined;
+    fileUpload?: Array<string> | undefined;
+    gitRepository?: Array<string> | undefined;
+    ipBlocking?: Array<string> | undefined;
+    integration?: Array<string> | undefined;
+    integrationAccount?: Array<string> | undefined;
+    integrationConfiguration?: Array<string> | undefined;
+    integrationConfigurationTransfer?: Array<string> | undefined;
+    integrationConfigurationProjects?: Array<string> | undefined;
+    integrationVercelConfigurationOverride?: Array<string> | undefined;
+    integrationConfigurationRole?: Array<string> | undefined;
+    integrationResource?: Array<string> | undefined;
+    integrationEvent?: Array<string> | undefined;
+    integrationResourceSecrets?: Array<string> | undefined;
+    integrationDeploymentAction?: Array<string> | undefined;
+    marketplaceInstallationMember?: Array<string> | undefined;
+    marketplaceBillingData?: Array<string> | undefined;
+    marketplaceInvoice?: Array<string> | undefined;
+    jobGlobal?: Array<string> | undefined;
+    logDrain?: Array<string> | undefined;
+    Monitoring?: Array<string> | undefined;
+    monitoringSettings?: Array<string> | undefined;
+    monitoringQuery?: Array<string> | undefined;
+    monitoringChart?: Array<string> | undefined;
+    monitoringAlert?: Array<string> | undefined;
+    notificationDeploymentFailed?: Array<string> | undefined;
+    notificationDomainConfiguration?: Array<string> | undefined;
+    notificationDomainExpire?: Array<string> | undefined;
+    notificationDomainMoved?: Array<string> | undefined;
+    notificationDomainPurchase?: Array<string> | undefined;
+    notificationDomainRenewal?: Array<string> | undefined;
+    notificationDomainTransfer?: Array<string> | undefined;
+    notificationDomainUnverified?: Array<string> | undefined;
+    NotificationMonitoringAlert?: Array<string> | undefined;
+    notificationPaymentFailed?: Array<string> | undefined;
+    notificationUsageAlert?: Array<string> | undefined;
+    notificationCustomerBudget?: Array<string> | undefined;
+    notificationStatementOfReasons?: Array<string> | undefined;
+    oauth2Connection?: Array<string> | undefined;
+    openTelemetryEndpoint?: Array<string> | undefined;
+    paymentMethod?: Array<string> | undefined;
+    permissions?: Array<string> | undefined;
+    postgres?: Array<string> | undefined;
+    previewDeploymentSuffix?: Array<string> | undefined;
+    proTrialOnboarding?: Array<string> | undefined;
+    sharedEnvVars?: Array<string> | undefined;
+    sharedEnvVarsProduction?: Array<string> | undefined;
+    space?: Array<string> | undefined;
+    spaceRun?: Array<string> | undefined;
+    passwordProtectionInvoiceItem?: Array<string> | undefined;
+    rateLimit?: Array<string> | undefined;
+    redis?: Array<string> | undefined;
+    repository?: Array<string> | undefined;
+    remoteCaching?: Array<string> | undefined;
+    samlConfig?: Array<string> | undefined;
+    secret?: Array<string> | undefined;
+    redisStoreTokenSet?: Array<string> | undefined;
+    blobStoreTokenSet?: Array<string> | undefined;
+    postgresStoreTokenSet?: Array<string> | undefined;
+    integrationStoreTokenSet?: Array<string> | undefined;
+    integrationResourceReplCommand?: Array<string> | undefined;
+    storeTransfer?: Array<string> | undefined;
+    supportCase?: Array<string> | undefined;
+    supportCaseComment?: Array<string> | undefined;
+    dataCacheBillingSettings?: Array<string> | undefined;
+    team?: Array<string> | undefined;
+    teamAccessRequest?: Array<string> | undefined;
+    teamFellowMembership?: Array<string> | undefined;
+    teamGitExclusivity?: Array<string> | undefined;
+    teamInvite?: Array<string> | undefined;
+    teamInviteCode?: Array<string> | undefined;
+    teamJoin?: Array<string> | undefined;
+    teamOwnMembership?: Array<string> | undefined;
+    teamOwnMembershipDisconnectSAML?: Array<string> | undefined;
+    token?: Array<string> | undefined;
+    usage?: Array<string> | undefined;
+    usageCycle?: Array<string> | undefined;
+    user?: Array<string> | undefined;
+    userConnection?: Array<string> | undefined;
+    vpcPeeringConnection?: Array<string> | undefined;
+    webAnalyticsPlan?: Array<string> | undefined;
+    webAuthn?: Array<string> | undefined;
+    edgeConfig?: Array<string> | undefined;
+    edgeConfigItem?: Array<string> | undefined;
+    edgeConfigSchema?: Array<string> | undefined;
+    edgeConfigToken?: Array<string> | undefined;
+    webhook?: Array<string> | undefined;
+    "webhook-event"?: Array<string> | undefined;
+    endpointVerification?: Array<string> | undefined;
+    projectTransferIn?: Array<string> | undefined;
+    oauth2Application?: Array<string> | undefined;
+    aliasProject?: Array<string> | undefined;
+    aliasProtectionBypass?: Array<string> | undefined;
+    productionAliasProtectionBypass?: Array<string> | undefined;
+    connectConfigurationLink?: Array<string> | undefined;
+    dataCacheNamespace?: Array<string> | undefined;
+    deployment?: Array<string> | undefined;
+    deploymentCheck?: Array<string> | undefined;
+    deploymentCheckPreview?: Array<string> | undefined;
+    deploymentCheckReRunFromProductionBranch?: Array<string> | undefined;
+    deploymentProductionGit?: Array<string> | undefined;
+    deploymentPreview?: Array<string> | undefined;
+    deploymentPrivate?: Array<string> | undefined;
+    deploymentPromote?: Array<string> | undefined;
+    deploymentRollback?: Array<string> | undefined;
+    environments?: Array<string> | undefined;
+    logs?: Array<string> | undefined;
+    logsPreset?: Array<string> | undefined;
+    passwordProtection?: Array<string> | undefined;
+    optionsAllowlist?: Array<string> | undefined;
+    job?: Array<string> | undefined;
+    project?: Array<string> | undefined;
+    projectAccessGroup?: Array<string> | undefined;
+    projectAnalyticsSampling?: Array<string> | undefined;
+    projectDeploymentHook?: Array<string> | undefined;
+    projectDomain?: Array<string> | undefined;
+    projectDomainMove?: Array<string> | undefined;
+    projectDomainCheckConfig?: Array<string> | undefined;
+    projectEnvVars?: Array<string> | undefined;
+    projectEnvVarsProduction?: Array<string> | undefined;
+    projectEnvVarsUnownedByIntegration?: Array<string> | undefined;
+    projectFlags?: Array<string> | undefined;
+    projectId?: Array<string> | undefined;
+    projectIntegrationConfiguration?: Array<string> | undefined;
+    projectLink?: Array<string> | undefined;
+    projectMember?: Array<string> | undefined;
+    projectMonitoring?: Array<string> | undefined;
+    projectPermissions?: Array<string> | undefined;
+    projectProductionBranch?: Array<string> | undefined;
+    projectTransfer?: Array<string> | undefined;
+    projectTransferOut?: Array<string> | undefined;
+    projectProtectionBypass?: Array<string> | undefined;
+    projectUsage?: Array<string> | undefined;
+    projectAnalyticsUsage?: Array<string> | undefined;
+    projectSupportCase?: Array<string> | undefined;
+    projectSupportCaseComment?: Array<string> | undefined;
+    projectDeploymentExpiration?: Array<string> | undefined;
+    projectTier?: Array<string> | undefined;
+    seawallConfig?: Array<string> | undefined;
+    skewProtection?: Array<string> | undefined;
+    analytics?: Array<string> | undefined;
+    trustedIps?: Array<string> | undefined;
+    webAnalytics?: Array<string> | undefined;
+    sharedEnvVarConnection?: Array<string> | undefined;
+    sonar?: Array<string> | undefined;
+};
+/** @internal */
+export declare const Permissions$outboundSchema: z.ZodType<Permissions$Outbound, z.ZodTypeDef, Permissions>;
+/**
+ * @internal
+ * @deprecated This namespace will be removed in future versions. Use schemas and types that are exported directly from this module.
+ */
+export declare namespace Permissions$ {
+    /** @deprecated use `Permissions$inboundSchema` instead. */
+    const inboundSchema: z.ZodType<Permissions, z.ZodTypeDef, unknown>;
+    /** @deprecated use `Permissions$outboundSchema` instead. */
+    const outboundSchema: z.ZodType<Permissions$Outbound, z.ZodTypeDef, Permissions>;
+    /** @deprecated use `Permissions$Outbound` instead. */
+    type Outbound = Permissions$Outbound;
+}
+/** @internal */
+export declare const LastRollbackTarget$inboundSchema: z.ZodType<LastRollbackTarget, z.ZodTypeDef, unknown>;
+/** @internal */
+export type LastRollbackTarget$Outbound = {};
+/** @internal */
+export declare const LastRollbackTarget$outboundSchema: z.ZodType<LastRollbackTarget$Outbound, z.ZodTypeDef, LastRollbackTarget>;
+/**
+ * @internal
+ * @deprecated This namespace will be removed in future versions. Use schemas and types that are exported directly from this module.
+ */
+export declare namespace LastRollbackTarget$ {
+    /** @deprecated use `LastRollbackTarget$inboundSchema` instead. */
+    const inboundSchema: z.ZodType<LastRollbackTarget, z.ZodTypeDef, unknown>;
+    /** @deprecated use `LastRollbackTarget$outboundSchema` instead. */
+    const outboundSchema: z.ZodType<LastRollbackTarget$Outbound, z.ZodTypeDef, LastRollbackTarget>;
+    /** @deprecated use `LastRollbackTarget$Outbound` instead. */
+    type Outbound = LastRollbackTarget$Outbound;
+}
+/** @internal */
+export declare const JobStatus$inboundSchema: z.ZodNativeEnum<typeof JobStatus>;
+/** @internal */
+export declare const JobStatus$outboundSchema: z.ZodNativeEnum<typeof JobStatus>;
+/**
+ * @internal
+ * @deprecated This namespace will be removed in future versions. Use schemas and types that are exported directly from this module.
+ */
+export declare namespace JobStatus$ {
+    /** @deprecated use `JobStatus$inboundSchema` instead. */
+    const inboundSchema: z.ZodNativeEnum<{
+        readonly Succeeded: "succeeded";
+        readonly Failed: "failed";
+        readonly Skipped: "skipped";
+        readonly Pending: "pending";
+        readonly InProgress: "in-progress";
+    }>;
+    /** @deprecated use `JobStatus$outboundSchema` instead. */
+    const outboundSchema: z.ZodNativeEnum<{
+        readonly Succeeded: "succeeded";
+        readonly Failed: "failed";
+        readonly Skipped: "skipped";
+        readonly Pending: "pending";
+        readonly InProgress: "in-progress";
+    }>;
+}
+/** @internal */
+export declare const UpdateProjectDataCacheProjectsResponseType$inboundSchema: z.ZodNativeEnum<typeof UpdateProjectDataCacheProjectsResponseType>;
+/** @internal */
+export declare const UpdateProjectDataCacheProjectsResponseType$outboundSchema: z.ZodNativeEnum<typeof UpdateProjectDataCacheProjectsResponseType>;
+/**
+ * @internal
+ * @deprecated This namespace will be removed in future versions. Use schemas and types that are exported directly from this module.
+ */
+export declare namespace UpdateProjectDataCacheProjectsResponseType$ {
+    /** @deprecated use `UpdateProjectDataCacheProjectsResponseType$inboundSchema` instead. */
+    const inboundSchema: z.ZodNativeEnum<{
+        readonly Promote: "promote";
+        readonly Rollback: "rollback";
+    }>;
+    /** @deprecated use `UpdateProjectDataCacheProjectsResponseType$outboundSchema` instead. */
+    const outboundSchema: z.ZodNativeEnum<{
+        readonly Promote: "promote";
+        readonly Rollback: "rollback";
+    }>;
+}
+/** @internal */
+export declare const LastAliasRequest$inboundSchema: z.ZodType<LastAliasRequest, z.ZodTypeDef, unknown>;
+/** @internal */
+export type LastAliasRequest$Outbound = {
+    fromDeploymentId: string;
+    toDeploymentId: string;
+    jobStatus: string;
+    requestedAt: number;
+    type: string;
+};
+/** @internal */
+export declare const LastAliasRequest$outboundSchema: z.ZodType<LastAliasRequest$Outbound, z.ZodTypeDef, LastAliasRequest>;
+/**
+ * @internal
+ * @deprecated This namespace will be removed in future versions. Use schemas and types that are exported directly from this module.
+ */
+export declare namespace LastAliasRequest$ {
+    /** @deprecated use `LastAliasRequest$inboundSchema` instead. */
+    const inboundSchema: z.ZodType<LastAliasRequest, z.ZodTypeDef, unknown>;
+    /** @deprecated use `LastAliasRequest$outboundSchema` instead. */
+    const outboundSchema: z.ZodType<LastAliasRequest$Outbound, z.ZodTypeDef, LastAliasRequest>;
+    /** @deprecated use `LastAliasRequest$Outbound` instead. */
+    type Outbound = LastAliasRequest$Outbound;
+}
+/** @internal */
+export declare const Scope$inboundSchema: z.ZodNativeEnum<typeof Scope>;
+/** @internal */
+export declare const Scope$outboundSchema: z.ZodNativeEnum<typeof Scope>;
+/**
+ * @internal
+ * @deprecated This namespace will be removed in future versions. Use schemas and types that are exported directly from this module.
+ */
+export declare namespace Scope$ {
+    /** @deprecated use `Scope$inboundSchema` instead. */
+    const inboundSchema: z.ZodNativeEnum<{
+        readonly AutomationBypass: "automation-bypass";
+    }>;
+    /** @deprecated use `Scope$outboundSchema` instead. */
+    const outboundSchema: z.ZodNativeEnum<{
+        readonly AutomationBypass: "automation-bypass";
+    }>;
+}
+/** @internal */
+export declare const ProtectionBypass$inboundSchema: z.ZodType<ProtectionBypass, z.ZodTypeDef, unknown>;
+/** @internal */
+export type ProtectionBypass$Outbound = {
+    createdAt: number;
+    createdBy: string;
+    scope: string;
+};
+/** @internal */
+export declare const ProtectionBypass$outboundSchema: z.ZodType<ProtectionBypass$Outbound, z.ZodTypeDef, ProtectionBypass>;
+/**
+ * @internal
+ * @deprecated This namespace will be removed in future versions. Use schemas and types that are exported directly from this module.
+ */
+export declare namespace ProtectionBypass$ {
+    /** @deprecated use `ProtectionBypass$inboundSchema` instead. */
+    const inboundSchema: z.ZodType<ProtectionBypass, z.ZodTypeDef, unknown>;
+    /** @deprecated use `ProtectionBypass$outboundSchema` instead. */
+    const outboundSchema: z.ZodType<ProtectionBypass$Outbound, z.ZodTypeDef, ProtectionBypass>;
+    /** @deprecated use `ProtectionBypass$Outbound` instead. */
+    type Outbound = ProtectionBypass$Outbound;
+}
+/** @internal */
+export declare const UpdateProjectDataCacheTrustedIpsDeploymentType$inboundSchema: z.ZodNativeEnum<typeof UpdateProjectDataCacheTrustedIpsDeploymentType>;
+/** @internal */
+export declare const UpdateProjectDataCacheTrustedIpsDeploymentType$outboundSchema: z.ZodNativeEnum<typeof UpdateProjectDataCacheTrustedIpsDeploymentType>;
+/**
+ * @internal
+ * @deprecated This namespace will be removed in future versions. Use schemas and types that are exported directly from this module.
+ */
+export declare namespace UpdateProjectDataCacheTrustedIpsDeploymentType$ {
+    /** @deprecated use `UpdateProjectDataCacheTrustedIpsDeploymentType$inboundSchema` instead. */
+    const inboundSchema: z.ZodNativeEnum<{
+        readonly Production: "production";
+        readonly Preview: "preview";
+        readonly All: "all";
+        readonly ProdDeploymentUrlsAndAllPreviews: "prod_deployment_urls_and_all_previews";
+    }>;
+    /** @deprecated use `UpdateProjectDataCacheTrustedIpsDeploymentType$outboundSchema` instead. */
+    const outboundSchema: z.ZodNativeEnum<{
+        readonly Production: "production";
+        readonly Preview: "preview";
+        readonly All: "all";
+        readonly ProdDeploymentUrlsAndAllPreviews: "prod_deployment_urls_and_all_previews";
+    }>;
+}
+/** @internal */
+export declare const TrustedIps2$inboundSchema: z.ZodType<TrustedIps2, z.ZodTypeDef, unknown>;
+/** @internal */
+export type TrustedIps2$Outbound = {
+    deploymentType: string;
+};
+/** @internal */
+export declare const TrustedIps2$outboundSchema: z.ZodType<TrustedIps2$Outbound, z.ZodTypeDef, TrustedIps2>;
+/**
+ * @internal
+ * @deprecated This namespace will be removed in future versions. Use schemas and types that are exported directly from this module.
+ */
+export declare namespace TrustedIps2$ {
+    /** @deprecated use `TrustedIps2$inboundSchema` instead. */
+    const inboundSchema: z.ZodType<TrustedIps2, z.ZodTypeDef, unknown>;
+    /** @deprecated use `TrustedIps2$outboundSchema` instead. */
+    const outboundSchema: z.ZodType<TrustedIps2$Outbound, z.ZodTypeDef, TrustedIps2>;
+    /** @deprecated use `TrustedIps2$Outbound` instead. */
+    type Outbound = TrustedIps2$Outbound;
+}
+/** @internal */
+export declare const TrustedIpsDeploymentType$inboundSchema: z.ZodNativeEnum<typeof TrustedIpsDeploymentType>;
+/** @internal */
+export declare const TrustedIpsDeploymentType$outboundSchema: z.ZodNativeEnum<typeof TrustedIpsDeploymentType>;
+/**
+ * @internal
+ * @deprecated This namespace will be removed in future versions. Use schemas and types that are exported directly from this module.
+ */
+export declare namespace TrustedIpsDeploymentType$ {
+    /** @deprecated use `TrustedIpsDeploymentType$inboundSchema` instead. */
+    const inboundSchema: z.ZodNativeEnum<{
+        readonly Production: "production";
+        readonly Preview: "preview";
+        readonly All: "all";
+        readonly ProdDeploymentUrlsAndAllPreviews: "prod_deployment_urls_and_all_previews";
+    }>;
+    /** @deprecated use `TrustedIpsDeploymentType$outboundSchema` instead. */
+    const outboundSchema: z.ZodNativeEnum<{
+        readonly Production: "production";
+        readonly Preview: "preview";
+        readonly All: "all";
+        readonly ProdDeploymentUrlsAndAllPreviews: "prod_deployment_urls_and_all_previews";
+    }>;
+}
+/** @internal */
+export declare const UpdateProjectDataCacheTrustedIpsAddresses$inboundSchema: z.ZodType<UpdateProjectDataCacheTrustedIpsAddresses, z.ZodTypeDef, unknown>;
+/** @internal */
+export type UpdateProjectDataCacheTrustedIpsAddresses$Outbound = {
+    value: string;
+    note?: string | undefined;
+};
+/** @internal */
+export declare const UpdateProjectDataCacheTrustedIpsAddresses$outboundSchema: z.ZodType<UpdateProjectDataCacheTrustedIpsAddresses$Outbound, z.ZodTypeDef, UpdateProjectDataCacheTrustedIpsAddresses>;
+/**
+ * @internal
+ * @deprecated This namespace will be removed in future versions. Use schemas and types that are exported directly from this module.
+ */
+export declare namespace UpdateProjectDataCacheTrustedIpsAddresses$ {
+    /** @deprecated use `UpdateProjectDataCacheTrustedIpsAddresses$inboundSchema` instead. */
+    const inboundSchema: z.ZodType<UpdateProjectDataCacheTrustedIpsAddresses, z.ZodTypeDef, unknown>;
+    /** @deprecated use `UpdateProjectDataCacheTrustedIpsAddresses$outboundSchema` instead. */
+    const outboundSchema: z.ZodType<UpdateProjectDataCacheTrustedIpsAddresses$Outbound, z.ZodTypeDef, UpdateProjectDataCacheTrustedIpsAddresses>;
+    /** @deprecated use `UpdateProjectDataCacheTrustedIpsAddresses$Outbound` instead. */
+    type Outbound = UpdateProjectDataCacheTrustedIpsAddresses$Outbound;
+}
+/** @internal */
+export declare const UpdateProjectDataCacheTrustedIpsProtectionMode$inboundSchema: z.ZodNativeEnum<typeof UpdateProjectDataCacheTrustedIpsProtectionMode>;
+/** @internal */
+export declare const UpdateProjectDataCacheTrustedIpsProtectionMode$outboundSchema: z.ZodNativeEnum<typeof UpdateProjectDataCacheTrustedIpsProtectionMode>;
+/**
+ * @internal
+ * @deprecated This namespace will be removed in future versions. Use schemas and types that are exported directly from this module.
+ */
+export declare namespace UpdateProjectDataCacheTrustedIpsProtectionMode$ {
+    /** @deprecated use `UpdateProjectDataCacheTrustedIpsProtectionMode$inboundSchema` instead. */
+    const inboundSchema: z.ZodNativeEnum<{
+        readonly Additional: "additional";
+        readonly Exclusive: "exclusive";
+    }>;
+    /** @deprecated use `UpdateProjectDataCacheTrustedIpsProtectionMode$outboundSchema` instead. */
+    const outboundSchema: z.ZodNativeEnum<{
+        readonly Additional: "additional";
+        readonly Exclusive: "exclusive";
+    }>;
+}
+/** @internal */
+export declare const TrustedIps1$inboundSchema: z.ZodType<TrustedIps1, z.ZodTypeDef, unknown>;
+/** @internal */
+export type TrustedIps1$Outbound = {
+    deploymentType: string;
+    addresses: Array<UpdateProjectDataCacheTrustedIpsAddresses$Outbound>;
+    protectionMode: string;
+};
+/** @internal */
+export declare const TrustedIps1$outboundSchema: z.ZodType<TrustedIps1$Outbound, z.ZodTypeDef, TrustedIps1>;
+/**
+ * @internal
+ * @deprecated This namespace will be removed in future versions. Use schemas and types that are exported directly from this module.
+ */
+export declare namespace TrustedIps1$ {
+    /** @deprecated use `TrustedIps1$inboundSchema` instead. */
+    const inboundSchema: z.ZodType<TrustedIps1, z.ZodTypeDef, unknown>;
+    /** @deprecated use `TrustedIps1$outboundSchema` instead. */
+    const outboundSchema: z.ZodType<TrustedIps1$Outbound, z.ZodTypeDef, TrustedIps1>;
+    /** @deprecated use `TrustedIps1$Outbound` instead. */
+    type Outbound = TrustedIps1$Outbound;
+}
+/** @internal */
+export declare const UpdateProjectDataCacheTrustedIps$inboundSchema: z.ZodType<UpdateProjectDataCacheTrustedIps, z.ZodTypeDef, unknown>;
+/** @internal */
+export type UpdateProjectDataCacheTrustedIps$Outbound = TrustedIps2$Outbound | TrustedIps1$Outbound;
+/** @internal */
+export declare const UpdateProjectDataCacheTrustedIps$outboundSchema: z.ZodType<UpdateProjectDataCacheTrustedIps$Outbound, z.ZodTypeDef, UpdateProjectDataCacheTrustedIps>;
+/**
+ * @internal
+ * @deprecated This namespace will be removed in future versions. Use schemas and types that are exported directly from this module.
+ */
+export declare namespace UpdateProjectDataCacheTrustedIps$ {
+    /** @deprecated use `UpdateProjectDataCacheTrustedIps$inboundSchema` instead. */
+    const inboundSchema: z.ZodType<UpdateProjectDataCacheTrustedIps, z.ZodTypeDef, unknown>;
+    /** @deprecated use `UpdateProjectDataCacheTrustedIps$outboundSchema` instead. */
+    const outboundSchema: z.ZodType<UpdateProjectDataCacheTrustedIps$Outbound, z.ZodTypeDef, UpdateProjectDataCacheTrustedIps>;
+    /** @deprecated use `UpdateProjectDataCacheTrustedIps$Outbound` instead. */
+    type Outbound = UpdateProjectDataCacheTrustedIps$Outbound;
+}
+/** @internal */
+export declare const GitComments$inboundSchema: z.ZodType<GitComments, z.ZodTypeDef, unknown>;
+/** @internal */
+export type GitComments$Outbound = {
+    onPullRequest: boolean;
+    onCommit: boolean;
+};
+/** @internal */
+export declare const GitComments$outboundSchema: z.ZodType<GitComments$Outbound, z.ZodTypeDef, GitComments>;
+/**
+ * @internal
+ * @deprecated This namespace will be removed in future versions. Use schemas and types that are exported directly from this module.
+ */
+export declare namespace GitComments$ {
+    /** @deprecated use `GitComments$inboundSchema` instead. */
+    const inboundSchema: z.ZodType<GitComments, z.ZodTypeDef, unknown>;
+    /** @deprecated use `GitComments$outboundSchema` instead. */
+    const outboundSchema: z.ZodType<GitComments$Outbound, z.ZodTypeDef, GitComments>;
+    /** @deprecated use `GitComments$Outbound` instead. */
+    type Outbound = GitComments$Outbound;
+}
+/** @internal */
+export declare const WebAnalytics$inboundSchema: z.ZodType<WebAnalytics, z.ZodTypeDef, unknown>;
+/** @internal */
+export type WebAnalytics$Outbound = {
+    id: string;
+    disabledAt?: number | undefined;
+    canceledAt?: number | undefined;
+    enabledAt?: number | undefined;
+    hasData?: boolean | undefined;
+};
+/** @internal */
+export declare const WebAnalytics$outboundSchema: z.ZodType<WebAnalytics$Outbound, z.ZodTypeDef, WebAnalytics>;
+/**
+ * @internal
+ * @deprecated This namespace will be removed in future versions. Use schemas and types that are exported directly from this module.
+ */
+export declare namespace WebAnalytics$ {
+    /** @deprecated use `WebAnalytics$inboundSchema` instead. */
+    const inboundSchema: z.ZodType<WebAnalytics, z.ZodTypeDef, unknown>;
+    /** @deprecated use `WebAnalytics$outboundSchema` instead. */
+    const outboundSchema: z.ZodType<WebAnalytics$Outbound, z.ZodTypeDef, WebAnalytics>;
+    /** @deprecated use `WebAnalytics$Outbound` instead. */
+    type Outbound = WebAnalytics$Outbound;
+}
+/** @internal */
+export declare const Src2$inboundSchema: z.ZodType<Src2, z.ZodTypeDef, unknown>;
+/** @internal */
+export type Src2$Outbound = {
+    re?: string | undefined;
+    eq?: string | undefined;
+    neq?: string | undefined;
+    inc?: Array<string> | undefined;
+    ninc?: Array<string> | undefined;
+    pre?: string | undefined;
+    suf?: string | undefined;
+    gt?: number | undefined;
+    gte?: number | undefined;
+    lt?: number | undefined;
+    lte?: number | undefined;
+};
+/** @internal */
+export declare const Src2$outboundSchema: z.ZodType<Src2$Outbound, z.ZodTypeDef, Src2>;
+/**
+ * @internal
+ * @deprecated This namespace will be removed in future versions. Use schemas and types that are exported directly from this module.
+ */
+export declare namespace Src2$ {
+    /** @deprecated use `Src2$inboundSchema` instead. */
+    const inboundSchema: z.ZodType<Src2, z.ZodTypeDef, unknown>;
+    /** @deprecated use `Src2$outboundSchema` instead. */
+    const outboundSchema: z.ZodType<Src2$Outbound, z.ZodTypeDef, Src2>;
+    /** @deprecated use `Src2$Outbound` instead. */
+    type Outbound = Src2$Outbound;
+}
+/** @internal */
+export declare const Src$inboundSchema: z.ZodType<Src, z.ZodTypeDef, unknown>;
+/** @internal */
+export type Src$Outbound = Src2$Outbound | string;
+/** @internal */
+export declare const Src$outboundSchema: z.ZodType<Src$Outbound, z.ZodTypeDef, Src>;
+/**
+ * @internal
+ * @deprecated This namespace will be removed in future versions. Use schemas and types that are exported directly from this module.
+ */
+export declare namespace Src$ {
+    /** @deprecated use `Src$inboundSchema` instead. */
+    const inboundSchema: z.ZodType<Src, z.ZodTypeDef, unknown>;
+    /** @deprecated use `Src$outboundSchema` instead. */
+    const outboundSchema: z.ZodType<Src$Outbound, z.ZodTypeDef, Src>;
+    /** @deprecated use `Src$Outbound` instead. */
+    type Outbound = Src$Outbound;
+}
+/** @internal */
+export declare const UpdateProjectDataCacheProjectsResponse200ApplicationJSONResponseBodySecurityType$inboundSchema: z.ZodNativeEnum<typeof UpdateProjectDataCacheProjectsResponse200ApplicationJSONResponseBodySecurityType>;
+/** @internal */
+export declare const UpdateProjectDataCacheProjectsResponse200ApplicationJSONResponseBodySecurityType$outboundSchema: z.ZodNativeEnum<typeof UpdateProjectDataCacheProjectsResponse200ApplicationJSONResponseBodySecurityType>;
+/**
+ * @internal
+ * @deprecated This namespace will be removed in future versions. Use schemas and types that are exported directly from this module.
+ */
+export declare namespace UpdateProjectDataCacheProjectsResponse200ApplicationJSONResponseBodySecurityType$ {
+    /** @deprecated use `UpdateProjectDataCacheProjectsResponse200ApplicationJSONResponseBodySecurityType$inboundSchema` instead. */
+    const inboundSchema: z.ZodNativeEnum<{
+        readonly Path: "path";
+        readonly Host: "host";
+        readonly Method: "method";
+        readonly Header: "header";
+        readonly Cookie: "cookie";
+        readonly Query: "query";
+        readonly IpAddress: "ip_address";
+        readonly Protocol: "protocol";
+        readonly Scheme: "scheme";
+        readonly Environment: "environment";
+        readonly Region: "region";
+    }>;
+    /** @deprecated use `UpdateProjectDataCacheProjectsResponse200ApplicationJSONResponseBodySecurityType$outboundSchema` instead. */
+    const outboundSchema: z.ZodNativeEnum<{
+        readonly Path: "path";
+        readonly Host: "host";
+        readonly Method: "method";
+        readonly Header: "header";
+        readonly Cookie: "cookie";
+        readonly Query: "query";
+        readonly IpAddress: "ip_address";
+        readonly Protocol: "protocol";
+        readonly Scheme: "scheme";
+        readonly Environment: "environment";
+        readonly Region: "region";
+    }>;
+}
+/** @internal */
+export declare const UpdateProjectDataCacheValueProjects2$inboundSchema: z.ZodType<UpdateProjectDataCacheValueProjects2, z.ZodTypeDef, unknown>;
+/** @internal */
+export type UpdateProjectDataCacheValueProjects2$Outbound = {
+    re?: string | undefined;
+    eq?: string | undefined;
+    neq?: string | undefined;
+    inc?: Array<string> | undefined;
+    ninc?: Array<string> | undefined;
+    pre?: string | undefined;
+    suf?: string | undefined;
+    gt?: number | undefined;
+    gte?: number | undefined;
+    lt?: number | undefined;
+    lte?: number | undefined;
+};
+/** @internal */
+export declare const UpdateProjectDataCacheValueProjects2$outboundSchema: z.ZodType<UpdateProjectDataCacheValueProjects2$Outbound, z.ZodTypeDef, UpdateProjectDataCacheValueProjects2>;
+/**
+ * @internal
+ * @deprecated This namespace will be removed in future versions. Use schemas and types that are exported directly from this module.
+ */
+export declare namespace UpdateProjectDataCacheValueProjects2$ {
+    /** @deprecated use `UpdateProjectDataCacheValueProjects2$inboundSchema` instead. */
+    const inboundSchema: z.ZodType<UpdateProjectDataCacheValueProjects2, z.ZodTypeDef, unknown>;
+    /** @deprecated use `UpdateProjectDataCacheValueProjects2$outboundSchema` instead. */
+    const outboundSchema: z.ZodType<UpdateProjectDataCacheValueProjects2$Outbound, z.ZodTypeDef, UpdateProjectDataCacheValueProjects2>;
+    /** @deprecated use `UpdateProjectDataCacheValueProjects2$Outbound` instead. */
+    type Outbound = UpdateProjectDataCacheValueProjects2$Outbound;
+}
+/** @internal */
+export declare const UpdateProjectDataCacheProjectsValue$inboundSchema: z.ZodType<UpdateProjectDataCacheProjectsValue, z.ZodTypeDef, unknown>;
+/** @internal */
+export type UpdateProjectDataCacheProjectsValue$Outbound = UpdateProjectDataCacheValueProjects2$Outbound | string;
+/** @internal */
+export declare const UpdateProjectDataCacheProjectsValue$outboundSchema: z.ZodType<UpdateProjectDataCacheProjectsValue$Outbound, z.ZodTypeDef, UpdateProjectDataCacheProjectsValue>;
+/**
+ * @internal
+ * @deprecated This namespace will be removed in future versions. Use schemas and types that are exported directly from this module.
+ */
+export declare namespace UpdateProjectDataCacheProjectsValue$ {
+    /** @deprecated use `UpdateProjectDataCacheProjectsValue$inboundSchema` instead. */
+    const inboundSchema: z.ZodType<UpdateProjectDataCacheProjectsValue, z.ZodTypeDef, unknown>;
+    /** @deprecated use `UpdateProjectDataCacheProjectsValue$outboundSchema` instead. */
+    const outboundSchema: z.ZodType<UpdateProjectDataCacheProjectsValue$Outbound, z.ZodTypeDef, UpdateProjectDataCacheProjectsValue>;
+    /** @deprecated use `UpdateProjectDataCacheProjectsValue$Outbound` instead. */
+    type Outbound = UpdateProjectDataCacheProjectsValue$Outbound;
+}
+/** @internal */
+export declare const Has$inboundSchema: z.ZodType<Has, z.ZodTypeDef, unknown>;
+/** @internal */
+export type Has$Outbound = {
+    type: string;
+    key?: string | undefined;
+    value?: UpdateProjectDataCacheValueProjects2$Outbound | string | undefined;
+};
+/** @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;
+}
+/** @internal */
+export declare const UpdateProjectDataCacheProjectsResponse200ApplicationJSONResponseBodySecurityFirewallRoutesType$inboundSchema: z.ZodNativeEnum<typeof UpdateProjectDataCacheProjectsResponse200ApplicationJSONResponseBodySecurityFirewallRoutesType>;
+/** @internal */
+export declare const UpdateProjectDataCacheProjectsResponse200ApplicationJSONResponseBodySecurityFirewallRoutesType$outboundSchema: z.ZodNativeEnum<typeof UpdateProjectDataCacheProjectsResponse200ApplicationJSONResponseBodySecurityFirewallRoutesType>;
+/**
+ * @internal
+ * @deprecated This namespace will be removed in future versions. Use schemas and types that are exported directly from this module.
+ */
+export declare namespace UpdateProjectDataCacheProjectsResponse200ApplicationJSONResponseBodySecurityFirewallRoutesType$ {
+    /** @deprecated use `UpdateProjectDataCacheProjectsResponse200ApplicationJSONResponseBodySecurityFirewallRoutesType$inboundSchema` instead. */
+    const inboundSchema: z.ZodNativeEnum<{
+        readonly Path: "path";
+        readonly Host: "host";
+        readonly Method: "method";
+        readonly Header: "header";
+        readonly Cookie: "cookie";
+        readonly Query: "query";
+        readonly IpAddress: "ip_address";
+        readonly Protocol: "protocol";
+        readonly Scheme: "scheme";
+        readonly Environment: "environment";
+        readonly Region: "region";
+    }>;
+    /** @deprecated use `UpdateProjectDataCacheProjectsResponse200ApplicationJSONResponseBodySecurityFirewallRoutesType$outboundSchema` instead. */
+    const outboundSchema: z.ZodNativeEnum<{
+        readonly Path: "path";
+        readonly Host: "host";
+        readonly Method: "method";
+        readonly Header: "header";
+        readonly Cookie: "cookie";
+        readonly Query: "query";
+        readonly IpAddress: "ip_address";
+        readonly Protocol: "protocol";
+        readonly Scheme: "scheme";
+        readonly Environment: "environment";
+        readonly Region: "region";
+    }>;
+}
+/** @internal */
+export declare const UpdateProjectDataCacheValue2$inboundSchema: z.ZodType<UpdateProjectDataCacheValue2, z.ZodTypeDef, unknown>;
+/** @internal */
+export type UpdateProjectDataCacheValue2$Outbound = {
+    re?: string | undefined;
+    eq?: string | undefined;
+    neq?: string | undefined;
+    inc?: Array<string> | undefined;
+    ninc?: Array<string> | undefined;
+    pre?: string | undefined;
+    suf?: string | undefined;
+    gt?: number | undefined;
+    gte?: number | undefined;
+    lt?: number | undefined;
+    lte?: number | undefined;
+};
+/** @internal */
+export declare const UpdateProjectDataCacheValue2$outboundSchema: z.ZodType<UpdateProjectDataCacheValue2$Outbound, z.ZodTypeDef, UpdateProjectDataCacheValue2>;
+/**
+ * @internal
+ * @deprecated This namespace will be removed in future versions. Use schemas and types that are exported directly from this module.
+ */
+export declare namespace UpdateProjectDataCacheValue2$ {
+    /** @deprecated use `UpdateProjectDataCacheValue2$inboundSchema` instead. */
+    const inboundSchema: z.ZodType<UpdateProjectDataCacheValue2, z.ZodTypeDef, unknown>;
+    /** @deprecated use `UpdateProjectDataCacheValue2$outboundSchema` instead. */
+    const outboundSchema: z.ZodType<UpdateProjectDataCacheValue2$Outbound, z.ZodTypeDef, UpdateProjectDataCacheValue2>;
+    /** @deprecated use `UpdateProjectDataCacheValue2$Outbound` instead. */
+    type Outbound = UpdateProjectDataCacheValue2$Outbound;
+}
+/** @internal */
+export declare const UpdateProjectDataCacheValue$inboundSchema: z.ZodType<UpdateProjectDataCacheValue, z.ZodTypeDef, unknown>;
+/** @internal */
+export type UpdateProjectDataCacheValue$Outbound = UpdateProjectDataCacheValue2$Outbound | string;
+/** @internal */
+export declare const UpdateProjectDataCacheValue$outboundSchema: z.ZodType<UpdateProjectDataCacheValue$Outbound, z.ZodTypeDef, UpdateProjectDataCacheValue>;
+/**
+ * @internal
+ * @deprecated This namespace will be removed in future versions. Use schemas and types that are exported directly from this module.
+ */
+export declare namespace UpdateProjectDataCacheValue$ {
+    /** @deprecated use `UpdateProjectDataCacheValue$inboundSchema` instead. */
+    const inboundSchema: z.ZodType<UpdateProjectDataCacheValue, z.ZodTypeDef, unknown>;
+    /** @deprecated use `UpdateProjectDataCacheValue$outboundSchema` instead. */
+    const outboundSchema: z.ZodType<UpdateProjectDataCacheValue$Outbound, z.ZodTypeDef, UpdateProjectDataCacheValue>;
+    /** @deprecated use `UpdateProjectDataCacheValue$Outbound` instead. */
+    type Outbound = UpdateProjectDataCacheValue$Outbound;
+}
+/** @internal */
+export declare const Missing$inboundSchema: z.ZodType<Missing, z.ZodTypeDef, unknown>;
+/** @internal */
+export type Missing$Outbound = {
+    type: string;
+    key?: string | undefined;
+    value?: UpdateProjectDataCacheValue2$Outbound | string | undefined;
+};
+/** @internal */
+export declare const Missing$outboundSchema: z.ZodType<Missing$Outbound, z.ZodTypeDef, Missing>;
+/**
+ * @internal
+ * @deprecated This namespace will be removed in future versions. Use schemas and types that are exported directly from this module.
+ */
+export declare namespace Missing$ {
+    /** @deprecated use `Missing$inboundSchema` instead. */
+    const inboundSchema: z.ZodType<Missing, z.ZodTypeDef, unknown>;
+    /** @deprecated use `Missing$outboundSchema` instead. */
+    const outboundSchema: z.ZodType<Missing$Outbound, z.ZodTypeDef, Missing>;
+    /** @deprecated use `Missing$Outbound` instead. */
+    type Outbound = Missing$Outbound;
+}
+/** @internal */
+export declare const Handle$inboundSchema: z.ZodNativeEnum<typeof Handle>;
+/** @internal */
+export declare const Handle$outboundSchema: z.ZodNativeEnum<typeof Handle>;
+/**
+ * @internal
+ * @deprecated This namespace will be removed in future versions. Use schemas and types that are exported directly from this module.
+ */
+export declare namespace Handle$ {
+    /** @deprecated use `Handle$inboundSchema` instead. */
+    const inboundSchema: z.ZodNativeEnum<{
+        readonly Init: "init";
+        readonly Finalize: "finalize";
+    }>;
+    /** @deprecated use `Handle$outboundSchema` instead. */
+    const outboundSchema: z.ZodNativeEnum<{
+        readonly Init: "init";
+        readonly Finalize: "finalize";
+    }>;
+}
+/** @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 Deny: "deny";
+        readonly Challenge: "challenge";
+        readonly Log: "log";
+        readonly Bypass: "bypass";
+        readonly RateLimit: "rate_limit";
+        readonly Redirect: "redirect";
+    }>;
+    /** @deprecated use `UpdateProjectDataCacheAction$outboundSchema` instead. */
+    const outboundSchema: z.ZodNativeEnum<{
+        readonly Deny: "deny";
+        readonly Challenge: "challenge";
+        readonly Log: "log";
+        readonly Bypass: "bypass";
+        readonly RateLimit: "rate_limit";
+        readonly Redirect: "redirect";
+    }>;
+}
+/** @internal */
+export declare const UpdateProjectDataCacheAlgo$inboundSchema: z.ZodNativeEnum<typeof UpdateProjectDataCacheAlgo>;
+/** @internal */
+export declare const UpdateProjectDataCacheAlgo$outboundSchema: z.ZodNativeEnum<typeof UpdateProjectDataCacheAlgo>;
+/**
+ * @internal
+ * @deprecated This namespace will be removed in future versions. Use schemas and types that are exported directly from this module.
+ */
+export declare namespace UpdateProjectDataCacheAlgo$ {
+    /** @deprecated use `UpdateProjectDataCacheAlgo$inboundSchema` instead. */
+    const inboundSchema: z.ZodNativeEnum<{
+        readonly FixedWindow: "fixed_window";
+        readonly TokenBucket: "token_bucket";
+    }>;
+    /** @deprecated use `UpdateProjectDataCacheAlgo$outboundSchema` instead. */
+    const outboundSchema: z.ZodNativeEnum<{
+        readonly FixedWindow: "fixed_window";
+        readonly TokenBucket: "token_bucket";
+    }>;
+}
+/** @internal */
+export declare const Erl$inboundSchema: z.ZodType<Erl, z.ZodTypeDef, unknown>;
+/** @internal */
+export type Erl$Outbound = {
+    algo: string;
+    window: number;
+    limit: number;
+    keys: Array<string>;
+};
+/** @internal */
+export declare const Erl$outboundSchema: z.ZodType<Erl$Outbound, z.ZodTypeDef, Erl>;
+/**
+ * @internal
+ * @deprecated This namespace will be removed in future versions. Use schemas and types that are exported directly from this module.
+ */
+export declare namespace Erl$ {
+    /** @deprecated use `Erl$inboundSchema` instead. */
+    const inboundSchema: z.ZodType<Erl, z.ZodTypeDef, unknown>;
+    /** @deprecated use `Erl$outboundSchema` instead. */
+    const outboundSchema: z.ZodType<Erl$Outbound, z.ZodTypeDef, Erl>;
+    /** @deprecated use `Erl$Outbound` instead. */
+    type Outbound = Erl$Outbound;
+}
+/** @internal */
+export declare const UpdateProjectDataCacheMitigate$inboundSchema: z.ZodType<UpdateProjectDataCacheMitigate, z.ZodTypeDef, unknown>;
+/** @internal */
+export type UpdateProjectDataCacheMitigate$Outbound = {
+    action: string;
+    rule_id: string;
+    ttl?: number | undefined;
+    erl?: Erl$Outbound | undefined;
+};
+/** @internal */
+export declare const UpdateProjectDataCacheMitigate$outboundSchema: z.ZodType<UpdateProjectDataCacheMitigate$Outbound, z.ZodTypeDef, UpdateProjectDataCacheMitigate>;
+/**
+ * @internal
+ * @deprecated This namespace will be removed in future versions. Use schemas and types that are exported directly from this module.
+ */
+export declare namespace UpdateProjectDataCacheMitigate$ {
+    /** @deprecated use `UpdateProjectDataCacheMitigate$inboundSchema` instead. */
+    const inboundSchema: z.ZodType<UpdateProjectDataCacheMitigate, z.ZodTypeDef, unknown>;
+    /** @deprecated use `UpdateProjectDataCacheMitigate$outboundSchema` instead. */
+    const outboundSchema: z.ZodType<UpdateProjectDataCacheMitigate$Outbound, z.ZodTypeDef, UpdateProjectDataCacheMitigate>;
+    /** @deprecated use `UpdateProjectDataCacheMitigate$Outbound` instead. */
+    type Outbound = UpdateProjectDataCacheMitigate$Outbound;
+}
+/** @internal */
+export declare const FirewallRoutes$inboundSchema: z.ZodType<FirewallRoutes, z.ZodTypeDef, unknown>;
+/** @internal */
+export type FirewallRoutes$Outbound = {
+    src?: Src2$Outbound | string | undefined;
+    has?: Array<Has$Outbound> | undefined;
+    missing?: Array<Missing$Outbound> | undefined;
+    dest?: string | undefined;
+    status?: number | undefined;
+    handle?: string | undefined;
+    mitigate?: UpdateProjectDataCacheMitigate$Outbound | undefined;
+};
+/** @internal */
+export declare const FirewallRoutes$outboundSchema: z.ZodType<FirewallRoutes$Outbound, z.ZodTypeDef, FirewallRoutes>;
+/**
+ * @internal
+ * @deprecated This namespace will be removed in future versions. Use schemas and types that are exported directly from this module.
+ */
+export declare namespace FirewallRoutes$ {
+    /** @deprecated use `FirewallRoutes$inboundSchema` instead. */
+    const inboundSchema: z.ZodType<FirewallRoutes, z.ZodTypeDef, unknown>;
+    /** @deprecated use `FirewallRoutes$outboundSchema` instead. */
+    const outboundSchema: z.ZodType<FirewallRoutes$Outbound, z.ZodTypeDef, FirewallRoutes>;
+    /** @deprecated use `FirewallRoutes$Outbound` instead. */
+    type Outbound = FirewallRoutes$Outbound;
+}
+/** @internal */
+export declare const Security$inboundSchema: z.ZodType<Security, z.ZodTypeDef, unknown>;
+/** @internal */
+export type Security$Outbound = {
+    attackModeEnabled?: boolean | undefined;
+    attackModeUpdatedAt?: number | undefined;
+    firewallEnabled?: boolean | undefined;
+    firewallUpdatedAt?: number | undefined;
+    attackModeActiveUntil?: number | null | undefined;
+    firewallConfigVersion?: number | undefined;
+    firewallRoutes?: Array<FirewallRoutes$Outbound> | undefined;
+    firewallSeawallEnabled?: boolean | undefined;
+    ja3Enabled?: boolean | undefined;
+    ja4Enabled?: boolean | undefined;
+};
+/** @internal */
+export declare const Security$outboundSchema: z.ZodType<Security$Outbound, z.ZodTypeDef, Security>;
+/**
+ * @internal
+ * @deprecated This namespace will be removed in future versions. Use schemas and types that are exported directly from this module.
+ */
+export declare namespace Security$ {
+    /** @deprecated use `Security$inboundSchema` instead. */
+    const inboundSchema: z.ZodType<Security, z.ZodTypeDef, unknown>;
+    /** @deprecated use `Security$outboundSchema` instead. */
+    const outboundSchema: z.ZodType<Security$Outbound, z.ZodTypeDef, Security>;
+    /** @deprecated use `Security$Outbound` instead. */
+    type Outbound = Security$Outbound;
+}
+/** @internal */
+export declare const UpdateProjectDataCacheIssuerMode$inboundSchema: z.ZodNativeEnum<typeof UpdateProjectDataCacheIssuerMode>;
+/** @internal */
+export declare const UpdateProjectDataCacheIssuerMode$outboundSchema: z.ZodNativeEnum<typeof UpdateProjectDataCacheIssuerMode>;
+/**
+ * @internal
+ * @deprecated This namespace will be removed in future versions. Use schemas and types that are exported directly from this module.
+ */
+export declare namespace UpdateProjectDataCacheIssuerMode$ {
+    /** @deprecated use `UpdateProjectDataCacheIssuerMode$inboundSchema` instead. */
+    const inboundSchema: z.ZodNativeEnum<{
+        readonly Team: "team";
+        readonly Global: "global";
+    }>;
+    /** @deprecated use `UpdateProjectDataCacheIssuerMode$outboundSchema` instead. */
+    const outboundSchema: z.ZodNativeEnum<{
+        readonly Team: "team";
+        readonly Global: "global";
+    }>;
+}
+/** @internal */
+export declare const UpdateProjectDataCacheOidcTokenConfig$inboundSchema: z.ZodType<UpdateProjectDataCacheOidcTokenConfig, z.ZodTypeDef, unknown>;
+/** @internal */
+export type UpdateProjectDataCacheOidcTokenConfig$Outbound = {
+    enabled: boolean;
+    issuerMode?: string | undefined;
+};
+/** @internal */
+export declare const UpdateProjectDataCacheOidcTokenConfig$outboundSchema: z.ZodType<UpdateProjectDataCacheOidcTokenConfig$Outbound, z.ZodTypeDef, UpdateProjectDataCacheOidcTokenConfig>;
+/**
+ * @internal
+ * @deprecated This namespace will be removed in future versions. Use schemas and types that are exported directly from this module.
+ */
+export declare namespace UpdateProjectDataCacheOidcTokenConfig$ {
+    /** @deprecated use `UpdateProjectDataCacheOidcTokenConfig$inboundSchema` instead. */
+    const inboundSchema: z.ZodType<UpdateProjectDataCacheOidcTokenConfig, z.ZodTypeDef, unknown>;
+    /** @deprecated use `UpdateProjectDataCacheOidcTokenConfig$outboundSchema` instead. */
+    const outboundSchema: z.ZodType<UpdateProjectDataCacheOidcTokenConfig$Outbound, z.ZodTypeDef, UpdateProjectDataCacheOidcTokenConfig>;
+    /** @deprecated use `UpdateProjectDataCacheOidcTokenConfig$Outbound` instead. */
+    type Outbound = UpdateProjectDataCacheOidcTokenConfig$Outbound;
+}
+/** @internal */
+export declare const Tier$inboundSchema: z.ZodNativeEnum<typeof Tier>;
+/** @internal */
+export declare const Tier$outboundSchema: z.ZodNativeEnum<typeof Tier>;
+/**
+ * @internal
+ * @deprecated This namespace will be removed in future versions. Use schemas and types that are exported directly from this module.
+ */
+export declare namespace Tier$ {
+    /** @deprecated use `Tier$inboundSchema` instead. */
+    const inboundSchema: z.ZodNativeEnum<{
+        readonly Standard: "standard";
+        readonly Advanced: "advanced";
+        readonly Critical: "critical";
+    }>;
+    /** @deprecated use `Tier$outboundSchema` instead. */
+    const outboundSchema: z.ZodNativeEnum<{
+        readonly Standard: "standard";
+        readonly Advanced: "advanced";
+        readonly Critical: "critical";
+    }>;
+}
+/** @internal */
+export declare const UpdateProjectDataCacheResponseBody$inboundSchema: z.ZodType<UpdateProjectDataCacheResponseBody, z.ZodTypeDef, unknown>;
+/** @internal */
+export type UpdateProjectDataCacheResponseBody$Outbound = {
+    accountId: string;
+    analytics?: Analytics$Outbound | undefined;
+    speedInsights?: SpeedInsights$Outbound | undefined;
+    autoExposeSystemEnvs?: boolean | undefined;
+    autoAssignCustomDomains?: boolean | undefined;
+    autoAssignCustomDomainsUpdatedBy?: string | undefined;
+    buildCommand?: string | null | undefined;
+    commandForIgnoringBuildStep?: string | null | undefined;
+    connectConfigurationId?: string | null | undefined;
+    connectBuildsEnabled?: boolean | undefined;
+    createdAt?: number | undefined;
+    customerSupportCodeVisibility?: boolean | undefined;
+    crons?: Crons$Outbound | undefined;
+    dataCache?: DataCache$Outbound | undefined;
+    deploymentExpiration?: DeploymentExpiration$Outbound | null | undefined;
+    devCommand?: string | null | undefined;
+    directoryListing: boolean;
+    installCommand?: string | null | undefined;
+    env?: Array<Env$Outbound> | undefined;
+    customEnvironments?: Array<CustomEnvironments$Outbound> | undefined;
+    framework?: string | null | undefined;
+    gitForkProtection?: boolean | undefined;
+    gitLFS?: boolean | undefined;
+    id: string;
+    ipBuckets?: Array<IpBuckets$Outbound> | undefined;
+    latestDeployments?: Array<LatestDeployments$Outbound> | undefined;
+    link?: Link1$Outbound | Link3$Outbound | Link2$Outbound | undefined;
+    microfrontends?: Microfrontends$Outbound | undefined;
+    name: string;
+    nodeVersion: string;
+    optionsAllowlist?: UpdateProjectDataCacheOptionsAllowlist$Outbound | null | undefined;
+    outputDirectory?: string | null | undefined;
+    passiveConnectConfigurationId?: string | null | undefined;
+    passwordProtection?: UpdateProjectDataCachePasswordProtection$Outbound | null | undefined;
+    productionDeploymentsFastLane?: boolean | undefined;
+    publicSource?: boolean | null | undefined;
+    resourceConfig?: ResourceConfig$Outbound | undefined;
+    rootDirectory?: string | null | undefined;
+    serverlessFunctionRegion?: string | null | undefined;
+    serverlessFunctionZeroConfigFailover?: boolean | undefined;
+    skewProtectionBoundaryAt?: number | undefined;
+    skewProtectionMaxAge?: number | undefined;
+    skipGitConnectDuringLink?: boolean | undefined;
+    sourceFilesOutsideRootDirectory?: boolean | undefined;
+    enableAffectedProjectsDeployments?: boolean | undefined;
+    ssoProtection?: UpdateProjectDataCacheSsoProtection$Outbound | null | undefined;
+    targets?: {
+        [k: string]: Targets$Outbound;
+    } | undefined;
+    transferCompletedAt?: number | undefined;
+    transferStartedAt?: number | undefined;
+    transferToAccountId?: string | undefined;
+    transferredFromAccountId?: string | undefined;
+    updatedAt?: number | undefined;
+    live?: boolean | undefined;
+    enablePreviewFeedback?: boolean | null | undefined;
+    enableProductionFeedback?: boolean | null | undefined;
+    permissions?: Permissions$Outbound | undefined;
+    lastRollbackTarget?: LastRollbackTarget$Outbound | null | undefined;
+    lastAliasRequest?: LastAliasRequest$Outbound | null | undefined;
+    hasFloatingAliases?: boolean | undefined;
+    protectionBypass?: {
+        [k: string]: ProtectionBypass$Outbound;
+    } | undefined;
+    hasActiveBranches?: boolean | undefined;
+    trustedIps?: TrustedIps2$Outbound | TrustedIps1$Outbound | null | undefined;
+    gitComments?: GitComments$Outbound | undefined;
+    paused?: boolean | undefined;
+    concurrencyBucketName?: string | undefined;
+    webAnalytics?: WebAnalytics$Outbound | undefined;
+    security?: Security$Outbound | undefined;
+    oidcTokenConfig?: UpdateProjectDataCacheOidcTokenConfig$Outbound | undefined;
+    tier?: string | undefined;
+};
+/** @internal */
+export declare const UpdateProjectDataCacheResponseBody$outboundSchema: z.ZodType<UpdateProjectDataCacheResponseBody$Outbound, z.ZodTypeDef, UpdateProjectDataCacheResponseBody>;
+/**
+ * @internal
+ * @deprecated This namespace will be removed in future versions. Use schemas and types that are exported directly from this module.
+ */
+export declare namespace UpdateProjectDataCacheResponseBody$ {
+    /** @deprecated use `UpdateProjectDataCacheResponseBody$inboundSchema` instead. */
+    const inboundSchema: z.ZodType<UpdateProjectDataCacheResponseBody, z.ZodTypeDef, unknown>;
+    /** @deprecated use `UpdateProjectDataCacheResponseBody$outboundSchema` instead. */
+    const outboundSchema: z.ZodType<UpdateProjectDataCacheResponseBody$Outbound, z.ZodTypeDef, UpdateProjectDataCacheResponseBody>;
+    /** @deprecated use `UpdateProjectDataCacheResponseBody$Outbound` instead. */
+    type Outbound = UpdateProjectDataCacheResponseBody$Outbound;
+}
+//# sourceMappingURL=updateprojectdatacache.d.ts.map