notte-sdk 0.0.22 → 1.9.1

package/dist/index.d.mts

@@ -1,5 +1,6 @@
+import { Page, Browser, Dialog } from 'playwright-core';
 import { z } from 'zod';
-export { N as NotteProxyAuthError, a as NotteProxyConfig } from './types-DmqqdEMP.mjs';
+export { N as NotteProxyAuthError, a as NotteProxyConfig } from './types-C5V9BOux.mjs';
 
 type AuthToken = string | undefined;
 interface Auth {
@@ -327,8 +328,24 @@ interface TDataShape {
 type OmitKeys<T, K> = Pick<T, Exclude<keyof T, K>>;
 type Options$1<TData extends TDataShape = TDataShape, ThrowOnError extends boolean = boolean, TResponse = unknown, TResponseStyle extends ResponseStyle = 'fields'> = OmitKeys<RequestOptions<TResponse, TResponseStyle, ThrowOnError>, 'body' | 'path' | 'query' | 'url'> & ([TData] extends [never] ? unknown : Omit<TData, 'url'>);
 
+type Env = Record<string, string | undefined>;
+type VersionCheckOptions = {
+    currentVersion?: string;
+    packageName?: string;
+    fetchFn?: typeof fetch;
+    warnFn?: (message: string) => void;
+    env?: Env;
+};
+/**
+ * Check the npm registry once per process and warn when a newer release exists.
+ * Called by `NotteClient` on construction, like `check_and_warn_version_mismatch`
+ * in the Python client. Never throws and never blocks the caller.
+ */
+declare function startVersionCheck(): void;
+declare function checkForLatestVersion(options?: VersionCheckOptions): Promise<void>;
+
 type ClientOptions = {
-    baseUrl: 'https://us-staging.notte.cc' | (string & {});
+    baseUrl: 'https://api.notte.cc' | (string & {});
 };
 /**
  * ActionParameter
@@ -729,6 +746,15 @@ type ApiExecutionResponse = {
      */
     exception?: string | null;
     exception_detail?: SerializedError | null;
+    captcha?: CaptchaStatus | null;
+    /**
+     * Action Executed
+     */
+    action_executed?: boolean | null;
+    /**
+     * Code
+     */
+    code?: string | null;
 };
 /**
  * ApiSessionStartRequest
@@ -833,15 +859,19 @@ type ApiSessionStartRequest = {
     /**
      * Auth Ids
      *
-     * Managed Auth connection IDs to verify and, when necessary, authenticate inside this session. Authentication finishes before the session is returned unless wait_for_authentication is false.
+     * Managed Auth connection IDs to verify and, when necessary, authenticate inside this session. Initial verification runs before returning; when login is needed, the session returns as authenticating. Poll /sessions/{id}/auth for readiness.
      */
     auth_ids?: Array<string>;
     /**
      * Wait For Authentication
      *
-     * Whether to wait for Managed Auth profile restoration and authentication before returning the session. When false, authentication continues in the background after the browser is ready.
+     * SDK waiting preference. The API always verifies inline and returns authenticating when background login is needed; SDKs implement waiting through readiness polling.
      */
     wait_for_authentication?: boolean;
+    /**
+     * Auth Retry
+     */
+    auth_retry?: number;
     /**
      * Advanced Stealth
      *
@@ -991,6 +1021,39 @@ type CaptchaSolveAction = {
      */
     captcha_type?: 'recaptcha' | 'hcaptcha' | 'image' | 'text' | 'auth0' | 'cloudflare' | 'datadome' | 'arkose labs' | 'geetest' | 'press&hold' | 'unknown' | null;
 };
+/**
+ * CaptchaStatus
+ */
+type CaptchaStatus = {
+    /**
+     * Captcha Id
+     */
+    captcha_id: string;
+    /**
+     * Page Id
+     */
+    page_id: string;
+    /**
+     * Generation
+     */
+    generation: number;
+    /**
+     * State
+     */
+    state: 'solving' | 'solved' | 'failed' | 'cancelled';
+    /**
+     * Retry After Ms
+     */
+    retry_after_ms?: number;
+    /**
+     * Message
+     */
+    message?: string;
+    /**
+     * Cancel Reason
+     */
+    cancel_reason?: 'navigation' | null;
+};
 /**
  * CheckAction
  */
@@ -2060,7 +2123,7 @@ type FallbackFillActionOutput = {
 /**
  * FileSource
  */
-type FileSource$1 = 'user_upload' | 'session_download';
+type FileSource = 'user_upload' | 'session_download';
 /**
  * FillAction
  */
@@ -3005,6 +3068,10 @@ type GlobalScrapeRequest = {
      * Whether to wait for Managed Auth before returning the session. Defaults to true. When true, authentication failure or timeout fails session creation; when false, authentication continues in the background after the browser is ready.
      */
     wait_for_authentication?: boolean;
+    /**
+     * Auth Retry
+     */
+    auth_retry?: number;
     /**
      * Advanced Stealth
      *
@@ -3463,6 +3530,88 @@ type ManagedAuthCredentials = {
      */
     mfa_secret?: null;
 };
+/**
+ * ManagedAuthOperation
+ */
+type ManagedAuthOperation = {
+    /**
+     * Id
+     */
+    id: string;
+    /**
+     * Connection Id
+     */
+    connection_id: string;
+    /**
+     * Session Id
+     */
+    session_id?: string | null;
+    /**
+     * Source
+     */
+    source: string;
+    /**
+     * Status
+     */
+    status: 'pending' | 'running' | 'succeeded' | 'failed' | 'cancelled';
+    /**
+     * Phase
+     */
+    phase: string;
+    /**
+     * Attempt
+     */
+    attempt?: number;
+    /**
+     * Auth Retry
+     */
+    auth_retry?: number;
+    /**
+     * Authenticated
+     */
+    authenticated?: boolean | null;
+    /**
+     * Failure Code
+     */
+    failure_code?: string | null;
+    /**
+     * Error
+     */
+    error?: string | null;
+    /**
+     * Deadline
+     */
+    deadline: string;
+    /**
+     * Created At
+     */
+    created_at: string;
+    /**
+     * Updated At
+     */
+    updated_at: string;
+};
+/**
+ * ManagedAuthReadiness
+ */
+type ManagedAuthReadiness = {
+    /**
+     * Session Id
+     */
+    session_id: string;
+    /**
+     * Status
+     */
+    status: 'authenticating' | 'active' | 'failed' | 'closed';
+    /**
+     * Operations
+     */
+    operations?: Array<ManagedAuthOperation>;
+    /**
+     * Error
+     */
+    error?: string | null;
+};
 /**
  * MultiFactorFillAction
  */
@@ -3950,6 +4099,190 @@ type ParameterInfo = {
      */
     default?: string | null;
 };
+/**
+ * PaymentConnectRequest
+ */
+type PaymentConnectRequest = {
+    /**
+     * Mode
+     */
+    mode?: 'test' | 'live';
+};
+/**
+ * PaymentConnectionResponse
+ */
+type PaymentConnectionResponse = {
+    /**
+     * Id
+     */
+    id: string;
+    /**
+     * Mode
+     */
+    mode: string;
+    /**
+     * Status
+     */
+    status: string;
+    /**
+     * Connection Url
+     */
+    connection_url?: string | null;
+    /**
+     * Connection Phrase
+     */
+    connection_phrase?: string | null;
+    /**
+     * Expires At
+     */
+    expires_at?: string | null;
+    /**
+     * Error Code
+     */
+    error_code?: string | null;
+};
+/**
+ * PaymentDisconnectError
+ */
+type PaymentDisconnectError = {
+    /**
+     * Detail
+     */
+    detail: string;
+};
+/**
+ * PaymentDisconnectResponse
+ */
+type PaymentDisconnectResponse = {
+    /**
+     * Mode
+     */
+    mode: 'test' | 'live';
+    /**
+     * Status
+     */
+    status?: 'disconnected';
+};
+/**
+ * PaymentNextAction
+ */
+type PaymentNextAction = {
+    /**
+     * Type
+     */
+    type: 'ssn_verification' | 'identity_verification' | 'contact_support' | 'select_payment_method' | 'add_payment_method' | 'update_payment_method' | 're_authorize' | 'three_d_secure' | 'three_d_secure_retry';
+    /**
+     * Resolution
+     */
+    resolution: 'auto_resume' | 'create_new_spend_request' | 'create_new_spend_request_after_completion';
+    /**
+     * Action Url
+     */
+    action_url?: string | null;
+    /**
+     * Expires At
+     */
+    expires_at?: string | null;
+};
+/**
+ * PaymentRequest
+ */
+type PaymentRequest = {
+    /**
+     * Amount
+     *
+     * Amount in currency units, e.g. 100.91 means USD 100.91. Never rounded.
+     */
+    amount: number | string;
+    /**
+     * Currency
+     */
+    currency: string;
+    /**
+     * Merchant Url
+     */
+    merchant_url: string;
+    /**
+     * Merchant Name
+     */
+    merchant_name: string;
+    /**
+     * Description
+     */
+    description: string;
+    /**
+     * Mode
+     */
+    mode?: 'test' | 'live';
+};
+/**
+ * PaymentResponse
+ */
+type PaymentResponse = {
+    /**
+     * Id
+     */
+    id: string;
+    /**
+     * Session Id
+     */
+    session_id: string;
+    /**
+     * Status
+     */
+    status: string;
+    /**
+     * Mode
+     */
+    mode: string;
+    /**
+     * Amount
+     *
+     * Amount in currency units, serialized as an exact decimal string.
+     */
+    amount: string;
+    /**
+     * Currency
+     */
+    currency: string;
+    /**
+     * Merchant Name
+     */
+    merchant_name: string;
+    /**
+     * Merchant Url
+     */
+    merchant_url: string;
+    /**
+     * Vault Id
+     */
+    vault_id?: string | null;
+    /**
+     * Approval Url
+     */
+    approval_url?: string | null;
+    /**
+     * Connection Url
+     */
+    connection_url?: string | null;
+    /**
+     * Connection Phrase
+     */
+    connection_phrase?: string | null;
+    /**
+     * Expires At
+     */
+    expires_at?: string | null;
+    /**
+     * Error Code
+     */
+    error_code?: string | null;
+    next_action?: PaymentNextAction | null;
+    /**
+     * Purchase Status
+     */
+    purchase_status?: 'unverified';
+};
 /**
  * PersonaCreateRequest
  */
@@ -4027,6 +4360,10 @@ type PersonaResponse = {
      * Name
      */
     name?: string | null;
+    /**
+     * Created At
+     */
+    created_at: string;
 };
 /**
  * PersonaUpdateRequest
@@ -4166,52 +4503,6 @@ type ProfileResponse = {
      */
     persisted_domains?: Array<string>;
 };
-/**
- * ProxyCredentialRequest
- */
-type ProxyCredentialRequest = {
-    /**
-     * Country
-     *
-     * ISO 3166-1 alpha-2 country code, e.g. `us`.
-     */
-    country?: string | null;
-    /**
-     * City
-     *
-     * Evomi city id or display name, e.g. `new.york`. Wins over country.
-     */
-    city?: string | null;
-};
-/**
- * ProxyCredentialResponse
- */
-type ProxyCredentialResponse = {
-    /**
-     * Username
-     */
-    username: string;
-    /**
-     * Password
-     */
-    password: string;
-    /**
-     * Expires At
-     */
-    expires_at: string;
-    /**
-     * Proxy Url Tls
-     *
-     * `https://user:pass@host:443`, for clients that do TLS to the proxy.
-     */
-    proxy_url_tls: string;
-    /**
-     * Proxy Url Plain
-     *
-     * `http://user:pass@host:3128`, for clients that cannot.
-     */
-    proxy_url_plain: string;
-};
 /**
  * ProxyGeolocationCountry
  */
@@ -4234,11 +4525,44 @@ type ReloadAction = {
     description?: string;
 };
 /**
- * ReplayResponse
+ * ReplayMissingResponse
  */
-type ReplayResponse = {
+type ReplayMissingResponse = {
     /**
-     * Playlist Content
+     * Detail
+     */
+    detail: string;
+    /**
+     * Session Id
+     */
+    session_id: string | null;
+    /**
+     * Status
+     */
+    status: number;
+    /**
+     * Error
+     */
+    error: string;
+    /**
+     * Message
+     */
+    message: string;
+    /**
+     * Replay Status
+     */
+    replay_status: 'waiting_for_session' | 'processing' | 'unavailable' | 'failed' | 'unknown';
+    /**
+     * Retryable
+     */
+    retryable: boolean;
+};
+/**
+ * ReplayResponse
+ */
+type ReplayResponse = {
+    /**
+     * Playlist Content
      */
     playlist_content?: string | null;
     /**
@@ -4874,7 +5198,7 @@ type SessionDebugResponse = {
 /**
  * SessionFile
  */
-type SessionFile$1 = {
+type SessionFile = {
     /**
      * Id
      */
@@ -4907,16 +5231,16 @@ type SessionFile$1 = {
      * Expires At
      */
     expires_at: string;
-    source: FileSource$1;
+    source: FileSource;
 };
 /**
  * SessionFilesPage
  */
-type SessionFilesPage$1 = {
+type SessionFilesPage = {
     /**
      * Files
      */
-    files: Array<SessionFile$1>;
+    files: Array<SessionFile>;
     /**
      * Total
      */
@@ -4958,6 +5282,16 @@ type SessionProfile = {
      */
     persist?: boolean;
 };
+/**
+ * SessionProfilePreviewResponse
+ */
+type SessionProfilePreviewResponse = {
+    profile?: SessionProfile | null;
+    /**
+     * Cookie Domains
+     */
+    cookie_domains?: Array<string> | null;
+};
 /**
  * SessionResponse
  */
@@ -5006,10 +5340,8 @@ type SessionResponse = {
     duration?: string;
     /**
      * Status
-     *
-     * Session status
      */
-    status: 'active' | 'closed' | 'error' | 'timed_out';
+    status: 'active' | 'authenticating' | 'closed' | 'error' | 'timed_out';
     /**
      * Close Reason
      *
@@ -5725,6 +6057,15 @@ type ApiExecutionResponseWritable = {
      */
     exception?: string | null;
     exception_detail?: SerializedError | null;
+    captcha?: CaptchaStatus | null;
+    /**
+     * Action Executed
+     */
+    action_executed?: boolean | null;
+    /**
+     * Code
+     */
+    code?: string | null;
 };
 /**
  * BaseModel
@@ -6876,10 +7217,8 @@ type SessionResponseWritable = {
     duration?: string;
     /**
      * Status
-     *
-     * Session status
      */
-    status: 'active' | 'closed' | 'error' | 'timed_out';
+    status: 'active' | 'authenticating' | 'closed' | 'error' | 'timed_out';
     /**
      * Close Reason
      *
@@ -7003,6 +7342,41 @@ type UpdateFunctionRunResponseWritable = {
      */
     status?: 'updated' | 'stopped';
 };
+type SessionAuthReadinessData = {
+    body?: never;
+    headers?: {
+        /**
+         * X-Notte-Request-Origin
+         */
+        'x-notte-request-origin'?: string | null;
+        /**
+         * X-Notte-Sdk-Version
+         */
+        'x-notte-sdk-version'?: string | null;
+    };
+    path: {
+        /**
+         * Session Id
+         */
+        session_id: string;
+    };
+    query?: never;
+    url: '/sessions/{session_id}/auth';
+};
+type SessionAuthReadinessErrors = {
+    /**
+     * Validation Error
+     */
+    422: HttpValidationError;
+};
+type SessionAuthReadinessError = SessionAuthReadinessErrors[keyof SessionAuthReadinessErrors];
+type SessionAuthReadinessResponses = {
+    /**
+     * Successful Response
+     */
+    200: ManagedAuthReadiness;
+};
+type SessionAuthReadinessResponse = SessionAuthReadinessResponses[keyof SessionAuthReadinessResponses];
 type ListSessionsData = {
     body?: never;
     headers?: {
@@ -7129,6 +7503,46 @@ type SessionStatusResponses = {
     200: SessionResponse;
 };
 type SessionStatusResponse = SessionStatusResponses[keyof SessionStatusResponses];
+type SessionProfilePreviewData = {
+    body?: never;
+    headers?: {
+        /**
+         * X-Notte-Request-Origin
+         */
+        'x-notte-request-origin'?: string | null;
+        /**
+         * X-Notte-Sdk-Version
+         */
+        'x-notte-sdk-version'?: string | null;
+    };
+    path: {
+        /**
+         * Session Id
+         */
+        session_id: string;
+    };
+    query?: {
+        /**
+         * Include Cookies
+         */
+        include_cookies?: boolean;
+    };
+    url: '/sessions/{session_id}/profile-preview';
+};
+type SessionProfilePreviewErrors = {
+    /**
+     * Validation Error
+     */
+    422: HttpValidationError;
+};
+type SessionProfilePreviewError = SessionProfilePreviewErrors[keyof SessionProfilePreviewErrors];
+type SessionProfilePreviewResponses = {
+    /**
+     * Successful Response
+     */
+    200: SessionProfilePreviewResponse;
+};
+type SessionProfilePreviewResponse2 = SessionProfilePreviewResponses[keyof SessionProfilePreviewResponses];
 type GetSessionScriptData = {
     body?: never;
     headers?: {
@@ -7529,6 +7943,22 @@ type PageExecuteData = {
         session_id: string;
     };
     query?: {
+        /**
+         * Captcha Id
+         */
+        captcha_id?: string | null;
+        /**
+         * Captcha Timeout Seconds
+         */
+        captcha_timeout_seconds?: number;
+        /**
+         * Target Page Id
+         */
+        target_page_id?: string | null;
+        /**
+         * Target Generation
+         */
+        target_generation?: number | null;
         /**
          * Update Metadata
          */
@@ -7660,6 +8090,14 @@ type SessionReplayData = {
     url: '/sessions/{session_id}/replay';
 };
 type SessionReplayErrors = {
+    /**
+     * Replay missing; see replay_status and retryable.
+     */
+    404: ReplayMissingResponse;
+    /**
+     * Capture completed without any frames.
+     */
+    410: ReplayMissingResponse;
     /**
      * Validation Error
      */
@@ -7695,7 +8133,7 @@ type ListSessionFilesData = {
         /**
          * Source
          */
-        source?: FileSource$1 | null;
+        source?: FileSource | null;
         /**
          * Limit
          */
@@ -7718,7 +8156,7 @@ type ListSessionFilesResponses = {
     /**
      * Successful Response
      */
-    200: SessionFilesPage$1;
+    200: SessionFilesPage;
 };
 type ListSessionFilesResponse = ListSessionFilesResponses[keyof ListSessionFilesResponses];
 type UploadSessionFileData = {
@@ -7753,7 +8191,7 @@ type UploadSessionFileResponses = {
     /**
      * Successful Response
      */
-    201: SessionFile$1;
+    201: SessionFile;
 };
 type UploadSessionFileResponse = UploadSessionFileResponses[keyof UploadSessionFileResponses];
 type DeleteSessionFileData = {
@@ -9141,6 +9579,157 @@ type ListVaultsResponses = {
     200: PaginatedResponseVault;
 };
 type ListVaultsResponse = ListVaultsResponses[keyof ListVaultsResponses];
+type ConnectPaymentWalletData = {
+    body: PaymentConnectRequest;
+    headers?: {
+        /**
+         * X-Notte-Request-Origin
+         */
+        'x-notte-request-origin'?: string | null;
+        /**
+         * X-Notte-Sdk-Version
+         */
+        'x-notte-sdk-version'?: string | null;
+    };
+    path?: never;
+    query?: never;
+    url: '/payments/connect';
+};
+type ConnectPaymentWalletErrors = {
+    /**
+     * Validation Error
+     */
+    422: HttpValidationError;
+};
+type ConnectPaymentWalletError = ConnectPaymentWalletErrors[keyof ConnectPaymentWalletErrors];
+type ConnectPaymentWalletResponses = {
+    /**
+     * Successful Response
+     */
+    200: PaymentConnectionResponse;
+};
+type ConnectPaymentWalletResponse = ConnectPaymentWalletResponses[keyof ConnectPaymentWalletResponses];
+type DisconnectPaymentWalletData = {
+    body: PaymentConnectRequest;
+    headers?: {
+        /**
+         * X-Notte-Request-Origin
+         */
+        'x-notte-request-origin'?: string | null;
+        /**
+         * X-Notte-Sdk-Version
+         */
+        'x-notte-sdk-version'?: string | null;
+    };
+    path?: never;
+    query?: never;
+    url: '/payments/disconnect';
+};
+type DisconnectPaymentWalletErrors = {
+    /**
+     * Caller cannot disconnect the wallet
+     */
+    403: PaymentDisconnectError;
+    /**
+     * Wallet has active payments
+     */
+    409: PaymentDisconnectError;
+    /**
+     * Validation Error
+     */
+    422: HttpValidationError;
+    /**
+     * Payments unavailable or wallet revocation must be retried
+     */
+    503: PaymentDisconnectError;
+};
+type DisconnectPaymentWalletError = DisconnectPaymentWalletErrors[keyof DisconnectPaymentWalletErrors];
+type DisconnectPaymentWalletResponses = {
+    /**
+     * Successful Response
+     */
+    200: PaymentDisconnectResponse;
+};
+type DisconnectPaymentWalletResponse = DisconnectPaymentWalletResponses[keyof DisconnectPaymentWalletResponses];
+type CreatePaymentData = {
+    body: PaymentRequest;
+    headers: {
+        /**
+         * Idempotency-Key
+         */
+        'idempotency-key': string;
+        /**
+         * X-Notte-Request-Origin
+         */
+        'x-notte-request-origin'?: string | null;
+        /**
+         * X-Notte-Sdk-Version
+         */
+        'x-notte-sdk-version'?: string | null;
+    };
+    path: {
+        /**
+         * Session Id
+         */
+        session_id: string;
+    };
+    query?: {
+        /**
+         * Update Metadata
+         */
+        update_metadata?: boolean;
+    };
+    url: '/sessions/{session_id}/payments';
+};
+type CreatePaymentErrors = {
+    /**
+     * Validation Error
+     */
+    422: HttpValidationError;
+};
+type CreatePaymentError = CreatePaymentErrors[keyof CreatePaymentErrors];
+type CreatePaymentResponses = {
+    /**
+     * Successful Response
+     */
+    202: PaymentResponse;
+};
+type CreatePaymentResponse = CreatePaymentResponses[keyof CreatePaymentResponses];
+type GetPaymentData = {
+    body?: never;
+    headers?: {
+        /**
+         * X-Notte-Request-Origin
+         */
+        'x-notte-request-origin'?: string | null;
+        /**
+         * X-Notte-Sdk-Version
+         */
+        'x-notte-sdk-version'?: string | null;
+    };
+    path: {
+        /**
+         * Payment Id
+         */
+        payment_id: string;
+    };
+    query?: never;
+    url: '/payments/{payment_id}';
+};
+type GetPaymentErrors = {
+    /**
+     * Validation Error
+     */
+    422: HttpValidationError;
+};
+type GetPaymentError = GetPaymentErrors[keyof GetPaymentErrors];
+type GetPaymentResponses = {
+    /**
+     * Successful Response
+     */
+    200: PaymentResponse;
+};
+type GetPaymentResponse = GetPaymentResponses[keyof GetPaymentResponses];
 type ProfileCreateData = {
     body: ProfileCreateRequest;
     headers?: {
@@ -10425,36 +11014,6 @@ type DeleteSecretResponses = {
     204: void;
 };
 type DeleteSecretResponse = DeleteSecretResponses[keyof DeleteSecretResponses];
-type MintProxyCredentialsData = {
-    body: ProxyCredentialRequest;
-    headers?: {
-        /**
-         * X-Notte-Request-Origin
-         */
-        'x-notte-request-origin'?: string | null;
-        /**
-         * X-Notte-Sdk-Version
-         */
-        'x-notte-sdk-version'?: string | null;
-    };
-    path?: never;
-    query?: never;
-    url: '/proxies/gateway/credentials';
-};
-type MintProxyCredentialsErrors = {
-    /**
-     * Validation Error
-     */
-    422: HttpValidationError;
-};
-type MintProxyCredentialsError = MintProxyCredentialsErrors[keyof MintProxyCredentialsErrors];
-type MintProxyCredentialsResponses = {
-    /**
-     * Successful Response
-     */
-    200: ProxyCredentialResponse;
-};
-type MintProxyCredentialsResponse = MintProxyCredentialsResponses[keyof MintProxyCredentialsResponses];
 type HealthCheckData = {
     body?: never;
     path?: never;
@@ -10584,6 +11143,10 @@ type Options<TData extends TDataShape = TDataShape, ThrowOnError extends boolean
      */
     meta?: keyof ClientMeta extends never ? Record<string, unknown> : ClientMeta;
 };
+/**
+ * Session Auth Readiness
+ */
+declare const sessionAuthReadiness: <ThrowOnError extends boolean = false>(options: Options<SessionAuthReadinessData, ThrowOnError>) => RequestResult<SessionAuthReadinessResponses, SessionAuthReadinessErrors, ThrowOnError>;
 /**
  * List Sessions
  */
@@ -10596,6 +11159,10 @@ declare const sessionStart: <ThrowOnError extends boolean = false>(options: Opti
  * Session Status
  */
 declare const sessionStatus: <ThrowOnError extends boolean = false>(options: Options<SessionStatusData, ThrowOnError>) => RequestResult<SessionStatusResponses, SessionStatusErrors, ThrowOnError>;
+/**
+ * Session Profile Preview
+ */
+declare const sessionProfilePreview: <ThrowOnError extends boolean = false>(options: Options<SessionProfilePreviewData, ThrowOnError>) => RequestResult<SessionProfilePreviewResponses, SessionProfilePreviewErrors, ThrowOnError>;
 /**
  * Get Session Script
  */
@@ -10789,19 +11356,35 @@ declare const vaultCreditCardSet: <ThrowOnError extends boolean = false>(options
  */
 declare const listVaults: <ThrowOnError extends boolean = false>(options?: Options<ListVaultsData, ThrowOnError>) => RequestResult<ListVaultsResponses, ListVaultsErrors, ThrowOnError>;
 /**
- * Profile Create
+ * Connect Payment Wallet
  */
-declare const profileCreate: <ThrowOnError extends boolean = false>(options: Options<ProfileCreateData, ThrowOnError>) => RequestResult<ProfileCreateResponses, ProfileCreateErrors, ThrowOnError>;
+declare const connectPaymentWallet: <ThrowOnError extends boolean = false>(options: Options<ConnectPaymentWalletData, ThrowOnError>) => RequestResult<ConnectPaymentWalletResponses, ConnectPaymentWalletErrors, ThrowOnError>;
 /**
- * Profile Delete
+ * Disconnect Payment Wallet
  */
-declare const profileDelete: <ThrowOnError extends boolean = false>(options: Options<ProfileDeleteData, ThrowOnError>) => RequestResult<ProfileDeleteResponses, ProfileDeleteErrors, ThrowOnError>;
+declare const disconnectPaymentWallet: <ThrowOnError extends boolean = false>(options: Options<DisconnectPaymentWalletData, ThrowOnError>) => RequestResult<DisconnectPaymentWalletResponses, DisconnectPaymentWalletErrors, ThrowOnError>;
 /**
- * Profile Get
+ * Create Payment
  */
-declare const profileGet: <ThrowOnError extends boolean = false>(options: Options<ProfileGetData, ThrowOnError>) => RequestResult<ProfileGetResponses, ProfileGetErrors, ThrowOnError>;
+declare const createPayment: <ThrowOnError extends boolean = false>(options: Options<CreatePaymentData, ThrowOnError>) => RequestResult<CreatePaymentResponses, CreatePaymentErrors, ThrowOnError>;
 /**
- * Profile Duplicate
+ * Get Payment
+ */
+declare const getPayment: <ThrowOnError extends boolean = false>(options: Options<GetPaymentData, ThrowOnError>) => RequestResult<GetPaymentResponses, GetPaymentErrors, ThrowOnError>;
+/**
+ * Profile Create
+ */
+declare const profileCreate: <ThrowOnError extends boolean = false>(options: Options<ProfileCreateData, ThrowOnError>) => RequestResult<ProfileCreateResponses, ProfileCreateErrors, ThrowOnError>;
+/**
+ * Profile Delete
+ */
+declare const profileDelete: <ThrowOnError extends boolean = false>(options: Options<ProfileDeleteData, ThrowOnError>) => RequestResult<ProfileDeleteResponses, ProfileDeleteErrors, ThrowOnError>;
+/**
+ * Profile Get
+ */
+declare const profileGet: <ThrowOnError extends boolean = false>(options: Options<ProfileGetData, ThrowOnError>) => RequestResult<ProfileGetResponses, ProfileGetErrors, ThrowOnError>;
+/**
+ * Profile Duplicate
  */
 declare const profileDuplicate: <ThrowOnError extends boolean = false>(options: Options<ProfileDuplicateData, ThrowOnError>) => RequestResult<ProfileDuplicateResponses, ProfileDuplicateErrors, ThrowOnError>;
 /**
@@ -10932,12 +11515,6 @@ declare const getSecret: <ThrowOnError extends boolean = false>(options: Options
  * Delete Secret
  */
 declare const deleteSecret: <ThrowOnError extends boolean = false>(options: Options<DeleteSecretData, ThrowOnError>) => RequestResult<DeleteSecretResponses, DeleteSecretErrors, ThrowOnError>;
-/**
- * Mint a short-lived proxy credential
- *
- * Returns a derived username/password for `proxy.notte.cc`, signed for this workspace and valid for your plan's maximum session duration (see `expires_at`). Traffic through it is billed to this API key's workspace at the proxy rate. Clients that support TLS to a proxy can also use the API key itself as the proxy password on port 443.
- */
-declare const mintProxyCredentials: <ThrowOnError extends boolean = false>(options: Options<MintProxyCredentialsData, ThrowOnError>) => RequestResult<MintProxyCredentialsResponses, MintProxyCredentialsErrors, ThrowOnError>;
 /**
  * Health Check
  */
@@ -10961,7 +11538,623 @@ declare const scrapeFromHtml: <ThrowOnError extends boolean = false>(options: Op
 
 declare const client: Client;
 
-interface SessionOptions extends Omit<ApiSessionStartRequest, 'use_file_storage'> {
+/**
+ * Typed error hierarchy mirroring `notte_sdk.errors` and the `notte_core` errors
+ * the Python SDK raises. Every error thrown by the SDK extends `NotteError`, so
+ * callers can `catch (e) { if (e instanceof NotteError) ... }` and branch on the
+ * concrete class or on `NotteAPIError.statusCode`.
+ */
+
+declare class NotteError extends Error {
+    constructor(message: string, options?: {
+        cause?: unknown;
+    });
+}
+/**
+ * Body of a failed HTTP response, best effort. JSON bodies are exposed as-is;
+ * non-JSON bodies (HTML error pages, empty 502s) are wrapped as `{ message }`.
+ */
+type NotteAPIErrorBody = Record<string, unknown>;
+/** The API answered with a non-2xx status. */
+declare class NotteAPIError extends NotteError {
+    readonly path: string;
+    readonly statusCode: number;
+    readonly error: NotteAPIErrorBody;
+    readonly response: Response | undefined;
+    constructor(path: string, statusCode: number, error: NotteAPIErrorBody, response?: Response);
+    /** The API's own error message, when it sent one. */
+    get apiMessage(): string | undefined;
+    static fromBody(path: string, statusCode: number, body: unknown, response?: Response): NotteAPIError;
+}
+/** The API flagged the failure as an execution error (`x-error-class: NotteApiExecutionError`). */
+declare class NotteAPIExecutionError extends NotteAPIError {
+    constructor(path: string, statusCode: number, error: NotteAPIErrorBody, response?: Response);
+}
+/** Missing or rejected credentials. Not retryable. */
+declare class AuthenticationError extends NotteError {
+    constructor(message: string);
+}
+/** The request is malformed. Not retryable. */
+declare class InvalidRequestError extends NotteError {
+    constructor(message: string);
+}
+/** A request or a wait exceeded its deadline. */
+declare class NotteTimeoutError extends NotteError {
+}
+/** A cloud function run finished with `status: "failed"`. */
+declare class FailedToRunCloudFunctionError extends NotteError {
+    readonly functionId: string;
+    readonly functionRunId: string;
+    readonly response: unknown;
+    constructor(functionId: string, functionRunId: string, response: unknown);
+}
+/** Structured scrape extraction failed (`StructuredData.success === false`). */
+declare class ScrapeFailedError extends NotteError {
+    readonly structuredError: string | undefined;
+    constructor(error: string | undefined);
+}
+/**
+ * An action executed through `session.execute()` failed. Rehydrated from the
+ * structured `exception_detail` payload the API returns, so `errorType` names
+ * the concrete server-side error class and the three messages carry the same
+ * text Python exposes on `NotteBaseError`.
+ */
+declare class ActionExecutionError extends NotteError {
+    readonly errorType: string;
+    readonly devMessage: string;
+    readonly userMessage: string;
+    readonly agentMessage: string;
+    readonly shouldRetryLater: boolean;
+    readonly shouldNotifyTeam: boolean;
+    constructor(detail: SerializedError);
+    static fromMessage(message: string, errorType?: string): ActionExecutionError;
+}
+/** `evaluate_js` reported success but the API build predates the data payload. */
+declare class EvaluateJsNoDataError extends NotteError {
+    constructor();
+}
+/** The envelope returned by `session.fetch()` could not be decoded. */
+declare class FetchResponseDecodeError extends NotteError {
+    constructor(reason: string);
+}
+interface RetryOptions {
+    /** Maximum number of attempts, including the first one. */
+    maxTries: number;
+    /** Delay between attempts in milliseconds. Defaults to 5000 like the Python decorator. */
+    delayMs?: number;
+    /** Message of the `Error` raised once every attempt failed. */
+    errorMessage?: string;
+    /** Only retry when this returns true for the thrown error. Defaults to retrying on any error. */
+    shouldRetry?: (error: unknown, attempt: number) => boolean;
+    /** Called before sleeping between attempts. Defaults to `console.warn`. */
+    onRetry?: (error: unknown, attempt: number, maxTries: number) => void;
+}
+/**
+ * Wrap an async function so it is retried when it throws, mirroring
+ * `notte_sdk.errors.retry`. The final failure is raised as an `Error` whose
+ * `cause` is the last underlying error.
+ *
+ * ```ts
+ * const start = retry(() => session.start(), { maxTries: 3, delayMs: 1000 });
+ * await start();
+ * ```
+ */
+declare function retry<TArgs extends unknown[], TResult>(fn: (...args: TArgs) => Promise<TResult>, options: RetryOptions): (...args: TArgs) => Promise<TResult>;
+
+/** A file ID was not found in the session, the counterpart of Python's `FileNotFoundError`. */
+declare class FileNotFoundError extends NotteError {
+}
+/** The download destination already exists, the counterpart of Python's `FileExistsError`. */
+declare class FileExistsError extends NotteError {
+}
+interface FileListOptions {
+    /** Only return files from this source: `user_upload` or `session_download`. */
+    source?: FileSource;
+    /** Page size. Defaults to 100. */
+    limit?: number;
+    /** Page offset. Defaults to 0. */
+    offset?: number;
+}
+interface FileDownloadOptions {
+    /** Overwrite an existing local file instead of rejecting with `FileExistsError`. */
+    force?: boolean;
+}
+/** Bytes accepted by `upload()`: a local path, a `Blob`/`File`, or an in-memory buffer. */
+type UploadableFile = string | Blob | Uint8Array;
+/**
+ * Reduce a server-provided filename to a safe basename, like Python's
+ * `Path(PureWindowsPath(filename).name).name`: both separators are honoured,
+ * drive letters are dropped and only the last component is kept.
+ */
+declare function sanitizeFilename(filename: string): string;
+/**
+ * Session-scoped file operations built on the generated `sessions/{id}/files`
+ * client. Every API failure rejects with a `NotteAPIError`.
+ *
+ * ```ts
+ * const files = client.Files(sessionId);
+ * const uploaded = await files.upload(new Blob(['hello']), 'hello.txt');
+ * const page = await files.list({ source: 'user_upload' });
+ * ```
+ */
+declare class SessionFiles {
+    private readonly client;
+    readonly sessionId: string;
+    constructor(client: Client, sessionId: string);
+    /**
+     * Upload bytes as a session file. `filename` is what the browser sees when
+     * the file is later attached to a page.
+     *
+     * @param file - Bytes to upload as a Blob, File, or buffer.
+     * @param filename - Stored filename, defaulting to `file`.
+     * @returns Metadata for the uploaded file, including its ID, name, and size.
+     * @throws NotteAPIError if the storage API request fails.
+     */
+    upload(file: Blob | Uint8Array, filename?: string): Promise<SessionFile>;
+    /** List the session's non-expired files, newest first.
+     *
+     * @param options - Optional source filter and pagination. Defaults to all sources, limit 100, and offset 0.
+     * @returns One page of non-expired files and the total count; pagination is not automatic.
+     * @throws NotteAPIError if the storage API request fails.
+     */
+    list(options?: FileListOptions): Promise<SessionFilesPage>;
+    /**
+     * Find a file's metadata by ID by scanning the session listing. Rejects with
+     * `FileNotFoundError` when the ID is unknown or expired.
+     *
+     * @param fileId - ID of a file belonging to this session.
+     * @returns The matching file's metadata.
+     * @throws NotteAPIError if the storage API request fails.
+     * @throws FileNotFoundError if the file ID is unknown or expired.
+     */
+    metadata(fileId: string): Promise<SessionFile>;
+    /** Download a file's bytes as a `Blob`.
+     *
+     * @param fileId - ID of a file belonging to this session.
+     * @returns The downloaded bytes as a Blob; no local file is written.
+     * @throws NotteAPIError if the storage API request fails.
+     */
+    download(fileId: string): Promise<Blob>;
+    /** Stream a file's bytes. Used by `RemoteFileStorage.download()` to write to disk without buffering. */
+    stream(fileId: string): Promise<ReadableStream<Uint8Array>>;
+    /** Delete a session file.
+     *
+     * @param fileId - ID of the session file to delete.
+     * @returns Resolves when deletion succeeds.
+     * @throws NotteAPIError if the storage API request fails.
+     */
+    delete(fileId: string): Promise<void>;
+}
+/**
+ * File storage bound to a session, the counterpart of Python's
+ * `RemoteFileStorage`. Create it unbound and pass it to `client.Session({ storage })`
+ * so the session binds it on start, or bind it yourself with a session ID.
+ *
+ * ```ts
+ * const storage = client.FileStorage(sessionId);
+ * const uploaded = await storage.upload('./resume.pdf');
+ * const localPath = await storage.download(uploaded.id, './downloads');
+ * const blob = await storage.downloadBlob(uploaded.id);
+ * ```
+ *
+ * `download()` saves to disk; `downloadBlob()` returns bytes in memory, and
+ * `stream()` returns a readable stream. For lower-level session file access,
+ * see [NotteClient.Files](/typescript-sdk-reference/client/files).
+ *
+ */
+declare class RemoteFileStorage {
+    readonly client: NotteClient;
+    private _sessionId;
+    constructor(client: NotteClient, sessionId?: string);
+    /** Bind the storage to a session. Called by `Session.start()` when the storage was passed to the session. */
+    setSessionId(sessionId: string): void;
+    /**
+     * Bind this storage once, cloning it when another session already owns it.
+     *
+     * ```ts
+     * const first = storage.forSession('session-a'); // first === storage
+     * const second = storage.forSession('session-b'); // a clone sharing the client
+     * ```
+     */
+    forSession(sessionId: string): RemoteFileStorage;
+    /** ID of the bound session. Throws `InvalidRequestError` while the storage is unbound. */
+    get sessionId(): string;
+    /** Whether the storage has been bound to a session yet. */
+    get isBound(): boolean;
+    private files;
+    /**
+     * Upload a file to the session. A string is read as a local path and its
+     * basename becomes the uploaded filename unless `uploadFileName` is set.
+     *
+     * @param file - Local file path, Blob, File, or buffer to upload.
+     * @param uploadFileName - Optional stored filename. Local paths default to their basename; File objects keep their name.
+     * @returns Metadata for the uploaded file, including its ID, name, and size.
+     * @throws NotteAPIError if the storage API request fails.
+     * @throws InvalidRequestError if storage has not been bound to a session.
+     * @throws InvalidRequestError if a supplied local path is not a file.
+     * @example
+     * await storage.upload('./data/resume.pdf');
+     * await storage.upload(Buffer.from('hello'), 'hello.txt');
+     */
+    upload(file: UploadableFile, uploadFileName?: string): Promise<SessionFile>;
+    /**
+     * List the session's files.
+     *
+     * @param options - Optional source filter and pagination. Defaults to all sources, limit 100, and offset 0.
+     * @returns One page of non-expired files and the total count; pagination is not automatic.
+     * @throws NotteAPIError if the storage API request fails.
+     * @throws InvalidRequestError if storage has not been bound to a session.
+     * @example
+     * const downloads = await storage.list({ source: 'session_download', limit: 1000 });
+     */
+    list(options?: FileListOptions): Promise<SessionFilesPage>;
+    /** Metadata of a file by ID. Rejects with `FileNotFoundError` when unknown.
+     *
+     * @param fileId - ID of a file belonging to this session.
+     * @returns The matching file's metadata.
+     * @throws NotteAPIError if the storage API request fails.
+     * @throws FileNotFoundError if the file ID is unknown or expired.
+     * @throws InvalidRequestError if storage has not been bound to a session.
+     */
+    metadata(fileId: string): Promise<SessionFile>;
+    /**
+     * Download a file to `<localDir>/<filename>` and return the local path. The
+     * file is written atomically (temporary file + rename). Rejects with
+     * `FileExistsError` when the destination exists unless `force` is set.
+     *
+     * @param fileId - ID of the file to download.
+     * @param localDir - Destination directory, created if needed. Defaults to the current directory.
+     * @param options - Set `force` to overwrite an existing destination; defaults to false.
+     * @returns The local file path after the download has been written successfully.
+     * @throws NotteAPIError if the storage API request fails.
+     * @throws InvalidRequestError if storage has not been bound to a session.
+     * @throws FileExistsError if the destination exists and `force` is false. Filesystem errors also propagate.
+     * @example
+     * const path = await storage.download(fileId, './downloads', { force: true });
+     */
+    download(fileId: string, localDir?: string, options?: FileDownloadOptions): Promise<string>;
+    /** Download a file's bytes as a `Blob` without touching the local filesystem. */
+    downloadBlob(fileId: string): Promise<Blob>;
+    /** Stream a file's bytes without buffering the whole file in memory. */
+    stream(fileId: string): Promise<ReadableStream<Uint8Array>>;
+    /** Delete a session file.
+     *
+     * @param fileId - ID of the session file to delete.
+     * @returns Resolves when deletion succeeds.
+     * @throws NotteAPIError if the storage API request fails.
+     * @throws InvalidRequestError if storage has not been bound to a session.
+     */
+    delete(fileId: string): Promise<void>;
+}
+
+/** Session response including managed authentication readiness. */
+type AuthSessionResponse = SessionResponse;
+interface ManagedAuthRunResponse {
+    operation_id?: string | null;
+    authenticated?: boolean | null;
+    connection_id: string;
+    status: string;
+    message: string;
+}
+interface AuthWaitOptions {
+    /** Overall waiting deadline, milliseconds. Defaults to 615000. */
+    timeoutMs?: number;
+    /** Delay between short polling requests, milliseconds. Defaults to 1000. */
+    pollIntervalMs?: number;
+    signal?: AbortSignal;
+}
+interface ManagedAuthRunOptions extends AuthWaitOptions {
+    /** Wait for completion. Defaults to true. */
+    wait?: boolean;
+    /** Additional server-side login attempts, from 0 to 2. Defaults to 0. */
+    auth_retry?: number;
+}
+declare class ManagedAuthError extends NotteError {
+}
+/**
+ * Connection verification and recovery through `client.managedAuth`.
+ *
+ * ```typescript
+ * const operation = await client.managedAuth.refreshConnection("<connection-id>", { wait: false });
+ * await client.managedAuth.waitForAuth(operation);
+ * ```
+ */
+declare class NotteManagedAuth {
+    private readonly client;
+    constructor(client: NotteClient);
+    /** Run only the verifier; this does not submit login credentials. */
+    checkConnection(connectionId: string): Promise<ManagedAuthRunResponse>;
+    getOperation(operationId: string, options?: Pick<AuthWaitOptions, 'signal'>): Promise<ManagedAuthOperation>;
+    /** Wait for an accepted operation. Aborting this wait does not cancel the server operation. */
+    waitForAuth(operation: ManagedAuthOperation, options?: AuthWaitOptions): Promise<ManagedAuthOperation>;
+    /** Verify first, logging in only when required and automatic recovery is allowed. */
+    refreshConnection(connectionId: string, options?: ManagedAuthRunOptions): Promise<ManagedAuthOperation>;
+    /** Explicitly request a new login. Conflicting operations remain HTTP 409 errors. */
+    reauthenticateConnection(connectionId: string, options?: ManagedAuthRunOptions): Promise<ManagedAuthOperation>;
+    private run;
+}
+
+/** Per-request cancellation; authentication and transport stay bound to NotteClient. */
+interface ResourceRequestOptions {
+    signal?: AbortSignal;
+}
+
+/** Discriminated union of every action `session.execute()` accepts. */
+type ExecuteAction = PageExecuteData['body'];
+/** The `type` discriminator of an `ExecuteAction`. */
+type ActionType = ExecuteAction['type'];
+/** The union member whose `type` is `T`. */
+type ActionOfType<T extends ActionType> = Extract<ExecuteAction, {
+    type: T;
+}>;
+/** The fields of an action minus its `type` discriminator. */
+type ActionInput<T extends ActionType> = Omit<ActionOfType<T>, 'type'>;
+/** Namespace object mirroring `from notte_sdk import actions`. */
+declare const actions: {
+    readonly goto: (input: ActionInput<"goto">) => {
+        type: "goto";
+    } & GotoAction;
+    readonly gotoNewTab: (input: ActionInput<"goto_new_tab">) => {
+        type: "goto_new_tab";
+    } & GotoNewTabAction;
+    readonly closeTab: (input?: ActionInput<"close_tab"> | undefined) => {
+        type: "close_tab";
+    } & CloseTabAction;
+    readonly switchTab: (input: ActionInput<"switch_tab">) => {
+        type: "switch_tab";
+    } & SwitchTabAction;
+    readonly goBack: (input?: ActionInput<"go_back"> | undefined) => {
+        type: "go_back";
+    } & GoBackAction;
+    readonly goForward: (input?: ActionInput<"go_forward"> | undefined) => {
+        type: "go_forward";
+    } & GoForwardAction;
+    readonly reload: (input?: ActionInput<"reload"> | undefined) => {
+        type: "reload";
+    } & ReloadAction;
+    readonly wait: (input: ActionInput<"wait">) => {
+        type: "wait";
+    } & WaitAction;
+    readonly pressKey: (input: ActionInput<"press_key">) => {
+        type: "press_key";
+    } & PressKeyAction;
+    readonly scrollUp: (input?: ActionInput<"scroll_up"> | undefined) => {
+        type: "scroll_up";
+    } & ScrollUpAction;
+    readonly scrollDown: (input?: ActionInput<"scroll_down"> | undefined) => {
+        type: "scroll_down";
+    } & ScrollDownAction;
+    readonly captchaSolve: (input?: ActionInput<"captcha_solve"> | undefined) => {
+        type: "captcha_solve";
+    } & CaptchaSolveAction;
+    readonly help: (input: ActionInput<"help">) => {
+        type: "help";
+    } & HelpAction;
+    readonly completion: (input: ActionInput<"completion">) => {
+        type: "completion";
+    } & CompletionAction;
+    readonly scrape: (input?: ActionInput<"scrape"> | undefined) => {
+        type: "scrape";
+    } & ScrapeAction;
+    readonly emailRead: (input?: ActionInput<"email_read"> | undefined) => {
+        type: "email_read";
+    } & EmailReadAction;
+    readonly emailVerificationRead: (input: ActionInput<"email_verification_read">) => {
+        type: "email_verification_read";
+    } & EmailVerificationReadAction;
+    readonly smsRead: (input?: ActionInput<"sms_read"> | undefined) => {
+        type: "sms_read";
+    } & SmsReadAction;
+    readonly evaluateJs: (input: ActionInput<"evaluate_js">) => {
+        type: "evaluate_js";
+    } & EvaluateJsAction;
+    readonly formFill: (input: ActionInput<"form_fill">) => {
+        type: "form_fill";
+    } & FormFillActionWritable;
+    readonly click: (input?: ActionInput<"click"> | undefined) => {
+        type: "click";
+    } & ClickActionInput;
+    readonly fill: (input: ActionInput<"fill">) => {
+        type: "fill";
+    } & FillActionInputWritable;
+    readonly multiFactorFill: (input: ActionInput<"multi_factor_fill">) => {
+        type: "multi_factor_fill";
+    } & MultiFactorFillActionInputWritable;
+    readonly fallbackFill: (input: ActionInput<"fallback_fill">) => {
+        type: "fallback_fill";
+    } & FallbackFillActionInputWritable;
+    readonly check: (input: ActionInput<"check">) => {
+        type: "check";
+    } & CheckActionInput;
+    readonly selectDropdownOption: (input: ActionInput<"select_dropdown_option">) => {
+        type: "select_dropdown_option";
+    } & SelectDropdownOptionActionInputWritable;
+    readonly uploadFile: (input: ActionInput<"upload_file">) => {
+        type: "upload_file";
+    } & UploadFileActionInput;
+    readonly downloadFile: (input?: ActionInput<"download_file"> | undefined) => {
+        type: "download_file";
+    } & DownloadFileActionInput;
+};
+/** True when the action is a captcha solve, which gets a longer request timeout and 408 retries. */
+declare function isCaptchaSolveAction(action: ExecuteAction): action is ActionOfType<'captcha_solve'>;
+
+/** Execution envelope with the backend's additive CAPTCHA coordination fields. */
+type CaptchaExecutionResponse = ApiExecutionResponse & {
+    captcha?: CaptchaStatus | null;
+    action_executed?: boolean | null;
+    code?: string | null;
+};
+
+/**
+ * Issue an HTTP request from the page a session is on, the port of
+ * `notte_core.data.fetch`.
+ *
+ * `session.fetch()` runs the browser's own `fetch()` inside the current page, so
+ * the request carries the page's cookies, the session's proxy and the browser's
+ * network fingerprint. This module builds the script and reads the result back
+ * into a `PageFetchResponse`.
+ */
+
+/** A form body (`Record`) or a raw string body. */
+type FetchData = string | Record<string, unknown>;
+interface PageFetchOptions {
+    /** HTTP method. Defaults to `GET`. */
+    method?: string;
+    /** Request headers. */
+    headers?: Record<string, string>;
+    /** Query parameters appended to the URL (before any fragment). Arrays repeat the key. */
+    params?: Record<string, unknown>;
+    /** JSON body, sent with `Content-Type: application/json` unless a content type is given. */
+    json?: unknown;
+    /** Form body (`Record`, sent url-encoded) or a raw string body sent verbatim. */
+    data?: FetchData;
+    /** Abort the request after this many milliseconds. Must be positive. */
+    timeoutMs?: number;
+    /**
+     * Allow `http:` URLs and follow redirects. Off by default because the request
+     * carries the page's cookies: an `https:` request redirected to `http:` would
+     * send them in cleartext before the response can be inspected, so by default
+     * redirects are not followed and a redirected response throws.
+     */
+    allowInsecure?: boolean;
+    /**
+     * Browser `fetch` redirect mode. Defaults to `manual` (a redirect throws)
+     * unless `allowInsecure` is set, in which case redirects are followed like
+     * the Python SDK does.
+     */
+    redirect?: 'follow' | 'manual' | 'error';
+}
+/**
+ * Return the JavaScript that performs the request and serialises the response.
+ *
+ * The script is an async IIFE, which `evaluateJs` awaits. It returns a JSON
+ * string so the value survives the evaluate round-trip unchanged.
+ *
+ * ```ts
+ * const script = buildFetchScript('/api/items', { params: { page: 2 } });
+ * const response = responseFromEvaluated(await session.evaluateJs(script));
+ * ```
+ */
+declare function buildFetchScript(url: string, options?: PageFetchOptions): string;
+/** `response.raiseForStatus()` rejected a 4xx/5xx response, like `requests.HTTPError`. */
+declare class PageFetchHTTPError extends NotteError {
+    readonly response: PageFetchResponse;
+    constructor(response: PageFetchResponse);
+}
+/**
+ * The response of `session.fetch()`, shaped like the Web `Response` with the
+ * final `url` after redirects exposed as a plain property. A non-2xx status is
+ * a response, not an error; `raiseForStatus()` throws `PageFetchHTTPError`.
+ * `bytes()` holds the exact bytes the server sent, so binary bodies survive;
+ * `text()` decodes them with the declared charset, or utf-8 when none is given.
+ */
+declare class PageFetchResponse {
+    readonly status: number;
+    readonly statusText: string;
+    readonly headers: Headers;
+    /** The final URL after redirects. */
+    readonly url: string;
+    /** The declared charset, `utf-8` when the body is valid utf-8, else `undefined`. */
+    readonly encoding: string | undefined;
+    private readonly content;
+    constructor(init: {
+        status: number;
+        headers: Record<string, string>;
+        url: string;
+        content: Uint8Array;
+    });
+    get ok(): boolean;
+    /** The raw body bytes. */
+    bytes(): Uint8Array;
+    arrayBuffer(): Promise<ArrayBuffer>;
+    text(): Promise<string>;
+    json(): Promise<unknown>;
+    /** Throw `PageFetchHTTPError` on a 4xx/5xx status, like `requests.Response.raise_for_status()`. */
+    raiseForStatus(): this;
+}
+/**
+ * Turn the envelope `buildFetchScript` returns into a `PageFetchResponse`.
+ * Throws `FetchResponseDecodeError` when the envelope cannot be read.
+ */
+declare function responseFromEvaluated(raw: string): PageFetchResponse;
+
+/**
+ * Shared scrape request/response handling for `client.scrape()` and
+ * `session.scrape()`, mirroring `PageClient.scrape` in the Python SDK.
+ */
+
+/** Minimal structural view of a Zod schema so `zod` stays an optional import path. */
+interface ZodLikeSchema<T> {
+    parse(data: unknown): T;
+}
+/** Structured extraction result when `raiseOnFailure` is false, like `StructuredData` in Python. */
+interface StructuredData<T> {
+    success: boolean;
+    error?: string | null;
+    data?: T | null;
+}
+interface ScrapeOptions<T = unknown> {
+    /** A Zod schema or a JSON Schema object describing the data to extract. */
+    response_format?: ZodLikeSchema<T> | Record<string, unknown> | null;
+    /** JSON Schema to send instead of converting `response_format`. Only used with a Zod schema. */
+    json_schema?: Record<string, unknown>;
+    /**
+     * When true (default) a failed structured extraction throws `ScrapeFailedError`
+     * and the extracted data is returned directly. When false the `StructuredData`
+     * wrapper is returned so callers can inspect `.success`.
+     */
+    raiseOnFailure?: boolean;
+}
+type SessionScrapeOptions<T = unknown> = Omit<ScrapeRequest, 'response_format'> & ScrapeOptions<T>;
+type ScrapeResult<T> = string | ImageData[] | T | StructuredData<T>;
+/**
+ * Post-process a scrape response according to the request options:
+ * - `only_images` returns the image list,
+ * - `response_format` / `instructions` return the extracted data (validated by
+ *   the Zod schema when one was given) or throw `ScrapeFailedError`,
+ * - otherwise the markdown string is returned.
+ */
+declare function processScrapeResponse<T = unknown>(scrapeResponse: DataSpace | undefined, options: SessionScrapeOptions<T> & {
+    instructions?: string | null;
+    only_images?: boolean;
+}): ScrapeResult<T>;
+
+/** Number of attempts `start()` makes on 5xx errors, like `RemoteSession.start(tries=3)`. */
+declare const SESSION_START_TRIES = 3;
+/** Delay before retrying `start()` after an HTTP 529 (cluster overload). */
+declare const CLUSTER_OVERLOAD_RETRY_DELAY_MS = 30000;
+/** @deprecated Legacy request limit; CAPTCHA polls now use at most 10 seconds per request. */
+declare const CAPTCHA_SOLVE_TIMEOUT_MS = 100000;
+type PerceptionType = NonNullable<ObserveRequest['perception_type']>;
+type SessionCloseReason = 'manual' | 'error';
+interface ExecuteOptions {
+    /** Throw when the action fails. Defaults to the session's `raiseOnFailure` (true). */
+    raiseOnFailure?: boolean;
+}
+interface ReplayOptions {
+    /** Poll until the replay is ready instead of failing on 404. Defaults to true. */
+    wait?: boolean;
+    /** Maximum time to wait for the replay, in milliseconds. Defaults to 240 000. */
+    timeoutMs?: number;
+    /** Delay between polling attempts, in milliseconds. Defaults to 5 000. */
+    pollIntervalMs?: number;
+}
+interface SessionScriptOptions {
+    /** Return a standalone workflow script rather than only the relevant steps. Defaults to true. */
+    as_workflow?: boolean;
+    /** Infer a `response_format` schema for scrape calls that have instructions but no schema. */
+    infer_response_format?: boolean;
+}
+interface SessionStartOptions extends AuthWaitOptions {
+    /** Override the session default; false returns while authentication continues. */
+    wait_for_authentication?: boolean;
+}
+interface SessionOptions extends ApiSessionStartRequest {
+    /** Wait in the SDK for managed authentication on start(). Defaults to true; use() always waits. */
+    wait_for_authentication?: boolean;
+    /** Additional server-side login attempts, from 0 to 2. Only sent with auth_ids. */
+    auth_retry?: number;
     /**
      * @deprecated Remote sessions always use the supported browser launch mode.
      * Retained as a boolean so existing typed configuration still compiles.
@@ -10973,85 +12166,340 @@ interface SessionOptions extends Omit<ApiSessionStartRequest, 'use_file_storage'
      * This is a local SDK option and is not sent to the API.
      */
     open_viewer?: boolean;
+    /**
+     * Default for `execute()`: throw `ActionExecutionError` when an action fails.
+     * The counterpart of `raise_on_failure` on `RemoteSession`. Defaults to true.
+     */
+    raiseOnFailure?: boolean;
+    /** Default perception type for `observe()`. Defaults to `fast`. */
+    perception_type?: PerceptionType;
+    /**
+     * JSON cookie file: loaded into the session on `start()` when it exists and
+     * appended with the session cookies on `stop()`.
+     */
+    cookie_file?: string;
+    /** File storage to attach to the session so agents can consume uploaded files. */
+    storage?: RemoteFileStorage;
 }
+/**
+ * Keep the external CDP client from competing with Notte for native dialogs.
+ *
+ * Playwright automatically handles a JavaScript dialog when no listener is
+ * registered. Native dialogs are target-global, so that default races the
+ * Notte browser controller attached to the same target. The backend owns
+ * dialog handling; this listener makes the SDK Playwright connection an
+ * observer without issuing a second `Page.handleJavaScriptDialog` command.
+ */
+declare function observeServerOwnedDialog(_dialog: Dialog): void;
+declare function installServerOwnedDialogPolicy(browser: Pick<Browser, 'contexts'>): void;
+/**
+ * Browser session created with `client.Session(options)`.
+ * Call `start()` before using it and `stop()` when finished, or use `use()`
+ * to start and stop automatically around an asynchronous callback.
+ */
 declare class Session {
     private client;
     private options;
     private openViewer;
     private legacyHeadless;
+    private defaultRaiseOnFailure;
+    private defaultPerceptionType;
+    private cookieFile;
+    private cookiesLoaded;
+    private cookieLoadPromise;
+    private authenticationReady;
+    private fileStorage;
     private sessionId;
     private isActive;
     private response;
+    private playwrightBrowser;
+    private playwrightPage;
     constructor(client: NotteClient, options?: SessionOptions);
     /**
-     * Start the session - creates a new session on the server
+     * Start the session: creates a new session on the server.
+     *
+     * Retries up to `SESSION_START_TRIES` times on 5xx errors, waiting
+     * `CLUSTER_OVERLOAD_RETRY_DELAY_MS` on HTTP 529 (cluster overload). 4xx
+     * errors are never retried.
+     *
+     * Managed-auth sessions wait for readiness by default. Pass
+     * `{ wait_for_authentication: false }` for an explicit nonblocking start,
+     * then call `waitForAuth()` before executing actions or connecting over CDP.
+     * Cancellation during creation waits for its response so the new session can
+     * be closed. Cancellation or failure during the startup wait also closes it.
+     * Prefer `session.use(async session => { ... })`, which also stops the session.
+     * @example
+     * const session = client.Session();
+     * await session.start();
      */
-    start(): Promise<void>;
+    start(options?: SessionStartOptions): Promise<void>;
     /**
-     * Stop the session - terminates the session on the server
+     * Wait for this session to become usable without creating a session or submitting another login.
+     * A standalone wait leaves session ownership with the caller, including on timeout or cancellation.
      */
-    stop(closeReason?: 'manual' | 'error'): Promise<void>;
+    waitForAuth(options?: AuthWaitOptions): Promise<void>;
+    private loadInitialCookies;
     /**
-     * Get session status
+     * Stop the session and clean up resources (including any Playwright
+     * connection opened with `page()`). When a `cookie_file` was given, the
+     * session cookies are appended to it first. A session the API reports as
+     * already stopped is tolerated with a warning.
+     *
+     * @example
+     * await session.stop();
      */
-    status(): Promise<SessionResponse>;
+    stop(closeReason?: SessionCloseReason): Promise<void>;
+    private closePlaywright;
     /**
-     * Get session ID
+     * Get the current status of the session. Like Python, this keeps working
+     * after `stop()` (for example to read the recorded `steps`).
+     *
+     * @returns Current session metadata, including lifecycle status and recorded steps. Works after `stop()`.
+     * @throws Error if this session has never been started.
+     * @throws NotteAPIError if the status request fails.
+     * @example
+     * const status = await session.status();
+     * console.log(status.status); // 'active'
      */
+    status(): Promise<AuthSessionResponse>;
+    /** Session ID while the session is active, `null` otherwise. */
     getId(): string | null;
-    /**
-     * Check if session is active
-     */
+    /** Whether the session has been started and not stopped yet. */
     isSessionActive(): boolean;
-    /**
-     * Get the last response from session operations
-     */
-    getResponse(): SessionResponse | null;
+    /** The last `SessionResponse` received from the API (start, stop or status). */
+    getResponse(): AuthSessionResponse | null;
+    /** The file storage attached to the session, when one was given. */
+    get storage(): RemoteFileStorage | undefined;
+    private requireSessionId;
+    /** Session ID of the active session, or of the last one when it was stopped. */
+    private lastSessionId;
     /**
      * Open the live viewer for this session in the local default browser.
+     * @throws If the session has not started or no viewer URL is available.
      */
     viewer(): void;
     private openViewerInBrowser;
     /**
-     * Set cookies for the session
+     * Get presigned URLs for the session replay. Recordings are finalized after
+     * the session is closed, so by default this polls on 404 until the replay is
+     * ready. It keeps working after `stop()`.
+     *
+     * Throws an `Error` when the API reports the session is still active and a
+     * `NotteTimeoutError` when the replay is not ready within `timeoutMs`.
+     * @example
+     * await session.stop();
+     * const replay = await session.replay();
+     * console.log(replay.mp4_url);
+     */
+    replay(options?: ReplayOptions): Promise<ReplayResponse>;
+    /**
+     * Download the MP4 replay to a local file, like `ReplayResponse.download()`
+     * in Python. Resolves with the absolute path of the written file and throws
+     * when the replay has no `mp4_url`.
+     *
+     * @example
+     * await session.stop();
+     * const file = await session.downloadReplay('session.mp4');
+     */
+    downloadReplay(path?: string, options?: ReplayOptions): Promise<string>;
+    /**
+     * Upload cookies to the session.
+     *
+     * @example
+     * await session.setCookies([{ name: 'token', value: 'abc', domain: 'example.com', path: '/', httpOnly: false }]);
      */
     setCookies(cookies: Cookie[]): Promise<ExecutionResponse>;
     /**
-     * Set cookies from a file
+     * Upload cookies from a JSON file (a list of cookies, like `getCookies()` returns).
+     *
+     * @example
+     * await session.setCookiesFromFile('cookies.json');
      */
     setCookiesFromFile(cookieFile: string): Promise<ExecutionResponse>;
     /**
-     * Get cookies from the session
+     * Get the cookies of the session.
+     *
+     * @example
+     * const cookies = await session.getCookies();
+     * await fs.writeFile('cookies.json', JSON.stringify(cookies));
      */
     getCookies(): Promise<Cookie[]>;
+    /** Detailed debug information for the session (debug URL, websocket URLs, tabs). */
+    debugInfo(): Promise<SessionDebugResponse>;
     /**
-     * Execute an action on the page
+     * Debug information for one tab of the session. The API client has no
+     * dedicated tab endpoint, so this reads the tab from `debugInfo().tabs`.
      */
-    execute(action: any, raiseOnFailure?: boolean): Promise<ApiExecutionResponse>;
+    debugTabInfo(tabIdx?: number): Promise<TabSessionDebugResponse>;
     /**
-     * Observe the current page state
+     * Get the Chrome DevTools Protocol WebSocket URL for the session.
+     *
+     * A `cdp_url` given at construction (another browser provider) is returned
+     * untouched. Notte-served URLs, from the start response or the debug info,
+     * carry the database preview branch when one is configured.
+     *
+     * @returns The CDP WebSocket URL for connecting a browser automation client.
+     * @throws Error if no session ID or CDP URL is available.
+     * @example
+     * const browser = await chromium.connectOverCDP(await session.cdpUrl());
      */
-    observe(perceptionType?: 'fast' | 'deep'): Promise<Observation>;
+    cdpUrl(): Promise<string>;
     /**
-     * Get session replay data
+     * Get a Playwright page connected to the session via CDP. The connection is
+     * established lazily on first access, cached, and closed by `stop()`.
+     * Native dialogs are left to the Notte backend.
+     *
+     * Requires the optional `playwright-core` peer dependency
+     * (`npm install playwright-core`).
+     *
+     * @example
+     * const page = await session.page();
+     * await page.goto('https://www.google.com');
+     * await page.screenshot({ path: 'screenshot.png' });
      */
-    replay(): Promise<any>;
+    page(): Promise<Page>;
     /**
-     * Scrape the current page
-     */
-    scrape(options?: ScrapeRequest): Promise<string | any>;
-    scrape<T>(options: ScrapeRequest & {
-        response_format: z.ZodSchema<T>;
-        json_schema?: any;
+     * Get the workflow code generated from the session steps
+     * (`GET /sessions/{id}/workflow/code`).
+     *
+     * @example
+     * const { python_script } = await session.getScript();
+     */
+    getScript(options?: SessionScriptOptions): Promise<AgentFunctionCodeResponse>;
+    /**
+     * Execute an action on the current page.
+     *
+     * When the action fails and `raiseOnFailure` is true (the default, see the
+     * session option), the structured `exception_detail` returned by the API is
+     * rehydrated into an `ActionExecutionError` whose `errorType` names the
+     * server-side error class. `captcha_solve` actions get a 100 s request
+     * timeout and are retried up to 3 times on HTTP 408.
+     *
+     * @param action - Action type, target, and action-specific arguments.
+     * @param options - Override failure handling for this call; otherwise use the session setting.
+     * @returns The execution response, including `success` and failure details when throwing is disabled.
+     * @throws ActionExecutionError if the action fails and failure throwing is enabled.
+     * @throws NotteAPIError if the API request fails.
+     * @example
+     * import { actions } from 'notte-sdk';
+     *
+     * await session.execute({ type: 'goto', url: 'https://www.notte.cc' });
+     * await session.execute(actions.fill({ selector: "input[name='email']", value: 'user@example.com' }));
+     * const result = await session.execute({ type: 'click', id: 'B1' }, { raiseOnFailure: false });
+     * if (!result.success) console.log(result.message);
+     */
+    execute(action: ExecuteAction, options?: boolean | ExecuteOptions): Promise<CaptchaExecutionResponse>;
+    /**
+     * Evaluate JavaScript on the current page and return its result as a string.
+     *
+     * The result is stringified the way `evaluate_js` records it: objects and
+     * arrays as JSON, a JS `null` as the string `"null"`. On failure the typed
+     * `ActionExecutionError` is thrown with the actual JavaScript error; pass
+     * `raiseOnFailure: false` to get the execution result envelope instead.
+     *
+     * @example
+     * const title = await session.evaluateJs('document.title');
+     * const payload = JSON.parse(await session.evaluateJs('(async () => JSON.stringify(await (await fetch("/api")).json()))()'));
+     */
+    evaluateJs(code: string, options?: {
+        raiseOnFailure?: true;
+    }): Promise<string>;
+    evaluateJs(code: string, options: {
+        raiseOnFailure: false;
+    }): Promise<ApiExecutionResponse>;
+    /**
+     * Issue an HTTP request from the page the session is on and return the response.
+     *
+     * The request runs inside the browser through `fetch()`, so it carries the
+     * page's cookies, the session's proxy and the browser's own network
+     * fingerprint. A relative `url` resolves against the current page, which
+     * also makes it same-origin; a cross-origin URL is subject to CORS exactly
+     * as in a browser tab, so `goto` the target origin first. Redirects are
+     * followed and the final URL is on `response.url`. A non-2xx status is
+     * returned, not thrown; `response.raiseForStatus()` throws `PageFetchHTTPError`.
+     *
+     * `json` is serialised as the body with an `application/json` content type,
+     * `data` as a form body when it is an object or verbatim when it is a string.
+     *
+     * @param url - Absolute URL or a path relative to the current page.
+     * @param options - HTTP method, headers, and request body settings.
+     * @returns A response with status, headers, and body readers. Non-2xx responses are not automatically thrown.
+     * @throws ActionExecutionError if browser-side execution fails.
+     * @example
+     * await session.execute({ type: 'goto', url: 'https://en.wikipedia.org/wiki/Main_Page' });
+     * const summary = await (await session.fetch('/api/rest_v1/page/summary/Main_Page')).json();
+     */
+    fetch(url: string, options?: PageFetchOptions): Promise<PageFetchResponse>;
+    /**
+     * Observe the current page: the list of actions that can be taken, a
+     * screenshot and page metadata.
+     *
+     * The `perception_type` defaults to the session option (`fast`). A bare
+     * string argument is accepted as the perception type.
+     *
+     * @param options - Observation settings, including an optional URL, or a perception-mode string.
+     * @returns Structured page analysis, available actions, and page metadata.
+     * @throws NotteAPIError if observation fails.
+     * @example
+     * const obs = await session.observe();
+     * console.log(obs.space.description);
+     * const deep = await session.observe({ perception_type: 'deep', max_nb_actions: 50 });
+     */
+    observe(options?: ObserveRequest | PerceptionType): Promise<Observation>;
+    /**
+     * Scrape the current page.
+     *
+     * With `response_format` or `instructions`, the extracted data is returned
+     * directly and a failed extraction throws `ScrapeFailedError`. Pass
+     * `raiseOnFailure: false` to receive the `StructuredData` wrapper instead.
+     * @example
+     * const markdown = await session.scrape({ only_main_content: true });
+     * const images = await session.scrape({ only_images: true });
+     * const product = await session.scrape({ response_format: Product, instructions: 'Extract the product' });
+     * const result = await session.scrape({ response_format: Product, raiseOnFailure: false });
+     * if (result.success) console.log(result.data);
+     */
+    scrape(options: SessionScrapeOptions<unknown> & {
+        only_images: true;
+    }): Promise<ImageData[]>;
+    scrape(options?: SessionScrapeOptions<unknown> & {
+        response_format?: undefined;
+        instructions?: undefined | null;
+        only_images?: false;
+    }): Promise<string>;
+    scrape<T>(options: SessionScrapeOptions<T> & {
+        response_format: ZodLikeSchema<T>;
+        raiseOnFailure?: true;
     }): Promise<T>;
+    scrape<T>(options: SessionScrapeOptions<T> & {
+        response_format: ZodLikeSchema<T>;
+        raiseOnFailure: false;
+    }): Promise<StructuredData<T>>;
+    scrape(options: SessionScrapeOptions<unknown>): Promise<ScrapeResult<unknown>>;
     /**
-     * Context manager pattern - automatically start and stop session
-     * Usage: await session.use(async (session) => { ... })
+     * Context manager pattern: start the session, run the callback and stop the
+     * session, with close reason `error` when the callback throws.
+     *
+     * Always waits for Managed Auth readiness before invoking the callback.
+     *
+     * @param callback - Async work to perform with the ready session.
+     * @param options - Controls the Managed Auth readiness wait, including timeout and cancellation.
+     * @returns The callback's return value after session cleanup has been attempted.
+     * @throws Error if startup fails, the callback throws, or cleanup fails after a successful callback.
+     * @example
+     * await client.Session().use(async session => {
+     *   await session.execute({ type: 'goto', url: 'https://www.notte.cc' });
+     * });
      */
-    use<T>(callback: (session: Session) => Promise<T>): Promise<T>;
+    use<T>(callback: (session: Session) => Promise<T>, options?: AuthWaitOptions): Promise<T>;
     /**
-     * Async iterator pattern for session lifecycle management
-     * Usage: for await (const session of sessionInstance) { ... }
+     * Async iterator pattern for session lifecycle management.
+     *
+     * ```ts
+     * for await (const session of client.Session()) {
+     *   await session.execute({ type: 'goto', url: 'https://www.notte.cc' });
+     * }
+     * ```
      */
     [Symbol.asyncIterator](): AsyncGenerator<this, void, unknown>;
 }
@@ -11059,12 +12507,67 @@ declare class Session {
 interface VaultConstructorWithId {
     vault_id: string;
 }
-interface VaultConstructorCreate extends Omit<VaultCreateRequest, never> {
+interface VaultConstructorCreate extends VaultCreateRequest {
     vault_id?: never;
 }
 type VaultConstructor = VaultConstructorWithId | VaultConstructorCreate;
+/** Credential fields read by `addCredentialsFromEnv`, in the order Python's `CredentialField.registry` declares them. */
+declare const CREDENTIAL_FIELDS: readonly ["email", "username", "mfa_secret", "password"];
+type CredentialField = (typeof CREDENTIAL_FIELDS)[number];
+/**
+ * Get the root domain of a URL, the counterpart of `notte_core.utils.url.get_root_domain`.
+ * Returns an empty string when no domain can be extracted.
+ *
+ * ```ts
+ * getRootDomain('https://www.example.com/path'); // 'example.com'
+ * getRootDomain('https://test.peeple.com/ok'); // 'peeple.com'
+ * getRootDomain('https://shop.example.co.uk'); // 'example.co.uk'
+ * ```
+ */
+declare function getRootDomain(url: string): string;
+/**
+ * Normalise a credential URL to its root domain, the counterpart of
+ * `notte_sdk.types.validate_url`. Throws `InvalidRequestError` when the URL
+ * has no domain name.
+ *
+ * ```ts
+ * validateUrl('https://github.com/login'); // 'github.com'
+ * validateUrl('https://'); // throws InvalidRequestError
+ * ```
+ */
+declare function validateUrl(url: string): string;
+/**
+ * Check that a string is a base32 TOTP secret, with the padding rules Python's
+ * `pyotp.TOTP(secret).now()` applies (`base64.b32decode` after right-padding
+ * the secret to a multiple of eight characters).
+ */
+declare function isValidMfaSecret(secret: string): boolean;
 /**
- * Vault that fetches credentials stored using the SDK - mirrors Python NotteVault class
+ * Validate an MFA secret like `AddCredentialsRequest.check_email_and_username`
+ * in Python. Rejects one-time codes (`999777`) and anything that is not base32.
+ */
+declare function validateMfaSecret(secret: string): void;
+/**
+ * Apply the client-side rules of Python's `AddCredentialsRequest`: exactly one
+ * of `username` / `email`, and a base32 `mfa_secret` when one is provided.
+ * Returns the credentials unchanged.
+ */
+declare function validateCredentials(credentials: CredentialsDictInput): CredentialsDictInput;
+/**
+ * Vault that fetches credentials stored using the SDK, the counterpart of
+ * `notte_sdk.endpoints.vaults.NotteVault`.
+ *
+ * The remote vault is created lazily on the first API operation so local-only
+ * helpers such as `generatePassword()` stay side-effect free. Every API
+ * failure rejects with a `NotteAPIError`; caller mistakes (invalid URL,
+ * one-time code stored as an MFA secret, ...) reject with `InvalidRequestError`.
+ * // pragma: allowlist secret
+ * ```ts
+ * const vault = client.Vault({ name: 'My vault' });
+ * await vault.addCredentials('https://github.com/', { email: 'me@example.org', password: 'secret' }); // pragma: allowlist secret
+ * const credentials = await vault.getCredentials('https://github.com/login');
+ * await vault.stop(); // deletes the vault and every credential it holds
+ * ```
  */
 declare class NotteVault {
     private client;
@@ -11076,64 +12579,98 @@ declare class NotteVault {
     private initNewVault;
     private verifyVaultExists;
     private ensureInitialized;
+    /** ID of the remote vault. Throws until the first API operation has created or verified it. */
     get vaultId(): string;
     /**
-     * Start the vault - no-op for compatibility with Python interface
+     * Start the vault. No-op kept for parity with Python's `SyncResource` interface.
      */
     start(): void;
     /**
-     * Stop the vault - deletes it and all credentials
+     * Stop the vault: deletes it together with every credential it holds.
+     *
+     * ```ts
+     * await vault.stop();
+     * ```
      */
     stop(): Promise<void>;
     /**
-     * Add or update credentials for a URL
+     * Add or update the credentials stored for a website. The URL is reduced to
+     * its root domain (`https://github.com/login` → `github.com`) before it is
+     * sent, like Python's `AddCredentialsRequest`.
+     *
+     * ```ts
+     * await vault.addCredentials('https://github.com/', {
+     *   email: 'me@example.org',
+     *   password: 'secret', // pragma: allowlist secret
+     *   mfa_secret: 'JBSWY3DPEHPK3PXP', // pragma: allowlist secret
+     * });
+     * ```
      */
     addCredentials(url: string, credentials: CredentialsDictInput): Promise<void>;
     /**
-     * Get credentials for a URL
-     */
-    getCredentials(url: string): Promise<CredentialsDictInput | null>;
-    /**
-     * Delete credentials for a URL
+     * Get the credentials stored for a website. Rejects with a `NotteAPIError`
+     * when the vault holds no credentials for that domain, like Python's
+     * `get_credentials`.
+     *
+     * ```ts
+     * const { email, password } = await vault.getCredentials('https://github.com/login');
+     * ```
      */
-    deleteCredentials(url: string): Promise<void>;
+    getCredentials(url: string): Promise<CredentialsDictOutput>;
     /**
-     * Set credit card information
+     * Check whether the vault holds credentials for a website, the counterpart
+     * of `BaseVault.has_credential`. Never rejects for a missing credential.
+     *
+     * ```ts
+     * if (!(await vault.hasCredential('https://github.com/'))) {
+     *   await vault.addCredentialsFromEnv('https://github.com/');
+     * }
+     * ```
      */
-    setCreditCard(creditCard: CreditCardDictInput): Promise<void>;
+    hasCredential(url: string): Promise<boolean>;
     /**
-     * Get credit card information
+     * Delete the credentials stored for a website.
+     *
+     * ```ts
+     * await vault.deleteCredentials('https://github.com/');
+     * ```
      */
-    getCreditCard(): Promise<CreditCardDictInput>;
+    deleteCredentials(url: string): Promise<void>;
     /**
-     * List all credentials in the vault
+     * List the websites the vault holds credentials for. Passwords are never returned.
+     *
+     * ```ts
+     * const credentials = await vault.listCredentials();
+     * console.log(credentials.map(c => c.url));
+     * ```
      */
     listCredentials(): Promise<Credential[]>;
     /**
-     * Delete credit card information
-     */
-    deleteCreditCard(): Promise<void>;
-    /**
-     * Delete the entire vault
+     * Delete the vault and every credential it holds.
      */
     delete(): Promise<void>;
     /**
-     * Add credentials from environment variables
-     * Mirrors Python's add_credentials_from_env method
+     * Add credentials read from environment variables, the counterpart of
+     * `BaseVault.add_credentials_from_env`. For `https://github.com/` the
+     * variables are `GITHUB_COM_EMAIL`, `GITHUB_COM_USERNAME`,
+     * `GITHUB_COM_MFA_SECRET` and `GITHUB_COM_PASSWORD`.
+     *
+     * ```ts
+     * process.env.GITHUB_COM_EMAIL = 'me@example.org';
+     * process.env.GITHUB_COM_PASSWORD = 'secret'; // pragma: allowlist secret
+     * await vault.addCredentialsFromEnv('https://github.com/');
+     * ```
      */
     addCredentialsFromEnv(url: string): Promise<void>;
     /**
-     * Extract domain from URL for environment variable naming
-     */
-    private extractDomainFromUrl;
-    /**
-     * Validate MFA secret format
-     * Mirrors Python's MFA secret validation
-     */
-    private validateMfaSecret;
-    /**
-     * Generate a secure random password
-     * Mirrors Python's generate_password method
+     * Generate a secure random password, the counterpart of Python's
+     * `generate_password`. The result always contains a lowercase letter, an
+     * uppercase letter and a digit, plus a special character unless
+     * `includeSpecialChars` is false.
+     *
+     * ```ts
+     * const password = vault.generatePassword(24);
+     * ```
      */
     generatePassword(length?: number, includeSpecialChars?: boolean): string;
 }
@@ -11167,6 +12704,7 @@ declare class NottePersona {
     private response;
     private initPromise;
     private _vault;
+    private readonly ownsPersona;
     constructor(client: NotteClient, options?: PersonaConstructor);
     /**
      * Get persona info
@@ -11232,11 +12770,24 @@ declare class NottePersona {
      */
     get(): Promise<PersonaResponseWithInternalEmail>;
     /**
-     * Context manager for automatic cleanup
+     * Run a callback and automatically delete a persona created by this instance.
+     * Personas loaded by an existing ID are retained after the callback finishes.
      */
     use<T>(callback: (persona: NottePersona) => Promise<T>): Promise<T>;
 }
 
+/**
+ * If `response_format` is a Zod schema, convert it to JSON Schema for the API
+ * and return the schema for later runtime validation of the agent's answer.
+ * Mirrors the Zod handling on `session.scrape()`.
+ */
+declare function prepareAgentRequest<T = unknown>(data: AgentRunRequest & {
+    response_format?: z.ZodSchema<T> | unknown | null;
+}): {
+    apiData: AgentRunRequest;
+    zodSchema: z.ZodSchema<T> | null;
+};
+declare function parseAgentStatusMessage(parsed: any, agentId: string): LegacyAgentStatusResponse | null;
 interface AgentConstructorWithSession extends Omit<ApiAgentStartRequest, 'session_id' | 'vault_id' | 'persona_id' | 'task' | 'response_format' | 'url'> {
     session: Session;
     vault?: NotteVault;
@@ -11307,7 +12858,7 @@ declare class Agent {
     /**
      * Get agent status - mirrors Python status method
      */
-    status(): Promise<LegacyAgentStatusResponse>;
+    status(signal?: AbortSignal): Promise<LegacyAgentStatusResponse>;
     /**
      * Stop the agent - mirrors Python stop method
      */
@@ -11325,134 +12876,592 @@ declare class Agent {
      */
     get sessionId(): string;
     /**
-     * Check if agent is running - convenience method
+     * Whether `start()`/`run()` was called on this instance (or it was built from an agent id).
+     * This is a local check and does not contact the API.
+     */
+    hasStarted(): boolean;
+    /**
+     * Whether the agent is still active on the server. Fetches the current status,
+     * like calling `agent.status()` in Python; an agent that was never started is not active.
+     */
+    isActive(): Promise<boolean>;
+    /**
+     * @deprecated Only reports whether this instance was started; it does not
+     * contact the API. Use `hasStarted()` for that check or `isActive()` for the
+     * live server status.
      */
     isRunning(): boolean;
 }
 
-/** Select extended for longer cloud execution. Defaults to standard (Lambda). */
-type FunctionRunOptions = Pick<RunFunctionRequest, 'runtime'>;
-interface FunctionRunStartResult {
+/** Default deadline of `run()`, the counterpart of `WorkflowsClient.WORKFLOW_RUN_TIMEOUT` (5 minutes). */
+declare const FUNCTION_RUN_TIMEOUT_MS: number;
+/**
+ * Run endpoints that the OpenAPI spec does not describe. They are the Python
+ * SDK's `WorkflowsClient.CREATE_WORKFLOW_RUN` and `START_WORKFLOW_RUN` paths
+ * and are only ever called through `NotteFunction.postRunEndpoint()`.
+ */
+declare const FUNCTION_RUN_ENDPOINTS: {
+    /** `POST` creates a run record without executing it (`CreateFunctionRunRequest`). */
+    readonly create: "/functions/{function_id}/runs/create";
+    /** `POST` executes a previously created run (`StartFunctionRunRequest`). */
+    readonly start: "/functions/{function_id}/runs/{run_id}";
+};
+/**
+ * The run endpoints hand the caller's key to the execution runtime through
+ * this header (the `Authorization` header is not forwarded), so `run()` sends
+ * it whenever the client holds a key, like `WorkflowsClient.run` in Python.
+ * Proxy-mode clients have no key; their proxy must add the header itself.
+ */
+declare const RUN_API_KEY_HEADER = "x-notte-api-key";
+type FunctionRuntime = NonNullable<RunFunctionRequest['runtime']>;
+type FunctionRunStatus = GetFunctionRunResponse['status'];
+/** Reference an existing function by ID. */
+interface FunctionConstructorWithId {
+    function_id: string;
+    /** Key used to decrypt the download URL of Notte managed functions. */
+    decryption_key?: string;
+    path?: never;
+}
+/**
+ * Create a function from a local `.py` file, like `client.Function(path=...)`
+ * in Python. The upload happens on the first operation that needs the ID.
+ */
+interface FunctionConstructorCreate {
+    /** Path to the python file containing the `run` function. Must end with `.py`. */
+    path: string;
+    name?: string | null;
+    description?: string | null;
+    /** Whether the function is public and shared with other users. Defaults to false. */
+    shared?: boolean;
+    decryption_key?: string;
+    function_id?: never;
+}
+type FunctionConstructor = FunctionConstructorWithId | FunctionConstructorCreate;
+/** Result of executing a run, the counterpart of `FunctionRunResponse` in Python. */
+interface FunctionRunResult {
+    function_id: string;
     function_run_id: string;
-    [key: string]: unknown;
+    session_id: string | null;
+    /** The value returned by the script's `run` function, decoded from JSON. */
+    result: unknown;
+    status: FunctionRunStatus;
 }
-interface FunctionConstructor {
+/** Alias of `FunctionRunResult` using the Python model name. */
+type FunctionRunResponse = FunctionRunResult;
+/** @deprecated `run()` now returns `FunctionRunResult` whether or not it streams. */
+type FunctionRunStartResult = FunctionRunResult;
+/** Run record returned by `createRun()`, the counterpart of `CreateFunctionRunResponse` in Python. */
+interface FunctionRunCreateResult {
     function_id: string;
-    decryption_key?: string;
+    function_run_id: string;
+    created_at: string;
+    status: 'created';
 }
-interface FunctionUrlOptions {
-    /** Version to download. Defaults to the latest version. */
+interface FunctionRunCreateOptions {
+    /** Mark the record as a local run. Defaults to false; the Node SDK only executes on the cloud. */
+    local?: boolean;
+}
+interface FunctionRunOptions {
+    /** Stream logs and wait for completion. Defaults to true. */
+    stream?: boolean;
+    /** Receive streamed logs instead of printing them to console.log. */
+    onLog?: (message: string) => void;
+    /** Throw `FailedToRunCloudFunctionError` when execution fails. Defaults to true, matching Python. */
+    raiseOnFailure?: boolean;
+    /** Execute a record returned by createRun(). Omit to create a new run. */
+    functionRunId?: string;
+    /** Override the saved function runtime; omit to inherit its default. */
+    runtime?: FunctionRuntime;
+    /**
+     * Deadline of the whole execution in milliseconds. The wait is aborted with
+     * `NotteTimeoutError` once it elapses. Defaults to `FUNCTION_RUN_TIMEOUT_MS` (5 minutes).
+     */
+    timeoutMs?: number;
+}
+interface FunctionGetOptions {
+    /** Version to fetch. Defaults to the latest version. */
     version?: string;
+}
+interface FunctionUrlOptions extends FunctionGetOptions {
     /** Overrides the decryption key passed to the constructor. */
     decryption_key?: string;
 }
 interface FunctionDownloadOptions extends FunctionUrlOptions {
-    /** Where to write the code. Must end with `.py`. Returned only when omitted. */
+    /** Optional local destination ending in `.py`. Source text is returned whether or not a path is supplied. */
+    path?: string;
+}
+interface FunctionUpdateOptions {
+    /** Path to the new python code. Must end with `.py`. */
     path?: string;
+    /** Only update this version. Defaults to creating a new version. */
+    version?: string;
+    /** Whether to restrict the function code. Defaults to true, like Python. */
+    restricted?: boolean;
+}
+/** Metadata fields accepted by `PATCH /functions/{function_id}`. */
+type FunctionMetadataUpdateOptions = FunctionMetadataUpdateRequest;
+interface FunctionScheduleOptions {
+    /** Cron expression of the schedule. */
+    cron: FunctionScheduleCreateRequest['cron'];
+    /** Variables passed to every scheduled run. */
+    variables?: FunctionScheduleCreateRequest['variables'];
+}
+interface FunctionRollbackOptions extends FunctionRollbackRequest {
+    /** Whether to restrict the function code. Defaults to true, like `update()`. */
+    restricted?: boolean;
 }
 /**
  * Query options for listing a function's runs: `page`, `page_size`,
- * `only_active`, `only_current_token`, `include_system`.
+ * `only_active`, `only_current_token`, `include_system`, `source`.
  */
 type FunctionRunListOptions = NonNullable<ListFunctionRunsByFunctionIdData['query']>;
 /**
- * Function class for managing function runs
+ * Cloud function saved in the Notte console, the counterpart of
+ * `notte.Function` in Python.
+ *
+ * ```ts
+ * const fn = client.NotteFunction({ function_id: '<your-function-id>' });
+ * const result = await fn.run({ url: 'https://example.com' });
+ *
+ * const created = client.NotteFunction({ path: './scraper.py', name: 'Scraper' });
+ * await created.run(); // uploads scraper.py first
+ * ```
  */
 declare class NotteFunction {
-    private client;
-    readonly functionId: string;
+    private readonly client;
+    private _functionId;
+    private initPromise;
+    private createData;
     readonly decryptionKey?: string;
     constructor(client: NotteClient, options: FunctionConstructor);
+    /** The function ID. Throws before a `path`-constructed function has been uploaded. */
+    get functionId(): string;
+    /** Alias of the `functionId` accessor. */
+    getFunctionId(): string;
+    private ensureInitialized;
+    private createFunction;
+    /**
+     * Get the function metadata together with its download URL, the
+     * counterpart of `client.functions.get()` in Python.
+     *
+     * @param options - Optional version selector; omitted means the latest version.
+     * @returns Function metadata, version history, and the download link returned by the API.
+     * @throws NotteAPIError if the function cannot be retrieved.
+     * @example
+     * const { latest_version, versions } = await fn.get();
+     */
+    get(options?: FunctionGetOptions): Promise<FunctionWithLinkResponse>;
+    /**
+     * Upload a new version of the code, mirroring `function.update(path=...)`.
+     *
+     * @param options - Local Python file path, optional version, and code-access settings.
+     * @returns Updated function metadata, including its latest version.
+     * @throws InvalidRequestError if the path is missing or does not end in `.py`.
+     * @throws NotteAPIError if the upload is rejected.
+     * @example
+     * const updated = await fn.update({ path: './scraper.py' });
+     * console.log(updated.latest_version);
+     */
+    update(options: FunctionUpdateOptions): Promise<FunctionResponse>;
+    /**
+     * Update the function metadata (name, description, default runtime, ...).
+     *
+     * @param options - Metadata fields to update, such as name, description, or default runtime.
+     * @returns Updated function metadata.
+     * @throws NotteAPIError if the metadata update is rejected.
+     * @example
+     * await fn.updateMetadata({ name: 'Price monitor', default_runtime: 'extended' });
+     */
+    updateMetadata(options: FunctionMetadataUpdateOptions): Promise<FunctionResponse>;
+    /**
+     * Delete the function from the Notte console.
+     *
+     * @returns The API's function-deletion confirmation.
+     * @throws NotteAPIError if the function cannot be deleted.
+     * @example
+     * await fn.delete();
+     */
+    delete(): Promise<DeleteFunctionResponse>;
+    /**
+     * Schedule the function to run on a cron expression.
+     *
+     * @param options - Cron expression and optional variables passed to each scheduled execution.
+     * @returns The saved schedule configuration.
+     * @throws NotteAPIError if the schedule cannot be saved.
+     * @example
+     * await fn.setSchedule({ cron: '0 9 * * *', variables: { url: 'https://example.com' } });
+     */
+    setSchedule(options: FunctionScheduleOptions): Promise<ScheduleResponse>;
+    /**
+     * Remove the function schedule.
+     *
+     * @returns The API's schedule-deletion confirmation.
+     * @throws NotteAPIError if schedule deletion fails.
+     * @example
+     * await fn.deleteSchedule();
+     */
+    deleteSchedule(): Promise<ScheduleDeleteResponse>;
+    /**
+     * Roll the function back to a previous version.
+     *
+     * @param options - Target version and optional code-access restriction, which defaults to true.
+     * @returns Updated function metadata after rollback.
+     * @throws NotteAPIError if the requested version cannot be restored.
+     * @example
+     * const { versions } = await fn.get();
+     * await fn.rollback({ version: versions[0] });
+     */
+    rollback(options: FunctionRollbackOptions): Promise<FunctionResponse>;
+    /**
+     * Get metadata for a specific function run.
+     *
+     * @param functionRunId - ID of a run belonging to this function.
+     * @returns The run's current status, logs, and result metadata. This does not wait for completion.
+     * @throws NotteAPIError if the run cannot be retrieved.
+     * @example
+     * const run = await fn.getRun(result.function_run_id);
+     * console.log(run.status, run.logs);
+     */
+    getRun(functionRunId: string): Promise<GetFunctionRunResponse>;
     /**
-     * Get metadata for a specific function run
+     * Compatibility alias for getRun().
+     * @deprecated Use getRun() instead. Retained for backwards compatibility.
      */
     retrieve(functionRunId: string): Promise<GetFunctionRunResponse>;
+    /**
+     * Create a cloud run record without starting execution, like
+     * `function.create_run()` in Python. Use this only when you need the ID
+     * before execution, then pass it to `run(variables, { functionRunId })`.
+     * `run()` otherwise creates a new run on its own.
+     *
+     * @param options - Run-record settings; `local` defaults to false. Node execution remains cloud-only.
+     * @returns A created run record and its ID. No function code has executed yet.
+     * @throws NotteAPIError if run creation is rejected.
+     * @example
+     * const created = await fn.createRun();
+     * const result = await fn.run({ url: 'https://example.com' }, { functionRunId: created.function_run_id });
+     */
+    createRun(options?: FunctionRunCreateOptions): Promise<FunctionRunCreateResult>;
     /**
      * List the runs of this function.
      *
-     * `only_active` is sent as `false` unless the caller says otherwise, and that
-     * is deliberate rather than redundant. `GET /functions/{function_id}/runs`
-     * now defaults it to `false` server-side as well, but it used to default to
-     * `true`: the request model was a bare subclass of the session one, where
-     * "only active" reads sensibly as "list my running sessions" and, for "list
-     * this function's runs", was a trap. Hitting the endpoint with no query
-     * parameters returned only the runs executing right now - an empty list for
-     * any function that had finished. That cost us a bug in the anything-api
-     * console, where a function with 15 recorded runs displayed "Nothing has run
-     * this endpoint yet".
-     *
-     * Sending it explicitly pins this method to the documented behaviour against
-     * whichever API version it is talking to, including deployments that predate
-     * the server-side change. Callers who want only in-flight runs pass
-     * `only_active: true`.
+     * Includes completed runs by default. Set `only_active: true` to retrieve
+     * only in-flight runs. Use the response pagination metadata to request
+     * additional pages.
+     *
+     * @param options - Pagination and filtering options. `only_active` defaults to false, including completed runs.
+     * @returns One page of run records and pagination metadata; additional pages require another call.
+     * @throws NotteAPIError if the run history cannot be retrieved.
+     * @example
+     * const { items } = await fn.runs({ page_size: 20 });
      */
     runs(options?: FunctionRunListOptions): Promise<PaginatedResponseFunctionRunListItemResponse>;
     /**
-     * Start a function run
+     * Run the function on the cloud and wait for its result, streaming logs by
+     * default like `function.run(**variables)` in Python.
+     *
+     * Pass `{ stream: false }` to receive the backend's JSON response without
+     * live logs; execution still blocks until completion. Pass `functionRunId`
+     * to execute a record returned by `createRun()`; otherwise a new run record
+     * is created first, exactly like Python. A failed execution throws
+     * `FailedToRunCloudFunctionError` unless `raiseOnFailure` is false, and the
+     * wait is aborted with `NotteTimeoutError` after `timeoutMs`.
+     *
+     * @param variables - JSON-serializable keyword arguments passed to the Python function's `run` entry point.
+     * @param options - Log streaming, failure handling, runtime, run ID, and timeout settings.
+     * @returns The completed execution response. The function's return value is in `result`. Disabling streaming still waits for completion.
+     * @throws FailedToRunCloudFunctionError if execution fails and `raiseOnFailure` is true.
+     * @throws NotteTimeoutError if the execution request exceeds `timeoutMs`.
+     * @throws InvalidRequestError if the run options are invalid.
+     * @example
+     * const result = await fn.run({ url: 'https://example.com' });
+     * console.log(result.result);
+     *
+     * await fn.run({ url: 'https://example.com' }, { runtime: 'extended', onLog: line => logger.info(line) });
      */
-    run(variables?: Record<string, unknown>, options?: FunctionRunOptions): Promise<FunctionRunStartResult>;
+    run(variables?: Record<string, unknown>, options?: FunctionRunOptions): Promise<FunctionRunResult>;
     /**
      * Get the download URL of the function code, decrypting it when the API
      * returns an encrypted one (Notte managed functions).
+     *
+     * @param options - Optional version and decryption-key override.
+     * @returns An HTTP(S) URL for downloading the function source.
+     * @throws InvalidRequestError if an encrypted URL has no usable decryption key.
+     * @throws NotteError if decryption does not produce an HTTP(S) URL.
+     * @example
+     * const url = await fn.getUrl({ version: 'v1' });
      */
     getUrl(options?: FunctionUrlOptions): Promise<string>;
     /**
      * Download the function code as a python file. Returns the code, and writes
      * it to `path` when one is provided.
+     *
+     * @param options - Optional version, decryption key, and local `.py` destination path.
+     * @returns The Python source text, including when a local destination is supplied.
+     * @throws InvalidRequestError if the destination does not end in `.py` or the decryption key is invalid.
+     * @throws NotteError if the source download fails. Local filesystem failures also propagate.
+     * @example
+     * const code = await fn.download({ path: './scraper.py' });
      */
     download(options?: FunctionDownloadOptions): Promise<string>;
     /**
-     * Get the function ID
+     * Call one of the run endpoints that the OpenAPI spec does not describe
+     * (`FUNCTION_RUN_ENDPOINTS`). The generated client has no operation for
+     * them, so this is the single place where they are hand-rolled; the request
+     * and response shapes are transcribed from `notte_sdk.types`
+     * (`CreateFunctionRunRequest` / `CreateFunctionRunResponse` and
+     * `StartFunctionRunRequest` / `FunctionRunResponse`). Replace the callers
+     * with generated operations once the spec exposes these paths.
      */
-    getFunctionId(): string;
+    private postRunEndpoint;
 }
 
-type FileSource = 'user_upload' | 'session_download';
-type SessionFile = {
-    id: string;
-    session_id: string;
-    filename: string;
-    mime_type: string;
-    size: number;
-    checksum: string;
-    created_at: string;
-    expires_at: string;
-    source: FileSource;
-};
-type SessionFilesPage = {
-    files: SessionFile[];
-    total: number;
-    limit: number;
-    offset: number;
-};
-declare class SessionFiles {
+/**
+ * Options of `client.search()`: the `POST /search` body minus the query
+ * itself (`q`). Extra fields such as `maxResults` or `includeDomains` are
+ * forwarded to the search provider untouched.
+ */
+type SearchOptions = Omit<SearchRequest, 'q'>;
+/** One ranked hit of a `searchResults` search. */
+interface SearchResultItem {
+    url: string;
+    name: string;
+    content: string;
+    [key: string]: unknown;
+}
+/** Response of a search with `outputType: 'searchResults'` (the default). */
+interface SearchResultsResponse {
+    results: SearchResultItem[];
+    [key: string]: unknown;
+}
+/** One supporting source of a `sourcedAnswer` search. */
+interface SearchSource {
+    url: string;
+    name?: string;
+    snippet?: string;
+    [key: string]: unknown;
+}
+/** Response of a search with `outputType: 'sourcedAnswer'`. */
+interface SearchSourcedAnswerResponse {
+    answer: string;
+    sources: SearchSource[];
+    [key: string]: unknown;
+}
+/** Response of a search with `outputType: 'structured'`: the caller-provided schema decides the shape. */
+type SearchStructuredResponse = Record<string, unknown>;
+/**
+ * Union of every shape `POST /search` can answer with. The OpenAPI spec leaves
+ * the response untyped; these interfaces follow the documented shapes at
+ * https://docs.notte.cc/concepts/search#response-shapes.
+ */
+type SearchResponse = SearchResultsResponse | SearchSourcedAnswerResponse | SearchStructuredResponse;
+
+/** Body of `POST /anything/start`: the natural-language description of the task. */
+type AnythingStartOptions = AnythingStartRequest;
+/**
+ * Response of `POST /anything/start`. The OpenAPI spec declares the 200
+ * response as an untyped JSON object (`{}`), so the SDK exposes it as an
+ * opaque record. In practice the Anything API answers with a reference to the
+ * function it built for the task (for example a `function_id`), which can then
+ * be run through `client.NotteFunction({ function_id })`. Check the keys at
+ * runtime rather than relying on a fixed shape.
+ */
+type AnythingStartResponse = Record<string, unknown>;
+/**
+ * Anything API, the counterpart of `POST /anything/start`: turn a plain-English
+ * description of a web task into a deployed, reusable function.
+ *
+ * ```ts
+ * const started = await client.anything.start({ task: 'fetch the top 3 hacker news posts' });
+ * console.log(started);
+ * ```
+ */
+declare class NotteAnything {
     private readonly client;
-    private readonly sessionId;
-    constructor(client: Client, sessionId: string);
-    private path;
-    upload(file: Blob, filename?: string): Promise<SessionFile>;
-    list(options?: {
-        source?: FileSource;
-        limit?: number;
-        offset?: number;
-    }): Promise<SessionFilesPage>;
-    download(fileId: string): Promise<Blob>;
-    delete(fileId: string): Promise<void>;
+    constructor(client: NotteClient);
+    /**
+     * Start building a function for `task`. Building is slow (minutes) and
+     * billable; prefer the marketplace (`client.functions.list()`) when a
+     * ready-made function already fits.
+     *
+     * ```ts
+     * const result = await client.anything.start({ task: 'get the weather in Paris' });
+     * if (typeof result.function_id === 'string') {
+     *   const fn = client.NotteFunction({ function_id: result.function_id });
+     * }
+     * ```
+     *
+     * Rejects with a `NotteAPIError` when the API answers with a non-2xx status.
+     */
+    start(body: AnythingStartOptions): Promise<AnythingStartResponse>;
 }
 
+/** Options of `client.secrets.list()`: optionally filter by namespace. */
+type SecretListOptions = NonNullable<ListSecretsData['query']>;
+/** Body of `client.secrets.store()`. */
+type SecretStoreOptions = SecretStoreRequest;
+
+/**
+ * Workspace secrets store, the counterpart of the `/secrets` endpoints.
+ * Secrets are scoped by namespace: `llm_provider` keys are used by agents and
+ * scraping, `function_env` values are injected into function runs.
+ *
+ * ```ts
+ * await client.secrets.store({ namespace: 'function_env', name: 'MY_TOKEN', value: 'xyz' });
+ * const secrets = await client.secrets.list({ namespace: 'function_env' });
+ * ```
+ */
+declare class NotteSecrets {
+    private readonly client;
+    constructor(client: NotteClient);
+    /**
+     * List secret metadata (never the values), optionally filtered by namespace.
+     *
+     * ```ts
+     * const secrets = await client.secrets.list({ namespace: 'llm_provider' });
+     * secrets.forEach(s => console.log(s.name, s.key_hint));
+     * ```
+     */
+    list(options?: SecretListOptions): Promise<SecretMetadata[]>;
+    /**
+     * Store (or overwrite) a secret and return its metadata.
+     *
+     * ```ts
+     * const meta = await client.secrets.store({ namespace: 'function_env', name: 'API_TOKEN', value: 'xyz' });
+     * console.log(meta.id, meta.key_hint);
+     * ```
+     */
+    store(body: SecretStoreOptions): Promise<SecretMetadata>;
+    /**
+     * Read the value of a secret by name within a namespace.
+     *
+     * ```ts
+     * const { value } = await client.secrets.get('API_TOKEN', 'function_env');
+     * ```
+     */
+    get(name: string, namespace: SecretNamespace): Promise<SecretValueResponse>;
+    /**
+     * Delete a secret by id (the `id` field of `SecretMetadata`).
+     *
+     * ```ts
+     * const meta = await client.secrets.store({ namespace: 'function_env', name: 'TMP', value: 'x' });
+     * await client.secrets.delete(meta.id);
+     * ```
+     */
+    delete(secretId: string): Promise<void>;
+}
+
+/** Options of `client.usage.get()`: the monthly period, e.g. `"May 2025"`. Defaults to the current month. */
+type UsageOptions = NonNullable<GetUsageData['query']>;
+/** Options of `client.usage.logs()`: endpoint filter and pagination. */
+type UsageLogsOptions = NonNullable<GetUsageLogsData['query']>;
+/** Endpoint names accepted by `UsageLogsOptions.endpoint`. */
+type UsageLogEndpoint = NonNullable<UsageLogsOptions['endpoint']>;
+
+/**
+ * Usage and billing, the counterpart of `GET /usage` and `GET /usage/logs`.
+ *
+ * ```ts
+ * const usage = await client.usage.get();
+ * console.log(usage.total_cost, usage.balance_amount);
+ * ```
+ */
+declare class NotteUsage {
+    private readonly client;
+    constructor(client: NotteClient);
+    /**
+     * Usage summary for a monthly period (current month by default).
+     *
+     * ```ts
+     * const usage = await client.usage.get({ period: 'May 2025' });
+     * console.log(`${usage.session_count} sessions, $${usage.total_cost}`);
+     * ```
+     */
+    get(options?: UsageOptions): Promise<UsageResponse>;
+    /**
+     * Paginated per-request usage logs, optionally filtered by endpoint.
+     *
+     * ```ts
+     * const page = await client.usage.logs({ endpoint: 'sessions.start', page: 1, page_size: 50 });
+     * page.items.forEach(log => console.log(log.created_at, log.endpoint, log.duration_ms));
+     * ```
+     */
+    logs(options?: UsageLogsOptions): Promise<PaginatedResponseUsageLog>;
+}
+
+declare const DEFAULT_NOTTE_API_URL = "https://api.notte.cc";
+declare const DEFAULT_REQUEST_TIMEOUT_MS = 60000;
+/**
+ * Per-call header read by the client's request interceptor to override the
+ * default request timeout. `0` disables the timeout (streaming responses).
+ * The header is stripped before the request leaves the process.
+ */
+declare const TIMEOUT_HEADER = "x-notte-timeout-ms";
 interface NotteClientConfig {
+    /** API base URL. Defaults to `NOTTE_API_URL` or `https://api.notte.cc`. */
     baseUrl?: string;
+    /** API key. Defaults to `NOTTE_API_KEY`. Optional only for relative proxy base URLs. */
     apiKey?: string;
+    /** Default per-request timeout in milliseconds. Defaults to 60 000, like the Python SDK. */
+    timeoutMs?: number;
+    /** Maximum CAPTCHA wait in seconds, separate from each HTTP timeout. Defaults to 180. */
+    captchaTimeoutSeconds?: number;
+    /** Database preview branch. Defaults to `NOTTE_DB_PREVIEW_BRANCH`. Internal. */
+    dbPreview?: string;
+    /** Log every request like `NotteClient(verbose=True)` in Python. */
+    verbose?: boolean;
 }
+type SessionListOptions = NonNullable<ListSessionsData['query']>;
+type AgentListOptions = NonNullable<ListAgentsData['query']>;
+type VaultListOptions = NonNullable<ListVaultsData['query']>;
+type FunctionListOptions = NonNullable<ListFunctionsData['query']>;
+/** Options of `client.scrape()`: the global scrape request minus `url`, plus the SDK-only scrape options. */
+type GlobalScrapeOptions<T = unknown> = Omit<GlobalScrapeRequest, 'url' | 'response_format' | 'wait_for_authentication'> & ScrapeOptions<T> & {
+    /** Whether to wait for Managed Auth before the scrape request completes. Defaults to true. Authentication failure or timeout can fail the scrape request. */
+    wait_for_authentication?: boolean;
+};
+/** Entry point for sessions, agents, functions, vaults, personas, and session files. */
 declare class NotteClient {
-    private config;
+    private readonly config;
+    private readonly client;
+    private readonly resources;
     constructor(config?: NotteClientConfig);
+    /**
+     * Map the raw value the generated client rejects with into a `NotteError`.
+     * HTTP failures become `NotteAPIError` (or `NotteAPIExecutionError` when the
+     * API flags them), timeouts become `NotteTimeoutError`, anything else is
+     * returned untouched.
+     */
+    private toTypedError;
+    /**
+     * Add the database preview branch to a websocket URL served by the Notte API.
+     * The websocket handshake reads the branch from the query string, so without
+     * it a preview-branch session is looked up in the default database.
+     */
+    withDbPreview(url: string): string;
+    /**
+     * Health check the Notte API. Resolves when the API answers 200 and rejects
+     * with a `NotteAPIError` (or a network error) otherwise.
+     */
+    healthCheck(): Promise<void>;
     /**
      * Create a new session
      */
     Session(options?: SessionOptions): Session;
     /** Access files owned by a specific session, including closed sessions. */
     Files(sessionId: string): SessionFiles;
+    /**
+     * File storage to attach to a session, the counterpart of `client.FileStorage()`.
+     *
+     * ```ts
+     * const storage = client.FileStorage();
+     * await client.Session({ storage }).use(async session => {
+     *   await storage.upload('./invoice.pdf');
+     *   const files = await storage.list({ source: 'session_download' });
+     * });
+     * ```
+     */
+    FileStorage(sessionId?: string): RemoteFileStorage;
     /**
      * Create a new agent
      */
@@ -11469,24 +13478,282 @@ declare class NotteClient {
      * Create or access a function
      */
     NotteFunction(options: FunctionConstructor): NotteFunction;
+    /** Alias of `NotteFunction`, matching `client.Function` in Python. */
+    Function(options: FunctionConstructor): NotteFunction;
+    /** Client-bound session API operations. `list()` retains its array return value. */
+    get sessions(): {
+        list: (options?: SessionListOptions) => Promise<AuthSessionResponse[]>;
+        authReadiness: (sessionId: SessionAuthReadinessData["path"]["session_id"], requestOptions?: ResourceRequestOptions & {
+            headers?: Omit<NonNullable<SessionAuthReadinessData["headers"]>, "x-notte-api-key">;
+        }) => Promise<ManagedAuthReadiness>;
+        createPayment: (sessionId: CreatePaymentData["path"]["session_id"], body: CreatePaymentData["body"], query: CreatePaymentData["query"], requestOptions: ResourceRequestOptions & {
+            headers: Omit<NonNullable<CreatePaymentData["headers"]>, "x-notte-api-key">;
+        }) => Promise<PaymentResponse>;
+        debugInfo: (sessionId: SessionDebugInfoData["path"]["session_id"], query?: SessionDebugInfoData["query"], requestOptions?: ResourceRequestOptions & {
+            headers?: Omit<NonNullable<SessionDebugInfoData["headers"]>, "x-notte-api-key">;
+        }) => Promise<SessionDebugResponse>;
+        deleteSessionFile: (sessionId: DeleteSessionFileData["path"]["session_id"], fileId: DeleteSessionFileData["path"]["file_id"], requestOptions?: ResourceRequestOptions & {
+            headers?: Omit<NonNullable<DeleteSessionFileData["headers"]>, "x-notte-api-key">;
+        }) => Promise<void>;
+        downloadSessionFile: (sessionId: DownloadSessionFileData["path"]["session_id"], fileId: DownloadSessionFileData["path"]["file_id"], requestOptions?: ResourceRequestOptions & {
+            headers?: Omit<NonNullable<DownloadSessionFileData["headers"]>, "x-notte-api-key">;
+        }) => Promise<unknown>;
+        execute: (sessionId: PageExecuteData["path"]["session_id"], body: PageExecuteData["body"], query?: PageExecuteData["query"], requestOptions?: ResourceRequestOptions & {
+            headers?: Omit<NonNullable<PageExecuteData["headers"]>, "x-notte-api-key">;
+        }) => Promise<ApiExecutionResponse>;
+        getCookies: (sessionId: SessionCookiesGetData["path"]["session_id"], query?: SessionCookiesGetData["query"], requestOptions?: ResourceRequestOptions & {
+            headers?: Omit<NonNullable<SessionCookiesGetData["headers"]>, "x-notte-api-key">;
+        }) => Promise<GetCookiesResponse>;
+        getSessionScript: (sessionId: GetSessionScriptData["path"]["session_id"], query: GetSessionScriptData["query"], requestOptions?: ResourceRequestOptions & {
+            headers?: Omit<NonNullable<GetSessionScriptData["headers"]>, "x-notte-api-key">;
+        }) => Promise<AgentFunctionCodeResponse>;
+        listSessionFiles: (sessionId: ListSessionFilesData["path"]["session_id"], query?: ListSessionFilesData["query"], requestOptions?: ResourceRequestOptions & {
+            headers?: Omit<NonNullable<ListSessionFilesData["headers"]>, "x-notte-api-key">;
+        }) => Promise<SessionFilesPage>;
+        networkLogs: (sessionId: SessionNetworkLogsData["path"]["session_id"], query?: SessionNetworkLogsData["query"], requestOptions?: ResourceRequestOptions & {
+            headers?: Omit<NonNullable<SessionNetworkLogsData["headers"]>, "x-notte-api-key">;
+        }) => Promise<NetworkLogsResponse>;
+        observe: (sessionId: PageObserveData["path"]["session_id"], body: PageObserveData["body"], query?: PageObserveData["query"], requestOptions?: ResourceRequestOptions & {
+            headers?: Omit<NonNullable<PageObserveData["headers"]>, "x-notte-api-key">;
+        }) => Promise<Observation>;
+        offset: (sessionId: SessionOffsetData["path"]["session_id"], requestOptions?: ResourceRequestOptions & {
+            headers?: Omit<NonNullable<SessionOffsetData["headers"]>, "x-notte-api-key">;
+        }) => Promise<SessionOffsetResponse>;
+        pageScreenshot: (sessionId: PageScreenshotData["path"]["session_id"], query?: PageScreenshotData["query"], requestOptions?: ResourceRequestOptions & {
+            headers?: Omit<NonNullable<PageScreenshotData["headers"]>, "x-notte-api-key">;
+        }) => Promise<unknown>;
+        profilePreview: (sessionId: SessionProfilePreviewData["path"]["session_id"], query?: SessionProfilePreviewData["query"], requestOptions?: ResourceRequestOptions & {
+            headers?: Omit<NonNullable<SessionProfilePreviewData["headers"]>, "x-notte-api-key">;
+        }) => Promise<SessionProfilePreviewResponse>;
+        replay: (sessionId: SessionReplayData["path"]["session_id"], requestOptions?: ResourceRequestOptions & {
+            headers?: Omit<NonNullable<SessionReplayData["headers"]>, "x-notte-api-key">;
+        }) => Promise<ReplayResponse>;
+        scrape: (sessionId: PageScrapeData["path"]["session_id"], body: PageScrapeData["body"], query?: PageScrapeData["query"], requestOptions?: ResourceRequestOptions & {
+            headers?: Omit<NonNullable<PageScrapeData["headers"]>, "x-notte-api-key">;
+        }) => Promise<DataSpace>;
+        setCookies: (sessionId: SessionCookiesSetData["path"]["session_id"], body: SessionCookiesSetData["body"], query?: SessionCookiesSetData["query"], requestOptions?: ResourceRequestOptions & {
+            headers?: Omit<NonNullable<SessionCookiesSetData["headers"]>, "x-notte-api-key">;
+        }) => Promise<ExecutionResponse>;
+        start: (body: SessionStartData["body"], requestOptions?: ResourceRequestOptions & {
+            headers?: Omit<NonNullable<SessionStartData["headers"]>, "x-notte-api-key">;
+        }) => Promise<SessionResponse>;
+        status: (sessionId: SessionStatusData["path"]["session_id"], requestOptions?: ResourceRequestOptions & {
+            headers?: Omit<NonNullable<SessionStatusData["headers"]>, "x-notte-api-key">;
+        }) => Promise<SessionResponse>;
+        stop: (sessionId: SessionStopData["path"]["session_id"], query?: SessionStopData["query"], requestOptions?: ResourceRequestOptions & {
+            headers?: Omit<NonNullable<SessionStopData["headers"]>, "x-notte-api-key">;
+        }) => Promise<SessionResponse>;
+        uploadSessionFile: (sessionId: UploadSessionFileData["path"]["session_id"], body: UploadSessionFileData["body"], requestOptions?: ResourceRequestOptions & {
+            headers?: Omit<NonNullable<UploadSessionFileData["headers"]>, "x-notte-api-key">;
+        }) => Promise<SessionFile>;
+    };
+    /** Client-bound agent API operations. `list()` retains its array return value. */
+    get agents(): {
+        list: (options?: AgentListOptions) => Promise<AgentResponse[]>;
+        getScript: (agentId: GetScriptData["path"]["agent_id"], query: GetScriptData["query"], requestOptions?: ResourceRequestOptions & {
+            headers?: Omit<NonNullable<GetScriptData["headers"]>, "x-notte-api-key">;
+        }) => Promise<AgentFunctionCodeResponse>;
+        start: (body: AgentStartData["body"], requestOptions?: ResourceRequestOptions & {
+            headers?: Omit<NonNullable<AgentStartData["headers"]>, "x-notte-api-key">;
+        }) => Promise<AgentResponse>;
+        status: (agentId: AgentStatusData["path"]["agent_id"], requestOptions?: ResourceRequestOptions & {
+            headers?: Omit<NonNullable<AgentStatusData["headers"]>, "x-notte-api-key">;
+        }) => Promise<LegacyAgentStatusResponse>;
+        stop: (agentId: AgentStopData["path"]["agent_id"], query: AgentStopData["query"], requestOptions?: ResourceRequestOptions & {
+            headers?: Omit<NonNullable<AgentStopData["headers"]>, "x-notte-api-key">;
+        }) => Promise<AgentStatusResponse>;
+    };
+    /** Client-bound vault API operations. `list()` retains its array return value. */
+    get vaults(): {
+        list: (options?: VaultListOptions) => Promise<Vault[]>;
+        create: (body: VaultCreateData["body"], requestOptions?: ResourceRequestOptions & {
+            headers?: Omit<NonNullable<VaultCreateData["headers"]>, "x-notte-api-key">;
+        }) => Promise<Vault>;
+        credentialsAdd: (vaultId: VaultCredentialsAddData["path"]["vault_id"], body: VaultCredentialsAddData["body"], requestOptions?: ResourceRequestOptions & {
+            headers?: Omit<NonNullable<VaultCredentialsAddData["headers"]>, "x-notte-api-key">;
+        }) => Promise<AddCredentialsResponse>;
+        credentialsDelete: (vaultId: VaultCredentialsDeleteData["path"]["vault_id"], query: VaultCredentialsDeleteData["query"], requestOptions?: ResourceRequestOptions & {
+            headers?: Omit<NonNullable<VaultCredentialsDeleteData["headers"]>, "x-notte-api-key">;
+        }) => Promise<DeleteCredentialsResponse>;
+        credentialsGet: (vaultId: VaultCredentialsGetData["path"]["vault_id"], query: VaultCredentialsGetData["query"], requestOptions?: ResourceRequestOptions & {
+            headers?: Omit<NonNullable<VaultCredentialsGetData["headers"]>, "x-notte-api-key">;
+        }) => Promise<GetCredentialsResponse>;
+        credentialsList: (vaultId: VaultCredentialsListData["path"]["vault_id"], requestOptions?: ResourceRequestOptions & {
+            headers?: Omit<NonNullable<VaultCredentialsListData["headers"]>, "x-notte-api-key">;
+        }) => Promise<ListCredentialsResponse>;
+        creditCardDelete: (vaultId: VaultCreditCardDeleteData["path"]["vault_id"], requestOptions?: ResourceRequestOptions & {
+            headers?: Omit<NonNullable<VaultCreditCardDeleteData["headers"]>, "x-notte-api-key">;
+        }) => Promise<DeleteCreditCardResponse>;
+        creditCardGet: (vaultId: VaultCreditCardGetData["path"]["vault_id"], requestOptions?: ResourceRequestOptions & {
+            headers?: Omit<NonNullable<VaultCreditCardGetData["headers"]>, "x-notte-api-key">;
+        }) => Promise<GetCreditCardResponse>;
+        creditCardSet: (vaultId: VaultCreditCardSetData["path"]["vault_id"], body: VaultCreditCardSetData["body"], requestOptions?: ResourceRequestOptions & {
+            headers?: Omit<NonNullable<VaultCreditCardSetData["headers"]>, "x-notte-api-key">;
+        }) => Promise<AddCreditCardResponse>;
+        delete: (vaultId: VaultDeleteData["path"]["vault_id"], requestOptions?: ResourceRequestOptions & {
+            headers?: Omit<NonNullable<VaultDeleteData["headers"]>, "x-notte-api-key">;
+        }) => Promise<DeleteVaultResponse>;
+        update: (vaultId: VaultUpdateData["path"]["vault_id"], body: VaultUpdateData["body"], requestOptions?: ResourceRequestOptions & {
+            headers?: Omit<NonNullable<VaultUpdateData["headers"]>, "x-notte-api-key">;
+        }) => Promise<Vault>;
+    };
+    /** Client-bound function API operations. `list()` retains its array return value. */
+    get functions(): {
+        list: (options?: FunctionListOptions) => Promise<FunctionListItemResponse[]>;
+        create: (body: FunctionCreateData["body"], query?: FunctionCreateData["query"], requestOptions?: ResourceRequestOptions & {
+            headers?: Omit<NonNullable<FunctionCreateData["headers"]>, "x-notte-api-key">;
+        }) => Promise<FunctionResponse>;
+        delete: (functionId: FunctionDeleteData["path"]["function_id"], requestOptions?: ResourceRequestOptions & {
+            headers?: Omit<NonNullable<FunctionDeleteData["headers"]>, "x-notte-api-key">;
+        }) => Promise<DeleteFunctionResponse>;
+        deleteSchedule: (functionId: FunctionScheduleDeleteData["path"]["function_id"], requestOptions?: ResourceRequestOptions & {
+            headers?: Omit<NonNullable<FunctionScheduleDeleteData["headers"]>, "x-notte-api-key">;
+        }) => Promise<ScheduleDeleteResponse>;
+        downloadUrl: (functionId: FunctionDownloadUrlData["path"]["function_id"], query?: FunctionDownloadUrlData["query"], requestOptions?: ResourceRequestOptions & {
+            headers?: Omit<NonNullable<FunctionDownloadUrlData["headers"]>, "x-notte-api-key">;
+        }) => Promise<FunctionWithLinkResponse>;
+        fork: (functionId: FunctionForkData["path"]["function_id"], requestOptions?: ResourceRequestOptions & {
+            headers?: Omit<NonNullable<FunctionForkData["headers"]>, "x-notte-api-key">;
+        }) => Promise<FunctionResponse>;
+        listRuns: (functionId: ListFunctionRunsByFunctionIdData["path"]["function_id"], query?: ListFunctionRunsByFunctionIdData["query"], requestOptions?: ResourceRequestOptions & {
+            headers?: Omit<NonNullable<ListFunctionRunsByFunctionIdData["headers"]>, "x-notte-api-key">;
+        }) => Promise<PaginatedResponseFunctionRunListItemResponse>;
+        metadataUpdate: (functionId: FunctionMetadataUpdateData["path"]["function_id"], body: FunctionMetadataUpdateData["body"], requestOptions?: ResourceRequestOptions & {
+            headers?: Omit<NonNullable<FunctionMetadataUpdateData["headers"]>, "x-notte-api-key">;
+        }) => Promise<FunctionResponse>;
+        rollback: (functionId: FunctionRollbackData["path"]["function_id"], body: FunctionRollbackData["body"], query?: FunctionRollbackData["query"], requestOptions?: ResourceRequestOptions & {
+            headers?: Omit<NonNullable<FunctionRollbackData["headers"]>, "x-notte-api-key">;
+        }) => Promise<FunctionResponse>;
+        runGetMetadata: (functionId: FunctionRunGetMetadataData["path"]["function_id"], runId: FunctionRunGetMetadataData["path"]["run_id"], requestOptions?: ResourceRequestOptions & {
+            headers?: Omit<NonNullable<FunctionRunGetMetadataData["headers"]>, "x-notte-api-key">;
+        }) => Promise<GetFunctionRunResponse>;
+        runStart: (functionId: FunctionRunStartData["path"]["function_id"], body: FunctionRunStartData["body"], requestOptions?: ResourceRequestOptions & {
+            headers?: Omit<NonNullable<FunctionRunStartData["headers"]>, "x-notte-api-key">;
+        }) => Promise<unknown>;
+        runStop: (functionId: FunctionRunStopData["path"]["function_id"], runId: FunctionRunStopData["path"]["run_id"], requestOptions?: ResourceRequestOptions & {
+            headers?: Omit<NonNullable<FunctionRunStopData["headers"]>, "x-notte-api-key">;
+        }) => Promise<UpdateFunctionRunResponse>;
+        runUpdateMetadata: (functionId: FunctionRunUpdateMetadataData["path"]["function_id"], runId: FunctionRunUpdateMetadataData["path"]["run_id"], body: FunctionRunUpdateMetadataData["body"], requestOptions?: ResourceRequestOptions & {
+            headers?: Omit<NonNullable<FunctionRunUpdateMetadataData["headers"]>, "x-notte-api-key">;
+        }) => Promise<UpdateFunctionRunResponse>;
+        runtimeHealth: (requestOptions?: ResourceRequestOptions & {
+            headers?: Omit<NonNullable<FunctionRuntimeHealthData["headers"]>, "x-notte-api-key">;
+        }) => Promise<FunctionRuntimeHealthResponse>;
+        setSchedule: (functionId: FunctionScheduleSetData["path"]["function_id"], body: FunctionScheduleSetData["body"], requestOptions?: ResourceRequestOptions & {
+            headers?: Omit<NonNullable<FunctionScheduleSetData["headers"]>, "x-notte-api-key">;
+        }) => Promise<ScheduleResponse>;
+        update: (functionId: FunctionUpdateData["path"]["function_id"], body: FunctionUpdateData["body"], query?: FunctionUpdateData["query"], requestOptions?: ResourceRequestOptions & {
+            headers?: Omit<NonNullable<FunctionUpdateData["headers"]>, "x-notte-api-key">;
+        }) => Promise<FunctionResponse>;
+    };
+    /**
+     * Search the public web (`POST /search`). Returns ranked results by default,
+     * an answer with sources with `outputType: 'sourcedAnswer'`, or structured
+     * output with `outputType: 'structured'`.
+     *
+     * ```ts
+     * import { NotteClient } from 'notte-sdk';
+     *
+     * const client = new NotteClient();
+     * const { results } = await client.search('notte browser agents');
+     * const { answer } = await client.search('what is notte?', { outputType: 'sourcedAnswer' });
+     * ```
+     */
+    search(query: string, options?: SearchOptions & {
+        outputType?: 'searchResults';
+    }): Promise<SearchResultsResponse>;
+    search(query: string, options: SearchOptions & {
+        outputType: 'sourcedAnswer';
+    }): Promise<SearchSourcedAnswerResponse>;
+    search(query: string, options: SearchOptions & {
+        outputType: 'structured';
+    }): Promise<SearchStructuredResponse>;
+    search(query: string, options: SearchOptions): Promise<SearchResponse>;
+    /** Anything API (`POST /anything/start`). */
+    get anything(): NotteAnything;
+    /** Workspace secrets (`/secrets`). */
+    get secrets(): NotteSecrets;
+    /** Managed authentication: verify connections, request login, and wait for readiness. */
+    get managedAuth(): NotteManagedAuth;
+    /** Usage and billing (`/usage`, `/usage/logs`). */
+    get usage(): NotteUsage;
     /**
      * Personas client for listing and managing personas
      */
     get personas(): {
         list: (options?: PersonaListOptions) => Promise<PersonaResponse[]>;
+        create: (body: PersonaCreateData["body"], requestOptions?: ResourceRequestOptions & {
+            headers?: Omit<NonNullable<PersonaCreateData["headers"]>, "x-notte-api-key">;
+        }) => Promise<PersonaResponse>;
+        delete: (personaId: PersonaDeleteData["path"]["persona_id"], requestOptions?: ResourceRequestOptions & {
+            headers?: Omit<NonNullable<PersonaDeleteData["headers"]>, "x-notte-api-key">;
+        }) => Promise<DeletePersonaResponse>;
+        emailsList: (personaId: PersonaEmailsListData["path"]["persona_id"], query?: PersonaEmailsListData["query"], requestOptions?: ResourceRequestOptions & {
+            headers?: Omit<NonNullable<PersonaEmailsListData["headers"]>, "x-notte-api-key">;
+        }) => Promise<EmailResponse[]>;
+        get: (personaId: PersonaGetData["path"]["persona_id"], requestOptions?: ResourceRequestOptions & {
+            headers?: Omit<NonNullable<PersonaGetData["headers"]>, "x-notte-api-key">;
+        }) => Promise<PersonaResponse>;
+        smsList: (personaId: PersonaSmsListData["path"]["persona_id"], query?: PersonaSmsListData["query"], requestOptions?: ResourceRequestOptions & {
+            headers?: Omit<NonNullable<PersonaSmsListData["headers"]>, "x-notte-api-key">;
+        }) => Promise<SmsResponse[]>;
+        update: (personaId: PersonaUpdateData["path"]["persona_id"], body: PersonaUpdateData["body"], requestOptions?: ResourceRequestOptions & {
+            headers?: Omit<NonNullable<PersonaUpdateData["headers"]>, "x-notte-api-key">;
+        }) => Promise<PersonaResponse>;
     };
     /**
      * Get the configured client instance
      */
     getClient(): Client;
-    /**
-     * Scrape a webpage directly (without session)
-     */
-    scrape(url: string, options?: Omit<GlobalScrapeRequest, 'url'>): Promise<string | any>;
-    scrape<T>(url: string, options: Omit<GlobalScrapeRequest, 'url'> & {
-        response_format: z.ZodSchema<T>;
-        json_schema?: any;
+    /** Client-bound profile API operations, generated from OpenAPI. */
+    get profiles(): {
+        cookiesGet: (profileId: ProfileCookiesGetData["path"]["profile_id"], requestOptions?: ResourceRequestOptions & {
+            headers?: Omit<NonNullable<ProfileCookiesGetData["headers"]>, "x-notte-api-key">;
+        }) => Promise<GetCookiesResponse>;
+        cookiesSet: (profileId: ProfileCookiesSetData["path"]["profile_id"], body: ProfileCookiesSetData["body"], requestOptions?: ResourceRequestOptions & {
+            headers?: Omit<NonNullable<ProfileCookiesSetData["headers"]>, "x-notte-api-key">;
+        }) => Promise<ProfileCookiesImportResponse>;
+        create: (body: ProfileCreateData["body"], requestOptions?: ResourceRequestOptions & {
+            headers?: Omit<NonNullable<ProfileCreateData["headers"]>, "x-notte-api-key">;
+        }) => Promise<ProfileResponse>;
+        delete: (profileId: ProfileDeleteData["path"]["profile_id"], requestOptions?: ResourceRequestOptions & {
+            headers?: Omit<NonNullable<ProfileDeleteData["headers"]>, "x-notte-api-key">;
+        }) => Promise<ProfileDeleteResponse>;
+        duplicate: (profileId: ProfileDuplicateData["path"]["profile_id"], body: ProfileDuplicateData["body"], requestOptions?: ResourceRequestOptions & {
+            headers?: Omit<NonNullable<ProfileDuplicateData["headers"]>, "x-notte-api-key">;
+        }) => Promise<ProfileResponse>;
+        get: (profileId: ProfileGetData["path"]["profile_id"], requestOptions?: ResourceRequestOptions & {
+            headers?: Omit<NonNullable<ProfileGetData["headers"]>, "x-notte-api-key">;
+        }) => Promise<ProfileResponse>;
+        list: (query?: ProfileListData["query"], requestOptions?: ResourceRequestOptions & {
+            headers?: Omit<NonNullable<ProfileListData["headers"]>, "x-notte-api-key">;
+        }) => Promise<PaginatedResponseProfileResponse>;
+    };
+    /**
+     * Scrape a webpage directly (without session).
+     *
+     * ```ts
+     * const markdown = await client.scrape('https://www.notte.cc', { only_main_content: true });
+     * const product = await client.scrape('https://www.notte.cc', { response_format: Product, instructions: 'Extract the product' });
+     * ```
+     *
+     * With `response_format` or `instructions`, the extracted data is returned
+     * directly and a failed extraction throws `ScrapeFailedError`. Pass
+     * `raiseOnFailure: false` to receive the `StructuredData` wrapper instead.
+     */
+    scrape(url: string, options?: GlobalScrapeOptions<unknown> & {
+        response_format?: undefined;
+        instructions?: undefined | null;
+    }): Promise<string>;
+    scrape<T>(url: string, options: GlobalScrapeOptions<T> & {
+        response_format: ZodLikeSchema<T>;
+        raiseOnFailure?: true;
     }): Promise<T>;
+    scrape<T>(url: string, options: GlobalScrapeOptions<T> & {
+        response_format: ZodLikeSchema<T>;
+        raiseOnFailure: false;
+    }): Promise<StructuredData<T>>;
+    scrape(url: string, options: GlobalScrapeOptions<unknown>): Promise<ScrapeResult<unknown>>;
     /**
      * Get the client configuration
      */
@@ -11506,9 +13773,17 @@ declare class Encryption {
     decrypt(token: string): string;
 }
 
+/** Read a JSON cookie file (a list of cookies, like `session.getCookies()` returns). */
+declare function readCookiesFile(cookieFile: string): Promise<Cookie[]>;
+/**
+ * Append `cookies` to the JSON list stored in `cookieFile`, creating the file
+ * when it does not exist yet.
+ */
+declare function createOrAppendCookiesToFile(cookieFile: string, cookies: Cookie[]): Promise<void>;
+
 declare const createClient: (config?: {
     baseUrl?: string;
     token?: string;
 }) => Client;
 
-export { type ActionParameter, type ActionSpace, type ActionSpaceWritable, type AddCredentialsRequest, type AddCredentialsResponse, type AddCreditCardRequest, type AddCreditCardResponse, Agent, type AgentConstructor, type AgentFunctionCodeResponse, type AgentResponse, type AgentRunRequest, type AgentStartData, type AgentStartError, type AgentStartErrors, type AgentStartResponse, type AgentStartResponses, type AgentStatus, type AgentStatusData, type AgentStatusError, type AgentStatusErrors, type AgentStatusResponse, type AgentStatusResponse2, type AgentStatusResponses, type AgentStopData, type AgentStopError, type AgentStopErrors, type AgentStopResponse, type AgentStopResponses, type AgentUpdateHandler, type AnythingStartData, type AnythingStartError, type AnythingStartErrors, type AnythingStartRequest, type AnythingStartResponses, type ApiAgentStartRequest, type ApiExecutionResponse, type ApiExecutionResponseWritable, type ApiSessionStartRequest, type BaseModel, type BaseModelWritable, type BodyFunctionCreateFunctionsPost, type BodyFunctionUpdateFunctionsFunctionIdPost, type BodySessionCookiesSetSessionsSessionIdCookiesPost, type BodyUploadSessionFileSessionsSessionIdFilesPost, type BoundingBox, type CaptchaSolveAction, type CheckActionInput, type CheckActionOutput, type ClickActionInput, type ClickActionOutput, type ClientOptions, type CloseTabAction, type CompletionAction, type ConnectLinkContext, type ConnectLinkContextData, type ConnectLinkContextError, type ConnectLinkContextErrors, type ConnectLinkContextResponse, type ConnectLinkContextResponses, type ConnectLinkCreateRequest, type ConnectLinkCreateResponse, type ConnectLinkMailbox, type ConnectLinkMailboxConnectData, type ConnectLinkMailboxConnectError, type ConnectLinkMailboxConnectErrors, type ConnectLinkMailboxConnectRequest, type ConnectLinkMailboxConnectResponse, type ConnectLinkMailboxConnectResponse2, type ConnectLinkMailboxConnectResponses, type ConnectLinkMailboxSyncData, type ConnectLinkMailboxSyncError, type ConnectLinkMailboxSyncErrors, type ConnectLinkMailboxSyncRequest, type ConnectLinkMailboxSyncResponse, type ConnectLinkMailboxSyncResponses, type ConnectLinkMailboxesData, type ConnectLinkMailboxesError, type ConnectLinkMailboxesErrors, type ConnectLinkMailboxesResponse, type ConnectLinkMailboxesResponses, type ConnectLinkStatusData, type ConnectLinkStatusError, type ConnectLinkStatusErrors, type ConnectLinkStatusResponse, type ConnectLinkStatusResponse2, type ConnectLinkStatusResponses, type ConnectLinkSubmitData, type ConnectLinkSubmitError, type ConnectLinkSubmitErrors, type ConnectLinkSubmitRequest, type ConnectLinkSubmitRequestWritable, type ConnectLinkSubmitResponse, type ConnectLinkSubmitResponses, type Cookie, type Credential, type CredentialsDictInput, type CredentialsDictOutput, type CreditCardDictInput, type CreditCardDictOutput, type DataSpace, type DeleteCredentialsResponse, type DeleteCreditCardResponse, type DeleteFunctionResponse, type DeletePersonaResponse, type DeleteSecretData, type DeleteSecretError, type DeleteSecretErrors, type DeleteSecretResponse, type DeleteSecretResponses, type DeleteSessionFileData, type DeleteSessionFileError, type DeleteSessionFileErrors, type DeleteSessionFileResponse, type DeleteSessionFileResponses, type DeleteVaultResponse, type DownloadFileActionInput, type DownloadFileActionOutput, type DownloadSessionFileData, type DownloadSessionFileError, type DownloadSessionFileErrors, type DownloadSessionFileResponses, type EmailReadAction, type EmailResponse, type EmailVerificationReadAction, Encryption, type EvaluateJsAction, type ExecutionResponse, type ExternalProxy, type FallbackFillActionInput, type FallbackFillActionInputWritable, type FallbackFillActionOutput, type FallbackFillActionOutputWritable, type FileSource, type FillActionInput, type FillActionInputWritable, type FillActionOutput, type FillActionOutputWritable, type FormFillAction, type FormFillActionWritable, type FrameData, type FunctionConstructor, type FunctionCreateData, type FunctionCreateError, type FunctionCreateErrors, type FunctionCreateResponse, type FunctionCreateResponses, type FunctionDeleteData, type FunctionDeleteError, type FunctionDeleteErrors, type FunctionDeleteResponse, type FunctionDeleteResponses, type FunctionDownloadOptions, type FunctionDownloadUrlData, type FunctionDownloadUrlError, type FunctionDownloadUrlErrors, type FunctionDownloadUrlResponse, type FunctionDownloadUrlResponses, type FunctionForkData, type FunctionForkError, type FunctionForkErrors, type FunctionForkResponse, type FunctionForkResponses, type FunctionListItemResponse, type FunctionListItemResponseWritable, type FunctionMetadataUpdateData, type FunctionMetadataUpdateError, type FunctionMetadataUpdateErrors, type FunctionMetadataUpdateRequest, type FunctionMetadataUpdateResponse, type FunctionMetadataUpdateResponses, type FunctionResponse, type FunctionResponseWritable, type FunctionRollbackData, type FunctionRollbackError, type FunctionRollbackErrors, type FunctionRollbackRequest, type FunctionRollbackResponse, type FunctionRollbackResponses, type FunctionRunGetMetadataData, type FunctionRunGetMetadataError, type FunctionRunGetMetadataErrors, type FunctionRunGetMetadataResponse, type FunctionRunGetMetadataResponses, type FunctionRunListItemResponse, type FunctionRunListItemResponseWritable, type FunctionRunOptions, type FunctionRunStartData, type FunctionRunStartError, type FunctionRunStartErrors, type FunctionRunStartResponses, type FunctionRunStartResult, type FunctionRunStopData, type FunctionRunStopError, type FunctionRunStopErrors, type FunctionRunStopResponse, type FunctionRunStopResponses, type FunctionRunUpdateMetadataData, type FunctionRunUpdateMetadataError, type FunctionRunUpdateMetadataErrors, type FunctionRunUpdateMetadataResponse, type FunctionRunUpdateMetadataResponses, type FunctionRunUpdateRequest, type FunctionRuntimeHealthData, type FunctionRuntimeHealthError, type FunctionRuntimeHealthErrors, type FunctionRuntimeHealthResponse, type FunctionRuntimeHealthResponse2, type FunctionRuntimeHealthResponses, type FunctionScheduleCreateRequest, type FunctionScheduleDeleteData, type FunctionScheduleDeleteError, type FunctionScheduleDeleteErrors, type FunctionScheduleDeleteResponse, type FunctionScheduleDeleteResponses, type FunctionScheduleSetData, type FunctionScheduleSetError, type FunctionScheduleSetErrors, type FunctionScheduleSetResponse, type FunctionScheduleSetResponses, type FunctionSource, type FunctionUpdateData, type FunctionUpdateError, type FunctionUpdateErrors, type FunctionUpdateResponse, type FunctionUpdateResponses, type FunctionUrlOptions, type FunctionWithLinkResponse, type FunctionWithLinkResponseWritable, type GetCookiesResponse, type GetCredentialsResponse, type GetCreditCardResponse, type GetFunctionRunResponse, type GetFunctionRunResponseWritable, type GetScriptData, type GetScriptError, type GetScriptErrors, type GetScriptResponse, type GetScriptResponses, type GetSecretData, type GetSecretError, type GetSecretErrors, type GetSecretResponse, type GetSecretResponses, type GetSessionScriptData, type GetSessionScriptError, type GetSessionScriptErrors, type GetSessionScriptResponse, type GetSessionScriptResponses, type GetUsageData, type GetUsageError, type GetUsageErrors, type GetUsageLogsData, type GetUsageLogsError, type GetUsageLogsErrors, type GetUsageLogsResponse, type GetUsageLogsResponses, type GetUsageResponse, type GetUsageResponses, type GlobalScrapeRequest, type GoBackAction, type GoForwardAction, type GotoAction, type GotoNewTabAction, type HealthCheckData, type HealthCheckResponse, type HealthCheckResponses, type HealthResponse, type HelpAction, type HttpValidationError, type ImageCategory, type ImageData, type ImprovePromptData, type ImprovePromptError, type ImprovePromptErrors, type ImprovePromptRequest, type ImprovePromptResponse, type ImprovePromptResponse2, type ImprovePromptResponses, type LegacyAgentStatusResponse, type ListAgentsData, type ListAgentsError, type ListAgentsErrors, type ListAgentsResponse, type ListAgentsResponses, type ListCredentialsResponse, type ListFunctionRunsByFunctionIdData, type ListFunctionRunsByFunctionIdError, type ListFunctionRunsByFunctionIdErrors, type ListFunctionRunsByFunctionIdResponse, type ListFunctionRunsByFunctionIdResponses, type ListFunctionsData, type ListFunctionsError, type ListFunctionsErrors, type ListFunctionsResponse, type ListFunctionsResponses, type ListPersonasData, type ListPersonasError, type ListPersonasErrors, type ListPersonasResponse, type ListPersonasResponses, type ListSecretsData, type ListSecretsError, type ListSecretsErrors, type ListSecretsResponse, type ListSecretsResponses, type ListSessionFilesData, type ListSessionFilesError, type ListSessionFilesErrors, type ListSessionFilesResponse, type ListSessionFilesResponses, type ListSessionsData, type ListSessionsError, type ListSessionsErrors, type ListSessionsResponse, type ListSessionsResponses, type ListVaultsData, type ListVaultsError, type ListVaultsErrors, type ListVaultsResponse, type ListVaultsResponses, type LlmModel, type MailboxConnectRequest, type MailboxConnectResponse, type MailboxConnectTokenData, type MailboxConnectTokenError, type MailboxConnectTokenErrors, type MailboxConnectTokenResponse, type MailboxConnectTokenResponses, type MailboxConnection, type MailboxDeleteData, type MailboxDeleteError, type MailboxDeleteErrors, type MailboxDeleteResponse, type MailboxDeleteResponses, type MailboxGetData, type MailboxGetError, type MailboxGetErrors, type MailboxGetResponse, type MailboxGetResponses, type MailboxListData, type MailboxListError, type MailboxListErrors, type MailboxListResponse, type MailboxListResponse2, type MailboxListResponses, type MailboxSyncData, type MailboxSyncError, type MailboxSyncErrors, type MailboxSyncRequest, type MailboxSyncResponse, type MailboxSyncResponses, type MailboxUpdateData, type MailboxUpdateError, type MailboxUpdateErrors, type MailboxUpdateRequest, type MailboxUpdateResponse, type MailboxUpdateResponses, type ManagedAuthConnectLinkCreateData, type ManagedAuthConnectLinkCreateError, type ManagedAuthConnectLinkCreateErrors, type ManagedAuthConnectLinkCreateResponse, type ManagedAuthConnectLinkCreateResponses, type ManagedAuthCredentials, type ManagedAuthCredentialsWritable, type MessageReadOptions, type MintProxyCredentialsData, type MintProxyCredentialsError, type MintProxyCredentialsErrors, type MintProxyCredentialsResponse, type MintProxyCredentialsResponses, type MultiFactorFillActionInput, type MultiFactorFillActionInputWritable, type MultiFactorFillActionOutput, type MultiFactorFillActionOutputWritable, type NetworkBatchFile, type NetworkLogsResponse, type NodeSelectors, NotteClient, type NotteClientConfig, NotteFunction, NottePersona, type NotteProxy, NotteVault, type NudgePromptData, type NudgePromptError, type NudgePromptErrors, type NudgePromptRequest, type NudgePromptResponse, type NudgePromptResponse2, type NudgePromptResponses, type Observation, type ObservationWritable, type ObserveRequest, type Options, type PageExecuteData, type PageExecuteError, type PageExecuteErrors, type PageExecuteResponse, type PageExecuteResponses, type PageObserveData, type PageObserveError, type PageObserveErrors, type PageObserveResponse, type PageObserveResponses, type PageScrapeData, type PageScrapeError, type PageScrapeErrors, type PageScrapeResponse, type PageScrapeResponses, type PageScreenshotData, type PageScreenshotError, type PageScreenshotErrors, type PageScreenshotResponses, type PaginatedResponseAgentResponse, type PaginatedResponseAgentResponseWritable, type PaginatedResponseFunctionListItemResponse, type PaginatedResponseFunctionListItemResponseWritable, type PaginatedResponseFunctionRunListItemResponse, type PaginatedResponseFunctionRunListItemResponseWritable, type PaginatedResponsePersonaResponse, type PaginatedResponsePersonaResponseWritable, type PaginatedResponseProfileResponse, type PaginatedResponseProfileResponseWritable, type PaginatedResponseSessionResponse, type PaginatedResponseSessionResponseWritable, type PaginatedResponseUsageLog, type PaginatedResponseUsageLogWritable, type PaginatedResponseVault, type PaginatedResponseVaultWritable, type ParameterInfo, type PersonaConstructor, type PersonaCreateData, type PersonaCreateError, type PersonaCreateErrors, type PersonaCreateRequest, type PersonaCreateResponse, type PersonaCreateResponses, type PersonaDeleteData, type PersonaDeleteError, type PersonaDeleteErrors, type PersonaDeleteResponse, type PersonaDeleteResponses, type PersonaEmailsListData, type PersonaEmailsListError, type PersonaEmailsListErrors, type PersonaEmailsListResponse, type PersonaEmailsListResponses, type PersonaGetData, type PersonaGetError, type PersonaGetErrors, type PersonaGetResponse, type PersonaGetResponses, type PersonaListOptions, type PersonaResponse, type PersonaSmsListData, type PersonaSmsListError, type PersonaSmsListErrors, type PersonaSmsListResponse, type PersonaSmsListResponses, type PersonaUpdateData, type PersonaUpdateError, type PersonaUpdateErrors, type PersonaUpdateRequest, type PersonaUpdateResponse, type PersonaUpdateResponses, type PressKeyAction, type ProfileCookiesGetData, type ProfileCookiesGetError, type ProfileCookiesGetErrors, type ProfileCookiesGetResponse, type ProfileCookiesGetResponses, type ProfileCookiesImportRequest, type ProfileCookiesImportResponse, type ProfileCookiesSetData, type ProfileCookiesSetError, type ProfileCookiesSetErrors, type ProfileCookiesSetResponse, type ProfileCookiesSetResponses, type ProfileCreateData, type ProfileCreateError, type ProfileCreateErrors, type ProfileCreateRequest, type ProfileCreateResponse, type ProfileCreateResponses, type ProfileDeleteData, type ProfileDeleteError, type ProfileDeleteErrors, type ProfileDeleteResponse, type ProfileDeleteResponse2, type ProfileDeleteResponses, type ProfileDuplicateData, type ProfileDuplicateError, type ProfileDuplicateErrors, type ProfileDuplicateRequest, type ProfileDuplicateResponse, type ProfileDuplicateResponses, type ProfileGetData, type ProfileGetError, type ProfileGetErrors, type ProfileGetResponse, type ProfileGetResponses, type ProfileListData, type ProfileListError, type ProfileListErrors, type ProfileListResponse, type ProfileListResponses, type ProfileResponse, type ProxyCredentialRequest, type ProxyCredentialResponse, type ProxyGeolocationCountry, type ReadyCheckData, type ReadyCheckResponse, type ReadyCheckResponses, type ReloadAction, type ReplayResponse, type RootModelAny, type RunFunctionRequest, type RuntimePackage, type ScheduleDeleteResponse, type ScheduleResponse, type SchemaGenerationResponse, type ScrapeAction, type ScrapeFromHtmlData, type ScrapeFromHtmlError, type ScrapeFromHtmlErrors, type ScrapeFromHtmlRequest, type ScrapeFromHtmlResponse, type ScrapeFromHtmlResponses, type ScrapeRequest, type ScrapeSchemaResponse, type ScrapeWebpageData, type ScrapeWebpageError, type ScrapeWebpageErrors, type ScrapeWebpageResponse, type ScrapeWebpageResponses, type Screenshot, type ScrollDownAction, type ScrollUpAction, type SearchRequest, type SearchWebData, type SearchWebError, type SearchWebErrors, type SearchWebResponses, type SecretListResponse, type SecretMetadata, type SecretNamespace, type SecretStoreRequest, type SecretValueResponse, type SelectDropdownOptionActionInput, type SelectDropdownOptionActionInputWritable, type SelectDropdownOptionActionOutput, type SelectDropdownOptionActionOutputWritable, type SerializedError, Session, type SessionCookiesGetData, type SessionCookiesGetError, type SessionCookiesGetErrors, type SessionCookiesGetResponse, type SessionCookiesGetResponses, type SessionCookiesSetData, type SessionCookiesSetError, type SessionCookiesSetErrors, type SessionCookiesSetResponse, type SessionCookiesSetResponses, type SessionDebugInfoData, type SessionDebugInfoError, type SessionDebugInfoErrors, type SessionDebugInfoResponse, type SessionDebugInfoResponses, type SessionDebugResponse, type SessionFile, SessionFiles, type SessionFilesPage, type SessionNetworkLogsData, type SessionNetworkLogsError, type SessionNetworkLogsErrors, type SessionNetworkLogsResponse, type SessionNetworkLogsResponses, type SessionOffsetData, type SessionOffsetError, type SessionOffsetErrors, type SessionOffsetResponse, type SessionOffsetResponse2, type SessionOffsetResponses, type SessionOptions, type SessionProfile, type SessionReplayData, type SessionReplayError, type SessionReplayErrors, type SessionReplayResponse, type SessionReplayResponses, type SessionResponse, type SessionResponseWritable, type SessionStartData, type SessionStartError, type SessionStartErrors, type SessionStartResponse, type SessionStartResponses, type SessionStatusData, type SessionStatusError, type SessionStatusErrors, type SessionStatusResponse, type SessionStatusResponses, type SessionStopData, type SessionStopError, type SessionStopErrors, type SessionStopResponse, type SessionStopResponses, type SmsReadAction, type SmsResponse, type SnapshotMetadata, type SpaceCategory, type StoreSecretData, type StoreSecretError, type StoreSecretErrors, type StoreSecretResponse, type StoreSecretResponses, type StructuredDataBaseModel, type SubscriptionType, type SwitchTabAction, type TabSessionDebugResponse, type TabsData, type TailnetProxy, type UpdateFunctionRunResponse, type UpdateFunctionRunResponseWritable, type UploadFileActionInput, type UploadFileActionOutput, type UploadSessionFileData, type UploadSessionFileError, type UploadSessionFileErrors, type UploadSessionFileResponse, type UploadSessionFileResponses, type UsageLog, type UsageResponse, type ValidationError, type Vault, type VaultConstructor, type VaultCreateData, type VaultCreateError, type VaultCreateErrors, type VaultCreateRequest, type VaultCreateResponse, type VaultCreateResponses, type VaultCredentialsAddData, type VaultCredentialsAddError, type VaultCredentialsAddErrors, type VaultCredentialsAddResponse, type VaultCredentialsAddResponses, type VaultCredentialsDeleteData, type VaultCredentialsDeleteError, type VaultCredentialsDeleteErrors, type VaultCredentialsDeleteResponse, type VaultCredentialsDeleteResponses, type VaultCredentialsGetData, type VaultCredentialsGetError, type VaultCredentialsGetErrors, type VaultCredentialsGetResponse, type VaultCredentialsGetResponses, type VaultCredentialsListData, type VaultCredentialsListError, type VaultCredentialsListErrors, type VaultCredentialsListResponse, type VaultCredentialsListResponses, type VaultCreditCardDeleteData, type VaultCreditCardDeleteError, type VaultCreditCardDeleteErrors, type VaultCreditCardDeleteResponse, type VaultCreditCardDeleteResponses, type VaultCreditCardGetData, type VaultCreditCardGetError, type VaultCreditCardGetErrors, type VaultCreditCardGetResponse, type VaultCreditCardGetResponses, type VaultCreditCardSetData, type VaultCreditCardSetError, type VaultCreditCardSetErrors, type VaultCreditCardSetResponse, type VaultCreditCardSetResponses, type VaultDeleteData, type VaultDeleteError, type VaultDeleteErrors, type VaultDeleteResponse, type VaultDeleteResponses, type VaultUpdateData, type VaultUpdateError, type VaultUpdateErrors, type VaultUpdateRequest, type VaultUpdateResponse, type VaultUpdateResponses, type ViewportData, type WaitAction, type WebSocketUrls, agentStart, agentStatus, agentStop, anythingStart, client, connectLinkContext, connectLinkMailboxConnect, connectLinkMailboxSync, connectLinkMailboxes, connectLinkStatus, connectLinkSubmit, createClient, NotteClient as default, deleteSecret, deleteSessionFile, downloadSessionFile, functionCreate, functionDelete, functionDownloadUrl, functionFork, functionMetadataUpdate, functionRollback, functionRunGetMetadata, functionRunStart, functionRunStop, functionRunUpdateMetadata, functionRuntimeHealth, functionScheduleDelete, functionScheduleSet, functionUpdate, getScript, getSecret, getSessionScript, getUsage, getUsageLogs, healthCheck, improvePrompt, listAgents, listFunctionRunsByFunctionId, listFunctions, listPersonas, listSecrets, listSessionFiles, listSessions, listVaults, mailboxConnectToken, mailboxDelete, mailboxGet, mailboxList, mailboxSync, mailboxUpdate, managedAuthConnectLinkCreate, mintProxyCredentials, nudgePrompt, pageExecute, pageObserve, pageScrape, pageScreenshot, personaCreate, personaDelete, personaEmailsList, personaGet, personaSmsList, personaUpdate, profileCookiesGet, profileCookiesSet, profileCreate, profileDelete, profileDuplicate, profileGet, profileList, readyCheck, scrapeFromHtml, scrapeWebpage, searchWeb, sessionCookiesGet, sessionCookiesSet, sessionDebugInfo, sessionNetworkLogs, sessionOffset, sessionReplay, sessionStart, sessionStatus, sessionStop, storeSecret, uploadSessionFile, vaultCreate, vaultCredentialsAdd, vaultCredentialsDelete, vaultCredentialsGet, vaultCredentialsList, vaultCreditCardDelete, vaultCreditCardGet, vaultCreditCardSet, vaultDelete, vaultUpdate };
+export { ActionExecutionError, type ActionInput, type ActionOfType, type ActionParameter, type ActionSpace, type ActionSpaceWritable, type ActionType, type AddCredentialsRequest, type AddCredentialsResponse, type AddCreditCardRequest, type AddCreditCardResponse, Agent, type AgentConstructor, type AgentFunctionCodeResponse, type AgentListOptions, type AgentResponse, type AgentRunRequest, type AgentStartData, type AgentStartError, type AgentStartErrors, type AgentStartResponse, type AgentStartResponses, type AgentStatus, type AgentStatusData, type AgentStatusError, type AgentStatusErrors, type AgentStatusResponse, type AgentStatusResponse2, type AgentStatusResponses, type AgentStopData, type AgentStopError, type AgentStopErrors, type AgentStopResponse, type AgentStopResponses, type AgentUpdateHandler, type AnythingStartData, type AnythingStartError, type AnythingStartErrors, type AnythingStartOptions, type AnythingStartRequest, type AnythingStartResponse, type AnythingStartResponses, type ApiAgentStartRequest, type ApiExecutionResponse, type ApiExecutionResponseWritable, type ApiSessionStartRequest, type AuthSessionResponse, type AuthWaitOptions, AuthenticationError, type BaseModel, type BaseModelWritable, type BodyFunctionCreateFunctionsPost, type BodyFunctionUpdateFunctionsFunctionIdPost, type BodySessionCookiesSetSessionsSessionIdCookiesPost, type BodyUploadSessionFileSessionsSessionIdFilesPost, type BoundingBox, CAPTCHA_SOLVE_TIMEOUT_MS, CLUSTER_OVERLOAD_RETRY_DELAY_MS, CREDENTIAL_FIELDS, type CaptchaExecutionResponse, type CaptchaSolveAction, type CaptchaStatus, type CheckActionInput, type CheckActionOutput, type ClickActionInput, type ClickActionOutput, type ClientOptions, type CloseTabAction, type CompletionAction, type ConnectLinkContext, type ConnectLinkContextData, type ConnectLinkContextError, type ConnectLinkContextErrors, type ConnectLinkContextResponse, type ConnectLinkContextResponses, type ConnectLinkCreateRequest, type ConnectLinkCreateResponse, type ConnectLinkMailbox, type ConnectLinkMailboxConnectData, type ConnectLinkMailboxConnectError, type ConnectLinkMailboxConnectErrors, type ConnectLinkMailboxConnectRequest, type ConnectLinkMailboxConnectResponse, type ConnectLinkMailboxConnectResponse2, type ConnectLinkMailboxConnectResponses, type ConnectLinkMailboxSyncData, type ConnectLinkMailboxSyncError, type ConnectLinkMailboxSyncErrors, type ConnectLinkMailboxSyncRequest, type ConnectLinkMailboxSyncResponse, type ConnectLinkMailboxSyncResponses, type ConnectLinkMailboxesData, type ConnectLinkMailboxesError, type ConnectLinkMailboxesErrors, type ConnectLinkMailboxesResponse, type ConnectLinkMailboxesResponses, type ConnectLinkStatusData, type ConnectLinkStatusError, type ConnectLinkStatusErrors, type ConnectLinkStatusResponse, type ConnectLinkStatusResponse2, type ConnectLinkStatusResponses, type ConnectLinkSubmitData, type ConnectLinkSubmitError, type ConnectLinkSubmitErrors, type ConnectLinkSubmitRequest, type ConnectLinkSubmitRequestWritable, type ConnectLinkSubmitResponse, type ConnectLinkSubmitResponses, type ConnectPaymentWalletData, type ConnectPaymentWalletError, type ConnectPaymentWalletErrors, type ConnectPaymentWalletResponse, type ConnectPaymentWalletResponses, type Cookie, type CreatePaymentData, type CreatePaymentError, type CreatePaymentErrors, type CreatePaymentResponse, type CreatePaymentResponses, type Credential, type CredentialField, type CredentialsDictInput, type CredentialsDictOutput, type CreditCardDictInput, type CreditCardDictOutput, DEFAULT_NOTTE_API_URL, DEFAULT_REQUEST_TIMEOUT_MS, type DataSpace, type DeleteCredentialsResponse, type DeleteCreditCardResponse, type DeleteFunctionResponse, type DeletePersonaResponse, type DeleteSecretData, type DeleteSecretError, type DeleteSecretErrors, type DeleteSecretResponse, type DeleteSecretResponses, type DeleteSessionFileData, type DeleteSessionFileError, type DeleteSessionFileErrors, type DeleteSessionFileResponse, type DeleteSessionFileResponses, type DeleteVaultResponse, type DisconnectPaymentWalletData, type DisconnectPaymentWalletError, type DisconnectPaymentWalletErrors, type DisconnectPaymentWalletResponse, type DisconnectPaymentWalletResponses, type DownloadFileActionInput, type DownloadFileActionOutput, type DownloadSessionFileData, type DownloadSessionFileError, type DownloadSessionFileErrors, type DownloadSessionFileResponses, type EmailReadAction, type EmailResponse, type EmailVerificationReadAction, Encryption, type EvaluateJsAction, EvaluateJsNoDataError, type ExecuteAction, type ExecuteOptions, type ExecutionResponse, type ExternalProxy, FUNCTION_RUN_ENDPOINTS, FUNCTION_RUN_TIMEOUT_MS, FailedToRunCloudFunctionError, type FallbackFillActionInput, type FallbackFillActionInputWritable, type FallbackFillActionOutput, type FallbackFillActionOutputWritable, type FetchData, FetchResponseDecodeError, type FileDownloadOptions, FileExistsError, type FileListOptions, FileNotFoundError, type FileSource, type FillActionInput, type FillActionInputWritable, type FillActionOutput, type FillActionOutputWritable, type FormFillAction, type FormFillActionWritable, type FrameData, type FunctionConstructor, type FunctionConstructorCreate, type FunctionConstructorWithId, type FunctionCreateData, type FunctionCreateError, type FunctionCreateErrors, type FunctionCreateResponse, type FunctionCreateResponses, type FunctionDeleteData, type FunctionDeleteError, type FunctionDeleteErrors, type FunctionDeleteResponse, type FunctionDeleteResponses, type FunctionDownloadOptions, type FunctionDownloadUrlData, type FunctionDownloadUrlError, type FunctionDownloadUrlErrors, type FunctionDownloadUrlResponse, type FunctionDownloadUrlResponses, type FunctionForkData, type FunctionForkError, type FunctionForkErrors, type FunctionForkResponse, type FunctionForkResponses, type FunctionGetOptions, type FunctionListItemResponse, type FunctionListItemResponseWritable, type FunctionListOptions, type FunctionMetadataUpdateData, type FunctionMetadataUpdateError, type FunctionMetadataUpdateErrors, type FunctionMetadataUpdateOptions, type FunctionMetadataUpdateRequest, type FunctionMetadataUpdateResponse, type FunctionMetadataUpdateResponses, type FunctionResponse, type FunctionResponseWritable, type FunctionRollbackData, type FunctionRollbackError, type FunctionRollbackErrors, type FunctionRollbackOptions, type FunctionRollbackRequest, type FunctionRollbackResponse, type FunctionRollbackResponses, type FunctionRunCreateOptions, type FunctionRunCreateResult, type FunctionRunGetMetadataData, type FunctionRunGetMetadataError, type FunctionRunGetMetadataErrors, type FunctionRunGetMetadataResponse, type FunctionRunGetMetadataResponses, type FunctionRunListItemResponse, type FunctionRunListItemResponseWritable, type FunctionRunListOptions, type FunctionRunOptions, type FunctionRunResponse, type FunctionRunResult, type FunctionRunStartData, type FunctionRunStartError, type FunctionRunStartErrors, type FunctionRunStartResponses, type FunctionRunStartResult, type FunctionRunStatus, type FunctionRunStopData, type FunctionRunStopError, type FunctionRunStopErrors, type FunctionRunStopResponse, type FunctionRunStopResponses, type FunctionRunUpdateMetadataData, type FunctionRunUpdateMetadataError, type FunctionRunUpdateMetadataErrors, type FunctionRunUpdateMetadataResponse, type FunctionRunUpdateMetadataResponses, type FunctionRunUpdateRequest, type FunctionRuntime, type FunctionRuntimeHealthData, type FunctionRuntimeHealthError, type FunctionRuntimeHealthErrors, type FunctionRuntimeHealthResponse, type FunctionRuntimeHealthResponse2, type FunctionRuntimeHealthResponses, type FunctionScheduleCreateRequest, type FunctionScheduleDeleteData, type FunctionScheduleDeleteError, type FunctionScheduleDeleteErrors, type FunctionScheduleDeleteResponse, type FunctionScheduleDeleteResponses, type FunctionScheduleOptions, type FunctionScheduleSetData, type FunctionScheduleSetError, type FunctionScheduleSetErrors, type FunctionScheduleSetResponse, type FunctionScheduleSetResponses, type FunctionSource, type FunctionUpdateData, type FunctionUpdateError, type FunctionUpdateErrors, type FunctionUpdateOptions, type FunctionUpdateResponse, type FunctionUpdateResponses, type FunctionUrlOptions, type FunctionWithLinkResponse, type FunctionWithLinkResponseWritable, type GetCookiesResponse, type GetCredentialsResponse, type GetCreditCardResponse, type GetFunctionRunResponse, type GetFunctionRunResponseWritable, type GetPaymentData, type GetPaymentError, type GetPaymentErrors, type GetPaymentResponse, type GetPaymentResponses, type GetScriptData, type GetScriptError, type GetScriptErrors, type GetScriptResponse, type GetScriptResponses, type GetSecretData, type GetSecretError, type GetSecretErrors, type GetSecretResponse, type GetSecretResponses, type GetSessionScriptData, type GetSessionScriptError, type GetSessionScriptErrors, type GetSessionScriptResponse, type GetSessionScriptResponses, type GetUsageData, type GetUsageError, type GetUsageErrors, type GetUsageLogsData, type GetUsageLogsError, type GetUsageLogsErrors, type GetUsageLogsResponse, type GetUsageLogsResponses, type GetUsageResponse, type GetUsageResponses, type GlobalScrapeOptions, type GlobalScrapeRequest, type GoBackAction, type GoForwardAction, type GotoAction, type GotoNewTabAction, type HealthCheckData, type HealthCheckResponse, type HealthCheckResponses, type HealthResponse, type HelpAction, type HttpValidationError, type ImageCategory, type ImageData, type ImprovePromptData, type ImprovePromptError, type ImprovePromptErrors, type ImprovePromptRequest, type ImprovePromptResponse, type ImprovePromptResponse2, type ImprovePromptResponses, InvalidRequestError, type LegacyAgentStatusResponse, type ListAgentsData, type ListAgentsError, type ListAgentsErrors, type ListAgentsResponse, type ListAgentsResponses, type ListCredentialsResponse, type ListFunctionRunsByFunctionIdData, type ListFunctionRunsByFunctionIdError, type ListFunctionRunsByFunctionIdErrors, type ListFunctionRunsByFunctionIdResponse, type ListFunctionRunsByFunctionIdResponses, type ListFunctionsData, type ListFunctionsError, type ListFunctionsErrors, type ListFunctionsResponse, type ListFunctionsResponses, type ListPersonasData, type ListPersonasError, type ListPersonasErrors, type ListPersonasResponse, type ListPersonasResponses, type ListSecretsData, type ListSecretsError, type ListSecretsErrors, type ListSecretsResponse, type ListSecretsResponses, type ListSessionFilesData, type ListSessionFilesError, type ListSessionFilesErrors, type ListSessionFilesResponse, type ListSessionFilesResponses, type ListSessionsData, type ListSessionsError, type ListSessionsErrors, type ListSessionsResponse, type ListSessionsResponses, type ListVaultsData, type ListVaultsError, type ListVaultsErrors, type ListVaultsResponse, type ListVaultsResponses, type LlmModel, type MailboxConnectRequest, type MailboxConnectResponse, type MailboxConnectTokenData, type MailboxConnectTokenError, type MailboxConnectTokenErrors, type MailboxConnectTokenResponse, type MailboxConnectTokenResponses, type MailboxConnection, type MailboxDeleteData, type MailboxDeleteError, type MailboxDeleteErrors, type MailboxDeleteResponse, type MailboxDeleteResponses, type MailboxGetData, type MailboxGetError, type MailboxGetErrors, type MailboxGetResponse, type MailboxGetResponses, type MailboxListData, type MailboxListError, type MailboxListErrors, type MailboxListResponse, type MailboxListResponse2, type MailboxListResponses, type MailboxSyncData, type MailboxSyncError, type MailboxSyncErrors, type MailboxSyncRequest, type MailboxSyncResponse, type MailboxSyncResponses, type MailboxUpdateData, type MailboxUpdateError, type MailboxUpdateErrors, type MailboxUpdateRequest, type MailboxUpdateResponse, type MailboxUpdateResponses, type ManagedAuthConnectLinkCreateData, type ManagedAuthConnectLinkCreateError, type ManagedAuthConnectLinkCreateErrors, type ManagedAuthConnectLinkCreateResponse, type ManagedAuthConnectLinkCreateResponses, type ManagedAuthCredentials, type ManagedAuthCredentialsWritable, ManagedAuthError, type ManagedAuthOperation, type ManagedAuthReadiness, type ManagedAuthRunOptions, type ManagedAuthRunResponse, type MessageReadOptions, type MultiFactorFillActionInput, type MultiFactorFillActionInputWritable, type MultiFactorFillActionOutput, type MultiFactorFillActionOutputWritable, type NetworkBatchFile, type NetworkLogsResponse, type NodeSelectors, NotteAPIError, type NotteAPIErrorBody, NotteAPIExecutionError, NotteAnything, NotteClient, type NotteClientConfig, NotteError, NotteFunction, NotteManagedAuth, NottePersona, type NotteProxy, NotteSecrets, NotteTimeoutError, NotteUsage, NotteVault, type NudgePromptData, type NudgePromptError, type NudgePromptErrors, type NudgePromptRequest, type NudgePromptResponse, type NudgePromptResponse2, type NudgePromptResponses, type Observation, type ObservationWritable, type ObserveRequest, type Options, type PageExecuteData, type PageExecuteError, type PageExecuteErrors, type PageExecuteResponse, type PageExecuteResponses, PageFetchHTTPError, type PageFetchOptions, PageFetchResponse, type PageObserveData, type PageObserveError, type PageObserveErrors, type PageObserveResponse, type PageObserveResponses, type PageScrapeData, type PageScrapeError, type PageScrapeErrors, type PageScrapeResponse, type PageScrapeResponses, type PageScreenshotData, type PageScreenshotError, type PageScreenshotErrors, type PageScreenshotResponses, type PaginatedResponseAgentResponse, type PaginatedResponseAgentResponseWritable, type PaginatedResponseFunctionListItemResponse, type PaginatedResponseFunctionListItemResponseWritable, type PaginatedResponseFunctionRunListItemResponse, type PaginatedResponseFunctionRunListItemResponseWritable, type PaginatedResponsePersonaResponse, type PaginatedResponsePersonaResponseWritable, type PaginatedResponseProfileResponse, type PaginatedResponseProfileResponseWritable, type PaginatedResponseSessionResponse, type PaginatedResponseSessionResponseWritable, type PaginatedResponseUsageLog, type PaginatedResponseUsageLogWritable, type PaginatedResponseVault, type PaginatedResponseVaultWritable, type ParameterInfo, type PaymentConnectRequest, type PaymentConnectionResponse, type PaymentDisconnectError, type PaymentDisconnectResponse, type PaymentNextAction, type PaymentRequest, type PaymentResponse, type PerceptionType, type PersonaConstructor, type PersonaCreateData, type PersonaCreateError, type PersonaCreateErrors, type PersonaCreateRequest, type PersonaCreateResponse, type PersonaCreateResponses, type PersonaDeleteData, type PersonaDeleteError, type PersonaDeleteErrors, type PersonaDeleteResponse, type PersonaDeleteResponses, type PersonaEmailsListData, type PersonaEmailsListError, type PersonaEmailsListErrors, type PersonaEmailsListResponse, type PersonaEmailsListResponses, type PersonaGetData, type PersonaGetError, type PersonaGetErrors, type PersonaGetResponse, type PersonaGetResponses, type PersonaListOptions, type PersonaResponse, type PersonaResponseWithInternalEmail, type PersonaSmsListData, type PersonaSmsListError, type PersonaSmsListErrors, type PersonaSmsListResponse, type PersonaSmsListResponses, type PersonaUpdateData, type PersonaUpdateError, type PersonaUpdateErrors, type PersonaUpdateRequest, type PersonaUpdateResponse, type PersonaUpdateResponses, type PressKeyAction, type ProfileCookiesGetData, type ProfileCookiesGetError, type ProfileCookiesGetErrors, type ProfileCookiesGetResponse, type ProfileCookiesGetResponses, type ProfileCookiesImportRequest, type ProfileCookiesImportResponse, type ProfileCookiesSetData, type ProfileCookiesSetError, type ProfileCookiesSetErrors, type ProfileCookiesSetResponse, type ProfileCookiesSetResponses, type ProfileCreateData, type ProfileCreateError, type ProfileCreateErrors, type ProfileCreateRequest, type ProfileCreateResponse, type ProfileCreateResponses, type ProfileDeleteData, type ProfileDeleteError, type ProfileDeleteErrors, type ProfileDeleteResponse, type ProfileDeleteResponse2, type ProfileDeleteResponses, type ProfileDuplicateData, type ProfileDuplicateError, type ProfileDuplicateErrors, type ProfileDuplicateRequest, type ProfileDuplicateResponse, type ProfileDuplicateResponses, type ProfileGetData, type ProfileGetError, type ProfileGetErrors, type ProfileGetResponse, type ProfileGetResponses, type ProfileListData, type ProfileListError, type ProfileListErrors, type ProfileListResponse, type ProfileListResponses, type ProfileResponse, type ProxyGeolocationCountry, RUN_API_KEY_HEADER, type ReadyCheckData, type ReadyCheckResponse, type ReadyCheckResponses, type ReloadAction, RemoteFileStorage, type ReplayMissingResponse, type ReplayOptions, type ReplayResponse, type ResourceRequestOptions, type RetryOptions, type RootModelAny, type RunFunctionRequest, type RuntimePackage, SESSION_START_TRIES, type ScheduleDeleteResponse, type ScheduleResponse, type SchemaGenerationResponse, type ScrapeAction, ScrapeFailedError, type ScrapeFromHtmlData, type ScrapeFromHtmlError, type ScrapeFromHtmlErrors, type ScrapeFromHtmlRequest, type ScrapeFromHtmlResponse, type ScrapeFromHtmlResponses, type ScrapeOptions, type ScrapeRequest, type ScrapeResult, type ScrapeSchemaResponse, type ScrapeWebpageData, type ScrapeWebpageError, type ScrapeWebpageErrors, type ScrapeWebpageResponse, type ScrapeWebpageResponses, type Screenshot, type ScrollDownAction, type ScrollUpAction, type SearchOptions, type SearchRequest, type SearchResponse, type SearchResultItem, type SearchResultsResponse, type SearchSource, type SearchSourcedAnswerResponse, type SearchStructuredResponse, type SearchWebData, type SearchWebError, type SearchWebErrors, type SearchWebResponses, type SecretListOptions, type SecretListResponse, type SecretMetadata, type SecretNamespace, type SecretStoreOptions, type SecretStoreRequest, type SecretValueResponse, type SelectDropdownOptionActionInput, type SelectDropdownOptionActionInputWritable, type SelectDropdownOptionActionOutput, type SelectDropdownOptionActionOutputWritable, type SerializedError, Session, type SessionAuthReadinessData, type SessionAuthReadinessError, type SessionAuthReadinessErrors, type SessionAuthReadinessResponse, type SessionAuthReadinessResponses, type SessionCloseReason, type SessionCookiesGetData, type SessionCookiesGetError, type SessionCookiesGetErrors, type SessionCookiesGetResponse, type SessionCookiesGetResponses, type SessionCookiesSetData, type SessionCookiesSetError, type SessionCookiesSetErrors, type SessionCookiesSetResponse, type SessionCookiesSetResponses, type SessionDebugInfoData, type SessionDebugInfoError, type SessionDebugInfoErrors, type SessionDebugInfoResponse, type SessionDebugInfoResponses, type SessionDebugResponse, type SessionFile, SessionFiles, type SessionFilesPage, type SessionListOptions, type SessionNetworkLogsData, type SessionNetworkLogsError, type SessionNetworkLogsErrors, type SessionNetworkLogsResponse, type SessionNetworkLogsResponses, type SessionOffsetData, type SessionOffsetError, type SessionOffsetErrors, type SessionOffsetResponse, type SessionOffsetResponse2, type SessionOffsetResponses, type SessionOptions, type SessionProfile, type SessionProfilePreviewData, type SessionProfilePreviewError, type SessionProfilePreviewErrors, type SessionProfilePreviewResponse, type SessionProfilePreviewResponse2, type SessionProfilePreviewResponses, type SessionReplayData, type SessionReplayError, type SessionReplayErrors, type SessionReplayResponse, type SessionReplayResponses, type AuthSessionResponse as SessionResponse, type SessionResponseWritable, type SessionScrapeOptions, type SessionScriptOptions, type SessionStartData, type SessionStartError, type SessionStartErrors, type SessionStartOptions, type SessionStartResponse, type SessionStartResponses, type SessionStatusData, type SessionStatusError, type SessionStatusErrors, type SessionStatusResponse, type SessionStatusResponses, type SessionStopData, type SessionStopError, type SessionStopErrors, type SessionStopResponse, type SessionStopResponses, type SmsReadAction, type SmsResponse, type SnapshotMetadata, type SpaceCategory, type StoreSecretData, type StoreSecretError, type StoreSecretErrors, type StoreSecretResponse, type StoreSecretResponses, type StructuredData, type StructuredDataBaseModel, type SubscriptionType, type SwitchTabAction, TIMEOUT_HEADER, type TabSessionDebugResponse, type TabsData, type TailnetProxy, type UpdateFunctionRunResponse, type UpdateFunctionRunResponseWritable, type UploadFileActionInput, type UploadFileActionOutput, type UploadSessionFileData, type UploadSessionFileError, type UploadSessionFileErrors, type UploadSessionFileResponse, type UploadSessionFileResponses, type UploadableFile, type UsageLog, type UsageLogEndpoint, type UsageLogsOptions, type UsageOptions, type UsageResponse, type ValidationError, type Vault, type VaultConstructor, type VaultConstructorCreate, type VaultConstructorWithId, type VaultCreateData, type VaultCreateError, type VaultCreateErrors, type VaultCreateRequest, type VaultCreateResponse, type VaultCreateResponses, type VaultCredentialsAddData, type VaultCredentialsAddError, type VaultCredentialsAddErrors, type VaultCredentialsAddResponse, type VaultCredentialsAddResponses, type VaultCredentialsDeleteData, type VaultCredentialsDeleteError, type VaultCredentialsDeleteErrors, type VaultCredentialsDeleteResponse, type VaultCredentialsDeleteResponses, type VaultCredentialsGetData, type VaultCredentialsGetError, type VaultCredentialsGetErrors, type VaultCredentialsGetResponse, type VaultCredentialsGetResponses, type VaultCredentialsListData, type VaultCredentialsListError, type VaultCredentialsListErrors, type VaultCredentialsListResponse, type VaultCredentialsListResponses, type VaultCreditCardDeleteData, type VaultCreditCardDeleteError, type VaultCreditCardDeleteErrors, type VaultCreditCardDeleteResponse, type VaultCreditCardDeleteResponses, type VaultCreditCardGetData, type VaultCreditCardGetError, type VaultCreditCardGetErrors, type VaultCreditCardGetResponse, type VaultCreditCardGetResponses, type VaultCreditCardSetData, type VaultCreditCardSetError, type VaultCreditCardSetErrors, type VaultCreditCardSetResponse, type VaultCreditCardSetResponses, type VaultDeleteData, type VaultDeleteError, type VaultDeleteErrors, type VaultDeleteResponse, type VaultDeleteResponses, type VaultListOptions, type VaultUpdateData, type VaultUpdateError, type VaultUpdateErrors, type VaultUpdateRequest, type VaultUpdateResponse, type VaultUpdateResponses, type ViewportData, type WaitAction, type WebSocketUrls, type ZodLikeSchema, actions, agentStart, agentStatus, agentStop, anythingStart, buildFetchScript, checkForLatestVersion, client, connectLinkContext, connectLinkMailboxConnect, connectLinkMailboxSync, connectLinkMailboxes, connectLinkStatus, connectLinkSubmit, connectPaymentWallet, createClient, createOrAppendCookiesToFile, createPayment, NotteClient as default, deleteSecret, deleteSessionFile, disconnectPaymentWallet, downloadSessionFile, functionCreate, functionDelete, functionDownloadUrl, functionFork, functionMetadataUpdate, functionRollback, functionRunGetMetadata, functionRunStart, functionRunStop, functionRunUpdateMetadata, functionRuntimeHealth, functionScheduleDelete, functionScheduleSet, functionUpdate, getPayment, getRootDomain, getScript, getSecret, getSessionScript, getUsage, getUsageLogs, healthCheck, improvePrompt, installServerOwnedDialogPolicy, isCaptchaSolveAction, isValidMfaSecret, listAgents, listFunctionRunsByFunctionId, listFunctions, listPersonas, listSecrets, listSessionFiles, listSessions, listVaults, mailboxConnectToken, mailboxDelete, mailboxGet, mailboxList, mailboxSync, mailboxUpdate, managedAuthConnectLinkCreate, nudgePrompt, observeServerOwnedDialog, pageExecute, pageObserve, pageScrape, pageScreenshot, parseAgentStatusMessage, personaCreate, personaDelete, personaEmailsList, personaGet, personaSmsList, personaUpdate, prepareAgentRequest, processScrapeResponse, profileCookiesGet, profileCookiesSet, profileCreate, profileDelete, profileDuplicate, profileGet, profileList, readCookiesFile, readyCheck, responseFromEvaluated, retry, sanitizeFilename, scrapeFromHtml, scrapeWebpage, searchWeb, sessionAuthReadiness, sessionCookiesGet, sessionCookiesSet, sessionDebugInfo, sessionNetworkLogs, sessionOffset, sessionProfilePreview, sessionReplay, sessionStart, sessionStatus, sessionStop, startVersionCheck, storeSecret, uploadSessionFile, validateCredentials, validateMfaSecret, validateUrl, vaultCreate, vaultCredentialsAdd, vaultCredentialsDelete, vaultCredentialsGet, vaultCredentialsList, vaultCreditCardDelete, vaultCreditCardGet, vaultCreditCardSet, vaultDelete, vaultUpdate };