@expandai/sdk 0.19.0 → 0.20.0

package/build/esm/Generated.js

@@ -3,10 +3,17 @@ import * as HttpClientRequest from '@effect/platform/HttpClientRequest';
 import * as HttpClientResponse from '@effect/platform/HttpClientResponse';
 import * as Effect from 'effect/Effect';
 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')({
     url: S.String,
     include: S.optionalWith(S.Struct({
@@ -26,8 +33,12 @@ export class FetchFetchRequest extends S.Class('FetchFetchRequest')({
         }), { nullable: true }),
         json: S.optionalWith(S.Boolean, { nullable: true, default: () => false }),
         appendix: S.optionalWith(S.Boolean, { nullable: true }),
+        appendixMarkers: S.optionalWith(FetchFetchRequestIncludeAppendixMarkers, {
+            nullable: true,
+            default: () => 'compact',
+        }),
     }), { nullable: true }),
-    search: S.optionalWith(S.Struct({
+    highlights: S.optionalWith(S.Struct({
         query: S.String,
         maxResults: S.optionalWith(S.Int.pipe(S.greaterThanOrEqualTo(1), S.lessThanOrEqualTo(50)), {
             nullable: true,
@@ -41,6 +52,14 @@ export class FetchFetchRequest extends S.Class('FetchFetchRequest')({
     browserConfig: S.optionalWith(S.Struct({
         scrollFullPage: S.optionalWith(S.Boolean, { nullable: true, default: () => false }),
     }), { 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,
+        }),
+        ocr: S.optionalWith(FetchFetchRequestDocumentConfigOcr, { nullable: true, default: () => 'auto' }),
+    }), { nullable: true }),
 }) {
 }
 export class IssueTag extends S.Literal('Pointer', 'Unexpected', 'Missing', 'Composite', 'Refinement', 'Transformation', 'Type', 'Forbidden') {
@@ -103,13 +122,35 @@ export class FetchFetch403 extends S.Union(S.Struct({
     _tag: S.Literal('AccessBlocked'),
 }), FetchBlocked) {
 }
+export class FetchOriginNotFoundTag extends S.Literal('FetchOriginHttpError') {
+}
+export class FetchOriginNotFoundStatusCode extends S.Literal(404) {
+}
+export class FetchOriginNotFound extends S.Class('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')({
+    _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') {
 }
@@ -118,61 +159,163 @@ 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')({
+    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')({
+    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')({
+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')({
+    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')({
+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')({
+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')({
     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')({
     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')({
     url: S.String,
     include: S.optionalWith(S.Struct({
@@ -192,8 +335,12 @@ export class FetchFetchJsonRequest extends S.Class('FetchFetchJsonRequest')({
         }), { nullable: true }),
         json: S.optionalWith(S.Boolean, { nullable: true, default: () => false }),
         appendix: S.optionalWith(S.Boolean, { nullable: true }),
+        appendixMarkers: S.optionalWith(FetchFetchJsonRequestIncludeAppendixMarkers, {
+            nullable: true,
+            default: () => 'compact',
+        }),
     }), { nullable: true }),
-    search: S.optionalWith(S.Struct({
+    highlights: S.optionalWith(S.Struct({
         query: S.String,
         maxResults: S.optionalWith(S.Int.pipe(S.greaterThanOrEqualTo(1), S.lessThanOrEqualTo(50)), {
             nullable: true,
@@ -207,18 +354,44 @@ export class FetchFetchJsonRequest extends S.Class('FetchFetchJsonRequest')({
     browserConfig: S.optionalWith(S.Struct({
         scrollFullPage: S.optionalWith(S.Boolean, { nullable: true, default: () => false }),
     }), { 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,
+        }),
+        ocr: S.optionalWith(FetchFetchJsonRequestDocumentConfigOcr, { nullable: true, default: () => 'auto' }),
+    }), { 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({
@@ -230,6 +403,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,
@@ -238,8 +420,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 }),
@@ -250,6 +434,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 }),
 }) {
@@ -266,7 +451,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 }),
@@ -289,7 +474,7 @@ 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,
@@ -301,9 +486,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 }),
@@ -311,138 +494,182 @@ 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({
         type: S.optionalWith(S.Literal('text'), { nullable: true, default: () => 'text' }),
         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')({
+export class FetchObjectModeResult extends S.Struct({
     meta: FetchObjectModeMeta,
     markdown: S.String,
     json: S.Array(FetchObjectModeEvidence),
     data: S.optionalWith(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,
             fullPage: S.Boolean,
         }), { 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: 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 }),
     }), { nullable: true }),
+    originError: S.optionalWith(FetchHttpOriginError, { 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 FetchNetworkOriginErrorKind extends S.Literal('dns', 'tls', 'connectionRefused', 'connectionReset', 'connectionClosed', 'addressUnreachable', 'emptyResponse', 'connectionTimeout') {
 }
-export class FetchFetchJson413 extends S.Union(PayloadTooLarge, FetchPageTooLarge) {
+export class FetchNetworkOriginErrorTag extends S.Literal('FetchOriginError') {
 }
-export class FetchFetchSearchRequest extends S.Class('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,
-        }),
-        minScore: S.optionalWith(S.Number.pipe(S.greaterThanOrEqualTo(0), S.lessThanOrEqualTo(1)), {
-            nullable: true,
-            default: () => 0.6,
-        }),
-    }),
-    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 }),
-            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 }),
-        response: S.optionalWith(S.Struct({
-            includeHeaders: S.optionalWith(S.Boolean, { nullable: true, default: () => false }),
-        }), { nullable: true }),
-        json: S.optionalWith(S.Boolean, { nullable: true, default: () => false }),
-        appendix: S.optionalWith(S.Boolean, { nullable: true }),
-    }), { nullable: true }),
+export class FetchNetworkOriginError extends S.Struct({
+    url: S.String,
+    kind: FetchNetworkOriginErrorKind,
+    upstreamError: S.optionalWith(S.String, { nullable: true }),
+    retryable: S.Boolean,
+    _tag: FetchNetworkOriginErrorTag,
 }) {
 }
-export class URL extends S.String {
+export class FetchHttpOriginRefusalTag extends S.Literal('FetchOriginError') {
 }
-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 }),
-    headers: S.optionalWith(S.Struct({}), { nullable: true }),
-}) {
+export class FetchHttpOriginRefusalKind extends S.Literal('http') {
 }
-export class FetchSnapshotSearchResult extends S.Class('FetchSnapshotSearchResult')({
-    snapshotId: S.String.pipe(S.minLength(1)),
-    response: ResponseInfo,
-    search: FetchSearchResult,
-    durationMs: S.Number.pipe(S.greaterThanOrEqualTo(0)),
-    playground: S.String,
+export class FetchHttpOriginRefusalContentAvailable extends S.Literal(false) {
+}
+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 FetchFetchSearch400 extends S.Union(HttpApiDecodeError, BadRequest) {
+export class FetchFetchJson200 extends S.Union(FetchObjectModeResult, FetchNetworkOriginError, FetchHttpOriginRefusal) {
 }
-export class FetchFetchSearch403Tag extends S.Literal('AccessBlocked') {
+export class FetchFetchJson400 extends S.Union(HttpApiDecodeError, BadRequest) {
 }
-export class FetchFetchSearch403 extends S.Struct({
+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: FetchFetchSearch403Tag,
-}) {
+    _tag: S.Literal('AccessBlocked'),
+}), FetchBlocked) {
 }
-export class NonEmptyString extends S.String.pipe(S.minLength(1)) {
+export class FetchFetchJson413 extends S.Union(PayloadTooLarge, FetchPageTooLarge) {
 }
-export class FetchSnapshotSearchNotFoundTag extends S.Literal('FetchSnapshotSearchNotFound') {
+export class FetchFetchJson429 extends S.Union(TooManyRequests, FetchConcurrencyLimitExceeded) {
 }
-export class FetchSnapshotSearchNotFound extends S.Class('FetchSnapshotSearchNotFound')({
-    snapshotId: NonEmptyString,
-    _tag: FetchSnapshotSearchNotFoundTag,
-}) {
+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')({
     urls: S.NonEmptyArray(S.String),
     include: S.optionalWith(S.Struct({
@@ -462,10 +689,22 @@ export class FetchBatchedRequest extends S.Class('FetchBatchedRequest')({
         }), { nullable: true }),
         json: S.optionalWith(S.Boolean, { nullable: true, default: () => false }),
         appendix: S.optionalWith(S.Boolean, { nullable: true }),
+        appendixMarkers: S.optionalWith(FetchBatchedRequestIncludeAppendixMarkers, {
+            nullable: true,
+            default: () => 'compact',
+        }),
     }), { nullable: true }),
     browserConfig: S.optionalWith(S.Struct({
         scrollFullPage: S.optionalWith(S.Boolean, { nullable: true, default: () => false }),
     }), { 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,
+        }),
+        ocr: S.optionalWith(FetchBatchedRequestDocumentConfigOcr, { nullable: true, default: () => 'auto' }),
+    }), { nullable: true }),
 }) {
 }
 export class BatchedRun extends S.Class('BatchedRun')({
@@ -504,6 +743,17 @@ export class BatchedStatusBatchedStatus extends S.Literal('QUEUED', 'RUNNING', '
 }
 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)),
@@ -549,6 +799,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 }),
@@ -579,14 +837,59 @@ export class BatchedFetchItem extends S.Struct({
             url: S.String,
             fullPage: S.Boolean,
         }), { 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 }),
         assets: S.optionalWith(S.Array(FetchAssetReference), { nullable: true }),
         degraded: S.optionalWith(FetchDegradedInfo, { nullable: true }),
     }), { nullable: true }),
-    error: S.optionalWith(S.Union(FetchBlocked, FetchPageTooLarge, FetchNavigationFailed, FetchCaptureTimeout, FetchCapacityTimeout), { nullable: true }),
+    error: S.optionalWith(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({
@@ -631,6 +934,107 @@ export class BatchedCancellationConflict extends S.Class('BatchedCancellationCon
     _tag: BatchedCancellationConflictTag,
 }) {
 }
+export class SnapshotHighlightsInputIncludeAppendixMarkers extends S.Literal('off', 'compact', 'detailed') {
+}
+export class SnapshotHighlightsInput extends S.Class('SnapshotHighlightsInput')({
+    highlights: S.Struct({
+        query: S.String,
+        maxResults: S.optionalWith(S.Int.pipe(S.greaterThanOrEqualTo(1), S.lessThanOrEqualTo(50)), {
+            nullable: true,
+            default: () => 5,
+        }),
+        minScore: S.optionalWith(S.Number.pipe(S.greaterThanOrEqualTo(0), S.lessThanOrEqualTo(1)), {
+            nullable: true,
+            default: () => 0.6,
+        }),
+    }),
+    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 }),
+            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 }),
+        response: S.optionalWith(S.Struct({
+            includeHeaders: S.optionalWith(S.Boolean, { nullable: true, default: () => false }),
+        }), { nullable: true }),
+        json: S.optionalWith(S.Boolean, { nullable: true, default: () => false }),
+        appendix: S.optionalWith(S.Boolean, { nullable: true }),
+        appendixMarkers: S.optionalWith(SnapshotHighlightsInputIncludeAppendixMarkers, {
+            nullable: true,
+            default: () => 'compact',
+        }),
+    }), { nullable: true }),
+}) {
+}
+export class FetchSnapshotHighlightsResult extends S.Class('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')({
+    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')({
+    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')({
+    snapshotId: S.String,
+    _tag: SnapshotNotFoundTag,
+}) {
+}
 export const make = (httpClient, options = {}) => {
     const unexpectedStatus = (request, response) => Effect.flatMap(Effect.orElseSucceed(response.text, () => 'Unexpected status code'), (description) => Effect.fail(new HttpClientError.ResponseError({
         request,
@@ -641,45 +1045,47 @@ export const make = (httpClient, options = {}) => {
     const applyClientTransform = (client) => options.transformClient ? options.transformClient(client) : Effect.succeed(client);
     const decodeError = (response, schema) => Effect.flatMap(HttpClientResponse.schemaBodyJson(schema)(response), Effect.fail);
     return {
-        fetchFetch: (options) => HttpClientRequest.make('POST')(`/v1/fetch`).pipe(HttpClientRequest.setUrlParams({ include: options.params['include'] }), (req) => Effect.orDie(HttpClientRequest.bodyJson(req, options.payload)), Effect.flatMap((request) => Effect.flatMap(applyClientTransform(httpClient), (httpClient) => Effect.flatMap(httpClient.execute(request), HttpClientResponse.matchStatus({
+        fetchFetch: (options) => HttpClientRequest.make('POST')(`/v1/fetch`).pipe(HttpClientRequest.setUrlParams({
+            include: options.params['include'],
+            appendixMarkers: options.params['appendixMarkers'],
+        }), (req) => Effect.orDie(HttpClientRequest.bodyJson(req, options.payload)), Effect.flatMap((request) => Effect.flatMap(applyClientTransform(httpClient), (httpClient) => Effect.flatMap(httpClient.execute(request), HttpClientResponse.matchStatus({
             '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),
         }))))),
-        fetchFetchJson: (options) => HttpClientRequest.make('POST')(`/v1/fetch/json`).pipe(HttpClientRequest.setUrlParams({ include: options.params['include'] }), (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),
+        fetchFetchJson: (options) => HttpClientRequest.make('POST')(`/v1/fetch/json`).pipe(HttpClientRequest.setUrlParams({
+            include: options.params['include'],
+            appendixMarkers: options.params['appendixMarkers'],
+        }), (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(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),
         }))))),
-        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 }), (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(BatchedRun)(r),
             '400': (r) => decodeError(r, FetchBatched400),
@@ -717,6 +1123,28 @@ export const make = (httpClient, options = {}) => {
             '503': (r) => decodeError(r, ServiceUnavailable),
             orElse: (response) => unexpectedStatus(request, response),
         }))))),
+        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'] }), 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),
+        }))))),
     };
 };
 //# sourceMappingURL=Generated.js.map