@distilled.cloud/vercel 1.0.0-rc.8 → 1.0.0-rc.9

package/lib/services/connect.d.ts

@@ -53,599 +53,887 @@ declare const UnprocessableEntity_base: S.Class<UnprocessableEntity, S.TaggedStr
 });
 export declare class UnprocessableEntity extends /*@__PURE__*/ UnprocessableEntity_base {
 }
-export type CreateConnectorRequestDataCase0ServerConfigJwksKeysItemUse = "sig" | "enc";
-export declare const CreateConnectorRequestDataCase0ServerConfigJwksKeysItemUse: any;
-export type CreateConnectorRequestDataCase0ServerConfigJwksKeysItemKeyOpsList = Array<string>;
-export declare const CreateConnectorRequestDataCase0ServerConfigJwksKeysItemKeyOpsList: S.Schema<CreateConnectorRequestDataCase0ServerConfigJwksKeysItemKeyOpsList>;
-export interface CreateConnectorRequestDataCase0ServerConfigJwksKeysItem {
+/** Intended key use: signing or encryption. */
+export type ConnectConnectorCreateDataCase0ServerConfigJwksKeysItemUse = "sig" | "enc";
+export declare const ConnectConnectorCreateDataCase0ServerConfigJwksKeysItemUse: any;
+/** Operations permitted for this key. */
+export type ConnectConnectorCreateDataCase0ServerConfigJwksKeysItemKeyOpsList = Array<string>;
+export declare const ConnectConnectorCreateDataCase0ServerConfigJwksKeysItemKeyOpsList: S.Schema<ConnectConnectorCreateDataCase0ServerConfigJwksKeysItemKeyOpsList>;
+export interface ConnectConnectorCreateDataCase0ServerConfigJwksKeysItem {
+    /** JSON Web Key type. */
     kty: string;
+    /** JSON Web Key identifier. */
     kid?: string;
-    use?: CreateConnectorRequestDataCase0ServerConfigJwksKeysItemUse | (string & {});
-    key_ops?: CreateConnectorRequestDataCase0ServerConfigJwksKeysItemKeyOpsList;
+    /** Intended key use: signing or encryption. */
+    use?: ConnectConnectorCreateDataCase0ServerConfigJwksKeysItemUse | (string & {});
+    /** Operations permitted for this key. */
+    key_ops?: ConnectConnectorCreateDataCase0ServerConfigJwksKeysItemKeyOpsList;
+    /** Algorithm intended for this key. */
     alg?: string;
 }
-export declare const CreateConnectorRequestDataCase0ServerConfigJwksKeysItem: S.Schema<CreateConnectorRequestDataCase0ServerConfigJwksKeysItem>;
-export type CreateConnectorRequestDataCase0ServerConfigJwksKeysList = Array<CreateConnectorRequestDataCase0ServerConfigJwksKeysItem>;
-export declare const CreateConnectorRequestDataCase0ServerConfigJwksKeysList: S.Schema<CreateConnectorRequestDataCase0ServerConfigJwksKeysList>;
-export interface CreateConnectorRequestDataCase0ServerConfigJwks {
-    keys: CreateConnectorRequestDataCase0ServerConfigJwksKeysList;
-}
-export declare const CreateConnectorRequestDataCase0ServerConfigJwks: S.Schema<CreateConnectorRequestDataCase0ServerConfigJwks>;
-export type CreateConnectorRequestDataCase0ServerConfigResponseTypesSupportedList = Array<string>;
-export declare const CreateConnectorRequestDataCase0ServerConfigResponseTypesSupportedList: S.Schema<CreateConnectorRequestDataCase0ServerConfigResponseTypesSupportedList>;
-export type CreateConnectorRequestDataCase0ServerConfigTokenEndpointAuthMethodsSupportedList = Array<string>;
-export declare const CreateConnectorRequestDataCase0ServerConfigTokenEndpointAuthMethodsSupportedList: S.Schema<CreateConnectorRequestDataCase0ServerConfigTokenEndpointAuthMethodsSupportedList>;
-export type CreateConnectorRequestDataCase0ServerConfigTokenEndpointAuthSigningAlgValuesSupportedList = Array<string>;
-export declare const CreateConnectorRequestDataCase0ServerConfigTokenEndpointAuthSigningAlgValuesSupportedList: S.Schema<CreateConnectorRequestDataCase0ServerConfigTokenEndpointAuthSigningAlgValuesSupportedList>;
-export type CreateConnectorRequestDataCase0ServerConfigScopesSupportedList = Array<string>;
-export declare const CreateConnectorRequestDataCase0ServerConfigScopesSupportedList: S.Schema<CreateConnectorRequestDataCase0ServerConfigScopesSupportedList>;
-export type CreateConnectorRequestDataCase0ServerConfigGrantTypesSupportedList = Array<string>;
-export declare const CreateConnectorRequestDataCase0ServerConfigGrantTypesSupportedList: S.Schema<CreateConnectorRequestDataCase0ServerConfigGrantTypesSupportedList>;
-export type CreateConnectorRequestDataCase0ServerConfigResponseModesSupportedList = Array<string>;
-export declare const CreateConnectorRequestDataCase0ServerConfigResponseModesSupportedList: S.Schema<CreateConnectorRequestDataCase0ServerConfigResponseModesSupportedList>;
-export type CreateConnectorRequestDataCase0ServerConfigSubjectTypesSupportedList = Array<string>;
-export declare const CreateConnectorRequestDataCase0ServerConfigSubjectTypesSupportedList: S.Schema<CreateConnectorRequestDataCase0ServerConfigSubjectTypesSupportedList>;
-export type CreateConnectorRequestDataCase0ServerConfigIdTokenSigningAlgValuesSupportedList = Array<string>;
-export declare const CreateConnectorRequestDataCase0ServerConfigIdTokenSigningAlgValuesSupportedList: S.Schema<CreateConnectorRequestDataCase0ServerConfigIdTokenSigningAlgValuesSupportedList>;
-export type CreateConnectorRequestDataCase0ServerConfigIdTokenEncryptionAlgValuesSupportedList = Array<string>;
-export declare const CreateConnectorRequestDataCase0ServerConfigIdTokenEncryptionAlgValuesSupportedList: S.Schema<CreateConnectorRequestDataCase0ServerConfigIdTokenEncryptionAlgValuesSupportedList>;
-export type CreateConnectorRequestDataCase0ServerConfigIdTokenEncryptionEncValuesSupportedList = Array<string>;
-export declare const CreateConnectorRequestDataCase0ServerConfigIdTokenEncryptionEncValuesSupportedList: S.Schema<CreateConnectorRequestDataCase0ServerConfigIdTokenEncryptionEncValuesSupportedList>;
-export type CreateConnectorRequestDataCase0ServerConfigClaimTypesSupportedList = Array<string>;
-export declare const CreateConnectorRequestDataCase0ServerConfigClaimTypesSupportedList: S.Schema<CreateConnectorRequestDataCase0ServerConfigClaimTypesSupportedList>;
-export type CreateConnectorRequestDataCase0ServerConfigClaimsSupportedList = Array<string>;
-export declare const CreateConnectorRequestDataCase0ServerConfigClaimsSupportedList: S.Schema<CreateConnectorRequestDataCase0ServerConfigClaimsSupportedList>;
-export type CreateConnectorRequestDataCase0ServerConfigCodeChallengeMethodsSupportedList = Array<string>;
-export declare const CreateConnectorRequestDataCase0ServerConfigCodeChallengeMethodsSupportedList: S.Schema<CreateConnectorRequestDataCase0ServerConfigCodeChallengeMethodsSupportedList>;
-export type CreateConnectorRequestDataCase0ServerConfigPromptValuesSupportedList = Array<string>;
-export declare const CreateConnectorRequestDataCase0ServerConfigPromptValuesSupportedList: S.Schema<CreateConnectorRequestDataCase0ServerConfigPromptValuesSupportedList>;
-export type CreateConnectorRequestDataCase0ServerConfigAuthorizationDetailsTypesSupportedList = Array<string>;
-export declare const CreateConnectorRequestDataCase0ServerConfigAuthorizationDetailsTypesSupportedList: S.Schema<CreateConnectorRequestDataCase0ServerConfigAuthorizationDetailsTypesSupportedList>;
-export interface CreateConnectorRequestDataCase0ServerConfig {
+export declare const ConnectConnectorCreateDataCase0ServerConfigJwksKeysItem: S.Schema<ConnectConnectorCreateDataCase0ServerConfigJwksKeysItem>;
+/** JSON Web Keys published by the authorization server. */
+export type ConnectConnectorCreateDataCase0ServerConfigJwksKeysList = Array<ConnectConnectorCreateDataCase0ServerConfigJwksKeysItem>;
+export declare const ConnectConnectorCreateDataCase0ServerConfigJwksKeysList: S.Schema<ConnectConnectorCreateDataCase0ServerConfigJwksKeysList>;
+/** Inline authorization server JSON Web Key Set. */
+export interface ConnectConnectorCreateDataCase0ServerConfigJwks {
+    /** JSON Web Keys published by the authorization server. */
+    keys: ConnectConnectorCreateDataCase0ServerConfigJwksKeysList;
+}
+export declare const ConnectConnectorCreateDataCase0ServerConfigJwks: S.Schema<ConnectConnectorCreateDataCase0ServerConfigJwks>;
+/** OAuth response types supported by the server. */
+export type ConnectConnectorCreateDataCase0ServerConfigResponseTypesSupportedList = Array<string>;
+export declare const ConnectConnectorCreateDataCase0ServerConfigResponseTypesSupportedList: S.Schema<ConnectConnectorCreateDataCase0ServerConfigResponseTypesSupportedList>;
+/** Token endpoint client authentication methods supported by the server. */
+export type ConnectConnectorCreateDataCase0ServerConfigTokenEndpointAuthMethodsSupportedList = Array<string>;
+export declare const ConnectConnectorCreateDataCase0ServerConfigTokenEndpointAuthMethodsSupportedList: S.Schema<ConnectConnectorCreateDataCase0ServerConfigTokenEndpointAuthMethodsSupportedList>;
+/** Signing algorithms supported for token endpoint authentication. */
+export type ConnectConnectorCreateDataCase0ServerConfigTokenEndpointAuthSigningAlgValuesSupportedList = Array<string>;
+export declare const ConnectConnectorCreateDataCase0ServerConfigTokenEndpointAuthSigningAlgValuesSupportedList: S.Schema<ConnectConnectorCreateDataCase0ServerConfigTokenEndpointAuthSigningAlgValuesSupportedList>;
+/** OAuth scopes supported by the server. */
+export type ConnectConnectorCreateDataCase0ServerConfigScopesSupportedList = Array<string>;
+export declare const ConnectConnectorCreateDataCase0ServerConfigScopesSupportedList: S.Schema<ConnectConnectorCreateDataCase0ServerConfigScopesSupportedList>;
+/** OAuth grant types supported by the server. */
+export type ConnectConnectorCreateDataCase0ServerConfigGrantTypesSupportedList = Array<string>;
+export declare const ConnectConnectorCreateDataCase0ServerConfigGrantTypesSupportedList: S.Schema<ConnectConnectorCreateDataCase0ServerConfigGrantTypesSupportedList>;
+/** OAuth response modes supported by the server. */
+export type ConnectConnectorCreateDataCase0ServerConfigResponseModesSupportedList = Array<string>;
+export declare const ConnectConnectorCreateDataCase0ServerConfigResponseModesSupportedList: S.Schema<ConnectConnectorCreateDataCase0ServerConfigResponseModesSupportedList>;
+/** OpenID Connect subject identifier types supported by the server. */
+export type ConnectConnectorCreateDataCase0ServerConfigSubjectTypesSupportedList = Array<string>;
+export declare const ConnectConnectorCreateDataCase0ServerConfigSubjectTypesSupportedList: S.Schema<ConnectConnectorCreateDataCase0ServerConfigSubjectTypesSupportedList>;
+/** Signing algorithms supported for ID tokens. */
+export type ConnectConnectorCreateDataCase0ServerConfigIdTokenSigningAlgValuesSupportedList = Array<string>;
+export declare const ConnectConnectorCreateDataCase0ServerConfigIdTokenSigningAlgValuesSupportedList: S.Schema<ConnectConnectorCreateDataCase0ServerConfigIdTokenSigningAlgValuesSupportedList>;
+/** Key management algorithms supported for encrypted ID tokens. */
+export type ConnectConnectorCreateDataCase0ServerConfigIdTokenEncryptionAlgValuesSupportedList = Array<string>;
+export declare const ConnectConnectorCreateDataCase0ServerConfigIdTokenEncryptionAlgValuesSupportedList: S.Schema<ConnectConnectorCreateDataCase0ServerConfigIdTokenEncryptionAlgValuesSupportedList>;
+/** Content encryption algorithms supported for encrypted ID tokens. */
+export type ConnectConnectorCreateDataCase0ServerConfigIdTokenEncryptionEncValuesSupportedList = Array<string>;
+export declare const ConnectConnectorCreateDataCase0ServerConfigIdTokenEncryptionEncValuesSupportedList: S.Schema<ConnectConnectorCreateDataCase0ServerConfigIdTokenEncryptionEncValuesSupportedList>;
+/** OpenID Connect claim value types supported by the server. */
+export type ConnectConnectorCreateDataCase0ServerConfigClaimTypesSupportedList = Array<string>;
+export declare const ConnectConnectorCreateDataCase0ServerConfigClaimTypesSupportedList: S.Schema<ConnectConnectorCreateDataCase0ServerConfigClaimTypesSupportedList>;
+/** Claims that the authorization server can return. */
+export type ConnectConnectorCreateDataCase0ServerConfigClaimsSupportedList = Array<string>;
+export declare const ConnectConnectorCreateDataCase0ServerConfigClaimsSupportedList: S.Schema<ConnectConnectorCreateDataCase0ServerConfigClaimsSupportedList>;
+/** PKCE code challenge methods supported by the server. */
+export type ConnectConnectorCreateDataCase0ServerConfigCodeChallengeMethodsSupportedList = Array<string>;
+export declare const ConnectConnectorCreateDataCase0ServerConfigCodeChallengeMethodsSupportedList: S.Schema<ConnectConnectorCreateDataCase0ServerConfigCodeChallengeMethodsSupportedList>;
+/** Authorization prompt values supported by the server. */
+export type ConnectConnectorCreateDataCase0ServerConfigPromptValuesSupportedList = Array<string>;
+export declare const ConnectConnectorCreateDataCase0ServerConfigPromptValuesSupportedList: S.Schema<ConnectConnectorCreateDataCase0ServerConfigPromptValuesSupportedList>;
+/** OAuth authorization-detail types supported by the server. */
+export type ConnectConnectorCreateDataCase0ServerConfigAuthorizationDetailsTypesSupportedList = Array<string>;
+export declare const ConnectConnectorCreateDataCase0ServerConfigAuthorizationDetailsTypesSupportedList: S.Schema<ConnectConnectorCreateDataCase0ServerConfigAuthorizationDetailsTypesSupportedList>;
+/** Authorization server metadata. Values override discovered metadata. Empty known string fields remove their stored overrides. */
+export interface ConnectConnectorCreateDataCase0ServerConfig {
+    /** Authorization server issuer URL. */
     issuer?: string;
+    /** OAuth authorization endpoint URL. */
     authorization_endpoint?: string;
+    /** OAuth token endpoint URL. */
     token_endpoint?: string;
+    /** OpenID Connect UserInfo endpoint URL. */
     userinfo_endpoint?: string;
+    /** URL of the authorization server JSON Web Key Set. */
     jwks_uri?: string;
-    jwks?: CreateConnectorRequestDataCase0ServerConfigJwks;
+    /** Inline authorization server JSON Web Key Set. */
+    jwks?: ConnectConnectorCreateDataCase0ServerConfigJwks;
+    /** OAuth token revocation endpoint URL. */
     revocation_endpoint?: string;
+    /** OAuth token introspection endpoint URL. */
     introspection_endpoint?: string;
+    /** OpenID Connect session termination endpoint URL. */
     end_session_endpoint?: string;
+    /** OAuth device authorization endpoint URL. */
     device_authorization_endpoint?: string;
+    /** OAuth dynamic client registration endpoint URL. */
     registration_endpoint?: string;
-    response_types_supported?: CreateConnectorRequestDataCase0ServerConfigResponseTypesSupportedList;
-    token_endpoint_auth_methods_supported?: CreateConnectorRequestDataCase0ServerConfigTokenEndpointAuthMethodsSupportedList;
-    token_endpoint_auth_signing_alg_values_supported?: CreateConnectorRequestDataCase0ServerConfigTokenEndpointAuthSigningAlgValuesSupportedList;
-    scopes_supported?: CreateConnectorRequestDataCase0ServerConfigScopesSupportedList;
-    grant_types_supported?: CreateConnectorRequestDataCase0ServerConfigGrantTypesSupportedList;
-    response_modes_supported?: CreateConnectorRequestDataCase0ServerConfigResponseModesSupportedList;
-    subject_types_supported?: CreateConnectorRequestDataCase0ServerConfigSubjectTypesSupportedList;
-    id_token_signing_alg_values_supported?: CreateConnectorRequestDataCase0ServerConfigIdTokenSigningAlgValuesSupportedList;
-    id_token_encryption_alg_values_supported?: CreateConnectorRequestDataCase0ServerConfigIdTokenEncryptionAlgValuesSupportedList;
-    id_token_encryption_enc_values_supported?: CreateConnectorRequestDataCase0ServerConfigIdTokenEncryptionEncValuesSupportedList;
-    claim_types_supported?: CreateConnectorRequestDataCase0ServerConfigClaimTypesSupportedList;
-    claims_supported?: CreateConnectorRequestDataCase0ServerConfigClaimsSupportedList;
-    code_challenge_methods_supported?: CreateConnectorRequestDataCase0ServerConfigCodeChallengeMethodsSupportedList;
-    prompt_values_supported?: CreateConnectorRequestDataCase0ServerConfigPromptValuesSupportedList;
+    /** OAuth response types supported by the server. */
+    response_types_supported?: ConnectConnectorCreateDataCase0ServerConfigResponseTypesSupportedList;
+    /** Token endpoint client authentication methods supported by the server. */
+    token_endpoint_auth_methods_supported?: ConnectConnectorCreateDataCase0ServerConfigTokenEndpointAuthMethodsSupportedList;
+    /** Signing algorithms supported for token endpoint authentication. */
+    token_endpoint_auth_signing_alg_values_supported?: ConnectConnectorCreateDataCase0ServerConfigTokenEndpointAuthSigningAlgValuesSupportedList;
+    /** OAuth scopes supported by the server. */
+    scopes_supported?: ConnectConnectorCreateDataCase0ServerConfigScopesSupportedList;
+    /** OAuth grant types supported by the server. */
+    grant_types_supported?: ConnectConnectorCreateDataCase0ServerConfigGrantTypesSupportedList;
+    /** OAuth response modes supported by the server. */
+    response_modes_supported?: ConnectConnectorCreateDataCase0ServerConfigResponseModesSupportedList;
+    /** OpenID Connect subject identifier types supported by the server. */
+    subject_types_supported?: ConnectConnectorCreateDataCase0ServerConfigSubjectTypesSupportedList;
+    /** Signing algorithms supported for ID tokens. */
+    id_token_signing_alg_values_supported?: ConnectConnectorCreateDataCase0ServerConfigIdTokenSigningAlgValuesSupportedList;
+    /** Key management algorithms supported for encrypted ID tokens. */
+    id_token_encryption_alg_values_supported?: ConnectConnectorCreateDataCase0ServerConfigIdTokenEncryptionAlgValuesSupportedList;
+    /** Content encryption algorithms supported for encrypted ID tokens. */
+    id_token_encryption_enc_values_supported?: ConnectConnectorCreateDataCase0ServerConfigIdTokenEncryptionEncValuesSupportedList;
+    /** OpenID Connect claim value types supported by the server. */
+    claim_types_supported?: ConnectConnectorCreateDataCase0ServerConfigClaimTypesSupportedList;
+    /** Claims that the authorization server can return. */
+    claims_supported?: ConnectConnectorCreateDataCase0ServerConfigClaimsSupportedList;
+    /** PKCE code challenge methods supported by the server. */
+    code_challenge_methods_supported?: ConnectConnectorCreateDataCase0ServerConfigCodeChallengeMethodsSupportedList;
+    /** Authorization prompt values supported by the server. */
+    prompt_values_supported?: ConnectConnectorCreateDataCase0ServerConfigPromptValuesSupportedList;
+    /** Whether authorization requests can use the claims parameter. */
     claims_parameter_supported?: boolean;
+    /** Whether authorization requests can use signed request objects. */
     request_parameter_supported?: boolean;
+    /** Whether authorization requests can use request_uri. */
     request_uri_parameter_supported?: boolean;
+    /** Whether request_uri values must be registered in advance. */
     require_request_uri_registration?: boolean;
+    /** Authorization server documentation URL. */
     service_documentation?: string;
+    /** Authorization server privacy policy URL. */
     op_policy_uri?: string;
+    /** Authorization server terms of service URL. */
     op_tos_uri?: string;
+    /** Authorization server logo URL. */
     logo_uri?: string;
+    /** Whether the server supports OAuth client ID metadata documents. */
     client_id_metadata_document_supported?: boolean;
-    authorization_details_types_supported?: CreateConnectorRequestDataCase0ServerConfigAuthorizationDetailsTypesSupportedList;
+    /** OAuth authorization-detail types supported by the server. */
+    authorization_details_types_supported?: ConnectConnectorCreateDataCase0ServerConfigAuthorizationDetailsTypesSupportedList;
 }
-export declare const CreateConnectorRequestDataCase0ServerConfig: S.Schema<CreateConnectorRequestDataCase0ServerConfig>;
+export declare const ConnectConnectorCreateDataCase0ServerConfig: S.Schema<ConnectConnectorCreateDataCase0ServerConfig>;
 /** Default scopes to request when token params specify scopes: [\"*\"]. */
-export type CreateConnectorRequestDataCase0UserAuthorizationScopesList = Array<string>;
-export declare const CreateConnectorRequestDataCase0UserAuthorizationScopesList: S.Schema<CreateConnectorRequestDataCase0UserAuthorizationScopesList>;
-export interface CreateConnectorRequestDataCase0UserAuthorization {
+export type ConnectConnectorCreateDataCase0UserAuthorizationScopesList = Array<string>;
+export declare const ConnectConnectorCreateDataCase0UserAuthorizationScopesList: S.Schema<ConnectConnectorCreateDataCase0UserAuthorizationScopesList>;
+/** User authorization grant settings. */
+export interface ConnectConnectorCreateDataCase0UserAuthorization {
+    /** Whether this OAuth grant is enabled. */
     enabled: boolean;
     /** Default scopes to request when token params specify scopes: [\"*\"]. */
-    scopes?: CreateConnectorRequestDataCase0UserAuthorizationScopesList;
+    scopes?: ConnectConnectorCreateDataCase0UserAuthorizationScopesList;
 }
-export declare const CreateConnectorRequestDataCase0UserAuthorization: S.Schema<CreateConnectorRequestDataCase0UserAuthorization>;
-export interface CreateConnectorRequestDataCase0RefreshTokens {
+export declare const ConnectConnectorCreateDataCase0UserAuthorization: S.Schema<ConnectConnectorCreateDataCase0UserAuthorization>;
+/** Refresh token settings. */
+export interface ConnectConnectorCreateDataCase0RefreshTokens {
+    /** Whether this OAuth grant is enabled. */
     enabled: boolean;
 }
-export declare const CreateConnectorRequestDataCase0RefreshTokens: S.Schema<CreateConnectorRequestDataCase0RefreshTokens>;
+export declare const ConnectConnectorCreateDataCase0RefreshTokens: S.Schema<ConnectConnectorCreateDataCase0RefreshTokens>;
 /** Default scopes to request when token params specify scopes: [\"*\"]. */
-export type CreateConnectorRequestDataCase0ClientCredentialsScopesList = Array<string>;
-export declare const CreateConnectorRequestDataCase0ClientCredentialsScopesList: S.Schema<CreateConnectorRequestDataCase0ClientCredentialsScopesList>;
-export interface CreateConnectorRequestDataCase0ClientCredentials {
+export type ConnectConnectorCreateDataCase0ClientCredentialsScopesList = Array<string>;
+export declare const ConnectConnectorCreateDataCase0ClientCredentialsScopesList: S.Schema<ConnectConnectorCreateDataCase0ClientCredentialsScopesList>;
+/** Client credentials grant settings. */
+export interface ConnectConnectorCreateDataCase0ClientCredentials {
+    /** Whether this OAuth grant is enabled. */
     enabled: boolean;
     /** Default scopes to request when token params specify scopes: [\"*\"]. */
-    scopes?: CreateConnectorRequestDataCase0ClientCredentialsScopesList;
+    scopes?: ConnectConnectorCreateDataCase0ClientCredentialsScopesList;
 }
-export declare const CreateConnectorRequestDataCase0ClientCredentials: S.Schema<CreateConnectorRequestDataCase0ClientCredentials>;
-export type CreateConnectorRequestDataCase0ForwardedClaimsIdTokenList = Array<string>;
-export declare const CreateConnectorRequestDataCase0ForwardedClaimsIdTokenList: S.Schema<CreateConnectorRequestDataCase0ForwardedClaimsIdTokenList>;
+export declare const ConnectConnectorCreateDataCase0ClientCredentials: S.Schema<ConnectConnectorCreateDataCase0ClientCredentials>;
+/** ID token claim names that Connect can expose. */
+export type ConnectConnectorCreateDataCase0ForwardedClaimsIdTokenList = Array<string>;
+export declare const ConnectConnectorCreateDataCase0ForwardedClaimsIdTokenList: S.Schema<ConnectConnectorCreateDataCase0ForwardedClaimsIdTokenList>;
 /** Allow-list of extra claims to propagate, keyed by source (idToken). Only claims named here and present in that source are exposed. */
-export interface CreateConnectorRequestDataCase0ForwardedClaims {
-    idToken?: CreateConnectorRequestDataCase0ForwardedClaimsIdTokenList;
+export interface ConnectConnectorCreateDataCase0ForwardedClaims {
+    /** ID token claim names that Connect can expose. */
+    idToken?: ConnectConnectorCreateDataCase0ForwardedClaimsIdTokenList;
 }
-export declare const CreateConnectorRequestDataCase0ForwardedClaims: S.Schema<CreateConnectorRequestDataCase0ForwardedClaims>;
-export type CreateConnectorRequestDataCase0AuthorizationUrlParamsMap = {
+export declare const ConnectConnectorCreateDataCase0ForwardedClaims: S.Schema<ConnectConnectorCreateDataCase0ForwardedClaims>;
+/** Extra query parameters added to authorization URLs. */
+export type ConnectConnectorCreateDataCase0AuthorizationUrlParamsMap = {
     [key: string]: string | undefined;
 };
-export declare const CreateConnectorRequestDataCase0AuthorizationUrlParamsMap: S.Schema<CreateConnectorRequestDataCase0AuthorizationUrlParamsMap>;
+export declare const ConnectConnectorCreateDataCase0AuthorizationUrlParamsMap: S.Schema<ConnectConnectorCreateDataCase0AuthorizationUrlParamsMap>;
 /** Default scopes to request when token params specify scopes: [\"*\"]. */
-export type CreateConnectorRequestDataCase0JwtBearerScopesList = Array<string>;
-export declare const CreateConnectorRequestDataCase0JwtBearerScopesList: S.Schema<CreateConnectorRequestDataCase0JwtBearerScopesList>;
-export type CreateConnectorRequestDataCase0JwtBearerAdditionalClaimsMap = {
+export type ConnectConnectorCreateDataCase0JwtBearerScopesList = Array<string>;
+export declare const ConnectConnectorCreateDataCase0JwtBearerScopesList: S.Schema<ConnectConnectorCreateDataCase0JwtBearerScopesList>;
+/** Additional claims included in generated JWT assertions. */
+export type ConnectConnectorCreateDataCase0JwtBearerAdditionalClaimsMap = {
     [key: string]: unknown | undefined;
 };
-export declare const CreateConnectorRequestDataCase0JwtBearerAdditionalClaimsMap: S.Schema<CreateConnectorRequestDataCase0JwtBearerAdditionalClaimsMap>;
-export interface CreateConnectorRequestDataCase0JwtBearer {
+export declare const ConnectConnectorCreateDataCase0JwtBearerAdditionalClaimsMap: S.Schema<ConnectConnectorCreateDataCase0JwtBearerAdditionalClaimsMap>;
+/** JWT bearer grant settings. */
+export interface ConnectConnectorCreateDataCase0JwtBearer {
+    /** Whether JWT bearer grants are enabled. */
     enabled?: boolean;
     /** Default scopes to request when token params specify scopes: [\"*\"]. */
-    scopes?: CreateConnectorRequestDataCase0JwtBearerScopesList;
+    scopes?: ConnectConnectorCreateDataCase0JwtBearerScopesList;
+    /** Default JWT subject claim. */
     sub?: string;
+    /** Default JWT issuer claim. */
     iss?: string;
+    /** Default JWT audience claim. */
     aud?: string;
-    additionalClaims?: CreateConnectorRequestDataCase0JwtBearerAdditionalClaimsMap;
+    /** Additional claims included in generated JWT assertions. */
+    additionalClaims?: ConnectConnectorCreateDataCase0JwtBearerAdditionalClaimsMap;
+    /** JWT lifetime in seconds. */
     ttl?: number;
+    /** Whether JWT bearer requests also use client credentials. */
     useClientCredentials?: boolean;
 }
-export declare const CreateConnectorRequestDataCase0JwtBearer: S.Schema<CreateConnectorRequestDataCase0JwtBearer>;
-export type CreateConnectorRequestDataCase0ClientAssertionClaimsMap = {
+export declare const ConnectConnectorCreateDataCase0JwtBearer: S.Schema<ConnectConnectorCreateDataCase0JwtBearer>;
+/** Additional claims included in the client assertion. */
+export type ConnectConnectorCreateDataCase0ClientAssertionClaimsMap = {
     [key: string]: unknown | undefined;
 };
-export declare const CreateConnectorRequestDataCase0ClientAssertionClaimsMap: S.Schema<CreateConnectorRequestDataCase0ClientAssertionClaimsMap>;
-export interface CreateConnectorRequestDataCase0ClientAssertion {
+export declare const ConnectConnectorCreateDataCase0ClientAssertionClaimsMap: S.Schema<ConnectConnectorCreateDataCase0ClientAssertionClaimsMap>;
+/** `private_key_jwt` client assertion settings. */
+export interface ConnectConnectorCreateDataCase0ClientAssertion {
+    /** OAuth client assertion type. Defaults to urn:ietf:params:oauth:client-assertion-type:jwt-bearer. An empty string clears the configured type. */
     type?: string;
+    /** Client assertion lifetime in seconds. */
     ttl?: number;
-    claims?: CreateConnectorRequestDataCase0ClientAssertionClaimsMap;
+    /** Additional claims included in the client assertion. */
+    claims?: ConnectConnectorCreateDataCase0ClientAssertionClaimsMap;
 }
-export declare const CreateConnectorRequestDataCase0ClientAssertion: S.Schema<CreateConnectorRequestDataCase0ClientAssertion>;
-export interface CreateConnectorRequestDataCase0 {
+export declare const ConnectConnectorCreateDataCase0ClientAssertion: S.Schema<ConnectConnectorCreateDataCase0ClientAssertion>;
+export interface ConnectConnectorCreateDataCase0 {
+    /** Authorization server base URL used for discovery. */
     serverUrl?: string;
-    serverConfig?: CreateConnectorRequestDataCase0ServerConfig;
+    /** Authorization server metadata. Values override discovered metadata. Empty known string fields remove their stored overrides. */
+    serverConfig?: ConnectConnectorCreateDataCase0ServerConfig;
+    /** OAuth client ID assigned by the provider. */
     clientId: string;
+    /** OAuth client name. */
     clientName?: string;
+    /** OAuth client secret. */
     clientSecret?: string | Redacted.Redacted<string>;
+    /** OAuth token endpoint authentication method. Common values are client_secret_post, client_secret_basic, none, and private_key_jwt. If omitted, Vercel selects a supported method from serverConfig and otherwise uses client_secret_post. */
     tokenEndpointAuthMethod?: string;
+    /** OAuth authorization response type. Defaults to code. Other provider-supported values are accepted. An empty string clears the configured type. */
     responseType?: string;
+    /** Whether user authorization must use PKCE. */
     pkceRequired?: boolean;
+    /** PKCE code challenge method. Supported values are S256 and plain. Vercel prefers S256 when the provider supports it. An empty string clears the configured method. */
     codeChallengeMethod?: string;
-    userAuthorization?: CreateConnectorRequestDataCase0UserAuthorization;
-    refreshTokens?: CreateConnectorRequestDataCase0RefreshTokens;
-    clientCredentials?: CreateConnectorRequestDataCase0ClientCredentials;
+    /** User authorization grant settings. */
+    userAuthorization?: ConnectConnectorCreateDataCase0UserAuthorization;
+    /** Refresh token settings. */
+    refreshTokens?: ConnectConnectorCreateDataCase0RefreshTokens;
+    /** Client credentials grant settings. */
+    clientCredentials?: ConnectConnectorCreateDataCase0ClientCredentials;
     /** Allow-list of extra claims to propagate, keyed by source (idToken). Only claims named here and present in that source are exposed. */
-    forwardedClaims?: CreateConnectorRequestDataCase0ForwardedClaims;
+    forwardedClaims?: ConnectConnectorCreateDataCase0ForwardedClaims;
+    /** Default audience used when a token request omits one. An empty string clears the default. */
     defaultAudience?: string;
     /** Default token lifetime in seconds to use when the token response omits expires_in. */
     defaultTokenExpiresIn?: number;
-    authorizationUrlParams?: CreateConnectorRequestDataCase0AuthorizationUrlParamsMap;
-    jwtBearer?: CreateConnectorRequestDataCase0JwtBearer;
-    clientAssertion?: CreateConnectorRequestDataCase0ClientAssertion;
-}
-export declare const CreateConnectorRequestDataCase0: S.Schema<CreateConnectorRequestDataCase0>;
-export type CreateConnectorRequestDataCase1SubjectType = "app" | "user";
-export declare const CreateConnectorRequestDataCase1SubjectType: any;
-export interface CreateConnectorRequestDataCase1ValuesItem {
+    /** Extra query parameters added to authorization URLs. */
+    authorizationUrlParams?: ConnectConnectorCreateDataCase0AuthorizationUrlParamsMap;
+    /** JWT bearer grant settings. */
+    jwtBearer?: ConnectConnectorCreateDataCase0JwtBearer;
+    /** `private_key_jwt` client assertion settings. */
+    clientAssertion?: ConnectConnectorCreateDataCase0ClientAssertion;
+}
+export declare const ConnectConnectorCreateDataCase0: S.Schema<ConnectConnectorCreateDataCase0>;
+/** Which subject the connector issues tokens for. Defaults to \"app\" (connector-level keys). \"user\" connectors store no connector-level values; each user supplies their own key during authorization. */
+export type ConnectConnectorCreateDataCase1SubjectType = "app" | "user";
+export declare const ConnectConnectorCreateDataCase1SubjectType: any;
+export interface ConnectConnectorCreateDataCase1ValuesItem {
+    /** API key value. */
     value: string;
+    /** Optional scope associated with the API key value. */
     scope?: string;
     /** The timestamp when the API key value expires in milliseconds. */
     expiresAt?: number;
 }
-export declare const CreateConnectorRequestDataCase1ValuesItem: S.Schema<CreateConnectorRequestDataCase1ValuesItem>;
-export type CreateConnectorRequestDataCase1ValuesList = Array<CreateConnectorRequestDataCase1ValuesItem>;
-export declare const CreateConnectorRequestDataCase1ValuesList: S.Schema<CreateConnectorRequestDataCase1ValuesList>;
-export interface CreateConnectorRequestDataCase1 {
-    subjectType?: CreateConnectorRequestDataCase1SubjectType | (string & {});
-    values?: CreateConnectorRequestDataCase1ValuesList;
-}
-export declare const CreateConnectorRequestDataCase1: S.Schema<CreateConnectorRequestDataCase1>;
-export type CreateConnectorRequestDataCase2OwnerType = "user" | "organization" | "User" | "Organization";
-export declare const CreateConnectorRequestDataCase2OwnerType: any;
-export interface CreateConnectorRequestDataCase2Owner {
-    type: CreateConnectorRequestDataCase2OwnerType | (string & {});
+export declare const ConnectConnectorCreateDataCase1ValuesItem: S.Schema<ConnectConnectorCreateDataCase1ValuesItem>;
+/** Initial API key values stored by the connector. */
+export type ConnectConnectorCreateDataCase1ValuesList = Array<ConnectConnectorCreateDataCase1ValuesItem>;
+export declare const ConnectConnectorCreateDataCase1ValuesList: S.Schema<ConnectConnectorCreateDataCase1ValuesList>;
+/** The HTTPS resources the API key authenticates against. */
+export type ConnectConnectorCreateDataCase1ServiceUrlsList = Array<string>;
+export declare const ConnectConnectorCreateDataCase1ServiceUrlsList: S.Schema<ConnectConnectorCreateDataCase1ServiceUrlsList>;
+export interface ConnectConnectorCreateDataCase1 {
+    /** Which subject the connector issues tokens for. Defaults to \"app\" (connector-level keys). \"user\" connectors store no connector-level values; each user supplies their own key during authorization. */
+    subjectType?: ConnectConnectorCreateDataCase1SubjectType | (string & {});
+    /** Initial API key values stored by the connector. */
+    values?: ConnectConnectorCreateDataCase1ValuesList;
+    /** The HTTPS resources the API key authenticates against. */
+    serviceUrls?: ConnectConnectorCreateDataCase1ServiceUrlsList;
+}
+export declare const ConnectConnectorCreateDataCase1: S.Schema<ConnectConnectorCreateDataCase1>;
+/** GitHub App owner type. */
+export type ConnectConnectorCreateDataCase2OwnerType = "user" | "organization" | "User" | "Organization";
+export declare const ConnectConnectorCreateDataCase2OwnerType: any;
+/** GitHub App owner. */
+export interface ConnectConnectorCreateDataCase2Owner {
+    /** GitHub App owner type. */
+    type: ConnectConnectorCreateDataCase2OwnerType | (string & {});
+    /** GitHub App owner numeric ID. */
     id: number;
+    /** GitHub App owner login. */
     slug: string;
+    /** GitHub App owner display name. */
     name?: string;
 }
-export declare const CreateConnectorRequestDataCase2Owner: S.Schema<CreateConnectorRequestDataCase2Owner>;
-export type CreateConnectorRequestDataCase2ExtrasMap = {
+export declare const ConnectConnectorCreateDataCase2Owner: S.Schema<ConnectConnectorCreateDataCase2Owner>;
+/** Additional provider metadata stored with the connector. */
+export type ConnectConnectorCreateDataCase2ExtrasMap = {
     [key: string]: unknown | undefined;
 };
-export declare const CreateConnectorRequestDataCase2ExtrasMap: S.Schema<CreateConnectorRequestDataCase2ExtrasMap>;
-export interface CreateConnectorRequestDataCase2 {
+export declare const ConnectConnectorCreateDataCase2ExtrasMap: S.Schema<ConnectConnectorCreateDataCase2ExtrasMap>;
+export interface ConnectConnectorCreateDataCase2 {
+    /** GitHub App numeric ID. */
     appId: number;
+    /** GitHub App slug. */
     appSlug: string;
+    /** GitHub App display name. */
     appName: string;
+    /** OAuth client ID assigned by GitHub. */
     clientId: string;
-    owner?: CreateConnectorRequestDataCase2Owner;
+    /** GitHub App owner. */
+    owner?: ConnectConnectorCreateDataCase2Owner;
+    /** GitHub App OAuth client secret. */
     clientSecret?: string | Redacted.Redacted<string>;
+    /** GitHub App private key in PEM format. */
     privateKeyPem?: string;
+    /** GitHub App webhook secret. */
     webhookSecret?: string;
-    extras?: CreateConnectorRequestDataCase2ExtrasMap;
-}
-export declare const CreateConnectorRequestDataCase2: S.Schema<CreateConnectorRequestDataCase2>;
-export type CreateConnectorRequestDataCase3AppScopesList = Array<string>;
-export declare const CreateConnectorRequestDataCase3AppScopesList: S.Schema<CreateConnectorRequestDataCase3AppScopesList>;
-export type CreateConnectorRequestDataCase3UserScopesList = Array<string>;
-export declare const CreateConnectorRequestDataCase3UserScopesList: S.Schema<CreateConnectorRequestDataCase3UserScopesList>;
-export interface CreateConnectorRequestDataCase3OwnerOrganization {
+    /** Additional provider metadata stored with the connector. */
+    extras?: ConnectConnectorCreateDataCase2ExtrasMap;
+}
+export declare const ConnectConnectorCreateDataCase2: S.Schema<ConnectConnectorCreateDataCase2>;
+/** OAuth scopes requested for Linear application tokens. */
+export type ConnectConnectorCreateDataCase3AppScopesList = Array<string>;
+export declare const ConnectConnectorCreateDataCase3AppScopesList: S.Schema<ConnectConnectorCreateDataCase3AppScopesList>;
+/** OAuth scopes requested for Linear user tokens. */
+export type ConnectConnectorCreateDataCase3UserScopesList = Array<string>;
+export declare const ConnectConnectorCreateDataCase3UserScopesList: S.Schema<ConnectConnectorCreateDataCase3UserScopesList>;
+/** Linear organization that owns the OAuth application. */
+export interface ConnectConnectorCreateDataCase3OwnerOrganization {
+    /** Linear organization ID. */
     id: string;
+    /** Linear organization slug. */
     slug: string;
+    /** Linear organization name. */
     name: string;
+    /** Linear organization logo URL. */
     logoUrl?: string | null;
 }
-export declare const CreateConnectorRequestDataCase3OwnerOrganization: S.Schema<CreateConnectorRequestDataCase3OwnerOrganization>;
-export type CreateConnectorRequestDataCase3ApplicationRedirectUrisList = Array<string>;
-export declare const CreateConnectorRequestDataCase3ApplicationRedirectUrisList: S.Schema<CreateConnectorRequestDataCase3ApplicationRedirectUrisList>;
-export type CreateConnectorRequestDataCase3ApplicationWebhookResourceTypesList = Array<string>;
-export declare const CreateConnectorRequestDataCase3ApplicationWebhookResourceTypesList: S.Schema<CreateConnectorRequestDataCase3ApplicationWebhookResourceTypesList>;
-export interface CreateConnectorRequestDataCase3Application {
+export declare const ConnectConnectorCreateDataCase3OwnerOrganization: S.Schema<ConnectConnectorCreateDataCase3OwnerOrganization>;
+/** Registered redirect URIs for the Linear OAuth application. */
+export type ConnectConnectorCreateDataCase3ApplicationRedirectUrisList = Array<string>;
+export declare const ConnectConnectorCreateDataCase3ApplicationRedirectUrisList: S.Schema<ConnectConnectorCreateDataCase3ApplicationRedirectUrisList>;
+/** Linear resource types delivered to the webhook. */
+export type ConnectConnectorCreateDataCase3ApplicationWebhookResourceTypesList = Array<string>;
+export declare const ConnectConnectorCreateDataCase3ApplicationWebhookResourceTypesList: S.Schema<ConnectConnectorCreateDataCase3ApplicationWebhookResourceTypesList>;
+/** Linear OAuth application metadata. */
+export interface ConnectConnectorCreateDataCase3Application {
+    /** Linear OAuth application ID. */
     id: string;
+    /** Linear OAuth client ID. */
     clientId: string;
+    /** Linear OAuth application name. */
     name: string;
+    /** Linear OAuth application description. */
     description?: string | null;
+    /** Linear OAuth application developer name. */
     developer?: string | null;
+    /** Linear OAuth application developer URL. */
     developerUrl?: string | null;
+    /** Linear OAuth application image URL. */
     imageUrl?: string | null;
-    redirectUris?: CreateConnectorRequestDataCase3ApplicationRedirectUrisList;
+    /** Registered redirect URIs for the Linear OAuth application. */
+    redirectUris?: ConnectConnectorCreateDataCase3ApplicationRedirectUrisList;
+    /** Linear OAuth application distribution mode. */
     distribution?: string | null;
-    webhookResourceTypes?: CreateConnectorRequestDataCase3ApplicationWebhookResourceTypesList;
+    /** Linear resource types delivered to the webhook. */
+    webhookResourceTypes?: ConnectConnectorCreateDataCase3ApplicationWebhookResourceTypesList;
+    /** Linear webhook URL. */
     webhookUrl?: string | null;
+    /** Whether the Linear webhook is enabled. */
     webhookEnabled?: boolean;
+    /** Linear OAuth application creation timestamp. */
     createdAt?: string;
+    /** Linear OAuth application update timestamp. */
     updatedAt?: string;
 }
-export declare const CreateConnectorRequestDataCase3Application: S.Schema<CreateConnectorRequestDataCase3Application>;
-export type CreateConnectorRequestDataCase3ExtrasMap = {
+export declare const ConnectConnectorCreateDataCase3Application: S.Schema<ConnectConnectorCreateDataCase3Application>;
+/** Additional provider metadata stored with the connector. */
+export type ConnectConnectorCreateDataCase3ExtrasMap = {
     [key: string]: unknown | undefined;
 };
-export declare const CreateConnectorRequestDataCase3ExtrasMap: S.Schema<CreateConnectorRequestDataCase3ExtrasMap>;
-export interface CreateConnectorRequestDataCase3 {
+export declare const ConnectConnectorCreateDataCase3ExtrasMap: S.Schema<ConnectConnectorCreateDataCase3ExtrasMap>;
+export interface ConnectConnectorCreateDataCase3 {
+    /** Linear application ID. */
     appId?: string;
+    /** Linear application name. */
     appName?: string;
+    /** OAuth client ID assigned by Linear. */
     clientId: string;
+    /** Linear OAuth client secret. */
     clientSecret: string | Redacted.Redacted<string>;
+    /** Linear webhook verification secret. */
     webhookSecret?: string;
-    appScopes?: CreateConnectorRequestDataCase3AppScopesList;
-    userScopes?: CreateConnectorRequestDataCase3UserScopesList;
-    ownerOrganization?: CreateConnectorRequestDataCase3OwnerOrganization;
-    application?: CreateConnectorRequestDataCase3Application;
-    extras?: CreateConnectorRequestDataCase3ExtrasMap;
-}
-export declare const CreateConnectorRequestDataCase3: S.Schema<CreateConnectorRequestDataCase3>;
-export interface CreateConnectorRequestDataCase4 {
+    /** OAuth scopes requested for Linear application tokens. */
+    appScopes?: ConnectConnectorCreateDataCase3AppScopesList;
+    /** OAuth scopes requested for Linear user tokens. */
+    userScopes?: ConnectConnectorCreateDataCase3UserScopesList;
+    /** Linear organization that owns the OAuth application. */
+    ownerOrganization?: ConnectConnectorCreateDataCase3OwnerOrganization;
+    /** Linear OAuth application metadata. */
+    application?: ConnectConnectorCreateDataCase3Application;
+    /** Additional provider metadata stored with the connector. */
+    extras?: ConnectConnectorCreateDataCase3ExtrasMap;
+}
+export declare const ConnectConnectorCreateDataCase3: S.Schema<ConnectConnectorCreateDataCase3>;
+export type ConnectConnectorCreateDataCase4PhoneNumbersList = Array<string>;
+export declare const ConnectConnectorCreateDataCase4PhoneNumbersList: S.Schema<ConnectConnectorCreateDataCase4PhoneNumbersList>;
+export interface ConnectConnectorCreateDataCase4 {
+    /** Linq partner API token for the shared line. */
+    apiToken: string | Redacted.Redacted<string>;
+    phoneNumbers?: ConnectConnectorCreateDataCase4PhoneNumbersList;
+}
+export declare const ConnectConnectorCreateDataCase4: S.Schema<ConnectConnectorCreateDataCase4>;
+export interface ConnectConnectorCreateDataCase5 {
+    /** Salesforce connected app consumer key. */
     consumerKey: string;
+    /** Salesforce connected app consumer secret. */
     consumerSecret: string;
+    /** Salesforce login host, such as login.salesforce.com. */
     loginHost: string;
 }
-export declare const CreateConnectorRequestDataCase4: S.Schema<CreateConnectorRequestDataCase4>;
-export interface CreateConnectorRequestDataCase5SlackTeam {
+export declare const ConnectConnectorCreateDataCase5: S.Schema<ConnectConnectorCreateDataCase5>;
+/** E.164 Sendblue lines this connector sends and receives on. Used as the connector's display name, and the only lines its webhooks are registered for; an empty array clears them, which also removes the webhook subscription. */
+export type ConnectConnectorCreateDataCase6PhoneNumbersList = Array<string>;
+export declare const ConnectConnectorCreateDataCase6PhoneNumbersList: S.Schema<ConnectConnectorCreateDataCase6PhoneNumbersList>;
+export interface ConnectConnectorCreateDataCase6 {
+    /** Sendblue API key id (`sb-api-key-id`). */
+    apiKeyId: string;
+    /** Sendblue API secret key (`sb-api-secret-key`). */
+    apiSecretKey: string | Redacted.Redacted<string>;
+    /** E.164 Sendblue lines this connector sends and receives on. Used as the connector's display name, and the only lines its webhooks are registered for; an empty array clears them, which also removes the webhook subscription. */
+    phoneNumbers?: ConnectConnectorCreateDataCase6PhoneNumbersList;
+}
+export declare const ConnectConnectorCreateDataCase6: S.Schema<ConnectConnectorCreateDataCase6>;
+/** Slack workspace metadata. */
+export interface ConnectConnectorCreateDataCase7SlackTeam {
+    /** Slack workspace ID. */
     id: string;
+    /** Slack workspace name. */
     name?: string;
+    /** Slack workspace domain. */
     domain?: string;
 }
-export declare const CreateConnectorRequestDataCase5SlackTeam: S.Schema<CreateConnectorRequestDataCase5SlackTeam>;
-export type CreateConnectorRequestDataCase5BotScopesList = Array<string>;
-export declare const CreateConnectorRequestDataCase5BotScopesList: S.Schema<CreateConnectorRequestDataCase5BotScopesList>;
-export type CreateConnectorRequestDataCase5UserScopesList = Array<string>;
-export declare const CreateConnectorRequestDataCase5UserScopesList: S.Schema<CreateConnectorRequestDataCase5UserScopesList>;
-export type CreateConnectorRequestDataCase5ExtrasMap = {
+export declare const ConnectConnectorCreateDataCase7SlackTeam: S.Schema<ConnectConnectorCreateDataCase7SlackTeam>;
+/** OAuth scopes requested for Slack bot tokens. */
+export type ConnectConnectorCreateDataCase7BotScopesList = Array<string>;
+export declare const ConnectConnectorCreateDataCase7BotScopesList: S.Schema<ConnectConnectorCreateDataCase7BotScopesList>;
+/** OAuth scopes requested for Slack user tokens. */
+export type ConnectConnectorCreateDataCase7UserScopesList = Array<string>;
+export declare const ConnectConnectorCreateDataCase7UserScopesList: S.Schema<ConnectConnectorCreateDataCase7UserScopesList>;
+export interface ConnectConnectorCreateDataCase7SlashCommandsItem {
+    /** Slash command including its leading slash. */
+    command: string;
+    /** Description shown for the slash command in Slack. */
+    description: string;
+    /** Optional usage hint shown for the slash command. */
+    usageHint?: string;
+    /** Whether Slack should escape command arguments. */
+    shouldEscape?: boolean;
+}
+export declare const ConnectConnectorCreateDataCase7SlashCommandsItem: S.Schema<ConnectConnectorCreateDataCase7SlashCommandsItem>;
+/** Slash commands configured for the managed Slack app. */
+export type ConnectConnectorCreateDataCase7SlashCommandsList = Array<ConnectConnectorCreateDataCase7SlashCommandsItem>;
+export declare const ConnectConnectorCreateDataCase7SlashCommandsList: S.Schema<ConnectConnectorCreateDataCase7SlashCommandsList>;
+/** Where Slack exposes the shortcut. */
+export type ConnectConnectorCreateDataCase7ShortcutsItemType = "global" | "message";
+export declare const ConnectConnectorCreateDataCase7ShortcutsItemType: any;
+export interface ConnectConnectorCreateDataCase7ShortcutsItem {
+    /** Where Slack exposes the shortcut. */
+    type: ConnectConnectorCreateDataCase7ShortcutsItemType | (string & {});
+    /** Shortcut display name. */
+    name: string;
+    /** Identifier included in the shortcut callback. */
+    callbackId: string;
+    /** Description shown for the shortcut in Slack. */
+    description: string;
+}
+export declare const ConnectConnectorCreateDataCase7ShortcutsItem: S.Schema<ConnectConnectorCreateDataCase7ShortcutsItem>;
+/** Global and message shortcuts configured for the Slack app. */
+export type ConnectConnectorCreateDataCase7ShortcutsList = Array<ConnectConnectorCreateDataCase7ShortcutsItem>;
+export declare const ConnectConnectorCreateDataCase7ShortcutsList: S.Schema<ConnectConnectorCreateDataCase7ShortcutsList>;
+/** Additional provider metadata stored with the connector. */
+export type ConnectConnectorCreateDataCase7ExtrasMap = {
     [key: string]: unknown | undefined;
 };
-export declare const CreateConnectorRequestDataCase5ExtrasMap: S.Schema<CreateConnectorRequestDataCase5ExtrasMap>;
-export interface CreateConnectorRequestDataCase5 {
+export declare const ConnectConnectorCreateDataCase7ExtrasMap: S.Schema<ConnectConnectorCreateDataCase7ExtrasMap>;
+export interface ConnectConnectorCreateDataCase7 {
+    /** Slack app ID. */
     appId: string;
+    /** Slack app display name. */
     appName: string;
+    /** OAuth client ID assigned by Slack. */
     clientId: string;
+    /** Slack app OAuth client secret. */
     clientSecret: string | Redacted.Redacted<string>;
-    slackTeam?: CreateConnectorRequestDataCase5SlackTeam;
+    /** Slack workspace metadata. */
+    slackTeam?: ConnectConnectorCreateDataCase7SlackTeam;
+    /** Slack request signing secret. */
     signingSecret?: string;
+    /** Legacy Slack webhook verification token. */
     verificationToken?: string;
-    botScopes?: CreateConnectorRequestDataCase5BotScopesList;
-    userScopes?: CreateConnectorRequestDataCase5UserScopesList;
-    extras?: CreateConnectorRequestDataCase5ExtrasMap;
-}
-export declare const CreateConnectorRequestDataCase5: S.Schema<CreateConnectorRequestDataCase5>;
-export type CreateConnectorRequestDataCase6ExtrasMap = {
+    /** OAuth scopes requested for Slack bot tokens. */
+    botScopes?: ConnectConnectorCreateDataCase7BotScopesList;
+    /** OAuth scopes requested for Slack user tokens. */
+    userScopes?: ConnectConnectorCreateDataCase7UserScopesList;
+    /** Slash commands configured for the managed Slack app. */
+    slashCommands?: ConnectConnectorCreateDataCase7SlashCommandsList;
+    /** Global and message shortcuts configured for the Slack app. */
+    shortcuts?: ConnectConnectorCreateDataCase7ShortcutsList;
+    /** Additional provider metadata stored with the connector. */
+    extras?: ConnectConnectorCreateDataCase7ExtrasMap;
+}
+export declare const ConnectConnectorCreateDataCase7: S.Schema<ConnectConnectorCreateDataCase7>;
+/** Additional provider metadata stored with the connector. */
+export type ConnectConnectorCreateDataCase8ExtrasMap = {
     [key: string]: unknown | undefined;
 };
-export declare const CreateConnectorRequestDataCase6ExtrasMap: S.Schema<CreateConnectorRequestDataCase6ExtrasMap>;
-export interface CreateConnectorRequestDataCase6 {
+export declare const ConnectConnectorCreateDataCase8ExtrasMap: S.Schema<ConnectConnectorCreateDataCase8ExtrasMap>;
+export interface ConnectConnectorCreateDataCase8 {
+    /** Snowflake OAuth client name. */
     clientName?: string;
+    /** Snowflake account identifier. */
     accountIdentifier: string;
+    /** Default Snowflake role for created sessions. */
     defaultSessionRole?: string;
-    extras?: CreateConnectorRequestDataCase6ExtrasMap;
+    /** Additional provider metadata stored with the connector. */
+    extras?: ConnectConnectorCreateDataCase8ExtrasMap;
 }
-export declare const CreateConnectorRequestDataCase6: S.Schema<CreateConnectorRequestDataCase6>;
-export type CreateConnectorRequestDataCase7ExtrasMap = {
+export declare const ConnectConnectorCreateDataCase8: S.Schema<ConnectConnectorCreateDataCase8>;
+/** Additional provider metadata stored with the connector. */
+export type ConnectConnectorCreateDataCase9ExtrasMap = {
     [key: string]: unknown | undefined;
 };
-export declare const CreateConnectorRequestDataCase7ExtrasMap: S.Schema<CreateConnectorRequestDataCase7ExtrasMap>;
-export interface CreateConnectorRequestDataCase7 {
+export declare const ConnectConnectorCreateDataCase9ExtrasMap: S.Schema<ConnectConnectorCreateDataCase9ExtrasMap>;
+export interface ConnectConnectorCreateDataCase9 {
+    /** Snowflake client name. */
     clientName?: string;
+    /** Snowflake account identifier. */
     accountIdentifier?: string;
-    extras?: CreateConnectorRequestDataCase7ExtrasMap;
+    /** Additional provider metadata stored with the connector. */
+    extras?: ConnectConnectorCreateDataCase9ExtrasMap;
 }
-export declare const CreateConnectorRequestDataCase7: S.Schema<CreateConnectorRequestDataCase7>;
-export interface CreateConnectorRequestDataCase8 {
+export declare const ConnectConnectorCreateDataCase9: S.Schema<ConnectConnectorCreateDataCase9>;
+export interface ConnectConnectorCreateDataCase10 {
+    /** Photon project ID. */
     projectId: string;
+    /** Photon project secret. */
     projectSecret: string;
+    /** Photon webhook verification secret. */
     webhookSecret?: string;
 }
-export declare const CreateConnectorRequestDataCase8: S.Schema<CreateConnectorRequestDataCase8>;
-export type CreateConnectorRequestDataCase9Map = {
+export declare const ConnectConnectorCreateDataCase10: S.Schema<ConnectConnectorCreateDataCase10>;
+export type ConnectConnectorCreateDataCase11Map = {
     [key: string]: unknown | undefined;
 };
-export declare const CreateConnectorRequestDataCase9Map: S.Schema<CreateConnectorRequestDataCase9Map>;
-export type CreateConnectorRequestData = CreateConnectorRequestDataCase0 | CreateConnectorRequestDataCase1 | CreateConnectorRequestDataCase2 | CreateConnectorRequestDataCase3 | CreateConnectorRequestDataCase4 | CreateConnectorRequestDataCase5 | CreateConnectorRequestDataCase6 | CreateConnectorRequestDataCase7 | CreateConnectorRequestDataCase8 | CreateConnectorRequestDataCase9Map;
-export declare const CreateConnectorRequestData: S.Schema<CreateConnectorRequestData>;
-/** Values for the connection method's templateFields. */
+export declare const ConnectConnectorCreateDataCase11Map: S.Schema<ConnectConnectorCreateDataCase11Map>;
+/** Provider configuration. With type, provide the complete configuration for that type. With service and connectionMethod, provide only credentials and preferences; Connect supplies the type, endpoints, templates, and defaults. Other connector types accept an arbitrary object. */
+export type ConnectConnectorCreateData = ConnectConnectorCreateDataCase0 | ConnectConnectorCreateDataCase1 | ConnectConnectorCreateDataCase2 | ConnectConnectorCreateDataCase3 | ConnectConnectorCreateDataCase4 | ConnectConnectorCreateDataCase5 | ConnectConnectorCreateDataCase6 | ConnectConnectorCreateDataCase7 | ConnectConnectorCreateDataCase8 | ConnectConnectorCreateDataCase9 | ConnectConnectorCreateDataCase10 | ConnectConnectorCreateDataCase11Map;
+export declare const ConnectConnectorCreateData: S.Schema<ConnectConnectorCreateData>;
+/** Values for the selected connection method's template fields. Requires connectionMethod. */
 export type CreateConnectorRequestParamsMap = {
     [key: string]: string | undefined;
 };
 export declare const CreateConnectorRequestParamsMap: S.Schema<CreateConnectorRequestParamsMap>;
-/** Use these built-in environment names or stable custom environment IDs when linking to projectId. */
-export type CreateConnectorRequestEnvironmentsList = Array<string>;
+export type CreateConnectorRequestEnvironmentsItemCase0 = "development" | "preview" | "production";
+export declare const CreateConnectorRequestEnvironmentsItemCase0: any;
+/** A built-in environment name or the stable env_* ID of a custom environment. */
+export type CreateConnectorRequestEnvironmentsItem = CreateConnectorRequestEnvironmentsItemCase0 | string;
+export declare const CreateConnectorRequestEnvironmentsItem: S.Schema<CreateConnectorRequestEnvironmentsItem>;
+/** Environments for the project connection. Requires projectId. Use one or more built-in environment names or stable custom environment IDs that belong to the project. Duplicate values are accepted and removed. */
+export type CreateConnectorRequestEnvironmentsList = Array<CreateConnectorRequestEnvironmentsItem>;
 export declare const CreateConnectorRequestEnvironmentsList: S.Schema<CreateConnectorRequestEnvironmentsList>;
-/** Initial trigger destination routing for the linked project. */
-export interface CreateConnectorRequestTriggerDestination {
+export interface CreateConnectorRequestTriggerDestinationCase0 {
+    /** Project that receives triggers. During connector creation, omit it to use the top-level projectId. */
     projectId?: string;
     /** Route path on the linked project that receives forwarded trigger requests. */
     path?: string;
-    branch?: string;
-    /** The stable env_* ID of a custom environment. */
-    customEnvironmentId?: string;
 }
+export declare const CreateConnectorRequestTriggerDestinationCase0: S.Schema<CreateConnectorRequestTriggerDestinationCase0>;
+export interface CreateConnectorRequestTriggerDestinationCase1 {
+    /** Project that receives triggers. During connector creation, omit it to use the top-level projectId. */
+    projectId?: string;
+    /** Git branch used to select a preview deployment. */
+    branch: string;
+    /** Route path on the linked project that receives forwarded trigger requests. */
+    path?: string;
+}
+export declare const CreateConnectorRequestTriggerDestinationCase1: S.Schema<CreateConnectorRequestTriggerDestinationCase1>;
+export interface CreateConnectorRequestTriggerDestinationCase2 {
+    /** Project that receives triggers. During connector creation, omit it to use the top-level projectId. */
+    projectId?: string;
+    /** Stable custom environment ID that belongs to the destination project. */
+    customEnvironmentId: string;
+    /** Route path on the linked project that receives forwarded trigger requests. */
+    path?: string;
+}
+export declare const CreateConnectorRequestTriggerDestinationCase2: S.Schema<CreateConnectorRequestTriggerDestinationCase2>;
+/** Initial trigger destination. Requires triggers to be enabled and a projectId here or at the top level. Connector responses expose the resulting set as triggerDestinations. Replace the complete set with PATCH /v1/connect/connectors/{connector}/trigger-destinations. */
+export type CreateConnectorRequestTriggerDestination = CreateConnectorRequestTriggerDestinationCase0 | CreateConnectorRequestTriggerDestinationCase1 | CreateConnectorRequestTriggerDestinationCase2;
 export declare const CreateConnectorRequestTriggerDestination: S.Schema<CreateConnectorRequestTriggerDestination>;
-/** The list of the defaults trigger events for this connector. */
+/** Default trigger events for this connector. */
 export type CreateConnectorRequestEventsList = Array<string>;
 export declare const CreateConnectorRequestEventsList: S.Schema<CreateConnectorRequestEventsList>;
 export interface CreateConnectorRequest {
-    data: CreateConnectorRequestData;
+    /** The team ID that scopes the request. Do not send it with slug. If both are omitted, Vercel uses the team associated with the token or the authenticated user's default team. The request returns 401 if no team can be selected. */
+    teamId?: string;
+    /** The team slug that scopes the request. Do not send it with teamId. If both are omitted, Vercel uses the team associated with the token or the authenticated user's default team. The request returns 401 if no team can be selected. */
+    slug?: string;
+    /** Provider configuration for the selected connector type or connection method. */
+    data: ConnectConnectorCreateData;
+    /** SHA-1 digest of a PNG or JPEG icon that is at least 640 by 640 pixels. This field does not accept a URL or image bytes. First compute the digest and upload the raw image with [POST /v2/files](https://vercel.com/docs/rest-api/deployments/upload-deployment-files). Send `Content-Length` and the same 40-character digest in `x-vercel-digest`. Then set `icon` to that digest. ```js import { createHash } from 'node:crypto'; import { readFile } from 'node:fs/promises'; const VERCEL_TOKEN = process.env.VERCEL_TOKEN; const connectorId = 'scl_...'; const bytes = await readFile('icon.png'); const digest = createHash('sha1').update(bytes).digest('hex'); await fetch('https://api.vercel.com/v2/files', { method: 'POST', headers: { Authorization: `Bearer ${VERCEL_TOKEN}`, 'Content-Type': 'application/octet-stream', 'Content-Length': String(bytes.length), 'x-vercel-digest': digest, }, body: bytes, }); await fetch(`https://api.vercel.com/v2/connect/connectors/${connectorId}`, { method: 'PATCH', headers: { Authorization: `Bearer ${VERCEL_TOKEN}`, 'Content-Type': 'application/json', }, body: JSON.stringify({ icon: digest }), }); ``` */
     icon?: string;
+    /** Branding background color (6-digit hex, for example */
     backgroundColor?: string;
+    /** Branding accent color (6-digit hex, for example */
     accentColor?: string;
-    /** Known types: api-key, github, linear, oauth, photon, salesforce, slack, snowflake. Optional when \"connectionMethod\" is set. */
+    /** Connector implementation type for full configuration. Known types: api-key, discord, github, linear, linq, microsoft-entra, oauth, photon, salesforce, sendblue, slack, snowflake, snowflake-wif. Optional when service and connectionMethod select the type. */
     type?: string;
-    /** Service slug or URL for which the connector is used. */
+    /** Service slug or URL for which the connector is used. Required when connectionMethod is set. Service alone does not enable preset configuration. */
     service?: string;
-    /** Connection method slug of the service. */
+    /** Connection method slug of the service. Use it with service to select preset configuration. */
     connectionMethod?: string;
-    /** Values for the connection method's templateFields. */
+    /** Values for the selected connection method's template fields. Requires connectionMethod. */
     params?: CreateConnectorRequestParamsMap;
     /** Which of the service's targets this connector is for. Requires \"connectionMethod\" and must be one that method serves. Optional. */
     target?: string;
+    /** Optional team-scoped unique identifier for the connector. If omitted or empty, Connect generates a value. */
     uid?: string;
+    /** Connector name. The value is trimmed and cannot contain control characters. If omitted or empty, the project name is used. A name or projectId is required. API key connectors require name. */
     name?: string;
-    /** Link to the specified project when specified. See environments. */
+    /** Project to connect during creation. If environments is omitted, the connection uses development, preview, and production. */
     projectId?: string;
-    /** Use these built-in environment names or stable custom environment IDs when linking to projectId. */
+    /** Environments for the project connection. Requires projectId. Use one or more built-in environment names or stable custom environment IDs that belong to the project. Duplicate values are accepted and removed. */
     environments?: CreateConnectorRequestEnvironmentsList;
     /** Whether the triggers are enabled for this connector. */
     triggers?: boolean;
-    /** Initial trigger destination routing for the linked project. */
+    /** Initial trigger destination. Requires triggers to be enabled and a projectId here or at the top level. Connector responses expose the resulting set as triggerDestinations. Replace the complete set with PATCH /v1/connect/connectors/{connector}/trigger-destinations. */
     triggerDestination?: CreateConnectorRequestTriggerDestination;
-    /** The list of the defaults trigger events for this connector. */
+    /** Default trigger events for this connector. */
     events?: CreateConnectorRequestEventsList;
 }
 export declare const CreateConnectorRequest: S.Schema<CreateConnectorRequest>;
-export type CreateConnectorResponseCreatedByCase0Type = "user";
-export declare const CreateConnectorResponseCreatedByCase0Type: any;
+/** Principal kind. */
+export type ConnectConnectorCreateResultCreatedByCase0Type = "user";
+export declare const ConnectConnectorCreateResultCreatedByCase0Type: any;
 /** Principal that originally created the connector — either a Vercel user (interactive dashboard / CLI flow) or a Vercel deployment (OIDC-authenticated project, used by runtime auto-provisioning). See {@link ConnexPrincipal}. Optional: pre-existing rows from before this shape was introduced may carry no attribution at all. */
-export interface CreateConnectorResponseCreatedByCase0 {
-    type: CreateConnectorResponseCreatedByCase0Type;
+export interface ConnectConnectorCreateResultCreatedByCase0 {
+    /** Principal kind. */
+    type: ConnectConnectorCreateResultCreatedByCase0Type;
+    /** Vercel user ID. */
     id: string;
 }
-export declare const CreateConnectorResponseCreatedByCase0: S.Schema<CreateConnectorResponseCreatedByCase0>;
-export type CreateConnectorResponseCreatedByCase1Type = "project";
-export declare const CreateConnectorResponseCreatedByCase1Type: any;
-export type CreateConnectorResponseCreatedByCase1EnvironmentCase1 = "development" | "preview" | "production";
-export declare const CreateConnectorResponseCreatedByCase1EnvironmentCase1: any;
-export type CreateConnectorResponseCreatedByCase1Environment = string | CreateConnectorResponseCreatedByCase1EnvironmentCase1;
-export declare const CreateConnectorResponseCreatedByCase1Environment: S.Schema<CreateConnectorResponseCreatedByCase1Environment>;
+export declare const ConnectConnectorCreateResultCreatedByCase0: S.Schema<ConnectConnectorCreateResultCreatedByCase0>;
+/** Principal kind. */
+export type ConnectConnectorCreateResultCreatedByCase1Type = "project";
+export declare const ConnectConnectorCreateResultCreatedByCase1Type: any;
+export type ConnectConnectorCreateResultCreatedByCase1EnvironmentCase1 = "development" | "preview" | "production";
+export declare const ConnectConnectorCreateResultCreatedByCase1EnvironmentCase1: any;
+/** Deployment environment of the project principal. */
+export type ConnectConnectorCreateResultCreatedByCase1Environment = string | ConnectConnectorCreateResultCreatedByCase1EnvironmentCase1;
+export declare const ConnectConnectorCreateResultCreatedByCase1Environment: S.Schema<ConnectConnectorCreateResultCreatedByCase1Environment>;
 /** Principal that originally created the connector — either a Vercel user (interactive dashboard / CLI flow) or a Vercel deployment (OIDC-authenticated project, used by runtime auto-provisioning). See {@link ConnexPrincipal}. Optional: pre-existing rows from before this shape was introduced may carry no attribution at all. */
-export interface CreateConnectorResponseCreatedByCase1 {
-    type: CreateConnectorResponseCreatedByCase1Type;
+export interface ConnectConnectorCreateResultCreatedByCase1 {
+    /** Principal kind. */
+    type: ConnectConnectorCreateResultCreatedByCase1Type;
+    /** Vercel project ID. */
     id: string;
-    environment: CreateConnectorResponseCreatedByCase1Environment;
-}
-export declare const CreateConnectorResponseCreatedByCase1: S.Schema<CreateConnectorResponseCreatedByCase1>;
-export type CreateConnectorResponseCreatedBy = CreateConnectorResponseCreatedByCase0 | CreateConnectorResponseCreatedByCase1;
-export declare const CreateConnectorResponseCreatedBy: S.Schema<CreateConnectorResponseCreatedBy>;
-export type CreateConnectorResponseUpdatedByCase0Type = "user";
-export declare const CreateConnectorResponseUpdatedByCase0Type: any;
+    /** Deployment environment of the project principal. */
+    environment: ConnectConnectorCreateResultCreatedByCase1Environment;
+}
+export declare const ConnectConnectorCreateResultCreatedByCase1: S.Schema<ConnectConnectorCreateResultCreatedByCase1>;
+/** Principal that created the connector. */
+export type ConnectConnectorCreateResultCreatedBy = ConnectConnectorCreateResultCreatedByCase0 | ConnectConnectorCreateResultCreatedByCase1;
+export declare const ConnectConnectorCreateResultCreatedBy: S.Schema<ConnectConnectorCreateResultCreatedBy>;
+/** Principal kind. */
+export type ConnectConnectorCreateResultUpdatedByCase0Type = "user";
+export declare const ConnectConnectorCreateResultUpdatedByCase0Type: any;
 /** Principal that most recently mutated the connector. Same shape as {@link createdBy} but tracks the most recent updater, not the original creator. At create time the two fields point at the same principal; they diverge on the first subsequent update. */
-export interface CreateConnectorResponseUpdatedByCase0 {
-    type: CreateConnectorResponseUpdatedByCase0Type;
+export interface ConnectConnectorCreateResultUpdatedByCase0 {
+    /** Principal kind. */
+    type: ConnectConnectorCreateResultUpdatedByCase0Type;
+    /** Vercel user ID. */
     id: string;
 }
-export declare const CreateConnectorResponseUpdatedByCase0: S.Schema<CreateConnectorResponseUpdatedByCase0>;
-export type CreateConnectorResponseUpdatedByCase1Type = "project";
-export declare const CreateConnectorResponseUpdatedByCase1Type: any;
-export type CreateConnectorResponseUpdatedByCase1EnvironmentCase1 = "development" | "preview" | "production";
-export declare const CreateConnectorResponseUpdatedByCase1EnvironmentCase1: any;
-export type CreateConnectorResponseUpdatedByCase1Environment = string | CreateConnectorResponseUpdatedByCase1EnvironmentCase1;
-export declare const CreateConnectorResponseUpdatedByCase1Environment: S.Schema<CreateConnectorResponseUpdatedByCase1Environment>;
+export declare const ConnectConnectorCreateResultUpdatedByCase0: S.Schema<ConnectConnectorCreateResultUpdatedByCase0>;
+/** Principal kind. */
+export type ConnectConnectorCreateResultUpdatedByCase1Type = "project";
+export declare const ConnectConnectorCreateResultUpdatedByCase1Type: any;
+export type ConnectConnectorCreateResultUpdatedByCase1EnvironmentCase1 = "development" | "preview" | "production";
+export declare const ConnectConnectorCreateResultUpdatedByCase1EnvironmentCase1: any;
+/** Deployment environment of the project principal. */
+export type ConnectConnectorCreateResultUpdatedByCase1Environment = string | ConnectConnectorCreateResultUpdatedByCase1EnvironmentCase1;
+export declare const ConnectConnectorCreateResultUpdatedByCase1Environment: S.Schema<ConnectConnectorCreateResultUpdatedByCase1Environment>;
 /** Principal that most recently mutated the connector. Same shape as {@link createdBy} but tracks the most recent updater, not the original creator. At create time the two fields point at the same principal; they diverge on the first subsequent update. */
-export interface CreateConnectorResponseUpdatedByCase1 {
-    type: CreateConnectorResponseUpdatedByCase1Type;
+export interface ConnectConnectorCreateResultUpdatedByCase1 {
+    /** Principal kind. */
+    type: ConnectConnectorCreateResultUpdatedByCase1Type;
+    /** Vercel project ID. */
     id: string;
-    environment: CreateConnectorResponseUpdatedByCase1Environment;
+    /** Deployment environment of the project principal. */
+    environment: ConnectConnectorCreateResultUpdatedByCase1Environment;
 }
-export declare const CreateConnectorResponseUpdatedByCase1: S.Schema<CreateConnectorResponseUpdatedByCase1>;
-export type CreateConnectorResponseUpdatedBy = CreateConnectorResponseUpdatedByCase0 | CreateConnectorResponseUpdatedByCase1;
-export declare const CreateConnectorResponseUpdatedBy: S.Schema<CreateConnectorResponseUpdatedBy>;
+export declare const ConnectConnectorCreateResultUpdatedByCase1: S.Schema<ConnectConnectorCreateResultUpdatedByCase1>;
+/** Principal that most recently updated the connector. */
+export type ConnectConnectorCreateResultUpdatedBy = ConnectConnectorCreateResultUpdatedByCase0 | ConnectConnectorCreateResultUpdatedByCase1;
+export declare const ConnectConnectorCreateResultUpdatedBy: S.Schema<ConnectConnectorCreateResultUpdatedBy>;
 /** How the connector row was originally created. New create paths stamp this explicitly; older rows may omit it. */
-export type CreateConnectorResponseCreationMode = "managed" | "manual";
-export declare const CreateConnectorResponseCreationMode: any;
-/** Managed-client metadata exposed without leaking the manager client or installation identifiers. */
-export interface CreateConnectorResponseManaged {
+export type ConnectConnectorCreateResultCreationMode = "managed" | "manual";
+export declare const ConnectConnectorCreateResultCreationMode: any;
+/** Managed connector metadata exposed without leaking the manager connector or installation identifiers. */
+export interface ConnectConnectorCreateResultManaged {
+    /** Whether Vercel synchronizes provider-side configuration. */
     sync?: boolean;
 }
-export declare const CreateConnectorResponseManaged: S.Schema<CreateConnectorResponseManaged>;
-export type CreateConnectorResponseType = "api-key" | "custom" | "discord" | "github" | "linear" | "microsoft-entra" | "oauth" | "photon" | "salesforce" | "slack" | "snowflake" | "snowflake-wif";
-export declare const CreateConnectorResponseType: any;
-export type CreateConnectorResponseDataMap = {
-    [key: string]: unknown | undefined;
-};
-export declare const CreateConnectorResponseDataMap: S.Schema<CreateConnectorResponseDataMap>;
-export type CreateConnectorResponseSupportedSubjectTypesList = Array<string>;
-export declare const CreateConnectorResponseSupportedSubjectTypesList: S.Schema<CreateConnectorResponseSupportedSubjectTypesList>;
-/** Known allowed app-level scopes. For Slack this is the bot scope set configured on the app; for OAuth it is `scopes_supported` from the server's discovery document. */
-export type CreateConnectorResponseAppTokensScopesList = Array<string>;
-export declare const CreateConnectorResponseAppTokensScopesList: S.Schema<CreateConnectorResponseAppTokensScopesList>;
-export type CreateConnectorResponseAppTokensSupportedAuthorizationDetailsList = Array<string>;
-export declare const CreateConnectorResponseAppTokensSupportedAuthorizationDetailsList: S.Schema<CreateConnectorResponseAppTokensSupportedAuthorizationDetailsList>;
-export interface CreateConnectorResponseAppTokens {
+export declare const ConnectConnectorCreateResultManaged: S.Schema<ConnectConnectorCreateResultManaged>;
+/** Connector implementation type. */
+export type ConnectConnectorCreateResultType = "api-key" | "custom" | "discord" | "github" | "linear" | "linq" | "microsoft-entra" | "microsoft-teams" | "oauth" | "photon" | "salesforce" | "sendblue" | "slack" | "snowflake" | "snowflake-wif";
+export declare const ConnectConnectorCreateResultType: any;
+/** Token subject types supported by the connector. */
+export type ConnectConnectorCreateResultSupportedSubjectTypesList = Array<string>;
+export declare const ConnectConnectorCreateResultSupportedSubjectTypesList: S.Schema<ConnectConnectorCreateResultSupportedSubjectTypesList>;
+/** Known allowed app-level scopes. For Slack this is the bot scope set configured on the app; for OAuth it is the connector's enabled `clientCredentials.scopes` configuration. */
+export type ConnectConnectorCreateResultAppTokensScopesList = Array<string>;
+export declare const ConnectConnectorCreateResultAppTokensScopesList: S.Schema<ConnectConnectorCreateResultAppTokensScopesList>;
+/** Supported OAuth authorization-detail type names. */
+export type ConnectConnectorCreateResultAppTokensSupportedAuthorizationDetailsList = Array<string>;
+export declare const ConnectConnectorCreateResultAppTokensSupportedAuthorizationDetailsList: S.Schema<ConnectConnectorCreateResultAppTokensSupportedAuthorizationDetailsList>;
+/** App-token capabilities and known grants for the connector. */
+export interface ConnectConnectorCreateResultAppTokens {
+    /** Whether one app token can be used across installations. */
     crossInstallation: boolean;
+    /** Whether callers can narrow app-token grants per request. */
     supportsRefinement: boolean;
     /** True when changing app token grants requires reinstalling the app, so tokens cannot be partitioned independently by requester environment. */
     requiresReinstallation?: boolean;
-    /** Known allowed app-level scopes. For Slack this is the bot scope set configured on the app; for OAuth it is `scopes_supported` from the server's discovery document. */
-    scopes?: CreateConnectorResponseAppTokensScopesList;
-    supportedAuthorizationDetails?: CreateConnectorResponseAppTokensSupportedAuthorizationDetailsList;
-    /** Link to the page on the service where this client's app-level permissions are declared and granted, when the service has one and it differs from `clientUrl`. */
+    /** Known allowed app-level scopes. For Slack this is the bot scope set configured on the app; for OAuth it is the connector's enabled `clientCredentials.scopes` configuration. */
+    scopes?: ConnectConnectorCreateResultAppTokensScopesList;
+    /** Supported OAuth authorization-detail type names. */
+    supportedAuthorizationDetails?: ConnectConnectorCreateResultAppTokensSupportedAuthorizationDetailsList;
+    /** Link to the page on the service where this connector's app-level permissions are declared and granted, when the service has one and it differs from `clientUrl`. */
     permissionsUrl?: string;
 }
-export declare const CreateConnectorResponseAppTokens: S.Schema<CreateConnectorResponseAppTokens>;
-/** Known allowed user-level scopes. For Slack this is the user scope set configured on the app; for OAuth it is `scopes_supported` from the server's discovery document. */
-export type CreateConnectorResponseUserTokensScopesList = Array<string>;
-export declare const CreateConnectorResponseUserTokensScopesList: S.Schema<CreateConnectorResponseUserTokensScopesList>;
-export type CreateConnectorResponseUserTokensSupportedAuthorizationDetailsList = Array<string>;
-export declare const CreateConnectorResponseUserTokensSupportedAuthorizationDetailsList: S.Schema<CreateConnectorResponseUserTokensSupportedAuthorizationDetailsList>;
-export interface CreateConnectorResponseUserTokens {
+export declare const ConnectConnectorCreateResultAppTokens: S.Schema<ConnectConnectorCreateResultAppTokens>;
+/** Known allowed user-level scopes. For Slack this is the user scope set configured on the app; for OAuth it is the connector's enabled `userAuthorization.scopes` configuration. */
+export type ConnectConnectorCreateResultUserTokensScopesList = Array<string>;
+export declare const ConnectConnectorCreateResultUserTokensScopesList: S.Schema<ConnectConnectorCreateResultUserTokensScopesList>;
+/** Supported OAuth authorization-detail type names. */
+export type ConnectConnectorCreateResultUserTokensSupportedAuthorizationDetailsList = Array<string>;
+export declare const ConnectConnectorCreateResultUserTokensSupportedAuthorizationDetailsList: S.Schema<ConnectConnectorCreateResultUserTokensSupportedAuthorizationDetailsList>;
+/** User-token capabilities and known grants for the connector. */
+export interface ConnectConnectorCreateResultUserTokens {
+    /** Whether one user token can be used across installations. */
     crossInstallation: boolean;
+    /** Whether callers can narrow user-token grants per request. */
     supportsRefinement: boolean;
-    /** Known allowed user-level scopes. For Slack this is the user scope set configured on the app; for OAuth it is `scopes_supported` from the server's discovery document. */
-    scopes?: CreateConnectorResponseUserTokensScopesList;
-    supportedAuthorizationDetails?: CreateConnectorResponseUserTokensSupportedAuthorizationDetailsList;
+    /** Known allowed user-level scopes. For Slack this is the user scope set configured on the app; for OAuth it is the connector's enabled `userAuthorization.scopes` configuration. */
+    scopes?: ConnectConnectorCreateResultUserTokensScopesList;
+    /** Supported OAuth authorization-detail type names. */
+    supportedAuthorizationDetails?: ConnectConnectorCreateResultUserTokensSupportedAuthorizationDetailsList;
     /** User authorization is completed by the Connect consent screen submitting a credential instead of an OAuth redirect. */
     manualCredentialInput?: boolean;
 }
-export declare const CreateConnectorResponseUserTokens: S.Schema<CreateConnectorResponseUserTokens>;
+export declare const ConnectConnectorCreateResultUserTokens: S.Schema<ConnectConnectorCreateResultUserTokens>;
 /** Incoming trigger configuration. Only present when enabled. */
-export type CreateConnectorResponseTriggers = CreateConnectorRequestDataCase0RefreshTokens;
-export declare const CreateConnectorResponseTriggers: S.Schema<CreateConnectorRequestDataCase0RefreshTokens>;
-/** Known events this client subscribes to (e.g. Slack bot events, GitHub webhook events). Names are type-specific and validated by the managed-create flow when forwarded to the third-party service. */
-export type CreateConnectorResponseEventsList = Array<string>;
-export declare const CreateConnectorResponseEventsList: S.Schema<CreateConnectorResponseEventsList>;
-/** Destinations that incoming triggers should be forwarded to. Limited to `MAX_CONNEX_TRIGGER_DESTINATIONS` entries. */
-export interface CreateConnectorResponseTriggerDestinationsItem {
+export interface ConnectTriggerConfiguration {
+    /** Whether incoming triggers are enabled for the connector. */
+    enabled: boolean;
+}
+export declare const ConnectTriggerConfiguration: S.Schema<ConnectTriggerConfiguration>;
+/** Known events this connector subscribes to (e.g. Slack bot events, GitHub webhook events). Names are type-specific and validated by the managed-create flow when forwarded to the third-party service. */
+export type ConnectConnectorCreateResultEventsList = Array<string>;
+export declare const ConnectConnectorCreateResultEventsList: S.Schema<ConnectConnectorCreateResultEventsList>;
+/** Destinations that incoming triggers should be forwarded to. Limited to 3 entries. Set the initial destination with `triggerDestination` during creation. Replace the complete set with `PATCH /v1/connect/connectors/{connector}/trigger-destinations`. */
+export interface ConnectTriggerDestination {
+    /** Vercel project that receives matching trigger requests. */
     projectId: string;
     /** Stable custom-environment ID to route this destination to. Mutually exclusive with `branch`; omitted destinations keep the legacy production behavior. */
     customEnvironmentId?: string;
+    /** Git branch used to select a preview deployment. */
     branch?: string;
+    /** Route path that receives the forwarded trigger request. */
     path?: string;
 }
-export declare const CreateConnectorResponseTriggerDestinationsItem: S.Schema<CreateConnectorResponseTriggerDestinationsItem>;
-/** Destinations that incoming triggers should be forwarded to. Limited to `MAX_CONNEX_TRIGGER_DESTINATIONS` entries. */
-export type CreateConnectorResponseTriggerDestinationsList = Array<CreateConnectorResponseTriggerDestinationsItem>;
-export declare const CreateConnectorResponseTriggerDestinationsList: S.Schema<CreateConnectorResponseTriggerDestinationsList>;
-export interface CreateConnectorResponseIncludesProjectsItemsItemProjectCustomEnvironmentsItem {
-    id: string;
-    slug: string;
-}
-export declare const CreateConnectorResponseIncludesProjectsItemsItemProjectCustomEnvironmentsItem: S.Schema<CreateConnectorResponseIncludesProjectsItemsItemProjectCustomEnvironmentsItem>;
-export type CreateConnectorResponseIncludesProjectsItemsItemProjectCustomEnvironmentsList = Array<CreateConnectorResponseIncludesProjectsItemsItemProjectCustomEnvironmentsItem>;
-export declare const CreateConnectorResponseIncludesProjectsItemsItemProjectCustomEnvironmentsList: S.Schema<CreateConnectorResponseIncludesProjectsItemsItemProjectCustomEnvironmentsList>;
-export interface CreateConnectorResponseIncludesProjectsItemsItemProject {
-    id: string;
-    name: string;
-    customEnvironments?: CreateConnectorResponseIncludesProjectsItemsItemProjectCustomEnvironmentsList;
-}
-export declare const CreateConnectorResponseIncludesProjectsItemsItemProject: S.Schema<CreateConnectorResponseIncludesProjectsItemsItemProject>;
-export type CreateConnectorResponseIncludesProjectsItemsItemEnvironmentsItemCase1 = "development" | "preview" | "production";
-export declare const CreateConnectorResponseIncludesProjectsItemsItemEnvironmentsItemCase1: any;
-export type CreateConnectorResponseIncludesProjectsItemsItemEnvironmentsItem = string | CreateConnectorResponseIncludesProjectsItemsItemEnvironmentsItemCase1;
-export declare const CreateConnectorResponseIncludesProjectsItemsItemEnvironmentsItem: S.Schema<CreateConnectorResponseIncludesProjectsItemsItemEnvironmentsItem>;
-export type CreateConnectorResponseIncludesProjectsItemsItemEnvironmentsList = Array<CreateConnectorResponseIncludesProjectsItemsItemEnvironmentsItem>;
-export declare const CreateConnectorResponseIncludesProjectsItemsItemEnvironmentsList: S.Schema<CreateConnectorResponseIncludesProjectsItemsItemEnvironmentsList>;
-export interface CreateConnectorResponseIncludesProjectsItemsItem {
-    clientId: string;
-    projectId: string;
-    project?: CreateConnectorResponseIncludesProjectsItemsItemProject;
-    environments: CreateConnectorResponseIncludesProjectsItemsItemEnvironmentsList;
-    createdAt: number;
-    updatedAt: number;
-}
-export declare const CreateConnectorResponseIncludesProjectsItemsItem: S.Schema<CreateConnectorResponseIncludesProjectsItemsItem>;
-export type CreateConnectorResponseIncludesProjectsItemsList = Array<CreateConnectorResponseIncludesProjectsItemsItem>;
-export declare const CreateConnectorResponseIncludesProjectsItemsList: S.Schema<CreateConnectorResponseIncludesProjectsItemsList>;
-/** Set by `?include=projects`. Capped at 100 per client. */
-export interface CreateConnectorResponseIncludesProjects {
-    items: CreateConnectorResponseIncludesProjectsItemsList;
-    hasMore: boolean;
-    cursor?: string | null;
-}
-export declare const CreateConnectorResponseIncludesProjects: S.Schema<CreateConnectorResponseIncludesProjects>;
-/** Optional expansions populated by `?include=...` on the list endpoint. */
-export interface CreateConnectorResponseIncludes {
-    /** Set by `?include=projects`. Capped at 100 per client. */
-    projects?: CreateConnectorResponseIncludesProjects;
-}
-export declare const CreateConnectorResponseIncludes: S.Schema<CreateConnectorResponseIncludes>;
-export interface CreateConnectorResponse {
+export declare const ConnectTriggerDestination: S.Schema<ConnectTriggerDestination>;
+/** Destinations that incoming triggers should be forwarded to. Limited to 3 entries. Set the initial destination with `triggerDestination` during creation. Replace the complete set with `PATCH /v1/connect/connectors/{connector}/trigger-destinations`. */
+export type ConnectConnectorCreateResultTriggerDestinationsList = Array<ConnectTriggerDestination>;
+export declare const ConnectConnectorCreateResultTriggerDestinationsList: S.Schema<ConnectConnectorCreateResultTriggerDestinationsList>;
+/** Connector created by the request. */
+export interface ConnectConnectorCreateResult {
+    /** Stable `scl_` connector ID. Use this value directly in `{connector}`. */
     id: string;
-    ownerId: string;
+    /** Team-scoped UID. URL-encode this value before using it in `{connector}`. */
+    uid: string;
+    /** Installation used when a token request does not specify an installation. */
+    defaultInstallationId?: string;
+    /** Creation time in epoch milliseconds. */
     createdAt: number;
+    /** Last update time in epoch milliseconds. */
     updatedAt: number;
-    deletedAt?: number;
     /** Time when this connector started requiring reinstallation because an installation-affecting app-token grant changed. */
     reinstallAt?: number;
-    createdBy?: CreateConnectorResponseCreatedBy;
-    updatedBy?: CreateConnectorResponseUpdatedBy;
+    /** Principal that created the connector. */
+    createdBy?: ConnectConnectorCreateResultCreatedBy;
+    /** Principal that most recently updated the connector. */
+    updatedBy?: ConnectConnectorCreateResultUpdatedBy;
     /** How the connector row was originally created. New create paths stamp this explicitly; older rows may omit it. */
-    creationMode?: CreateConnectorResponseCreationMode;
-    /** Managed-client metadata exposed without leaking the manager client or installation identifiers. */
-    managed?: CreateConnectorResponseManaged;
-    public: boolean;
-    uid: string;
-    type: CreateConnectorResponseType;
-    /** Best-effort identifier of the third-party service this client represents, independent of `type`. Examples: `'slack'`, `'mcp.linear.app'`, `'auth.example.com'`. Always non-empty on the API response — falls back through `storedClient.service ?? typeDef.service ?? typeDef.type`. */
+    creationMode?: ConnectConnectorCreateResultCreationMode;
+    /** Managed connector metadata exposed without leaking the manager connector or installation identifiers. */
+    managed?: ConnectConnectorCreateResultManaged;
+    /** Connector implementation type. */
+    type: ConnectConnectorCreateResultType;
+    /** Best-effort identifier of the third-party service this connector represents, independent of `type`. Examples: `'slack'`, `'mcp.linear.app'`, and `'auth.example.com'`. Always present in API responses. */
     service: string;
     /** The connection method this connector was created from, when the create request named one. */
     connectionMethod?: string;
     /** Which of the service's products/surfaces this connector points at. */
     target?: string;
+    /** Connector name within the owning team. */
     name: string;
+    /** Human-readable connector name. */
+    displayName: string;
+    /** Provider-side URL for viewing or managing the resource represented by the connector. The destination can be an app, account, phone line, or service instance, depending on the connector type. */
     clientUrl?: string | null;
-    /** Redirect URI registered with the third-party service for this client, if any. Used by `startAuthorization`/`startInstallation` to replay the exact URI back to the provider's token endpoint. Absent on clients created before this field was introduced; those callers fall back to the `https://connect.vercel.com/callback` default. */
+    /** Redirect URI registered with the third-party service for this connector, if any. Used by `startAuthorization`/`startInstallation` to replay the exact URI back to the provider's token endpoint. Absent on connectors created before this field was introduced; those callers fall back to the `https://connect.vercel.com/callback` default. */
     redirectUri?: string;
-    defaultInstallationId?: string;
-    data: CreateConnectorResponseDataMap;
+    /** Human-readable name of the connector type. */
     typeName: string;
+    /** Icon identifier supplied by the connector type. */
     typeIcon?: string;
+    /** Public website for the connected service. */
     website?: string;
+    /** Developer website for the connected service. */
     devsite?: string;
+    /** Developer documentation for the connected service. */
     docsite?: string;
-    /** Client branding icon. SHA-1 hash that resolves to the uploaded icon via the Vercel avatar service. Clients render this with `https://vercel.com/api/www/avatar/{icon}`. */
+    /** Connector branding icon. SHA-1 hash that resolves to the uploaded icon through the Vercel avatar service. Consumers render this with `https://vercel.com/api/www/avatar/{icon}`. */
     icon?: string;
     /** Hex background color (e.g., `#000000`) for branding. */
     backgroundColor?: string;
     /** Hex accent color (e.g., `#000000`) for branding. */
     accentColor?: string;
-    supportedSubjectTypes: CreateConnectorResponseSupportedSubjectTypesList;
-    appTokens?: CreateConnectorResponseAppTokens;
-    userTokens?: CreateConnectorResponseUserTokens;
+    /** Token subject types supported by the connector. */
+    supportedSubjectTypes: ConnectConnectorCreateResultSupportedSubjectTypesList;
+    /** App-token capabilities and known grants for the connector. */
+    appTokens?: ConnectConnectorCreateResultAppTokens;
+    /** User-token capabilities and known grants for the connector. */
+    userTokens?: ConnectConnectorCreateResultUserTokens;
+    /** Whether the connector supports an installation flow. */
     supportsInstallation: boolean;
+    /** Whether Connect can revoke tokens for this connector. */
     supportsRevocation: boolean;
-    ownerTenantId?: string;
-    /** Whether this client type supports trigger webhooks. Derived from the type definition; indicates that `triggers` and `triggerDestinations` may be meaningful for this client. */
+    /** Whether this connector type supports trigger webhooks. Derived from the type definition; indicates that `triggers` and `triggerDestinations` may be meaningful for this connector. */
     supportsTriggers: boolean;
+    /** Whether the connector icon can propagate to the provider. */
     supportsIcon: unknown;
-    /** Incoming trigger configuration. Only present when enabled. */
-    triggers?: CreateConnectorRequestDataCase0RefreshTokens;
-    /** Known events this client subscribes to (e.g. Slack bot events, GitHub webhook events). Names are type-specific and validated by the managed-create flow when forwarded to the third-party service. */
-    events?: CreateConnectorResponseEventsList;
-    /** Destinations that incoming triggers should be forwarded to. Limited to `MAX_CONNEX_TRIGGER_DESTINATIONS` entries. */
-    triggerDestinations?: CreateConnectorResponseTriggerDestinationsList;
-    /** Whether this connector is linked to the project supplied through `prioritizedProjectId`. Only present on prioritized list responses. */
-    isConnectedToPrioritizedProject?: boolean;
-    /** Optional expansions populated by `?include=...` on the list endpoint. */
-    includes?: CreateConnectorResponseIncludes;
-}
-export declare const CreateConnectorResponse: S.Schema<CreateConnectorResponse>;
+    /** Incoming trigger configuration for the connector. */
+    triggers?: ConnectTriggerConfiguration;
+    /** Known events this connector subscribes to (e.g. Slack bot events, GitHub webhook events). Names are type-specific and validated by the managed-create flow when forwarded to the third-party service. */
+    events?: ConnectConnectorCreateResultEventsList;
+    /** Destinations that incoming triggers should be forwarded to. Limited to 3 entries. Set the initial destination with `triggerDestination` during creation. Replace the complete set with `PATCH /v1/connect/connectors/{connector}/trigger-destinations`. */
+    triggerDestinations?: ConnectConnectorCreateResultTriggerDestinationsList;
+}
+export declare const ConnectConnectorCreateResult: S.Schema<ConnectConnectorCreateResult>;
 export type CreateConnectorAuthorizationRequestRequestSubjectCase0Type = "app";
 export declare const CreateConnectorAuthorizationRequestRequestSubjectCase0Type: any;
 export interface CreateConnectorAuthorizationRequestRequestSubjectCase0 {
@@ -731,6 +1019,8 @@ export interface CreateConnectorAuthorizationRequestResponseConnector {
     service?: string;
     /** Curated display name of the resolved service (e.g. "Salesforce"), present when the service is a known service. Suited for end-user surfaces like "Sign in with {serviceName}". */
     serviceName?: string;
+    /** Provider-facing display name when the connector type exposes one, falling back to the stored connector name. */
+    displayName: string;
     /** The connector's own name: the operator-given client name, falling back to the client type's name for legacy rows without one. */
     name: string;
 }
@@ -744,42 +1034,294 @@ export interface CreateConnectorAuthorizationRequestResponse {
     connector: CreateConnectorAuthorizationRequestResponseConnector;
 }
 export declare const CreateConnectorAuthorizationRequestResponse: S.Schema<CreateConnectorAuthorizationRequestResponse>;
-export type CreateConnectorInstallationRequestRequestAudienceList = Array<string>;
-export declare const CreateConnectorInstallationRequestRequestAudienceList: S.Schema<CreateConnectorInstallationRequestRequestAudienceList>;
-export type CreateConnectorInstallationRequestRequestScopesList = Array<string>;
-export declare const CreateConnectorInstallationRequestRequestScopesList: S.Schema<CreateConnectorInstallationRequestRequestScopesList>;
-export type CreateConnectorInstallationRequestRequestResourcesList = Array<string>;
-export declare const CreateConnectorInstallationRequestRequestResourcesList: S.Schema<CreateConnectorInstallationRequestRequestResourcesList>;
-export type CreateConnectorInstallationRequestRequestAuthorizationDetailsItem = CreateConnectorAuthorizationRequestRequestAuthorizationDetailsItem;
-export declare const CreateConnectorInstallationRequestRequestAuthorizationDetailsItem: S.Schema<CreateConnectorAuthorizationRequestRequestAuthorizationDetailsItem>;
-export type CreateConnectorInstallationRequestRequestAuthorizationDetailsList = Array<CreateConnectorAuthorizationRequestRequestAuthorizationDetailsItem>;
-export declare const CreateConnectorInstallationRequestRequestAuthorizationDetailsList: S.Schema<CreateConnectorInstallationRequestRequestAuthorizationDetailsList>;
-export interface CreateConnectorInstallationRequestRequest {
+export interface DeleteConnectorRequest {
+    /** Stable connector ID or URL-encoded team-scoped UID. Examples: `scl_abc123` or `slack%2Fmy-bot`. */
     connector: string;
-    installationId?: string;
-    audience?: CreateConnectorInstallationRequestRequestAudienceList;
-    scopes?: CreateConnectorInstallationRequestRequestScopesList;
-    resources?: CreateConnectorInstallationRequestRequestResourcesList;
-    authorizationDetails?: CreateConnectorInstallationRequestRequestAuthorizationDetailsList;
-    validityBufferMs?: number;
-    returnUrl?: string;
-    webhook?: string;
-    tenantId?: string;
-    deviceCode?: boolean;
-    expiresInMs?: number;
+    /** The team ID that scopes the request. Do not send it with slug. If both are omitted, Vercel uses the team associated with the token or the authenticated user's default team. The request returns 401 if no team can be selected. */
+    teamId?: string;
+    /** The team slug that scopes the request. Do not send it with teamId. If both are omitted, Vercel uses the team associated with the token or the authenticated user's default team. The request returns 401 if no team can be selected. */
+    slug?: string;
 }
-export declare const CreateConnectorInstallationRequestRequest: S.Schema<CreateConnectorInstallationRequestRequest>;
-export type CreateConnectorInstallationRequestResponseConnector = CreateConnectorAuthorizationRequestResponseConnector;
-export declare const CreateConnectorInstallationRequestResponseConnector: S.Schema<CreateConnectorAuthorizationRequestResponseConnector>;
-export interface CreateConnectorInstallationRequestResponse {
-    url: string;
-    request: string;
-    verifier: string;
-    deviceCode?: string;
-    expiresAt: number;
-    connector: CreateConnectorAuthorizationRequestResponseConnector;
+export declare const DeleteConnectorRequest: S.Schema<DeleteConnectorRequest>;
+export interface DeleteConnectorResponse {
+}
+export declare const DeleteConnectorResponse: S.Schema<DeleteConnectorResponse>;
+export interface DeleteConnectorProjectConnectionRequest {
+    /** Stable connector ID or URL-encoded team-scoped UID. Examples: `scl_abc123` or `slack%2Fmy-bot`. */
+    connector: string;
+    /** Vercel project ID. */
+    projectId: string;
+    /** The team ID that scopes the request. Do not send it with slug. If both are omitted, Vercel uses the team associated with the token or the authenticated user's default team. The request returns 401 if no team can be selected. */
+    teamId?: string;
+    /** The team slug that scopes the request. Do not send it with teamId. If both are omitted, Vercel uses the team associated with the token or the authenticated user's default team. The request returns 401 if no team can be selected. */
+    slug?: string;
+}
+export declare const DeleteConnectorProjectConnectionRequest: S.Schema<DeleteConnectorProjectConnectionRequest>;
+export interface DeleteConnectorProjectConnectionResponse {
 }
-export declare const CreateConnectorInstallationRequestResponse: S.Schema<CreateConnectorInstallationRequestResponse>;
+export declare const DeleteConnectorProjectConnectionResponse: S.Schema<DeleteConnectorProjectConnectionResponse>;
+export interface GetConnectorRequest {
+    /** Stable connector ID or URL-encoded team-scoped UID. Examples: `scl_abc123` or `slack%2Fmy-bot`. */
+    connector: string;
+    /** The team ID that scopes the request. Do not send it with slug. If both are omitted, Vercel uses the team associated with the token or the authenticated user's default team. The request returns 401 if no team can be selected. */
+    teamId?: string;
+    /** The team slug that scopes the request. Do not send it with teamId. If both are omitted, Vercel uses the team associated with the token or the authenticated user's default team. The request returns 401 if no team can be selected. */
+    slug?: string;
+}
+export declare const GetConnectorRequest: S.Schema<GetConnectorRequest>;
+/** Principal kind. */
+export type ConnectConnectorCreatedByCase0Type = "user";
+export declare const ConnectConnectorCreatedByCase0Type: any;
+/** Principal that originally created the connector — either a Vercel user (interactive dashboard / CLI flow) or a Vercel deployment (OIDC-authenticated project, used by runtime auto-provisioning). See {@link ConnexPrincipal}. Optional: pre-existing rows from before this shape was introduced may carry no attribution at all. */
+export interface ConnectConnectorCreatedByCase0 {
+    /** Principal kind. */
+    type: ConnectConnectorCreatedByCase0Type;
+    /** Vercel user ID. */
+    id: string;
+}
+export declare const ConnectConnectorCreatedByCase0: S.Schema<ConnectConnectorCreatedByCase0>;
+/** Principal kind. */
+export type ConnectConnectorCreatedByCase1Type = "project";
+export declare const ConnectConnectorCreatedByCase1Type: any;
+export type ConnectConnectorCreatedByCase1EnvironmentCase1 = "development" | "preview" | "production";
+export declare const ConnectConnectorCreatedByCase1EnvironmentCase1: any;
+/** Deployment environment of the project principal. */
+export type ConnectConnectorCreatedByCase1Environment = string | ConnectConnectorCreatedByCase1EnvironmentCase1;
+export declare const ConnectConnectorCreatedByCase1Environment: S.Schema<ConnectConnectorCreatedByCase1Environment>;
+/** Principal that originally created the connector — either a Vercel user (interactive dashboard / CLI flow) or a Vercel deployment (OIDC-authenticated project, used by runtime auto-provisioning). See {@link ConnexPrincipal}. Optional: pre-existing rows from before this shape was introduced may carry no attribution at all. */
+export interface ConnectConnectorCreatedByCase1 {
+    /** Principal kind. */
+    type: ConnectConnectorCreatedByCase1Type;
+    /** Vercel project ID. */
+    id: string;
+    /** Deployment environment of the project principal. */
+    environment: ConnectConnectorCreatedByCase1Environment;
+}
+export declare const ConnectConnectorCreatedByCase1: S.Schema<ConnectConnectorCreatedByCase1>;
+/** Principal that created the connector. */
+export type ConnectConnectorCreatedBy = ConnectConnectorCreatedByCase0 | ConnectConnectorCreatedByCase1;
+export declare const ConnectConnectorCreatedBy: S.Schema<ConnectConnectorCreatedBy>;
+/** Principal kind. */
+export type ConnectConnectorUpdatedByCase0Type = "user";
+export declare const ConnectConnectorUpdatedByCase0Type: any;
+/** Principal that most recently mutated the connector. Same shape as {@link createdBy} but tracks the most recent updater, not the original creator. At create time the two fields point at the same principal; they diverge on the first subsequent update. */
+export interface ConnectConnectorUpdatedByCase0 {
+    /** Principal kind. */
+    type: ConnectConnectorUpdatedByCase0Type;
+    /** Vercel user ID. */
+    id: string;
+}
+export declare const ConnectConnectorUpdatedByCase0: S.Schema<ConnectConnectorUpdatedByCase0>;
+/** Principal kind. */
+export type ConnectConnectorUpdatedByCase1Type = "project";
+export declare const ConnectConnectorUpdatedByCase1Type: any;
+export type ConnectConnectorUpdatedByCase1EnvironmentCase1 = "development" | "preview" | "production";
+export declare const ConnectConnectorUpdatedByCase1EnvironmentCase1: any;
+/** Deployment environment of the project principal. */
+export type ConnectConnectorUpdatedByCase1Environment = string | ConnectConnectorUpdatedByCase1EnvironmentCase1;
+export declare const ConnectConnectorUpdatedByCase1Environment: S.Schema<ConnectConnectorUpdatedByCase1Environment>;
+/** Principal that most recently mutated the connector. Same shape as {@link createdBy} but tracks the most recent updater, not the original creator. At create time the two fields point at the same principal; they diverge on the first subsequent update. */
+export interface ConnectConnectorUpdatedByCase1 {
+    /** Principal kind. */
+    type: ConnectConnectorUpdatedByCase1Type;
+    /** Vercel project ID. */
+    id: string;
+    /** Deployment environment of the project principal. */
+    environment: ConnectConnectorUpdatedByCase1Environment;
+}
+export declare const ConnectConnectorUpdatedByCase1: S.Schema<ConnectConnectorUpdatedByCase1>;
+/** Principal that most recently updated the connector. */
+export type ConnectConnectorUpdatedBy = ConnectConnectorUpdatedByCase0 | ConnectConnectorUpdatedByCase1;
+export declare const ConnectConnectorUpdatedBy: S.Schema<ConnectConnectorUpdatedBy>;
+/** How the connector row was originally created. New create paths stamp this explicitly; older rows may omit it. */
+export type ConnectConnectorCreationMode = "managed" | "manual";
+export declare const ConnectConnectorCreationMode: any;
+/** Managed connector metadata exposed without leaking the manager connector or installation identifiers. */
+export type ConnectConnectorManaged = ConnectConnectorCreateResultManaged;
+export declare const ConnectConnectorManaged: S.Schema<ConnectConnectorCreateResultManaged>;
+/** Connector implementation type. */
+export type ConnectConnectorType = "api-key" | "custom" | "discord" | "github" | "linear" | "linq" | "microsoft-entra" | "microsoft-teams" | "oauth" | "photon" | "salesforce" | "sendblue" | "slack" | "snowflake" | "snowflake-wif";
+export declare const ConnectConnectorType: any;
+/** Token subject types supported by the connector. */
+export type ConnectConnectorSupportedSubjectTypesList = Array<string>;
+export declare const ConnectConnectorSupportedSubjectTypesList: S.Schema<ConnectConnectorSupportedSubjectTypesList>;
+/** Known allowed app-level scopes. For Slack this is the bot scope set configured on the app; for OAuth it is the connector's enabled `clientCredentials.scopes` configuration. */
+export type ConnectConnectorAppTokensScopesList = Array<string>;
+export declare const ConnectConnectorAppTokensScopesList: S.Schema<ConnectConnectorAppTokensScopesList>;
+/** Supported OAuth authorization-detail type names. */
+export type ConnectConnectorAppTokensSupportedAuthorizationDetailsList = Array<string>;
+export declare const ConnectConnectorAppTokensSupportedAuthorizationDetailsList: S.Schema<ConnectConnectorAppTokensSupportedAuthorizationDetailsList>;
+/** App-token capabilities and known grants for the connector. */
+export interface ConnectConnectorAppTokens {
+    /** Whether one app token can be used across installations. */
+    crossInstallation: boolean;
+    /** Whether callers can narrow app-token grants per request. */
+    supportsRefinement: boolean;
+    /** True when changing app token grants requires reinstalling the app, so tokens cannot be partitioned independently by requester environment. */
+    requiresReinstallation?: boolean;
+    /** Known allowed app-level scopes. For Slack this is the bot scope set configured on the app; for OAuth it is the connector's enabled `clientCredentials.scopes` configuration. */
+    scopes?: ConnectConnectorAppTokensScopesList;
+    /** Supported OAuth authorization-detail type names. */
+    supportedAuthorizationDetails?: ConnectConnectorAppTokensSupportedAuthorizationDetailsList;
+    /** Link to the page on the service where this connector's app-level permissions are declared and granted, when the service has one and it differs from `clientUrl`. */
+    permissionsUrl?: string;
+}
+export declare const ConnectConnectorAppTokens: S.Schema<ConnectConnectorAppTokens>;
+/** Known allowed user-level scopes. For Slack this is the user scope set configured on the app; for OAuth it is the connector's enabled `userAuthorization.scopes` configuration. */
+export type ConnectConnectorUserTokensScopesList = Array<string>;
+export declare const ConnectConnectorUserTokensScopesList: S.Schema<ConnectConnectorUserTokensScopesList>;
+/** Supported OAuth authorization-detail type names. */
+export type ConnectConnectorUserTokensSupportedAuthorizationDetailsList = Array<string>;
+export declare const ConnectConnectorUserTokensSupportedAuthorizationDetailsList: S.Schema<ConnectConnectorUserTokensSupportedAuthorizationDetailsList>;
+/** User-token capabilities and known grants for the connector. */
+export interface ConnectConnectorUserTokens {
+    /** Whether one user token can be used across installations. */
+    crossInstallation: boolean;
+    /** Whether callers can narrow user-token grants per request. */
+    supportsRefinement: boolean;
+    /** Known allowed user-level scopes. For Slack this is the user scope set configured on the app; for OAuth it is the connector's enabled `userAuthorization.scopes` configuration. */
+    scopes?: ConnectConnectorUserTokensScopesList;
+    /** Supported OAuth authorization-detail type names. */
+    supportedAuthorizationDetails?: ConnectConnectorUserTokensSupportedAuthorizationDetailsList;
+    /** User authorization is completed by the Connect consent screen submitting a credential instead of an OAuth redirect. */
+    manualCredentialInput?: boolean;
+}
+export declare const ConnectConnectorUserTokens: S.Schema<ConnectConnectorUserTokens>;
+/** Known events this connector subscribes to (e.g. Slack bot events, GitHub webhook events). Names are type-specific and validated by the managed-create flow when forwarded to the third-party service. */
+export type ConnectConnectorEventsList = Array<string>;
+export declare const ConnectConnectorEventsList: S.Schema<ConnectConnectorEventsList>;
+/** Destinations that incoming triggers should be forwarded to. Limited to 3 entries. Set the initial destination with `triggerDestination` during creation. Replace the complete set with `PATCH /v1/connect/connectors/{connector}/trigger-destinations`. */
+export type ConnectConnectorTriggerDestinationsList = Array<ConnectTriggerDestination>;
+export declare const ConnectConnectorTriggerDestinationsList: S.Schema<ConnectConnectorTriggerDestinationsList>;
+/** A connector that defines how Vercel accesses an external service. */
+export interface ConnectConnector {
+    /** Stable `scl_` connector ID. Use this value directly in `{connector}`. */
+    id: string;
+    /** Team-scoped UID. URL-encode this value before using it in `{connector}`. */
+    uid: string;
+    /** Installation used when a token request does not specify an installation. */
+    defaultInstallationId?: string;
+    /** Creation time in epoch milliseconds. */
+    createdAt: number;
+    /** Last update time in epoch milliseconds. */
+    updatedAt: number;
+    /** Time when this connector started requiring reinstallation because an installation-affecting app-token grant changed. */
+    reinstallAt?: number;
+    /** Principal that created the connector. */
+    createdBy?: ConnectConnectorCreatedBy;
+    /** Principal that most recently updated the connector. */
+    updatedBy?: ConnectConnectorUpdatedBy;
+    /** How the connector row was originally created. New create paths stamp this explicitly; older rows may omit it. */
+    creationMode?: ConnectConnectorCreationMode;
+    /** Managed connector metadata exposed without leaking the manager connector or installation identifiers. */
+    managed?: ConnectConnectorCreateResultManaged;
+    /** Connector implementation type. */
+    type: ConnectConnectorType;
+    /** Best-effort identifier of the third-party service this connector represents, independent of `type`. Examples: `'slack'`, `'mcp.linear.app'`, and `'auth.example.com'`. Always present in API responses. */
+    service: string;
+    /** The connection method this connector was created from, when the create request named one. */
+    connectionMethod?: string;
+    /** Which of the service's products/surfaces this connector points at. */
+    target?: string;
+    /** Connector name within the owning team. */
+    name: string;
+    /** Human-readable connector name. */
+    displayName: string;
+    /** Provider-side URL for viewing or managing the resource represented by the connector. The destination can be an app, account, phone line, or service instance, depending on the connector type. */
+    clientUrl?: string | null;
+    /** Redirect URI registered with the third-party service for this connector, if any. Used by `startAuthorization`/`startInstallation` to replay the exact URI back to the provider's token endpoint. Absent on connectors created before this field was introduced; those callers fall back to the `https://connect.vercel.com/callback` default. */
+    redirectUri?: string;
+    /** Human-readable name of the connector type. */
+    typeName: string;
+    /** Icon identifier supplied by the connector type. */
+    typeIcon?: string;
+    /** Public website for the connected service. */
+    website?: string;
+    /** Developer website for the connected service. */
+    devsite?: string;
+    /** Developer documentation for the connected service. */
+    docsite?: string;
+    /** Connector branding icon. SHA-1 hash that resolves to the uploaded icon through the Vercel avatar service. Consumers render this with `https://vercel.com/api/www/avatar/{icon}`. */
+    icon?: string;
+    /** Hex background color (e.g., `#000000`) for branding. */
+    backgroundColor?: string;
+    /** Hex accent color (e.g., `#000000`) for branding. */
+    accentColor?: string;
+    /** Token subject types supported by the connector. */
+    supportedSubjectTypes: ConnectConnectorSupportedSubjectTypesList;
+    /** App-token capabilities and known grants for the connector. */
+    appTokens?: ConnectConnectorAppTokens;
+    /** User-token capabilities and known grants for the connector. */
+    userTokens?: ConnectConnectorUserTokens;
+    /** Whether the connector supports an installation flow. */
+    supportsInstallation: boolean;
+    /** Whether Connect can revoke tokens for this connector. */
+    supportsRevocation: boolean;
+    /** Whether this connector type supports trigger webhooks. Derived from the type definition; indicates that `triggers` and `triggerDestinations` may be meaningful for this connector. */
+    supportsTriggers: boolean;
+    /** Whether the connector icon can propagate to the provider. */
+    supportsIcon: unknown;
+    /** Incoming trigger configuration for the connector. */
+    triggers?: ConnectTriggerConfiguration;
+    /** Known events this connector subscribes to (e.g. Slack bot events, GitHub webhook events). Names are type-specific and validated by the managed-create flow when forwarded to the third-party service. */
+    events?: ConnectConnectorEventsList;
+    /** Destinations that incoming triggers should be forwarded to. Limited to 3 entries. Set the initial destination with `triggerDestination` during creation. Replace the complete set with `PATCH /v1/connect/connectors/{connector}/trigger-destinations`. */
+    triggerDestinations?: ConnectConnectorTriggerDestinationsList;
+}
+export declare const ConnectConnector: S.Schema<ConnectConnector>;
+export interface GetConnectorProjectConnectionRequest {
+    /** Stable connector ID or URL-encoded team-scoped UID. Examples: `scl_abc123` or `slack%2Fmy-bot`. */
+    connector: string;
+    /** Vercel project ID. */
+    projectId: string;
+    /** The team ID that scopes the request. Do not send it with slug. If both are omitted, Vercel uses the team associated with the token or the authenticated user's default team. The request returns 401 if no team can be selected. */
+    teamId?: string;
+    /** The team slug that scopes the request. Do not send it with teamId. If both are omitted, Vercel uses the team associated with the token or the authenticated user's default team. The request returns 401 if no team can be selected. */
+    slug?: string;
+}
+export declare const GetConnectorProjectConnectionRequest: S.Schema<GetConnectorProjectConnectionRequest>;
+/** Custom environments available on the project. This list can include environments where the connector is not enabled. */
+export interface ConnectProjectConnectionProjectCustomEnvironmentsItem {
+    /** Stable custom environment ID. */
+    id: string;
+    /** Current human-readable custom environment slug. */
+    slug: string;
+}
+export declare const ConnectProjectConnectionProjectCustomEnvironmentsItem: S.Schema<ConnectProjectConnectionProjectCustomEnvironmentsItem>;
+/** Custom environments available on the project. This list can include environments where the connector is not enabled. */
+export type ConnectProjectConnectionProjectCustomEnvironmentsList = Array<ConnectProjectConnectionProjectCustomEnvironmentsItem>;
+export declare const ConnectProjectConnectionProjectCustomEnvironmentsList: S.Schema<ConnectProjectConnectionProjectCustomEnvironmentsList>;
+/** Vercel project connected to the connector. */
+export interface ConnectProjectConnectionProject {
+    /** Same Vercel project ID as the connection's top-level `projectId`. */
+    id: string;
+    /** Current Vercel project name. */
+    name: string;
+    /** Custom environments available on the project. This list can include environments where the connector is not enabled. */
+    customEnvironments?: ConnectProjectConnectionProjectCustomEnvironmentsList;
+}
+export declare const ConnectProjectConnectionProject: S.Schema<ConnectProjectConnectionProject>;
+export type ConnectProjectConnectionEnabledEnvironmentsItemCase1 = "development" | "preview" | "production";
+export declare const ConnectProjectConnectionEnabledEnvironmentsItemCase1: any;
+export type ConnectProjectConnectionEnabledEnvironmentsItem = string | ConnectProjectConnectionEnabledEnvironmentsItemCase1;
+export declare const ConnectProjectConnectionEnabledEnvironmentsItem: S.Schema<ConnectProjectConnectionEnabledEnvironmentsItem>;
+/** Environments where the connector is enabled for the project. */
+export type ConnectProjectConnectionEnabledEnvironmentsList = Array<ConnectProjectConnectionEnabledEnvironmentsItem>;
+export declare const ConnectProjectConnectionEnabledEnvironmentsList: S.Schema<ConnectProjectConnectionEnabledEnvironmentsList>;
+/** A connection between a connector and a Vercel project, including the environments where the connector is enabled. */
+export interface ConnectProjectConnection {
+    /** Stable `scl_` connector ID, even when the request used a UID. */
+    connectorId: string;
+    /** Vercel project connected to the connector. */
+    project: ConnectProjectConnectionProject;
+    /** Environments where the connector is enabled for the project. */
+    enabledEnvironments: ConnectProjectConnectionEnabledEnvironmentsList;
+    /** Time when the project connection was created, in epoch milliseconds. */
+    createdAt: number;
+    /** Time when the project connection was last updated, in epoch milliseconds. */
+    updatedAt: number;
+}
+export declare const ConnectProjectConnection: S.Schema<ConnectProjectConnection>;
 export type GetConnectorTokenRequestSubjectCase0Type = "app";
 export declare const GetConnectorTokenRequestSubjectCase0Type: any;
 export interface GetConnectorTokenRequestSubjectCase0 {
@@ -875,160 +1417,812 @@ export interface GetConnectorTokenResponse {
     metadata?: GetConnectorTokenResponseMetadataMap;
 }
 export declare const GetConnectorTokenResponse: S.Schema<GetConnectorTokenResponse>;
-export type ImportConnectorTokensRequestTokensItemSubjectCase0Type = "app";
-export declare const ImportConnectorTokensRequestTokensItemSubjectCase0Type: any;
-export interface ImportConnectorTokensRequestTokensItemSubjectCase0 {
-    type: ImportConnectorTokensRequestTokensItemSubjectCase0Type;
-}
-export declare const ImportConnectorTokensRequestTokensItemSubjectCase0: S.Schema<ImportConnectorTokensRequestTokensItemSubjectCase0>;
-export type ImportConnectorTokensRequestTokensItemSubjectCase1Type = "user";
-export declare const ImportConnectorTokensRequestTokensItemSubjectCase1Type: any;
-export interface ImportConnectorTokensRequestTokensItemSubjectCase1 {
-    type: ImportConnectorTokensRequestTokensItemSubjectCase1Type;
-    id: string;
+export interface ListConnectorProjectConnectionsRequest {
+    /** Stable connector ID or URL-encoded team-scoped UID. Examples: `scl_abc123` or `slack%2Fmy-bot`. */
+    connector: string;
+    /** Maximum number of project connections to return. Defaults to 50. */
+    limit?: number;
+    /** Cursor from `pagination.next` on the previous response. */
+    cursor?: string;
+    /** The team ID that scopes the request. Do not send it with slug. If both are omitted, Vercel uses the team associated with the token or the authenticated user's default team. The request returns 401 if no team can be selected. */
+    teamId?: string;
+    /** The team slug that scopes the request. Do not send it with teamId. If both are omitted, Vercel uses the team associated with the token or the authenticated user's default team. The request returns 401 if no team can be selected. */
+    slug?: string;
+}
+export declare const ListConnectorProjectConnectionsRequest: S.Schema<ListConnectorProjectConnectionsRequest>;
+/** Project connections in this page. */
+export type ConnectConnectorProjectConnectionListProjectsList = Array<ConnectProjectConnection>;
+export declare const ConnectConnectorProjectConnectionListProjectsList: S.Schema<ConnectConnectorProjectConnectionListProjectsList>;
+/** Cursor for the next page. */
+export interface ConnectPagination {
+    /** Opaque value to pass as `cursor` on the next request. */
+    next: string | null;
+}
+export declare const ConnectPagination: S.Schema<ConnectPagination>;
+/** Page of projects connected to a connector. */
+export interface ConnectConnectorProjectConnectionList {
+    /** Project connections in this page. */
+    projects: ConnectConnectorProjectConnectionListProjectsList;
+    /** Cursor for the next page. */
+    pagination: ConnectPagination;
+}
+export declare const ConnectConnectorProjectConnectionList: S.Schema<ConnectConnectorProjectConnectionList>;
+/** Sort by name in ascending order, or by creation or update time in descending order. */
+export type ListConnectorsRequestSort = "name" | "createdAt" | "updatedAt";
+export declare const ListConnectorsRequestSort: any;
+export interface ListConnectorsRequest {
+    /** Maximum number of connectors to return. Defaults to 20. */
+    limit?: number;
+    /** Cursor from `pagination.next` on the previous response. */
+    cursor?: string;
+    /** Return only connectors connected to this project. */
+    projectId?: string;
+    /** Search connector names, UIDs, and services. */
+    search?: string;
+    /** Comma-separated connector types: `slack`, `discord`, `github`, `linear`, `linq`, `salesforce`, `sendblue`, `snowflake`, `snowflake-wif`, `microsoft-entra`, `api-key`, `photon`, `oauth`, or `custom`. */
+    type?: string;
+    /** Comma-separated provider or service identifiers. */
+    service?: string;
+    /** Sort by name in ascending order, or by creation or update time in descending order. */
+    sort?: ListConnectorsRequestSort | (string & {});
+    /** The team ID that scopes the request. Do not send it with slug. If both are omitted, Vercel uses the team associated with the token or the authenticated user's default team. The request returns 401 if no team can be selected. */
+    teamId?: string;
+    /** The team slug that scopes the request. Do not send it with teamId. If both are omitted, Vercel uses the team associated with the token or the authenticated user's default team. The request returns 401 if no team can be selected. */
+    slug?: string;
+}
+export declare const ListConnectorsRequest: S.Schema<ListConnectorsRequest>;
+/** Connectors in this page. */
+export type ConnectConnectorListConnectorsList = Array<ConnectConnector>;
+export declare const ConnectConnectorListConnectorsList: S.Schema<ConnectConnectorListConnectorsList>;
+/** Page of connectors. */
+export interface ConnectConnectorList {
+    /** Connectors in this page. */
+    connectors: ConnectConnectorListConnectorsList;
+    /** Cursor for the next page. */
+    pagination: ConnectPagination;
+}
+export declare const ConnectConnectorList: S.Schema<ConnectConnectorList>;
+export interface ListProjectConnectorConnectionsRequest {
+    /** Vercel project ID. */
+    projectId: string;
+    /** Maximum number of connector connections to return. Defaults to 50. */
+    limit?: number;
+    /** Cursor from `pagination.next` on the previous response. */
+    cursor?: string;
+    /** The team ID that scopes the request. Do not send it with slug. If both are omitted, Vercel uses the team associated with the token or the authenticated user's default team. The request returns 401 if no team can be selected. */
+    teamId?: string;
+    /** The team slug that scopes the request. Do not send it with teamId. If both are omitted, Vercel uses the team associated with the token or the authenticated user's default team. The request returns 401 if no team can be selected. */
+    slug?: string;
+}
+export declare const ListProjectConnectorConnectionsRequest: S.Schema<ListProjectConnectorConnectionsRequest>;
+/** Connector connections in this page. */
+export type ConnectProjectConnectorConnectionListConnectorsList = Array<ConnectProjectConnection>;
+export declare const ConnectProjectConnectorConnectionListConnectorsList: S.Schema<ConnectProjectConnectorConnectionListConnectorsList>;
+/** Page of connectors connected to a project. */
+export interface ConnectProjectConnectorConnectionList {
+    /** Connector connections in this page. */
+    connectors: ConnectProjectConnectorConnectionListConnectorsList;
+    /** Cursor for the next page. */
+    pagination: ConnectPagination;
+}
+export declare const ConnectProjectConnectorConnectionList: S.Schema<ConnectProjectConnectorConnectionList>;
+export interface ConnectTriggerDestinationInputCase0 {
+    /** Project that receives matching trigger requests. */
+    projectId: string;
+    /** Route path on the linked project that receives forwarded trigger requests. */
+    path?: string;
+}
+export declare const ConnectTriggerDestinationInputCase0: S.Schema<ConnectTriggerDestinationInputCase0>;
+export interface ConnectTriggerDestinationInputCase1 {
+    /** Project that receives matching trigger requests. */
+    projectId: string;
+    /** Git branch used to select a preview deployment. */
+    branch: string;
+    /** Route path on the linked project that receives forwarded trigger requests. */
+    path?: string;
+}
+export declare const ConnectTriggerDestinationInputCase1: S.Schema<ConnectTriggerDestinationInputCase1>;
+export interface ConnectTriggerDestinationInputCase2 {
+    /** Project that receives matching trigger requests. */
+    projectId: string;
+    /** Stable custom environment ID that belongs to the destination project. */
+    customEnvironmentId: string;
+    /** Route path on the linked project that receives forwarded trigger requests. */
+    path?: string;
+}
+export declare const ConnectTriggerDestinationInputCase2: S.Schema<ConnectTriggerDestinationInputCase2>;
+/** A destination in the complete replacement set. Each destination targets the default deployment, a branch, or a custom environment. */
+export type ConnectTriggerDestinationInput = ConnectTriggerDestinationInputCase0 | ConnectTriggerDestinationInputCase1 | ConnectTriggerDestinationInputCase2;
+export declare const ConnectTriggerDestinationInput: S.Schema<ConnectTriggerDestinationInput>;
+/** Complete replacement set of trigger destinations. An empty array removes all destinations. Connector get and list responses expose the saved set as triggerDestinations. */
+export type ReplaceConnectorTriggerDestinationsRequestDestinationsList = Array<ConnectTriggerDestinationInput>;
+export declare const ReplaceConnectorTriggerDestinationsRequestDestinationsList: S.Schema<ReplaceConnectorTriggerDestinationsRequestDestinationsList>;
+export interface ReplaceConnectorTriggerDestinationsRequest {
+    /** Stable connector ID or URL-encoded team-scoped UID. Examples: `scl_abc123` or `slack%2Fmy-bot`. */
+    connector: string;
+    /** The team ID that scopes the request. Do not send it with slug. If both are omitted, Vercel uses the team associated with the token or the authenticated user's default team. The request returns 401 if no team can be selected. */
+    teamId?: string;
+    /** The team slug that scopes the request. Do not send it with teamId. If both are omitted, Vercel uses the team associated with the token or the authenticated user's default team. The request returns 401 if no team can be selected. */
+    slug?: string;
+    /** Complete replacement set of trigger destinations. An empty array removes all destinations. Connector get and list responses expose the saved set as triggerDestinations. */
+    destinations: ReplaceConnectorTriggerDestinationsRequestDestinationsList;
+}
+export declare const ReplaceConnectorTriggerDestinationsRequest: S.Schema<ReplaceConnectorTriggerDestinationsRequest>;
+/** Default trigger events for this connector. */
+export type UpdateConnectorRequestEventsList = Array<string>;
+export declare const UpdateConnectorRequestEventsList: S.Schema<UpdateConnectorRequestEventsList>;
+/** Intended key use: signing or encryption. */
+export type ConnectConnectorUpdateDataCase0ServerConfigJwksKeysItemUse = "sig" | "enc";
+export declare const ConnectConnectorUpdateDataCase0ServerConfigJwksKeysItemUse: any;
+/** Operations permitted for this key. */
+export type ConnectConnectorUpdateDataCase0ServerConfigJwksKeysItemKeyOpsList = Array<string>;
+export declare const ConnectConnectorUpdateDataCase0ServerConfigJwksKeysItemKeyOpsList: S.Schema<ConnectConnectorUpdateDataCase0ServerConfigJwksKeysItemKeyOpsList>;
+export interface ConnectConnectorUpdateDataCase0ServerConfigJwksKeysItem {
+    /** JSON Web Key type. */
+    kty: string;
+    /** JSON Web Key identifier. */
+    kid?: string;
+    /** Intended key use: signing or encryption. */
+    use?: ConnectConnectorUpdateDataCase0ServerConfigJwksKeysItemUse | (string & {});
+    /** Operations permitted for this key. */
+    key_ops?: ConnectConnectorUpdateDataCase0ServerConfigJwksKeysItemKeyOpsList;
+    /** Algorithm intended for this key. */
+    alg?: string;
+}
+export declare const ConnectConnectorUpdateDataCase0ServerConfigJwksKeysItem: S.Schema<ConnectConnectorUpdateDataCase0ServerConfigJwksKeysItem>;
+/** JSON Web Keys published by the authorization server. */
+export type ConnectConnectorUpdateDataCase0ServerConfigJwksKeysList = Array<ConnectConnectorUpdateDataCase0ServerConfigJwksKeysItem>;
+export declare const ConnectConnectorUpdateDataCase0ServerConfigJwksKeysList: S.Schema<ConnectConnectorUpdateDataCase0ServerConfigJwksKeysList>;
+/** Inline authorization server JSON Web Key Set. */
+export interface ConnectConnectorUpdateDataCase0ServerConfigJwks {
+    /** JSON Web Keys published by the authorization server. */
+    keys: ConnectConnectorUpdateDataCase0ServerConfigJwksKeysList;
+}
+export declare const ConnectConnectorUpdateDataCase0ServerConfigJwks: S.Schema<ConnectConnectorUpdateDataCase0ServerConfigJwks>;
+/** OAuth response types supported by the server. */
+export type ConnectConnectorUpdateDataCase0ServerConfigResponseTypesSupportedList = Array<string>;
+export declare const ConnectConnectorUpdateDataCase0ServerConfigResponseTypesSupportedList: S.Schema<ConnectConnectorUpdateDataCase0ServerConfigResponseTypesSupportedList>;
+/** Token endpoint client authentication methods supported by the server. */
+export type ConnectConnectorUpdateDataCase0ServerConfigTokenEndpointAuthMethodsSupportedList = Array<string>;
+export declare const ConnectConnectorUpdateDataCase0ServerConfigTokenEndpointAuthMethodsSupportedList: S.Schema<ConnectConnectorUpdateDataCase0ServerConfigTokenEndpointAuthMethodsSupportedList>;
+/** Signing algorithms supported for token endpoint authentication. */
+export type ConnectConnectorUpdateDataCase0ServerConfigTokenEndpointAuthSigningAlgValuesSupportedList = Array<string>;
+export declare const ConnectConnectorUpdateDataCase0ServerConfigTokenEndpointAuthSigningAlgValuesSupportedList: S.Schema<ConnectConnectorUpdateDataCase0ServerConfigTokenEndpointAuthSigningAlgValuesSupportedList>;
+/** OAuth scopes supported by the server. */
+export type ConnectConnectorUpdateDataCase0ServerConfigScopesSupportedList = Array<string>;
+export declare const ConnectConnectorUpdateDataCase0ServerConfigScopesSupportedList: S.Schema<ConnectConnectorUpdateDataCase0ServerConfigScopesSupportedList>;
+/** OAuth grant types supported by the server. */
+export type ConnectConnectorUpdateDataCase0ServerConfigGrantTypesSupportedList = Array<string>;
+export declare const ConnectConnectorUpdateDataCase0ServerConfigGrantTypesSupportedList: S.Schema<ConnectConnectorUpdateDataCase0ServerConfigGrantTypesSupportedList>;
+/** OAuth response modes supported by the server. */
+export type ConnectConnectorUpdateDataCase0ServerConfigResponseModesSupportedList = Array<string>;
+export declare const ConnectConnectorUpdateDataCase0ServerConfigResponseModesSupportedList: S.Schema<ConnectConnectorUpdateDataCase0ServerConfigResponseModesSupportedList>;
+/** OpenID Connect subject identifier types supported by the server. */
+export type ConnectConnectorUpdateDataCase0ServerConfigSubjectTypesSupportedList = Array<string>;
+export declare const ConnectConnectorUpdateDataCase0ServerConfigSubjectTypesSupportedList: S.Schema<ConnectConnectorUpdateDataCase0ServerConfigSubjectTypesSupportedList>;
+/** Signing algorithms supported for ID tokens. */
+export type ConnectConnectorUpdateDataCase0ServerConfigIdTokenSigningAlgValuesSupportedList = Array<string>;
+export declare const ConnectConnectorUpdateDataCase0ServerConfigIdTokenSigningAlgValuesSupportedList: S.Schema<ConnectConnectorUpdateDataCase0ServerConfigIdTokenSigningAlgValuesSupportedList>;
+/** Key management algorithms supported for encrypted ID tokens. */
+export type ConnectConnectorUpdateDataCase0ServerConfigIdTokenEncryptionAlgValuesSupportedList = Array<string>;
+export declare const ConnectConnectorUpdateDataCase0ServerConfigIdTokenEncryptionAlgValuesSupportedList: S.Schema<ConnectConnectorUpdateDataCase0ServerConfigIdTokenEncryptionAlgValuesSupportedList>;
+/** Content encryption algorithms supported for encrypted ID tokens. */
+export type ConnectConnectorUpdateDataCase0ServerConfigIdTokenEncryptionEncValuesSupportedList = Array<string>;
+export declare const ConnectConnectorUpdateDataCase0ServerConfigIdTokenEncryptionEncValuesSupportedList: S.Schema<ConnectConnectorUpdateDataCase0ServerConfigIdTokenEncryptionEncValuesSupportedList>;
+/** OpenID Connect claim value types supported by the server. */
+export type ConnectConnectorUpdateDataCase0ServerConfigClaimTypesSupportedList = Array<string>;
+export declare const ConnectConnectorUpdateDataCase0ServerConfigClaimTypesSupportedList: S.Schema<ConnectConnectorUpdateDataCase0ServerConfigClaimTypesSupportedList>;
+/** Claims that the authorization server can return. */
+export type ConnectConnectorUpdateDataCase0ServerConfigClaimsSupportedList = Array<string>;
+export declare const ConnectConnectorUpdateDataCase0ServerConfigClaimsSupportedList: S.Schema<ConnectConnectorUpdateDataCase0ServerConfigClaimsSupportedList>;
+/** PKCE code challenge methods supported by the server. */
+export type ConnectConnectorUpdateDataCase0ServerConfigCodeChallengeMethodsSupportedList = Array<string>;
+export declare const ConnectConnectorUpdateDataCase0ServerConfigCodeChallengeMethodsSupportedList: S.Schema<ConnectConnectorUpdateDataCase0ServerConfigCodeChallengeMethodsSupportedList>;
+/** Authorization prompt values supported by the server. */
+export type ConnectConnectorUpdateDataCase0ServerConfigPromptValuesSupportedList = Array<string>;
+export declare const ConnectConnectorUpdateDataCase0ServerConfigPromptValuesSupportedList: S.Schema<ConnectConnectorUpdateDataCase0ServerConfigPromptValuesSupportedList>;
+/** OAuth authorization-detail types supported by the server. */
+export type ConnectConnectorUpdateDataCase0ServerConfigAuthorizationDetailsTypesSupportedList = Array<string>;
+export declare const ConnectConnectorUpdateDataCase0ServerConfigAuthorizationDetailsTypesSupportedList: S.Schema<ConnectConnectorUpdateDataCase0ServerConfigAuthorizationDetailsTypesSupportedList>;
+/** Authorization server metadata. Values override discovered metadata. Empty known string fields remove their stored overrides. */
+export interface ConnectConnectorUpdateDataCase0ServerConfig {
+    /** Authorization server issuer URL. */
     issuer?: string;
+    /** OAuth authorization endpoint URL. */
+    authorization_endpoint?: string;
+    /** OAuth token endpoint URL. */
+    token_endpoint?: string;
+    /** OpenID Connect UserInfo endpoint URL. */
+    userinfo_endpoint?: string;
+    /** URL of the authorization server JSON Web Key Set. */
+    jwks_uri?: string;
+    /** Inline authorization server JSON Web Key Set. */
+    jwks?: ConnectConnectorUpdateDataCase0ServerConfigJwks;
+    /** OAuth token revocation endpoint URL. */
+    revocation_endpoint?: string;
+    /** OAuth token introspection endpoint URL. */
+    introspection_endpoint?: string;
+    /** OpenID Connect session termination endpoint URL. */
+    end_session_endpoint?: string;
+    /** OAuth device authorization endpoint URL. */
+    device_authorization_endpoint?: string;
+    /** OAuth dynamic client registration endpoint URL. */
+    registration_endpoint?: string;
+    /** OAuth response types supported by the server. */
+    response_types_supported?: ConnectConnectorUpdateDataCase0ServerConfigResponseTypesSupportedList;
+    /** Token endpoint client authentication methods supported by the server. */
+    token_endpoint_auth_methods_supported?: ConnectConnectorUpdateDataCase0ServerConfigTokenEndpointAuthMethodsSupportedList;
+    /** Signing algorithms supported for token endpoint authentication. */
+    token_endpoint_auth_signing_alg_values_supported?: ConnectConnectorUpdateDataCase0ServerConfigTokenEndpointAuthSigningAlgValuesSupportedList;
+    /** OAuth scopes supported by the server. */
+    scopes_supported?: ConnectConnectorUpdateDataCase0ServerConfigScopesSupportedList;
+    /** OAuth grant types supported by the server. */
+    grant_types_supported?: ConnectConnectorUpdateDataCase0ServerConfigGrantTypesSupportedList;
+    /** OAuth response modes supported by the server. */
+    response_modes_supported?: ConnectConnectorUpdateDataCase0ServerConfigResponseModesSupportedList;
+    /** OpenID Connect subject identifier types supported by the server. */
+    subject_types_supported?: ConnectConnectorUpdateDataCase0ServerConfigSubjectTypesSupportedList;
+    /** Signing algorithms supported for ID tokens. */
+    id_token_signing_alg_values_supported?: ConnectConnectorUpdateDataCase0ServerConfigIdTokenSigningAlgValuesSupportedList;
+    /** Key management algorithms supported for encrypted ID tokens. */
+    id_token_encryption_alg_values_supported?: ConnectConnectorUpdateDataCase0ServerConfigIdTokenEncryptionAlgValuesSupportedList;
+    /** Content encryption algorithms supported for encrypted ID tokens. */
+    id_token_encryption_enc_values_supported?: ConnectConnectorUpdateDataCase0ServerConfigIdTokenEncryptionEncValuesSupportedList;
+    /** OpenID Connect claim value types supported by the server. */
+    claim_types_supported?: ConnectConnectorUpdateDataCase0ServerConfigClaimTypesSupportedList;
+    /** Claims that the authorization server can return. */
+    claims_supported?: ConnectConnectorUpdateDataCase0ServerConfigClaimsSupportedList;
+    /** PKCE code challenge methods supported by the server. */
+    code_challenge_methods_supported?: ConnectConnectorUpdateDataCase0ServerConfigCodeChallengeMethodsSupportedList;
+    /** Authorization prompt values supported by the server. */
+    prompt_values_supported?: ConnectConnectorUpdateDataCase0ServerConfigPromptValuesSupportedList;
+    /** Whether authorization requests can use the claims parameter. */
+    claims_parameter_supported?: boolean;
+    /** Whether authorization requests can use signed request objects. */
+    request_parameter_supported?: boolean;
+    /** Whether authorization requests can use request_uri. */
+    request_uri_parameter_supported?: boolean;
+    /** Whether request_uri values must be registered in advance. */
+    require_request_uri_registration?: boolean;
+    /** Authorization server documentation URL. */
+    service_documentation?: string;
+    /** Authorization server privacy policy URL. */
+    op_policy_uri?: string;
+    /** Authorization server terms of service URL. */
+    op_tos_uri?: string;
+    /** Authorization server logo URL. */
+    logo_uri?: string;
+    /** Whether the server supports OAuth client ID metadata documents. */
+    client_id_metadata_document_supported?: boolean;
+    /** OAuth authorization-detail types supported by the server. */
+    authorization_details_types_supported?: ConnectConnectorUpdateDataCase0ServerConfigAuthorizationDetailsTypesSupportedList;
 }
-export declare const ImportConnectorTokensRequestTokensItemSubjectCase1: S.Schema<ImportConnectorTokensRequestTokensItemSubjectCase1>;
-export type ImportConnectorTokensRequestTokensItemSubject = ImportConnectorTokensRequestTokensItemSubjectCase0 | ImportConnectorTokensRequestTokensItemSubjectCase1;
-export declare const ImportConnectorTokensRequestTokensItemSubject: S.Schema<ImportConnectorTokensRequestTokensItemSubject>;
-export type ImportConnectorTokensRequestTokensItemEnvironmentCase0 = "development" | "preview" | "production";
-export declare const ImportConnectorTokensRequestTokensItemEnvironmentCase0: any;
-/** A built-in environment name or the stable env_* ID of a custom environment. */
-export type ImportConnectorTokensRequestTokensItemEnvironment = ImportConnectorTokensRequestTokensItemEnvironmentCase0 | string;
-export declare const ImportConnectorTokensRequestTokensItemEnvironment: S.Schema<ImportConnectorTokensRequestTokensItemEnvironment>;
-export type ImportConnectorTokensRequestTokensItemAudienceList = Array<string>;
-export declare const ImportConnectorTokensRequestTokensItemAudienceList: S.Schema<ImportConnectorTokensRequestTokensItemAudienceList>;
-export type ImportConnectorTokensRequestTokensItemScopesList = Array<string>;
-export declare const ImportConnectorTokensRequestTokensItemScopesList: S.Schema<ImportConnectorTokensRequestTokensItemScopesList>;
-export type ImportConnectorTokensRequestTokensItemResourcesList = Array<string>;
-export declare const ImportConnectorTokensRequestTokensItemResourcesList: S.Schema<ImportConnectorTokensRequestTokensItemResourcesList>;
-export type ImportConnectorTokensRequestTokensItemAuthorizationDetailsItem = CreateConnectorAuthorizationRequestRequestAuthorizationDetailsItem;
-export declare const ImportConnectorTokensRequestTokensItemAuthorizationDetailsItem: S.Schema<CreateConnectorAuthorizationRequestRequestAuthorizationDetailsItem>;
-export type ImportConnectorTokensRequestTokensItemAuthorizationDetailsList = Array<CreateConnectorAuthorizationRequestRequestAuthorizationDetailsItem>;
-export declare const ImportConnectorTokensRequestTokensItemAuthorizationDetailsList: S.Schema<ImportConnectorTokensRequestTokensItemAuthorizationDetailsList>;
-export interface ImportConnectorTokensRequestTokensItemInstallation {
+export declare const ConnectConnectorUpdateDataCase0ServerConfig: S.Schema<ConnectConnectorUpdateDataCase0ServerConfig>;
+/** Default scopes to request when token params specify scopes: [\"*\"]. */
+export type ConnectConnectorUpdateDataCase0UserAuthorizationScopesList = Array<string>;
+export declare const ConnectConnectorUpdateDataCase0UserAuthorizationScopesList: S.Schema<ConnectConnectorUpdateDataCase0UserAuthorizationScopesList>;
+/** User authorization grant settings. */
+export interface ConnectConnectorUpdateDataCase0UserAuthorization {
+    /** Whether this OAuth grant is enabled. */
+    enabled: boolean;
+    /** Default scopes to request when token params specify scopes: [\"*\"]. */
+    scopes?: ConnectConnectorUpdateDataCase0UserAuthorizationScopesList;
+}
+export declare const ConnectConnectorUpdateDataCase0UserAuthorization: S.Schema<ConnectConnectorUpdateDataCase0UserAuthorization>;
+/** Refresh token settings. */
+export type ConnectConnectorUpdateDataCase0RefreshTokens = ConnectConnectorCreateDataCase0RefreshTokens;
+export declare const ConnectConnectorUpdateDataCase0RefreshTokens: S.Schema<ConnectConnectorCreateDataCase0RefreshTokens>;
+/** Default scopes to request when token params specify scopes: [\"*\"]. */
+export type ConnectConnectorUpdateDataCase0ClientCredentialsScopesList = Array<string>;
+export declare const ConnectConnectorUpdateDataCase0ClientCredentialsScopesList: S.Schema<ConnectConnectorUpdateDataCase0ClientCredentialsScopesList>;
+/** Client credentials grant settings. */
+export interface ConnectConnectorUpdateDataCase0ClientCredentials {
+    /** Whether this OAuth grant is enabled. */
+    enabled: boolean;
+    /** Default scopes to request when token params specify scopes: [\"*\"]. */
+    scopes?: ConnectConnectorUpdateDataCase0ClientCredentialsScopesList;
+}
+export declare const ConnectConnectorUpdateDataCase0ClientCredentials: S.Schema<ConnectConnectorUpdateDataCase0ClientCredentials>;
+/** ID token claim names that Connect can expose. */
+export type ConnectConnectorUpdateDataCase0ForwardedClaimsIdTokenList = Array<string>;
+export declare const ConnectConnectorUpdateDataCase0ForwardedClaimsIdTokenList: S.Schema<ConnectConnectorUpdateDataCase0ForwardedClaimsIdTokenList>;
+/** Allow-list of extra claims to propagate, keyed by source (idToken). Only claims named here and present in that source are exposed. */
+export interface ConnectConnectorUpdateDataCase0ForwardedClaims {
+    /** ID token claim names that Connect can expose. */
+    idToken?: ConnectConnectorUpdateDataCase0ForwardedClaimsIdTokenList;
+}
+export declare const ConnectConnectorUpdateDataCase0ForwardedClaims: S.Schema<ConnectConnectorUpdateDataCase0ForwardedClaims>;
+/** Extra query parameters added to authorization URLs. */
+export type ConnectConnectorUpdateDataCase0AuthorizationUrlParamsMap = {
+    [key: string]: string | undefined;
+};
+export declare const ConnectConnectorUpdateDataCase0AuthorizationUrlParamsMap: S.Schema<ConnectConnectorUpdateDataCase0AuthorizationUrlParamsMap>;
+/** Default scopes to request when token params specify scopes: [\"*\"]. */
+export type ConnectConnectorUpdateDataCase0JwtBearerScopesList = Array<string>;
+export declare const ConnectConnectorUpdateDataCase0JwtBearerScopesList: S.Schema<ConnectConnectorUpdateDataCase0JwtBearerScopesList>;
+/** Additional claims included in generated JWT assertions. */
+export type ConnectConnectorUpdateDataCase0JwtBearerAdditionalClaimsMap = {
+    [key: string]: unknown | undefined;
+};
+export declare const ConnectConnectorUpdateDataCase0JwtBearerAdditionalClaimsMap: S.Schema<ConnectConnectorUpdateDataCase0JwtBearerAdditionalClaimsMap>;
+/** JWT bearer grant settings. */
+export interface ConnectConnectorUpdateDataCase0JwtBearer {
+    /** Whether JWT bearer grants are enabled. */
+    enabled?: boolean;
+    /** Default scopes to request when token params specify scopes: [\"*\"]. */
+    scopes?: ConnectConnectorUpdateDataCase0JwtBearerScopesList;
+    /** Default JWT subject claim. */
+    sub?: string;
+    /** Default JWT issuer claim. */
+    iss?: string;
+    /** Default JWT audience claim. */
+    aud?: string;
+    /** Additional claims included in generated JWT assertions. */
+    additionalClaims?: ConnectConnectorUpdateDataCase0JwtBearerAdditionalClaimsMap;
+    /** JWT lifetime in seconds. */
+    ttl?: number;
+    /** Whether JWT bearer requests also use client credentials. */
+    useClientCredentials?: boolean;
+}
+export declare const ConnectConnectorUpdateDataCase0JwtBearer: S.Schema<ConnectConnectorUpdateDataCase0JwtBearer>;
+/** Additional claims included in the client assertion. */
+export type ConnectConnectorUpdateDataCase0ClientAssertionClaimsMap = {
+    [key: string]: unknown | undefined;
+};
+export declare const ConnectConnectorUpdateDataCase0ClientAssertionClaimsMap: S.Schema<ConnectConnectorUpdateDataCase0ClientAssertionClaimsMap>;
+/** `private_key_jwt` client assertion settings. */
+export interface ConnectConnectorUpdateDataCase0ClientAssertion {
+    /** OAuth client assertion type. Defaults to urn:ietf:params:oauth:client-assertion-type:jwt-bearer. An empty string clears the configured type. */
+    type?: string;
+    /** Client assertion lifetime in seconds. */
+    ttl?: number;
+    /** Additional claims included in the client assertion. */
+    claims?: ConnectConnectorUpdateDataCase0ClientAssertionClaimsMap;
+}
+export declare const ConnectConnectorUpdateDataCase0ClientAssertion: S.Schema<ConnectConnectorUpdateDataCase0ClientAssertion>;
+export interface ConnectConnectorUpdateDataCase0 {
+    /** Authorization server base URL used for discovery. */
+    serverUrl?: string;
+    /** Authorization server metadata. Values override discovered metadata. Empty known string fields remove their stored overrides. */
+    serverConfig?: ConnectConnectorUpdateDataCase0ServerConfig;
+    /** OAuth client ID. */
+    clientId?: string;
+    /** OAuth client name. */
+    clientName?: string;
+    /** OAuth client secret. */
+    clientSecret?: string | Redacted.Redacted<string>;
+    /** OAuth token endpoint authentication method. Common values are client_secret_post, client_secret_basic, none, and private_key_jwt. If omitted, Vercel selects a supported method from serverConfig and otherwise uses client_secret_post. */
+    tokenEndpointAuthMethod?: string;
+    /** OAuth authorization response type. Defaults to code. Other provider-supported values are accepted. An empty string clears the configured type. */
+    responseType?: string;
+    /** Whether user authorization must use PKCE. */
+    pkceRequired?: boolean;
+    /** PKCE code challenge method. Supported values are S256 and plain. Vercel prefers S256 when the provider supports it. An empty string clears the configured method. */
+    codeChallengeMethod?: string;
+    /** User authorization grant settings. */
+    userAuthorization?: ConnectConnectorUpdateDataCase0UserAuthorization;
+    /** Refresh token settings. */
+    refreshTokens?: ConnectConnectorCreateDataCase0RefreshTokens;
+    /** Client credentials grant settings. */
+    clientCredentials?: ConnectConnectorUpdateDataCase0ClientCredentials;
+    /** Allow-list of extra claims to propagate, keyed by source (idToken). Only claims named here and present in that source are exposed. */
+    forwardedClaims?: ConnectConnectorUpdateDataCase0ForwardedClaims;
+    /** Default audience used when a token request omits one. An empty string clears the default. */
+    defaultAudience?: string;
+    /** Default token lifetime in seconds to use when the token response omits expires_in. */
+    defaultTokenExpiresIn?: number;
+    /** Extra query parameters added to authorization URLs. */
+    authorizationUrlParams?: ConnectConnectorUpdateDataCase0AuthorizationUrlParamsMap;
+    /** JWT bearer grant settings. */
+    jwtBearer?: ConnectConnectorUpdateDataCase0JwtBearer;
+    /** `private_key_jwt` client assertion settings. */
+    clientAssertion?: ConnectConnectorUpdateDataCase0ClientAssertion;
+}
+export declare const ConnectConnectorUpdateDataCase0: S.Schema<ConnectConnectorUpdateDataCase0>;
+/** Stored API key value IDs to delete. */
+export type ConnectConnectorUpdateDataCase1ToDeleteList = Array<string>;
+export declare const ConnectConnectorUpdateDataCase1ToDeleteList: S.Schema<ConnectConnectorUpdateDataCase1ToDeleteList>;
+export type ConnectConnectorUpdateDataCase1ToAddItem = ConnectConnectorCreateDataCase1ValuesItem;
+export declare const ConnectConnectorUpdateDataCase1ToAddItem: S.Schema<ConnectConnectorCreateDataCase1ValuesItem>;
+/** API key values to add. */
+export type ConnectConnectorUpdateDataCase1ToAddList = Array<ConnectConnectorCreateDataCase1ValuesItem>;
+export declare const ConnectConnectorUpdateDataCase1ToAddList: S.Schema<ConnectConnectorUpdateDataCase1ToAddList>;
+/** The timestamp when the API key value expires in milliseconds. */
+export type ConnectConnectorUpdateDataCase1ToUpdateItemExpiresAt = number | string;
+export declare const ConnectConnectorUpdateDataCase1ToUpdateItemExpiresAt: S.Schema<ConnectConnectorUpdateDataCase1ToUpdateItemExpiresAt>;
+export interface ConnectConnectorUpdateDataCase1ToUpdateItem {
+    /** Stored API key value ID. */
     id: string;
+    /** Replacement API key value. Use null to keep the stored value. */
+    value?: string;
+    /** Replacement scope. Use null to remove the scope. */
+    scope?: string;
+    /** The timestamp when the API key value expires in milliseconds. */
+    expiresAt?: ConnectConnectorUpdateDataCase1ToUpdateItemExpiresAt;
+}
+export declare const ConnectConnectorUpdateDataCase1ToUpdateItem: S.Schema<ConnectConnectorUpdateDataCase1ToUpdateItem>;
+/** Existing API key values to update. */
+export type ConnectConnectorUpdateDataCase1ToUpdateList = Array<ConnectConnectorUpdateDataCase1ToUpdateItem>;
+export declare const ConnectConnectorUpdateDataCase1ToUpdateList: S.Schema<ConnectConnectorUpdateDataCase1ToUpdateList>;
+export interface ConnectConnectorUpdateDataCase1 {
+    /** Stored API key value IDs to delete. */
+    toDelete?: ConnectConnectorUpdateDataCase1ToDeleteList;
+    /** API key values to add. */
+    toAdd?: ConnectConnectorUpdateDataCase1ToAddList;
+    /** Existing API key values to update. */
+    toUpdate?: ConnectConnectorUpdateDataCase1ToUpdateList;
+}
+export declare const ConnectConnectorUpdateDataCase1: S.Schema<ConnectConnectorUpdateDataCase1>;
+/** GitHub App owner type. */
+export type ConnectConnectorUpdateDataCase2OwnerType = "user" | "organization" | "User" | "Organization";
+export declare const ConnectConnectorUpdateDataCase2OwnerType: any;
+/** GitHub App owner. */
+export interface ConnectConnectorUpdateDataCase2Owner {
+    /** GitHub App owner type. */
+    type: ConnectConnectorUpdateDataCase2OwnerType | (string & {});
+    /** GitHub App owner numeric ID. */
+    id: number;
+    /** GitHub App owner login. */
+    slug: string;
+    /** GitHub App owner display name. */
     name?: string;
 }
-export declare const ImportConnectorTokensRequestTokensItemInstallation: S.Schema<ImportConnectorTokensRequestTokensItemInstallation>;
-export type ImportConnectorTokensRequestTokensItemTenant = ImportConnectorTokensRequestTokensItemInstallation;
-export declare const ImportConnectorTokensRequestTokensItemTenant: S.Schema<ImportConnectorTokensRequestTokensItemInstallation>;
-export type ImportConnectorTokensRequestTokensItemDataMap = {
+export declare const ConnectConnectorUpdateDataCase2Owner: S.Schema<ConnectConnectorUpdateDataCase2Owner>;
+/** Additional provider metadata stored with the connector. */
+export type ConnectConnectorUpdateDataCase2ExtrasMap = {
     [key: string]: unknown | undefined;
 };
-export declare const ImportConnectorTokensRequestTokensItemDataMap: S.Schema<ImportConnectorTokensRequestTokensItemDataMap>;
-export interface ImportConnectorTokensRequestTokensItem {
-    accessToken: string | Redacted.Redacted<string>;
-    expiresAt: number;
-    refreshToken?: string | Redacted.Redacted<string>;
-    refreshTokenExpiresAt?: number;
-    subject: ImportConnectorTokensRequestTokensItemSubject;
-    /** A built-in environment name or the stable env_* ID of a custom environment. */
-    environment: ImportConnectorTokensRequestTokensItemEnvironment;
-    installationId?: string;
-    audience?: ImportConnectorTokensRequestTokensItemAudienceList;
-    scopes?: ImportConnectorTokensRequestTokensItemScopesList;
-    resources?: ImportConnectorTokensRequestTokensItemResourcesList;
-    authorizationDetails?: ImportConnectorTokensRequestTokensItemAuthorizationDetailsList;
-    name?: string;
-    externalSubject?: string;
-    installation?: ImportConnectorTokensRequestTokensItemInstallation;
-    tenant?: ImportConnectorTokensRequestTokensItemInstallation;
-    data?: ImportConnectorTokensRequestTokensItemDataMap;
-}
-export declare const ImportConnectorTokensRequestTokensItem: S.Schema<ImportConnectorTokensRequestTokensItem>;
-export type ImportConnectorTokensRequestTokensList = Array<ImportConnectorTokensRequestTokensItem>;
-export declare const ImportConnectorTokensRequestTokensList: S.Schema<ImportConnectorTokensRequestTokensList>;
-export interface ImportConnectorTokensRequest {
-    connector: string;
-    tokens: ImportConnectorTokensRequestTokensList;
+export declare const ConnectConnectorUpdateDataCase2ExtrasMap: S.Schema<ConnectConnectorUpdateDataCase2ExtrasMap>;
+export interface ConnectConnectorUpdateDataCase2 {
+    /** GitHub App numeric ID. */
+    appId?: number;
+    /** GitHub App slug. */
+    appSlug?: string;
+    /** GitHub App display name. */
+    appName?: string;
+    /** GitHub App OAuth client ID. */
+    clientId?: string;
+    /** GitHub App owner. */
+    owner?: ConnectConnectorUpdateDataCase2Owner;
+    /** GitHub App OAuth client secret. */
+    clientSecret?: string | Redacted.Redacted<string>;
+    /** GitHub App private key in PEM format. */
+    privateKeyPem?: string;
+    /** GitHub App webhook secret. */
+    webhookSecret?: string;
+    /** Additional provider metadata stored with the connector. */
+    extras?: ConnectConnectorUpdateDataCase2ExtrasMap;
+}
+export declare const ConnectConnectorUpdateDataCase2: S.Schema<ConnectConnectorUpdateDataCase2>;
+/** OAuth scopes requested for Linear application tokens. */
+export type ConnectConnectorUpdateDataCase3AppScopesList = Array<string>;
+export declare const ConnectConnectorUpdateDataCase3AppScopesList: S.Schema<ConnectConnectorUpdateDataCase3AppScopesList>;
+/** OAuth scopes requested for Linear user tokens. */
+export type ConnectConnectorUpdateDataCase3UserScopesList = Array<string>;
+export declare const ConnectConnectorUpdateDataCase3UserScopesList: S.Schema<ConnectConnectorUpdateDataCase3UserScopesList>;
+/** Linear organization that owns the OAuth application. */
+export type ConnectConnectorUpdateDataCase3OwnerOrganization = ConnectConnectorCreateDataCase3OwnerOrganization;
+export declare const ConnectConnectorUpdateDataCase3OwnerOrganization: S.Schema<ConnectConnectorCreateDataCase3OwnerOrganization>;
+/** Registered redirect URIs for the Linear OAuth application. */
+export type ConnectConnectorUpdateDataCase3ApplicationRedirectUrisList = Array<string>;
+export declare const ConnectConnectorUpdateDataCase3ApplicationRedirectUrisList: S.Schema<ConnectConnectorUpdateDataCase3ApplicationRedirectUrisList>;
+/** Linear resource types delivered to the webhook. */
+export type ConnectConnectorUpdateDataCase3ApplicationWebhookResourceTypesList = Array<string>;
+export declare const ConnectConnectorUpdateDataCase3ApplicationWebhookResourceTypesList: S.Schema<ConnectConnectorUpdateDataCase3ApplicationWebhookResourceTypesList>;
+/** Linear OAuth application metadata. */
+export interface ConnectConnectorUpdateDataCase3Application {
+    /** Linear OAuth application ID. */
+    id: string;
+    /** Linear OAuth client ID. */
+    clientId: string;
+    /** Linear OAuth application name. */
+    name: string;
+    /** Linear OAuth application description. */
+    description?: string | null;
+    /** Linear OAuth application developer name. */
+    developer?: string | null;
+    /** Linear OAuth application developer URL. */
+    developerUrl?: string | null;
+    /** Linear OAuth application image URL. */
+    imageUrl?: string | null;
+    /** Registered redirect URIs for the Linear OAuth application. */
+    redirectUris?: ConnectConnectorUpdateDataCase3ApplicationRedirectUrisList;
+    /** Linear OAuth application distribution mode. */
+    distribution?: string | null;
+    /** Linear resource types delivered to the webhook. */
+    webhookResourceTypes?: ConnectConnectorUpdateDataCase3ApplicationWebhookResourceTypesList;
+    /** Linear webhook URL. */
+    webhookUrl?: string | null;
+    /** Whether the Linear webhook is enabled. */
+    webhookEnabled?: boolean;
+    /** Linear OAuth application creation timestamp. */
+    createdAt?: string;
+    /** Linear OAuth application update timestamp. */
+    updatedAt?: string;
 }
-export declare const ImportConnectorTokensRequest: S.Schema<ImportConnectorTokensRequest>;
-export type ImportConnectorTokensResponseTokensItemDataMap = {
+export declare const ConnectConnectorUpdateDataCase3Application: S.Schema<ConnectConnectorUpdateDataCase3Application>;
+/** Additional provider metadata stored with the connector. */
+export type ConnectConnectorUpdateDataCase3ExtrasMap = {
     [key: string]: unknown | undefined;
 };
-export declare const ImportConnectorTokensResponseTokensItemDataMap: S.Schema<ImportConnectorTokensResponseTokensItemDataMap>;
-export type ImportConnectorTokensResponseTokensItemAudienceList = Array<string>;
-export declare const ImportConnectorTokensResponseTokensItemAudienceList: S.Schema<ImportConnectorTokensResponseTokensItemAudienceList>;
-export type ImportConnectorTokensResponseTokensItemScopesList = Array<string>;
-export declare const ImportConnectorTokensResponseTokensItemScopesList: S.Schema<ImportConnectorTokensResponseTokensItemScopesList>;
-export type ImportConnectorTokensResponseTokensItemResourcesList = Array<string>;
-export declare const ImportConnectorTokensResponseTokensItemResourcesList: S.Schema<ImportConnectorTokensResponseTokensItemResourcesList>;
-export type ImportConnectorTokensResponseTokensItemAuthorizationDetailsItem = CreateConnectorAuthorizationRequestRequestSubjectCase4;
-export declare const ImportConnectorTokensResponseTokensItemAuthorizationDetailsItem: S.Schema<CreateConnectorAuthorizationRequestRequestSubjectCase4>;
-export type ImportConnectorTokensResponseTokensItemAuthorizationDetailsList = Array<CreateConnectorAuthorizationRequestRequestSubjectCase4>;
-export declare const ImportConnectorTokensResponseTokensItemAuthorizationDetailsList: S.Schema<ImportConnectorTokensResponseTokensItemAuthorizationDetailsList>;
-/** Claims extracted from the provider's tokens per the connector's `ForwardedClaims` allow-list. Currently sourced from the OIDC id_token only. */
-export type ImportConnectorTokensResponseTokensItemClaimsMap = {
+export declare const ConnectConnectorUpdateDataCase3ExtrasMap: S.Schema<ConnectConnectorUpdateDataCase3ExtrasMap>;
+export interface ConnectConnectorUpdateDataCase3 {
+    /** Linear application ID. */
+    appId?: string;
+    /** Linear application name. */
+    appName?: string;
+    /** Linear OAuth client ID. */
+    clientId?: string;
+    /** Linear OAuth client secret. */
+    clientSecret?: string | Redacted.Redacted<string>;
+    /** Linear webhook verification secret. */
+    webhookSecret?: string;
+    /** OAuth scopes requested for Linear application tokens. */
+    appScopes?: ConnectConnectorUpdateDataCase3AppScopesList;
+    /** OAuth scopes requested for Linear user tokens. */
+    userScopes?: ConnectConnectorUpdateDataCase3UserScopesList;
+    /** Linear organization that owns the OAuth application. */
+    ownerOrganization?: ConnectConnectorCreateDataCase3OwnerOrganization;
+    /** Linear OAuth application metadata. */
+    application?: ConnectConnectorUpdateDataCase3Application;
+    /** Additional provider metadata stored with the connector. */
+    extras?: ConnectConnectorUpdateDataCase3ExtrasMap;
+}
+export declare const ConnectConnectorUpdateDataCase3: S.Schema<ConnectConnectorUpdateDataCase3>;
+export interface ConnectConnectorUpdateDataCase4 {
+    /** Salesforce connected app consumer key. */
+    consumerKey?: string;
+    /** Salesforce connected app consumer secret. */
+    consumerSecret?: string;
+    /** Salesforce login host, such as login.salesforce.com. */
+    loginHost?: string;
+}
+export declare const ConnectConnectorUpdateDataCase4: S.Schema<ConnectConnectorUpdateDataCase4>;
+/** Slack workspace metadata. */
+export type ConnectConnectorUpdateDataCase5SlackTeam = ConnectConnectorCreateDataCase7SlackTeam;
+export declare const ConnectConnectorUpdateDataCase5SlackTeam: S.Schema<ConnectConnectorCreateDataCase7SlackTeam>;
+/** OAuth scopes requested for Slack bot tokens. */
+export type ConnectConnectorUpdateDataCase5BotScopesList = Array<string>;
+export declare const ConnectConnectorUpdateDataCase5BotScopesList: S.Schema<ConnectConnectorUpdateDataCase5BotScopesList>;
+/** OAuth scopes requested for Slack user tokens. */
+export type ConnectConnectorUpdateDataCase5UserScopesList = Array<string>;
+export declare const ConnectConnectorUpdateDataCase5UserScopesList: S.Schema<ConnectConnectorUpdateDataCase5UserScopesList>;
+export type ConnectConnectorUpdateDataCase5SlashCommandsItem = ConnectConnectorCreateDataCase7SlashCommandsItem;
+export declare const ConnectConnectorUpdateDataCase5SlashCommandsItem: S.Schema<ConnectConnectorCreateDataCase7SlashCommandsItem>;
+/** Slash commands configured for the managed Slack app. */
+export type ConnectConnectorUpdateDataCase5SlashCommandsList = Array<ConnectConnectorCreateDataCase7SlashCommandsItem>;
+export declare const ConnectConnectorUpdateDataCase5SlashCommandsList: S.Schema<ConnectConnectorUpdateDataCase5SlashCommandsList>;
+/** Where Slack exposes the shortcut. */
+export type ConnectConnectorUpdateDataCase5ShortcutsItemType = "global" | "message";
+export declare const ConnectConnectorUpdateDataCase5ShortcutsItemType: any;
+export interface ConnectConnectorUpdateDataCase5ShortcutsItem {
+    /** Where Slack exposes the shortcut. */
+    type: ConnectConnectorUpdateDataCase5ShortcutsItemType | (string & {});
+    /** Shortcut display name. */
+    name: string;
+    /** Identifier included in the shortcut callback. */
+    callbackId: string;
+    /** Description shown for the shortcut in Slack. */
+    description: string;
+}
+export declare const ConnectConnectorUpdateDataCase5ShortcutsItem: S.Schema<ConnectConnectorUpdateDataCase5ShortcutsItem>;
+/** Global and message shortcuts configured for the Slack app. */
+export type ConnectConnectorUpdateDataCase5ShortcutsList = Array<ConnectConnectorUpdateDataCase5ShortcutsItem>;
+export declare const ConnectConnectorUpdateDataCase5ShortcutsList: S.Schema<ConnectConnectorUpdateDataCase5ShortcutsList>;
+/** Additional provider metadata stored with the connector. */
+export type ConnectConnectorUpdateDataCase5ExtrasMap = {
     [key: string]: unknown | undefined;
 };
-export declare const ImportConnectorTokensResponseTokensItemClaimsMap: S.Schema<ImportConnectorTokensResponseTokensItemClaimsMap>;
-export type ImportConnectorTokensResponseTokensItemInstallation = ImportConnectorTokensRequestTokensItemInstallation;
-export declare const ImportConnectorTokensResponseTokensItemInstallation: S.Schema<ImportConnectorTokensRequestTokensItemInstallation>;
-export type ImportConnectorTokensResponseTokensItemTenant = ImportConnectorTokensRequestTokensItemInstallation;
-export declare const ImportConnectorTokensResponseTokensItemTenant: S.Schema<ImportConnectorTokensRequestTokensItemInstallation>;
-export type ImportConnectorTokensResponseTokensItemSubjectCase0Type = "app";
-export declare const ImportConnectorTokensResponseTokensItemSubjectCase0Type: any;
-export interface ImportConnectorTokensResponseTokensItemSubjectCase0 {
-    type: ImportConnectorTokensResponseTokensItemSubjectCase0Type;
-}
-export declare const ImportConnectorTokensResponseTokensItemSubjectCase0: S.Schema<ImportConnectorTokensResponseTokensItemSubjectCase0>;
-export type ImportConnectorTokensResponseTokensItemSubjectCase1Type = "user";
-export declare const ImportConnectorTokensResponseTokensItemSubjectCase1Type: any;
-export interface ImportConnectorTokensResponseTokensItemSubjectCase1 {
-    type: ImportConnectorTokensResponseTokensItemSubjectCase1Type;
-    id: string;
-    issuer?: string;
+export declare const ConnectConnectorUpdateDataCase5ExtrasMap: S.Schema<ConnectConnectorUpdateDataCase5ExtrasMap>;
+export interface ConnectConnectorUpdateDataCase5 {
+    /** Slack app ID. */
+    appId?: string;
+    /** Slack app display name. */
+    appName?: string;
+    /** Slack app OAuth client ID. */
+    clientId?: string;
+    /** Slack app OAuth client secret. */
+    clientSecret?: string | Redacted.Redacted<string>;
+    /** Slack workspace metadata. */
+    slackTeam?: ConnectConnectorCreateDataCase7SlackTeam;
+    /** Slack request signing secret. */
+    signingSecret?: string;
+    /** Legacy Slack webhook verification token. */
+    verificationToken?: string;
+    /** OAuth scopes requested for Slack bot tokens. */
+    botScopes?: ConnectConnectorUpdateDataCase5BotScopesList;
+    /** OAuth scopes requested for Slack user tokens. */
+    userScopes?: ConnectConnectorUpdateDataCase5UserScopesList;
+    /** Slash commands configured for the managed Slack app. */
+    slashCommands?: ConnectConnectorUpdateDataCase5SlashCommandsList;
+    /** Global and message shortcuts configured for the Slack app. */
+    shortcuts?: ConnectConnectorUpdateDataCase5ShortcutsList;
+    /** Additional provider metadata stored with the connector. */
+    extras?: ConnectConnectorUpdateDataCase5ExtrasMap;
+}
+export declare const ConnectConnectorUpdateDataCase5: S.Schema<ConnectConnectorUpdateDataCase5>;
+export interface ConnectConnectorUpdateDataCase6 {
+    /** Snowflake account identifier. */
+    accountIdentifier?: string;
+    /** Default Snowflake role for created sessions. */
+    defaultSessionRole?: string;
+}
+export declare const ConnectConnectorUpdateDataCase6: S.Schema<ConnectConnectorUpdateDataCase6>;
+export interface ConnectConnectorUpdateDataCase7 {
+    /** Snowflake account identifier. */
+    accountIdentifier?: string;
+}
+export declare const ConnectConnectorUpdateDataCase7: S.Schema<ConnectConnectorUpdateDataCase7>;
+export type ConnectConnectorUpdateDataCase8PhoneNumbersList = Array<string>;
+export declare const ConnectConnectorUpdateDataCase8PhoneNumbersList: S.Schema<ConnectConnectorUpdateDataCase8PhoneNumbersList>;
+export interface ConnectConnectorUpdateDataCase8 {
+    /** Linq partner API token for the shared line. */
+    apiToken?: string | Redacted.Redacted<string>;
+    phoneNumbers?: ConnectConnectorUpdateDataCase8PhoneNumbersList;
+}
+export declare const ConnectConnectorUpdateDataCase8: S.Schema<ConnectConnectorUpdateDataCase8>;
+/** E.164 Sendblue lines this connector sends and receives on. Used as the connector's display name, and the only lines its webhooks are registered for; an empty array clears them, which also removes the webhook subscription. */
+export type ConnectConnectorUpdateDataCase9PhoneNumbersList = Array<string>;
+export declare const ConnectConnectorUpdateDataCase9PhoneNumbersList: S.Schema<ConnectConnectorUpdateDataCase9PhoneNumbersList>;
+export interface ConnectConnectorUpdateDataCase9 {
+    /** Sendblue API key id (`sb-api-key-id`). */
+    apiKeyId?: string;
+    /** Sendblue API secret key (`sb-api-secret-key`). */
+    apiSecretKey?: string | Redacted.Redacted<string>;
+    /** E.164 Sendblue lines this connector sends and receives on. Used as the connector's display name, and the only lines its webhooks are registered for; an empty array clears them, which also removes the webhook subscription. */
+    phoneNumbers?: ConnectConnectorUpdateDataCase9PhoneNumbersList;
+}
+export declare const ConnectConnectorUpdateDataCase9: S.Schema<ConnectConnectorUpdateDataCase9>;
+export interface ConnectConnectorUpdateDataCase10 {
+    /** Photon project secret. */
+    projectSecret?: string;
+    /** Photon webhook verification secret. */
+    webhookSecret?: string;
+    /** Whether Connect should recreate the Photon webhook. */
+    repairWebhook?: boolean;
 }
-export declare const ImportConnectorTokensResponseTokensItemSubjectCase1: S.Schema<ImportConnectorTokensResponseTokensItemSubjectCase1>;
-export type ImportConnectorTokensResponseTokensItemSubject = ImportConnectorTokensResponseTokensItemSubjectCase0 | ImportConnectorTokensResponseTokensItemSubjectCase1;
-export declare const ImportConnectorTokensResponseTokensItemSubject: S.Schema<ImportConnectorTokensResponseTokensItemSubject>;
-export type ImportConnectorTokensResponseTokensItemEnvironmentCase1 = "development" | "preview" | "production";
-export declare const ImportConnectorTokensResponseTokensItemEnvironmentCase1: any;
-export type ImportConnectorTokensResponseTokensItemEnvironment = string | ImportConnectorTokensResponseTokensItemEnvironmentCase1;
-export declare const ImportConnectorTokensResponseTokensItemEnvironment: S.Schema<ImportConnectorTokensResponseTokensItemEnvironment>;
-export interface ImportConnectorTokensResponseTokensItem {
+export declare const ConnectConnectorUpdateDataCase10: S.Schema<ConnectConnectorUpdateDataCase10>;
+export type ConnectConnectorUpdateDataCase11Map = {
+    [key: string]: unknown | undefined;
+};
+export declare const ConnectConnectorUpdateDataCase11Map: S.Schema<ConnectConnectorUpdateDataCase11Map>;
+/** Provider configuration fields for the connector type. */
+export type ConnectConnectorUpdateData = ConnectConnectorUpdateDataCase0 | ConnectConnectorUpdateDataCase1 | ConnectConnectorUpdateDataCase2 | ConnectConnectorUpdateDataCase3 | ConnectConnectorUpdateDataCase4 | ConnectConnectorUpdateDataCase5 | ConnectConnectorUpdateDataCase6 | ConnectConnectorUpdateDataCase7 | ConnectConnectorUpdateDataCase8 | ConnectConnectorUpdateDataCase9 | ConnectConnectorUpdateDataCase10 | ConnectConnectorUpdateDataCase11Map;
+export declare const ConnectConnectorUpdateData: S.Schema<ConnectConnectorUpdateData>;
+export interface UpdateConnectorRequest {
+    /** Stable connector ID or URL-encoded team-scoped UID. Examples: `scl_abc123` or `slack%2Fmy-bot`. */
+    connector: string;
+    /** The team ID that scopes the request. Do not send it with slug. If both are omitted, Vercel uses the team associated with the token or the authenticated user's default team. The request returns 401 if no team can be selected. */
+    teamId?: string;
+    /** The team slug that scopes the request. Do not send it with teamId. If both are omitted, Vercel uses the team associated with the token or the authenticated user's default team. The request returns 401 if no team can be selected. */
+    slug?: string;
+    /** Whether the triggers are enabled for this connector. */
+    triggers?: boolean;
+    /** Default trigger events for this connector. */
+    events?: UpdateConnectorRequestEventsList;
+    /** Provider configuration fields to update. */
+    data?: ConnectConnectorUpdateData;
+    /** SHA-1 digest of a PNG or JPEG icon that is at least 640 by 640 pixels. This field does not accept a URL or image bytes. First compute the digest and upload the raw image with [POST /v2/files](https://vercel.com/docs/rest-api/deployments/upload-deployment-files). Send `Content-Length` and the same 40-character digest in `x-vercel-digest`. Then set `icon` to that digest. ```js import { createHash } from 'node:crypto'; import { readFile } from 'node:fs/promises'; const VERCEL_TOKEN = process.env.VERCEL_TOKEN; const connectorId = 'scl_...'; const bytes = await readFile('icon.png'); const digest = createHash('sha1').update(bytes).digest('hex'); await fetch('https://api.vercel.com/v2/files', { method: 'POST', headers: { Authorization: `Bearer ${VERCEL_TOKEN}`, 'Content-Type': 'application/octet-stream', 'Content-Length': String(bytes.length), 'x-vercel-digest': digest, }, body: bytes, }); await fetch(`https://api.vercel.com/v2/connect/connectors/${connectorId}`, { method: 'PATCH', headers: { Authorization: `Bearer ${VERCEL_TOKEN}`, 'Content-Type': 'application/json', }, body: JSON.stringify({ icon: digest }), }); ``` */
+    icon?: string;
+    backgroundColor?: string;
+    accentColor?: string;
+    /** Full team-scoped UID, such as `slack/my-bot`. It cannot contain whitespace, `%`, `#`, control characters, or Vercel-owned namespaces. Changing it breaks callers that use the old UID. The stable connector ID does not change. */
+    uid?: string;
+    /** Display name for the connector. It is trimmed and cannot be empty or contain control characters. */
     name?: string;
-    data?: ImportConnectorTokensResponseTokensItemDataMap;
-    installationId?: string;
-    audience?: ImportConnectorTokensResponseTokensItemAudienceList;
-    scopes?: ImportConnectorTokensResponseTokensItemScopesList;
-    resources?: ImportConnectorTokensResponseTokensItemResourcesList;
-    authorizationDetails?: ImportConnectorTokensResponseTokensItemAuthorizationDetailsList;
-    expiresAt: number;
-    expiresIn?: number;
-    refreshTokenExpiresAt?: number;
-    externalSubject?: string;
-    /** Claims extracted from the provider's tokens per the connector's `ForwardedClaims` allow-list. Currently sourced from the OIDC id_token only. */
-    claims?: ImportConnectorTokensResponseTokensItemClaimsMap;
-    installation?: ImportConnectorTokensRequestTokensItemInstallation;
-    tenant?: ImportConnectorTokensRequestTokensItemInstallation;
-    subject: ImportConnectorTokensResponseTokensItemSubject;
-    environment: ImportConnectorTokensResponseTokensItemEnvironment;
-    succeeded: boolean;
-}
-export declare const ImportConnectorTokensResponseTokensItem: S.Schema<ImportConnectorTokensResponseTokensItem>;
-export type ImportConnectorTokensResponseTokensList = Array<ImportConnectorTokensResponseTokensItem>;
-export declare const ImportConnectorTokensResponseTokensList: S.Schema<ImportConnectorTokensResponseTokensList>;
-export interface ImportConnectorTokensResponse {
-    accepted: number;
-    imported: number;
-    tokens: ImportConnectorTokensResponseTokensList;
-}
-export declare const ImportConnectorTokensResponse: S.Schema<ImportConnectorTokensResponse>;
+}
+export declare const UpdateConnectorRequest: S.Schema<UpdateConnectorRequest>;
+/** The affected authorization scope. user means each affected user must authorize again. */
+export type ConnectReconsentScope = "user";
+export declare const ConnectReconsentScope: any;
+/** Existing authorizations no longer cover the connector's configured scopes, so they must be re-authorized. */
+export interface ConnectReconsent {
+    /** The affected authorization scope. user means each affected user must authorize again. */
+    scope: ConnectReconsentScope;
+}
+export declare const ConnectReconsent: S.Schema<ConnectReconsent>;
+/** done means the external service was updated. required means the Vercel update was saved, but provider-side configuration still needs attention. */
+export type ConnectServiceSyncStatus = "done" | "required";
+export declare const ConnectServiceSyncStatus: any;
+/** Connector fields that caused the synchronization error. */
+export type ConnectServiceSyncErrorFieldsList = Array<string>;
+export declare const ConnectServiceSyncErrorFieldsList: S.Schema<ConnectServiceSyncErrorFieldsList>;
+/** Provider-specific error details that are safe to expose. */
+export type ConnectServiceSyncErrorVendorMap = {
+    [key: string]: unknown | undefined;
+};
+export declare const ConnectServiceSyncErrorVendorMap: S.Schema<ConnectServiceSyncErrorVendorMap>;
+/** Provider synchronization errors, when synchronization is required. */
+export interface ConnectServiceSyncError {
+    /** Human-readable provider synchronization error. */
+    message: string;
+    /** Connector fields that caused the synchronization error. */
+    fields?: ConnectServiceSyncErrorFieldsList;
+    /** Provider-specific error details that are safe to expose. */
+    vendor?: ConnectServiceSyncErrorVendorMap;
+}
+export declare const ConnectServiceSyncError: S.Schema<ConnectServiceSyncError>;
+/** Provider synchronization errors. Present when serviceSync.status is required. */
+export type ConnectServiceSyncErrorsList = Array<ConnectServiceSyncError>;
+export declare const ConnectServiceSyncErrorsList: S.Schema<ConnectServiceSyncErrorsList>;
+/** Provider-side configuration synchronization result. */
+export interface ConnectServiceSync {
+    /** done means the external service was updated. required means the Vercel update was saved, but provider-side configuration still needs attention. */
+    status: ConnectServiceSyncStatus;
+    /** Provider synchronization errors. Present when serviceSync.status is required. */
+    errors?: ConnectServiceSyncErrorsList;
+}
+export declare const ConnectServiceSync: S.Schema<ConnectServiceSync>;
+/** Updated connector and any required provider follow-up actions. */
+export interface ConnectConnectorUpdateResult {
+    /** Updated connector. */
+    connector: ConnectConnector;
+    /** When true, prompt a team owner or administrator to reinstall the connector before relying on the change. */
+    reinstallNeeded?: boolean;
+    /** Present when affected users must authorize the connector's new permissions. */
+    reconsentNeeded?: ConnectReconsent;
+    /** Result of synchronizing the change with the external service. */
+    serviceSync?: ConnectServiceSync;
+}
+export declare const ConnectConnectorUpdateResult: S.Schema<ConnectConnectorUpdateResult>;
+export type UpsertConnectorProjectConnectionRequestEnvironmentsItemCase0 = "development" | "preview" | "production";
+export declare const UpsertConnectorProjectConnectionRequestEnvironmentsItemCase0: any;
+/** A built-in environment name or the stable env_* ID of a custom environment. */
+export type UpsertConnectorProjectConnectionRequestEnvironmentsItem = UpsertConnectorProjectConnectionRequestEnvironmentsItemCase0 | string;
+export declare const UpsertConnectorProjectConnectionRequestEnvironmentsItem: S.Schema<UpsertConnectorProjectConnectionRequestEnvironmentsItem>;
+/** One or more built-in environment names or stable custom environment IDs that belong to the project. Duplicate values are accepted and removed. */
+export type UpsertConnectorProjectConnectionRequestEnvironmentsList = Array<UpsertConnectorProjectConnectionRequestEnvironmentsItem>;
+export declare const UpsertConnectorProjectConnectionRequestEnvironmentsList: S.Schema<UpsertConnectorProjectConnectionRequestEnvironmentsList>;
+export interface UpsertConnectorProjectConnectionRequest {
+    /** Stable connector ID or URL-encoded team-scoped UID. Examples: `scl_abc123` or `slack%2Fmy-bot`. */
+    connector: string;
+    /** Vercel project ID. */
+    projectId: string;
+    /** The team ID that scopes the request. Do not send it with slug. If both are omitted, Vercel uses the team associated with the token or the authenticated user's default team. The request returns 401 if no team can be selected. */
+    teamId?: string;
+    /** The team slug that scopes the request. Do not send it with teamId. If both are omitted, Vercel uses the team associated with the token or the authenticated user's default team. The request returns 401 if no team can be selected. */
+    slug?: string;
+    /** One or more built-in environment names or stable custom environment IDs that belong to the project. Duplicate values are accepted and removed. */
+    environments: UpsertConnectorProjectConnectionRequestEnvironmentsList;
+}
+export declare const UpsertConnectorProjectConnectionRequest: S.Schema<UpsertConnectorProjectConnectionRequest>;
 export type CreateConnectorError = BadRequest | Forbidden | NotFound | Conflict | UnprocessableEntity | VercelOpError;
-/** Create a connector Create a connector from type-specific configuration and optionally link it to a project during creation. */
-export declare const createConnector: API.OperationMethod<CreateConnectorRequest, CreateConnectorResponse, CreateConnectorError, VercelOpContext>;
+/** Create a connector Create a connector and optionally link it to a project. Use `type` with complete provider data, or use `service` with `connectionMethod` so Connect can supply the type, endpoints, templates, and defaults. */
+export declare const createConnector: API.OperationMethod<CreateConnectorRequest, ConnectConnectorCreateResult, CreateConnectorError, VercelOpContext>;
 export type CreateConnectorAuthorizationRequestError = BadRequest | Forbidden | NotFound | VercelOpError;
 /** Create a Connect authorization request Create an authorization request for a connector and return the URL and verifier details needed to complete the flow. */
 export declare const createConnectorAuthorizationRequest: API.OperationMethod<CreateConnectorAuthorizationRequestRequest, CreateConnectorAuthorizationRequestResponse, CreateConnectorAuthorizationRequestError, VercelOpContext>;
-export type CreateConnectorInstallationRequestError = BadRequest | Forbidden | NotFound | UnprocessableEntity | VercelOpError;
-/** Create a Connect installation request Create an installation request for a connector and return the URL and verifier details needed to complete the flow. */
-export declare const createConnectorInstallationRequest: API.OperationMethod<CreateConnectorInstallationRequestRequest, CreateConnectorInstallationRequestResponse, CreateConnectorInstallationRequestError, VercelOpContext>;
+export type DeleteConnectorError = BadRequest | Forbidden | NotFound | Conflict | UnprocessableEntity | VercelOpError;
+/** Delete a connector Delete a connector, its project connections, and its installation records. */
+export declare const deleteConnector: API.OperationMethod<DeleteConnectorRequest, DeleteConnectorResponse, DeleteConnectorError, VercelOpContext>;
+export type DeleteConnectorProjectConnectionError = BadRequest | Forbidden | NotFound | VercelOpError;
+/** Disconnect a connector from a project Disconnect a connector from a project. */
+export declare const deleteConnectorProjectConnection: API.OperationMethod<DeleteConnectorProjectConnectionRequest, DeleteConnectorProjectConnectionResponse, DeleteConnectorProjectConnectionError, VercelOpContext>;
+export type GetConnectorError = BadRequest | Forbidden | NotFound | UnprocessableEntity | VercelOpError;
+/** Get a connector Get the connector by ID. Accepts a dashboard/team requester or a deployment's project OIDC token; project requesters may only read connectors linked to their project and environment. */
+export declare const getConnector: API.OperationMethod<GetConnectorRequest, ConnectConnector, GetConnectorError, VercelOpContext>;
+export type GetConnectorProjectConnectionError = BadRequest | Forbidden | NotFound | VercelOpError;
+/** Get a connector project connection Get the configuration that connects a connector to a project. */
+export declare const getConnectorProjectConnection: API.OperationMethod<GetConnectorProjectConnectionRequest, ConnectProjectConnection, GetConnectorProjectConnectionError, VercelOpContext>;
 export type GetConnectorTokenError = BadRequest | Forbidden | NotFound | UnprocessableEntity | VercelOpError;
 /** Get a Connect token Get an access token for a connector identified by the path parameter and scoped to the requester. */
 export declare const getConnectorToken: API.OperationMethod<GetConnectorTokenRequest, GetConnectorTokenResponse, GetConnectorTokenError, VercelOpContext>;
-export type ImportConnectorTokensError = BadRequest | Forbidden | NotFound | UnprocessableEntity | VercelOpError;
-/** Import Connect tokens Import access and refresh tokens for a connector identified by the path parameter. */
-export declare const importConnectorTokens: API.OperationMethod<ImportConnectorTokensRequest, ImportConnectorTokensResponse, ImportConnectorTokensError, VercelOpContext>;
+export type ListConnectorProjectConnectionsError = BadRequest | Forbidden | NotFound | UnprocessableEntity | VercelOpError;
+/** List projects for a connector List the projects connected to a connector and the environments where each connection is available. */
+export declare const listConnectorProjectConnections: API.OperationMethod<ListConnectorProjectConnectionsRequest, ConnectConnectorProjectConnectionList, ListConnectorProjectConnectionsError, VercelOpContext>;
+export type ListConnectorsError = BadRequest | Forbidden | UnprocessableEntity | VercelOpError;
+/** List connectors List connectors that belong to a team. */
+export declare const listConnectors: API.OperationMethod<ListConnectorsRequest, ConnectConnectorList, ListConnectorsError, VercelOpContext>;
+export type ListProjectConnectorConnectionsError = BadRequest | Forbidden | NotFound | VercelOpError;
+/** List connectors for a project List the connectors connected to a project and the environments where each connection is available. */
+export declare const listProjectConnectorConnections: API.OperationMethod<ListProjectConnectorConnectionsRequest, ConnectProjectConnectorConnectionList, ListProjectConnectorConnectionsError, VercelOpContext>;
+export type ReplaceConnectorTriggerDestinationsError = BadRequest | Forbidden | NotFound | UnprocessableEntity | VercelOpError;
+/** Update connector trigger destinations Replace the full set of destinations that receive trigger requests for a connector. */
+export declare const replaceConnectorTriggerDestinations: API.OperationMethod<ReplaceConnectorTriggerDestinationsRequest, ConnectConnector, ReplaceConnectorTriggerDestinationsError, VercelOpContext>;
+export type UpdateConnectorError = BadRequest | Forbidden | NotFound | Conflict | UnprocessableEntity | VercelOpError;
+/** Update a connector Update a connector and return the connector with any service-side update signals that the caller must handle. */
+export declare const updateConnector: API.OperationMethod<UpdateConnectorRequest, ConnectConnectorUpdateResult, UpdateConnectorError, VercelOpContext>;
+export type UpsertConnectorProjectConnectionError = BadRequest | Forbidden | NotFound | VercelOpError;
+/** Create or update a connector project connection Connect a connector to a project, or replace the environments on an existing project connection. */
+export declare const upsertConnectorProjectConnection: API.OperationMethod<UpsertConnectorProjectConnectionRequest, ConnectProjectConnection, UpsertConnectorProjectConnectionError, VercelOpContext>;
 //# sourceMappingURL=connect.d.ts.map