@expandai/sdk 0.19.0 → 0.20.0

package/build/dts/Generated.d.ts

@@ -4,13 +4,25 @@ import * as HttpClientError from '@effect/platform/HttpClientError';
 import * as Effect from 'effect/Effect';
 import type { ParseError } from 'effect/ParseResult';
 import * as S from 'effect/Schema';
+declare const FetchFetchParamsAppendixMarkers_base: S.Literal<["off", "compact", "detailed"]>;
+export declare class FetchFetchParamsAppendixMarkers extends FetchFetchParamsAppendixMarkers_base {
+}
 declare const FetchFetchParams_base: S.Struct<{
     include: S.optionalWith<typeof S.String, {
         nullable: true;
     }>;
+    appendixMarkers: S.optionalWith<typeof FetchFetchParamsAppendixMarkers, {
+        nullable: true;
+    }>;
 }>;
 export declare class FetchFetchParams extends FetchFetchParams_base {
 }
+declare const FetchFetchRequestIncludeAppendixMarkers_base: S.Literal<["off", "compact", "detailed"]>;
+export declare class FetchFetchRequestIncludeAppendixMarkers extends FetchFetchRequestIncludeAppendixMarkers_base {
+}
+declare const FetchFetchRequestDocumentConfigOcr_base: S.Literal<["auto", "never", "always"]>;
+export declare class FetchFetchRequestDocumentConfigOcr extends FetchFetchRequestDocumentConfigOcr_base {
+}
 declare const FetchFetchRequest_base: S.Class<FetchFetchRequest, {
     url: typeof S.String;
     include: S.optionalWith<S.Struct<{
@@ -60,10 +72,14 @@ declare const FetchFetchRequest_base: S.Class<FetchFetchRequest, {
         appendix: S.optionalWith<typeof S.Boolean, {
             nullable: true;
         }>;
+        appendixMarkers: S.optionalWith<typeof FetchFetchRequestIncludeAppendixMarkers, {
+            nullable: true;
+            default: () => "compact";
+        }>;
     }>, {
         nullable: true;
     }>;
-    search: S.optionalWith<S.Struct<{
+    highlights: S.optionalWith<S.Struct<{
         query: typeof S.String;
         maxResults: S.optionalWith<S.filter<S.filter<typeof S.Int>>, {
             nullable: true;
@@ -84,6 +100,21 @@ declare const FetchFetchRequest_base: S.Class<FetchFetchRequest, {
     }>, {
         nullable: true;
     }>;
+    documentConfig: S.optionalWith<S.Struct<{
+        maxPages: S.optionalWith<S.filter<typeof S.Int>, {
+            nullable: true;
+        }>;
+        maxAudioSeconds: S.optionalWith<S.filter<S.filter<typeof S.Int>>, {
+            nullable: true;
+            default: () => 3600;
+        }>;
+        ocr: S.optionalWith<typeof FetchFetchRequestDocumentConfigOcr, {
+            nullable: true;
+            default: () => "auto";
+        }>;
+    }>, {
+        nullable: true;
+    }>;
 }, S.Struct.Encoded<{
     url: typeof S.String;
     include: S.optionalWith<S.Struct<{
@@ -133,10 +164,14 @@ declare const FetchFetchRequest_base: S.Class<FetchFetchRequest, {
         appendix: S.optionalWith<typeof S.Boolean, {
             nullable: true;
         }>;
+        appendixMarkers: S.optionalWith<typeof FetchFetchRequestIncludeAppendixMarkers, {
+            nullable: true;
+            default: () => "compact";
+        }>;
     }>, {
         nullable: true;
     }>;
-    search: S.optionalWith<S.Struct<{
+    highlights: S.optionalWith<S.Struct<{
         query: typeof S.String;
         maxResults: S.optionalWith<S.filter<S.filter<typeof S.Int>>, {
             nullable: true;
@@ -157,10 +192,37 @@ declare const FetchFetchRequest_base: S.Class<FetchFetchRequest, {
     }>, {
         nullable: true;
     }>;
+    documentConfig: S.optionalWith<S.Struct<{
+        maxPages: S.optionalWith<S.filter<typeof S.Int>, {
+            nullable: true;
+        }>;
+        maxAudioSeconds: S.optionalWith<S.filter<S.filter<typeof S.Int>>, {
+            nullable: true;
+            default: () => 3600;
+        }>;
+        ocr: S.optionalWith<typeof FetchFetchRequestDocumentConfigOcr, {
+            nullable: true;
+            default: () => "auto";
+        }>;
+    }>, {
+        nullable: true;
+    }>;
 }>, never, {
     readonly browserConfig?: {
         readonly scrollFullPage: boolean;
     } | undefined;
+} & {
+    readonly documentConfig?: {
+        readonly maxPages?: number | undefined;
+        readonly maxAudioSeconds: number;
+        readonly ocr: "always" | "auto" | "never";
+    } | undefined;
+} & {
+    readonly highlights?: {
+        readonly query: string;
+        readonly maxResults: number;
+        readonly minScore: number;
+    } | undefined;
 } & {
     readonly include?: {
         readonly html?: boolean | {
@@ -183,12 +245,7 @@ declare const FetchFetchRequest_base: S.Class<FetchFetchRequest, {
         } | undefined;
         readonly json: boolean;
         readonly appendix?: boolean | undefined;
-    } | undefined;
-} & {
-    readonly search?: {
-        readonly query: string;
-        readonly maxResults: number;
-        readonly minScore: number;
+        readonly appendixMarkers: "compact" | "detailed" | "off";
     } | undefined;
 } & {
     readonly url: string;
@@ -292,6 +349,68 @@ declare const FetchFetch403_base: S.Union<[S.Struct<{
 }>, typeof FetchBlocked]>;
 export declare class FetchFetch403 extends FetchFetch403_base {
 }
+declare const FetchOriginNotFoundTag_base: S.Literal<["FetchOriginHttpError"]>;
+export declare class FetchOriginNotFoundTag extends FetchOriginNotFoundTag_base {
+}
+declare const FetchOriginNotFoundStatusCode_base: S.Literal<[404]>;
+export declare class FetchOriginNotFoundStatusCode extends FetchOriginNotFoundStatusCode_base {
+}
+declare const FetchOriginNotFound_base: S.Class<FetchOriginNotFound, {
+    _tag: typeof FetchOriginNotFoundTag;
+    url: typeof S.String;
+    statusCode: typeof FetchOriginNotFoundStatusCode;
+    contentType: S.optionalWith<typeof S.String, {
+        nullable: true;
+    }>;
+}, S.Struct.Encoded<{
+    _tag: typeof FetchOriginNotFoundTag;
+    url: typeof S.String;
+    statusCode: typeof FetchOriginNotFoundStatusCode;
+    contentType: S.optionalWith<typeof S.String, {
+        nullable: true;
+    }>;
+}>, never, {
+    readonly contentType?: string | undefined;
+} & {
+    readonly _tag: "FetchOriginHttpError";
+} & {
+    readonly statusCode: 404;
+} & {
+    readonly url: string;
+}, {}, {}>;
+export declare class FetchOriginNotFound extends FetchOriginNotFound_base {
+}
+declare const FetchOriginGoneTag_base: S.Literal<["FetchOriginHttpError"]>;
+export declare class FetchOriginGoneTag extends FetchOriginGoneTag_base {
+}
+declare const FetchOriginGoneStatusCode_base: S.Literal<[410]>;
+export declare class FetchOriginGoneStatusCode extends FetchOriginGoneStatusCode_base {
+}
+declare const FetchOriginGone_base: S.Class<FetchOriginGone, {
+    _tag: typeof FetchOriginGoneTag;
+    url: typeof S.String;
+    statusCode: typeof FetchOriginGoneStatusCode;
+    contentType: S.optionalWith<typeof S.String, {
+        nullable: true;
+    }>;
+}, S.Struct.Encoded<{
+    _tag: typeof FetchOriginGoneTag;
+    url: typeof S.String;
+    statusCode: typeof FetchOriginGoneStatusCode;
+    contentType: S.optionalWith<typeof S.String, {
+        nullable: true;
+    }>;
+}>, never, {
+    readonly contentType?: string | undefined;
+} & {
+    readonly _tag: "FetchOriginHttpError";
+} & {
+    readonly statusCode: 410;
+} & {
+    readonly url: string;
+}, {}, {}>;
+export declare class FetchOriginGone extends FetchOriginGone_base {
+}
 declare const PayloadTooLargeTag_base: S.Literal<["PayloadTooLarge"]>;
 export declare class PayloadTooLargeTag extends PayloadTooLargeTag_base {
 }
@@ -300,7 +419,7 @@ declare const PayloadTooLarge_base: S.Struct<{
 }>;
 export declare class PayloadTooLarge extends PayloadTooLarge_base {
 }
-declare const FetchPageTooLargeLimitKind_base: S.Literal<["transfer_bytes", "domsnapshot_bytes", "ast_bytes"]>;
+declare const FetchPageTooLargeLimitKind_base: S.Literal<["transfer_bytes", "domsnapshot_bytes", "ast_bytes", "document_frame_bytes", "document_pages", "audio_seconds"]>;
 export declare class FetchPageTooLargeLimitKind extends FetchPageTooLargeLimitKind_base {
 }
 declare const FetchPageTooLargeTag_base: S.Literal<["FetchPageTooLarge"]>;
@@ -317,6 +436,12 @@ declare const FetchPageTooLarge_base: S.Struct<{
     measuredBytes: S.optionalWith<typeof S.Number, {
         nullable: true;
     }>;
+    limit: S.optionalWith<typeof S.Number, {
+        nullable: true;
+    }>;
+    measured: S.optionalWith<typeof S.Number, {
+        nullable: true;
+    }>;
     _tag: typeof FetchPageTooLargeTag;
 }>;
 export declare class FetchPageTooLarge extends FetchPageTooLarge_base {
@@ -324,81 +449,226 @@ export declare class FetchPageTooLarge extends FetchPageTooLarge_base {
 declare const FetchFetch413_base: S.Union<[typeof PayloadTooLarge, typeof FetchPageTooLarge]>;
 export declare class FetchFetch413 extends FetchFetch413_base {
 }
-declare const TooManyRequestsTag_base: S.Literal<["TooManyRequests"]>;
-export declare class TooManyRequestsTag extends TooManyRequestsTag_base {
+declare const FetchUnsupportedContentTypeTag_base: S.Literal<["FetchUnsupportedContentType"]>;
+export declare class FetchUnsupportedContentTypeTag extends FetchUnsupportedContentTypeTag_base {
 }
-declare const TooManyRequests_base: S.Class<TooManyRequests, {
-    _tag: typeof TooManyRequestsTag;
+declare const FetchUnsupportedContentType_base: S.Class<FetchUnsupportedContentType, {
+    url: typeof S.String;
+    contentType: S.optionalWith<typeof S.String, {
+        nullable: true;
+    }>;
+    _tag: typeof FetchUnsupportedContentTypeTag;
 }, S.Struct.Encoded<{
-    _tag: typeof TooManyRequestsTag;
+    url: typeof S.String;
+    contentType: S.optionalWith<typeof S.String, {
+        nullable: true;
+    }>;
+    _tag: typeof FetchUnsupportedContentTypeTag;
+}>, never, {
+    readonly contentType?: string | undefined;
+} & {
+    readonly _tag: "FetchUnsupportedContentType";
+} & {
+    readonly url: string;
+}, {}, {}>;
+export declare class FetchUnsupportedContentType extends FetchUnsupportedContentType_base {
+}
+declare const FetchVideoUnavailableAvailability_base: S.Literal<["private", "removed", "geoRestricted", "ageRestricted", "membersOnly", "live", "upcoming", "unknown"]>;
+export declare class FetchVideoUnavailableAvailability extends FetchVideoUnavailableAvailability_base {
+}
+declare const FetchVideoUnavailableTag_base: S.Literal<["FetchVideoUnavailable"]>;
+export declare class FetchVideoUnavailableTag extends FetchVideoUnavailableTag_base {
+}
+declare const FetchVideoUnavailable_base: S.Class<FetchVideoUnavailable, {
+    url: typeof S.String;
+    availability: typeof FetchVideoUnavailableAvailability;
+    message: S.optionalWith<typeof S.String, {
+        nullable: true;
+    }>;
+    _tag: typeof FetchVideoUnavailableTag;
+}, S.Struct.Encoded<{
+    url: typeof S.String;
+    availability: typeof FetchVideoUnavailableAvailability;
+    message: S.optionalWith<typeof S.String, {
+        nullable: true;
+    }>;
+    _tag: typeof FetchVideoUnavailableTag;
 }>, never, {
-    readonly _tag: "TooManyRequests";
+    readonly message?: string | undefined;
+} & {
+    readonly _tag: "FetchVideoUnavailable";
+} & {
+    readonly availability: "ageRestricted" | "geoRestricted" | "live" | "membersOnly" | "private" | "removed" | "unknown" | "upcoming";
+} & {
+    readonly url: string;
 }, {}, {}>;
+export declare class FetchVideoUnavailable extends FetchVideoUnavailable_base {
+}
+declare const TooManyRequestsRetryable_base: S.Literal<[true]>;
+export declare class TooManyRequestsRetryable extends TooManyRequestsRetryable_base {
+}
+declare const TooManyRequestsTag_base: S.Literal<["TooManyRequests"]>;
+export declare class TooManyRequestsTag extends TooManyRequestsTag_base {
+}
+declare const TooManyRequests_base: S.Struct<{
+    retryable: S.optionalWith<typeof TooManyRequestsRetryable, {
+        default: () => true;
+    }>;
+    retryAfterSeconds: S.optionalWith<typeof S.Number, {
+        nullable: true;
+    }>;
+    _tag: typeof TooManyRequestsTag;
+}>;
 export declare class TooManyRequests extends TooManyRequests_base {
 }
+declare const FetchConcurrencyLimitExceededRetryable_base: S.Literal<[true]>;
+export declare class FetchConcurrencyLimitExceededRetryable extends FetchConcurrencyLimitExceededRetryable_base {
+}
+declare const FetchConcurrencyLimitExceededTag_base: S.Literal<["FetchConcurrencyLimitExceeded"]>;
+export declare class FetchConcurrencyLimitExceededTag extends FetchConcurrencyLimitExceededTag_base {
+}
+declare const FetchConcurrencyLimitExceeded_base: S.Struct<{
+    retryable: S.optionalWith<typeof FetchConcurrencyLimitExceededRetryable, {
+        default: () => true;
+    }>;
+    retryAfterSeconds: typeof S.Number;
+    maxConcurrency: typeof S.Number;
+    message: S.optionalWith<typeof S.String, {
+        nullable: true;
+    }>;
+    requestId: S.optionalWith<typeof S.String, {
+        nullable: true;
+    }>;
+    _tag: typeof FetchConcurrencyLimitExceededTag;
+}>;
+export declare class FetchConcurrencyLimitExceeded extends FetchConcurrencyLimitExceeded_base {
+}
+declare const FetchFetch429_base: S.Union<[typeof TooManyRequests, typeof FetchConcurrencyLimitExceeded]>;
+export declare class FetchFetch429 extends FetchFetch429_base {
+}
+declare const InternalErrorRetryable_base: S.Literal<[true]>;
+export declare class InternalErrorRetryable extends InternalErrorRetryable_base {
+}
 declare const InternalErrorTag_base: S.Literal<["InternalError"]>;
 export declare class InternalErrorTag extends InternalErrorTag_base {
 }
 declare const InternalError_base: S.Class<InternalError, {
+    retryable: S.optionalWith<typeof InternalErrorRetryable, {
+        default: () => true;
+    }>;
     _tag: typeof InternalErrorTag;
 }, S.Struct.Encoded<{
+    retryable: S.optionalWith<typeof InternalErrorRetryable, {
+        default: () => true;
+    }>;
     _tag: typeof InternalErrorTag;
 }>, never, {
+    readonly retryable?: true | undefined;
+} & {
     readonly _tag: "InternalError";
 }, {}, {}>;
 export declare class InternalError extends InternalError_base {
 }
+declare const FetchCaptureFailedFailureType_base: S.Literal<["pageNeverSettled", "capabilityFailed"]>;
+export declare class FetchCaptureFailedFailureType extends FetchCaptureFailedFailureType_base {
+}
+declare const FetchCaptureFailedRetryable_base: S.Literal<[false]>;
+export declare class FetchCaptureFailedRetryable extends FetchCaptureFailedRetryable_base {
+}
+declare const FetchCaptureFailedTag_base: S.Literal<["FetchCaptureFailed"]>;
+export declare class FetchCaptureFailedTag extends FetchCaptureFailedTag_base {
+}
+declare const FetchCaptureFailed_base: S.Struct<{
+    url: typeof S.String;
+    failureType: typeof FetchCaptureFailedFailureType;
+    retryable: S.optionalWith<typeof FetchCaptureFailedRetryable, {
+        default: () => false;
+    }>;
+    _tag: typeof FetchCaptureFailedTag;
+}>;
+export declare class FetchCaptureFailed extends FetchCaptureFailed_base {
+}
 declare const FetchNavigationFailedFailureType_base: S.Literal<["browserInternalDocument"]>;
 export declare class FetchNavigationFailedFailureType extends FetchNavigationFailedFailureType_base {
 }
+declare const FetchNavigationFailedRetryable_base: S.Literal<[false]>;
+export declare class FetchNavigationFailedRetryable extends FetchNavigationFailedRetryable_base {
+}
 declare const FetchNavigationFailedTag_base: S.Literal<["FetchNavigationFailed"]>;
 export declare class FetchNavigationFailedTag extends FetchNavigationFailedTag_base {
 }
-declare const FetchNavigationFailed_base: S.Class<FetchNavigationFailed, {
-    url: typeof S.String;
-    failureType: typeof FetchNavigationFailedFailureType;
-    _tag: typeof FetchNavigationFailedTag;
-}, S.Struct.Encoded<{
+declare const FetchNavigationFailed_base: S.Struct<{
     url: typeof S.String;
     failureType: typeof FetchNavigationFailedFailureType;
+    retryable: S.optionalWith<typeof FetchNavigationFailedRetryable, {
+        default: () => false;
+    }>;
     _tag: typeof FetchNavigationFailedTag;
-}>, never, {
-    readonly _tag: "FetchNavigationFailed";
-} & {
-    readonly failureType: "browserInternalDocument";
-} & {
-    readonly url: string;
-}, {}, {}>;
+}>;
 export declare class FetchNavigationFailed extends FetchNavigationFailed_base {
 }
+declare const FetchOriginHttpErrorTag_base: S.Literal<["FetchOriginHttpError"]>;
+export declare class FetchOriginHttpErrorTag extends FetchOriginHttpErrorTag_base {
+}
+declare const FetchOriginHttpError_base: S.Struct<{
+    url: typeof S.String;
+    statusCode: typeof S.Number;
+    contentType: S.optionalWith<typeof S.String, {
+        nullable: true;
+    }>;
+    _tag: typeof FetchOriginHttpErrorTag;
+}>;
+export declare class FetchOriginHttpError extends FetchOriginHttpError_base {
+}
+declare const FetchFetch502_base: S.Union<[typeof FetchCaptureFailed, typeof FetchNavigationFailed, typeof FetchOriginHttpError]>;
+export declare class FetchFetch502 extends FetchFetch502_base {
+}
+declare const ServiceUnavailableDispatchOutcome_base: S.Literal<["cancelled_before_start", "cancelled_after_start", "unknown"]>;
+export declare class ServiceUnavailableDispatchOutcome extends ServiceUnavailableDispatchOutcome_base {
+}
+declare const ServiceUnavailableRetryable_base: S.Literal<[true]>;
+export declare class ServiceUnavailableRetryable extends ServiceUnavailableRetryable_base {
+}
 declare const ServiceUnavailableTag_base: S.Literal<["ServiceUnavailable"]>;
 export declare class ServiceUnavailableTag extends ServiceUnavailableTag_base {
 }
-declare const ServiceUnavailable_base: S.Class<ServiceUnavailable, {
+declare const ServiceUnavailable_base: S.Struct<{
     message: S.optionalWith<typeof S.String, {
         nullable: true;
     }>;
     requestId: S.optionalWith<typeof S.String, {
         nullable: true;
     }>;
-    _tag: typeof ServiceUnavailableTag;
-}, S.Struct.Encoded<{
-    message: S.optionalWith<typeof S.String, {
+    dispatchOutcome: S.optionalWith<typeof ServiceUnavailableDispatchOutcome, {
         nullable: true;
     }>;
-    requestId: S.optionalWith<typeof S.String, {
-        nullable: true;
+    retryable: S.optionalWith<typeof ServiceUnavailableRetryable, {
+        default: () => true;
     }>;
     _tag: typeof ServiceUnavailableTag;
-}>, never, {
-    readonly message?: string | undefined;
-} & {
-    readonly requestId?: string | undefined;
-} & {
-    readonly _tag: "ServiceUnavailable";
-}, {}, {}>;
+}>;
 export declare class ServiceUnavailable extends ServiceUnavailable_base {
 }
+declare const FetchDocumentProcessingUnavailableOperation_base: S.Literal<["ocr", "transcription", "video"]>;
+export declare class FetchDocumentProcessingUnavailableOperation extends FetchDocumentProcessingUnavailableOperation_base {
+}
+declare const FetchDocumentProcessingUnavailableTag_base: S.Literal<["FetchDocumentProcessingUnavailable"]>;
+export declare class FetchDocumentProcessingUnavailableTag extends FetchDocumentProcessingUnavailableTag_base {
+}
+declare const FetchDocumentProcessingUnavailable_base: S.Struct<{
+    url: typeof S.String;
+    operation: typeof FetchDocumentProcessingUnavailableOperation;
+    message: typeof S.String;
+    _tag: typeof FetchDocumentProcessingUnavailableTag;
+}>;
+export declare class FetchDocumentProcessingUnavailable extends FetchDocumentProcessingUnavailable_base {
+}
+declare const FetchFetch503_base: S.Union<[typeof ServiceUnavailable, typeof FetchDocumentProcessingUnavailable]>;
+export declare class FetchFetch503 extends FetchFetch503_base {
+}
+declare const FetchCaptureTimeoutRetryable_base: S.Literal<[false]>;
+export declare class FetchCaptureTimeoutRetryable extends FetchCaptureTimeoutRetryable_base {
+}
 declare const FetchCaptureTimeoutTag_base: S.Literal<["FetchCaptureTimeout"]>;
 export declare class FetchCaptureTimeoutTag extends FetchCaptureTimeoutTag_base {
 }
@@ -407,15 +677,23 @@ declare const FetchCaptureTimeout_base: S.Class<FetchCaptureTimeout, {
     timeoutMs: S.optionalWith<typeof S.Number, {
         nullable: true;
     }>;
+    retryable: S.optionalWith<typeof FetchCaptureTimeoutRetryable, {
+        default: () => false;
+    }>;
     _tag: typeof FetchCaptureTimeoutTag;
 }, S.Struct.Encoded<{
     url: typeof S.String;
     timeoutMs: S.optionalWith<typeof S.Number, {
         nullable: true;
     }>;
+    retryable: S.optionalWith<typeof FetchCaptureTimeoutRetryable, {
+        default: () => false;
+    }>;
     _tag: typeof FetchCaptureTimeoutTag;
 }>, never, {
     readonly timeoutMs?: number | undefined;
+} & {
+    readonly retryable?: false | undefined;
 } & {
     readonly _tag: "FetchCaptureTimeout";
 } & {
@@ -423,6 +701,9 @@ declare const FetchCaptureTimeout_base: S.Class<FetchCaptureTimeout, {
 }, {}, {}>;
 export declare class FetchCaptureTimeout extends FetchCaptureTimeout_base {
 }
+declare const FetchCapacityTimeoutRetryable_base: S.Literal<[true]>;
+export declare class FetchCapacityTimeoutRetryable extends FetchCapacityTimeoutRetryable_base {
+}
 declare const FetchCapacityTimeoutTag_base: S.Literal<["FetchCapacityTimeout"]>;
 export declare class FetchCapacityTimeoutTag extends FetchCapacityTimeoutTag_base {
 }
@@ -431,15 +712,23 @@ declare const FetchCapacityTimeout_base: S.Class<FetchCapacityTimeout, {
     timeoutMs: S.optionalWith<typeof S.Number, {
         nullable: true;
     }>;
+    retryable: S.optionalWith<typeof FetchCapacityTimeoutRetryable, {
+        default: () => true;
+    }>;
     _tag: typeof FetchCapacityTimeoutTag;
 }, S.Struct.Encoded<{
     url: typeof S.String;
     timeoutMs: S.optionalWith<typeof S.Number, {
         nullable: true;
     }>;
+    retryable: S.optionalWith<typeof FetchCapacityTimeoutRetryable, {
+        default: () => true;
+    }>;
     _tag: typeof FetchCapacityTimeoutTag;
 }>, never, {
     readonly timeoutMs?: number | undefined;
+} & {
+    readonly retryable?: true | undefined;
 } & {
     readonly _tag: "FetchCapacityTimeout";
 } & {
@@ -447,13 +736,25 @@ declare const FetchCapacityTimeout_base: S.Class<FetchCapacityTimeout, {
 }, {}, {}>;
 export declare class FetchCapacityTimeout extends FetchCapacityTimeout_base {
 }
+declare const FetchFetchJsonParamsAppendixMarkers_base: S.Literal<["off", "compact", "detailed"]>;
+export declare class FetchFetchJsonParamsAppendixMarkers extends FetchFetchJsonParamsAppendixMarkers_base {
+}
 declare const FetchFetchJsonParams_base: S.Struct<{
     include: S.optionalWith<typeof S.String, {
         nullable: true;
     }>;
+    appendixMarkers: S.optionalWith<typeof FetchFetchJsonParamsAppendixMarkers, {
+        nullable: true;
+    }>;
 }>;
 export declare class FetchFetchJsonParams extends FetchFetchJsonParams_base {
 }
+declare const FetchFetchJsonRequestIncludeAppendixMarkers_base: S.Literal<["off", "compact", "detailed"]>;
+export declare class FetchFetchJsonRequestIncludeAppendixMarkers extends FetchFetchJsonRequestIncludeAppendixMarkers_base {
+}
+declare const FetchFetchJsonRequestDocumentConfigOcr_base: S.Literal<["auto", "never", "always"]>;
+export declare class FetchFetchJsonRequestDocumentConfigOcr extends FetchFetchJsonRequestDocumentConfigOcr_base {
+}
 declare const FetchFetchJsonRequest_base: S.Class<FetchFetchJsonRequest, {
     url: typeof S.String;
     include: S.optionalWith<S.Struct<{
@@ -503,10 +804,14 @@ declare const FetchFetchJsonRequest_base: S.Class<FetchFetchJsonRequest, {
         appendix: S.optionalWith<typeof S.Boolean, {
             nullable: true;
         }>;
+        appendixMarkers: S.optionalWith<typeof FetchFetchJsonRequestIncludeAppendixMarkers, {
+            nullable: true;
+            default: () => "compact";
+        }>;
     }>, {
         nullable: true;
     }>;
-    search: S.optionalWith<S.Struct<{
+    highlights: S.optionalWith<S.Struct<{
         query: typeof S.String;
         maxResults: S.optionalWith<S.filter<S.filter<typeof S.Int>>, {
             nullable: true;
@@ -527,6 +832,21 @@ declare const FetchFetchJsonRequest_base: S.Class<FetchFetchJsonRequest, {
     }>, {
         nullable: true;
     }>;
+    documentConfig: S.optionalWith<S.Struct<{
+        maxPages: S.optionalWith<S.filter<typeof S.Int>, {
+            nullable: true;
+        }>;
+        maxAudioSeconds: S.optionalWith<S.filter<S.filter<typeof S.Int>>, {
+            nullable: true;
+            default: () => 3600;
+        }>;
+        ocr: S.optionalWith<typeof FetchFetchJsonRequestDocumentConfigOcr, {
+            nullable: true;
+            default: () => "auto";
+        }>;
+    }>, {
+        nullable: true;
+    }>;
 }, S.Struct.Encoded<{
     url: typeof S.String;
     include: S.optionalWith<S.Struct<{
@@ -576,10 +896,14 @@ declare const FetchFetchJsonRequest_base: S.Class<FetchFetchJsonRequest, {
         appendix: S.optionalWith<typeof S.Boolean, {
             nullable: true;
         }>;
+        appendixMarkers: S.optionalWith<typeof FetchFetchJsonRequestIncludeAppendixMarkers, {
+            nullable: true;
+            default: () => "compact";
+        }>;
     }>, {
         nullable: true;
     }>;
-    search: S.optionalWith<S.Struct<{
+    highlights: S.optionalWith<S.Struct<{
         query: typeof S.String;
         maxResults: S.optionalWith<S.filter<S.filter<typeof S.Int>>, {
             nullable: true;
@@ -600,10 +924,37 @@ declare const FetchFetchJsonRequest_base: S.Class<FetchFetchJsonRequest, {
     }>, {
         nullable: true;
     }>;
+    documentConfig: S.optionalWith<S.Struct<{
+        maxPages: S.optionalWith<S.filter<typeof S.Int>, {
+            nullable: true;
+        }>;
+        maxAudioSeconds: S.optionalWith<S.filter<S.filter<typeof S.Int>>, {
+            nullable: true;
+            default: () => 3600;
+        }>;
+        ocr: S.optionalWith<typeof FetchFetchJsonRequestDocumentConfigOcr, {
+            nullable: true;
+            default: () => "auto";
+        }>;
+    }>, {
+        nullable: true;
+    }>;
 }>, never, {
     readonly browserConfig?: {
         readonly scrollFullPage: boolean;
     } | undefined;
+} & {
+    readonly documentConfig?: {
+        readonly maxPages?: number | undefined;
+        readonly maxAudioSeconds: number;
+        readonly ocr: "always" | "auto" | "never";
+    } | undefined;
+} & {
+    readonly highlights?: {
+        readonly query: string;
+        readonly maxResults: number;
+        readonly minScore: number;
+    } | undefined;
 } & {
     readonly include?: {
         readonly html?: boolean | {
@@ -626,12 +977,7 @@ declare const FetchFetchJsonRequest_base: S.Class<FetchFetchJsonRequest, {
         } | undefined;
         readonly json: boolean;
         readonly appendix?: boolean | undefined;
-    } | undefined;
-} & {
-    readonly search?: {
-        readonly query: string;
-        readonly maxResults: number;
-        readonly minScore: number;
+        readonly appendixMarkers: "compact" | "detailed" | "off";
     } | undefined;
 } & {
     readonly url: string;
@@ -641,15 +987,47 @@ export declare class FetchFetchJsonRequest extends FetchFetchJsonRequest_base {
 declare const FetchObjectModeMetaVersion_base: S.Literal<[1]>;
 export declare class FetchObjectModeMetaVersion extends FetchObjectModeMetaVersion_base {
 }
+export declare class Int extends S.Int {
+}
 declare const FetchObjectModeAppendixLinks_base: S.Struct<{
     sameDomain: typeof S.Number;
     external: typeof S.Number;
 }>;
 export declare class FetchObjectModeAppendixLinks extends FetchObjectModeAppendixLinks_base {
 }
+declare const FetchObjectModeAppendixOmitted_base: S.Struct<{
+    blocks: typeof S.Number;
+    approxTokens: typeof S.Number;
+}>;
+export declare class FetchObjectModeAppendixOmitted extends FetchObjectModeAppendixOmitted_base {
+}
+declare const FetchObjectModeAppendixMarker_base: S.Struct<{
+    evidenceId: S.optionalWith<typeof S.Number, {
+        nullable: true;
+    }>;
+    links: typeof S.Number;
+    approxTokens: typeof S.Number;
+    label: S.optionalWith<typeof S.String, {
+        nullable: true;
+    }>;
+    preview: S.optionalWith<typeof S.String, {
+        nullable: true;
+    }>;
+    moreBlocks: S.optionalWith<typeof S.Number, {
+        nullable: true;
+    }>;
+}>;
+export declare class FetchObjectModeAppendixMarker extends FetchObjectModeAppendixMarker_base {
+}
 declare const FetchObjectModeAppendixHint_base: S.Struct<{
     url: typeof S.String;
     links: typeof FetchObjectModeAppendixLinks;
+    omitted: S.optionalWith<typeof FetchObjectModeAppendixOmitted, {
+        nullable: true;
+    }>;
+    markers: S.optionalWith<S.Array$<typeof FetchObjectModeAppendixMarker>, {
+        nullable: true;
+    }>;
 }>;
 export declare class FetchObjectModeAppendixHint extends FetchObjectModeAppendixHint_base {
 }
@@ -666,6 +1044,17 @@ declare const FetchObjectModeMarkdownHint_base: S.Struct<{
 }>;
 export declare class FetchObjectModeMarkdownHint extends FetchObjectModeMarkdownHint_base {
 }
+declare const FetchObjectModeResourcesVersion_base: S.Literal<[1]>;
+export declare class FetchObjectModeResourcesVersion extends FetchObjectModeResourcesVersion_base {
+}
+declare const FetchObjectModeResources_base: S.Struct<{
+    version: typeof FetchObjectModeResourcesVersion;
+    snapshotId: typeof S.String;
+    url: typeof S.String;
+    markdownUrl: typeof S.String;
+}>;
+export declare class FetchObjectModeResources extends FetchObjectModeResources_base {
+}
 declare const FetchObjectModeMeta_base: S.Struct<{
     version: typeof FetchObjectModeMetaVersion;
     url: typeof S.String;
@@ -674,12 +1063,18 @@ declare const FetchObjectModeMeta_base: S.Struct<{
     lang: typeof S.String;
     pageType: typeof S.String;
     playground: typeof S.String;
+    citationEvidenceIds: S.optionalWith<S.filter<S.Array$<typeof Int>>, {
+        nullable: true;
+    }>;
     title: S.optionalWith<typeof S.String, {
         nullable: true;
     }>;
     finalUrl: S.optionalWith<typeof S.String, {
         nullable: true;
     }>;
+    contentType: S.optionalWith<typeof S.String, {
+        nullable: true;
+    }>;
     canonical: S.optionalWith<typeof S.String, {
         nullable: true;
     }>;
@@ -710,6 +1105,9 @@ declare const FetchObjectModeMeta_base: S.Struct<{
     markdown: S.optionalWith<typeof FetchObjectModeMarkdownHint, {
         nullable: true;
     }>;
+    resources: S.optionalWith<typeof FetchObjectModeResources, {
+        nullable: true;
+    }>;
     blocked: S.optionalWith<typeof S.String, {
         nullable: true;
     }>;
@@ -735,7 +1133,7 @@ declare const FetchObjectModeEvidence_base: S.Struct<{
     id: typeof S.Number;
     kind: typeof FetchObjectModeEvidenceKind;
     role: typeof FetchObjectModeEvidenceRole;
-    score: typeof S.Number;
+    score: S.filter<typeof S.Number>;
     url: S.optionalWith<typeof S.String, {
         nullable: true;
     }>;
@@ -774,7 +1172,7 @@ export declare class FetchAssetReference extends FetchAssetReference_base {
 declare const FetchDegradedInfoReason_base: S.Literal<["pageTooLarge", "modelInputTooLarge"]>;
 export declare class FetchDegradedInfoReason extends FetchDegradedInfoReason_base {
 }
-declare const FetchDegradedInfoLimitKind_base: S.Literal<["domsnapshot_bytes", "ast_bytes", "hfc_tokens"]>;
+declare const FetchDegradedInfoLimitKind_base: S.Literal<["domsnapshot_bytes", "ast_bytes", "document_frame_bytes", "hfc_tokens"]>;
 export declare class FetchDegradedInfoLimitKind extends FetchDegradedInfoLimitKind_base {
 }
 declare const FetchDegradedInfo_base: S.Struct<{
@@ -796,9 +1194,7 @@ declare const FetchDegradedInfo_base: S.Struct<{
 }>;
 export declare class FetchDegradedInfo extends FetchDegradedInfo_base {
 }
-export declare class Int extends S.Int {
-}
-declare const FetchSearchSnippetLocation_base: S.Struct<{
+declare const FetchHighlightsSnippetLocation_base: S.Struct<{
     evidenceId: S.optionalWith<typeof Int, {
         nullable: true;
     }>;
@@ -815,37 +1211,37 @@ declare const FetchSearchSnippetLocation_base: S.Struct<{
         nullable: true;
     }>;
 }>;
-export declare class FetchSearchSnippetLocation extends FetchSearchSnippetLocation_base {
+export declare class FetchHighlightsSnippetLocation extends FetchHighlightsSnippetLocation_base {
 }
-declare const FetchSearchSourceMetaSource_base: S.Literal<["markdown", "appendix", "statejson"]>;
-export declare class FetchSearchSourceMetaSource extends FetchSearchSourceMetaSource_base {
+declare const FetchHighlightsSourceMetaSource_base: S.Literal<["markdown", "appendix", "statejson"]>;
+export declare class FetchHighlightsSourceMetaSource extends FetchHighlightsSourceMetaSource_base {
 }
-declare const FetchSearchSourceMetaRanker_base: S.Literal<["zeroentropy", "mixedbread", "local_lexical"]>;
-export declare class FetchSearchSourceMetaRanker extends FetchSearchSourceMetaRanker_base {
+declare const FetchHighlightsSourceMetaRanker_base: S.Literal<["zeroentropy", "mixedbread", "local_lexical"]>;
+export declare class FetchHighlightsSourceMetaRanker extends FetchHighlightsSourceMetaRanker_base {
 }
-declare const FetchSearchSourceMetaFallbackReason_base: S.Literal<["timeout", "error"]>;
-export declare class FetchSearchSourceMetaFallbackReason extends FetchSearchSourceMetaFallbackReason_base {
+declare const FetchHighlightsSourceMetaFallbackReason_base: S.Literal<["timeout", "error"]>;
+export declare class FetchHighlightsSourceMetaFallbackReason extends FetchHighlightsSourceMetaFallbackReason_base {
 }
-declare const FetchSearchSourceMeta_base: S.Struct<{
-    source: typeof FetchSearchSourceMetaSource;
+declare const FetchHighlightsSourceMeta_base: S.Struct<{
+    source: typeof FetchHighlightsSourceMetaSource;
     chunkCount: S.filter<typeof S.Int>;
     batchCount: S.filter<typeof S.Int>;
-    ranker: typeof FetchSearchSourceMetaRanker;
+    ranker: typeof FetchHighlightsSourceMetaRanker;
     fallback: typeof S.Boolean;
-    fallbackReason: S.optionalWith<typeof FetchSearchSourceMetaFallbackReason, {
+    fallbackReason: S.optionalWith<typeof FetchHighlightsSourceMetaFallbackReason, {
         nullable: true;
     }>;
     durationMs: S.filter<typeof S.Number>;
 }>;
-export declare class FetchSearchSourceMeta extends FetchSearchSourceMeta_base {
+export declare class FetchHighlightsSourceMeta extends FetchHighlightsSourceMeta_base {
 }
-declare const FetchSearchMeta_base: S.Struct<{
+declare const FetchHighlightsMeta_base: S.Struct<{
     durationMs: S.filter<typeof S.Number>;
-    sources: S.Array$<typeof FetchSearchSourceMeta>;
+    sources: S.Array$<typeof FetchHighlightsSourceMeta>;
 }>;
-export declare class FetchSearchMeta extends FetchSearchMeta_base {
+export declare class FetchHighlightsMeta extends FetchHighlightsMeta_base {
 }
-declare const FetchSearchResult_base: S.Struct<{
+declare const FetchHighlightsResult_base: S.Struct<{
     query: typeof S.String;
     snippets: S.Array$<S.Struct<{
         type: S.optionalWith<S.Literal<["text"]>, {
@@ -855,17 +1251,56 @@ declare const FetchSearchResult_base: S.Struct<{
         source: S.Literal<["markdown", "appendix", "statejson"]>;
         text: typeof S.String;
         score: S.filter<S.filter<typeof S.Number>>;
-        location: S.optionalWith<typeof FetchSearchSnippetLocation, {
+        location: S.optionalWith<typeof FetchHighlightsSnippetLocation, {
             nullable: true;
         }>;
     }>>;
-    meta: S.optionalWith<typeof FetchSearchMeta, {
+    meta: S.optionalWith<typeof FetchHighlightsMeta, {
+        nullable: true;
+    }>;
+}>;
+export declare class FetchHighlightsResult extends FetchHighlightsResult_base {
+}
+declare const FetchObjectModeResultDataVideoProvider_base: S.Literal<["youtube"]>;
+export declare class FetchObjectModeResultDataVideoProvider extends FetchObjectModeResultDataVideoProvider_base {
+}
+declare const FetchObjectModeResultDataVideoTranscriptSource_base: S.Literal<["captions", "transcription"]>;
+export declare class FetchObjectModeResultDataVideoTranscriptSource extends FetchObjectModeResultDataVideoTranscriptSource_base {
+}
+declare const FetchObjectModeResultDataVideoTranscriptKind_base: S.Literal<["manual", "auto"]>;
+export declare class FetchObjectModeResultDataVideoTranscriptKind extends FetchObjectModeResultDataVideoTranscriptKind_base {
+}
+declare const FetchHttpOriginErrorKind_base: S.Literal<["http"]>;
+export declare class FetchHttpOriginErrorKind extends FetchHttpOriginErrorKind_base {
+}
+declare const FetchHttpOriginErrorContentAvailable_base: S.Literal<[false]>;
+export declare class FetchHttpOriginErrorContentAvailable extends FetchHttpOriginErrorContentAvailable_base {
+}
+declare const FetchHttpOriginErrorRedirectLimitReached_base: S.Literal<[true]>;
+export declare class FetchHttpOriginErrorRedirectLimitReached extends FetchHttpOriginErrorRedirectLimitReached_base {
+}
+declare const FetchHttpOriginErrorTag_base: S.Literal<["FetchOriginError"]>;
+export declare class FetchHttpOriginErrorTag extends FetchHttpOriginErrorTag_base {
+}
+declare const FetchHttpOriginError_base: S.Struct<{
+    url: typeof S.String;
+    kind: typeof FetchHttpOriginErrorKind;
+    contentAvailable: S.optionalWith<typeof FetchHttpOriginErrorContentAvailable, {
+        nullable: true;
+    }>;
+    finalUrl: S.optionalWith<typeof S.String, {
         nullable: true;
     }>;
+    redirectLimitReached: S.optionalWith<typeof FetchHttpOriginErrorRedirectLimitReached, {
+        nullable: true;
+    }>;
+    originStatusCode: typeof S.Number;
+    retryable: typeof S.Boolean;
+    _tag: typeof FetchHttpOriginErrorTag;
 }>;
-export declare class FetchSearchResult extends FetchSearchResult_base {
+export declare class FetchHttpOriginError extends FetchHttpOriginError_base {
 }
-declare const FetchObjectModeResult_base: S.Class<FetchObjectModeResult, {
+declare const FetchObjectModeResult_base: S.Struct<{
     meta: typeof FetchObjectModeMeta;
     markdown: typeof S.String;
     json: S.Array$<typeof FetchObjectModeEvidence>;
@@ -876,7 +1311,7 @@ declare const FetchObjectModeResult_base: S.Class<FetchObjectModeResult, {
         degraded: S.optionalWith<typeof FetchDegradedInfo, {
             nullable: true;
         }>;
-        search: S.optionalWith<typeof FetchSearchResult, {
+        highlights: S.optionalWith<typeof FetchHighlightsResult, {
             nullable: true;
         }>;
         screenshot: S.optionalWith<S.Struct<{
@@ -885,138 +1320,138 @@ declare const FetchObjectModeResult_base: S.Class<FetchObjectModeResult, {
         }>, {
             nullable: true;
         }>;
-    }>, {
-        nullable: true;
-    }>;
-}, S.Struct.Encoded<{
-    meta: typeof FetchObjectModeMeta;
-    markdown: typeof S.String;
-    json: S.Array$<typeof FetchObjectModeEvidence>;
-    data: S.optionalWith<S.Struct<{
-        assets: S.optionalWith<S.Array$<typeof FetchAssetReference>, {
-            nullable: true;
-        }>;
-        degraded: S.optionalWith<typeof FetchDegradedInfo, {
+        document: S.optionalWith<S.Struct<{
+            url: typeof S.String;
+            contentType: typeof S.String;
+            sizeBytes: typeof S.Number;
+        }>, {
             nullable: true;
         }>;
-        search: S.optionalWith<typeof FetchSearchResult, {
+        usage: S.optionalWith<S.Struct<{
+            documentPages: typeof Int;
+            ocrPages: typeof Int;
+            audioSeconds: S.filter<typeof S.Number>;
+            videos: S.optionalWith<typeof Int, {
+                nullable: true;
+            }>;
+        }>, {
             nullable: true;
         }>;
-        screenshot: S.optionalWith<S.Struct<{
-            url: typeof S.String;
-            fullPage: typeof S.Boolean;
+        video: S.optionalWith<S.Struct<{
+            provider: typeof FetchObjectModeResultDataVideoProvider;
+            videoId: typeof S.String;
+            title: typeof S.String;
+            channel: S.optionalWith<typeof S.String, {
+                nullable: true;
+            }>;
+            channelUrl: S.optionalWith<typeof S.String, {
+                nullable: true;
+            }>;
+            durationSeconds: S.optionalWith<typeof S.Number, {
+                nullable: true;
+            }>;
+            publishedAt: S.optionalWith<typeof S.String, {
+                nullable: true;
+            }>;
+            viewCount: S.optionalWith<typeof S.Number, {
+                nullable: true;
+            }>;
+            language: S.optionalWith<typeof S.String, {
+                nullable: true;
+            }>;
+            transcript: S.Struct<{
+                source: typeof FetchObjectModeResultDataVideoTranscriptSource;
+                kind: S.optionalWith<typeof FetchObjectModeResultDataVideoTranscriptKind, {
+                    nullable: true;
+                }>;
+                language: S.optionalWith<typeof S.String, {
+                    nullable: true;
+                }>;
+            }>;
+            segments: S.optionalWith<S.Array$<S.Struct<{
+                startSeconds: typeof S.Number;
+                text: typeof S.String;
+            }>>, {
+                nullable: true;
+            }>;
+            chapters: S.optionalWith<S.Array$<S.Struct<{
+                title: typeof S.String;
+                startSeconds: typeof S.Number;
+            }>>, {
+                nullable: true;
+            }>;
+            storyboard: S.optionalWith<S.Struct<{
+                frameWidth: typeof S.Int;
+                frameHeight: typeof S.Int;
+                rows: typeof S.Int;
+                columns: typeof S.Int;
+                sheets: S.Array$<S.Struct<{
+                    url: typeof S.String;
+                    durationSeconds: typeof S.Number;
+                }>>;
+            }>, {
+                nullable: true;
+            }>;
         }>, {
             nullable: true;
         }>;
     }>, {
         nullable: true;
     }>;
-}>, never, {
-    readonly data?: {
-        readonly assets?: readonly {
-            readonly id: string;
-            readonly kind: "data-url";
-            readonly placeholder: string;
-            readonly archiveKey: string;
-            readonly mimeType: string;
-            readonly sha256: string;
-            readonly bytes: number;
-        }[] | undefined;
-        readonly degraded?: {
-            readonly reason: "modelInputTooLarge" | "pageTooLarge";
-            readonly skipped: readonly "hfc"[];
-            readonly limitKind: "ast_bytes" | "domsnapshot_bytes" | "hfc_tokens";
-            readonly measuredBytes?: number | undefined;
-            readonly thresholdBytes?: number | undefined;
-            readonly measuredTokens?: number | undefined;
-            readonly thresholdTokens?: number | undefined;
-        } | undefined;
-        readonly search?: {
-            readonly query: string;
-            readonly snippets: readonly {
-                readonly type: "text";
-                readonly source: "appendix" | "markdown" | "statejson";
-                readonly text: string;
-                readonly score: number;
-                readonly location?: {
-                    readonly evidenceId?: number | undefined;
-                    readonly markdownBlockId?: string | undefined;
-                    readonly nodeIds?: readonly number[] | undefined;
-                    readonly stateJsonSourceId?: number | undefined;
-                    readonly jsonPath?: string | undefined;
-                } | undefined;
-            }[];
-            readonly meta?: {
-                readonly durationMs: number;
-                readonly sources: readonly {
-                    readonly source: "appendix" | "markdown" | "statejson";
-                    readonly chunkCount: number;
-                    readonly batchCount: number;
-                    readonly ranker: "local_lexical" | "mixedbread" | "zeroentropy";
-                    readonly fallback: boolean;
-                    readonly fallbackReason?: "error" | "timeout" | undefined;
-                    readonly durationMs: number;
-                }[];
-            } | undefined;
-        } | undefined;
-        readonly screenshot?: {
-            readonly url: string;
-            readonly fullPage: boolean;
-        } | undefined;
-    } | undefined;
-} & {
-    readonly json: readonly {
-        readonly id: number;
-        readonly kind: "inline" | "network";
-        readonly role: "apollo-state" | "application-json" | "data-attribute" | "initial-state" | "ld+json" | "network-json" | "network-response" | "next-data" | "nuxt" | "other" | "script-tag";
-        readonly score: number;
-        readonly url?: string | undefined;
-        readonly method?: string | undefined;
-        readonly moreTokens?: number | undefined;
-        readonly keys?: readonly string[] | undefined;
-        readonly urlRedacted?: true | undefined;
-        readonly urlOmitted?: "invalid" | "too-long" | "unsafe" | undefined;
-    }[];
-} & {
-    readonly markdown: string;
-} & {
-    readonly meta: {
-        readonly version: 1;
-        readonly url: string;
-        readonly capturedAt: string;
-        readonly snapshotId: string;
-        readonly lang: string;
-        readonly pageType: string;
-        readonly playground: string;
-        readonly title?: string | undefined;
-        readonly finalUrl?: string | undefined;
-        readonly canonical?: string | undefined;
-        readonly description?: string | undefined;
-        readonly author?: string | undefined;
-        readonly createdAt?: string | undefined;
-        readonly updatedAt?: string | undefined;
-        readonly image?: string | undefined;
-        readonly paginationNext?: string | undefined;
-        readonly appendix?: {
-            readonly url: string;
-            readonly links: {
-                readonly sameDomain: number;
-                readonly external: number;
-            };
-        } | undefined;
-        readonly stateJson?: {
-            readonly moreTokens: number;
-        } | undefined;
-        readonly markdown?: {
-            readonly url: string;
-            readonly moreTokens?: number | undefined;
-        } | undefined;
-        readonly blocked?: string | undefined;
-        readonly loadingStatus?: string | undefined;
-    };
-}, {}, {}>;
+    originError: S.optionalWith<typeof FetchHttpOriginError, {
+        nullable: true;
+    }>;
+}>;
 export declare class FetchObjectModeResult extends FetchObjectModeResult_base {
 }
+declare const FetchNetworkOriginErrorKind_base: S.Literal<["dns", "tls", "connectionRefused", "connectionReset", "connectionClosed", "addressUnreachable", "emptyResponse", "connectionTimeout"]>;
+export declare class FetchNetworkOriginErrorKind extends FetchNetworkOriginErrorKind_base {
+}
+declare const FetchNetworkOriginErrorTag_base: S.Literal<["FetchOriginError"]>;
+export declare class FetchNetworkOriginErrorTag extends FetchNetworkOriginErrorTag_base {
+}
+declare const FetchNetworkOriginError_base: S.Struct<{
+    url: typeof S.String;
+    kind: typeof FetchNetworkOriginErrorKind;
+    upstreamError: S.optionalWith<typeof S.String, {
+        nullable: true;
+    }>;
+    retryable: typeof S.Boolean;
+    _tag: typeof FetchNetworkOriginErrorTag;
+}>;
+export declare class FetchNetworkOriginError extends FetchNetworkOriginError_base {
+}
+declare const FetchHttpOriginRefusalTag_base: S.Literal<["FetchOriginError"]>;
+export declare class FetchHttpOriginRefusalTag extends FetchHttpOriginRefusalTag_base {
+}
+declare const FetchHttpOriginRefusalKind_base: S.Literal<["http"]>;
+export declare class FetchHttpOriginRefusalKind extends FetchHttpOriginRefusalKind_base {
+}
+declare const FetchHttpOriginRefusalContentAvailable_base: S.Literal<[false]>;
+export declare class FetchHttpOriginRefusalContentAvailable extends FetchHttpOriginRefusalContentAvailable_base {
+}
+declare const FetchHttpOriginRefusalRedirectLimitReached_base: S.Literal<[true]>;
+export declare class FetchHttpOriginRefusalRedirectLimitReached extends FetchHttpOriginRefusalRedirectLimitReached_base {
+}
+declare const FetchHttpOriginRefusal_base: S.Struct<{
+    _tag: typeof FetchHttpOriginRefusalTag;
+    url: typeof S.String;
+    kind: typeof FetchHttpOriginRefusalKind;
+    contentAvailable: typeof FetchHttpOriginRefusalContentAvailable;
+    finalUrl: S.optionalWith<typeof S.String, {
+        nullable: true;
+    }>;
+    redirectLimitReached: S.optionalWith<typeof FetchHttpOriginRefusalRedirectLimitReached, {
+        nullable: true;
+    }>;
+    originStatusCode: typeof S.Number;
+    retryable: typeof S.Boolean;
+}>;
+export declare class FetchHttpOriginRefusal extends FetchHttpOriginRefusal_base {
+}
+declare const FetchFetchJson200_base: S.Union<[typeof FetchObjectModeResult, typeof FetchNetworkOriginError, typeof FetchHttpOriginRefusal]>;
+export declare class FetchFetchJson200 extends FetchFetchJson200_base {
+}
 declare const FetchFetchJson400_base: S.Union<[typeof HttpApiDecodeError, typeof BadRequest]>;
 export declare class FetchFetchJson400 extends FetchFetchJson400_base {
 }
@@ -1032,19 +1467,30 @@ export declare class FetchFetchJson403 extends FetchFetchJson403_base {
 declare const FetchFetchJson413_base: S.Union<[typeof PayloadTooLarge, typeof FetchPageTooLarge]>;
 export declare class FetchFetchJson413 extends FetchFetchJson413_base {
 }
-declare const FetchFetchSearchRequest_base: S.Class<FetchFetchSearchRequest, {
-    snapshotId: S.filter<typeof S.String>;
-    search: S.Struct<{
-        query: typeof S.String;
-        maxResults: S.optionalWith<S.filter<S.filter<typeof S.Int>>, {
-            nullable: true;
-            default: () => 5;
-        }>;
-        minScore: S.optionalWith<S.filter<S.filter<typeof S.Number>>, {
-            nullable: true;
-            default: () => 0.6;
-        }>;
+declare const FetchFetchJson429_base: S.Union<[typeof TooManyRequests, typeof FetchConcurrencyLimitExceeded]>;
+export declare class FetchFetchJson429 extends FetchFetchJson429_base {
+}
+declare const FetchFetchJson502_base: S.Union<[typeof FetchCaptureFailed, typeof FetchNavigationFailed, typeof FetchOriginHttpError]>;
+export declare class FetchFetchJson502 extends FetchFetchJson502_base {
+}
+declare const FetchFetchJson503_base: S.Union<[typeof ServiceUnavailable, typeof FetchDocumentProcessingUnavailable]>;
+export declare class FetchFetchJson503 extends FetchFetchJson503_base {
+}
+declare const FetchBatchedParams_base: S.Struct<{
+    'x-idempotency-key': S.optionalWith<S.filter<S.filter<typeof S.String>>, {
+        nullable: true;
     }>;
+}>;
+export declare class FetchBatchedParams extends FetchBatchedParams_base {
+}
+declare const FetchBatchedRequestIncludeAppendixMarkers_base: S.Literal<["off", "compact", "detailed"]>;
+export declare class FetchBatchedRequestIncludeAppendixMarkers extends FetchBatchedRequestIncludeAppendixMarkers_base {
+}
+declare const FetchBatchedRequestDocumentConfigOcr_base: S.Literal<["auto", "never", "always"]>;
+export declare class FetchBatchedRequestDocumentConfigOcr extends FetchBatchedRequestDocumentConfigOcr_base {
+}
+declare const FetchBatchedRequest_base: S.Class<FetchBatchedRequest, {
+    urls: S.NonEmptyArray<typeof S.String>;
     include: S.optionalWith<S.Struct<{
         html: S.optionalWith<S.Union<[typeof S.Boolean, S.Record$<typeof S.String, typeof S.Unknown>]>, {
             nullable: true;
@@ -1092,22 +1538,38 @@ declare const FetchFetchSearchRequest_base: S.Class<FetchFetchSearchRequest, {
         appendix: S.optionalWith<typeof S.Boolean, {
             nullable: true;
         }>;
+        appendixMarkers: S.optionalWith<typeof FetchBatchedRequestIncludeAppendixMarkers, {
+            nullable: true;
+            default: () => "compact";
+        }>;
     }>, {
         nullable: true;
     }>;
-}, S.Struct.Encoded<{
-    snapshotId: S.filter<typeof S.String>;
-    search: S.Struct<{
-        query: typeof S.String;
-        maxResults: S.optionalWith<S.filter<S.filter<typeof S.Int>>, {
+    browserConfig: S.optionalWith<S.Struct<{
+        scrollFullPage: S.optionalWith<typeof S.Boolean, {
             nullable: true;
-            default: () => 5;
+            default: () => false;
         }>;
-        minScore: S.optionalWith<S.filter<S.filter<typeof S.Number>>, {
+    }>, {
+        nullable: true;
+    }>;
+    documentConfig: S.optionalWith<S.Struct<{
+        maxPages: S.optionalWith<S.filter<typeof S.Int>, {
             nullable: true;
-            default: () => 0.6;
         }>;
+        maxAudioSeconds: S.optionalWith<S.filter<S.filter<typeof S.Int>>, {
+            nullable: true;
+            default: () => 3600;
+        }>;
+        ocr: S.optionalWith<typeof FetchBatchedRequestDocumentConfigOcr, {
+            nullable: true;
+            default: () => "auto";
+        }>;
+    }>, {
+        nullable: true;
     }>;
+}, S.Struct.Encoded<{
+    urls: S.NonEmptyArray<typeof S.String>;
     include: S.optionalWith<S.Struct<{
         html: S.optionalWith<S.Union<[typeof S.Boolean, S.Record$<typeof S.String, typeof S.Unknown>]>, {
             nullable: true;
@@ -1155,10 +1617,47 @@ declare const FetchFetchSearchRequest_base: S.Class<FetchFetchSearchRequest, {
         appendix: S.optionalWith<typeof S.Boolean, {
             nullable: true;
         }>;
+        appendixMarkers: S.optionalWith<typeof FetchBatchedRequestIncludeAppendixMarkers, {
+            nullable: true;
+            default: () => "compact";
+        }>;
+    }>, {
+        nullable: true;
+    }>;
+    browserConfig: S.optionalWith<S.Struct<{
+        scrollFullPage: S.optionalWith<typeof S.Boolean, {
+            nullable: true;
+            default: () => false;
+        }>;
+    }>, {
+        nullable: true;
+    }>;
+    documentConfig: S.optionalWith<S.Struct<{
+        maxPages: S.optionalWith<S.filter<typeof S.Int>, {
+            nullable: true;
+        }>;
+        maxAudioSeconds: S.optionalWith<S.filter<S.filter<typeof S.Int>>, {
+            nullable: true;
+            default: () => 3600;
+        }>;
+        ocr: S.optionalWith<typeof FetchBatchedRequestDocumentConfigOcr, {
+            nullable: true;
+            default: () => "auto";
+        }>;
     }>, {
         nullable: true;
     }>;
 }>, never, {
+    readonly browserConfig?: {
+        readonly scrollFullPage: boolean;
+    } | undefined;
+} & {
+    readonly documentConfig?: {
+        readonly maxPages?: number | undefined;
+        readonly maxAudioSeconds: number;
+        readonly ocr: "always" | "auto" | "never";
+    } | undefined;
+} & {
     readonly include?: {
         readonly html?: boolean | {
             readonly [x: string]: unknown;
@@ -1180,17 +1679,81 @@ declare const FetchFetchSearchRequest_base: S.Class<FetchFetchSearchRequest, {
         } | undefined;
         readonly json: boolean;
         readonly appendix?: boolean | undefined;
+        readonly appendixMarkers: "compact" | "detailed" | "off";
     } | undefined;
 } & {
-    readonly search: {
-        readonly query: string;
-        readonly maxResults: number;
-        readonly minScore: number;
-    };
+    readonly urls: readonly [string, ...string[]];
+}, {}, {}>;
+export declare class FetchBatchedRequest extends FetchBatchedRequest_base {
+}
+declare const BatchedRun_base: S.Class<BatchedRun, {
+    id: typeof S.String;
+}, S.Struct.Encoded<{
+    id: typeof S.String;
+}>, never, {
+    readonly id: string;
+}, {}, {}>;
+export declare class BatchedRun extends BatchedRun_base {
+}
+declare const FetchBatched400_base: S.Union<[typeof HttpApiDecodeError, typeof BadRequest]>;
+export declare class FetchBatched400 extends FetchBatched400_base {
+}
+declare const FetchBatched403Tag_base: S.Literal<["AccessBlocked"]>;
+export declare class FetchBatched403Tag extends FetchBatched403Tag_base {
+}
+declare const FetchBatched403_base: S.Struct<{
+    organizationId: S.filter<typeof S.String>;
+    blockedUntil: S.optionalWith<S.Union<[typeof DateTimeUtc, typeof S.Null]>, {
+        nullable: true;
+    }>;
+    _tag: typeof FetchBatched403Tag;
+}>;
+export declare class FetchBatched403 extends FetchBatched403_base {
+}
+declare const BatchedIdempotencyConflictReason_base: S.Literal<["payload_mismatch"]>;
+export declare class BatchedIdempotencyConflictReason extends BatchedIdempotencyConflictReason_base {
+}
+declare const BatchedIdempotencyConflictTag_base: S.Literal<["BatchedIdempotencyConflict"]>;
+export declare class BatchedIdempotencyConflictTag extends BatchedIdempotencyConflictTag_base {
+}
+declare const BatchedIdempotencyConflict_base: S.Class<BatchedIdempotencyConflict, {
+    existingRunId: typeof S.String;
+    reason: typeof BatchedIdempotencyConflictReason;
+    _tag: typeof BatchedIdempotencyConflictTag;
+}, S.Struct.Encoded<{
+    existingRunId: typeof S.String;
+    reason: typeof BatchedIdempotencyConflictReason;
+    _tag: typeof BatchedIdempotencyConflictTag;
+}>, never, {
+    readonly _tag: "BatchedIdempotencyConflict";
 } & {
-    readonly snapshotId: string;
+    readonly existingRunId: string;
+} & {
+    readonly reason: "payload_mismatch";
 }, {}, {}>;
-export declare class FetchFetchSearchRequest extends FetchFetchSearchRequest_base {
+export declare class BatchedIdempotencyConflict extends BatchedIdempotencyConflict_base {
+}
+declare const FetchGetBatchedParams_base: S.Struct<{
+    limit: S.optionalWith<typeof S.String, {
+        nullable: true;
+    }>;
+    offset: S.optionalWith<typeof S.String, {
+        nullable: true;
+    }>;
+    include: S.optionalWith<typeof S.String, {
+        nullable: true;
+    }>;
+}>;
+export declare class FetchGetBatchedParams extends FetchGetBatchedParams_base {
+}
+declare const BatchedStatusStatus_base: S.Literal<["QUEUED", "RUNNING", "CANCELLING", "COMPLETED", "FAILED", "CANCELLED"]>;
+export declare class BatchedStatusStatus extends BatchedStatusStatus_base {
+}
+declare const BatchedStatusBatchedStatus_base: S.Literal<["QUEUED", "RUNNING", "CANCELLING", "COMPLETED", "FAILED", "CANCELLED"]>;
+export declare class BatchedStatusBatchedStatus extends BatchedStatusBatchedStatus_base {
+}
+declare const BatchedFetchItemStatus_base: S.Literal<["QUEUED", "RUNNING", "SUCCEEDED", "FAILED", "CANCELLED"]>;
+export declare class BatchedFetchItemStatus extends BatchedFetchItemStatus_base {
 }
 export declare class URL extends S.String {
 }
@@ -1205,173 +1768,583 @@ declare const ResponseInfo_base: S.Struct<{
     redirectStatusCode: S.optionalWith<typeof S.Number, {
         nullable: true;
     }>;
+    contentType: S.optionalWith<typeof S.String, {
+        nullable: true;
+    }>;
     headers: S.optionalWith<S.Struct<{}>, {
         nullable: true;
     }>;
 }>;
 export declare class ResponseInfo extends ResponseInfo_base {
 }
-declare const FetchSnapshotSearchResult_base: S.Class<FetchSnapshotSearchResult, {
-    snapshotId: S.filter<typeof S.String>;
-    response: typeof ResponseInfo;
-    search: typeof FetchSearchResult;
-    durationMs: S.filter<typeof S.Number>;
-    playground: typeof S.String;
-}, S.Struct.Encoded<{
-    snapshotId: S.filter<typeof S.String>;
-    response: typeof ResponseInfo;
-    search: typeof FetchSearchResult;
-    durationMs: S.filter<typeof S.Number>;
-    playground: typeof S.String;
-}>, never, {
-    readonly durationMs: number;
-} & {
-    readonly playground: string;
-} & {
-    readonly response: {
-        readonly url: string;
-        readonly requestedUrl?: string | undefined;
-        readonly originStatusCode?: number | undefined;
-        readonly redirectStatusCode?: number | undefined;
-        readonly headers?: {} | undefined;
-    };
-} & {
-    readonly search: {
-        readonly query: string;
-        readonly snippets: readonly {
-            readonly type: "text";
-            readonly source: "appendix" | "markdown" | "statejson";
-            readonly text: string;
-            readonly score: number;
-            readonly location?: {
-                readonly evidenceId?: number | undefined;
-                readonly markdownBlockId?: string | undefined;
-                readonly nodeIds?: readonly number[] | undefined;
-                readonly stateJsonSourceId?: number | undefined;
-                readonly jsonPath?: string | undefined;
-            } | undefined;
-        }[];
-        readonly meta?: {
-            readonly durationMs: number;
-            readonly sources: readonly {
-                readonly source: "appendix" | "markdown" | "statejson";
-                readonly chunkCount: number;
-                readonly batchCount: number;
-                readonly ranker: "local_lexical" | "mixedbread" | "zeroentropy";
-                readonly fallback: boolean;
-                readonly fallbackReason?: "error" | "timeout" | undefined;
-                readonly durationMs: number;
-            }[];
-        } | undefined;
-    };
-} & {
-    readonly snapshotId: string;
-}, {}, {}>;
-export declare class FetchSnapshotSearchResult extends FetchSnapshotSearchResult_base {
+declare const IconMeta_base: S.Struct<{
+    href: S.filter<typeof S.String>;
+    rel: S.filter<typeof S.String>;
+    type: S.optionalWith<S.filter<typeof S.String>, {
+        nullable: true;
+    }>;
+    sizes: S.optionalWith<S.filter<typeof S.String>, {
+        nullable: true;
+    }>;
+}>;
+export declare class IconMeta extends IconMeta_base {
+}
+declare const OgImage_base: S.Struct<{
+    url: S.filter<typeof S.String>;
+    width: S.optionalWith<typeof S.Number, {
+        nullable: true;
+    }>;
+    height: S.optionalWith<typeof S.Number, {
+        nullable: true;
+    }>;
+    alt: S.optionalWith<typeof S.String, {
+        nullable: true;
+    }>;
+}>;
+export declare class OgImage extends OgImage_base {
 }
-declare const FetchFetchSearch400_base: S.Union<[typeof HttpApiDecodeError, typeof BadRequest]>;
-export declare class FetchFetchSearch400 extends FetchFetchSearch400_base {
+declare const OpenGraphMeta_base: S.Struct<{
+    title: S.optionalWith<typeof S.String, {
+        nullable: true;
+    }>;
+    description: S.optionalWith<typeof S.String, {
+        nullable: true;
+    }>;
+    type: S.optionalWith<S.filter<typeof S.String>, {
+        nullable: true;
+    }>;
+    url: S.optionalWith<S.filter<typeof S.String>, {
+        nullable: true;
+    }>;
+    siteName: S.optionalWith<typeof S.String, {
+        nullable: true;
+    }>;
+    locale: S.optionalWith<typeof S.String, {
+        nullable: true;
+    }>;
+    images: S.optionalWith<S.Array$<typeof OgImage>, {
+        nullable: true;
+    }>;
+}>;
+export declare class OpenGraphMeta extends OpenGraphMeta_base {
 }
-declare const FetchFetchSearch403Tag_base: S.Literal<["AccessBlocked"]>;
-export declare class FetchFetchSearch403Tag extends FetchFetchSearch403Tag_base {
+declare const TwitterCardMeta_base: S.Struct<{
+    card: S.optionalWith<S.filter<typeof S.String>, {
+        nullable: true;
+    }>;
+    site: S.optionalWith<typeof S.String, {
+        nullable: true;
+    }>;
+    creator: S.optionalWith<typeof S.String, {
+        nullable: true;
+    }>;
+    title: S.optionalWith<typeof S.String, {
+        nullable: true;
+    }>;
+    description: S.optionalWith<typeof S.String, {
+        nullable: true;
+    }>;
+    image: S.optionalWith<S.filter<typeof S.String>, {
+        nullable: true;
+    }>;
+}>;
+export declare class TwitterCardMeta extends TwitterCardMeta_base {
 }
-declare const FetchFetchSearch403_base: S.Struct<{
-    organizationId: S.filter<typeof S.String>;
-    blockedUntil: S.optionalWith<S.Union<[typeof DateTimeUtc, typeof S.Null]>, {
+declare const PageMeta_base: S.Struct<{
+    title: S.optionalWith<typeof S.String, {
+        nullable: true;
+    }>;
+    description: S.optionalWith<typeof S.String, {
+        nullable: true;
+    }>;
+    canonicalUrl: S.optionalWith<S.filter<typeof S.String>, {
+        nullable: true;
+    }>;
+    language: S.optionalWith<S.filter<typeof S.String>, {
+        nullable: true;
+    }>;
+    charset: S.optionalWith<S.filter<typeof S.String>, {
+        nullable: true;
+    }>;
+    favicon: S.optionalWith<S.filter<typeof S.String>, {
+        nullable: true;
+    }>;
+    icons: S.optionalWith<S.Array$<typeof IconMeta>, {
+        nullable: true;
+    }>;
+    openGraph: S.optionalWith<typeof OpenGraphMeta, {
+        nullable: true;
+    }>;
+    twitter: S.optionalWith<typeof TwitterCardMeta, {
         nullable: true;
     }>;
-    _tag: typeof FetchFetchSearch403Tag;
 }>;
-export declare class FetchFetchSearch403 extends FetchFetchSearch403_base {
+export declare class PageMeta extends PageMeta_base {
 }
 declare const NonEmptyString_base: S.filter<typeof S.String>;
 export declare class NonEmptyString extends NonEmptyString_base {
 }
-declare const FetchSnapshotSearchNotFoundTag_base: S.Literal<["FetchSnapshotSearchNotFound"]>;
-export declare class FetchSnapshotSearchNotFoundTag extends FetchSnapshotSearchNotFoundTag_base {
+declare const BatchedFetchItemDataVideoProvider_base: S.Literal<["youtube"]>;
+export declare class BatchedFetchItemDataVideoProvider extends BatchedFetchItemDataVideoProvider_base {
 }
-declare const FetchSnapshotSearchNotFound_base: S.Class<FetchSnapshotSearchNotFound, {
-    snapshotId: typeof NonEmptyString;
-    _tag: typeof FetchSnapshotSearchNotFoundTag;
-}, S.Struct.Encoded<{
-    snapshotId: typeof NonEmptyString;
-    _tag: typeof FetchSnapshotSearchNotFoundTag;
-}>, never, {
-    readonly _tag: "FetchSnapshotSearchNotFound";
-} & {
-    readonly snapshotId: string;
-}, {}, {}>;
-export declare class FetchSnapshotSearchNotFound extends FetchSnapshotSearchNotFound_base {
+declare const BatchedFetchItemDataVideoTranscriptSource_base: S.Literal<["captions", "transcription"]>;
+export declare class BatchedFetchItemDataVideoTranscriptSource extends BatchedFetchItemDataVideoTranscriptSource_base {
 }
-declare const FetchBatchedParams_base: S.Struct<{
-    'x-idempotency-key': S.optionalWith<S.filter<S.filter<typeof S.String>>, {
+declare const BatchedFetchItemDataVideoTranscriptKind_base: S.Literal<["manual", "auto"]>;
+export declare class BatchedFetchItemDataVideoTranscriptKind extends BatchedFetchItemDataVideoTranscriptKind_base {
+}
+declare const FetchLink_base: S.Struct<{
+    url: typeof S.String;
+    text: S.optionalWith<typeof S.String, {
         nullable: true;
     }>;
 }>;
-export declare class FetchBatchedParams extends FetchBatchedParams_base {
+export declare class FetchLink extends FetchLink_base {
 }
-declare const FetchBatchedRequest_base: S.Class<FetchBatchedRequest, {
-    urls: S.NonEmptyArray<typeof S.String>;
-    include: S.optionalWith<S.Struct<{
-        html: S.optionalWith<S.Union<[typeof S.Boolean, S.Record$<typeof S.String, typeof S.Unknown>]>, {
+declare const RenderEnginesInfoCapture_base: S.Literal<["rust"]>;
+export declare class RenderEnginesInfoCapture extends RenderEnginesInfoCapture_base {
+}
+declare const RenderEnginesInfoMarkdown_base: S.Literal<["rust"]>;
+export declare class RenderEnginesInfoMarkdown extends RenderEnginesInfoMarkdown_base {
+}
+declare const RenderEnginesInfoTree_base: S.Literal<["rust"]>;
+export declare class RenderEnginesInfoTree extends RenderEnginesInfoTree_base {
+}
+declare const RenderEnginesInfo_base: S.Struct<{
+    capture: S.optionalWith<typeof RenderEnginesInfoCapture, {
+        nullable: true;
+    }>;
+    markdown: S.optionalWith<typeof RenderEnginesInfoMarkdown, {
+        nullable: true;
+    }>;
+    tree: S.optionalWith<typeof RenderEnginesInfoTree, {
+        nullable: true;
+    }>;
+}>;
+export declare class RenderEnginesInfo extends RenderEnginesInfo_base {
+}
+declare const BatchedFetchItem_base: S.Struct<{
+    status: typeof BatchedFetchItemStatus;
+    data: S.optionalWith<S.Struct<{
+        response: typeof ResponseInfo;
+        meta: S.optionalWith<typeof PageMeta, {
             nullable: true;
         }>;
-        markdown: S.optionalWith<S.Union<[typeof S.Boolean, S.Record$<typeof S.String, typeof S.Unknown>]>, {
+        json: S.optionalWith<S.Array$<S.Struct<{}>>, {
             nullable: true;
         }>;
-        screenshot: S.optionalWith<S.Union<[typeof S.Boolean, S.Struct<{
-            fullPage: S.optionalWith<typeof S.Boolean, {
+        snapshotId: S.optionalWith<typeof NonEmptyString, {
+            nullable: true;
+        }>;
+        html: S.optionalWith<S.filter<typeof S.String>, {
+            nullable: true;
+        }>;
+        markdown: S.optionalWith<S.filter<typeof S.String>, {
+            nullable: true;
+        }>;
+        screenshot: S.optionalWith<S.Struct<{
+            url: typeof S.String;
+            fullPage: typeof S.Boolean;
+        }>, {
+            nullable: true;
+        }>;
+        document: S.optionalWith<S.Struct<{
+            url: typeof S.String;
+            contentType: typeof S.String;
+            sizeBytes: typeof S.Number;
+        }>, {
+            nullable: true;
+        }>;
+        usage: S.optionalWith<S.Struct<{
+            documentPages: typeof Int;
+            ocrPages: typeof Int;
+            audioSeconds: S.filter<typeof S.Number>;
+            videos: S.optionalWith<typeof Int, {
                 nullable: true;
             }>;
-        }>]>, {
+        }>, {
             nullable: true;
         }>;
-        links: S.optionalWith<S.Union<[typeof S.Boolean, S.Struct<{
-            sameDomainOnly: S.optionalWith<typeof S.Boolean, {
+        video: S.optionalWith<S.Struct<{
+            provider: typeof BatchedFetchItemDataVideoProvider;
+            videoId: typeof S.String;
+            title: typeof S.String;
+            channel: S.optionalWith<typeof S.String, {
                 nullable: true;
-                default: () => true;
             }>;
-            includePatterns: S.optionalWith<S.Array$<typeof S.String>, {
+            channelUrl: S.optionalWith<typeof S.String, {
                 nullable: true;
             }>;
-            excludePatterns: S.optionalWith<S.Array$<typeof S.String>, {
+            durationSeconds: S.optionalWith<typeof S.Number, {
                 nullable: true;
             }>;
-        }>]>, {
+            publishedAt: S.optionalWith<typeof S.String, {
+                nullable: true;
+            }>;
+            viewCount: S.optionalWith<typeof S.Number, {
+                nullable: true;
+            }>;
+            language: S.optionalWith<typeof S.String, {
+                nullable: true;
+            }>;
+            transcript: S.Struct<{
+                source: typeof BatchedFetchItemDataVideoTranscriptSource;
+                kind: S.optionalWith<typeof BatchedFetchItemDataVideoTranscriptKind, {
+                    nullable: true;
+                }>;
+                language: S.optionalWith<typeof S.String, {
+                    nullable: true;
+                }>;
+            }>;
+            segments: S.optionalWith<S.Array$<S.Struct<{
+                startSeconds: typeof S.Number;
+                text: typeof S.String;
+            }>>, {
+                nullable: true;
+            }>;
+            chapters: S.optionalWith<S.Array$<S.Struct<{
+                title: typeof S.String;
+                startSeconds: typeof S.Number;
+            }>>, {
+                nullable: true;
+            }>;
+            storyboard: S.optionalWith<S.Struct<{
+                frameWidth: typeof S.Int;
+                frameHeight: typeof S.Int;
+                rows: typeof S.Int;
+                columns: typeof S.Int;
+                sheets: S.Array$<S.Struct<{
+                    url: typeof S.String;
+                    durationSeconds: typeof S.Number;
+                }>>;
+            }>, {
+                nullable: true;
+            }>;
+        }>, {
             nullable: true;
         }>;
-        meta: S.optionalWith<typeof S.Boolean, {
+        links: S.optionalWith<S.Array$<typeof FetchLink>, {
             nullable: true;
-            default: () => true;
         }>;
-        response: S.optionalWith<S.Struct<{
-            includeHeaders: S.optionalWith<typeof S.Boolean, {
-                nullable: true;
-                default: () => false;
-            }>;
-        }>, {
+        appendix: S.optionalWith<S.filter<typeof S.String>, {
             nullable: true;
         }>;
-        json: S.optionalWith<typeof S.Boolean, {
+        renderEngines: S.optionalWith<typeof RenderEnginesInfo, {
             nullable: true;
-            default: () => false;
         }>;
-        appendix: S.optionalWith<typeof S.Boolean, {
+        assets: S.optionalWith<S.Array$<typeof FetchAssetReference>, {
             nullable: true;
         }>;
-    }>, {
-        nullable: true;
-    }>;
-    browserConfig: S.optionalWith<S.Struct<{
-        scrollFullPage: S.optionalWith<typeof S.Boolean, {
+        degraded: S.optionalWith<typeof FetchDegradedInfo, {
             nullable: true;
-            default: () => false;
         }>;
     }>, {
         nullable: true;
     }>;
+    error: S.optionalWith<S.Union<[typeof FetchBlocked, typeof FetchPageTooLarge, typeof FetchNavigationFailed, typeof FetchUnsupportedContentType, typeof FetchOriginHttpError, S.Union<[typeof FetchNetworkOriginError, typeof FetchHttpOriginRefusal]>, typeof FetchDocumentProcessingUnavailable, typeof FetchVideoUnavailable, typeof FetchCaptureFailed, typeof FetchCaptureTimeout, typeof FetchCapacityTimeout]>, {
+        nullable: true;
+    }>;
+    originError: S.optionalWith<typeof FetchHttpOriginError, {
+        nullable: true;
+    }>;
+}>;
+export declare class BatchedFetchItem extends BatchedFetchItem_base {
+}
+declare const PaginationMeta_base: S.Struct<{
+    total: typeof S.Number;
+    limit: typeof S.Number;
+    offset: typeof S.Number;
+    hasMore: typeof S.Boolean;
+}>;
+export declare class PaginationMeta extends PaginationMeta_base {
+}
+declare const BatchedStatus_base: S.Class<BatchedStatus, {
+    id: typeof S.String;
+    status: typeof BatchedStatusStatus;
+    batchedStatus: typeof BatchedStatusBatchedStatus;
+    totalUrls: typeof S.Number;
+    results: S.Array$<typeof BatchedFetchItem>;
+    pagination: typeof PaginationMeta;
 }, S.Struct.Encoded<{
-    urls: S.NonEmptyArray<typeof S.String>;
+    id: typeof S.String;
+    status: typeof BatchedStatusStatus;
+    batchedStatus: typeof BatchedStatusBatchedStatus;
+    totalUrls: typeof S.Number;
+    results: S.Array$<typeof BatchedFetchItem>;
+    pagination: typeof PaginationMeta;
+}>, never, {
+    readonly batchedStatus: "CANCELLED" | "CANCELLING" | "COMPLETED" | "FAILED" | "QUEUED" | "RUNNING";
+} & {
+    readonly id: string;
+} & {
+    readonly pagination: {
+        readonly total: number;
+        readonly limit: number;
+        readonly offset: number;
+        readonly hasMore: boolean;
+    };
+} & {
+    readonly results: readonly {
+        readonly status: "CANCELLED" | "FAILED" | "QUEUED" | "RUNNING" | "SUCCEEDED";
+        readonly data?: {
+            readonly response: {
+                readonly url: string;
+                readonly requestedUrl?: string | undefined;
+                readonly originStatusCode?: number | undefined;
+                readonly redirectStatusCode?: number | undefined;
+                readonly contentType?: string | undefined;
+                readonly headers?: {} | undefined;
+            };
+            readonly meta?: {
+                readonly title?: string | undefined;
+                readonly description?: string | undefined;
+                readonly canonicalUrl?: string | undefined;
+                readonly language?: string | undefined;
+                readonly charset?: string | undefined;
+                readonly favicon?: string | undefined;
+                readonly icons?: readonly {
+                    readonly href: string;
+                    readonly rel: string;
+                    readonly type?: string | undefined;
+                    readonly sizes?: string | undefined;
+                }[] | undefined;
+                readonly openGraph?: {
+                    readonly title?: string | undefined;
+                    readonly description?: string | undefined;
+                    readonly type?: string | undefined;
+                    readonly url?: string | undefined;
+                    readonly siteName?: string | undefined;
+                    readonly locale?: string | undefined;
+                    readonly images?: readonly {
+                        readonly url: string;
+                        readonly width?: number | undefined;
+                        readonly height?: number | undefined;
+                        readonly alt?: string | undefined;
+                    }[] | undefined;
+                } | undefined;
+                readonly twitter?: {
+                    readonly card?: string | undefined;
+                    readonly site?: string | undefined;
+                    readonly creator?: string | undefined;
+                    readonly title?: string | undefined;
+                    readonly description?: string | undefined;
+                    readonly image?: string | undefined;
+                } | undefined;
+            } | undefined;
+            readonly json?: readonly {}[] | undefined;
+            readonly snapshotId?: string | undefined;
+            readonly html?: string | undefined;
+            readonly markdown?: string | undefined;
+            readonly screenshot?: {
+                readonly url: string;
+                readonly fullPage: boolean;
+            } | undefined;
+            readonly document?: {
+                readonly url: string;
+                readonly contentType: string;
+                readonly sizeBytes: number;
+            } | undefined;
+            readonly usage?: {
+                readonly documentPages: number;
+                readonly ocrPages: number;
+                readonly audioSeconds: number;
+                readonly videos?: number | undefined;
+            } | undefined;
+            readonly video?: {
+                readonly provider: "youtube";
+                readonly videoId: string;
+                readonly title: string;
+                readonly channel?: string | undefined;
+                readonly channelUrl?: string | undefined;
+                readonly durationSeconds?: number | undefined;
+                readonly publishedAt?: string | undefined;
+                readonly viewCount?: number | undefined;
+                readonly language?: string | undefined;
+                readonly transcript: {
+                    readonly source: "captions" | "transcription";
+                    readonly kind?: "auto" | "manual" | undefined;
+                    readonly language?: string | undefined;
+                };
+                readonly segments?: readonly {
+                    readonly startSeconds: number;
+                    readonly text: string;
+                }[] | undefined;
+                readonly chapters?: readonly {
+                    readonly title: string;
+                    readonly startSeconds: number;
+                }[] | undefined;
+                readonly storyboard?: {
+                    readonly frameWidth: number;
+                    readonly frameHeight: number;
+                    readonly rows: number;
+                    readonly columns: number;
+                    readonly sheets: readonly {
+                        readonly url: string;
+                        readonly durationSeconds: number;
+                    }[];
+                } | undefined;
+            } | undefined;
+            readonly links?: readonly {
+                readonly url: string;
+                readonly text?: string | undefined;
+            }[] | undefined;
+            readonly appendix?: string | undefined;
+            readonly renderEngines?: {
+                readonly capture?: "rust" | undefined;
+                readonly markdown?: "rust" | undefined;
+                readonly tree?: "rust" | undefined;
+            } | undefined;
+            readonly assets?: readonly {
+                readonly id: string;
+                readonly kind: "data-url";
+                readonly placeholder: string;
+                readonly archiveKey: string;
+                readonly mimeType: string;
+                readonly sha256: string;
+                readonly bytes: number;
+            }[] | undefined;
+            readonly degraded?: {
+                readonly reason: "modelInputTooLarge" | "pageTooLarge";
+                readonly skipped: readonly "hfc"[];
+                readonly limitKind: "ast_bytes" | "document_frame_bytes" | "domsnapshot_bytes" | "hfc_tokens";
+                readonly measuredBytes?: number | undefined;
+                readonly thresholdBytes?: number | undefined;
+                readonly measuredTokens?: number | undefined;
+                readonly thresholdTokens?: number | undefined;
+            } | undefined;
+        } | undefined;
+        readonly error?: FetchCapacityTimeout | FetchCaptureTimeout | FetchUnsupportedContentType | FetchVideoUnavailable | {
+            readonly url: string;
+            readonly blockedType?: string | undefined;
+            readonly _tag: "FetchBlocked";
+        } | {
+            readonly url: string;
+            readonly limitKind?: "ast_bytes" | "audio_seconds" | "document_frame_bytes" | "document_pages" | "domsnapshot_bytes" | "transfer_bytes" | undefined;
+            readonly limitBytes?: number | undefined;
+            readonly measuredBytes?: number | undefined;
+            readonly limit?: number | undefined;
+            readonly measured?: number | undefined;
+            readonly _tag: "FetchPageTooLarge";
+        } | {
+            readonly url: string;
+            readonly failureType: "capabilityFailed" | "pageNeverSettled";
+            readonly retryable: false;
+            readonly _tag: "FetchCaptureFailed";
+        } | {
+            readonly url: string;
+            readonly failureType: "browserInternalDocument";
+            readonly retryable: false;
+            readonly _tag: "FetchNavigationFailed";
+        } | {
+            readonly url: string;
+            readonly statusCode: number;
+            readonly contentType?: string | undefined;
+            readonly _tag: "FetchOriginHttpError";
+        } | {
+            readonly url: string;
+            readonly operation: "ocr" | "transcription" | "video";
+            readonly message: string;
+            readonly _tag: "FetchDocumentProcessingUnavailable";
+        } | {
+            readonly url: string;
+            readonly kind: "addressUnreachable" | "connectionClosed" | "connectionRefused" | "connectionReset" | "connectionTimeout" | "dns" | "emptyResponse" | "tls";
+            readonly upstreamError?: string | undefined;
+            readonly retryable: boolean;
+            readonly _tag: "FetchOriginError";
+        } | {
+            readonly _tag: "FetchOriginError";
+            readonly url: string;
+            readonly kind: "http";
+            readonly contentAvailable: false;
+            readonly finalUrl?: string | undefined;
+            readonly redirectLimitReached?: true | undefined;
+            readonly originStatusCode: number;
+            readonly retryable: boolean;
+        } | undefined;
+        readonly originError?: {
+            readonly url: string;
+            readonly kind: "http";
+            readonly contentAvailable?: false | undefined;
+            readonly finalUrl?: string | undefined;
+            readonly redirectLimitReached?: true | undefined;
+            readonly originStatusCode: number;
+            readonly retryable: boolean;
+            readonly _tag: "FetchOriginError";
+        } | undefined;
+    }[];
+} & {
+    readonly status: "CANCELLED" | "CANCELLING" | "COMPLETED" | "FAILED" | "QUEUED" | "RUNNING";
+} & {
+    readonly totalUrls: number;
+}, {}, {}>;
+export declare class BatchedStatus extends BatchedStatus_base {
+}
+declare const BatchedIncludeUnsupportedTag_base: S.Literal<["BatchedIncludeUnsupported"]>;
+export declare class BatchedIncludeUnsupportedTag extends BatchedIncludeUnsupportedTag_base {
+}
+declare const BatchedIncludeUnsupported_base: S.Struct<{
+    unsupportedFields: S.Array$<typeof S.String>;
+    _tag: typeof BatchedIncludeUnsupportedTag;
+}>;
+export declare class BatchedIncludeUnsupported extends BatchedIncludeUnsupported_base {
+}
+declare const FetchGetBatched400_base: S.Union<[typeof HttpApiDecodeError, typeof BatchedIncludeUnsupported]>;
+export declare class FetchGetBatched400 extends FetchGetBatched400_base {
+}
+declare const BatchedCancellationStatus_base: S.Literal<["CANCELLING", "CANCELLED"]>;
+export declare class BatchedCancellationStatus extends BatchedCancellationStatus_base {
+}
+declare const BatchedCancellation_base: S.Class<BatchedCancellation, {
+    id: typeof S.String;
+    status: typeof BatchedCancellationStatus;
+}, S.Struct.Encoded<{
+    id: typeof S.String;
+    status: typeof BatchedCancellationStatus;
+}>, never, {
+    readonly id: string;
+} & {
+    readonly status: "CANCELLED" | "CANCELLING";
+}, {}, {}>;
+export declare class BatchedCancellation extends BatchedCancellation_base {
+}
+declare const BatchedCancellationConflictStatus_base: S.Literal<["COMPLETED", "FAILED"]>;
+export declare class BatchedCancellationConflictStatus extends BatchedCancellationConflictStatus_base {
+}
+declare const BatchedCancellationConflictTag_base: S.Literal<["BatchedCancellationConflict"]>;
+export declare class BatchedCancellationConflictTag extends BatchedCancellationConflictTag_base {
+}
+declare const BatchedCancellationConflict_base: S.Class<BatchedCancellationConflict, {
+    id: typeof S.String;
+    status: typeof BatchedCancellationConflictStatus;
+    _tag: typeof BatchedCancellationConflictTag;
+}, S.Struct.Encoded<{
+    id: typeof S.String;
+    status: typeof BatchedCancellationConflictStatus;
+    _tag: typeof BatchedCancellationConflictTag;
+}>, never, {
+    readonly _tag: "BatchedCancellationConflict";
+} & {
+    readonly id: string;
+} & {
+    readonly status: "COMPLETED" | "FAILED";
+}, {}, {}>;
+export declare class BatchedCancellationConflict extends BatchedCancellationConflict_base {
+}
+declare const SnapshotHighlightsInputIncludeAppendixMarkers_base: S.Literal<["off", "compact", "detailed"]>;
+export declare class SnapshotHighlightsInputIncludeAppendixMarkers extends SnapshotHighlightsInputIncludeAppendixMarkers_base {
+}
+declare const SnapshotHighlightsInput_base: S.Class<SnapshotHighlightsInput, {
+    highlights: S.Struct<{
+        query: typeof S.String;
+        maxResults: S.optionalWith<S.filter<S.filter<typeof S.Int>>, {
+            nullable: true;
+            default: () => 5;
+        }>;
+        minScore: S.optionalWith<S.filter<S.filter<typeof S.Number>>, {
+            nullable: true;
+            default: () => 0.6;
+        }>;
+    }>;
     include: S.optionalWith<S.Struct<{
         html: S.optionalWith<S.Union<[typeof S.Boolean, S.Record$<typeof S.String, typeof S.Unknown>]>, {
             nullable: true;
@@ -1419,25 +2392,83 @@ declare const FetchBatchedRequest_base: S.Class<FetchBatchedRequest, {
         appendix: S.optionalWith<typeof S.Boolean, {
             nullable: true;
         }>;
+        appendixMarkers: S.optionalWith<typeof SnapshotHighlightsInputIncludeAppendixMarkers, {
+            nullable: true;
+            default: () => "compact";
+        }>;
     }>, {
         nullable: true;
     }>;
-    browserConfig: S.optionalWith<S.Struct<{
-        scrollFullPage: S.optionalWith<typeof S.Boolean, {
+}, S.Struct.Encoded<{
+    highlights: S.Struct<{
+        query: typeof S.String;
+        maxResults: S.optionalWith<S.filter<S.filter<typeof S.Int>>, {
             nullable: true;
-            default: () => false;
+            default: () => 5;
+        }>;
+        minScore: S.optionalWith<S.filter<S.filter<typeof S.Number>>, {
+            nullable: true;
+            default: () => 0.6;
         }>;
-    }>, {
-        nullable: true;
     }>;
-}>, never, {
-    readonly browserConfig?: {
-        readonly scrollFullPage: boolean;
-    } | undefined;
-} & {
-    readonly include?: {
-        readonly html?: boolean | {
-            readonly [x: string]: unknown;
+    include: S.optionalWith<S.Struct<{
+        html: S.optionalWith<S.Union<[typeof S.Boolean, S.Record$<typeof S.String, typeof S.Unknown>]>, {
+            nullable: true;
+        }>;
+        markdown: S.optionalWith<S.Union<[typeof S.Boolean, S.Record$<typeof S.String, typeof S.Unknown>]>, {
+            nullable: true;
+        }>;
+        screenshot: S.optionalWith<S.Union<[typeof S.Boolean, S.Struct<{
+            fullPage: S.optionalWith<typeof S.Boolean, {
+                nullable: true;
+            }>;
+        }>]>, {
+            nullable: true;
+        }>;
+        links: S.optionalWith<S.Union<[typeof S.Boolean, S.Struct<{
+            sameDomainOnly: S.optionalWith<typeof S.Boolean, {
+                nullable: true;
+                default: () => true;
+            }>;
+            includePatterns: S.optionalWith<S.Array$<typeof S.String>, {
+                nullable: true;
+            }>;
+            excludePatterns: S.optionalWith<S.Array$<typeof S.String>, {
+                nullable: true;
+            }>;
+        }>]>, {
+            nullable: true;
+        }>;
+        meta: S.optionalWith<typeof S.Boolean, {
+            nullable: true;
+            default: () => true;
+        }>;
+        response: S.optionalWith<S.Struct<{
+            includeHeaders: S.optionalWith<typeof S.Boolean, {
+                nullable: true;
+                default: () => false;
+            }>;
+        }>, {
+            nullable: true;
+        }>;
+        json: S.optionalWith<typeof S.Boolean, {
+            nullable: true;
+            default: () => false;
+        }>;
+        appendix: S.optionalWith<typeof S.Boolean, {
+            nullable: true;
+        }>;
+        appendixMarkers: S.optionalWith<typeof SnapshotHighlightsInputIncludeAppendixMarkers, {
+            nullable: true;
+            default: () => "compact";
+        }>;
+    }>, {
+        nullable: true;
+    }>;
+}>, never, {
+    readonly include?: {
+        readonly html?: boolean | {
+            readonly [x: string]: unknown;
         } | undefined;
         readonly markdown?: boolean | {
             readonly [x: string]: unknown;
@@ -1456,481 +2487,206 @@ declare const FetchBatchedRequest_base: S.Class<FetchBatchedRequest, {
         } | undefined;
         readonly json: boolean;
         readonly appendix?: boolean | undefined;
+        readonly appendixMarkers: "compact" | "detailed" | "off";
     } | undefined;
 } & {
-    readonly urls: readonly [string, ...string[]];
+    readonly highlights: {
+        readonly query: string;
+        readonly maxResults: number;
+        readonly minScore: number;
+    };
 }, {}, {}>;
-export declare class FetchBatchedRequest extends FetchBatchedRequest_base {
+export declare class SnapshotHighlightsInput extends SnapshotHighlightsInput_base {
 }
-declare const BatchedRun_base: S.Class<BatchedRun, {
-    id: typeof S.String;
+declare const FetchSnapshotHighlightsResult_base: S.Class<FetchSnapshotHighlightsResult, {
+    snapshotId: S.filter<typeof S.String>;
+    response: typeof ResponseInfo;
+    highlights: typeof FetchHighlightsResult;
+    durationMs: S.filter<typeof S.Number>;
+    playground: typeof S.String;
 }, S.Struct.Encoded<{
-    id: typeof S.String;
+    snapshotId: S.filter<typeof S.String>;
+    response: typeof ResponseInfo;
+    highlights: typeof FetchHighlightsResult;
+    durationMs: S.filter<typeof S.Number>;
+    playground: typeof S.String;
 }>, never, {
-    readonly id: string;
+    readonly durationMs: number;
+} & {
+    readonly highlights: {
+        readonly query: string;
+        readonly snippets: readonly {
+            readonly type: "text";
+            readonly source: "appendix" | "markdown" | "statejson";
+            readonly text: string;
+            readonly score: number;
+            readonly location?: {
+                readonly evidenceId?: number | undefined;
+                readonly markdownBlockId?: string | undefined;
+                readonly nodeIds?: readonly number[] | undefined;
+                readonly stateJsonSourceId?: number | undefined;
+                readonly jsonPath?: string | undefined;
+            } | undefined;
+        }[];
+        readonly meta?: {
+            readonly durationMs: number;
+            readonly sources: readonly {
+                readonly source: "appendix" | "markdown" | "statejson";
+                readonly chunkCount: number;
+                readonly batchCount: number;
+                readonly ranker: "local_lexical" | "mixedbread" | "zeroentropy";
+                readonly fallback: boolean;
+                readonly fallbackReason?: "error" | "timeout" | undefined;
+                readonly durationMs: number;
+            }[];
+        } | undefined;
+    };
+} & {
+    readonly playground: string;
+} & {
+    readonly response: {
+        readonly url: string;
+        readonly requestedUrl?: string | undefined;
+        readonly originStatusCode?: number | undefined;
+        readonly redirectStatusCode?: number | undefined;
+        readonly contentType?: string | undefined;
+        readonly headers?: {} | undefined;
+    };
+} & {
+    readonly snapshotId: string;
 }, {}, {}>;
-export declare class BatchedRun extends BatchedRun_base {
+export declare class FetchSnapshotHighlightsResult extends FetchSnapshotHighlightsResult_base {
 }
-declare const FetchBatched400_base: S.Union<[typeof HttpApiDecodeError, typeof BadRequest]>;
-export declare class FetchBatched400 extends FetchBatched400_base {
+declare const SnapshotsHighlights400_base: S.Union<[typeof HttpApiDecodeError, typeof BadRequest]>;
+export declare class SnapshotsHighlights400 extends SnapshotsHighlights400_base {
 }
-declare const FetchBatched403Tag_base: S.Literal<["AccessBlocked"]>;
-export declare class FetchBatched403Tag extends FetchBatched403Tag_base {
+declare const SnapshotsHighlights403Tag_base: S.Literal<["AccessBlocked"]>;
+export declare class SnapshotsHighlights403Tag extends SnapshotsHighlights403Tag_base {
 }
-declare const FetchBatched403_base: S.Struct<{
+declare const SnapshotsHighlights403_base: S.Struct<{
     organizationId: S.filter<typeof S.String>;
     blockedUntil: S.optionalWith<S.Union<[typeof DateTimeUtc, typeof S.Null]>, {
         nullable: true;
     }>;
-    _tag: typeof FetchBatched403Tag;
+    _tag: typeof SnapshotsHighlights403Tag;
 }>;
-export declare class FetchBatched403 extends FetchBatched403_base {
-}
-declare const BatchedIdempotencyConflictReason_base: S.Literal<["payload_mismatch"]>;
-export declare class BatchedIdempotencyConflictReason extends BatchedIdempotencyConflictReason_base {
+export declare class SnapshotsHighlights403 extends SnapshotsHighlights403_base {
 }
-declare const BatchedIdempotencyConflictTag_base: S.Literal<["BatchedIdempotencyConflict"]>;
-export declare class BatchedIdempotencyConflictTag extends BatchedIdempotencyConflictTag_base {
+declare const FetchSnapshotHighlightsNotFoundTag_base: S.Literal<["FetchSnapshotHighlightsNotFound"]>;
+export declare class FetchSnapshotHighlightsNotFoundTag extends FetchSnapshotHighlightsNotFoundTag_base {
 }
-declare const BatchedIdempotencyConflict_base: S.Class<BatchedIdempotencyConflict, {
-    existingRunId: typeof S.String;
-    reason: typeof BatchedIdempotencyConflictReason;
-    _tag: typeof BatchedIdempotencyConflictTag;
+declare const FetchSnapshotHighlightsNotFound_base: S.Class<FetchSnapshotHighlightsNotFound, {
+    snapshotId: typeof NonEmptyString;
+    _tag: typeof FetchSnapshotHighlightsNotFoundTag;
 }, S.Struct.Encoded<{
-    existingRunId: typeof S.String;
-    reason: typeof BatchedIdempotencyConflictReason;
-    _tag: typeof BatchedIdempotencyConflictTag;
+    snapshotId: typeof NonEmptyString;
+    _tag: typeof FetchSnapshotHighlightsNotFoundTag;
 }>, never, {
-    readonly _tag: "BatchedIdempotencyConflict";
-} & {
-    readonly existingRunId: string;
+    readonly _tag: "FetchSnapshotHighlightsNotFound";
 } & {
-    readonly reason: "payload_mismatch";
+    readonly snapshotId: string;
 }, {}, {}>;
-export declare class BatchedIdempotencyConflict extends BatchedIdempotencyConflict_base {
-}
-declare const FetchGetBatchedParams_base: S.Struct<{
-    limit: S.optionalWith<typeof S.String, {
-        nullable: true;
-    }>;
-    offset: S.optionalWith<typeof S.String, {
-        nullable: true;
-    }>;
-    include: S.optionalWith<typeof S.String, {
-        nullable: true;
-    }>;
-}>;
-export declare class FetchGetBatchedParams extends FetchGetBatchedParams_base {
+export declare class FetchSnapshotHighlightsNotFound extends FetchSnapshotHighlightsNotFound_base {
 }
-declare const BatchedStatusStatus_base: S.Literal<["QUEUED", "RUNNING", "CANCELLING", "COMPLETED", "FAILED", "CANCELLED"]>;
-export declare class BatchedStatusStatus extends BatchedStatusStatus_base {
-}
-declare const BatchedStatusBatchedStatus_base: S.Literal<["QUEUED", "RUNNING", "CANCELLING", "COMPLETED", "FAILED", "CANCELLED"]>;
-export declare class BatchedStatusBatchedStatus extends BatchedStatusBatchedStatus_base {
+declare const SnapshotsHighlights429_base: S.Union<[typeof TooManyRequests, typeof FetchConcurrencyLimitExceeded]>;
+export declare class SnapshotsHighlights429 extends SnapshotsHighlights429_base {
 }
-declare const BatchedFetchItemStatus_base: S.Literal<["QUEUED", "RUNNING", "SUCCEEDED", "FAILED", "CANCELLED"]>;
-export declare class BatchedFetchItemStatus extends BatchedFetchItemStatus_base {
+declare const PublicSnapshotsGetCatalogParamsFormat_base: S.Literal<["json", "markdown"]>;
+export declare class PublicSnapshotsGetCatalogParamsFormat extends PublicSnapshotsGetCatalogParamsFormat_base {
 }
-declare const IconMeta_base: S.Struct<{
-    href: S.filter<typeof S.String>;
-    rel: S.filter<typeof S.String>;
-    type: S.optionalWith<S.filter<typeof S.String>, {
-        nullable: true;
-    }>;
-    sizes: S.optionalWith<S.filter<typeof S.String>, {
+declare const PublicSnapshotsGetCatalogParams_base: S.Struct<{
+    format: S.optionalWith<typeof PublicSnapshotsGetCatalogParamsFormat, {
         nullable: true;
     }>;
 }>;
-export declare class IconMeta extends IconMeta_base {
+export declare class PublicSnapshotsGetCatalogParams extends PublicSnapshotsGetCatalogParams_base {
 }
-declare const OgImage_base: S.Struct<{
-    url: S.filter<typeof S.String>;
-    width: S.optionalWith<typeof S.Number, {
-        nullable: true;
-    }>;
-    height: S.optionalWith<typeof S.Number, {
-        nullable: true;
-    }>;
-    alt: S.optionalWith<typeof S.String, {
-        nullable: true;
-    }>;
-}>;
-export declare class OgImage extends OgImage_base {
+declare const SnapshotCatalogVersion_base: S.Literal<[1]>;
+export declare class SnapshotCatalogVersion extends SnapshotCatalogVersion_base {
 }
-declare const OpenGraphMeta_base: S.Struct<{
-    title: S.optionalWith<typeof S.String, {
-        nullable: true;
-    }>;
-    description: S.optionalWith<typeof S.String, {
-        nullable: true;
-    }>;
-    type: S.optionalWith<S.filter<typeof S.String>, {
-        nullable: true;
-    }>;
-    url: S.optionalWith<S.filter<typeof S.String>, {
-        nullable: true;
+declare const SnapshotCatalog_base: S.Class<SnapshotCatalog, {
+    version: typeof SnapshotCatalogVersion;
+    snapshotId: typeof S.String;
+    collections: S.Struct<{
+        evidence: typeof S.String;
+        network: typeof S.String;
+        assets: typeof S.String;
+        artifacts: typeof S.String;
     }>;
-    siteName: S.optionalWith<typeof S.String, {
-        nullable: true;
+    artifacts: S.Array$<S.Struct<{
+        id: typeof S.String;
+        kind: typeof S.String;
+        url: typeof S.String;
+        preview: S.optionalWith<typeof S.String, {
+            nullable: true;
+        }>;
+    }>>;
+    links: S.Struct<{
+        markdown: typeof S.String;
+        json: typeof S.String;
     }>;
-    locale: S.optionalWith<typeof S.String, {
-        nullable: true;
+}, S.Struct.Encoded<{
+    version: typeof SnapshotCatalogVersion;
+    snapshotId: typeof S.String;
+    collections: S.Struct<{
+        evidence: typeof S.String;
+        network: typeof S.String;
+        assets: typeof S.String;
+        artifacts: typeof S.String;
     }>;
-    images: S.optionalWith<S.Array$<typeof OgImage>, {
-        nullable: true;
+    artifacts: S.Array$<S.Struct<{
+        id: typeof S.String;
+        kind: typeof S.String;
+        url: typeof S.String;
+        preview: S.optionalWith<typeof S.String, {
+            nullable: true;
+        }>;
+    }>>;
+    links: S.Struct<{
+        markdown: typeof S.String;
+        json: typeof S.String;
     }>;
-}>;
-export declare class OpenGraphMeta extends OpenGraphMeta_base {
+}>, never, {
+    readonly artifacts: readonly {
+        readonly id: string;
+        readonly kind: string;
+        readonly url: string;
+        readonly preview?: string | undefined;
+    }[];
+} & {
+    readonly collections: {
+        readonly evidence: string;
+        readonly network: string;
+        readonly assets: string;
+        readonly artifacts: string;
+    };
+} & {
+    readonly links: {
+        readonly markdown: string;
+        readonly json: string;
+    };
+} & {
+    readonly snapshotId: string;
+} & {
+    readonly version: 1;
+}, {}, {}>;
+export declare class SnapshotCatalog extends SnapshotCatalog_base {
 }
-declare const TwitterCardMeta_base: S.Struct<{
-    card: S.optionalWith<S.filter<typeof S.String>, {
-        nullable: true;
-    }>;
-    site: S.optionalWith<typeof S.String, {
-        nullable: true;
-    }>;
-    creator: S.optionalWith<typeof S.String, {
-        nullable: true;
-    }>;
-    title: S.optionalWith<typeof S.String, {
-        nullable: true;
-    }>;
-    description: S.optionalWith<typeof S.String, {
-        nullable: true;
-    }>;
-    image: S.optionalWith<S.filter<typeof S.String>, {
-        nullable: true;
-    }>;
-}>;
-export declare class TwitterCardMeta extends TwitterCardMeta_base {
+declare const SnapshotNotFoundTag_base: S.Literal<["SnapshotNotFound"]>;
+export declare class SnapshotNotFoundTag extends SnapshotNotFoundTag_base {
 }
-declare const PageMeta_base: S.Struct<{
-    title: S.optionalWith<typeof S.String, {
-        nullable: true;
-    }>;
-    description: S.optionalWith<typeof S.String, {
-        nullable: true;
-    }>;
-    canonicalUrl: S.optionalWith<S.filter<typeof S.String>, {
-        nullable: true;
-    }>;
-    language: S.optionalWith<S.filter<typeof S.String>, {
-        nullable: true;
-    }>;
-    charset: S.optionalWith<S.filter<typeof S.String>, {
-        nullable: true;
-    }>;
-    favicon: S.optionalWith<S.filter<typeof S.String>, {
-        nullable: true;
-    }>;
-    icons: S.optionalWith<S.Array$<typeof IconMeta>, {
-        nullable: true;
-    }>;
-    openGraph: S.optionalWith<typeof OpenGraphMeta, {
-        nullable: true;
-    }>;
-    twitter: S.optionalWith<typeof TwitterCardMeta, {
-        nullable: true;
-    }>;
-}>;
-export declare class PageMeta extends PageMeta_base {
-}
-declare const FetchLink_base: S.Struct<{
-    url: typeof S.String;
-    text: S.optionalWith<typeof S.String, {
-        nullable: true;
-    }>;
-}>;
-export declare class FetchLink extends FetchLink_base {
-}
-declare const RenderEnginesInfoCapture_base: S.Literal<["rust"]>;
-export declare class RenderEnginesInfoCapture extends RenderEnginesInfoCapture_base {
-}
-declare const RenderEnginesInfoMarkdown_base: S.Literal<["rust"]>;
-export declare class RenderEnginesInfoMarkdown extends RenderEnginesInfoMarkdown_base {
-}
-declare const RenderEnginesInfoTree_base: S.Literal<["rust"]>;
-export declare class RenderEnginesInfoTree extends RenderEnginesInfoTree_base {
-}
-declare const RenderEnginesInfo_base: S.Struct<{
-    capture: S.optionalWith<typeof RenderEnginesInfoCapture, {
-        nullable: true;
-    }>;
-    markdown: S.optionalWith<typeof RenderEnginesInfoMarkdown, {
-        nullable: true;
-    }>;
-    tree: S.optionalWith<typeof RenderEnginesInfoTree, {
-        nullable: true;
-    }>;
-}>;
-export declare class RenderEnginesInfo extends RenderEnginesInfo_base {
-}
-declare const BatchedFetchItem_base: S.Struct<{
-    status: typeof BatchedFetchItemStatus;
-    data: S.optionalWith<S.Struct<{
-        response: typeof ResponseInfo;
-        meta: S.optionalWith<typeof PageMeta, {
-            nullable: true;
-        }>;
-        json: S.optionalWith<S.Array$<S.Struct<{}>>, {
-            nullable: true;
-        }>;
-        snapshotId: S.optionalWith<typeof NonEmptyString, {
-            nullable: true;
-        }>;
-        html: S.optionalWith<S.filter<typeof S.String>, {
-            nullable: true;
-        }>;
-        markdown: S.optionalWith<S.filter<typeof S.String>, {
-            nullable: true;
-        }>;
-        screenshot: S.optionalWith<S.Struct<{
-            url: typeof S.String;
-            fullPage: typeof S.Boolean;
-        }>, {
-            nullable: true;
-        }>;
-        search: S.optionalWith<typeof FetchSearchResult, {
-            nullable: true;
-        }>;
-        links: S.optionalWith<S.Array$<typeof FetchLink>, {
-            nullable: true;
-        }>;
-        appendix: S.optionalWith<S.filter<typeof S.String>, {
-            nullable: true;
-        }>;
-        renderEngines: S.optionalWith<typeof RenderEnginesInfo, {
-            nullable: true;
-        }>;
-        assets: S.optionalWith<S.Array$<typeof FetchAssetReference>, {
-            nullable: true;
-        }>;
-        degraded: S.optionalWith<typeof FetchDegradedInfo, {
-            nullable: true;
-        }>;
-    }>, {
-        nullable: true;
-    }>;
-    error: S.optionalWith<S.Union<[typeof FetchBlocked, typeof FetchPageTooLarge, typeof FetchNavigationFailed, typeof FetchCaptureTimeout, typeof FetchCapacityTimeout]>, {
-        nullable: true;
-    }>;
-}>;
-export declare class BatchedFetchItem extends BatchedFetchItem_base {
-}
-declare const PaginationMeta_base: S.Struct<{
-    total: typeof S.Number;
-    limit: typeof S.Number;
-    offset: typeof S.Number;
-    hasMore: typeof S.Boolean;
-}>;
-export declare class PaginationMeta extends PaginationMeta_base {
-}
-declare const BatchedStatus_base: S.Class<BatchedStatus, {
-    id: typeof S.String;
-    status: typeof BatchedStatusStatus;
-    batchedStatus: typeof BatchedStatusBatchedStatus;
-    totalUrls: typeof S.Number;
-    results: S.Array$<typeof BatchedFetchItem>;
-    pagination: typeof PaginationMeta;
-}, S.Struct.Encoded<{
-    id: typeof S.String;
-    status: typeof BatchedStatusStatus;
-    batchedStatus: typeof BatchedStatusBatchedStatus;
-    totalUrls: typeof S.Number;
-    results: S.Array$<typeof BatchedFetchItem>;
-    pagination: typeof PaginationMeta;
-}>, never, {
-    readonly batchedStatus: "CANCELLED" | "CANCELLING" | "COMPLETED" | "FAILED" | "QUEUED" | "RUNNING";
-} & {
-    readonly id: string;
-} & {
-    readonly pagination: {
-        readonly total: number;
-        readonly limit: number;
-        readonly offset: number;
-        readonly hasMore: boolean;
-    };
-} & {
-    readonly results: readonly {
-        readonly status: "CANCELLED" | "FAILED" | "QUEUED" | "RUNNING" | "SUCCEEDED";
-        readonly data?: {
-            readonly response: {
-                readonly url: string;
-                readonly requestedUrl?: string | undefined;
-                readonly originStatusCode?: number | undefined;
-                readonly redirectStatusCode?: number | undefined;
-                readonly headers?: {} | undefined;
-            };
-            readonly meta?: {
-                readonly title?: string | undefined;
-                readonly description?: string | undefined;
-                readonly canonicalUrl?: string | undefined;
-                readonly language?: string | undefined;
-                readonly charset?: string | undefined;
-                readonly favicon?: string | undefined;
-                readonly icons?: readonly {
-                    readonly href: string;
-                    readonly rel: string;
-                    readonly type?: string | undefined;
-                    readonly sizes?: string | undefined;
-                }[] | undefined;
-                readonly openGraph?: {
-                    readonly title?: string | undefined;
-                    readonly description?: string | undefined;
-                    readonly type?: string | undefined;
-                    readonly url?: string | undefined;
-                    readonly siteName?: string | undefined;
-                    readonly locale?: string | undefined;
-                    readonly images?: readonly {
-                        readonly url: string;
-                        readonly width?: number | undefined;
-                        readonly height?: number | undefined;
-                        readonly alt?: string | undefined;
-                    }[] | undefined;
-                } | undefined;
-                readonly twitter?: {
-                    readonly card?: string | undefined;
-                    readonly site?: string | undefined;
-                    readonly creator?: string | undefined;
-                    readonly title?: string | undefined;
-                    readonly description?: string | undefined;
-                    readonly image?: string | undefined;
-                } | undefined;
-            } | undefined;
-            readonly json?: readonly {}[] | undefined;
-            readonly snapshotId?: string | undefined;
-            readonly html?: string | undefined;
-            readonly markdown?: string | undefined;
-            readonly screenshot?: {
-                readonly url: string;
-                readonly fullPage: boolean;
-            } | undefined;
-            readonly search?: {
-                readonly query: string;
-                readonly snippets: readonly {
-                    readonly type: "text";
-                    readonly source: "appendix" | "markdown" | "statejson";
-                    readonly text: string;
-                    readonly score: number;
-                    readonly location?: {
-                        readonly evidenceId?: number | undefined;
-                        readonly markdownBlockId?: string | undefined;
-                        readonly nodeIds?: readonly number[] | undefined;
-                        readonly stateJsonSourceId?: number | undefined;
-                        readonly jsonPath?: string | undefined;
-                    } | undefined;
-                }[];
-                readonly meta?: {
-                    readonly durationMs: number;
-                    readonly sources: readonly {
-                        readonly source: "appendix" | "markdown" | "statejson";
-                        readonly chunkCount: number;
-                        readonly batchCount: number;
-                        readonly ranker: "local_lexical" | "mixedbread" | "zeroentropy";
-                        readonly fallback: boolean;
-                        readonly fallbackReason?: "error" | "timeout" | undefined;
-                        readonly durationMs: number;
-                    }[];
-                } | undefined;
-            } | undefined;
-            readonly links?: readonly {
-                readonly url: string;
-                readonly text?: string | undefined;
-            }[] | undefined;
-            readonly appendix?: string | undefined;
-            readonly renderEngines?: {
-                readonly capture?: "rust" | undefined;
-                readonly markdown?: "rust" | undefined;
-                readonly tree?: "rust" | undefined;
-            } | undefined;
-            readonly assets?: readonly {
-                readonly id: string;
-                readonly kind: "data-url";
-                readonly placeholder: string;
-                readonly archiveKey: string;
-                readonly mimeType: string;
-                readonly sha256: string;
-                readonly bytes: number;
-            }[] | undefined;
-            readonly degraded?: {
-                readonly reason: "modelInputTooLarge" | "pageTooLarge";
-                readonly skipped: readonly "hfc"[];
-                readonly limitKind: "ast_bytes" | "domsnapshot_bytes" | "hfc_tokens";
-                readonly measuredBytes?: number | undefined;
-                readonly thresholdBytes?: number | undefined;
-                readonly measuredTokens?: number | undefined;
-                readonly thresholdTokens?: number | undefined;
-            } | undefined;
-        } | undefined;
-        readonly error?: FetchCapacityTimeout | FetchCaptureTimeout | FetchNavigationFailed | {
-            readonly url: string;
-            readonly blockedType?: string | undefined;
-            readonly _tag: "FetchBlocked";
-        } | {
-            readonly url: string;
-            readonly limitKind?: "ast_bytes" | "domsnapshot_bytes" | "transfer_bytes" | undefined;
-            readonly limitBytes?: number | undefined;
-            readonly measuredBytes?: number | undefined;
-            readonly _tag: "FetchPageTooLarge";
-        } | undefined;
-    }[];
-} & {
-    readonly status: "CANCELLED" | "CANCELLING" | "COMPLETED" | "FAILED" | "QUEUED" | "RUNNING";
-} & {
-    readonly totalUrls: number;
-}, {}, {}>;
-export declare class BatchedStatus extends BatchedStatus_base {
-}
-declare const BatchedIncludeUnsupportedTag_base: S.Literal<["BatchedIncludeUnsupported"]>;
-export declare class BatchedIncludeUnsupportedTag extends BatchedIncludeUnsupportedTag_base {
-}
-declare const BatchedIncludeUnsupported_base: S.Struct<{
-    unsupportedFields: S.Array$<typeof S.String>;
-    _tag: typeof BatchedIncludeUnsupportedTag;
-}>;
-export declare class BatchedIncludeUnsupported extends BatchedIncludeUnsupported_base {
-}
-declare const FetchGetBatched400_base: S.Union<[typeof HttpApiDecodeError, typeof BatchedIncludeUnsupported]>;
-export declare class FetchGetBatched400 extends FetchGetBatched400_base {
-}
-declare const BatchedCancellationStatus_base: S.Literal<["CANCELLING", "CANCELLED"]>;
-export declare class BatchedCancellationStatus extends BatchedCancellationStatus_base {
-}
-declare const BatchedCancellation_base: S.Class<BatchedCancellation, {
-    id: typeof S.String;
-    status: typeof BatchedCancellationStatus;
-}, S.Struct.Encoded<{
-    id: typeof S.String;
-    status: typeof BatchedCancellationStatus;
-}>, never, {
-    readonly id: string;
-} & {
-    readonly status: "CANCELLED" | "CANCELLING";
-}, {}, {}>;
-export declare class BatchedCancellation extends BatchedCancellation_base {
-}
-declare const BatchedCancellationConflictStatus_base: S.Literal<["COMPLETED", "FAILED"]>;
-export declare class BatchedCancellationConflictStatus extends BatchedCancellationConflictStatus_base {
-}
-declare const BatchedCancellationConflictTag_base: S.Literal<["BatchedCancellationConflict"]>;
-export declare class BatchedCancellationConflictTag extends BatchedCancellationConflictTag_base {
-}
-declare const BatchedCancellationConflict_base: S.Class<BatchedCancellationConflict, {
-    id: typeof S.String;
-    status: typeof BatchedCancellationConflictStatus;
-    _tag: typeof BatchedCancellationConflictTag;
+declare const SnapshotNotFound_base: S.Class<SnapshotNotFound, {
+    snapshotId: typeof S.String;
+    _tag: typeof SnapshotNotFoundTag;
 }, S.Struct.Encoded<{
-    id: typeof S.String;
-    status: typeof BatchedCancellationConflictStatus;
-    _tag: typeof BatchedCancellationConflictTag;
+    snapshotId: typeof S.String;
+    _tag: typeof SnapshotNotFoundTag;
 }>, never, {
-    readonly _tag: "BatchedCancellationConflict";
-} & {
-    readonly id: string;
+    readonly _tag: "SnapshotNotFound";
 } & {
-    readonly status: "COMPLETED" | "FAILED";
+    readonly snapshotId: string;
 }, {}, {}>;
-export declare class BatchedCancellationConflict extends BatchedCancellationConflict_base {
+export declare class SnapshotNotFound extends SnapshotNotFound_base {
 }
 export declare const make: (httpClient: HttpClient.HttpClient, options?: {
     readonly transformClient?: ((client: HttpClient.HttpClient) => Effect.Effect<HttpClient.HttpClient>) | undefined;
@@ -1939,18 +2695,19 @@ export interface Client {
     readonly fetchFetch: (options: {
         readonly params: typeof FetchFetchParams.Encoded;
         readonly payload: typeof FetchFetchRequest.Encoded;
-    }) => Effect.Effect<void, HttpClientError.HttpClientError | ParseError | typeof FetchFetch400.Type | typeof AuthFailed.Type | typeof FetchFetch403.Type | typeof FetchFetch413.Type | typeof TooManyRequests.Type | typeof InternalError.Type | typeof FetchNavigationFailed.Type | typeof ServiceUnavailable.Type | typeof FetchCaptureTimeout.Type | typeof FetchCapacityTimeout.Type>;
+    }) => Effect.Effect<void, HttpClientError.HttpClientError | ParseError | typeof FetchFetch400.Type | typeof AuthFailed.Type | typeof FetchFetch403.Type | typeof FetchOriginNotFound.Type | typeof FetchOriginGone.Type | typeof FetchFetch413.Type | typeof FetchUnsupportedContentType.Type | typeof FetchVideoUnavailable.Type | typeof FetchFetch429.Type | typeof InternalError.Type | typeof FetchFetch502.Type | typeof FetchFetch503.Type | typeof FetchCaptureTimeout.Type | typeof FetchCapacityTimeout.Type>;
     readonly fetchFetchJson: (options: {
         readonly params: typeof FetchFetchJsonParams.Encoded;
         readonly payload: typeof FetchFetchJsonRequest.Encoded;
-    }) => Effect.Effect<typeof FetchObjectModeResult.Type, HttpClientError.HttpClientError | ParseError | typeof FetchFetchJson400.Type | typeof AuthFailed.Type | typeof FetchFetchJson403.Type | typeof FetchFetchJson413.Type | typeof TooManyRequests.Type | typeof InternalError.Type | typeof FetchNavigationFailed.Type | typeof ServiceUnavailable.Type | typeof FetchCaptureTimeout.Type | typeof FetchCapacityTimeout.Type>;
-    readonly fetchFetchSearch: (options: typeof FetchFetchSearchRequest.Encoded) => Effect.Effect<typeof FetchSnapshotSearchResult.Type, HttpClientError.HttpClientError | ParseError | typeof FetchFetchSearch400.Type | typeof AuthFailed.Type | typeof FetchFetchSearch403.Type | typeof FetchSnapshotSearchNotFound.Type | typeof PayloadTooLarge.Type | typeof TooManyRequests.Type | typeof InternalError.Type | typeof ServiceUnavailable.Type>;
+    }) => Effect.Effect<typeof FetchFetchJson200.Type, HttpClientError.HttpClientError | ParseError | typeof FetchFetchJson400.Type | typeof AuthFailed.Type | typeof FetchFetchJson403.Type | typeof FetchOriginNotFound.Type | typeof FetchOriginGone.Type | typeof FetchFetchJson413.Type | typeof FetchUnsupportedContentType.Type | typeof FetchVideoUnavailable.Type | typeof FetchFetchJson429.Type | typeof InternalError.Type | typeof FetchFetchJson502.Type | typeof FetchFetchJson503.Type | typeof FetchCaptureTimeout.Type | typeof FetchCapacityTimeout.Type>;
     readonly fetchBatched: (options: {
         readonly params: typeof FetchBatchedParams.Encoded;
         readonly payload: typeof FetchBatchedRequest.Encoded;
     }) => Effect.Effect<typeof BatchedRun.Type, HttpClientError.HttpClientError | ParseError | typeof FetchBatched400.Type | typeof AuthFailed.Type | typeof FetchBatched403.Type | typeof BatchedIdempotencyConflict.Type | typeof PayloadTooLarge.Type | typeof TooManyRequests.Type | typeof InternalError.Type | typeof ServiceUnavailable.Type>;
     readonly fetchGetBatched: (id: string, options: typeof FetchGetBatchedParams.Encoded) => Effect.Effect<typeof BatchedStatus.Type, HttpClientError.HttpClientError | ParseError | typeof FetchGetBatched400.Type | typeof AuthFailed.Type | typeof PayloadTooLarge.Type | typeof TooManyRequests.Type | typeof InternalError.Type | typeof ServiceUnavailable.Type>;
     readonly fetchCancelBatched: (id: string) => Effect.Effect<typeof BatchedCancellation.Type, HttpClientError.HttpClientError | ParseError | typeof HttpApiDecodeError.Type | typeof AuthFailed.Type | typeof BatchedCancellationConflict.Type | typeof PayloadTooLarge.Type | typeof TooManyRequests.Type | typeof InternalError.Type | typeof ServiceUnavailable.Type>;
+    readonly snapshotsHighlights: (snapshotId: string, options: typeof SnapshotHighlightsInput.Encoded) => Effect.Effect<typeof FetchSnapshotHighlightsResult.Type, HttpClientError.HttpClientError | ParseError | typeof SnapshotsHighlights400.Type | typeof AuthFailed.Type | typeof SnapshotsHighlights403.Type | typeof FetchSnapshotHighlightsNotFound.Type | typeof PayloadTooLarge.Type | typeof SnapshotsHighlights429.Type | typeof InternalError.Type | typeof ServiceUnavailable.Type>;
+    readonly publicSnapshotsGetCatalog: (snapshotId: string, options: typeof PublicSnapshotsGetCatalogParams.Encoded) => Effect.Effect<typeof SnapshotCatalog.Type, HttpClientError.HttpClientError | ParseError | typeof HttpApiDecodeError.Type | typeof SnapshotNotFound.Type | typeof PayloadTooLarge.Type | typeof TooManyRequests.Type | typeof InternalError.Type | typeof ServiceUnavailable.Type>;
 }
 export {};
 //# sourceMappingURL=Generated.d.ts.map