@distilled.cloud/vercel 0.0.0 → 1.0.0-rc.10

package/lib/services/teams.d.ts

@@ -0,0 +1,1600 @@
+import * as S from "@distilled.cloud/core/schema";
+import * as Redacted from "effect/Redacted";
+import * as API from "@distilled.cloud/core/api";
+import { type VercelOpError, type VercelOpContext } from "../protocol.ts";
+export type { VercelOpError, VercelOpContext };
+declare const BadRequest_base: S.Class<BadRequest, S.TaggedStruct<"BadRequest", {
+    readonly code: any;
+    readonly message: any;
+}>, import("effect/Cause").YieldableError> & (new (...args: any[]) => {
+    "@distilled.cloud/error/categories": {
+        BadRequestError: true;
+    };
+});
+export declare class BadRequest extends /*@__PURE__*/ BadRequest_base {
+}
+declare const Conflict_base: S.Class<Conflict, S.TaggedStruct<"Conflict", {
+    readonly code: any;
+    readonly message: any;
+}>, import("effect/Cause").YieldableError> & (new (...args: any[]) => {
+    "@distilled.cloud/error/categories": {
+        ConflictError: true;
+    };
+});
+export declare class Conflict extends /*@__PURE__*/ Conflict_base {
+}
+declare const Forbidden_base: S.Class<Forbidden, S.TaggedStruct<"Forbidden", {
+    readonly code: any;
+    readonly message: any;
+}>, import("effect/Cause").YieldableError> & (new (...args: any[]) => {
+    "@distilled.cloud/error/categories": {
+        AuthError: true;
+    };
+});
+export declare class Forbidden extends /*@__PURE__*/ Forbidden_base {
+}
+declare const NotFound_base: S.Class<NotFound, S.TaggedStruct<"NotFound", {
+    readonly code: any;
+    readonly message: any;
+}>, import("effect/Cause").YieldableError> & (new (...args: any[]) => {
+    "@distilled.cloud/error/categories": {
+        BadRequestError: true;
+    };
+});
+export declare class NotFound extends /*@__PURE__*/ NotFound_base {
+}
+declare const PaymentRequired_base: S.Class<PaymentRequired, S.TaggedStruct<"PaymentRequired", {
+    readonly code: any;
+    readonly message: any;
+}>, import("effect/Cause").YieldableError> & (new (...args: any[]) => {
+    "@distilled.cloud/error/categories": {
+        QuotaError: true;
+    };
+});
+export declare class PaymentRequired extends /*@__PURE__*/ PaymentRequired_base {
+}
+export interface CreateTeamRequestAttributionUtm {
+    /** UTM source */
+    utmSource?: string;
+    /** UTM medium */
+    utmMedium?: string;
+    /** UTM campaign */
+    utmCampaign?: string;
+    /** UTM term */
+    utmTerm?: string;
+}
+export declare const CreateTeamRequestAttributionUtm: S.Schema<CreateTeamRequestAttributionUtm>;
+/** Attribution information for the session or current page */
+export interface CreateTeamRequestAttribution {
+    /** Session referrer */
+    sessionReferrer?: string;
+    /** Session landing page */
+    landingPage?: string;
+    /** Referrer to the signup page */
+    pageBeforeConversionPage?: string;
+    utm?: CreateTeamRequestAttributionUtm;
+}
+export declare const CreateTeamRequestAttribution: S.Schema<CreateTeamRequestAttribution>;
+export interface CreateTeamRequest {
+    /** The desired slug for the Team */
+    slug: string;
+    /** The desired name for the Team. It will be generated from the provided slug if nothing is provided */
+    name?: string;
+    /** Attribution information for the session or current page */
+    attribution?: CreateTeamRequestAttribution;
+}
+export declare const CreateTeamRequest: S.Schema<CreateTeamRequest>;
+export interface CreateTeamResponse {
+    /** Id of the created team */
+    id: string;
+    slug: string;
+}
+export declare const CreateTeamResponse: S.Schema<CreateTeamResponse>;
+export type CreateTeamDsyncRoleRequestRolesValueCase0 = "OWNER" | "MEMBER" | "DEVELOPER" | "SECURITY" | "BILLING" | "VIEWER" | "VIEWER_FOR_PLUS" | "CONTRIBUTOR";
+export declare const CreateTeamDsyncRoleRequestRolesValueCase0: any;
+export interface CreateTeamDsyncRoleRequestRolesValueCase1 {
+    accessGroupId: string;
+}
+export declare const CreateTeamDsyncRoleRequestRolesValueCase1: S.Schema<CreateTeamDsyncRoleRequestRolesValueCase1>;
+export type CreateTeamDsyncRoleRequestRolesValue = CreateTeamDsyncRoleRequestRolesValueCase0 | CreateTeamDsyncRoleRequestRolesValueCase1;
+export declare const CreateTeamDsyncRoleRequestRolesValue: S.Schema<CreateTeamDsyncRoleRequestRolesValue>;
+/** Directory groups to role or access group mappings. */
+export type CreateTeamDsyncRoleRequestRolesMap = {
+    [key: string]: CreateTeamDsyncRoleRequestRolesValue | undefined;
+};
+export declare const CreateTeamDsyncRoleRequestRolesMap: S.Schema<CreateTeamDsyncRoleRequestRolesMap>;
+export interface CreateTeamDsyncRoleRequest {
+    /** The Team identifier to perform the request on behalf of. */
+    teamId: string;
+    /** The Team slug to perform the request on behalf of. */
+    slug?: string;
+    /** Directory groups to role or access group mappings. */
+    roles: CreateTeamDsyncRoleRequestRolesMap;
+}
+export declare const CreateTeamDsyncRoleRequest: S.Schema<CreateTeamDsyncRoleRequest>;
+export interface CreateTeamDsyncRoleResponse {
+    ok: boolean;
+}
+export declare const CreateTeamDsyncRoleResponse: S.Schema<CreateTeamDsyncRoleResponse>;
+export interface DeleteMicrofrontendsGroupRequest {
+    /** The Team identifier to perform the request on behalf of. */
+    teamId: string;
+    /** The microfrontend group ID to delete. */
+    groupId: string;
+    /** The Team slug to perform the request on behalf of. */
+    slug?: string;
+}
+export declare const DeleteMicrofrontendsGroupRequest: S.Schema<DeleteMicrofrontendsGroupRequest>;
+export type DeleteMicrofrontendsGroupResponse = unknown;
+export declare const DeleteMicrofrontendsGroupResponse: S.Schema<DeleteMicrofrontendsGroupResponse>;
+/** An object describing the reason why the team is being deleted. */
+export interface DeleteTeamRequestReasonsItem {
+    /** Idenitifier slug of the reason why the team is being deleted. */
+    slug: string;
+    /** Description of the reason why the team is being deleted. */
+    description: string;
+}
+export declare const DeleteTeamRequestReasonsItem: S.Schema<DeleteTeamRequestReasonsItem>;
+/** Optional array of objects that describe the reason why the team is being deleted. */
+export type DeleteTeamRequestReasonsList = Array<DeleteTeamRequestReasonsItem>;
+export declare const DeleteTeamRequestReasonsList: S.Schema<DeleteTeamRequestReasonsList>;
+export interface DeleteTeamRequest {
+    /** The Team identifier to perform the request on behalf of. */
+    teamId: string;
+    /** Id of the team to be set as the new default team */
+    newDefaultTeamId?: string;
+    /** The Team slug to perform the request on behalf of. */
+    slug?: string;
+    /** Optional array of objects that describe the reason why the team is being deleted. */
+    reasons?: DeleteTeamRequestReasonsList;
+}
+export declare const DeleteTeamRequest: S.Schema<DeleteTeamRequest>;
+export interface DeleteTeamResponse {
+    /** The ID of the deleted Team */
+    id: string;
+    /** Signifies whether the default team update has failed, when newDefaultTeamId is provided in request query. */
+    newDefaultTeamIdError?: boolean;
+}
+export declare const DeleteTeamResponse: S.Schema<DeleteTeamResponse>;
+export interface DeleteTeamInviteCodeRequest {
+    /** The Team identifier to perform the request on behalf of. */
+    teamId: string;
+    /** The Team invite code ID. */
+    inviteId: string;
+}
+export declare const DeleteTeamInviteCodeRequest: S.Schema<DeleteTeamInviteCodeRequest>;
+export interface DeleteTeamInviteCodeResponse {
+    /** ID of the team. */
+    id: string;
+}
+export declare const DeleteTeamInviteCodeResponse: S.Schema<DeleteTeamInviteCodeResponse>;
+export interface GetTeamRequest {
+    /** The Team identifier to perform the request on behalf of. */
+    teamId: string;
+    slug?: string;
+}
+export declare const GetTeamRequest: S.Schema<GetTeamRequest>;
+export interface TeamConnect {
+    enabled?: boolean;
+}
+export declare const TeamConnect: S.Schema<TeamConnect>;
+/** Controls whether directory sync events are processed. - 'SETUP': Directory connected but role mappings not yet configured. Events are acknowledged but not processed. - 'ACTIVE': Fully configured. Events are processed normally. - undefined: Legacy directory (pre-feature), treat as 'ACTIVE' for backwards compatibility. */
+export type TeamSamlConnectionSyncState = "ACTIVE" | "SETUP";
+export declare const TeamSamlConnectionSyncState: any;
+/** Information for the SAML Single Sign-On configuration. */
+export interface TeamSamlConnection {
+    /** The Identity Provider "type", for example Okta. */
+    type: string;
+    /** Current state of the connection. */
+    state: string;
+    /** Timestamp (in milliseconds) of when the configuration was connected. */
+    connectedAt: number;
+    /** Timestamp (in milliseconds) of when the last webhook event was received from WorkOS. */
+    lastReceivedWebhookEvent?: number;
+    /** Timestamp (in milliseconds) of when the last directory sync was performed. */
+    lastSyncedAt?: number;
+    /** Controls whether directory sync events are processed. - 'SETUP': Directory connected but role mappings not yet configured. Events are acknowledged but not processed. - 'ACTIVE': Fully configured. Events are processed normally. - undefined: Legacy directory (pre-feature), treat as 'ACTIVE' for backwards compatibility. */
+    syncState?: TeamSamlConnectionSyncState;
+    status: string;
+}
+export declare const TeamSamlConnection: S.Schema<TeamSamlConnection>;
+/** Controls whether directory sync events are processed. - 'SETUP': Directory connected but role mappings not yet configured. Events are acknowledged but not processed. - 'ACTIVE': Fully configured. Events are processed normally. - undefined: Legacy directory (pre-feature), treat as 'ACTIVE' for backwards compatibility. */
+export type TeamSamlDirectorySyncState = "ACTIVE" | "SETUP";
+export declare const TeamSamlDirectorySyncState: any;
+/** Information for the Directory Sync configuration. */
+export interface TeamSamlDirectory {
+    /** The Identity Provider "type", for example Okta. */
+    type: string;
+    /** Current state of the connection. */
+    state: string;
+    /** Timestamp (in milliseconds) of when the configuration was connected. */
+    connectedAt: number;
+    /** Timestamp (in milliseconds) of when the last webhook event was received from WorkOS. */
+    lastReceivedWebhookEvent?: number;
+    /** Timestamp (in milliseconds) of when the last directory sync was performed. */
+    lastSyncedAt?: number;
+    /** Controls whether directory sync events are processed. - 'SETUP': Directory connected but role mappings not yet configured. Events are acknowledged but not processed. - 'ACTIVE': Fully configured. Events are processed normally. - undefined: Legacy directory (pre-feature), treat as 'ACTIVE' for backwards compatibility. */
+    syncState?: TeamSamlDirectorySyncState;
+}
+export declare const TeamSamlDirectory: S.Schema<TeamSamlDirectory>;
+/** The default redirect URI to use after successful SAML authentication. */
+export type TeamSamlDefaultRedirectUri = "v0.app" | "v0.dev" | "vercel.com";
+export declare const TeamSamlDefaultRedirectUri: any;
+/** When "Directory Sync" is configured, this object contains a mapping of which Directory Group (by ID) should be assigned to which Vercel Team "role". */
+export type TeamSamlRolesValueCase0 = CreateTeamDsyncRoleRequestRolesValueCase1;
+export declare const TeamSamlRolesValueCase0: S.Schema<CreateTeamDsyncRoleRequestRolesValueCase1>;
+export type TeamSamlRolesValueCase1 = "BILLING" | "CONTRIBUTOR" | "DEVELOPER" | "MEMBER" | "OWNER" | "SECURITY" | "VIEWER" | "VIEWER_FOR_PLUS";
+export declare const TeamSamlRolesValueCase1: any;
+export type TeamSamlRolesValue = CreateTeamDsyncRoleRequestRolesValueCase1 | TeamSamlRolesValueCase1;
+export declare const TeamSamlRolesValue: S.Schema<TeamSamlRolesValue>;
+/** When "Directory Sync" is configured, this object contains a mapping of which Directory Group (by ID) should be assigned to which Vercel Team "role". */
+export type TeamSamlRolesMap = {
+    [key: string]: TeamSamlRolesValue | undefined;
+};
+export declare const TeamSamlRolesMap: S.Schema<TeamSamlRolesMap>;
+/** When "Single Sign-On (SAML)" is configured, this object contains information regarding the configuration of the Identity Provider (IdP). */
+export interface TeamSaml {
+    /** Information for the SAML Single Sign-On configuration. */
+    connection?: TeamSamlConnection;
+    /** Information for the Directory Sync configuration. */
+    directory?: TeamSamlDirectory;
+    /** When `true`, interactions with the Team **must** be done with an authentication token that has been authenticated with the Team's SAML Single Sign-On provider. */
+    enforced: boolean;
+    /** The default redirect URI to use after successful SAML authentication. */
+    defaultRedirectUri?: TeamSamlDefaultRedirectUri;
+    /** When "Directory Sync" is configured, this object contains a mapping of which Directory Group (by ID) should be assigned to which Vercel Team "role". */
+    roles?: TeamSamlRolesMap;
+}
+export declare const TeamSaml: S.Schema<TeamSaml>;
+export type TeamBillingPlan = "enterprise" | "hobby" | "pro";
+export declare const TeamBillingPlan: any;
+/** The team's billing plan. */
+export interface TeamBilling {
+    plan: TeamBillingPlan;
+}
+export declare const TeamBilling: S.Schema<TeamBilling>;
+export type TeamDefaultRolesTeamRolesItem = "BILLING" | "CONTRIBUTOR" | "DEVELOPER" | "MEMBER" | "OWNER" | "SECURITY" | "VIEWER" | "VIEWER_FOR_PLUS";
+export declare const TeamDefaultRolesTeamRolesItem: any;
+export type TeamDefaultRolesTeamRolesList = Array<TeamDefaultRolesTeamRolesItem>;
+export declare const TeamDefaultRolesTeamRolesList: S.Schema<TeamDefaultRolesTeamRolesList>;
+export type TeamDefaultRolesTeamPermissionsItem = "AiGatewayApiKeyOwnedBySelf" | "AiGatewayBudgetManager" | "AiGatewayCredits" | "AiGatewaySettings" | "AiGatewayTranscriptsManager" | "AiGatewayTranscriptsViewer" | "ConnectorManager" | "CreateProject" | "EnvVariableManager" | "EnvironmentManager" | "FullProductionDeployment" | "IntegrationManager" | "OrgAdmin" | "OrgViewer" | "UsageViewer" | "V0Builder" | "V0Chatter" | "V0Viewer" | "WorkflowDecryptor";
+export declare const TeamDefaultRolesTeamPermissionsItem: any;
+export type TeamDefaultRolesTeamPermissionsList = Array<TeamDefaultRolesTeamPermissionsItem>;
+export declare const TeamDefaultRolesTeamPermissionsList: S.Schema<TeamDefaultRolesTeamPermissionsList>;
+/** Default roles for the team. */
+export interface TeamDefaultRoles {
+    teamRoles?: TeamDefaultRolesTeamRolesList;
+    teamPermissions?: TeamDefaultRolesTeamPermissionsList;
+}
+export declare const TeamDefaultRoles: S.Schema<TeamDefaultRoles>;
+export interface TeamResourceConfigBuildEntitlements {
+    enhancedBuilds?: boolean;
+}
+export declare const TeamResourceConfigBuildEntitlements: S.Schema<TeamResourceConfigBuildEntitlements>;
+/** Default build machine type for new builds */
+export type TeamResourceConfigBuildMachineDefault = "basic" | "elastic" | "enhanced" | "standard" | "turbo";
+export declare const TeamResourceConfigBuildMachineDefault: any;
+/** Build machine configuration */
+export interface TeamResourceConfigBuildMachine {
+    /** Default build machine type for new builds */
+    default?: TeamResourceConfigBuildMachineDefault;
+}
+export declare const TeamResourceConfigBuildMachine: S.Schema<TeamResourceConfigBuildMachine>;
+export interface TeamResourceConfig {
+    /** The total amount of concurrent builds that can be used. */
+    concurrentBuilds?: number;
+    /** Whether every build for this team / user has elastic concurrency enabled automatically. */
+    elasticConcurrencyEnabled?: boolean;
+    /** The maximum size in kilobytes of an Edge Config. Only specified if a custom limit is set. */
+    edgeConfigSize?: number;
+    /** The maximum number of edge configs an account can create. */
+    edgeConfigs?: number;
+    /** The maximum number of kv databases an account can create. */
+    kvDatabases?: number;
+    /** The maximum number of blob stores an account can create. */
+    blobStores?: number;
+    /** The maximum number of postgres databases an account can create. */
+    postgresDatabases?: number;
+    /** The maximum number of custom environments allowed per project. */
+    customEnvironmentsPerProject?: number;
+    /** The maximum memory size (in MB) for a serverless function. Only specified if a custom limit is set. */
+    serverlessFunctionMaxMemorySize?: number;
+    buildEntitlements?: TeamResourceConfigBuildEntitlements;
+    /** Build machine configuration */
+    buildMachine?: TeamResourceConfigBuildMachine;
+}
+export declare const TeamResourceConfig: S.Schema<TeamResourceConfig>;
+export type TeamDisableHardAutoBlocks = number | boolean;
+export declare const TeamDisableHardAutoBlocks: S.Schema<TeamDisableHardAutoBlocks>;
+/** Is remote caching enabled for this team */
+export type TeamRemoteCaching = TeamConnect;
+export declare const TeamRemoteCaching: S.Schema<TeamConnect>;
+export interface TeamDefaultDeploymentProtectionPasswordProtection {
+    deploymentType: string;
+}
+export declare const TeamDefaultDeploymentProtectionPasswordProtection: S.Schema<TeamDefaultDeploymentProtectionPasswordProtection>;
+export type TeamDefaultDeploymentProtectionSsoProtection = TeamDefaultDeploymentProtectionPasswordProtection;
+export declare const TeamDefaultDeploymentProtectionSsoProtection: S.Schema<TeamDefaultDeploymentProtectionPasswordProtection>;
+/** Default deployment protection for this team null indicates protection is disabled */
+export interface TeamDefaultDeploymentProtection {
+    passwordProtection?: TeamDefaultDeploymentProtectionPasswordProtection | null;
+    ssoProtection?: TeamDefaultDeploymentProtectionPasswordProtection | null;
+}
+export declare const TeamDefaultDeploymentProtection: S.Schema<TeamDefaultDeploymentProtection>;
+/** Default Passport configuration for new projects in this team. */
+export type TeamDefaultPassportDeploymentType = "all" | "all_except_custom_domains" | "preview" | "prod_deployment_urls_and_all_previews";
+export declare const TeamDefaultPassportDeploymentType: any;
+/** Default Passport configuration for new projects in this team. */
+export interface TeamDefaultPassport {
+    /** Default Passport configuration for new projects in this team. */
+    connectorId: string;
+    /** Default Passport configuration for new projects in this team. */
+    deploymentType: TeamDefaultPassportDeploymentType;
+}
+export declare const TeamDefaultPassport: S.Schema<TeamDefaultPassport>;
+/** Default deployment expiration settings for this team */
+export interface TeamDefaultExpirationSettings {
+    /** Number of days to keep non-production deployments (mostly preview deployments) before soft deletion. */
+    expirationDays?: number;
+    /** Number of days to keep production deployments before soft deletion. */
+    expirationDaysProduction?: number;
+    /** Number of days to keep canceled deployments before soft deletion. */
+    expirationDaysCanceled?: number;
+    /** Number of days to keep errored deployments before soft deletion. */
+    expirationDaysErrored?: number;
+    /** Minimum number of production deployments to keep for this project, even if they are over the production expiration limit. */
+    deploymentsToKeep?: number;
+}
+export declare const TeamDefaultExpirationSettings: S.Schema<TeamDefaultExpirationSettings>;
+/** Default job configuration applied to new projects created in this team. */
+export type TeamDefaultProjectJobsLintTargetsList = Array<string>;
+export declare const TeamDefaultProjectJobsLintTargetsList: S.Schema<TeamDefaultProjectJobsLintTargetsList>;
+/** Default job configuration applied to new projects created in this team. */
+export interface TeamDefaultProjectJobsLint {
+    /** Default job configuration applied to new projects created in this team. */
+    targets: TeamDefaultProjectJobsLintTargetsList;
+}
+export declare const TeamDefaultProjectJobsLint: S.Schema<TeamDefaultProjectJobsLint>;
+/** Default job configuration applied to new projects created in this team. */
+export type TeamDefaultProjectJobsTypecheckTargetsList = Array<string>;
+export declare const TeamDefaultProjectJobsTypecheckTargetsList: S.Schema<TeamDefaultProjectJobsTypecheckTargetsList>;
+/** Default job configuration applied to new projects created in this team. */
+export interface TeamDefaultProjectJobsTypecheck {
+    /** Default job configuration applied to new projects created in this team. */
+    targets: TeamDefaultProjectJobsTypecheckTargetsList;
+}
+export declare const TeamDefaultProjectJobsTypecheck: S.Schema<TeamDefaultProjectJobsTypecheck>;
+/** Default job configuration applied to new projects created in this team. */
+export type TeamDefaultProjectJobsMfeConfigPresentTargetsList = Array<string>;
+export declare const TeamDefaultProjectJobsMfeConfigPresentTargetsList: S.Schema<TeamDefaultProjectJobsMfeConfigPresentTargetsList>;
+/** Default job configuration applied to new projects created in this team. */
+export interface TeamDefaultProjectJobsMfeConfigPresent {
+    /** Default job configuration applied to new projects created in this team. */
+    targets: TeamDefaultProjectJobsMfeConfigPresentTargetsList;
+}
+export declare const TeamDefaultProjectJobsMfeConfigPresent: S.Schema<TeamDefaultProjectJobsMfeConfigPresent>;
+/** Default job configuration applied to new projects created in this team. */
+export interface TeamDefaultProjectJobs {
+    /** Default job configuration applied to new projects created in this team. */
+    lint?: TeamDefaultProjectJobsLint;
+    /** Default job configuration applied to new projects created in this team. */
+    typecheck?: TeamDefaultProjectJobsTypecheck;
+    /** Default job configuration applied to new projects created in this team. */
+    mfe_config_present?: TeamDefaultProjectJobsMfeConfigPresent;
+}
+export declare const TeamDefaultProjectJobs: S.Schema<TeamDefaultProjectJobs>;
+/** Whether toolbar is enabled on preview deployments */
+export type TeamEnablePreviewFeedback = "default" | "default-force" | "off" | "off-force" | "on" | "on-force";
+export declare const TeamEnablePreviewFeedback: any;
+/** Whether toolbar is enabled on production deployments */
+export type TeamEnableProductionFeedback = "default" | "default-force" | "off" | "off-force" | "on" | "on-force";
+export declare const TeamEnableProductionFeedback: any;
+/** Sensitive environment variable policy for this team */
+export type TeamSensitiveEnvironmentVariablePolicy = "default" | "off" | "on";
+export declare const TeamSensitiveEnvironmentVariablePolicy: any;
+/** Require production secrets to use a different value than preview or development. */
+export type TeamDisjunctiveProductionSecretPolicy = "default" | "off" | "on";
+export declare const TeamDisjunctiveProductionSecretPolicy: any;
+/** Controls who can request access to protected deployments. */
+export type TeamDpAccessRequestsMode = "all" | "email-domain" | "none";
+export declare const TeamDpAccessRequestsMode: any;
+export interface TeamIpBucketsItem {
+    bucket: string;
+    supportUntil?: number;
+    default?: boolean;
+}
+export declare const TeamIpBucketsItem: S.Schema<TeamIpBucketsItem>;
+export type TeamIpBucketsList = Array<TeamIpBucketsItem>;
+export declare const TeamIpBucketsList: S.Schema<TeamIpBucketsList>;
+/** When enabled, deployment protection settings require stricter permissions (owner-only). */
+export interface TeamStrictDeploymentProtectionSettings {
+    enabled: boolean;
+    updatedAt: number;
+}
+export declare const TeamStrictDeploymentProtectionSettings: S.Schema<TeamStrictDeploymentProtectionSettings>;
+/** When enabled, creating shareable links requires Owner role. */
+export type TeamStrictShareableLinks = TeamStrictDeploymentProtectionSettings;
+export declare const TeamStrictShareableLinks: S.Schema<TeamStrictDeploymentProtectionSettings>;
+/** When enabled, adding, changing, or removing project password protection requires Owner role. */
+export type TeamStrictPasswordProtectionSettings = TeamStrictDeploymentProtectionSettings;
+export declare const TeamStrictPasswordProtectionSettings: S.Schema<TeamStrictDeploymentProtectionSettings>;
+/** When enabled, creating and managing connectors requires Owner role or the ConnectorManager permission. */
+export type TeamStrictConnectors = TeamStrictDeploymentProtectionSettings;
+export declare const TeamStrictConnectors: S.Schema<TeamStrictDeploymentProtectionSettings>;
+export type TeamNsnbConfigPreference = "auto-approval" | "block" | "manual-approval";
+export declare const TeamNsnbConfigPreference: any;
+/** NSNB configuration for the team. */
+export interface TeamNsnbConfig {
+    preference: TeamNsnbConfigPreference;
+}
+export declare const TeamNsnbConfig: S.Schema<TeamNsnbConfig>;
+export type TeamDeploymentPolicyGitSourcesItemSourcesItemCase0Provider = "bitbucket" | "github";
+export declare const TeamDeploymentPolicyGitSourcesItemSourcesItemCase0Provider: any;
+/** Allowlist entry for GitHub and Bitbucket, whose repos are identified by a flat `org`/`repo` (Bitbucket's workspace/owner maps to `org`, its repo slug to `repo`). Omit `repo` to match any repo in the org. Org is matched case-insensitively. */
+export interface TeamDeploymentPolicyGitSourcesItemSourcesItemCase0 {
+    provider: TeamDeploymentPolicyGitSourcesItemSourcesItemCase0Provider;
+    org: string;
+    repo?: string;
+}
+export declare const TeamDeploymentPolicyGitSourcesItemSourcesItemCase0: S.Schema<TeamDeploymentPolicyGitSourcesItemSourcesItemCase0>;
+export type TeamDeploymentPolicyGitSourcesItemSourcesItemCase1Provider = "gitlab";
+export declare const TeamDeploymentPolicyGitSourcesItemSourcesItemCase1Provider: any;
+/** Allowlist entry for GitLab, which uses nested groups rather than a flat org/repo. `namespace` is the full group path (e.g. `group` or `group/subgroup`); `project` is the leaf project name. Omit `project` to match any project under the namespace. Namespace is matched case-insensitively. */
+export interface TeamDeploymentPolicyGitSourcesItemSourcesItemCase1 {
+    provider: TeamDeploymentPolicyGitSourcesItemSourcesItemCase1Provider;
+    namespace: string;
+    project?: string;
+}
+export declare const TeamDeploymentPolicyGitSourcesItemSourcesItemCase1: S.Schema<TeamDeploymentPolicyGitSourcesItemSourcesItemCase1>;
+export type TeamDeploymentPolicyGitSourcesItemSourcesItem = TeamDeploymentPolicyGitSourcesItemSourcesItemCase0 | TeamDeploymentPolicyGitSourcesItemSourcesItemCase1;
+export declare const TeamDeploymentPolicyGitSourcesItemSourcesItem: S.Schema<TeamDeploymentPolicyGitSourcesItemSourcesItem>;
+export type TeamDeploymentPolicyGitSourcesItemSourcesList = Array<TeamDeploymentPolicyGitSourcesItemSourcesItem>;
+export declare const TeamDeploymentPolicyGitSourcesItemSourcesList: S.Schema<TeamDeploymentPolicyGitSourcesItemSourcesList>;
+export type TeamDeploymentPolicyGitSourcesItemEnvironmentsItemCase0Type = "system";
+export declare const TeamDeploymentPolicyGitSourcesItemEnvironmentsItemCase0Type: any;
+export type TeamDeploymentPolicyGitSourcesItemEnvironmentsItemCase0Target = "preview" | "production";
+export declare const TeamDeploymentPolicyGitSourcesItemEnvironmentsItemCase0Target: any;
+export interface TeamDeploymentPolicyGitSourcesItemEnvironmentsItemCase0 {
+    type: TeamDeploymentPolicyGitSourcesItemEnvironmentsItemCase0Type;
+    target: TeamDeploymentPolicyGitSourcesItemEnvironmentsItemCase0Target;
+}
+export declare const TeamDeploymentPolicyGitSourcesItemEnvironmentsItemCase0: S.Schema<TeamDeploymentPolicyGitSourcesItemEnvironmentsItemCase0>;
+export type TeamDeploymentPolicyGitSourcesItemEnvironmentsItemCase1Type = "custom";
+export declare const TeamDeploymentPolicyGitSourcesItemEnvironmentsItemCase1Type: any;
+export interface TeamDeploymentPolicyGitSourcesItemEnvironmentsItemCase1 {
+    type: TeamDeploymentPolicyGitSourcesItemEnvironmentsItemCase1Type;
+    environmentId: string;
+}
+export declare const TeamDeploymentPolicyGitSourcesItemEnvironmentsItemCase1: S.Schema<TeamDeploymentPolicyGitSourcesItemEnvironmentsItemCase1>;
+export type TeamDeploymentPolicyGitSourcesItemEnvironmentsItem = TeamDeploymentPolicyGitSourcesItemEnvironmentsItemCase0 | TeamDeploymentPolicyGitSourcesItemEnvironmentsItemCase1;
+export declare const TeamDeploymentPolicyGitSourcesItemEnvironmentsItem: S.Schema<TeamDeploymentPolicyGitSourcesItemEnvironmentsItem>;
+export type TeamDeploymentPolicyGitSourcesItemEnvironmentsList = Array<TeamDeploymentPolicyGitSourcesItemEnvironmentsItem>;
+export declare const TeamDeploymentPolicyGitSourcesItemEnvironmentsList: S.Schema<TeamDeploymentPolicyGitSourcesItemEnvironmentsList>;
+/** `enabled: true` with empty `sources` is deny-all. */
+export interface TeamDeploymentPolicyGitSourcesItem {
+    sources: TeamDeploymentPolicyGitSourcesItemSourcesList;
+    enabled: boolean;
+    environments: TeamDeploymentPolicyGitSourcesItemEnvironmentsList;
+}
+export declare const TeamDeploymentPolicyGitSourcesItem: S.Schema<TeamDeploymentPolicyGitSourcesItem>;
+export type TeamDeploymentPolicyGitSourcesList = Array<TeamDeploymentPolicyGitSourcesItem>;
+export declare const TeamDeploymentPolicyGitSourcesList: S.Schema<TeamDeploymentPolicyGitSourcesList>;
+/** Customer-configurable deployment sources. Every deploy classifies to exactly one. JSON schema in `packages/deployment-policy/schemas/body.ts` enumerates exactly these values. - `'git'` — git provider webhook. - `'cli'` — Vercel CLI (legacy classic-token CLI and SIWV CLI both). - `'rest-api'` — direct user/team-token REST upload. Does NOT cover deploy hooks, Marketplace integrations, or first-party app tokens. - `'deploy-hook'` — project deploy-hook URL. The URL is the credential. - `'integration'` — third-party Marketplace actor: Marketplace integration token, user-delegated OAuth from a Marketplace app, or an unrecognized third-party Vercel App. First-party Vercel Apps are never `'integration'`. - `'v0'` — the v0 product surface (entitlement-gated). v0 deploys through the CLI under the hood, but classifies as its own source so a team can allow or deny v0 independently of `'cli'`. First-party Vercel apps (Toolbar, etc.) classify as `'first-party'` — see `ClassifiedSource` in `./checks`. They're not in this union because they aren't customer-configurable; they bypass `checkDeploymentSources` entirely. v0 is intentionally NOT among them: like the CLI, it's a real product surface and is policy-controllable. */
+export type TeamDeploymentPolicyDeploymentSourcesItemSourcesItem = "cli" | "deploy-hook" | "git" | "integration" | "rest-api" | "v0";
+export declare const TeamDeploymentPolicyDeploymentSourcesItemSourcesItem: any;
+export type TeamDeploymentPolicyDeploymentSourcesItemSourcesList = Array<TeamDeploymentPolicyDeploymentSourcesItemSourcesItem>;
+export declare const TeamDeploymentPolicyDeploymentSourcesItemSourcesList: S.Schema<TeamDeploymentPolicyDeploymentSourcesItemSourcesList>;
+export type TeamDeploymentPolicyDeploymentSourcesItemEnvironmentsItemCase0Type = "system";
+export declare const TeamDeploymentPolicyDeploymentSourcesItemEnvironmentsItemCase0Type: any;
+export type TeamDeploymentPolicyDeploymentSourcesItemEnvironmentsItemCase0Target = "preview" | "production";
+export declare const TeamDeploymentPolicyDeploymentSourcesItemEnvironmentsItemCase0Target: any;
+export interface TeamDeploymentPolicyDeploymentSourcesItemEnvironmentsItemCase0 {
+    type: TeamDeploymentPolicyDeploymentSourcesItemEnvironmentsItemCase0Type;
+    target: TeamDeploymentPolicyDeploymentSourcesItemEnvironmentsItemCase0Target;
+}
+export declare const TeamDeploymentPolicyDeploymentSourcesItemEnvironmentsItemCase0: S.Schema<TeamDeploymentPolicyDeploymentSourcesItemEnvironmentsItemCase0>;
+export type TeamDeploymentPolicyDeploymentSourcesItemEnvironmentsItemCase1Type = "custom";
+export declare const TeamDeploymentPolicyDeploymentSourcesItemEnvironmentsItemCase1Type: any;
+export interface TeamDeploymentPolicyDeploymentSourcesItemEnvironmentsItemCase1 {
+    type: TeamDeploymentPolicyDeploymentSourcesItemEnvironmentsItemCase1Type;
+    environmentId: string;
+}
+export declare const TeamDeploymentPolicyDeploymentSourcesItemEnvironmentsItemCase1: S.Schema<TeamDeploymentPolicyDeploymentSourcesItemEnvironmentsItemCase1>;
+export type TeamDeploymentPolicyDeploymentSourcesItemEnvironmentsItem = TeamDeploymentPolicyDeploymentSourcesItemEnvironmentsItemCase0 | TeamDeploymentPolicyDeploymentSourcesItemEnvironmentsItemCase1;
+export declare const TeamDeploymentPolicyDeploymentSourcesItemEnvironmentsItem: S.Schema<TeamDeploymentPolicyDeploymentSourcesItemEnvironmentsItem>;
+export type TeamDeploymentPolicyDeploymentSourcesItemEnvironmentsList = Array<TeamDeploymentPolicyDeploymentSourcesItemEnvironmentsItem>;
+export declare const TeamDeploymentPolicyDeploymentSourcesItemEnvironmentsList: S.Schema<TeamDeploymentPolicyDeploymentSourcesItemEnvironmentsList>;
+/** `enabled: true` with empty `sources` is deny-all. */
+export interface TeamDeploymentPolicyDeploymentSourcesItem {
+    sources: TeamDeploymentPolicyDeploymentSourcesItemSourcesList;
+    enabled: boolean;
+    environments: TeamDeploymentPolicyDeploymentSourcesItemEnvironmentsList;
+}
+export declare const TeamDeploymentPolicyDeploymentSourcesItem: S.Schema<TeamDeploymentPolicyDeploymentSourcesItem>;
+export type TeamDeploymentPolicyDeploymentSourcesList = Array<TeamDeploymentPolicyDeploymentSourcesItem>;
+export declare const TeamDeploymentPolicyDeploymentSourcesList: S.Schema<TeamDeploymentPolicyDeploymentSourcesList>;
+/** Composable deployment-time policy for the team. Used as the default for every project on the team, with optional per-project overrides on `project.deploymentPolicy`. */
+export interface TeamDeploymentPolicy {
+    gitSources?: TeamDeploymentPolicyGitSourcesList;
+    deploymentSources?: TeamDeploymentPolicyDeploymentSourcesList;
+}
+export declare const TeamDeploymentPolicy: S.Schema<TeamDeploymentPolicy>;
+export interface TeamMembershipEntitlementsItem {
+    entitlement: string;
+}
+export declare const TeamMembershipEntitlementsItem: S.Schema<TeamMembershipEntitlementsItem>;
+export type TeamMembershipEntitlementsList = Array<TeamMembershipEntitlementsItem>;
+export declare const TeamMembershipEntitlementsList: S.Schema<TeamMembershipEntitlementsList>;
+export type TeamMembershipRole = "BILLING" | "CONTRIBUTOR" | "DEVELOPER" | "MEMBER" | "OWNER" | "SECURITY" | "VIEWER" | "VIEWER_FOR_PLUS";
+export declare const TeamMembershipRole: any;
+export type TeamMembershipTeamRolesItem = "BILLING" | "CONTRIBUTOR" | "DEVELOPER" | "MEMBER" | "OWNER" | "SECURITY" | "VIEWER" | "VIEWER_FOR_PLUS";
+export declare const TeamMembershipTeamRolesItem: any;
+export type TeamMembershipTeamRolesList = Array<TeamMembershipTeamRolesItem>;
+export declare const TeamMembershipTeamRolesList: S.Schema<TeamMembershipTeamRolesList>;
+export type TeamMembershipTeamPermissionsItem = "AiGatewayApiKeyOwnedBySelf" | "AiGatewayBudgetManager" | "AiGatewayCredits" | "AiGatewaySettings" | "AiGatewayTranscriptsManager" | "AiGatewayTranscriptsViewer" | "ConnectorManager" | "CreateProject" | "EnvVariableManager" | "EnvironmentManager" | "FullProductionDeployment" | "IntegrationManager" | "OrgAdmin" | "OrgViewer" | "UsageViewer" | "V0Builder" | "V0Chatter" | "V0Viewer" | "WorkflowDecryptor";
+export declare const TeamMembershipTeamPermissionsItem: any;
+export type TeamMembershipTeamPermissionsList = Array<TeamMembershipTeamPermissionsItem>;
+export declare const TeamMembershipTeamPermissionsList: S.Schema<TeamMembershipTeamPermissionsList>;
+export type TeamMembershipJoinedFromOrigin = "account-update" | "bitbucket" | "dsync" | "feedback" | "github" | "gitlab" | "import" | "link" | "mail" | "nsnb-auto-approve" | "nsnb-hobby-upgrade" | "nsnb-invite" | "nsnb-redeploy" | "nsnb-redeploy-attribution-card" | "nsnb-request-access" | "nsnb-viewer-upgrade" | "organization-teams" | "saml" | "teams";
+export declare const TeamMembershipJoinedFromOrigin: any;
+export type TeamMembershipJoinedFromGitUserId = string | number;
+export declare const TeamMembershipJoinedFromGitUserId: S.Schema<TeamMembershipJoinedFromGitUserId>;
+export interface TeamMembershipJoinedFrom {
+    origin: TeamMembershipJoinedFromOrigin;
+    commitId?: string;
+    repoId?: string;
+    repoPath?: string;
+    gitUserId?: TeamMembershipJoinedFromGitUserId;
+    gitUserLogin?: string;
+    ssoUserId?: string;
+    ssoConnectedAt?: number;
+    idpUserId?: string;
+    dsyncUserId?: string;
+    dsyncConnectedAt?: number;
+}
+export declare const TeamMembershipJoinedFrom: S.Schema<TeamMembershipJoinedFrom>;
+/** The membership of the authenticated User in relation to the Team. */
+export interface TeamMembership {
+    uid?: string;
+    entitlements?: TeamMembershipEntitlementsList;
+    teamId?: string;
+    confirmed: boolean;
+    accessRequestedAt?: number;
+    role: TeamMembershipRole;
+    teamRoles?: TeamMembershipTeamRolesList;
+    teamPermissions?: TeamMembershipTeamPermissionsList;
+    createdAt: number;
+    created: number;
+    joinedFrom?: TeamMembershipJoinedFrom;
+}
+export declare const TeamMembership: S.Schema<TeamMembership>;
+/** Data representing a Team. */
+export interface Team {
+    connect?: TeamConnect;
+    /** The ID of the user who created the Team. */
+    creatorId: string;
+    /** Timestamp (in milliseconds) of when the Team was last updated. */
+    updatedAt: number;
+    /** Hostname that'll be matched with emails on sign-up to automatically join the Team. */
+    emailDomain?: string | null;
+    /** When "Single Sign-On (SAML)" is configured, this object contains information regarding the configuration of the Identity Provider (IdP). */
+    saml?: TeamSaml;
+    /** Code that can be used to join this Team. Only visible to Team owners. */
+    inviteCode?: string;
+    /** The team's billing plan. */
+    billing: TeamBilling | null;
+    /** A short description of the Team. */
+    description: string | null;
+    /** Default roles for the team. */
+    defaultRoles?: TeamDefaultRoles;
+    /** The prefix that is prepended to automatic aliases. */
+    stagingPrefix: string;
+    resourceConfig?: TeamResourceConfig;
+    /** The hostname that is current set as preview deployment suffix. */
+    previewDeploymentSuffix?: string | null;
+    /** Whether the team is a platform team. */
+    platform?: boolean;
+    disableHardAutoBlocks?: TeamDisableHardAutoBlocks;
+    /** Is remote caching enabled for this team */
+    remoteCaching?: TeamConnect;
+    /** Default deployment protection for this team null indicates protection is disabled */
+    defaultDeploymentProtection?: TeamDefaultDeploymentProtection;
+    /** Default Passport configuration for new projects in this team. */
+    defaultPassport?: TeamDefaultPassport | null;
+    /** Default deployment expiration settings for this team */
+    defaultExpirationSettings?: TeamDefaultExpirationSettings;
+    /** Default job configuration applied to new projects created in this team. */
+    defaultProjectJobs?: TeamDefaultProjectJobs;
+    /** Whether toolbar is enabled on preview deployments */
+    enablePreviewFeedback?: TeamEnablePreviewFeedback | null;
+    /** Whether toolbar is enabled on production deployments */
+    enableProductionFeedback?: TeamEnableProductionFeedback | null;
+    /** Sensitive environment variable policy for this team */
+    sensitiveEnvironmentVariablePolicy?: TeamSensitiveEnvironmentVariablePolicy | null;
+    /** Require production secrets to use a different value than preview or development. */
+    disjunctiveProductionSecretPolicy?: TeamDisjunctiveProductionSecretPolicy | null;
+    /** Indicates if IP addresses should be accessible in observability (o11y) tooling */
+    hideIpAddresses?: boolean | null;
+    /** Indicates if IP addresses should be accessible in log drains */
+    hideIpAddressesInLogDrains?: boolean | null;
+    /** Controls who can request access to protected deployments. */
+    dpAccessRequestsMode?: TeamDpAccessRequestsMode;
+    ipBuckets?: TeamIpBucketsList;
+    /** When enabled, all projects in the team require commits to be signed and verified by the git provider before deployments will be created. Projects may override this via `project.gitProviderOptions.requireVerifiedCommits` (gated by `Project:Update`). */
+    requireVerifiedCommits?: boolean;
+    /** Default for projects in the team. When `true`, projects in this team will not emit GitHub repository-dispatch events on deployment events unless the project explicitly overrides this setting via `project.gitProviderOptions.disableRepositoryDispatchEvents`. */
+    disableRepositoryDispatchEvents?: boolean;
+    /** When enabled, deployment protection settings require stricter permissions (owner-only). */
+    strictDeploymentProtectionSettings?: TeamStrictDeploymentProtectionSettings;
+    /** When enabled, creating shareable links requires Owner role. */
+    strictShareableLinks?: TeamStrictDeploymentProtectionSettings;
+    /** When enabled, adding, changing, or removing project password protection requires Owner role. */
+    strictPasswordProtectionSettings?: TeamStrictDeploymentProtectionSettings;
+    /** When enabled, creating and managing connectors requires Owner role or the ConnectorManager permission. */
+    strictConnectors?: TeamStrictDeploymentProtectionSettings;
+    /** NSNB configuration for the team. */
+    nsnbConfig?: TeamNsnbConfig;
+    /** Composable deployment-time policy for the team. Used as the default for every project on the team, with optional per-project overrides on `project.deploymentPolicy`. */
+    deploymentPolicy?: TeamDeploymentPolicy;
+    /** Timestamp (ms) after which personal access tokens created at or before this time are considered invalid for this team. */
+    personalAccessTokensInvalidatedAt?: number;
+    /** Timestamp (ms) after which Vercel App tokens created at or before this time are considered invalid for this team. */
+    appTokensInvalidatedAt?: number;
+    /** Timestamp (ms) after which API keys created at or before this time are considered invalid for this team. */
+    apiKeysInvalidatedAt?: number;
+    /** Timestamp (ms) after which integration tokens created at or before this time are considered invalid for this team. */
+    integrationTokensInvalidatedAt?: number;
+    /** The Team's unique identifier. */
+    id: string;
+    /** The Team's slug, which is unique across the Vercel platform. */
+    slug: string;
+    /** Name associated with the Team account, or `null` if none has been provided. */
+    name: string | null;
+    /** The ID of the file used as avatar for this Team. */
+    avatar: string | null;
+    /** The membership of the authenticated User in relation to the Team. */
+    membership?: TeamMembership;
+    /** UNIX timestamp (in milliseconds) when the Team was created. */
+    createdAt: number;
+    /** The organizationId for teams that belong to an organization (set on both the organization's root team and its child teams). */
+    parentId?: string;
+    /** Best-effort ID of the organization’s root billing team. When present, compare `orgRootTeamId === id` to identify the root team. It may be omitted even when `parentId` is set if organization resolution fails or the referenced organization is missing. Always omitted for non-organization teams. */
+    orgRootTeamId?: string;
+}
+export declare const Team: S.Schema<Team>;
+export interface GetTeamAccessRequestRequest {
+    teamId: string;
+    userId: string;
+}
+export declare const GetTeamAccessRequestRequest: S.Schema<GetTeamAccessRequestRequest>;
+export type GetTeamAccessRequestResponseJoinedFromOrigin = "account-update" | "bitbucket" | "dsync" | "feedback" | "github" | "gitlab" | "import" | "link" | "mail" | "nsnb-auto-approve" | "nsnb-hobby-upgrade" | "nsnb-invite" | "nsnb-redeploy" | "nsnb-redeploy-attribution-card" | "nsnb-request-access" | "nsnb-viewer-upgrade" | "organization-teams" | "saml" | "teams";
+export declare const GetTeamAccessRequestResponseJoinedFromOrigin: any;
+export type GetTeamAccessRequestResponseJoinedFromGitUserId = string | number;
+export declare const GetTeamAccessRequestResponseJoinedFromGitUserId: S.Schema<GetTeamAccessRequestResponseJoinedFromGitUserId>;
+/** A map that describes the origin from where the user joined. */
+export interface GetTeamAccessRequestResponseJoinedFrom {
+    origin: GetTeamAccessRequestResponseJoinedFromOrigin;
+    commitId?: string;
+    repoId?: string;
+    repoPath?: string;
+    gitUserId?: GetTeamAccessRequestResponseJoinedFromGitUserId;
+    gitUserLogin?: string;
+    ssoUserId?: string;
+    ssoConnectedAt?: number;
+    idpUserId?: string;
+    dsyncUserId?: string;
+    dsyncConnectedAt?: number;
+}
+export declare const GetTeamAccessRequestResponseJoinedFrom: S.Schema<GetTeamAccessRequestResponseJoinedFrom>;
+/** Map of the connected GitHub account. */
+export interface GetTeamAccessRequestResponseGithub {
+    login?: string;
+}
+export declare const GetTeamAccessRequestResponseGithub: S.Schema<GetTeamAccessRequestResponseGithub>;
+/** Map of the connected GitLab account. */
+export type GetTeamAccessRequestResponseGitlab = GetTeamAccessRequestResponseGithub;
+export declare const GetTeamAccessRequestResponseGitlab: S.Schema<GetTeamAccessRequestResponseGithub>;
+/** Map of the connected Bitbucket account. */
+export type GetTeamAccessRequestResponseBitbucket = GetTeamAccessRequestResponseGithub;
+export declare const GetTeamAccessRequestResponseBitbucket: S.Schema<GetTeamAccessRequestResponseGithub>;
+export interface GetTeamAccessRequestResponse {
+    /** The slug of the team. */
+    teamSlug: string;
+    /** The name of the team. */
+    teamName: string;
+    /** Current status of the membership. Will be `true` if confirmed, if pending it'll be `false`. */
+    confirmed: boolean;
+    /** A map that describes the origin from where the user joined. */
+    joinedFrom: GetTeamAccessRequestResponseJoinedFrom;
+    /** Timestamp in milliseconds when the user requested access to the team. */
+    accessRequestedAt: number;
+    /** Map of the connected GitHub account. */
+    github: GetTeamAccessRequestResponseGithub | null;
+    /** Map of the connected GitLab account. */
+    gitlab: GetTeamAccessRequestResponseGithub | null;
+    /** Map of the connected Bitbucket account. */
+    bitbucket: GetTeamAccessRequestResponseGithub | null;
+}
+export declare const GetTeamAccessRequestResponse: S.Schema<GetTeamAccessRequestResponse>;
+/** Only return members with the specified team role. */
+export type GetTeamMembersRequestRole = "OWNER" | "MEMBER" | "DEVELOPER" | "SECURITY" | "BILLING" | "VIEWER" | "VIEWER_FOR_PLUS" | "CONTRIBUTOR";
+export declare const GetTeamMembersRequestRole: any;
+export interface GetTeamMembersRequest {
+    /** The Team identifier to perform the request on behalf of. */
+    teamId: string;
+    /** Limit how many teams should be returned */
+    limit?: number;
+    /** Timestamp in milliseconds to only include members added since then. */
+    since?: number;
+    /** Timestamp in milliseconds to only include members added until then. */
+    until?: number;
+    /** Search team members by their name, username, and email. */
+    search?: string;
+    /** Only return members with the specified team role. */
+    role?: GetTeamMembersRequestRole | (string & {});
+    /** Exclude members who belong to the specified project. */
+    excludeProject?: string;
+    /** Include team members who are eligible to be members of the specified project. */
+    eligibleMembersForProjectId?: string;
+    /** The Team slug to perform the request on behalf of. */
+    slug?: string;
+}
+export declare const GetTeamMembersRequest: S.Schema<GetTeamMembersRequest>;
+/** Information about the GitHub account for this user. */
+export type GetTeamMembersResponseMembersItemGithub = GetTeamAccessRequestResponseGithub;
+export declare const GetTeamMembersResponseMembersItemGithub: S.Schema<GetTeamAccessRequestResponseGithub>;
+/** Information about the GitLab account of this user. */
+export type GetTeamMembersResponseMembersItemGitlab = GetTeamAccessRequestResponseGithub;
+export declare const GetTeamMembersResponseMembersItemGitlab: S.Schema<GetTeamAccessRequestResponseGithub>;
+/** Information about the Bitbucket account of this user. */
+export type GetTeamMembersResponseMembersItemBitbucket = GetTeamAccessRequestResponseGithub;
+export declare const GetTeamMembersResponseMembersItemBitbucket: S.Schema<GetTeamAccessRequestResponseGithub>;
+/** Role of this user in the team. */
+export type GetTeamMembersResponseMembersItemRole = "BILLING" | "CONTRIBUTOR" | "DEVELOPER" | "MEMBER" | "OWNER" | "SECURITY" | "VIEWER" | "VIEWER_FOR_PLUS";
+export declare const GetTeamMembersResponseMembersItemRole: any;
+export type GetTeamMembersResponseMembersItemJoinedFromOrigin = "account-update" | "bitbucket" | "dsync" | "feedback" | "github" | "gitlab" | "import" | "link" | "mail" | "nsnb-auto-approve" | "nsnb-hobby-upgrade" | "nsnb-invite" | "nsnb-redeploy" | "nsnb-redeploy-attribution-card" | "nsnb-request-access" | "nsnb-viewer-upgrade" | "organization-teams" | "saml" | "teams";
+export declare const GetTeamMembersResponseMembersItemJoinedFromOrigin: any;
+export type GetTeamMembersResponseMembersItemJoinedFromGitUserId = string | number;
+export declare const GetTeamMembersResponseMembersItemJoinedFromGitUserId: S.Schema<GetTeamMembersResponseMembersItemJoinedFromGitUserId>;
+/** Map with information about the members origin if they joined by requesting access. */
+export interface GetTeamMembersResponseMembersItemJoinedFrom {
+    origin: GetTeamMembersResponseMembersItemJoinedFromOrigin;
+    commitId?: string;
+    repoId?: string;
+    repoPath?: string;
+    gitUserId?: GetTeamMembersResponseMembersItemJoinedFromGitUserId;
+    gitUserLogin?: string;
+    ssoUserId?: string;
+    ssoConnectedAt?: number;
+    idpUserId?: string;
+    dsyncUserId?: string;
+    dsyncConnectedAt?: number;
+}
+export declare const GetTeamMembersResponseMembersItemJoinedFrom: S.Schema<GetTeamMembersResponseMembersItemJoinedFrom>;
+export type GetTeamMembersResponseMembersItemProjectsItemRole = "ADMIN" | "PROJECT_DEVELOPER" | "PROJECT_GUEST" | "PROJECT_VIEWER";
+export declare const GetTeamMembersResponseMembersItemProjectsItemRole: any;
+/** Array of project memberships */
+export interface GetTeamMembersResponseMembersItemProjectsItem {
+    name: string;
+    id: string;
+    role?: GetTeamMembersResponseMembersItemProjectsItemRole;
+}
+export declare const GetTeamMembersResponseMembersItemProjectsItem: S.Schema<GetTeamMembersResponseMembersItemProjectsItem>;
+/** Array of project memberships */
+export type GetTeamMembersResponseMembersItemProjectsList = Array<GetTeamMembersResponseMembersItemProjectsItem>;
+export declare const GetTeamMembersResponseMembersItemProjectsList: S.Schema<GetTeamMembersResponseMembersItemProjectsList>;
+export interface GetTeamMembersResponseMembersItem {
+    /** ID of the file for the Avatar of this member. */
+    avatar?: string;
+    /** Boolean that indicates if this member was confirmed by an owner. */
+    confirmed: boolean;
+    /** The email of this member. */
+    email: string;
+    /** Information about the GitHub account for this user. */
+    github?: GetTeamAccessRequestResponseGithub;
+    /** Information about the GitLab account of this user. */
+    gitlab?: GetTeamAccessRequestResponseGithub;
+    /** Information about the Bitbucket account of this user. */
+    bitbucket?: GetTeamAccessRequestResponseGithub;
+    /** Role of this user in the team. */
+    role: GetTeamMembersResponseMembersItemRole;
+    /** The ID of this user. */
+    uid: string;
+    /** The unique username of this user. */
+    username: string;
+    /** The name of this user. */
+    name?: string;
+    /** Timestamp in milliseconds when this member was added. */
+    createdAt: number;
+    /** Timestamp in milliseconds for when this team member was accepted by an owner. */
+    accessRequestedAt?: number;
+    /** Map with information about the members origin if they joined by requesting access. */
+    joinedFrom?: GetTeamMembersResponseMembersItemJoinedFrom;
+    /** Array of project memberships */
+    projects?: GetTeamMembersResponseMembersItemProjectsList;
+    /** Indicates whether the user is managed by an enterprise. */
+    isEnterpriseManaged?: boolean;
+}
+export declare const GetTeamMembersResponseMembersItem: S.Schema<GetTeamMembersResponseMembersItem>;
+export type GetTeamMembersResponseMembersList = Array<GetTeamMembersResponseMembersItem>;
+export declare const GetTeamMembersResponseMembersList: S.Schema<GetTeamMembersResponseMembersList>;
+export type GetTeamMembersResponseEmailInviteCodesItemAccessGroupsList = Array<string>;
+export declare const GetTeamMembersResponseEmailInviteCodesItemAccessGroupsList: S.Schema<GetTeamMembersResponseEmailInviteCodesItemAccessGroupsList>;
+export type GetTeamMembersResponseEmailInviteCodesItemRole = "BILLING" | "CONTRIBUTOR" | "DEVELOPER" | "MEMBER" | "OWNER" | "SECURITY" | "VIEWER" | "VIEWER_FOR_PLUS";
+export declare const GetTeamMembersResponseEmailInviteCodesItemRole: any;
+export type GetTeamMembersResponseEmailInviteCodesItemTeamRolesItem = "BILLING" | "CONTRIBUTOR" | "DEVELOPER" | "MEMBER" | "OWNER" | "SECURITY" | "VIEWER" | "VIEWER_FOR_PLUS";
+export declare const GetTeamMembersResponseEmailInviteCodesItemTeamRolesItem: any;
+export type GetTeamMembersResponseEmailInviteCodesItemTeamRolesList = Array<GetTeamMembersResponseEmailInviteCodesItemTeamRolesItem>;
+export declare const GetTeamMembersResponseEmailInviteCodesItemTeamRolesList: S.Schema<GetTeamMembersResponseEmailInviteCodesItemTeamRolesList>;
+export type GetTeamMembersResponseEmailInviteCodesItemTeamPermissionsItem = "AiGatewayApiKeyOwnedBySelf" | "AiGatewayBudgetManager" | "AiGatewayCredits" | "AiGatewaySettings" | "AiGatewayTranscriptsManager" | "AiGatewayTranscriptsViewer" | "ConnectorManager" | "CreateProject" | "EnvVariableManager" | "EnvironmentManager" | "FullProductionDeployment" | "IntegrationManager" | "OrgAdmin" | "OrgViewer" | "UsageViewer" | "V0Builder" | "V0Chatter" | "V0Viewer" | "WorkflowDecryptor";
+export declare const GetTeamMembersResponseEmailInviteCodesItemTeamPermissionsItem: any;
+export type GetTeamMembersResponseEmailInviteCodesItemTeamPermissionsList = Array<GetTeamMembersResponseEmailInviteCodesItemTeamPermissionsItem>;
+export declare const GetTeamMembersResponseEmailInviteCodesItemTeamPermissionsList: S.Schema<GetTeamMembersResponseEmailInviteCodesItemTeamPermissionsList>;
+export type GetTeamMembersResponseEmailInviteCodesItemProjectsValue = "ADMIN" | "PROJECT_DEVELOPER" | "PROJECT_GUEST" | "PROJECT_VIEWER";
+export declare const GetTeamMembersResponseEmailInviteCodesItemProjectsValue: any;
+export type GetTeamMembersResponseEmailInviteCodesItemProjectsMap = {
+    [key: string]: GetTeamMembersResponseEmailInviteCodesItemProjectsValue | undefined;
+};
+export declare const GetTeamMembersResponseEmailInviteCodesItemProjectsMap: S.Schema<GetTeamMembersResponseEmailInviteCodesItemProjectsMap>;
+export type GetTeamMembersResponseEmailInviteCodesItemEntitlementsList = Array<string>;
+export declare const GetTeamMembersResponseEmailInviteCodesItemEntitlementsList: S.Schema<GetTeamMembersResponseEmailInviteCodesItemEntitlementsList>;
+export interface GetTeamMembersResponseEmailInviteCodesItem {
+    accessGroups?: GetTeamMembersResponseEmailInviteCodesItemAccessGroupsList;
+    id: string;
+    email?: string;
+    role?: GetTeamMembersResponseEmailInviteCodesItemRole;
+    teamRoles?: GetTeamMembersResponseEmailInviteCodesItemTeamRolesList;
+    teamPermissions?: GetTeamMembersResponseEmailInviteCodesItemTeamPermissionsList;
+    isDSyncUser: boolean;
+    createdAt?: number;
+    expired?: boolean;
+    projects?: GetTeamMembersResponseEmailInviteCodesItemProjectsMap;
+    entitlements?: GetTeamMembersResponseEmailInviteCodesItemEntitlementsList;
+}
+export declare const GetTeamMembersResponseEmailInviteCodesItem: S.Schema<GetTeamMembersResponseEmailInviteCodesItem>;
+export type GetTeamMembersResponseEmailInviteCodesList = Array<GetTeamMembersResponseEmailInviteCodesItem>;
+export declare const GetTeamMembersResponseEmailInviteCodesList: S.Schema<GetTeamMembersResponseEmailInviteCodesList>;
+export interface GetTeamMembersResponsePagination {
+    hasNext: boolean;
+    /** Amount of items in the current page. */
+    count: number;
+    /** Timestamp that must be used to request the next page. */
+    next: number | null;
+    /** Timestamp that must be used to request the previous page. */
+    prev: number | null;
+}
+export declare const GetTeamMembersResponsePagination: S.Schema<GetTeamMembersResponsePagination>;
+export interface GetTeamMembersResponse {
+    members: GetTeamMembersResponseMembersList;
+    emailInviteCodes?: GetTeamMembersResponseEmailInviteCodesList;
+    pagination: GetTeamMembersResponsePagination;
+}
+export declare const GetTeamMembersResponse: S.Schema<GetTeamMembersResponse>;
+export interface GetTeamsRequest {
+    /** Maximum number of Teams which may be returned. */
+    limit?: number;
+    /** Timestamp (in milliseconds) to only include Teams created since then. */
+    since?: number;
+    /** Timestamp (in milliseconds) to only include Teams created until then. */
+    until?: number;
+}
+export declare const GetTeamsRequest: S.Schema<GetTeamsRequest>;
+export type TeamLimitedLimitedByItem = "invalidated" | "mfa" | "scope";
+export declare const TeamLimitedLimitedByItem: any;
+export type TeamLimitedLimitedByList = Array<TeamLimitedLimitedByItem>;
+export declare const TeamLimitedLimitedByList: S.Schema<TeamLimitedLimitedByList>;
+/** Controls whether directory sync events are processed. - 'SETUP': Directory connected but role mappings not yet configured. Events are acknowledged but not processed. - 'ACTIVE': Fully configured. Events are processed normally. - undefined: Legacy directory (pre-feature), treat as 'ACTIVE' for backwards compatibility. */
+export type TeamLimitedSamlConnectionSyncState = "ACTIVE" | "SETUP";
+export declare const TeamLimitedSamlConnectionSyncState: any;
+/** Information for the SAML Single Sign-On configuration. */
+export interface TeamLimitedSamlConnection {
+    /** The Identity Provider "type", for example Okta. */
+    type: string;
+    /** Current state of the connection. */
+    state: string;
+    /** Timestamp (in milliseconds) of when the configuration was connected. */
+    connectedAt: number;
+    /** Timestamp (in milliseconds) of when the last webhook event was received from WorkOS. */
+    lastReceivedWebhookEvent?: number;
+    /** Timestamp (in milliseconds) of when the last directory sync was performed. */
+    lastSyncedAt?: number;
+    /** Controls whether directory sync events are processed. - 'SETUP': Directory connected but role mappings not yet configured. Events are acknowledged but not processed. - 'ACTIVE': Fully configured. Events are processed normally. - undefined: Legacy directory (pre-feature), treat as 'ACTIVE' for backwards compatibility. */
+    syncState?: TeamLimitedSamlConnectionSyncState;
+    status: string;
+}
+export declare const TeamLimitedSamlConnection: S.Schema<TeamLimitedSamlConnection>;
+/** Controls whether directory sync events are processed. - 'SETUP': Directory connected but role mappings not yet configured. Events are acknowledged but not processed. - 'ACTIVE': Fully configured. Events are processed normally. - undefined: Legacy directory (pre-feature), treat as 'ACTIVE' for backwards compatibility. */
+export type TeamLimitedSamlDirectorySyncState = "ACTIVE" | "SETUP";
+export declare const TeamLimitedSamlDirectorySyncState: any;
+/** Information for the Directory Sync configuration. */
+export interface TeamLimitedSamlDirectory {
+    /** The Identity Provider "type", for example Okta. */
+    type: string;
+    /** Current state of the connection. */
+    state: string;
+    /** Timestamp (in milliseconds) of when the configuration was connected. */
+    connectedAt: number;
+    /** Timestamp (in milliseconds) of when the last webhook event was received from WorkOS. */
+    lastReceivedWebhookEvent?: number;
+    /** Timestamp (in milliseconds) of when the last directory sync was performed. */
+    lastSyncedAt?: number;
+    /** Controls whether directory sync events are processed. - 'SETUP': Directory connected but role mappings not yet configured. Events are acknowledged but not processed. - 'ACTIVE': Fully configured. Events are processed normally. - undefined: Legacy directory (pre-feature), treat as 'ACTIVE' for backwards compatibility. */
+    syncState?: TeamLimitedSamlDirectorySyncState;
+}
+export declare const TeamLimitedSamlDirectory: S.Schema<TeamLimitedSamlDirectory>;
+/** When "Single Sign-On (SAML)" is configured, this object contains information that allows the client-side to identify whether or not this Team has SAML enforced. */
+export interface TeamLimitedSaml {
+    /** Information for the SAML Single Sign-On configuration. */
+    connection?: TeamLimitedSamlConnection;
+    /** Information for the Directory Sync configuration. */
+    directory?: TeamLimitedSamlDirectory;
+    /** When `true`, interactions with the Team **must** be done with an authentication token that has been authenticated with the Team's SAML Single Sign-On provider. */
+    enforced: boolean;
+}
+export declare const TeamLimitedSaml: S.Schema<TeamLimitedSaml>;
+export type TeamLimitedMembershipEntitlementsItem = TeamMembershipEntitlementsItem;
+export declare const TeamLimitedMembershipEntitlementsItem: S.Schema<TeamMembershipEntitlementsItem>;
+export type TeamLimitedMembershipEntitlementsList = Array<TeamMembershipEntitlementsItem>;
+export declare const TeamLimitedMembershipEntitlementsList: S.Schema<TeamLimitedMembershipEntitlementsList>;
+export type TeamLimitedMembershipRole = "BILLING" | "CONTRIBUTOR" | "DEVELOPER" | "MEMBER" | "OWNER" | "SECURITY" | "VIEWER" | "VIEWER_FOR_PLUS";
+export declare const TeamLimitedMembershipRole: any;
+export type TeamLimitedMembershipTeamRolesItem = "BILLING" | "CONTRIBUTOR" | "DEVELOPER" | "MEMBER" | "OWNER" | "SECURITY" | "VIEWER" | "VIEWER_FOR_PLUS";
+export declare const TeamLimitedMembershipTeamRolesItem: any;
+export type TeamLimitedMembershipTeamRolesList = Array<TeamLimitedMembershipTeamRolesItem>;
+export declare const TeamLimitedMembershipTeamRolesList: S.Schema<TeamLimitedMembershipTeamRolesList>;
+export type TeamLimitedMembershipTeamPermissionsItem = "AiGatewayApiKeyOwnedBySelf" | "AiGatewayBudgetManager" | "AiGatewayCredits" | "AiGatewaySettings" | "AiGatewayTranscriptsManager" | "AiGatewayTranscriptsViewer" | "ConnectorManager" | "CreateProject" | "EnvVariableManager" | "EnvironmentManager" | "FullProductionDeployment" | "IntegrationManager" | "OrgAdmin" | "OrgViewer" | "UsageViewer" | "V0Builder" | "V0Chatter" | "V0Viewer" | "WorkflowDecryptor";
+export declare const TeamLimitedMembershipTeamPermissionsItem: any;
+export type TeamLimitedMembershipTeamPermissionsList = Array<TeamLimitedMembershipTeamPermissionsItem>;
+export declare const TeamLimitedMembershipTeamPermissionsList: S.Schema<TeamLimitedMembershipTeamPermissionsList>;
+export type TeamLimitedMembershipJoinedFromOrigin = "account-update" | "bitbucket" | "dsync" | "feedback" | "github" | "gitlab" | "import" | "link" | "mail" | "nsnb-auto-approve" | "nsnb-hobby-upgrade" | "nsnb-invite" | "nsnb-redeploy" | "nsnb-redeploy-attribution-card" | "nsnb-request-access" | "nsnb-viewer-upgrade" | "organization-teams" | "saml" | "teams";
+export declare const TeamLimitedMembershipJoinedFromOrigin: any;
+export type TeamLimitedMembershipJoinedFromGitUserId = string | number;
+export declare const TeamLimitedMembershipJoinedFromGitUserId: S.Schema<TeamLimitedMembershipJoinedFromGitUserId>;
+export interface TeamLimitedMembershipJoinedFrom {
+    origin: TeamLimitedMembershipJoinedFromOrigin;
+    commitId?: string;
+    repoId?: string;
+    repoPath?: string;
+    gitUserId?: TeamLimitedMembershipJoinedFromGitUserId;
+    gitUserLogin?: string;
+    ssoUserId?: string;
+    ssoConnectedAt?: number;
+    idpUserId?: string;
+    dsyncUserId?: string;
+    dsyncConnectedAt?: number;
+}
+export declare const TeamLimitedMembershipJoinedFrom: S.Schema<TeamLimitedMembershipJoinedFrom>;
+/** The membership of the authenticated User in relation to the Team. */
+export interface TeamLimitedMembership {
+    uid?: string;
+    entitlements?: TeamLimitedMembershipEntitlementsList;
+    teamId?: string;
+    confirmed: boolean;
+    accessRequestedAt?: number;
+    role: TeamLimitedMembershipRole;
+    teamRoles?: TeamLimitedMembershipTeamRolesList;
+    teamPermissions?: TeamLimitedMembershipTeamPermissionsList;
+    createdAt: number;
+    created: number;
+    joinedFrom?: TeamLimitedMembershipJoinedFrom;
+}
+export declare const TeamLimitedMembership: S.Schema<TeamLimitedMembership>;
+/** A limited form of data representing a Team, due to the authentication token missing privileges to read the full Team data. */
+export interface TeamLimited {
+    /** Property indicating that this Team data contains only limited information, due to the authentication token missing privileges to read the full Team data or due to team having MFA enforced and the user not having MFA enabled. Re-login with the Team's configured SAML Single Sign-On provider in order to upgrade the authentication token with the necessary privileges. */
+    limited: boolean;
+    limitedBy: TeamLimitedLimitedByList;
+    /** When "Single Sign-On (SAML)" is configured, this object contains information that allows the client-side to identify whether or not this Team has SAML enforced. */
+    saml?: TeamLimitedSaml;
+    /** The Team's unique identifier. */
+    id: string;
+    /** The Team's slug, which is unique across the Vercel platform. */
+    slug: string;
+    /** Name associated with the Team account, or `null` if none has been provided. */
+    name: string | null;
+    /** The ID of the file used as avatar for this Team. */
+    avatar: string | null;
+    /** The membership of the authenticated User in relation to the Team. */
+    membership?: TeamLimitedMembership;
+    /** UNIX timestamp (in milliseconds) when the Team was created. */
+    createdAt: number;
+    /** The organizationId for teams that belong to an organization (set on both the organization's root team and its child teams). */
+    parentId?: string;
+    /** Best-effort ID of the organization’s root billing team. When present, compare `orgRootTeamId === id` to identify the root team. It may be omitted even when `parentId` is set if organization resolution fails or the referenced organization is missing. Always omitted for non-organization teams. */
+    orgRootTeamId?: string;
+}
+export declare const TeamLimited: S.Schema<TeamLimited>;
+export type GetTeamsResponseTeamsItem = Team | TeamLimited;
+export declare const GetTeamsResponseTeamsItem: S.Schema<GetTeamsResponseTeamsItem>;
+export type GetTeamsResponseTeamsList = Array<GetTeamsResponseTeamsItem>;
+export declare const GetTeamsResponseTeamsList: S.Schema<GetTeamsResponseTeamsList>;
+/** This object contains information related to the pagination of the current request, including the necessary parameters to get the next or previous page of data. */
+export interface Pagination {
+    /** Amount of items in the current page. */
+    count: number;
+    /** Timestamp that must be used to request the next page. */
+    next: number | null;
+    /** Timestamp that must be used to request the previous page. */
+    prev: number | null;
+}
+export declare const Pagination: S.Schema<Pagination>;
+export interface GetTeamsResponse {
+    teams: GetTeamsResponseTeamsList;
+    pagination: Pagination;
+}
+export declare const GetTeamsResponse: S.Schema<GetTeamsResponse>;
+/** The role of the user to invite */
+export type InviteUserToTeamRequestBodyItemRole = "OWNER" | "MEMBER" | "DEVELOPER" | "SECURITY" | "BILLING" | "VIEWER" | "VIEWER_FOR_PLUS" | "CONTRIBUTOR";
+export declare const InviteUserToTeamRequestBodyItemRole: any;
+/** Sets the project roles for the invited user */
+export type InviteUserToTeamRequestBodyItemProjectsItemRole = "ADMIN" | "PROJECT_VIEWER" | "PROJECT_DEVELOPER" | "PROJECT_GUEST";
+export declare const InviteUserToTeamRequestBodyItemProjectsItemRole: any;
+export interface InviteUserToTeamRequestBodyItemProjectsItem {
+    /** The ID of the project. */
+    projectId: string;
+    /** Sets the project roles for the invited user */
+    role: InviteUserToTeamRequestBodyItemProjectsItemRole | (string & {});
+}
+export declare const InviteUserToTeamRequestBodyItemProjectsItem: S.Schema<InviteUserToTeamRequestBodyItemProjectsItem>;
+export type InviteUserToTeamRequestBodyItemProjectsList = Array<InviteUserToTeamRequestBodyItemProjectsItem>;
+export declare const InviteUserToTeamRequestBodyItemProjectsList: S.Schema<InviteUserToTeamRequestBodyItemProjectsList>;
+export interface InviteUserToTeamRequestBodyItem {
+    /** The email address of the user to invite */
+    email: string;
+    /** The role of the user to invite */
+    role?: InviteUserToTeamRequestBodyItemRole | (string & {});
+    projects?: InviteUserToTeamRequestBodyItemProjectsList;
+}
+export declare const InviteUserToTeamRequestBodyItem: S.Schema<InviteUserToTeamRequestBodyItem>;
+export type InviteUserToTeamRequestBodyList = Array<InviteUserToTeamRequestBodyItem>;
+export declare const InviteUserToTeamRequestBodyList: S.Schema<InviteUserToTeamRequestBodyList>;
+export interface InviteUserToTeamRequest {
+    /** The Team identifier to perform the request on behalf of. */
+    teamId: string;
+    /** The Team slug to perform the request on behalf of. */
+    slug?: string;
+    body?: InviteUserToTeamRequestBodyList;
+}
+export declare const InviteUserToTeamRequest: S.Schema<InviteUserToTeamRequest>;
+/** The role used for the invitation */
+export type InvitedTeamMemberRole = "BILLING" | "CONTRIBUTOR" | "DEVELOPER" | "MEMBER" | "OWNER" | "SECURITY" | "VIEWER" | "VIEWER_FOR_PLUS";
+export declare const InvitedTeamMemberRole: any;
+/** The team roles of the user */
+export type InvitedTeamMemberTeamRolesItem = "BILLING" | "CONTRIBUTOR" | "DEVELOPER" | "MEMBER" | "OWNER" | "SECURITY" | "VIEWER" | "VIEWER_FOR_PLUS";
+export declare const InvitedTeamMemberTeamRolesItem: any;
+/** The team roles of the user */
+export type InvitedTeamMemberTeamRolesList = Array<InvitedTeamMemberTeamRolesItem>;
+export declare const InvitedTeamMemberTeamRolesList: S.Schema<InvitedTeamMemberTeamRolesList>;
+/** The team permissions of the user */
+export type InvitedTeamMemberTeamPermissionsItem = "AiGatewayApiKeyOwnedBySelf" | "AiGatewayBudgetManager" | "AiGatewayCredits" | "AiGatewaySettings" | "AiGatewayTranscriptsManager" | "AiGatewayTranscriptsViewer" | "ConnectorManager" | "CreateProject" | "EnvVariableManager" | "EnvironmentManager" | "FullProductionDeployment" | "IntegrationManager" | "OrgAdmin" | "OrgViewer" | "UsageViewer" | "V0Builder" | "V0Chatter" | "V0Viewer" | "WorkflowDecryptor";
+export declare const InvitedTeamMemberTeamPermissionsItem: any;
+/** The team permissions of the user */
+export type InvitedTeamMemberTeamPermissionsList = Array<InvitedTeamMemberTeamPermissionsItem>;
+export declare const InvitedTeamMemberTeamPermissionsList: S.Schema<InvitedTeamMemberTeamPermissionsList>;
+/** The member was successfully added to the team. */
+export interface InvitedTeamMember {
+    /** The ID of the invited user */
+    uid: string;
+    /** The username of the invited user */
+    username: string;
+    /** The email of the invited user. */
+    email: string;
+    /** The role used for the invitation */
+    role: InvitedTeamMemberRole;
+    /** The team roles of the user */
+    teamRoles?: InvitedTeamMemberTeamRolesList;
+    /** The team permissions of the user */
+    teamPermissions?: InvitedTeamMemberTeamPermissionsList;
+}
+export declare const InvitedTeamMember: S.Schema<InvitedTeamMember>;
+export interface JoinTeamRequest {
+    teamId: string;
+    /** The invite code to join the team. */
+    inviteCode?: string;
+}
+export declare const JoinTeamRequest: S.Schema<JoinTeamRequest>;
+export interface JoinTeamResponse {
+    /** The ID of the team the user joined. */
+    teamId: string;
+    /** The slug of the team the user joined. */
+    slug: string;
+    /** The name of the team the user joined. */
+    name: string;
+    /** The origin of how the user joined. */
+    from: string;
+}
+export declare const JoinTeamResponse: S.Schema<JoinTeamResponse>;
+export interface RemoveTeamMemberRequest {
+    teamId: string;
+    /** The user ID of the member. */
+    uid: string;
+    /** The ID of the team to set as the new default team for the Northstar user. */
+    newDefaultTeamId?: string;
+}
+export declare const RemoveTeamMemberRequest: S.Schema<RemoveTeamMemberRequest>;
+export interface RemoveTeamMemberResponse {
+    /** ID of the team. */
+    id: string;
+}
+export declare const RemoveTeamMemberResponse: S.Schema<RemoveTeamMemberResponse>;
+/** The origin of the request. */
+export type RequestAccessToTeamRequestJoinedFromOrigin = "import" | "teams" | "github" | "gitlab" | "bitbucket" | "feedback" | "organization-teams";
+export declare const RequestAccessToTeamRequestJoinedFromOrigin: any;
+/** The ID of the Git account of the user who requests access. */
+export type RequestAccessToTeamRequestJoinedFromGitUserId = string | number;
+export declare const RequestAccessToTeamRequestJoinedFromGitUserId: S.Schema<RequestAccessToTeamRequestJoinedFromGitUserId>;
+export interface RequestAccessToTeamRequestJoinedFrom {
+    /** The origin of the request. */
+    origin: RequestAccessToTeamRequestJoinedFromOrigin | (string & {});
+    /** The commit sha if the origin is a git provider. */
+    commitId?: string;
+    /** The ID of the repository for the given Git provider. */
+    repoId?: string;
+    /** The path to the repository for the given Git provider. */
+    repoPath?: string;
+    /** The ID of the Git account of the user who requests access. */
+    gitUserId?: RequestAccessToTeamRequestJoinedFromGitUserId;
+    /** The login name for the Git account of the user who requests access. */
+    gitUserLogin?: string;
+}
+export declare const RequestAccessToTeamRequestJoinedFrom: S.Schema<RequestAccessToTeamRequestJoinedFrom>;
+export interface RequestAccessToTeamRequest {
+    teamId: string;
+    joinedFrom: RequestAccessToTeamRequestJoinedFrom;
+}
+export declare const RequestAccessToTeamRequest: S.Schema<RequestAccessToTeamRequest>;
+export type RequestAccessToTeamResponseJoinedFromOrigin = "account-update" | "bitbucket" | "dsync" | "feedback" | "github" | "gitlab" | "import" | "link" | "mail" | "nsnb-auto-approve" | "nsnb-hobby-upgrade" | "nsnb-invite" | "nsnb-redeploy" | "nsnb-redeploy-attribution-card" | "nsnb-request-access" | "nsnb-viewer-upgrade" | "organization-teams" | "saml" | "teams";
+export declare const RequestAccessToTeamResponseJoinedFromOrigin: any;
+export type RequestAccessToTeamResponseJoinedFromGitUserId = string | number;
+export declare const RequestAccessToTeamResponseJoinedFromGitUserId: S.Schema<RequestAccessToTeamResponseJoinedFromGitUserId>;
+export interface RequestAccessToTeamResponseJoinedFrom {
+    origin: RequestAccessToTeamResponseJoinedFromOrigin;
+    commitId?: string;
+    repoId?: string;
+    repoPath?: string;
+    gitUserId?: RequestAccessToTeamResponseJoinedFromGitUserId;
+    gitUserLogin?: string;
+    ssoUserId?: string;
+    ssoConnectedAt?: number;
+    idpUserId?: string;
+    dsyncUserId?: string;
+    dsyncConnectedAt?: number;
+}
+export declare const RequestAccessToTeamResponseJoinedFrom: S.Schema<RequestAccessToTeamResponseJoinedFrom>;
+export type RequestAccessToTeamResponseGithub = GetTeamAccessRequestResponseGithub;
+export declare const RequestAccessToTeamResponseGithub: S.Schema<GetTeamAccessRequestResponseGithub>;
+export type RequestAccessToTeamResponseGitlab = GetTeamAccessRequestResponseGithub;
+export declare const RequestAccessToTeamResponseGitlab: S.Schema<GetTeamAccessRequestResponseGithub>;
+export type RequestAccessToTeamResponseBitbucket = GetTeamAccessRequestResponseGithub;
+export declare const RequestAccessToTeamResponseBitbucket: S.Schema<GetTeamAccessRequestResponseGithub>;
+export interface RequestAccessToTeamResponse {
+    teamSlug: string;
+    teamName: string;
+    confirmed?: boolean;
+    joinedFrom?: RequestAccessToTeamResponseJoinedFrom;
+    accessRequestedAt?: number;
+    github: GetTeamAccessRequestResponseGithub | null;
+    gitlab: GetTeamAccessRequestResponseGithub | null;
+    bitbucket: GetTeamAccessRequestResponseGithub | null;
+}
+export declare const RequestAccessToTeamResponse: S.Schema<RequestAccessToTeamResponse>;
+export interface UpdateMicrofrontendsGroupRequest {
+    /** The Team identifier to perform the request on behalf of. */
+    teamId: string;
+    groupId: string;
+    /** The Team slug to perform the request on behalf of. */
+    slug?: string;
+    /** The new name for the existing microfrontends group. */
+    name?: string;
+    /** The new fallback environment for the microfrontends group. Must be "SAME_ENV", "PRODUCTION", or a valid custom environment slug from the default app. */
+    fallbackEnvironment?: string;
+    /** Whether Preview Deployments can link to branches with the same name in other Git repositories. */
+    enablePolyrepoBranchRouting?: boolean;
+}
+export declare const UpdateMicrofrontendsGroupRequest: S.Schema<UpdateMicrofrontendsGroupRequest>;
+export interface UpdateMicrofrontendsGroupResponseUpdatedMicrofrontendsGroup {
+    name?: string;
+    slug?: string;
+    id: string;
+    fallbackEnvironment?: string;
+    enablePolyrepoBranchRouting?: boolean;
+}
+export declare const UpdateMicrofrontendsGroupResponseUpdatedMicrofrontendsGroup: S.Schema<UpdateMicrofrontendsGroupResponseUpdatedMicrofrontendsGroup>;
+export interface UpdateMicrofrontendsGroupResponse {
+    updatedMicrofrontendsGroup: UpdateMicrofrontendsGroupResponseUpdatedMicrofrontendsGroup;
+}
+export declare const UpdateMicrofrontendsGroupResponse: S.Schema<UpdateMicrofrontendsGroupResponse>;
+export type UpdateTeamRequestSamlRolesValueCase0 = "OWNER" | "MEMBER" | "DEVELOPER" | "SECURITY" | "BILLING" | "VIEWER" | "VIEWER_FOR_PLUS" | "CONTRIBUTOR";
+export declare const UpdateTeamRequestSamlRolesValueCase0: any;
+export type UpdateTeamRequestSamlRolesValueCase1 = CreateTeamDsyncRoleRequestRolesValueCase1;
+export declare const UpdateTeamRequestSamlRolesValueCase1: S.Schema<CreateTeamDsyncRoleRequestRolesValueCase1>;
+export type UpdateTeamRequestSamlRolesValue = UpdateTeamRequestSamlRolesValueCase0 | CreateTeamDsyncRoleRequestRolesValueCase1;
+export declare const UpdateTeamRequestSamlRolesValue: S.Schema<UpdateTeamRequestSamlRolesValue>;
+/** Directory groups to role or access group mappings. */
+export type UpdateTeamRequestSamlRolesMap = {
+    [key: string]: UpdateTeamRequestSamlRolesValue | undefined;
+};
+export declare const UpdateTeamRequestSamlRolesMap: S.Schema<UpdateTeamRequestSamlRolesMap>;
+export interface UpdateTeamRequestSaml {
+    /** Require that members of the team use SAML Single Sign-On. */
+    enforced?: boolean;
+    /** Directory groups to role or access group mappings. */
+    roles?: UpdateTeamRequestSamlRolesMap;
+}
+export declare const UpdateTeamRequestSaml: S.Schema<UpdateTeamRequestSaml>;
+/** Whether or not remote caching is enabled for the team */
+export interface UpdateTeamRequestRemoteCaching {
+    /** Enable or disable remote caching for the team. */
+    enabled?: boolean;
+}
+export declare const UpdateTeamRequestRemoteCaching: S.Schema<UpdateTeamRequestRemoteCaching>;
+/** Controls who can request access to protected deployments. */
+export type UpdateTeamRequestDpAccessRequestsMode = "all" | "none" | "email-domain";
+export declare const UpdateTeamRequestDpAccessRequestsMode: any;
+/** Specify if the password will apply to every Deployment Target or just Preview */
+export type UpdateTeamRequestDefaultDeploymentProtectionPasswordProtectionDeploymentType = "all" | "preview" | "prod_deployment_urls_and_all_previews" | "all_except_custom_domains";
+export declare const UpdateTeamRequestDefaultDeploymentProtectionPasswordProtectionDeploymentType: any;
+/** Allows to protect project deployments with a password */
+export interface UpdateTeamRequestDefaultDeploymentProtectionPasswordProtection {
+    /** Specify if the password will apply to every Deployment Target or just Preview */
+    deploymentType: UpdateTeamRequestDefaultDeploymentProtectionPasswordProtectionDeploymentType | (string & {});
+    /** The password that will be used to protect Project Deployments */
+    password?: string | Redacted.Redacted<string> | null;
+}
+export declare const UpdateTeamRequestDefaultDeploymentProtectionPasswordProtection: S.Schema<UpdateTeamRequestDefaultDeploymentProtectionPasswordProtection>;
+/** Specify if the Vercel Authentication (SSO Protection) will apply to every Deployment Target or just Preview */
+export type UpdateTeamRequestDefaultDeploymentProtectionSsoProtectionDeploymentType = "all" | "preview" | "prod_deployment_urls_and_all_previews" | "all_except_custom_domains";
+export declare const UpdateTeamRequestDefaultDeploymentProtectionSsoProtectionDeploymentType: any;
+/** Ensures visitors to your Preview Deployments are logged into Vercel and have a minimum of Viewer access on your team */
+export interface UpdateTeamRequestDefaultDeploymentProtectionSsoProtection {
+    /** Specify if the Vercel Authentication (SSO Protection) will apply to every Deployment Target or just Preview */
+    deploymentType: UpdateTeamRequestDefaultDeploymentProtectionSsoProtectionDeploymentType | (string & {});
+}
+export declare const UpdateTeamRequestDefaultDeploymentProtectionSsoProtection: S.Schema<UpdateTeamRequestDefaultDeploymentProtectionSsoProtection>;
+/** Default deployment protection settings for new projects. */
+export interface UpdateTeamRequestDefaultDeploymentProtection {
+    /** Allows to protect project deployments with a password */
+    passwordProtection?: UpdateTeamRequestDefaultDeploymentProtectionPasswordProtection | null;
+    /** Ensures visitors to your Preview Deployments are logged into Vercel and have a minimum of Viewer access on your team */
+    ssoProtection?: UpdateTeamRequestDefaultDeploymentProtectionSsoProtection | null;
+}
+export declare const UpdateTeamRequestDefaultDeploymentProtection: S.Schema<UpdateTeamRequestDefaultDeploymentProtection>;
+export type UpdateTeamRequestDefaultPassportDeploymentType = "all" | "preview" | "prod_deployment_urls_and_all_previews" | "all_except_custom_domains";
+export declare const UpdateTeamRequestDefaultPassportDeploymentType: any;
+/** Default Passport configuration for new projects. */
+export interface UpdateTeamRequestDefaultPassport {
+    connectorId: string;
+    deploymentType?: UpdateTeamRequestDefaultPassportDeploymentType | (string & {});
+}
+export declare const UpdateTeamRequestDefaultPassport: S.Schema<UpdateTeamRequestDefaultPassport>;
+/** The time period to keep non-production deployments for */
+export type UpdateTeamRequestDefaultExpirationSettingsExpiration = "3y" | "2y" | "1y" | "6m" | "3m" | "2m" | "1m" | "2w" | "1w" | "1d" | "unlimited";
+export declare const UpdateTeamRequestDefaultExpirationSettingsExpiration: any;
+/** The time period to keep production deployments for */
+export type UpdateTeamRequestDefaultExpirationSettingsExpirationProduction = "3y" | "2y" | "1y" | "6m" | "3m" | "2m" | "1m" | "2w" | "1w" | "1d" | "unlimited";
+export declare const UpdateTeamRequestDefaultExpirationSettingsExpirationProduction: any;
+/** The time period to keep canceled deployments for */
+export type UpdateTeamRequestDefaultExpirationSettingsExpirationCanceled = "1y" | "6m" | "3m" | "2m" | "1m" | "2w" | "1w" | "1d" | "unlimited";
+export declare const UpdateTeamRequestDefaultExpirationSettingsExpirationCanceled: any;
+/** The time period to keep errored deployments for */
+export type UpdateTeamRequestDefaultExpirationSettingsExpirationErrored = "1y" | "6m" | "3m" | "2m" | "1m" | "2w" | "1w" | "1d" | "unlimited";
+export declare const UpdateTeamRequestDefaultExpirationSettingsExpirationErrored: any;
+export interface UpdateTeamRequestDefaultExpirationSettings {
+    /** The time period to keep non-production deployments for */
+    expiration?: UpdateTeamRequestDefaultExpirationSettingsExpiration | (string & {});
+    /** The time period to keep production deployments for */
+    expirationProduction?: UpdateTeamRequestDefaultExpirationSettingsExpirationProduction | (string & {});
+    /** The time period to keep canceled deployments for */
+    expirationCanceled?: UpdateTeamRequestDefaultExpirationSettingsExpirationCanceled | (string & {});
+    /** The time period to keep errored deployments for */
+    expirationErrored?: UpdateTeamRequestDefaultExpirationSettingsExpirationErrored | (string & {});
+}
+export declare const UpdateTeamRequestDefaultExpirationSettings: S.Schema<UpdateTeamRequestDefaultExpirationSettings>;
+export type UpdateTeamRequestDeploymentPolicyCase0GitSourcesCase0ItemEnvironmentsItemCase0Type = "system";
+export declare const UpdateTeamRequestDeploymentPolicyCase0GitSourcesCase0ItemEnvironmentsItemCase0Type: any;
+export type UpdateTeamRequestDeploymentPolicyCase0GitSourcesCase0ItemEnvironmentsItemCase0Target = "production" | "preview";
+export declare const UpdateTeamRequestDeploymentPolicyCase0GitSourcesCase0ItemEnvironmentsItemCase0Target: any;
+export interface UpdateTeamRequestDeploymentPolicyCase0GitSourcesCase0ItemEnvironmentsItemCase0 {
+    type: UpdateTeamRequestDeploymentPolicyCase0GitSourcesCase0ItemEnvironmentsItemCase0Type;
+    target: UpdateTeamRequestDeploymentPolicyCase0GitSourcesCase0ItemEnvironmentsItemCase0Target | (string & {});
+}
+export declare const UpdateTeamRequestDeploymentPolicyCase0GitSourcesCase0ItemEnvironmentsItemCase0: S.Schema<UpdateTeamRequestDeploymentPolicyCase0GitSourcesCase0ItemEnvironmentsItemCase0>;
+export type UpdateTeamRequestDeploymentPolicyCase0GitSourcesCase0ItemEnvironmentsItemCase1Type = "custom";
+export declare const UpdateTeamRequestDeploymentPolicyCase0GitSourcesCase0ItemEnvironmentsItemCase1Type: any;
+export interface UpdateTeamRequestDeploymentPolicyCase0GitSourcesCase0ItemEnvironmentsItemCase1 {
+    type: UpdateTeamRequestDeploymentPolicyCase0GitSourcesCase0ItemEnvironmentsItemCase1Type;
+    environmentId: string;
+}
+export declare const UpdateTeamRequestDeploymentPolicyCase0GitSourcesCase0ItemEnvironmentsItemCase1: S.Schema<UpdateTeamRequestDeploymentPolicyCase0GitSourcesCase0ItemEnvironmentsItemCase1>;
+export type UpdateTeamRequestDeploymentPolicyCase0GitSourcesCase0ItemEnvironmentsItem = UpdateTeamRequestDeploymentPolicyCase0GitSourcesCase0ItemEnvironmentsItemCase0 | UpdateTeamRequestDeploymentPolicyCase0GitSourcesCase0ItemEnvironmentsItemCase1;
+export declare const UpdateTeamRequestDeploymentPolicyCase0GitSourcesCase0ItemEnvironmentsItem: S.Schema<UpdateTeamRequestDeploymentPolicyCase0GitSourcesCase0ItemEnvironmentsItem>;
+export type UpdateTeamRequestDeploymentPolicyCase0GitSourcesCase0ItemEnvironmentsList = Array<UpdateTeamRequestDeploymentPolicyCase0GitSourcesCase0ItemEnvironmentsItem>;
+export declare const UpdateTeamRequestDeploymentPolicyCase0GitSourcesCase0ItemEnvironmentsList: S.Schema<UpdateTeamRequestDeploymentPolicyCase0GitSourcesCase0ItemEnvironmentsList>;
+export type UpdateTeamRequestDeploymentPolicyCase0GitSourcesCase0ItemSourcesItemCase0Provider = "github" | "bitbucket";
+export declare const UpdateTeamRequestDeploymentPolicyCase0GitSourcesCase0ItemSourcesItemCase0Provider: any;
+export interface UpdateTeamRequestDeploymentPolicyCase0GitSourcesCase0ItemSourcesItemCase0 {
+    provider: UpdateTeamRequestDeploymentPolicyCase0GitSourcesCase0ItemSourcesItemCase0Provider | (string & {});
+    org: string;
+    repo?: string;
+}
+export declare const UpdateTeamRequestDeploymentPolicyCase0GitSourcesCase0ItemSourcesItemCase0: S.Schema<UpdateTeamRequestDeploymentPolicyCase0GitSourcesCase0ItemSourcesItemCase0>;
+export type UpdateTeamRequestDeploymentPolicyCase0GitSourcesCase0ItemSourcesItemCase1Provider = "gitlab";
+export declare const UpdateTeamRequestDeploymentPolicyCase0GitSourcesCase0ItemSourcesItemCase1Provider: any;
+export interface UpdateTeamRequestDeploymentPolicyCase0GitSourcesCase0ItemSourcesItemCase1 {
+    provider: UpdateTeamRequestDeploymentPolicyCase0GitSourcesCase0ItemSourcesItemCase1Provider;
+    namespace: string;
+    project?: string;
+}
+export declare const UpdateTeamRequestDeploymentPolicyCase0GitSourcesCase0ItemSourcesItemCase1: S.Schema<UpdateTeamRequestDeploymentPolicyCase0GitSourcesCase0ItemSourcesItemCase1>;
+export type UpdateTeamRequestDeploymentPolicyCase0GitSourcesCase0ItemSourcesItem = UpdateTeamRequestDeploymentPolicyCase0GitSourcesCase0ItemSourcesItemCase0 | UpdateTeamRequestDeploymentPolicyCase0GitSourcesCase0ItemSourcesItemCase1;
+export declare const UpdateTeamRequestDeploymentPolicyCase0GitSourcesCase0ItemSourcesItem: S.Schema<UpdateTeamRequestDeploymentPolicyCase0GitSourcesCase0ItemSourcesItem>;
+export type UpdateTeamRequestDeploymentPolicyCase0GitSourcesCase0ItemSourcesList = Array<UpdateTeamRequestDeploymentPolicyCase0GitSourcesCase0ItemSourcesItem>;
+export declare const UpdateTeamRequestDeploymentPolicyCase0GitSourcesCase0ItemSourcesList: S.Schema<UpdateTeamRequestDeploymentPolicyCase0GitSourcesCase0ItemSourcesList>;
+export interface UpdateTeamRequestDeploymentPolicyCase0GitSourcesCase0Item {
+    enabled: boolean;
+    environments: UpdateTeamRequestDeploymentPolicyCase0GitSourcesCase0ItemEnvironmentsList;
+    sources: UpdateTeamRequestDeploymentPolicyCase0GitSourcesCase0ItemSourcesList;
+}
+export declare const UpdateTeamRequestDeploymentPolicyCase0GitSourcesCase0Item: S.Schema<UpdateTeamRequestDeploymentPolicyCase0GitSourcesCase0Item>;
+export type UpdateTeamRequestDeploymentPolicyCase0GitSourcesCase0List = Array<UpdateTeamRequestDeploymentPolicyCase0GitSourcesCase0Item>;
+export declare const UpdateTeamRequestDeploymentPolicyCase0GitSourcesCase0List: S.Schema<UpdateTeamRequestDeploymentPolicyCase0GitSourcesCase0List>;
+export type UpdateTeamRequestDeploymentPolicyCase0GitSources = UpdateTeamRequestDeploymentPolicyCase0GitSourcesCase0List | string;
+export declare const UpdateTeamRequestDeploymentPolicyCase0GitSources: S.Schema<UpdateTeamRequestDeploymentPolicyCase0GitSources>;
+export type UpdateTeamRequestDeploymentPolicyCase0DeploymentSourcesCase0ItemEnvironmentsItemCase0Type = "system";
+export declare const UpdateTeamRequestDeploymentPolicyCase0DeploymentSourcesCase0ItemEnvironmentsItemCase0Type: any;
+export type UpdateTeamRequestDeploymentPolicyCase0DeploymentSourcesCase0ItemEnvironmentsItemCase0Target = "production" | "preview";
+export declare const UpdateTeamRequestDeploymentPolicyCase0DeploymentSourcesCase0ItemEnvironmentsItemCase0Target: any;
+export interface UpdateTeamRequestDeploymentPolicyCase0DeploymentSourcesCase0ItemEnvironmentsItemCase0 {
+    type: UpdateTeamRequestDeploymentPolicyCase0DeploymentSourcesCase0ItemEnvironmentsItemCase0Type;
+    target: UpdateTeamRequestDeploymentPolicyCase0DeploymentSourcesCase0ItemEnvironmentsItemCase0Target | (string & {});
+}
+export declare const UpdateTeamRequestDeploymentPolicyCase0DeploymentSourcesCase0ItemEnvironmentsItemCase0: S.Schema<UpdateTeamRequestDeploymentPolicyCase0DeploymentSourcesCase0ItemEnvironmentsItemCase0>;
+export type UpdateTeamRequestDeploymentPolicyCase0DeploymentSourcesCase0ItemEnvironmentsItemCase1Type = "custom";
+export declare const UpdateTeamRequestDeploymentPolicyCase0DeploymentSourcesCase0ItemEnvironmentsItemCase1Type: any;
+export interface UpdateTeamRequestDeploymentPolicyCase0DeploymentSourcesCase0ItemEnvironmentsItemCase1 {
+    type: UpdateTeamRequestDeploymentPolicyCase0DeploymentSourcesCase0ItemEnvironmentsItemCase1Type;
+    environmentId: string;
+}
+export declare const UpdateTeamRequestDeploymentPolicyCase0DeploymentSourcesCase0ItemEnvironmentsItemCase1: S.Schema<UpdateTeamRequestDeploymentPolicyCase0DeploymentSourcesCase0ItemEnvironmentsItemCase1>;
+export type UpdateTeamRequestDeploymentPolicyCase0DeploymentSourcesCase0ItemEnvironmentsItem = UpdateTeamRequestDeploymentPolicyCase0DeploymentSourcesCase0ItemEnvironmentsItemCase0 | UpdateTeamRequestDeploymentPolicyCase0DeploymentSourcesCase0ItemEnvironmentsItemCase1;
+export declare const UpdateTeamRequestDeploymentPolicyCase0DeploymentSourcesCase0ItemEnvironmentsItem: S.Schema<UpdateTeamRequestDeploymentPolicyCase0DeploymentSourcesCase0ItemEnvironmentsItem>;
+export type UpdateTeamRequestDeploymentPolicyCase0DeploymentSourcesCase0ItemEnvironmentsList = Array<UpdateTeamRequestDeploymentPolicyCase0DeploymentSourcesCase0ItemEnvironmentsItem>;
+export declare const UpdateTeamRequestDeploymentPolicyCase0DeploymentSourcesCase0ItemEnvironmentsList: S.Schema<UpdateTeamRequestDeploymentPolicyCase0DeploymentSourcesCase0ItemEnvironmentsList>;
+export type UpdateTeamRequestDeploymentPolicyCase0DeploymentSourcesCase0ItemSourcesItem = "git" | "cli" | "rest-api" | "deploy-hook" | "integration" | "v0";
+export declare const UpdateTeamRequestDeploymentPolicyCase0DeploymentSourcesCase0ItemSourcesItem: any;
+export type UpdateTeamRequestDeploymentPolicyCase0DeploymentSourcesCase0ItemSourcesList = Array<UpdateTeamRequestDeploymentPolicyCase0DeploymentSourcesCase0ItemSourcesItem | (string & {})>;
+export declare const UpdateTeamRequestDeploymentPolicyCase0DeploymentSourcesCase0ItemSourcesList: S.Schema<UpdateTeamRequestDeploymentPolicyCase0DeploymentSourcesCase0ItemSourcesList>;
+export interface UpdateTeamRequestDeploymentPolicyCase0DeploymentSourcesCase0Item {
+    enabled: boolean;
+    environments: UpdateTeamRequestDeploymentPolicyCase0DeploymentSourcesCase0ItemEnvironmentsList;
+    sources: UpdateTeamRequestDeploymentPolicyCase0DeploymentSourcesCase0ItemSourcesList;
+}
+export declare const UpdateTeamRequestDeploymentPolicyCase0DeploymentSourcesCase0Item: S.Schema<UpdateTeamRequestDeploymentPolicyCase0DeploymentSourcesCase0Item>;
+export type UpdateTeamRequestDeploymentPolicyCase0DeploymentSourcesCase0List = Array<UpdateTeamRequestDeploymentPolicyCase0DeploymentSourcesCase0Item>;
+export declare const UpdateTeamRequestDeploymentPolicyCase0DeploymentSourcesCase0List: S.Schema<UpdateTeamRequestDeploymentPolicyCase0DeploymentSourcesCase0List>;
+export type UpdateTeamRequestDeploymentPolicyCase0DeploymentSources = UpdateTeamRequestDeploymentPolicyCase0DeploymentSourcesCase0List | string;
+export declare const UpdateTeamRequestDeploymentPolicyCase0DeploymentSources: S.Schema<UpdateTeamRequestDeploymentPolicyCase0DeploymentSources>;
+/** Composable deployment-time policy. Each rule type holds a list of rules, one per environment scope. */
+export interface UpdateTeamRequestDeploymentPolicyCase0 {
+    gitSources?: UpdateTeamRequestDeploymentPolicyCase0GitSources;
+    deploymentSources?: UpdateTeamRequestDeploymentPolicyCase0DeploymentSources;
+}
+export declare const UpdateTeamRequestDeploymentPolicyCase0: S.Schema<UpdateTeamRequestDeploymentPolicyCase0>;
+export type UpdateTeamRequestDeploymentPolicy = UpdateTeamRequestDeploymentPolicyCase0 | string;
+export declare const UpdateTeamRequestDeploymentPolicy: S.Schema<UpdateTeamRequestDeploymentPolicy>;
+/** When enabled, deployment protection settings require stricter permissions (owner-only). */
+export interface UpdateTeamRequestStrictDeploymentProtectionSettings {
+    /** Enable or disable strict deployment protection settings. */
+    enabled: boolean;
+}
+export declare const UpdateTeamRequestStrictDeploymentProtectionSettings: S.Schema<UpdateTeamRequestStrictDeploymentProtectionSettings>;
+/** When enabled, creating shareable links requires Owner role. */
+export interface UpdateTeamRequestStrictShareableLinks {
+    /** Enable or disable requiring Owner role to create shareable links. */
+    enabled: boolean;
+}
+export declare const UpdateTeamRequestStrictShareableLinks: S.Schema<UpdateTeamRequestStrictShareableLinks>;
+/** When enabled, adding, changing, or removing project password protection requires Owner role. */
+export interface UpdateTeamRequestStrictPasswordProtectionSettings {
+    /** Enable or disable requiring Owner role to change project password protection. */
+    enabled: boolean;
+}
+export declare const UpdateTeamRequestStrictPasswordProtectionSettings: S.Schema<UpdateTeamRequestStrictPasswordProtectionSettings>;
+/** When enabled, creating and managing connectors requires Owner role. */
+export interface UpdateTeamRequestStrictConnectors {
+    /** Enable or disable requiring Owner role to manage connectors. */
+    enabled: boolean;
+}
+export declare const UpdateTeamRequestStrictConnectors: S.Schema<UpdateTeamRequestStrictConnectors>;
+/** The NSNB preference for the team. */
+export type UpdateTeamRequestNsnbConfigCase0Preference = "auto-approval" | "manual-approval" | "block";
+export declare const UpdateTeamRequestNsnbConfigCase0Preference: any;
+/** NSNB configuration for the team. */
+export interface UpdateTeamRequestNsnbConfigCase0 {
+    /** The NSNB preference for the team. */
+    preference: UpdateTeamRequestNsnbConfigCase0Preference | (string & {});
+}
+export declare const UpdateTeamRequestNsnbConfigCase0: S.Schema<UpdateTeamRequestNsnbConfigCase0>;
+export type UpdateTeamRequestNsnbConfig = UpdateTeamRequestNsnbConfigCase0 | string;
+export declare const UpdateTeamRequestNsnbConfig: S.Schema<UpdateTeamRequestNsnbConfig>;
+export type UpdateTeamRequestDefaultProjectJobsCase0LintTargetsList = Array<string>;
+export declare const UpdateTeamRequestDefaultProjectJobsCase0LintTargetsList: S.Schema<UpdateTeamRequestDefaultProjectJobsCase0LintTargetsList>;
+export interface UpdateTeamRequestDefaultProjectJobsCase0Lint {
+    targets: UpdateTeamRequestDefaultProjectJobsCase0LintTargetsList;
+}
+export declare const UpdateTeamRequestDefaultProjectJobsCase0Lint: S.Schema<UpdateTeamRequestDefaultProjectJobsCase0Lint>;
+export type UpdateTeamRequestDefaultProjectJobsCase0TypecheckTargetsList = Array<string>;
+export declare const UpdateTeamRequestDefaultProjectJobsCase0TypecheckTargetsList: S.Schema<UpdateTeamRequestDefaultProjectJobsCase0TypecheckTargetsList>;
+export interface UpdateTeamRequestDefaultProjectJobsCase0Typecheck {
+    targets: UpdateTeamRequestDefaultProjectJobsCase0TypecheckTargetsList;
+}
+export declare const UpdateTeamRequestDefaultProjectJobsCase0Typecheck: S.Schema<UpdateTeamRequestDefaultProjectJobsCase0Typecheck>;
+/** Default job configuration applied to new projects created in this team. */
+export interface UpdateTeamRequestDefaultProjectJobsCase0 {
+    lint?: UpdateTeamRequestDefaultProjectJobsCase0Lint;
+    typecheck?: UpdateTeamRequestDefaultProjectJobsCase0Typecheck;
+}
+export declare const UpdateTeamRequestDefaultProjectJobsCase0: S.Schema<UpdateTeamRequestDefaultProjectJobsCase0>;
+export type UpdateTeamRequestDefaultProjectJobs = UpdateTeamRequestDefaultProjectJobsCase0 | string;
+export declare const UpdateTeamRequestDefaultProjectJobs: S.Schema<UpdateTeamRequestDefaultProjectJobs>;
+/** Default build machine type for new builds: standard, enhanced, turbo, or elastic. */
+export type UpdateTeamRequestResourceConfigBuildMachineDefault = "basic" | "enhanced" | "turbo" | "standard" | "elastic";
+export declare const UpdateTeamRequestResourceConfigBuildMachineDefault: any;
+/** Build machine configuration. */
+export interface UpdateTeamRequestResourceConfigBuildMachine {
+    /** Default build machine type for new builds: standard, enhanced, turbo, or elastic. */
+    default?: UpdateTeamRequestResourceConfigBuildMachineDefault | (string & {});
+}
+export declare const UpdateTeamRequestResourceConfigBuildMachine: S.Schema<UpdateTeamRequestResourceConfigBuildMachine>;
+/** Resource configuration for the team. */
+export interface UpdateTeamRequestResourceConfig {
+    /** Build machine configuration. */
+    buildMachine?: UpdateTeamRequestResourceConfigBuildMachine;
+}
+export declare const UpdateTeamRequestResourceConfig: S.Schema<UpdateTeamRequestResourceConfig>;
+export interface UpdateTeamRequest {
+    /** The Team identifier to perform the request on behalf of. */
+    teamId: string;
+    /** The Team slug to perform the request on behalf of. */
+    slug?: string;
+    /** The hash value of an uploaded image, or `null` to clear the avatar. */
+    avatar?: string | null;
+    /** A short text that describes the team. */
+    description?: string;
+    emailDomain?: string | null;
+    /** The name of the team. */
+    name?: string;
+    /** Suffix that will be used for all preview deployments. */
+    previewDeploymentSuffix?: string | null;
+    /** Create a new invite code and replace the current one. */
+    regenerateInviteCode?: boolean;
+    saml?: UpdateTeamRequestSaml;
+    /** Enable preview toolbar: one of on, off or default. */
+    enablePreviewFeedback?: string;
+    /** Enable production toolbar: one of on, off or default. */
+    enableProductionFeedback?: string;
+    /** Sensitive environment variable policy: one of on, off or default. */
+    sensitiveEnvironmentVariablePolicy?: string;
+    /** Require production secrets to be in their own environment group: one of on, off or default. */
+    disjunctiveProductionSecretPolicy?: string;
+    /** Whether or not remote caching is enabled for the team */
+    remoteCaching?: UpdateTeamRequestRemoteCaching;
+    /** Display or hide IP addresses in Monitoring queries. */
+    hideIpAddresses?: boolean;
+    /** Display or hide IP addresses in Log Drains. */
+    hideIpAddressesInLogDrains?: boolean;
+    /** Controls who can request access to protected deployments. */
+    dpAccessRequestsMode?: UpdateTeamRequestDpAccessRequestsMode | (string & {});
+    /** When enabled, all projects in the team require commits to be signed and verified by the git provider before deployments will be created. */
+    requireVerifiedCommits?: boolean;
+    /** Default for projects in the team. When `true`, projects in this team will not emit GitHub repository-dispatch events on deployment events unless the project explicitly overrides this setting. */
+    disableRepositoryDispatchEvents?: boolean;
+    /** Default deployment protection settings for new projects. */
+    defaultDeploymentProtection?: UpdateTeamRequestDefaultDeploymentProtection;
+    /** Default Passport configuration for new projects. */
+    defaultPassport?: UpdateTeamRequestDefaultPassport | null;
+    defaultExpirationSettings?: UpdateTeamRequestDefaultExpirationSettings;
+    deploymentPolicy?: UpdateTeamRequestDeploymentPolicy;
+    /** When enabled, deployment protection settings require stricter permissions (owner-only). */
+    strictDeploymentProtectionSettings?: UpdateTeamRequestStrictDeploymentProtectionSettings;
+    /** When enabled, creating shareable links requires Owner role. */
+    strictShareableLinks?: UpdateTeamRequestStrictShareableLinks;
+    /** When enabled, adding, changing, or removing project password protection requires Owner role. */
+    strictPasswordProtectionSettings?: UpdateTeamRequestStrictPasswordProtectionSettings;
+    /** When enabled, creating and managing connectors requires Owner role. */
+    strictConnectors?: UpdateTeamRequestStrictConnectors;
+    nsnbConfig?: UpdateTeamRequestNsnbConfig;
+    defaultProjectJobs?: UpdateTeamRequestDefaultProjectJobs;
+    /** Resource configuration for the team. */
+    resourceConfig?: UpdateTeamRequestResourceConfig;
+}
+export declare const UpdateTeamRequest: S.Schema<UpdateTeamRequest>;
+export type UpdateTeamMemberRequestTeamPermissionsItem = "ConnectorManager" | "IntegrationManager" | "CreateProject" | "FullProductionDeployment" | "UsageViewer" | "EnvVariableManager" | "EnvironmentManager" | "WorkflowDecryptor" | "OrgAdmin" | "OrgViewer" | "AiGatewaySettings" | "AiGatewayCredits" | "AiGatewayApiKeyOwnedBySelf" | "AiGatewayBudgetManager" | "AiGatewayTranscriptsManager" | "AiGatewayTranscriptsViewer" | "V0Builder" | "V0Chatter" | "V0Viewer";
+export declare const UpdateTeamMemberRequestTeamPermissionsItem: any;
+/** The team permissions to set for the member. Permissions must be compatible with the team roles assigned to the member. */
+export type UpdateTeamMemberRequestTeamPermissionsList = Array<UpdateTeamMemberRequestTeamPermissionsItem | (string & {})>;
+export declare const UpdateTeamMemberRequestTeamPermissionsList: S.Schema<UpdateTeamMemberRequestTeamPermissionsList>;
+/** The project role of the member that will be added. \"null\" will remove this project level role. */
+export type UpdateTeamMemberRequestProjectsItemRole = "ADMIN" | "PROJECT_VIEWER" | "PROJECT_DEVELOPER";
+export declare const UpdateTeamMemberRequestProjectsItemRole: any;
+export interface UpdateTeamMemberRequestProjectsItem {
+    /** The ID of the project. */
+    projectId: string;
+    /** The project role of the member that will be added. \"null\" will remove this project level role. */
+    role: UpdateTeamMemberRequestProjectsItemRole | (string & {}) | null;
+}
+export declare const UpdateTeamMemberRequestProjectsItem: S.Schema<UpdateTeamMemberRequestProjectsItem>;
+export type UpdateTeamMemberRequestProjectsList = Array<UpdateTeamMemberRequestProjectsItem>;
+export declare const UpdateTeamMemberRequestProjectsList: S.Schema<UpdateTeamMemberRequestProjectsList>;
+export interface UpdateTeamMemberRequestJoinedFrom {
+    ssoUserId?: unknown | null;
+}
+export declare const UpdateTeamMemberRequestJoinedFrom: S.Schema<UpdateTeamMemberRequestJoinedFrom>;
+export interface UpdateTeamMemberRequest {
+    teamId: string;
+    /** The ID of the member. */
+    uid: string;
+    /** Accept a user who requested access to the team. */
+    confirmed?: boolean;
+    /** The role in the team of the member. */
+    role?: string;
+    /** The team permissions to set for the member. Permissions must be compatible with the team roles assigned to the member. */
+    teamPermissions?: UpdateTeamMemberRequestTeamPermissionsList;
+    projects?: UpdateTeamMemberRequestProjectsList;
+    joinedFrom?: UpdateTeamMemberRequestJoinedFrom;
+}
+export declare const UpdateTeamMemberRequest: S.Schema<UpdateTeamMemberRequest>;
+export interface UpdateTeamMemberResponse {
+    /** ID of the team. */
+    id: string;
+}
+export declare const UpdateTeamMemberResponse: S.Schema<UpdateTeamMemberResponse>;
+export type CreateTeamError = BadRequest | Forbidden | NotFound | Conflict | VercelOpError;
+/** Create a Team Create a new Team under your account. You need to send a POST request with the desired Team slug, and optionally the Team name. */
+export declare const createTeam: API.OperationMethod<CreateTeamRequest, CreateTeamResponse, CreateTeamError, VercelOpContext>;
+export type CreateTeamDsyncRoleError = BadRequest | Forbidden | VercelOpError;
+/** Update Team Directory Sync Role Mappings Update the Directory Sync role mappings for a Team. This endpoint allows updating the mapping between directory groups and team roles or access groups. */
+export declare const createTeamDsyncRole: API.OperationMethod<CreateTeamDsyncRoleRequest, CreateTeamDsyncRoleResponse, CreateTeamDsyncRoleError, VercelOpContext>;
+export type DeleteMicrofrontendsGroupError = BadRequest | Forbidden | NotFound | VercelOpError;
+/** Delete a microfrontends group Deletes a microfrontends group from the team associated with the group ID. */
+export declare const deleteMicrofrontendsGroup: API.OperationMethod<DeleteMicrofrontendsGroupRequest, DeleteMicrofrontendsGroupResponse, DeleteMicrofrontendsGroupError, VercelOpContext>;
+export type DeleteTeamError = BadRequest | PaymentRequired | Forbidden | Conflict | VercelOpError;
+/** Delete a Team Delete a team under your account. You need to send a `DELETE` request with the desired team `id`. An optional array of reasons for deletion may also be sent. */
+export declare const deleteTeam: API.OperationMethod<DeleteTeamRequest, DeleteTeamResponse, DeleteTeamError, VercelOpContext>;
+export type DeleteTeamInviteCodeError = BadRequest | Forbidden | NotFound | VercelOpError;
+/** Delete a Team invite code Delete an active Team invite code. */
+export declare const deleteTeamInviteCode: API.OperationMethod<DeleteTeamInviteCodeRequest, DeleteTeamInviteCodeResponse, DeleteTeamInviteCodeError, VercelOpContext>;
+export type GetTeamError = BadRequest | Forbidden | NotFound | VercelOpError;
+/** Get a Team Get information for the Team specified by the `teamId` parameter. */
+export declare const getTeam: API.OperationMethod<GetTeamRequest, Team, GetTeamError, VercelOpContext>;
+export type GetTeamAccessRequestError = BadRequest | Forbidden | NotFound | VercelOpError;
+/** Get access request status Check the status of a join request. It'll respond with a 404 if the request has been declined. If no `userId` path segment was provided, this endpoint will instead return the status of the authenticated user. */
+export declare const getTeamAccessRequest: API.OperationMethod<GetTeamAccessRequestRequest, GetTeamAccessRequestResponse, GetTeamAccessRequestError, VercelOpContext>;
+export type GetTeamMembersError = BadRequest | Forbidden | NotFound | VercelOpError;
+/** List team members Get a paginated list of team members for the provided team. */
+export declare const getTeamMembers: API.OperationMethod<GetTeamMembersRequest, GetTeamMembersResponse, GetTeamMembersError, VercelOpContext>;
+export type GetTeamsError = BadRequest | Forbidden | VercelOpError;
+/** List all teams Get a paginated list of all the Teams the authenticated User is a member of. */
+export declare const getTeams: API.OperationMethod<GetTeamsRequest, GetTeamsResponse, GetTeamsError, VercelOpContext>;
+export type InviteUserToTeamError = BadRequest | Forbidden | VercelOpError;
+/** Invite a user Invite a user to join the team specified in the URL. The authenticated user needs to be an `OWNER` in order to successfully invoke this endpoint. The user to be invited must be specified by email. */
+export declare const inviteUserToTeam: API.OperationMethod<InviteUserToTeamRequest, InvitedTeamMember, InviteUserToTeamError, VercelOpContext>;
+export type JoinTeamError = BadRequest | PaymentRequired | Forbidden | NotFound | VercelOpError;
+/** Join a team Join a team with a provided invite code or team ID. */
+export declare const joinTeam: API.OperationMethod<JoinTeamRequest, JoinTeamResponse, JoinTeamError, VercelOpContext>;
+export type RemoveTeamMemberError = BadRequest | Forbidden | NotFound | VercelOpError;
+/** Remove a Team Member Remove a Team Member from the Team, or dismiss a user that requested access, or leave a team. Directory Sync members can be removed when their directory email is absent or does not match the user's primary or verified secondary emails. */
+export declare const removeTeamMember: API.OperationMethod<RemoveTeamMemberRequest, RemoveTeamMemberResponse, RemoveTeamMemberError, VercelOpContext>;
+export type RequestAccessToTeamError = BadRequest | Forbidden | NotFound | VercelOpError;
+/** Request access to a team Request access to a team as a member. An owner has to approve the request. Only 100 users can request access to a team at the same time. */
+export declare const requestAccessToTeam: API.OperationMethod<RequestAccessToTeamRequest, RequestAccessToTeamResponse, RequestAccessToTeamError, VercelOpContext>;
+export type UpdateMicrofrontendsGroupError = BadRequest | Forbidden | NotFound | VercelOpError;
+/** Update a microfrontends group Updates a microfrontends group's settings. */
+export declare const updateMicrofrontendsGroup: API.OperationMethod<UpdateMicrofrontendsGroupRequest, UpdateMicrofrontendsGroupResponse, UpdateMicrofrontendsGroupError, VercelOpContext>;
+export type UpdateTeamError = BadRequest | PaymentRequired | Forbidden | VercelOpError;
+/** Update a Team Update the information of a Team specified by the `teamId` parameter. The request body should contain the information that will be updated on the Team. */
+export declare const updateTeam: API.OperationMethod<UpdateTeamRequest, Team, UpdateTeamError, VercelOpContext>;
+export type UpdateTeamMemberError = BadRequest | PaymentRequired | Forbidden | NotFound | Conflict | VercelOpError;
+/** Update a Team Member Update the membership of a Team Member on the Team specified by `teamId`, such as changing the _role_ of the member, or confirming a request to join the Team for an unconfirmed member. The authenticated user must be an `OWNER` of the Team. */
+export declare const updateTeamMember: API.OperationMethod<UpdateTeamMemberRequest, UpdateTeamMemberResponse, UpdateTeamMemberError, VercelOpContext>;
+//# sourceMappingURL=teams.d.ts.map