@expandai/sdk 0.19.0 → 0.20.0

package/src/Generated.ts

@@ -8,10 +8,17 @@ import * as Effect from 'effect/Effect'
 import type { ParseError } from 'effect/ParseResult'
 import * as S from 'effect/Schema'
 
+export class FetchFetchParamsAppendixMarkers extends S.Literal('off', 'compact', 'detailed') {}
+
 export class FetchFetchParams extends S.Struct({
 	include: S.optionalWith(S.String, { nullable: true }),
+	appendixMarkers: S.optionalWith(FetchFetchParamsAppendixMarkers, { nullable: true }),
 }) {}
 
+export class FetchFetchRequestIncludeAppendixMarkers extends S.Literal('off', 'compact', 'detailed') {}
+
+export class FetchFetchRequestDocumentConfigOcr extends S.Literal('auto', 'never', 'always') {}
+
 export class FetchFetchRequest extends S.Class<FetchFetchRequest>('FetchFetchRequest')({
 	url: S.String,
 	include: S.optionalWith(
@@ -47,10 +54,14 @@ export class FetchFetchRequest extends S.Class<FetchFetchRequest>('FetchFetchReq
 			),
 			json: S.optionalWith(S.Boolean, { nullable: true, default: () => false as const }),
 			appendix: S.optionalWith(S.Boolean, { nullable: true }),
+			appendixMarkers: S.optionalWith(FetchFetchRequestIncludeAppendixMarkers, {
+				nullable: true,
+				default: () => 'compact' as const,
+			}),
 		}),
 		{ nullable: true },
 	),
-	search: S.optionalWith(
+	highlights: S.optionalWith(
 		S.Struct({
 			query: S.String,
 			maxResults: S.optionalWith(S.Int.pipe(S.greaterThanOrEqualTo(1), S.lessThanOrEqualTo(50)), {
@@ -70,6 +81,17 @@ export class FetchFetchRequest extends S.Class<FetchFetchRequest>('FetchFetchReq
 		}),
 		{ nullable: true },
 	),
+	documentConfig: S.optionalWith(
+		S.Struct({
+			maxPages: S.optionalWith(S.Int.pipe(S.greaterThanOrEqualTo(1)), { nullable: true }),
+			maxAudioSeconds: S.optionalWith(S.Int.pipe(S.greaterThanOrEqualTo(1), S.lessThanOrEqualTo(14400)), {
+				nullable: true,
+				default: () => 3600 as const,
+			}),
+			ocr: S.optionalWith(FetchFetchRequestDocumentConfigOcr, { nullable: true, default: () => 'auto' as const }),
+		}),
+		{ nullable: true },
+	),
 }) {}
 
 export class IssueTag extends S.Literal(
@@ -154,13 +176,42 @@ export class FetchFetch403 extends S.Union(
 	FetchBlocked,
 ) {}
 
+export class FetchOriginNotFoundTag extends S.Literal('FetchOriginHttpError') {}
+
+export class FetchOriginNotFoundStatusCode extends S.Literal(404) {}
+
+export class FetchOriginNotFound extends S.Class<FetchOriginNotFound>('FetchOriginNotFound')({
+	_tag: FetchOriginNotFoundTag,
+	url: S.String,
+	statusCode: FetchOriginNotFoundStatusCode,
+	contentType: S.optionalWith(S.String, { nullable: true }),
+}) {}
+
+export class FetchOriginGoneTag extends S.Literal('FetchOriginHttpError') {}
+
+export class FetchOriginGoneStatusCode extends S.Literal(410) {}
+
+export class FetchOriginGone extends S.Class<FetchOriginGone>('FetchOriginGone')({
+	_tag: FetchOriginGoneTag,
+	url: S.String,
+	statusCode: FetchOriginGoneStatusCode,
+	contentType: S.optionalWith(S.String, { nullable: true }),
+}) {}
+
 export class PayloadTooLargeTag extends S.Literal('PayloadTooLarge') {}
 
 export class PayloadTooLarge extends S.Struct({
 	_tag: PayloadTooLargeTag,
 }) {}
 
-export class FetchPageTooLargeLimitKind extends S.Literal('transfer_bytes', 'domsnapshot_bytes', 'ast_bytes') {}
+export class FetchPageTooLargeLimitKind extends S.Literal(
+	'transfer_bytes',
+	'domsnapshot_bytes',
+	'ast_bytes',
+	'document_frame_bytes',
+	'document_pages',
+	'audio_seconds',
+) {}
 
 export class FetchPageTooLargeTag extends S.Literal('FetchPageTooLarge') {}
 
@@ -169,61 +220,176 @@ export class FetchPageTooLarge extends S.Struct({
 	limitKind: S.optionalWith(FetchPageTooLargeLimitKind, { nullable: true }),
 	limitBytes: S.optionalWith(S.Number, { nullable: true }),
 	measuredBytes: S.optionalWith(S.Number, { nullable: true }),
+	limit: S.optionalWith(S.Number, { nullable: true }),
+	measured: S.optionalWith(S.Number, { nullable: true }),
 	_tag: FetchPageTooLargeTag,
 }) {}
 
 export class FetchFetch413 extends S.Union(PayloadTooLarge, FetchPageTooLarge) {}
 
+export class FetchUnsupportedContentTypeTag extends S.Literal('FetchUnsupportedContentType') {}
+
+export class FetchUnsupportedContentType extends S.Class<FetchUnsupportedContentType>('FetchUnsupportedContentType')({
+	url: S.String,
+	contentType: S.optionalWith(S.String, { nullable: true }),
+	_tag: FetchUnsupportedContentTypeTag,
+}) {}
+
+export class FetchVideoUnavailableAvailability extends S.Literal(
+	'private',
+	'removed',
+	'geoRestricted',
+	'ageRestricted',
+	'membersOnly',
+	'live',
+	'upcoming',
+	'unknown',
+) {}
+
+export class FetchVideoUnavailableTag extends S.Literal('FetchVideoUnavailable') {}
+
+export class FetchVideoUnavailable extends S.Class<FetchVideoUnavailable>('FetchVideoUnavailable')({
+	url: S.String,
+	availability: FetchVideoUnavailableAvailability,
+	message: S.optionalWith(S.String, { nullable: true }),
+	_tag: FetchVideoUnavailableTag,
+}) {}
+
+export class TooManyRequestsRetryable extends S.Literal(true) {}
+
 export class TooManyRequestsTag extends S.Literal('TooManyRequests') {}
 
-export class TooManyRequests extends S.Class<TooManyRequests>('TooManyRequests')({
+export class TooManyRequests extends S.Struct({
+	retryable: S.optionalWith(TooManyRequestsRetryable, { default: () => true }),
+	retryAfterSeconds: S.optionalWith(S.Number, { nullable: true }),
 	_tag: TooManyRequestsTag,
 }) {}
 
+export class FetchConcurrencyLimitExceededRetryable extends S.Literal(true) {}
+
+export class FetchConcurrencyLimitExceededTag extends S.Literal('FetchConcurrencyLimitExceeded') {}
+
+export class FetchConcurrencyLimitExceeded extends S.Struct({
+	retryable: S.optionalWith(FetchConcurrencyLimitExceededRetryable, { default: () => true }),
+	retryAfterSeconds: S.Number,
+	maxConcurrency: S.Number,
+	message: S.optionalWith(S.String, { nullable: true }),
+	requestId: S.optionalWith(S.String, { nullable: true }),
+	_tag: FetchConcurrencyLimitExceededTag,
+}) {}
+
+export class FetchFetch429 extends S.Union(TooManyRequests, FetchConcurrencyLimitExceeded) {}
+
+export class InternalErrorRetryable extends S.Literal(true) {}
+
 export class InternalErrorTag extends S.Literal('InternalError') {}
 
 export class InternalError extends S.Class<InternalError>('InternalError')({
+	retryable: S.optionalWith(InternalErrorRetryable, { default: () => true }),
 	_tag: InternalErrorTag,
 }) {}
 
+export class FetchCaptureFailedFailureType extends S.Literal('pageNeverSettled', 'capabilityFailed') {}
+
+export class FetchCaptureFailedRetryable extends S.Literal(false) {}
+
+export class FetchCaptureFailedTag extends S.Literal('FetchCaptureFailed') {}
+
+export class FetchCaptureFailed extends S.Struct({
+	url: S.String,
+	failureType: FetchCaptureFailedFailureType,
+	retryable: S.optionalWith(FetchCaptureFailedRetryable, { default: () => false }),
+	_tag: FetchCaptureFailedTag,
+}) {}
+
 export class FetchNavigationFailedFailureType extends S.Literal('browserInternalDocument') {}
 
+export class FetchNavigationFailedRetryable extends S.Literal(false) {}
+
 export class FetchNavigationFailedTag extends S.Literal('FetchNavigationFailed') {}
 
-export class FetchNavigationFailed extends S.Class<FetchNavigationFailed>('FetchNavigationFailed')({
+export class FetchNavigationFailed extends S.Struct({
 	url: S.String,
 	failureType: FetchNavigationFailedFailureType,
+	retryable: S.optionalWith(FetchNavigationFailedRetryable, { default: () => false }),
 	_tag: FetchNavigationFailedTag,
 }) {}
 
+export class FetchOriginHttpErrorTag extends S.Literal('FetchOriginHttpError') {}
+
+export class FetchOriginHttpError extends S.Struct({
+	url: S.String,
+	statusCode: S.Number,
+	contentType: S.optionalWith(S.String, { nullable: true }),
+	_tag: FetchOriginHttpErrorTag,
+}) {}
+
+export class FetchFetch502 extends S.Union(FetchCaptureFailed, FetchNavigationFailed, FetchOriginHttpError) {}
+
+export class ServiceUnavailableDispatchOutcome extends S.Literal(
+	'cancelled_before_start',
+	'cancelled_after_start',
+	'unknown',
+) {}
+
+export class ServiceUnavailableRetryable extends S.Literal(true) {}
+
 export class ServiceUnavailableTag extends S.Literal('ServiceUnavailable') {}
 
-export class ServiceUnavailable extends S.Class<ServiceUnavailable>('ServiceUnavailable')({
+export class ServiceUnavailable extends S.Struct({
 	message: S.optionalWith(S.String, { nullable: true }),
 	requestId: S.optionalWith(S.String, { nullable: true }),
+	dispatchOutcome: S.optionalWith(ServiceUnavailableDispatchOutcome, { nullable: true }),
+	retryable: S.optionalWith(ServiceUnavailableRetryable, { default: () => true }),
 	_tag: ServiceUnavailableTag,
 }) {}
 
+export class FetchDocumentProcessingUnavailableOperation extends S.Literal('ocr', 'transcription', 'video') {}
+
+export class FetchDocumentProcessingUnavailableTag extends S.Literal('FetchDocumentProcessingUnavailable') {}
+
+export class FetchDocumentProcessingUnavailable extends S.Struct({
+	url: S.String,
+	operation: FetchDocumentProcessingUnavailableOperation,
+	message: S.String,
+	_tag: FetchDocumentProcessingUnavailableTag,
+}) {}
+
+export class FetchFetch503 extends S.Union(ServiceUnavailable, FetchDocumentProcessingUnavailable) {}
+
+export class FetchCaptureTimeoutRetryable extends S.Literal(false) {}
+
 export class FetchCaptureTimeoutTag extends S.Literal('FetchCaptureTimeout') {}
 
 export class FetchCaptureTimeout extends S.Class<FetchCaptureTimeout>('FetchCaptureTimeout')({
 	url: S.String,
 	timeoutMs: S.optionalWith(S.Number, { nullable: true }),
+	retryable: S.optionalWith(FetchCaptureTimeoutRetryable, { default: () => false }),
 	_tag: FetchCaptureTimeoutTag,
 }) {}
 
+export class FetchCapacityTimeoutRetryable extends S.Literal(true) {}
+
 export class FetchCapacityTimeoutTag extends S.Literal('FetchCapacityTimeout') {}
 
 export class FetchCapacityTimeout extends S.Class<FetchCapacityTimeout>('FetchCapacityTimeout')({
 	url: S.String,
 	timeoutMs: S.optionalWith(S.Number, { nullable: true }),
+	retryable: S.optionalWith(FetchCapacityTimeoutRetryable, { default: () => true }),
 	_tag: FetchCapacityTimeoutTag,
 }) {}
 
+export class FetchFetchJsonParamsAppendixMarkers extends S.Literal('off', 'compact', 'detailed') {}
+
 export class FetchFetchJsonParams extends S.Struct({
 	include: S.optionalWith(S.String, { nullable: true }),
+	appendixMarkers: S.optionalWith(FetchFetchJsonParamsAppendixMarkers, { nullable: true }),
 }) {}
 
+export class FetchFetchJsonRequestIncludeAppendixMarkers extends S.Literal('off', 'compact', 'detailed') {}
+
+export class FetchFetchJsonRequestDocumentConfigOcr extends S.Literal('auto', 'never', 'always') {}
+
 export class FetchFetchJsonRequest extends S.Class<FetchFetchJsonRequest>('FetchFetchJsonRequest')({
 	url: S.String,
 	include: S.optionalWith(
@@ -259,10 +425,14 @@ export class FetchFetchJsonRequest extends S.Class<FetchFetchJsonRequest>('Fetch
 			),
 			json: S.optionalWith(S.Boolean, { nullable: true, default: () => false as const }),
 			appendix: S.optionalWith(S.Boolean, { nullable: true }),
+			appendixMarkers: S.optionalWith(FetchFetchJsonRequestIncludeAppendixMarkers, {
+				nullable: true,
+				default: () => 'compact' as const,
+			}),
 		}),
 		{ nullable: true },
 	),
-	search: S.optionalWith(
+	highlights: S.optionalWith(
 		S.Struct({
 			query: S.String,
 			maxResults: S.optionalWith(S.Int.pipe(S.greaterThanOrEqualTo(1), S.lessThanOrEqualTo(50)), {
@@ -282,18 +452,47 @@ export class FetchFetchJsonRequest extends S.Class<FetchFetchJsonRequest>('Fetch
 		}),
 		{ nullable: true },
 	),
+	documentConfig: S.optionalWith(
+		S.Struct({
+			maxPages: S.optionalWith(S.Int.pipe(S.greaterThanOrEqualTo(1)), { nullable: true }),
+			maxAudioSeconds: S.optionalWith(S.Int.pipe(S.greaterThanOrEqualTo(1), S.lessThanOrEqualTo(14400)), {
+				nullable: true,
+				default: () => 3600 as const,
+			}),
+			ocr: S.optionalWith(FetchFetchJsonRequestDocumentConfigOcr, { nullable: true, default: () => 'auto' as const }),
+		}),
+		{ nullable: true },
+	),
 }) {}
 
 export class FetchObjectModeMetaVersion extends S.Literal(1) {}
 
+export class Int extends S.Int {}
+
 export class FetchObjectModeAppendixLinks extends S.Struct({
 	sameDomain: S.Number,
 	external: S.Number,
 }) {}
 
+export class FetchObjectModeAppendixOmitted extends S.Struct({
+	blocks: S.Number,
+	approxTokens: S.Number,
+}) {}
+
+export class FetchObjectModeAppendixMarker extends S.Struct({
+	evidenceId: S.optionalWith(S.Number, { nullable: true }),
+	links: S.Number,
+	approxTokens: S.Number,
+	label: S.optionalWith(S.String, { nullable: true }),
+	preview: S.optionalWith(S.String, { nullable: true }),
+	moreBlocks: S.optionalWith(S.Number, { nullable: true }),
+}) {}
+
 export class FetchObjectModeAppendixHint extends S.Struct({
 	url: S.String,
 	links: FetchObjectModeAppendixLinks,
+	omitted: S.optionalWith(FetchObjectModeAppendixOmitted, { nullable: true }),
+	markers: S.optionalWith(S.Array(FetchObjectModeAppendixMarker), { nullable: true }),
 }) {}
 
 export class FetchObjectModeStateJsonHint extends S.Struct({
@@ -305,6 +504,15 @@ export class FetchObjectModeMarkdownHint extends S.Struct({
 	moreTokens: S.optionalWith(S.Number, { nullable: true }),
 }) {}
 
+export class FetchObjectModeResourcesVersion extends S.Literal(1) {}
+
+export class FetchObjectModeResources extends S.Struct({
+	version: FetchObjectModeResourcesVersion,
+	snapshotId: S.String,
+	url: S.String,
+	markdownUrl: S.String,
+}) {}
+
 export class FetchObjectModeMeta extends S.Struct({
 	version: FetchObjectModeMetaVersion,
 	url: S.String,
@@ -313,8 +521,10 @@ export class FetchObjectModeMeta extends S.Struct({
 	lang: S.String,
 	pageType: S.String,
 	playground: S.String,
+	citationEvidenceIds: S.optionalWith(S.Array(Int).pipe(S.maxItems(3)), { nullable: true }),
 	title: S.optionalWith(S.String, { nullable: true }),
 	finalUrl: S.optionalWith(S.String, { nullable: true }),
+	contentType: S.optionalWith(S.String, { nullable: true }),
 	canonical: S.optionalWith(S.String, { nullable: true }),
 	description: S.optionalWith(S.String, { nullable: true }),
 	author: S.optionalWith(S.String, { nullable: true }),
@@ -325,6 +535,7 @@ export class FetchObjectModeMeta extends S.Struct({
 	appendix: S.optionalWith(FetchObjectModeAppendixHint, { nullable: true }),
 	stateJson: S.optionalWith(FetchObjectModeStateJsonHint, { nullable: true }),
 	markdown: S.optionalWith(FetchObjectModeMarkdownHint, { nullable: true }),
+	resources: S.optionalWith(FetchObjectModeResources, { nullable: true }),
 	blocked: S.optionalWith(S.String, { nullable: true }),
 	loadingStatus: S.optionalWith(S.String, { nullable: true }),
 }) {}
@@ -353,7 +564,7 @@ export class FetchObjectModeEvidence extends S.Struct({
 	id: S.Number,
 	kind: FetchObjectModeEvidenceKind,
 	role: FetchObjectModeEvidenceRole,
-	score: S.Number,
+	score: S.Number.pipe(S.greaterThanOrEqualTo(0)),
 	url: S.optionalWith(S.String, { nullable: true }),
 	method: S.optionalWith(S.String, { nullable: true }),
 	moreTokens: S.optionalWith(S.Number, { nullable: true }),
@@ -376,7 +587,12 @@ export class FetchAssetReference extends S.Struct({
 
 export class FetchDegradedInfoReason extends S.Literal('pageTooLarge', 'modelInputTooLarge') {}
 
-export class FetchDegradedInfoLimitKind extends S.Literal('domsnapshot_bytes', 'ast_bytes', 'hfc_tokens') {}
+export class FetchDegradedInfoLimitKind extends S.Literal(
+	'domsnapshot_bytes',
+	'ast_bytes',
+	'document_frame_bytes',
+	'hfc_tokens',
+) {}
 
 export class FetchDegradedInfo extends S.Struct({
 	reason: FetchDegradedInfoReason,
@@ -388,9 +604,7 @@ export class FetchDegradedInfo extends S.Struct({
 	thresholdTokens: S.optionalWith(S.Int.pipe(S.greaterThanOrEqualTo(0)), { nullable: true }),
 }) {}
 
-export class Int extends S.Int {}
-
-export class FetchSearchSnippetLocation extends S.Struct({
+export class FetchHighlightsSnippetLocation extends S.Struct({
 	evidenceId: S.optionalWith(Int, { nullable: true }),
 	markdownBlockId: S.optionalWith(S.String, { nullable: true }),
 	nodeIds: S.optionalWith(S.Array(S.Number), { nullable: true }),
@@ -398,28 +612,28 @@ export class FetchSearchSnippetLocation extends S.Struct({
 	jsonPath: S.optionalWith(S.String, { nullable: true }),
 }) {}
 
-export class FetchSearchSourceMetaSource extends S.Literal('markdown', 'appendix', 'statejson') {}
+export class FetchHighlightsSourceMetaSource extends S.Literal('markdown', 'appendix', 'statejson') {}
 
-export class FetchSearchSourceMetaRanker extends S.Literal('zeroentropy', 'mixedbread', 'local_lexical') {}
+export class FetchHighlightsSourceMetaRanker extends S.Literal('zeroentropy', 'mixedbread', 'local_lexical') {}
 
-export class FetchSearchSourceMetaFallbackReason extends S.Literal('timeout', 'error') {}
+export class FetchHighlightsSourceMetaFallbackReason extends S.Literal('timeout', 'error') {}
 
-export class FetchSearchSourceMeta extends S.Struct({
-	source: FetchSearchSourceMetaSource,
+export class FetchHighlightsSourceMeta extends S.Struct({
+	source: FetchHighlightsSourceMetaSource,
 	chunkCount: S.Int.pipe(S.greaterThanOrEqualTo(0)),
 	batchCount: S.Int.pipe(S.greaterThanOrEqualTo(0)),
-	ranker: FetchSearchSourceMetaRanker,
+	ranker: FetchHighlightsSourceMetaRanker,
 	fallback: S.Boolean,
-	fallbackReason: S.optionalWith(FetchSearchSourceMetaFallbackReason, { nullable: true }),
+	fallbackReason: S.optionalWith(FetchHighlightsSourceMetaFallbackReason, { nullable: true }),
 	durationMs: S.Number.pipe(S.greaterThanOrEqualTo(0)),
 }) {}
 
-export class FetchSearchMeta extends S.Struct({
+export class FetchHighlightsMeta extends S.Struct({
 	durationMs: S.Number.pipe(S.greaterThanOrEqualTo(0)),
-	sources: S.Array(FetchSearchSourceMeta),
+	sources: S.Array(FetchHighlightsSourceMeta),
 }) {}
 
-export class FetchSearchResult extends S.Struct({
+export class FetchHighlightsResult extends S.Struct({
 	query: S.String,
 	snippets: S.Array(
 		S.Struct({
@@ -427,13 +641,38 @@ export class FetchSearchResult extends S.Struct({
 			source: S.Literal('markdown', 'appendix', 'statejson'),
 			text: S.String,
 			score: S.Number.pipe(S.greaterThanOrEqualTo(0), S.lessThanOrEqualTo(1)),
-			location: S.optionalWith(FetchSearchSnippetLocation, { nullable: true }),
+			location: S.optionalWith(FetchHighlightsSnippetLocation, { nullable: true }),
 		}),
 	),
-	meta: S.optionalWith(FetchSearchMeta, { nullable: true }),
+	meta: S.optionalWith(FetchHighlightsMeta, { nullable: true }),
+}) {}
+
+export class FetchObjectModeResultDataVideoProvider extends S.Literal('youtube') {}
+
+export class FetchObjectModeResultDataVideoTranscriptSource extends S.Literal('captions', 'transcription') {}
+
+export class FetchObjectModeResultDataVideoTranscriptKind extends S.Literal('manual', 'auto') {}
+
+export class FetchHttpOriginErrorKind extends S.Literal('http') {}
+
+export class FetchHttpOriginErrorContentAvailable extends S.Literal(false) {}
+
+export class FetchHttpOriginErrorRedirectLimitReached extends S.Literal(true) {}
+
+export class FetchHttpOriginErrorTag extends S.Literal('FetchOriginError') {}
+
+export class FetchHttpOriginError extends S.Struct({
+	url: S.String,
+	kind: FetchHttpOriginErrorKind,
+	contentAvailable: S.optionalWith(FetchHttpOriginErrorContentAvailable, { nullable: true }),
+	finalUrl: S.optionalWith(S.String, { nullable: true }),
+	redirectLimitReached: S.optionalWith(FetchHttpOriginErrorRedirectLimitReached, { nullable: true }),
+	originStatusCode: S.Number,
+	retryable: S.Boolean,
+	_tag: FetchHttpOriginErrorTag,
 }) {}
 
-export class FetchObjectModeResult extends S.Class<FetchObjectModeResult>('FetchObjectModeResult')({
+export class FetchObjectModeResult extends S.Struct({
 	meta: FetchObjectModeMeta,
 	markdown: S.String,
 	json: S.Array(FetchObjectModeEvidence),
@@ -441,7 +680,7 @@ export class FetchObjectModeResult extends S.Class<FetchObjectModeResult>('Fetch
 		S.Struct({
 			assets: S.optionalWith(S.Array(FetchAssetReference), { nullable: true }),
 			degraded: S.optionalWith(FetchDegradedInfo, { nullable: true }),
-			search: S.optionalWith(FetchSearchResult, { nullable: true }),
+			highlights: S.optionalWith(FetchHighlightsResult, { nullable: true }),
 			screenshot: S.optionalWith(
 				S.Struct({
 					url: S.String,
@@ -449,116 +688,154 @@ export class FetchObjectModeResult extends S.Class<FetchObjectModeResult>('Fetch
 				}),
 				{ nullable: true },
 			),
-		}),
-		{ nullable: true },
-	),
-}) {}
-
-export class FetchFetchJson400 extends S.Union(HttpApiDecodeError, BadRequest) {}
-
-export class FetchFetchJson403 extends S.Union(
-	S.Struct({
-		organizationId: S.String.pipe(S.minLength(1)),
-		blockedUntil: S.optionalWith(S.Union(DateTimeUtc, S.Null), { nullable: true }),
-		_tag: S.Literal('AccessBlocked'),
-	}),
-	FetchBlocked,
-) {}
-
-export class FetchFetchJson413 extends S.Union(PayloadTooLarge, FetchPageTooLarge) {}
-
-export class FetchFetchSearchRequest extends S.Class<FetchFetchSearchRequest>('FetchFetchSearchRequest')({
-	snapshotId: S.String.pipe(S.minLength(1)),
-	search: S.Struct({
-		query: S.String,
-		maxResults: S.optionalWith(S.Int.pipe(S.greaterThanOrEqualTo(1), S.lessThanOrEqualTo(50)), {
-			nullable: true,
-			default: () => 5 as const,
-		}),
-		minScore: S.optionalWith(S.Number.pipe(S.greaterThanOrEqualTo(0), S.lessThanOrEqualTo(1)), {
-			nullable: true,
-			default: () => 0.6 as const,
-		}),
-	}),
-	include: S.optionalWith(
-		S.Struct({
-			html: S.optionalWith(S.Union(S.Boolean, S.Record({ key: S.String, value: S.Unknown })), { nullable: true }),
-			markdown: S.optionalWith(S.Union(S.Boolean, S.Record({ key: S.String, value: S.Unknown })), { nullable: true }),
-			screenshot: S.optionalWith(
-				S.Union(
-					S.Boolean,
-					S.Struct({
-						fullPage: S.optionalWith(S.Boolean, { nullable: true }),
-					}),
-				),
+			document: S.optionalWith(
+				S.Struct({
+					url: S.String,
+					contentType: S.String,
+					sizeBytes: S.Number,
+				}),
 				{ nullable: true },
 			),
-			links: S.optionalWith(
-				S.Union(
-					S.Boolean,
-					S.Struct({
-						sameDomainOnly: S.optionalWith(S.Boolean, { nullable: true, default: () => true as const }),
-						includePatterns: S.optionalWith(S.Array(S.String), { nullable: true }),
-						excludePatterns: S.optionalWith(S.Array(S.String), { nullable: true }),
-					}),
-				),
+			usage: S.optionalWith(
+				S.Struct({
+					documentPages: Int,
+					ocrPages: Int,
+					audioSeconds: S.Number.pipe(S.greaterThanOrEqualTo(0)),
+					videos: S.optionalWith(Int, { nullable: true }),
+				}),
 				{ nullable: true },
 			),
-			meta: S.optionalWith(S.Boolean, { nullable: true, default: () => true as const }),
-			response: S.optionalWith(
+			video: S.optionalWith(
 				S.Struct({
-					includeHeaders: S.optionalWith(S.Boolean, { nullable: true, default: () => false as const }),
+					provider: FetchObjectModeResultDataVideoProvider,
+					videoId: S.String,
+					title: S.String,
+					channel: S.optionalWith(S.String, { nullable: true }),
+					channelUrl: S.optionalWith(S.String, { nullable: true }),
+					durationSeconds: S.optionalWith(S.Number, { nullable: true }),
+					publishedAt: S.optionalWith(S.String, { nullable: true }),
+					viewCount: S.optionalWith(S.Number, { nullable: true }),
+					language: S.optionalWith(S.String, { nullable: true }),
+					transcript: S.Struct({
+						source: FetchObjectModeResultDataVideoTranscriptSource,
+						kind: S.optionalWith(FetchObjectModeResultDataVideoTranscriptKind, { nullable: true }),
+						language: S.optionalWith(S.String, { nullable: true }),
+					}),
+					segments: S.optionalWith(
+						S.Array(
+							S.Struct({
+								startSeconds: S.Number,
+								text: S.String,
+							}),
+						),
+						{ nullable: true },
+					),
+					chapters: S.optionalWith(
+						S.Array(
+							S.Struct({
+								title: S.String,
+								startSeconds: S.Number,
+							}),
+						),
+						{ nullable: true },
+					),
+					storyboard: S.optionalWith(
+						S.Struct({
+							frameWidth: S.Int,
+							frameHeight: S.Int,
+							rows: S.Int,
+							columns: S.Int,
+							sheets: S.Array(
+								S.Struct({
+									url: S.String,
+									durationSeconds: S.Number,
+								}),
+							),
+						}),
+						{ nullable: true },
+					),
 				}),
 				{ nullable: true },
 			),
-			json: S.optionalWith(S.Boolean, { nullable: true, default: () => false as const }),
-			appendix: S.optionalWith(S.Boolean, { nullable: true }),
 		}),
 		{ nullable: true },
 	),
+	originError: S.optionalWith(FetchHttpOriginError, { nullable: true }),
 }) {}
 
-export class URL extends S.String {}
+export class FetchNetworkOriginErrorKind extends S.Literal(
+	'dns',
+	'tls',
+	'connectionRefused',
+	'connectionReset',
+	'connectionClosed',
+	'addressUnreachable',
+	'emptyResponse',
+	'connectionTimeout',
+) {}
 
-export class ResponseInfo extends S.Struct({
+export class FetchNetworkOriginErrorTag extends S.Literal('FetchOriginError') {}
+
+export class FetchNetworkOriginError extends S.Struct({
 	url: S.String,
-	requestedUrl: S.optionalWith(URL, { nullable: true }),
-	originStatusCode: S.optionalWith(S.Number, { nullable: true }),
-	redirectStatusCode: S.optionalWith(S.Number, { nullable: true }),
-	headers: S.optionalWith(S.Struct({}), { nullable: true }),
+	kind: FetchNetworkOriginErrorKind,
+	upstreamError: S.optionalWith(S.String, { nullable: true }),
+	retryable: S.Boolean,
+	_tag: FetchNetworkOriginErrorTag,
 }) {}
 
-export class FetchSnapshotSearchResult extends S.Class<FetchSnapshotSearchResult>('FetchSnapshotSearchResult')({
-	snapshotId: S.String.pipe(S.minLength(1)),
-	response: ResponseInfo,
-	search: FetchSearchResult,
-	durationMs: S.Number.pipe(S.greaterThanOrEqualTo(0)),
-	playground: S.String,
-}) {}
+export class FetchHttpOriginRefusalTag extends S.Literal('FetchOriginError') {}
 
-export class FetchFetchSearch400 extends S.Union(HttpApiDecodeError, BadRequest) {}
+export class FetchHttpOriginRefusalKind extends S.Literal('http') {}
 
-export class FetchFetchSearch403Tag extends S.Literal('AccessBlocked') {}
+export class FetchHttpOriginRefusalContentAvailable extends S.Literal(false) {}
 
-export class FetchFetchSearch403 extends S.Struct({
-	organizationId: S.String.pipe(S.minLength(1)),
-	blockedUntil: S.optionalWith(S.Union(DateTimeUtc, S.Null), { nullable: true }),
-	_tag: FetchFetchSearch403Tag,
+export class FetchHttpOriginRefusalRedirectLimitReached extends S.Literal(true) {}
+
+export class FetchHttpOriginRefusal extends S.Struct({
+	_tag: FetchHttpOriginRefusalTag,
+	url: S.String,
+	kind: FetchHttpOriginRefusalKind,
+	contentAvailable: FetchHttpOriginRefusalContentAvailable,
+	finalUrl: S.optionalWith(S.String, { nullable: true }),
+	redirectLimitReached: S.optionalWith(FetchHttpOriginRefusalRedirectLimitReached, { nullable: true }),
+	originStatusCode: S.Number,
+	retryable: S.Boolean,
 }) {}
 
-export class NonEmptyString extends S.String.pipe(S.minLength(1)) {}
+export class FetchFetchJson200 extends S.Union(
+	FetchObjectModeResult,
+	FetchNetworkOriginError,
+	FetchHttpOriginRefusal,
+) {}
 
-export class FetchSnapshotSearchNotFoundTag extends S.Literal('FetchSnapshotSearchNotFound') {}
+export class FetchFetchJson400 extends S.Union(HttpApiDecodeError, BadRequest) {}
 
-export class FetchSnapshotSearchNotFound extends S.Class<FetchSnapshotSearchNotFound>('FetchSnapshotSearchNotFound')({
-	snapshotId: NonEmptyString,
-	_tag: FetchSnapshotSearchNotFoundTag,
-}) {}
+export class FetchFetchJson403 extends S.Union(
+	S.Struct({
+		organizationId: S.String.pipe(S.minLength(1)),
+		blockedUntil: S.optionalWith(S.Union(DateTimeUtc, S.Null), { nullable: true }),
+		_tag: S.Literal('AccessBlocked'),
+	}),
+	FetchBlocked,
+) {}
+
+export class FetchFetchJson413 extends S.Union(PayloadTooLarge, FetchPageTooLarge) {}
+
+export class FetchFetchJson429 extends S.Union(TooManyRequests, FetchConcurrencyLimitExceeded) {}
+
+export class FetchFetchJson502 extends S.Union(FetchCaptureFailed, FetchNavigationFailed, FetchOriginHttpError) {}
+
+export class FetchFetchJson503 extends S.Union(ServiceUnavailable, FetchDocumentProcessingUnavailable) {}
 
 export class FetchBatchedParams extends S.Struct({
 	'x-idempotency-key': S.optionalWith(S.String.pipe(S.minLength(1), S.maxLength(255)), { nullable: true }),
 }) {}
 
+export class FetchBatchedRequestIncludeAppendixMarkers extends S.Literal('off', 'compact', 'detailed') {}
+
+export class FetchBatchedRequestDocumentConfigOcr extends S.Literal('auto', 'never', 'always') {}
+
 export class FetchBatchedRequest extends S.Class<FetchBatchedRequest>('FetchBatchedRequest')({
 	urls: S.NonEmptyArray(S.String),
 	include: S.optionalWith(
@@ -594,6 +871,10 @@ export class FetchBatchedRequest extends S.Class<FetchBatchedRequest>('FetchBatc
 			),
 			json: S.optionalWith(S.Boolean, { nullable: true, default: () => false as const }),
 			appendix: S.optionalWith(S.Boolean, { nullable: true }),
+			appendixMarkers: S.optionalWith(FetchBatchedRequestIncludeAppendixMarkers, {
+				nullable: true,
+				default: () => 'compact' as const,
+			}),
 		}),
 		{ nullable: true },
 	),
@@ -603,6 +884,17 @@ export class FetchBatchedRequest extends S.Class<FetchBatchedRequest>('FetchBatc
 		}),
 		{ nullable: true },
 	),
+	documentConfig: S.optionalWith(
+		S.Struct({
+			maxPages: S.optionalWith(S.Int.pipe(S.greaterThanOrEqualTo(1)), { nullable: true }),
+			maxAudioSeconds: S.optionalWith(S.Int.pipe(S.greaterThanOrEqualTo(1), S.lessThanOrEqualTo(14400)), {
+				nullable: true,
+				default: () => 3600 as const,
+			}),
+			ocr: S.optionalWith(FetchBatchedRequestDocumentConfigOcr, { nullable: true, default: () => 'auto' as const }),
+		}),
+		{ nullable: true },
+	),
 }) {}
 
 export class BatchedRun extends S.Class<BatchedRun>('BatchedRun')({
@@ -655,6 +947,17 @@ export class BatchedStatusBatchedStatus extends S.Literal(
 
 export class BatchedFetchItemStatus extends S.Literal('QUEUED', 'RUNNING', 'SUCCEEDED', 'FAILED', 'CANCELLED') {}
 
+export class URL extends S.String {}
+
+export class ResponseInfo extends S.Struct({
+	url: S.String,
+	requestedUrl: S.optionalWith(URL, { nullable: true }),
+	originStatusCode: S.optionalWith(S.Number, { nullable: true }),
+	redirectStatusCode: S.optionalWith(S.Number, { nullable: true }),
+	contentType: S.optionalWith(S.String, { nullable: true }),
+	headers: S.optionalWith(S.Struct({}), { nullable: true }),
+}) {}
+
 export class IconMeta extends S.Struct({
 	href: S.String.pipe(S.minLength(1)),
 	rel: S.String.pipe(S.minLength(1)),
@@ -700,6 +1003,14 @@ export class PageMeta extends S.Struct({
 	twitter: S.optionalWith(TwitterCardMeta, { nullable: true }),
 }) {}
 
+export class NonEmptyString extends S.String.pipe(S.minLength(1)) {}
+
+export class BatchedFetchItemDataVideoProvider extends S.Literal('youtube') {}
+
+export class BatchedFetchItemDataVideoTranscriptSource extends S.Literal('captions', 'transcription') {}
+
+export class BatchedFetchItemDataVideoTranscriptKind extends S.Literal('manual', 'auto') {}
+
 export class FetchLink extends S.Struct({
 	url: S.String,
 	text: S.optionalWith(S.String, { nullable: true }),
@@ -734,7 +1045,75 @@ export class BatchedFetchItem extends S.Struct({
 				}),
 				{ nullable: true },
 			),
-			search: S.optionalWith(FetchSearchResult, { nullable: true }),
+			document: S.optionalWith(
+				S.Struct({
+					url: S.String,
+					contentType: S.String,
+					sizeBytes: S.Number,
+				}),
+				{ nullable: true },
+			),
+			usage: S.optionalWith(
+				S.Struct({
+					documentPages: Int,
+					ocrPages: Int,
+					audioSeconds: S.Number.pipe(S.greaterThanOrEqualTo(0)),
+					videos: S.optionalWith(Int, { nullable: true }),
+				}),
+				{ nullable: true },
+			),
+			video: S.optionalWith(
+				S.Struct({
+					provider: BatchedFetchItemDataVideoProvider,
+					videoId: S.String,
+					title: S.String,
+					channel: S.optionalWith(S.String, { nullable: true }),
+					channelUrl: S.optionalWith(S.String, { nullable: true }),
+					durationSeconds: S.optionalWith(S.Number, { nullable: true }),
+					publishedAt: S.optionalWith(S.String, { nullable: true }),
+					viewCount: S.optionalWith(S.Number, { nullable: true }),
+					language: S.optionalWith(S.String, { nullable: true }),
+					transcript: S.Struct({
+						source: BatchedFetchItemDataVideoTranscriptSource,
+						kind: S.optionalWith(BatchedFetchItemDataVideoTranscriptKind, { nullable: true }),
+						language: S.optionalWith(S.String, { nullable: true }),
+					}),
+					segments: S.optionalWith(
+						S.Array(
+							S.Struct({
+								startSeconds: S.Number,
+								text: S.String,
+							}),
+						),
+						{ nullable: true },
+					),
+					chapters: S.optionalWith(
+						S.Array(
+							S.Struct({
+								title: S.String,
+								startSeconds: S.Number,
+							}),
+						),
+						{ nullable: true },
+					),
+					storyboard: S.optionalWith(
+						S.Struct({
+							frameWidth: S.Int,
+							frameHeight: S.Int,
+							rows: S.Int,
+							columns: S.Int,
+							sheets: S.Array(
+								S.Struct({
+									url: S.String,
+									durationSeconds: S.Number,
+								}),
+							),
+						}),
+						{ nullable: true },
+					),
+				}),
+				{ nullable: true },
+			),
 			links: S.optionalWith(S.Array(FetchLink), { nullable: true }),
 			appendix: S.optionalWith(S.String.pipe(S.minLength(1)), { nullable: true }),
 			renderEngines: S.optionalWith(RenderEnginesInfo, { nullable: true }),
@@ -744,9 +1123,22 @@ export class BatchedFetchItem extends S.Struct({
 		{ nullable: true },
 	),
 	error: S.optionalWith(
-		S.Union(FetchBlocked, FetchPageTooLarge, FetchNavigationFailed, FetchCaptureTimeout, FetchCapacityTimeout),
+		S.Union(
+			FetchBlocked,
+			FetchPageTooLarge,
+			FetchNavigationFailed,
+			FetchUnsupportedContentType,
+			FetchOriginHttpError,
+			S.Union(FetchNetworkOriginError, FetchHttpOriginRefusal),
+			FetchDocumentProcessingUnavailable,
+			FetchVideoUnavailable,
+			FetchCaptureFailed,
+			FetchCaptureTimeout,
+			FetchCapacityTimeout,
+		),
 		{ nullable: true },
 	),
+	originError: S.optionalWith(FetchHttpOriginError, { nullable: true }),
 }) {}
 
 export class PaginationMeta extends S.Struct({
@@ -791,6 +1183,131 @@ export class BatchedCancellationConflict extends S.Class<BatchedCancellationConf
 	_tag: BatchedCancellationConflictTag,
 }) {}
 
+export class SnapshotHighlightsInputIncludeAppendixMarkers extends S.Literal('off', 'compact', 'detailed') {}
+
+export class SnapshotHighlightsInput extends S.Class<SnapshotHighlightsInput>('SnapshotHighlightsInput')({
+	highlights: S.Struct({
+		query: S.String,
+		maxResults: S.optionalWith(S.Int.pipe(S.greaterThanOrEqualTo(1), S.lessThanOrEqualTo(50)), {
+			nullable: true,
+			default: () => 5 as const,
+		}),
+		minScore: S.optionalWith(S.Number.pipe(S.greaterThanOrEqualTo(0), S.lessThanOrEqualTo(1)), {
+			nullable: true,
+			default: () => 0.6 as const,
+		}),
+	}),
+	include: S.optionalWith(
+		S.Struct({
+			html: S.optionalWith(S.Union(S.Boolean, S.Record({ key: S.String, value: S.Unknown })), { nullable: true }),
+			markdown: S.optionalWith(S.Union(S.Boolean, S.Record({ key: S.String, value: S.Unknown })), { nullable: true }),
+			screenshot: S.optionalWith(
+				S.Union(
+					S.Boolean,
+					S.Struct({
+						fullPage: S.optionalWith(S.Boolean, { nullable: true }),
+					}),
+				),
+				{ nullable: true },
+			),
+			links: S.optionalWith(
+				S.Union(
+					S.Boolean,
+					S.Struct({
+						sameDomainOnly: S.optionalWith(S.Boolean, { nullable: true, default: () => true as const }),
+						includePatterns: S.optionalWith(S.Array(S.String), { nullable: true }),
+						excludePatterns: S.optionalWith(S.Array(S.String), { nullable: true }),
+					}),
+				),
+				{ nullable: true },
+			),
+			meta: S.optionalWith(S.Boolean, { nullable: true, default: () => true as const }),
+			response: S.optionalWith(
+				S.Struct({
+					includeHeaders: S.optionalWith(S.Boolean, { nullable: true, default: () => false as const }),
+				}),
+				{ nullable: true },
+			),
+			json: S.optionalWith(S.Boolean, { nullable: true, default: () => false as const }),
+			appendix: S.optionalWith(S.Boolean, { nullable: true }),
+			appendixMarkers: S.optionalWith(SnapshotHighlightsInputIncludeAppendixMarkers, {
+				nullable: true,
+				default: () => 'compact' as const,
+			}),
+		}),
+		{ nullable: true },
+	),
+}) {}
+
+export class FetchSnapshotHighlightsResult extends S.Class<FetchSnapshotHighlightsResult>(
+	'FetchSnapshotHighlightsResult',
+)({
+	snapshotId: S.String.pipe(S.minLength(1)),
+	response: ResponseInfo,
+	highlights: FetchHighlightsResult,
+	durationMs: S.Number.pipe(S.greaterThanOrEqualTo(0)),
+	playground: S.String,
+}) {}
+
+export class SnapshotsHighlights400 extends S.Union(HttpApiDecodeError, BadRequest) {}
+
+export class SnapshotsHighlights403Tag extends S.Literal('AccessBlocked') {}
+
+export class SnapshotsHighlights403 extends S.Struct({
+	organizationId: S.String.pipe(S.minLength(1)),
+	blockedUntil: S.optionalWith(S.Union(DateTimeUtc, S.Null), { nullable: true }),
+	_tag: SnapshotsHighlights403Tag,
+}) {}
+
+export class FetchSnapshotHighlightsNotFoundTag extends S.Literal('FetchSnapshotHighlightsNotFound') {}
+
+export class FetchSnapshotHighlightsNotFound extends S.Class<FetchSnapshotHighlightsNotFound>(
+	'FetchSnapshotHighlightsNotFound',
+)({
+	snapshotId: NonEmptyString,
+	_tag: FetchSnapshotHighlightsNotFoundTag,
+}) {}
+
+export class SnapshotsHighlights429 extends S.Union(TooManyRequests, FetchConcurrencyLimitExceeded) {}
+
+export class PublicSnapshotsGetCatalogParamsFormat extends S.Literal('json', 'markdown') {}
+
+export class PublicSnapshotsGetCatalogParams extends S.Struct({
+	format: S.optionalWith(PublicSnapshotsGetCatalogParamsFormat, { nullable: true }),
+}) {}
+
+export class SnapshotCatalogVersion extends S.Literal(1) {}
+
+export class SnapshotCatalog extends S.Class<SnapshotCatalog>('SnapshotCatalog')({
+	version: SnapshotCatalogVersion,
+	snapshotId: S.String,
+	collections: S.Struct({
+		evidence: S.String,
+		network: S.String,
+		assets: S.String,
+		artifacts: S.String,
+	}),
+	artifacts: S.Array(
+		S.Struct({
+			id: S.String,
+			kind: S.String,
+			url: S.String,
+			preview: S.optionalWith(S.String, { nullable: true }),
+		}),
+	),
+	links: S.Struct({
+		markdown: S.String,
+		json: S.String,
+	}),
+}) {}
+
+export class SnapshotNotFoundTag extends S.Literal('SnapshotNotFound') {}
+
+export class SnapshotNotFound extends S.Class<SnapshotNotFound>('SnapshotNotFound')({
+	snapshotId: S.String,
+	_tag: SnapshotNotFoundTag,
+}) {}
+
 export const make = (
 	httpClient: HttpClient.HttpClient,
 	options: {
@@ -820,7 +1337,10 @@ export const make = (
 	return {
 		fetchFetch: (options) =>
 			HttpClientRequest.make('POST')(`/v1/fetch`).pipe(
-				HttpClientRequest.setUrlParams({ include: options.params['include'] as UrlParams.Coercible }),
+				HttpClientRequest.setUrlParams({
+					include: options.params['include'] as UrlParams.Coercible,
+					appendixMarkers: options.params['appendixMarkers'] as UrlParams.Coercible,
+				}),
 				(req) => Effect.orDie(HttpClientRequest.bodyJson(req, options.payload)),
 				Effect.flatMap((request) =>
 					Effect.flatMap(applyClientTransform(httpClient), (httpClient) =>
@@ -830,11 +1350,15 @@ export const make = (
 								'400': (r) => decodeError(r, FetchFetch400),
 								'401': (r) => decodeError(r, AuthFailed),
 								'403': (r) => decodeError(r, FetchFetch403),
+								'404': (r) => decodeError(r, FetchOriginNotFound),
+								'410': (r) => decodeError(r, FetchOriginGone),
 								'413': (r) => decodeError(r, FetchFetch413),
-								'429': (r) => decodeError(r, TooManyRequests),
+								'415': (r) => decodeError(r, FetchUnsupportedContentType),
+								'422': (r) => decodeError(r, FetchVideoUnavailable),
+								'429': (r) => decodeError(r, FetchFetch429),
 								'500': (r) => decodeError(r, InternalError),
-								'502': (r) => decodeError(r, FetchNavigationFailed),
-								'503': (r) => decodeError(r, ServiceUnavailable),
+								'502': (r) => decodeError(r, FetchFetch502),
+								'503': (r) => decodeError(r, FetchFetch503),
 								'504': (r) => decodeError(r, FetchCaptureTimeout),
 								'529': (r) => decodeError(r, FetchCapacityTimeout),
 								orElse: (response) => unexpectedStatus(request, response),
@@ -845,22 +1369,29 @@ export const make = (
 			),
 		fetchFetchJson: (options) =>
 			HttpClientRequest.make('POST')(`/v1/fetch/json`).pipe(
-				HttpClientRequest.setUrlParams({ include: options.params['include'] as UrlParams.Coercible }),
+				HttpClientRequest.setUrlParams({
+					include: options.params['include'] as UrlParams.Coercible,
+					appendixMarkers: options.params['appendixMarkers'] as UrlParams.Coercible,
+				}),
 				(req) => Effect.orDie(HttpClientRequest.bodyJson(req, options.payload)),
 				Effect.flatMap((request) =>
 					Effect.flatMap(applyClientTransform(httpClient), (httpClient) =>
 						Effect.flatMap(
 							httpClient.execute(request),
 							HttpClientResponse.matchStatus({
-								'200': (r) => HttpClientResponse.schemaBodyJson(FetchObjectModeResult)(r),
+								'200': (r) => HttpClientResponse.schemaBodyJson(FetchFetchJson200)(r),
 								'400': (r) => decodeError(r, FetchFetchJson400),
 								'401': (r) => decodeError(r, AuthFailed),
 								'403': (r) => decodeError(r, FetchFetchJson403),
+								'404': (r) => decodeError(r, FetchOriginNotFound),
+								'410': (r) => decodeError(r, FetchOriginGone),
 								'413': (r) => decodeError(r, FetchFetchJson413),
-								'429': (r) => decodeError(r, TooManyRequests),
+								'415': (r) => decodeError(r, FetchUnsupportedContentType),
+								'422': (r) => decodeError(r, FetchVideoUnavailable),
+								'429': (r) => decodeError(r, FetchFetchJson429),
 								'500': (r) => decodeError(r, InternalError),
-								'502': (r) => decodeError(r, FetchNavigationFailed),
-								'503': (r) => decodeError(r, ServiceUnavailable),
+								'502': (r) => decodeError(r, FetchFetchJson502),
+								'503': (r) => decodeError(r, FetchFetchJson503),
 								'504': (r) => decodeError(r, FetchCaptureTimeout),
 								'529': (r) => decodeError(r, FetchCapacityTimeout),
 								orElse: (response) => unexpectedStatus(request, response),
@@ -869,29 +1400,6 @@ export const make = (
 					),
 				),
 			),
-		fetchFetchSearch: (options) =>
-			HttpClientRequest.make('POST')(`/v1/fetch/search`).pipe(
-				(req) => Effect.orDie(HttpClientRequest.bodyJson(req, options)),
-				Effect.flatMap((request) =>
-					Effect.flatMap(applyClientTransform(httpClient), (httpClient) =>
-						Effect.flatMap(
-							httpClient.execute(request),
-							HttpClientResponse.matchStatus({
-								'200': (r) => HttpClientResponse.schemaBodyJson(FetchSnapshotSearchResult)(r),
-								'400': (r) => decodeError(r, FetchFetchSearch400),
-								'401': (r) => decodeError(r, AuthFailed),
-								'403': (r) => decodeError(r, FetchFetchSearch403),
-								'404': (r) => decodeError(r, FetchSnapshotSearchNotFound),
-								'413': (r) => decodeError(r, PayloadTooLarge),
-								'429': (r) => decodeError(r, TooManyRequests),
-								'500': (r) => decodeError(r, InternalError),
-								'503': (r) => decodeError(r, ServiceUnavailable),
-								orElse: (response) => unexpectedStatus(request, response),
-							}),
-						),
-					),
-				),
-			),
 		fetchBatched: (options) =>
 			HttpClientRequest.make('POST')(`/v1/fetch/batched`).pipe(
 				HttpClientRequest.setHeaders({ 'x-idempotency-key': options.params['x-idempotency-key'] ?? undefined }),
@@ -964,6 +1472,51 @@ export const make = (
 					),
 				),
 			),
+		snapshotsHighlights: (snapshotId, options) =>
+			HttpClientRequest.make('POST')(`/v1/snapshots/${snapshotId}/highlights`).pipe(
+				(req) => Effect.orDie(HttpClientRequest.bodyJson(req, options)),
+				Effect.flatMap((request) =>
+					Effect.flatMap(applyClientTransform(httpClient), (httpClient) =>
+						Effect.flatMap(
+							httpClient.execute(request),
+							HttpClientResponse.matchStatus({
+								'200': (r) => HttpClientResponse.schemaBodyJson(FetchSnapshotHighlightsResult)(r),
+								'400': (r) => decodeError(r, SnapshotsHighlights400),
+								'401': (r) => decodeError(r, AuthFailed),
+								'403': (r) => decodeError(r, SnapshotsHighlights403),
+								'404': (r) => decodeError(r, FetchSnapshotHighlightsNotFound),
+								'413': (r) => decodeError(r, PayloadTooLarge),
+								'429': (r) => decodeError(r, SnapshotsHighlights429),
+								'500': (r) => decodeError(r, InternalError),
+								'503': (r) => decodeError(r, ServiceUnavailable),
+								orElse: (response) => unexpectedStatus(request, response),
+							}),
+						),
+					),
+				),
+			),
+		publicSnapshotsGetCatalog: (snapshotId, options) =>
+			HttpClientRequest.make('GET')(`/v1/public/snapshots/${snapshotId}`).pipe(
+				HttpClientRequest.setUrlParams({ format: options['format'] as UrlParams.Coercible }),
+				Effect.succeed,
+				Effect.flatMap((request) =>
+					Effect.flatMap(applyClientTransform(httpClient), (httpClient) =>
+						Effect.flatMap(
+							httpClient.execute(request),
+							HttpClientResponse.matchStatus({
+								'200': (r) => HttpClientResponse.schemaBodyJson(SnapshotCatalog)(r),
+								'400': (r) => decodeError(r, HttpApiDecodeError),
+								'404': (r) => decodeError(r, SnapshotNotFound),
+								'413': (r) => decodeError(r, PayloadTooLarge),
+								'429': (r) => decodeError(r, TooManyRequests),
+								'500': (r) => decodeError(r, InternalError),
+								'503': (r) => decodeError(r, ServiceUnavailable),
+								orElse: (response) => unexpectedStatus(request, response),
+							}),
+						),
+					),
+				),
+			),
 	}
 }
 
@@ -978,11 +1531,15 @@ export interface Client {
 		| typeof FetchFetch400.Type
 		| typeof AuthFailed.Type
 		| typeof FetchFetch403.Type
+		| typeof FetchOriginNotFound.Type
+		| typeof FetchOriginGone.Type
 		| typeof FetchFetch413.Type
-		| typeof TooManyRequests.Type
+		| typeof FetchUnsupportedContentType.Type
+		| typeof FetchVideoUnavailable.Type
+		| typeof FetchFetch429.Type
 		| typeof InternalError.Type
-		| typeof FetchNavigationFailed.Type
-		| typeof ServiceUnavailable.Type
+		| typeof FetchFetch502.Type
+		| typeof FetchFetch503.Type
 		| typeof FetchCaptureTimeout.Type
 		| typeof FetchCapacityTimeout.Type
 	>
@@ -990,35 +1547,24 @@ export interface Client {
 		readonly params: typeof FetchFetchJsonParams.Encoded
 		readonly payload: typeof FetchFetchJsonRequest.Encoded
 	}) => Effect.Effect<
-		typeof FetchObjectModeResult.Type,
+		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 TooManyRequests.Type
+		| typeof FetchUnsupportedContentType.Type
+		| typeof FetchVideoUnavailable.Type
+		| typeof FetchFetchJson429.Type
 		| typeof InternalError.Type
-		| typeof FetchNavigationFailed.Type
-		| typeof ServiceUnavailable.Type
+		| typeof FetchFetchJson502.Type
+		| typeof FetchFetchJson503.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
-	>
 	readonly fetchBatched: (options: {
 		readonly params: typeof FetchBatchedParams.Encoded
 		readonly payload: typeof FetchBatchedRequest.Encoded
@@ -1063,4 +1609,34 @@ export interface Client {
 		| 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
+	>
 }