@expandai/sdk 0.17.0 → 0.17.1

package/build/esm/Generated.js

@@ -0,0 +1,646 @@
+import * as HttpClientError from '@effect/platform/HttpClientError';
+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 FetchFetchParams extends S.Struct({
+    include: S.optionalWith(S.String, { nullable: true }),
+}) {
+}
+export class FetchFetchRequest extends S.Class('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 }),
+        response: S.optionalWith(S.Boolean, { nullable: true, default: () => false }),
+        json: S.optionalWith(S.Boolean, { nullable: true, default: () => false }),
+        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,
+        }),
+        minScore: S.optionalWith(S.Number.pipe(S.greaterThanOrEqualTo(0), S.lessThanOrEqualTo(1)), {
+            nullable: true,
+            default: () => 0.6,
+        }),
+    }), { nullable: true }),
+    browserConfig: S.optionalWith(S.Struct({
+        scrollFullPage: S.optionalWith(S.Boolean, { nullable: true, default: () => false }),
+    }), { 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')({
+    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')({
+    _tag: PayloadTooLargeTag,
+}) {
+}
+export class TooManyRequestsTag extends S.Literal('TooManyRequests') {
+}
+export class TooManyRequests extends S.Class('TooManyRequests')({
+    _tag: TooManyRequestsTag,
+}) {
+}
+export class InternalErrorTag extends S.Literal('InternalError') {
+}
+export class InternalError extends S.Class('InternalError')({
+    _tag: InternalErrorTag,
+}) {
+}
+export class ServiceUnavailableTag extends S.Literal('ServiceUnavailable') {
+}
+export class ServiceUnavailable extends S.Class('ServiceUnavailable')({
+    _tag: ServiceUnavailableTag,
+}) {
+}
+export class FetchFetchJsonParams extends S.Struct({
+    include: S.optionalWith(S.String, { nullable: true }),
+}) {
+}
+export class FetchFetchJsonRequest extends S.Class('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 }),
+        response: S.optionalWith(S.Boolean, { nullable: true, default: () => false }),
+        json: S.optionalWith(S.Boolean, { nullable: true, default: () => false }),
+        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,
+        }),
+        minScore: S.optionalWith(S.Number.pipe(S.greaterThanOrEqualTo(0), S.lessThanOrEqualTo(1)), {
+            nullable: true,
+            default: () => 0.6,
+        }),
+    }), { nullable: true }),
+    browserConfig: S.optionalWith(S.Struct({
+        scrollFullPage: S.optionalWith(S.Boolean, { nullable: true, default: () => false }),
+    }), { 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' }),
+        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')({
+    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')({
+    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, 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.',
+            }),
+        })), { 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 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')({
+    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')({
+    snapshotId: NonEmptyString,
+    _tag: FetchSnapshotSearchNotFoundTag,
+}) {
+}
+export class FetchBatchedRequest extends S.Class('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.',
+            }),
+        })), { 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 }),
+    browserConfig: S.optionalWith(S.Struct({
+        scrollFullPage: S.optionalWith(S.Boolean, { nullable: true, default: () => false }),
+    }), { nullable: true }),
+}) {
+}
+export class BatchedRun extends S.Class('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')({
+    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, options = {}) => {
+    const unexpectedStatus = (request, response) => Effect.flatMap(Effect.orElseSucceed(response.text, () => 'Unexpected status code'), (description) => Effect.fail(new HttpClientError.ResponseError({
+        request,
+        response,
+        reason: 'StatusCode',
+        description,
+    })));
+    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({
+            '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'] }), (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'],
+            offset: options['offset'],
+            include: options['include'],
+        }), 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),
+        }))))),
+    };
+};
+//# sourceMappingURL=Generated.js.map