@expandai/sdk 0.17.0 → 0.17.1

package/src/Generated.ts

@@ -0,0 +1,949 @@
+/** @effect-diagnostics schemaStructWithTag:skip-file */
+import type * as HttpClient from '@effect/platform/HttpClient'
+import * as HttpClientError from '@effect/platform/HttpClientError'
+import * as HttpClientRequest from '@effect/platform/HttpClientRequest'
+import * as HttpClientResponse from '@effect/platform/HttpClientResponse'
+import * as UrlParams from '@effect/platform/UrlParams'
+import * as Effect from 'effect/Effect'
+import type { ParseError } from 'effect/ParseResult'
+import * as S from 'effect/Schema'
+
+export class FetchFetchParams extends S.Struct({
+	include: S.optionalWith(S.String, { nullable: true }),
+}) {}
+
+export class FetchFetchRequest extends S.Class<FetchFetchRequest>('FetchFetchRequest')({
+	url: S.String,
+	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 },
+			),
+			summary: S.optionalWith(
+				S.Union(
+					S.Boolean,
+					S.Struct({
+						prompt: S.optionalWith(S.String.pipe(S.maxLength(5000)), { nullable: true }),
+					}),
+				),
+				{ nullable: true },
+			),
+			links: S.optionalWith(
+				S.Union(
+					S.Boolean,
+					S.Struct({
+						skipEmptyText: S.optionalWith(S.Boolean, { nullable: true }),
+						includeNavigation: S.optionalWith(S.Boolean, { nullable: true }),
+					}),
+				),
+				{ nullable: true },
+			),
+			meta: S.optionalWith(S.Boolean, { nullable: true, default: () => false as const }),
+			response: S.optionalWith(S.Boolean, { nullable: true, default: () => false as const }),
+			json: S.optionalWith(S.Boolean, { nullable: true, default: () => false as const }),
+			appendix: S.optionalWith(S.Boolean, { nullable: true }),
+		}),
+		{ nullable: true },
+	),
+	search: S.optionalWith(
+		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,
+			}),
+		}),
+		{ nullable: true },
+	),
+	browserConfig: S.optionalWith(
+		S.Struct({
+			scrollFullPage: S.optionalWith(S.Boolean, { nullable: true, default: () => false as const }),
+		}),
+		{ nullable: true },
+	),
+}) {}
+
+export class IssueTag extends S.Literal(
+	'Pointer',
+	'Unexpected',
+	'Missing',
+	'Composite',
+	'Refinement',
+	'Transformation',
+	'Type',
+	'Forbidden',
+) {}
+
+export class PropertyKeyEnumTag extends S.Literal('symbol') {}
+
+export class PropertyKey extends S.Union(
+	S.String,
+	S.Number,
+	S.Struct({
+		_tag: PropertyKeyEnumTag,
+		key: S.String,
+	}),
+) {}
+
+export class Issue extends S.Struct({
+	_tag: IssueTag,
+	path: S.Array(PropertyKey),
+	message: S.String,
+}) {}
+
+export class HttpApiDecodeErrorTag extends S.Literal('HttpApiDecodeError') {}
+
+export class HttpApiDecodeError extends S.Struct({
+	issues: S.Array(Issue),
+	message: S.String,
+	_tag: HttpApiDecodeErrorTag,
+}) {}
+
+export class BadRequestTag extends S.Literal('BadRequest') {}
+
+export class BadRequest extends S.Struct({
+	message: S.String,
+	_tag: BadRequestTag,
+}) {}
+
+export class FetchFetch400 extends S.Union(HttpApiDecodeError, BadRequest) {}
+
+export class AuthFailedReason extends S.Literal('InvalidApiKey', 'InvalidToken', 'InvalidSession', 'InvalidTenant') {}
+
+export class AuthFailedTag extends S.Literal('AuthFailed') {}
+
+export class AuthFailed extends S.Class<AuthFailed>('AuthFailed')({
+	reason: AuthFailedReason,
+	description: S.optionalWith(
+		S.Union(
+			S.String,
+			S.Struct({
+				message: S.String,
+			}),
+		),
+		{ nullable: true },
+	),
+	_tag: AuthFailedTag,
+}) {}
+
+export class DateTimeUtc extends S.String {}
+
+export class FetchBlockedTag extends S.Literal('FetchBlocked') {}
+
+export class FetchBlocked extends S.Struct({
+	url: S.String,
+	blockedType: S.optionalWith(S.String, { nullable: true }),
+	_tag: FetchBlockedTag,
+}) {}
+
+export class FetchFetch403 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 PayloadTooLargeTag extends S.Literal('PayloadTooLarge') {}
+
+export class PayloadTooLarge extends S.Class<PayloadTooLarge>('PayloadTooLarge')({
+	_tag: PayloadTooLargeTag,
+}) {}
+
+export class TooManyRequestsTag extends S.Literal('TooManyRequests') {}
+
+export class TooManyRequests extends S.Class<TooManyRequests>('TooManyRequests')({
+	_tag: TooManyRequestsTag,
+}) {}
+
+export class InternalErrorTag extends S.Literal('InternalError') {}
+
+export class InternalError extends S.Class<InternalError>('InternalError')({
+	_tag: InternalErrorTag,
+}) {}
+
+export class ServiceUnavailableTag extends S.Literal('ServiceUnavailable') {}
+
+export class ServiceUnavailable extends S.Class<ServiceUnavailable>('ServiceUnavailable')({
+	_tag: ServiceUnavailableTag,
+}) {}
+
+export class FetchFetchJsonParams extends S.Struct({
+	include: S.optionalWith(S.String, { nullable: true }),
+}) {}
+
+export class FetchFetchJsonRequest extends S.Class<FetchFetchJsonRequest>('FetchFetchJsonRequest')({
+	url: S.String,
+	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 },
+			),
+			summary: S.optionalWith(
+				S.Union(
+					S.Boolean,
+					S.Struct({
+						prompt: S.optionalWith(S.String.pipe(S.maxLength(5000)), { nullable: true }),
+					}),
+				),
+				{ nullable: true },
+			),
+			links: S.optionalWith(
+				S.Union(
+					S.Boolean,
+					S.Struct({
+						skipEmptyText: S.optionalWith(S.Boolean, { nullable: true }),
+						includeNavigation: S.optionalWith(S.Boolean, { nullable: true }),
+					}),
+				),
+				{ nullable: true },
+			),
+			meta: S.optionalWith(S.Boolean, { nullable: true, default: () => false as const }),
+			response: S.optionalWith(S.Boolean, { nullable: true, default: () => false as const }),
+			json: S.optionalWith(S.Boolean, { nullable: true, default: () => false as const }),
+			appendix: S.optionalWith(S.Boolean, { nullable: true }),
+		}),
+		{ nullable: true },
+	),
+	search: S.optionalWith(
+		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,
+			}),
+		}),
+		{ nullable: true },
+	),
+	browserConfig: S.optionalWith(
+		S.Struct({
+			scrollFullPage: S.optionalWith(S.Boolean, { nullable: true, default: () => false as const }),
+		}),
+		{ nullable: true },
+	),
+}) {}
+
+export class FetchObjectModeMetaVersion extends S.Literal(1) {}
+
+export class FetchObjectModeAppendixLinks extends S.Struct({
+	sameDomain: S.Number,
+	external: S.Number,
+}) {}
+
+export class FetchObjectModeAppendixHint extends S.Struct({
+	url: S.String,
+	links: FetchObjectModeAppendixLinks,
+}) {}
+
+export class FetchObjectModeStateJsonHint extends S.Struct({
+	moreTokens: S.Number,
+}) {}
+
+export class FetchObjectModeMarkdownHint extends S.Struct({
+	url: S.String,
+	moreTokens: S.Number,
+}) {}
+
+export class FetchObjectModeMeta extends S.Struct({
+	version: FetchObjectModeMetaVersion,
+	url: S.String,
+	capturedAt: S.String,
+	snapshotId: S.String,
+	lang: S.String,
+	pageType: S.String,
+	playground: S.String,
+	title: S.optionalWith(S.String, { nullable: true }),
+	finalUrl: 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 }),
+	createdAt: S.optionalWith(S.String, { nullable: true }),
+	updatedAt: S.optionalWith(S.String, { nullable: true }),
+	image: S.optionalWith(S.String, { nullable: true }),
+	paginationNext: S.optionalWith(S.String, { nullable: true }),
+	appendix: S.optionalWith(FetchObjectModeAppendixHint, { nullable: true }),
+	stateJson: S.optionalWith(FetchObjectModeStateJsonHint, { nullable: true }),
+	markdown: S.optionalWith(FetchObjectModeMarkdownHint, { nullable: true }),
+	blocked: S.optionalWith(S.String, { nullable: true }),
+	loadingStatus: S.optionalWith(S.String, { nullable: true }),
+}) {}
+
+export class FetchObjectModeEvidenceKind extends S.Literal('inline', 'network') {}
+
+export class FetchObjectModeEvidenceRole extends S.Literal(
+	'ld+json',
+	'next-data',
+	'nuxt',
+	'apollo-state',
+	'initial-state',
+	'application-json',
+	'script-tag',
+	'data-attribute',
+	'network-json',
+	'network-response',
+	'other',
+) {}
+
+export class FetchObjectModeEvidence extends S.Struct({
+	id: S.Number,
+	kind: FetchObjectModeEvidenceKind,
+	role: FetchObjectModeEvidenceRole,
+	score: S.Number,
+	url: S.optionalWith(S.String, { nullable: true }),
+	method: S.optionalWith(S.String, { nullable: true }),
+	moreTokens: S.optionalWith(S.Number, { nullable: true }),
+	keys: S.optionalWith(S.Array(S.String), { nullable: true }),
+}) {}
+
+export class FetchAssetReferenceKind extends S.Literal('data-url') {}
+
+export class FetchAssetReference extends S.Struct({
+	id: S.String,
+	kind: FetchAssetReferenceKind,
+	placeholder: S.String,
+	archiveKey: S.String,
+	mimeType: S.String,
+	sha256: S.String,
+	bytes: S.Number,
+}) {}
+
+export class CaptureTelemetryInfoRequestedStyleMode extends S.Literal('compat_full', 'native_default') {}
+
+export class CaptureTelemetryInfoSelected extends S.Literal('rust') {}
+
+export class CaptureTelemetryInfoActual extends S.Literal('rust') {}
+
+export class CaptureTelemetryInfoActualStyleMode extends S.Literal('compat_full', 'native_default') {}
+
+export class CaptureTelemetryInfoIconBackendDecision extends S.Literal('cpu', 'remote_gpu') {}
+
+export class CaptureTelemetryInfo extends S.Struct({
+	requestedStyleMode: S.optionalWith(CaptureTelemetryInfoRequestedStyleMode, { nullable: true }),
+	selected: CaptureTelemetryInfoSelected,
+	actual: CaptureTelemetryInfoActual,
+	actualStyleMode: S.optionalWith(CaptureTelemetryInfoActualStyleMode, { nullable: true }),
+	rolloutApplied: S.Boolean,
+	preparedSessionHit: S.optionalWith(S.Boolean, { nullable: true }),
+	nativePoolHit: S.optionalWith(S.Boolean, { nullable: true }),
+	preparedPageHit: S.optionalWith(S.Boolean, { nullable: true }),
+	nativePoolCapacity: S.optionalWith(S.Number, { nullable: true }),
+	nativePoolProfile: S.optionalWith(S.String, { nullable: true }),
+	poolHit: S.optionalWith(S.Boolean, { nullable: true }),
+	connectMs: S.optionalWith(S.Number, { nullable: true }),
+	warmConnectionAgeMs: S.optionalWith(S.Number, { nullable: true }),
+	iconBackendDecision: S.optionalWith(CaptureTelemetryInfoIconBackendDecision, { nullable: true }),
+}) {}
+
+export class FetchSearchSnippetLocation extends S.Struct({
+	markdownBlockId: S.optionalWith(S.String, { nullable: true }),
+	nodeIds: S.optionalWith(S.Array(S.Number), { nullable: true }),
+	stateJsonSourceId: S.optionalWith(S.Number, { nullable: true }),
+	jsonPath: S.optionalWith(S.String, { nullable: true }),
+}) {}
+
+export class FetchSearchSourceMetaSource extends S.Literal('markdown', 'appendix', 'statejson') {}
+
+export class FetchSearchSourceMetaRanker extends S.Literal('zeroentropy', 'local_lexical') {}
+
+export class FetchSearchSourceMetaFallbackReason extends S.Literal('timeout', 'error') {}
+
+export class FetchSearchSourceMeta extends S.Struct({
+	source: FetchSearchSourceMetaSource,
+	chunkCount: S.Int.pipe(S.greaterThanOrEqualTo(0)),
+	batchCount: S.Int.pipe(S.greaterThanOrEqualTo(0)),
+	ranker: FetchSearchSourceMetaRanker,
+	fallback: S.Boolean,
+	fallbackReason: S.optionalWith(FetchSearchSourceMetaFallbackReason, { nullable: true }),
+	durationMs: S.Number.pipe(S.greaterThanOrEqualTo(0)),
+}) {}
+
+export class FetchSearchMeta extends S.Struct({
+	durationMs: S.Number.pipe(S.greaterThanOrEqualTo(0)),
+	sources: S.Array(FetchSearchSourceMeta),
+}) {}
+
+export class FetchSearchResult extends S.Struct({
+	query: S.String,
+	snippets: S.Array(
+		S.Struct({
+			type: S.optionalWith(S.Literal('text'), { nullable: true, default: () => 'text' as const }),
+			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 }),
+		}),
+	),
+	meta: S.optionalWith(FetchSearchMeta, { nullable: true }),
+}) {}
+
+export class FetchObjectModeResult extends S.Class<FetchObjectModeResult>('FetchObjectModeResult')({
+	meta: FetchObjectModeMeta,
+	markdown: S.String,
+	json: S.Array(FetchObjectModeEvidence),
+	data: S.optionalWith(
+		S.Struct({
+			assets: S.optionalWith(S.Array(FetchAssetReference), { nullable: true }),
+			captureTelemetry: S.optionalWith(CaptureTelemetryInfo, { nullable: true }),
+			search: S.optionalWith(FetchSearchResult, { nullable: true }),
+			screenshot: S.optionalWith(
+				S.Struct({
+					url: S.String,
+					fullPage: S.Boolean,
+				}),
+				{ 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 IncludeHtmlConfig extends S.Record({ key: S.String, value: S.Unknown }) {}
+
+export class IncludeMarkdownConfig extends S.Record({ key: S.String, value: S.Unknown }) {}
+
+export class IncludeScreenshotConfig extends S.Struct({
+	fullPage: S.optionalWith(S.Boolean, { nullable: true }),
+}) {}
+
+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, IncludeHtmlConfig), { nullable: true }),
+			markdown: S.optionalWith(S.Union(S.Boolean, IncludeMarkdownConfig), { nullable: true }),
+			screenshot: S.optionalWith(S.Union(S.Boolean, IncludeScreenshotConfig), { nullable: true }),
+			summary: S.optionalWith(
+				S.Union(
+					S.Boolean,
+					S.Struct({
+						prompt: S.optionalWith(S.String.pipe(S.maxLength(5000)), {
+							nullable: true,
+							default: () =>
+								'You are a helpful assistant that summarizes web page content.\nGiven the markdown content of a web page, provide a clear and concise summary.\nFocus on the main points and key information.\nKeep the summary informative but brief.' as const,
+						}),
+					}),
+				),
+				{ 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 }),
+		}),
+		{ nullable: true },
+	),
+}) {}
+
+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 }),
+	headers: S.optionalWith(S.Struct({}), { nullable: true }),
+}) {}
+
+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)),
+}) {}
+
+export class FetchFetchSearch400 extends S.Union(HttpApiDecodeError, BadRequest) {}
+
+export class FetchFetchSearch403Tag extends S.Literal('AccessBlocked') {}
+
+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 NonEmptyString extends S.String.pipe(S.minLength(1)) {}
+
+export class FetchSnapshotSearchNotFoundTag extends S.Literal('FetchSnapshotSearchNotFound') {}
+
+export class FetchSnapshotSearchNotFound extends S.Class<FetchSnapshotSearchNotFound>('FetchSnapshotSearchNotFound')({
+	snapshotId: NonEmptyString,
+	_tag: FetchSnapshotSearchNotFoundTag,
+}) {}
+
+export class FetchBatchedRequest extends S.Class<FetchBatchedRequest>('FetchBatchedRequest')({
+	urls: S.NonEmptyArray(S.String),
+	include: S.optionalWith(
+		S.Struct({
+			html: S.optionalWith(S.Union(S.Boolean, IncludeHtmlConfig), { nullable: true }),
+			markdown: S.optionalWith(S.Union(S.Boolean, IncludeMarkdownConfig), { nullable: true }),
+			screenshot: S.optionalWith(S.Union(S.Boolean, IncludeScreenshotConfig), { nullable: true }),
+			summary: S.optionalWith(
+				S.Union(
+					S.Boolean,
+					S.Struct({
+						prompt: S.optionalWith(S.String.pipe(S.maxLength(5000)), {
+							nullable: true,
+							default: () =>
+								'You are a helpful assistant that summarizes web page content.\nGiven the markdown content of a web page, provide a clear and concise summary.\nFocus on the main points and key information.\nKeep the summary informative but brief.' as const,
+						}),
+					}),
+				),
+				{ 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 }),
+		}),
+		{ nullable: true },
+	),
+	browserConfig: S.optionalWith(
+		S.Struct({
+			scrollFullPage: S.optionalWith(S.Boolean, { nullable: true, default: () => false as const }),
+		}),
+		{ nullable: true },
+	),
+}) {}
+
+export class BatchedRun extends S.Class<BatchedRun>('BatchedRun')({
+	id: S.String,
+}) {}
+
+export class FetchBatched400 extends S.Union(HttpApiDecodeError, BadRequest) {}
+
+export class FetchBatched403Tag extends S.Literal('AccessBlocked') {}
+
+export class FetchBatched403 extends S.Struct({
+	organizationId: S.String.pipe(S.minLength(1)),
+	blockedUntil: S.optionalWith(S.Union(DateTimeUtc, S.Null), { nullable: true }),
+	_tag: FetchBatched403Tag,
+}) {}
+
+export class FetchGetBatchedParams extends S.Struct({
+	limit: S.optionalWith(S.String, { nullable: true }),
+	offset: S.optionalWith(S.String, { nullable: true }),
+	include: S.optionalWith(S.String, { nullable: true }),
+}) {}
+
+export class BatchedStatusStatus extends S.Literal('QUEUED', 'RUNNING', 'COMPLETED', 'FAILED', 'CANCELLED') {}
+
+export class BatchedStatusBatchedStatus extends S.Literal('QUEUED', 'RUNNING', 'COMPLETED', 'FAILED', 'CANCELLED') {}
+
+export class IconMeta extends S.Struct({
+	href: S.String.pipe(S.minLength(1)),
+	rel: S.String.pipe(S.minLength(1)),
+	type: S.optionalWith(S.String.pipe(S.minLength(1)), { nullable: true }),
+	sizes: S.optionalWith(S.String.pipe(S.minLength(1)), { nullable: true }),
+}) {}
+
+export class OgImage extends S.Struct({
+	url: S.String.pipe(S.minLength(1)),
+	width: S.optionalWith(S.Number, { nullable: true }),
+	height: S.optionalWith(S.Number, { nullable: true }),
+	alt: S.optionalWith(S.String, { nullable: true }),
+}) {}
+
+export class OpenGraphMeta extends S.Struct({
+	title: S.optionalWith(S.String, { nullable: true }),
+	description: S.optionalWith(S.String, { nullable: true }),
+	type: S.optionalWith(S.String.pipe(S.minLength(1)), { nullable: true }),
+	url: S.optionalWith(S.String.pipe(S.minLength(1)), { nullable: true }),
+	siteName: S.optionalWith(S.String, { nullable: true }),
+	locale: S.optionalWith(S.String, { nullable: true }),
+	images: S.optionalWith(S.Array(OgImage), { nullable: true }),
+}) {}
+
+export class TwitterCardMeta extends S.Struct({
+	card: S.optionalWith(S.String.pipe(S.minLength(1)), { nullable: true }),
+	site: S.optionalWith(S.String, { nullable: true }),
+	creator: S.optionalWith(S.String, { nullable: true }),
+	title: S.optionalWith(S.String, { nullable: true }),
+	description: S.optionalWith(S.String, { nullable: true }),
+	image: S.optionalWith(S.String.pipe(S.minLength(1)), { nullable: true }),
+}) {}
+
+export class PageMeta extends S.Struct({
+	title: S.optionalWith(S.String, { nullable: true }),
+	description: S.optionalWith(S.String, { nullable: true }),
+	canonicalUrl: S.optionalWith(S.String.pipe(S.minLength(1)), { nullable: true }),
+	language: S.optionalWith(S.String.pipe(S.minLength(1)), { nullable: true }),
+	charset: S.optionalWith(S.String.pipe(S.minLength(1)), { nullable: true }),
+	favicon: S.optionalWith(S.String.pipe(S.minLength(1)), { nullable: true }),
+	icons: S.optionalWith(S.Array(IconMeta), { nullable: true }),
+	openGraph: S.optionalWith(OpenGraphMeta, { nullable: true }),
+	twitter: S.optionalWith(TwitterCardMeta, { nullable: true }),
+}) {}
+
+export class FetchLink extends S.Struct({
+	url: S.String,
+	text: S.optionalWith(S.String, { nullable: true }),
+}) {}
+
+export class RenderEnginesInfoCapture extends S.Literal('rust') {}
+
+export class RenderEnginesInfoMarkdown extends S.Literal('rust') {}
+
+export class RenderEnginesInfoTree extends S.Literal('rust') {}
+
+export class RenderEnginesInfo extends S.Struct({
+	capture: S.optionalWith(RenderEnginesInfoCapture, { nullable: true }),
+	markdown: S.optionalWith(RenderEnginesInfoMarkdown, { nullable: true }),
+	tree: S.optionalWith(RenderEnginesInfoTree, { nullable: true }),
+}) {}
+
+export class PaginationMeta extends S.Struct({
+	total: S.Number,
+	limit: S.Number,
+	offset: S.Number,
+	hasMore: S.Boolean,
+}) {}
+
+export class BatchedStatus extends S.Class<BatchedStatus>('BatchedStatus')({
+	id: S.String,
+	status: BatchedStatusStatus,
+	batchedStatus: BatchedStatusBatchedStatus,
+	totalUrls: S.Number,
+	results: S.Array(
+		S.Struct({
+			data: S.Struct({
+				response: ResponseInfo,
+				meta: S.optionalWith(PageMeta, { nullable: true }),
+				json: S.optionalWith(S.Array(S.Struct({})), { nullable: true }),
+				snapshotId: S.optionalWith(NonEmptyString, { nullable: true }),
+				html: S.optionalWith(S.String.pipe(S.minLength(1)), { nullable: true }),
+				markdown: S.optionalWith(S.String.pipe(S.minLength(1)), { nullable: true }),
+				screenshot: S.optionalWith(
+					S.Struct({
+						url: S.String,
+						fullPage: S.Boolean,
+					}),
+					{ nullable: true },
+				),
+				summary: S.optionalWith(S.String.pipe(S.minLength(1)), { nullable: true }),
+				search: S.optionalWith(FetchSearchResult, { 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 }),
+				captureTelemetry: S.optionalWith(CaptureTelemetryInfo, { nullable: true }),
+				assets: S.optionalWith(S.Array(FetchAssetReference), { nullable: true }),
+				blocked: S.optionalWith(
+					S.Struct({
+						blockedType: S.optionalWith(S.String, { nullable: true }),
+					}),
+					{ nullable: true },
+				),
+			}),
+		}),
+	),
+	pagination: PaginationMeta,
+}) {}
+
+export class BatchedIncludeUnsupportedTag extends S.Literal('BatchedIncludeUnsupported') {}
+
+export class BatchedIncludeUnsupported extends S.Struct({
+	unsupportedFields: S.Array(S.String),
+	_tag: BatchedIncludeUnsupportedTag,
+}) {}
+
+export class FetchGetBatched400 extends S.Union(HttpApiDecodeError, BatchedIncludeUnsupported) {}
+
+export const make = (
+	httpClient: HttpClient.HttpClient,
+	options: {
+		readonly transformClient?: ((client: HttpClient.HttpClient) => Effect.Effect<HttpClient.HttpClient>) | undefined
+	} = {},
+): Client => {
+	const unexpectedStatus = (
+		request: HttpClientRequest.HttpClientRequest,
+		response: HttpClientResponse.HttpClientResponse,
+	) =>
+		Effect.flatMap(
+			Effect.orElseSucceed(response.text, () => 'Unexpected status code'),
+			(description) =>
+				Effect.fail(
+					new HttpClientError.ResponseError({
+						request,
+						response,
+						reason: 'StatusCode',
+						description,
+					}),
+				),
+		)
+	const applyClientTransform = (client: HttpClient.HttpClient): Effect.Effect<HttpClient.HttpClient> =>
+		options.transformClient ? options.transformClient(client) : Effect.succeed(client)
+	const decodeError = <A, I, R>(response: HttpClientResponse.HttpClientResponse, schema: S.Schema<A, I, R>) =>
+		Effect.flatMap(HttpClientResponse.schemaBodyJson(schema)(response), Effect.fail)
+	return {
+		fetchFetch: (options) =>
+			HttpClientRequest.make('POST')(`/v1/fetch`).pipe(
+				HttpClientRequest.setUrlParams({ include: options.params['include'] 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({
+								'400': (r) => decodeError(r, FetchFetch400),
+								'401': (r) => decodeError(r, AuthFailed),
+								'403': (r) => decodeError(r, FetchFetch403),
+								'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),
+							}),
+						),
+					),
+				),
+			),
+		fetchFetchJson: (options) =>
+			HttpClientRequest.make('POST')(`/v1/fetch/json`).pipe(
+				HttpClientRequest.setUrlParams({ include: options.params['include'] 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),
+								'400': (r) => decodeError(r, FetchFetchJson400),
+								'401': (r) => decodeError(r, AuthFailed),
+								'403': (r) => decodeError(r, FetchFetchJson403),
+								'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),
+							}),
+						),
+					),
+				),
+			),
+		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(
+				(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(BatchedRun)(r),
+								'400': (r) => decodeError(r, FetchBatched400),
+								'401': (r) => decodeError(r, AuthFailed),
+								'403': (r) => decodeError(r, FetchBatched403),
+								'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),
+							}),
+						),
+					),
+				),
+			),
+		fetchGetBatched: (id, options) =>
+			HttpClientRequest.make('GET')(`/v1/fetch/batched/${id}`).pipe(
+				HttpClientRequest.setUrlParams({
+					limit: options['limit'] as UrlParams.Coercible,
+					offset: options['offset'] as UrlParams.Coercible,
+					include: options['include'] as UrlParams.Coercible,
+				}),
+				Effect.succeed,
+				Effect.flatMap((request) =>
+					Effect.flatMap(applyClientTransform(httpClient), (httpClient) =>
+						Effect.flatMap(
+							httpClient.execute(request),
+							HttpClientResponse.matchStatus({
+								'200': (r) => HttpClientResponse.schemaBodyJson(BatchedStatus)(r),
+								'400': (r) => decodeError(r, FetchGetBatched400),
+								'401': (r) => decodeError(r, AuthFailed),
+								'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),
+							}),
+						),
+					),
+				),
+			),
+	}
+}
+
+export interface Client {
+	readonly fetchFetch: (options: {
+		readonly params: typeof FetchFetchParams.Encoded
+		readonly payload: typeof FetchFetchRequest.Encoded
+	}) => Effect.Effect<
+		void,
+		| HttpClientError.HttpClientError
+		| ParseError
+		| typeof FetchFetch400.Type
+		| typeof AuthFailed.Type
+		| typeof FetchFetch403.Type
+		| typeof PayloadTooLarge.Type
+		| typeof TooManyRequests.Type
+		| typeof InternalError.Type
+		| typeof ServiceUnavailable.Type
+	>
+	readonly fetchFetchJson: (options: {
+		readonly params: typeof FetchFetchJsonParams.Encoded
+		readonly payload: typeof FetchFetchJsonRequest.Encoded
+	}) => Effect.Effect<
+		typeof FetchObjectModeResult.Type,
+		| HttpClientError.HttpClientError
+		| ParseError
+		| typeof FetchFetchJson400.Type
+		| typeof AuthFailed.Type
+		| typeof FetchFetchJson403.Type
+		| typeof PayloadTooLarge.Type
+		| typeof TooManyRequests.Type
+		| typeof InternalError.Type
+		| typeof ServiceUnavailable.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: typeof FetchBatchedRequest.Encoded,
+	) => Effect.Effect<
+		typeof BatchedRun.Type,
+		| HttpClientError.HttpClientError
+		| ParseError
+		| typeof FetchBatched400.Type
+		| typeof AuthFailed.Type
+		| typeof FetchBatched403.Type
+		| typeof PayloadTooLarge.Type
+		| typeof TooManyRequests.Type
+		| typeof InternalError.Type
+		| typeof ServiceUnavailable.Type
+	>
+	readonly fetchGetBatched: (
+		id: string,
+		options: typeof FetchGetBatchedParams.Encoded,
+	) => Effect.Effect<
+		typeof BatchedStatus.Type,
+		| HttpClientError.HttpClientError
+		| ParseError
+		| typeof FetchGetBatched400.Type
+		| typeof AuthFailed.Type
+		| typeof PayloadTooLarge.Type
+		| typeof TooManyRequests.Type
+		| typeof InternalError.Type
+		| typeof ServiceUnavailable.Type
+	>
+}