@expandai/sdk 0.16.0 → 0.17.1

package/build/dts/Generated.d.ts

@@ -0,0 +1,1863 @@
+/** @effect-diagnostics schemaStructWithTag:skip-file */
+import type * as HttpClient from '@effect/platform/HttpClient';
+import * as HttpClientError from '@effect/platform/HttpClientError';
+import * as Effect from 'effect/Effect';
+import type { ParseError } from 'effect/ParseResult';
+import * as S from 'effect/Schema';
+declare const FetchFetchParams_base: S.Struct<{
+    include: S.optionalWith<typeof S.String, {
+        nullable: true;
+    }>;
+}>;
+export declare class FetchFetchParams extends FetchFetchParams_base {
+}
+declare const FetchFetchRequest_base: S.Class<FetchFetchRequest, {
+    url: typeof S.String;
+    include: S.optionalWith<S.Struct<{
+        html: S.optionalWith<S.Union<[typeof S.Boolean, S.Record$<typeof S.String, typeof S.Unknown>]>, {
+            nullable: true;
+        }>;
+        markdown: S.optionalWith<S.Union<[typeof S.Boolean, S.Record$<typeof S.String, typeof S.Unknown>]>, {
+            nullable: true;
+        }>;
+        screenshot: S.optionalWith<S.Union<[typeof S.Boolean, S.Struct<{
+            fullPage: S.optionalWith<typeof S.Boolean, {
+                nullable: true;
+            }>;
+        }>]>, {
+            nullable: true;
+        }>;
+        summary: S.optionalWith<S.Union<[typeof S.Boolean, S.Struct<{
+            prompt: S.optionalWith<S.filter<typeof S.String>, {
+                nullable: true;
+            }>;
+        }>]>, {
+            nullable: true;
+        }>;
+        links: S.optionalWith<S.Union<[typeof S.Boolean, S.Struct<{
+            skipEmptyText: S.optionalWith<typeof S.Boolean, {
+                nullable: true;
+            }>;
+            includeNavigation: S.optionalWith<typeof S.Boolean, {
+                nullable: true;
+            }>;
+        }>]>, {
+            nullable: true;
+        }>;
+        meta: S.optionalWith<typeof S.Boolean, {
+            nullable: true;
+            default: () => false;
+        }>;
+        response: S.optionalWith<typeof S.Boolean, {
+            nullable: true;
+            default: () => false;
+        }>;
+        json: S.optionalWith<typeof S.Boolean, {
+            nullable: true;
+            default: () => false;
+        }>;
+        appendix: S.optionalWith<typeof S.Boolean, {
+            nullable: true;
+        }>;
+    }>, {
+        nullable: true;
+    }>;
+    search: S.optionalWith<S.Struct<{
+        query: typeof S.String;
+        maxResults: S.optionalWith<S.filter<S.filter<typeof S.Int>>, {
+            nullable: true;
+            default: () => 5;
+        }>;
+        minScore: S.optionalWith<S.filter<S.filter<typeof S.Number>>, {
+            nullable: true;
+            default: () => 0.6;
+        }>;
+    }>, {
+        nullable: true;
+    }>;
+    browserConfig: S.optionalWith<S.Struct<{
+        scrollFullPage: S.optionalWith<typeof S.Boolean, {
+            nullable: true;
+            default: () => false;
+        }>;
+    }>, {
+        nullable: true;
+    }>;
+}, S.Struct.Encoded<{
+    url: typeof S.String;
+    include: S.optionalWith<S.Struct<{
+        html: S.optionalWith<S.Union<[typeof S.Boolean, S.Record$<typeof S.String, typeof S.Unknown>]>, {
+            nullable: true;
+        }>;
+        markdown: S.optionalWith<S.Union<[typeof S.Boolean, S.Record$<typeof S.String, typeof S.Unknown>]>, {
+            nullable: true;
+        }>;
+        screenshot: S.optionalWith<S.Union<[typeof S.Boolean, S.Struct<{
+            fullPage: S.optionalWith<typeof S.Boolean, {
+                nullable: true;
+            }>;
+        }>]>, {
+            nullable: true;
+        }>;
+        summary: S.optionalWith<S.Union<[typeof S.Boolean, S.Struct<{
+            prompt: S.optionalWith<S.filter<typeof S.String>, {
+                nullable: true;
+            }>;
+        }>]>, {
+            nullable: true;
+        }>;
+        links: S.optionalWith<S.Union<[typeof S.Boolean, S.Struct<{
+            skipEmptyText: S.optionalWith<typeof S.Boolean, {
+                nullable: true;
+            }>;
+            includeNavigation: S.optionalWith<typeof S.Boolean, {
+                nullable: true;
+            }>;
+        }>]>, {
+            nullable: true;
+        }>;
+        meta: S.optionalWith<typeof S.Boolean, {
+            nullable: true;
+            default: () => false;
+        }>;
+        response: S.optionalWith<typeof S.Boolean, {
+            nullable: true;
+            default: () => false;
+        }>;
+        json: S.optionalWith<typeof S.Boolean, {
+            nullable: true;
+            default: () => false;
+        }>;
+        appendix: S.optionalWith<typeof S.Boolean, {
+            nullable: true;
+        }>;
+    }>, {
+        nullable: true;
+    }>;
+    search: S.optionalWith<S.Struct<{
+        query: typeof S.String;
+        maxResults: S.optionalWith<S.filter<S.filter<typeof S.Int>>, {
+            nullable: true;
+            default: () => 5;
+        }>;
+        minScore: S.optionalWith<S.filter<S.filter<typeof S.Number>>, {
+            nullable: true;
+            default: () => 0.6;
+        }>;
+    }>, {
+        nullable: true;
+    }>;
+    browserConfig: S.optionalWith<S.Struct<{
+        scrollFullPage: S.optionalWith<typeof S.Boolean, {
+            nullable: true;
+            default: () => false;
+        }>;
+    }>, {
+        nullable: true;
+    }>;
+}>, never, {
+    readonly include?: {
+        readonly html?: boolean | {
+            readonly [x: string]: unknown;
+        } | undefined;
+        readonly markdown?: boolean | {
+            readonly [x: string]: unknown;
+        } | undefined;
+        readonly screenshot?: boolean | {
+            readonly fullPage?: boolean | undefined;
+        } | undefined;
+        readonly summary?: boolean | {
+            readonly prompt?: string | undefined;
+        } | undefined;
+        readonly links?: boolean | {
+            readonly skipEmptyText?: boolean | undefined;
+            readonly includeNavigation?: boolean | undefined;
+        } | undefined;
+        readonly meta: boolean;
+        readonly response: boolean;
+        readonly json: boolean;
+        readonly appendix?: boolean | undefined;
+    } | undefined;
+} & {
+    readonly url: string;
+} & {
+    readonly search?: {
+        readonly query: string;
+        readonly maxResults: number;
+        readonly minScore: number;
+    } | undefined;
+} & {
+    readonly browserConfig?: {
+        readonly scrollFullPage: boolean;
+    } | undefined;
+}, {}, {}>;
+export declare class FetchFetchRequest extends FetchFetchRequest_base {
+}
+declare const IssueTag_base: S.Literal<["Pointer", "Unexpected", "Missing", "Composite", "Refinement", "Transformation", "Type", "Forbidden"]>;
+export declare class IssueTag extends IssueTag_base {
+}
+declare const PropertyKeyEnumTag_base: S.Literal<["symbol"]>;
+export declare class PropertyKeyEnumTag extends PropertyKeyEnumTag_base {
+}
+declare const PropertyKey_base: S.Union<[typeof S.String, typeof S.Number, S.Struct<{
+    _tag: typeof PropertyKeyEnumTag;
+    key: typeof S.String;
+}>]>;
+export declare class PropertyKey extends PropertyKey_base {
+}
+declare const Issue_base: S.Struct<{
+    _tag: typeof IssueTag;
+    path: S.Array$<typeof PropertyKey>;
+    message: typeof S.String;
+}>;
+export declare class Issue extends Issue_base {
+}
+declare const HttpApiDecodeErrorTag_base: S.Literal<["HttpApiDecodeError"]>;
+export declare class HttpApiDecodeErrorTag extends HttpApiDecodeErrorTag_base {
+}
+declare const HttpApiDecodeError_base: S.Struct<{
+    issues: S.Array$<typeof Issue>;
+    message: typeof S.String;
+    _tag: typeof HttpApiDecodeErrorTag;
+}>;
+export declare class HttpApiDecodeError extends HttpApiDecodeError_base {
+}
+declare const BadRequestTag_base: S.Literal<["BadRequest"]>;
+export declare class BadRequestTag extends BadRequestTag_base {
+}
+declare const BadRequest_base: S.Struct<{
+    message: typeof S.String;
+    _tag: typeof BadRequestTag;
+}>;
+export declare class BadRequest extends BadRequest_base {
+}
+declare const FetchFetch400_base: S.Union<[typeof HttpApiDecodeError, typeof BadRequest]>;
+export declare class FetchFetch400 extends FetchFetch400_base {
+}
+declare const AuthFailedReason_base: S.Literal<["InvalidApiKey", "InvalidToken", "InvalidSession", "InvalidTenant"]>;
+export declare class AuthFailedReason extends AuthFailedReason_base {
+}
+declare const AuthFailedTag_base: S.Literal<["AuthFailed"]>;
+export declare class AuthFailedTag extends AuthFailedTag_base {
+}
+declare const AuthFailed_base: S.Class<AuthFailed, {
+    reason: typeof AuthFailedReason;
+    description: S.optionalWith<S.Union<[typeof S.String, S.Struct<{
+        message: typeof S.String;
+    }>]>, {
+        nullable: true;
+    }>;
+    _tag: typeof AuthFailedTag;
+}, S.Struct.Encoded<{
+    reason: typeof AuthFailedReason;
+    description: S.optionalWith<S.Union<[typeof S.String, S.Struct<{
+        message: typeof S.String;
+    }>]>, {
+        nullable: true;
+    }>;
+    _tag: typeof AuthFailedTag;
+}>, never, {
+    readonly _tag: "AuthFailed";
+} & {
+    readonly reason: "InvalidApiKey" | "InvalidToken" | "InvalidSession" | "InvalidTenant";
+} & {
+    readonly description?: string | {
+        readonly message: string;
+    } | undefined;
+}, {}, {}>;
+export declare class AuthFailed extends AuthFailed_base {
+}
+export declare class DateTimeUtc extends S.String {
+}
+declare const FetchBlockedTag_base: S.Literal<["FetchBlocked"]>;
+export declare class FetchBlockedTag extends FetchBlockedTag_base {
+}
+declare const FetchBlocked_base: S.Struct<{
+    url: typeof S.String;
+    blockedType: S.optionalWith<typeof S.String, {
+        nullable: true;
+    }>;
+    _tag: typeof FetchBlockedTag;
+}>;
+export declare class FetchBlocked extends FetchBlocked_base {
+}
+declare const FetchFetch403_base: S.Union<[S.Struct<{
+    organizationId: S.filter<typeof S.String>;
+    blockedUntil: S.optionalWith<S.Union<[typeof DateTimeUtc, typeof S.Null]>, {
+        nullable: true;
+    }>;
+    _tag: S.Literal<["AccessBlocked"]>;
+}>, typeof FetchBlocked]>;
+export declare class FetchFetch403 extends FetchFetch403_base {
+}
+declare const PayloadTooLargeTag_base: S.Literal<["PayloadTooLarge"]>;
+export declare class PayloadTooLargeTag extends PayloadTooLargeTag_base {
+}
+declare const PayloadTooLarge_base: S.Class<PayloadTooLarge, {
+    _tag: typeof PayloadTooLargeTag;
+}, S.Struct.Encoded<{
+    _tag: typeof PayloadTooLargeTag;
+}>, never, {
+    readonly _tag: "PayloadTooLarge";
+}, {}, {}>;
+export declare class PayloadTooLarge extends PayloadTooLarge_base {
+}
+declare const TooManyRequestsTag_base: S.Literal<["TooManyRequests"]>;
+export declare class TooManyRequestsTag extends TooManyRequestsTag_base {
+}
+declare const TooManyRequests_base: S.Class<TooManyRequests, {
+    _tag: typeof TooManyRequestsTag;
+}, S.Struct.Encoded<{
+    _tag: typeof TooManyRequestsTag;
+}>, never, {
+    readonly _tag: "TooManyRequests";
+}, {}, {}>;
+export declare class TooManyRequests extends TooManyRequests_base {
+}
+declare const InternalErrorTag_base: S.Literal<["InternalError"]>;
+export declare class InternalErrorTag extends InternalErrorTag_base {
+}
+declare const InternalError_base: S.Class<InternalError, {
+    _tag: typeof InternalErrorTag;
+}, S.Struct.Encoded<{
+    _tag: typeof InternalErrorTag;
+}>, never, {
+    readonly _tag: "InternalError";
+}, {}, {}>;
+export declare class InternalError extends InternalError_base {
+}
+declare const ServiceUnavailableTag_base: S.Literal<["ServiceUnavailable"]>;
+export declare class ServiceUnavailableTag extends ServiceUnavailableTag_base {
+}
+declare const ServiceUnavailable_base: S.Class<ServiceUnavailable, {
+    _tag: typeof ServiceUnavailableTag;
+}, S.Struct.Encoded<{
+    _tag: typeof ServiceUnavailableTag;
+}>, never, {
+    readonly _tag: "ServiceUnavailable";
+}, {}, {}>;
+export declare class ServiceUnavailable extends ServiceUnavailable_base {
+}
+declare const FetchFetchJsonParams_base: S.Struct<{
+    include: S.optionalWith<typeof S.String, {
+        nullable: true;
+    }>;
+}>;
+export declare class FetchFetchJsonParams extends FetchFetchJsonParams_base {
+}
+declare const FetchFetchJsonRequest_base: S.Class<FetchFetchJsonRequest, {
+    url: typeof S.String;
+    include: S.optionalWith<S.Struct<{
+        html: S.optionalWith<S.Union<[typeof S.Boolean, S.Record$<typeof S.String, typeof S.Unknown>]>, {
+            nullable: true;
+        }>;
+        markdown: S.optionalWith<S.Union<[typeof S.Boolean, S.Record$<typeof S.String, typeof S.Unknown>]>, {
+            nullable: true;
+        }>;
+        screenshot: S.optionalWith<S.Union<[typeof S.Boolean, S.Struct<{
+            fullPage: S.optionalWith<typeof S.Boolean, {
+                nullable: true;
+            }>;
+        }>]>, {
+            nullable: true;
+        }>;
+        summary: S.optionalWith<S.Union<[typeof S.Boolean, S.Struct<{
+            prompt: S.optionalWith<S.filter<typeof S.String>, {
+                nullable: true;
+            }>;
+        }>]>, {
+            nullable: true;
+        }>;
+        links: S.optionalWith<S.Union<[typeof S.Boolean, S.Struct<{
+            skipEmptyText: S.optionalWith<typeof S.Boolean, {
+                nullable: true;
+            }>;
+            includeNavigation: S.optionalWith<typeof S.Boolean, {
+                nullable: true;
+            }>;
+        }>]>, {
+            nullable: true;
+        }>;
+        meta: S.optionalWith<typeof S.Boolean, {
+            nullable: true;
+            default: () => false;
+        }>;
+        response: S.optionalWith<typeof S.Boolean, {
+            nullable: true;
+            default: () => false;
+        }>;
+        json: S.optionalWith<typeof S.Boolean, {
+            nullable: true;
+            default: () => false;
+        }>;
+        appendix: S.optionalWith<typeof S.Boolean, {
+            nullable: true;
+        }>;
+    }>, {
+        nullable: true;
+    }>;
+    search: S.optionalWith<S.Struct<{
+        query: typeof S.String;
+        maxResults: S.optionalWith<S.filter<S.filter<typeof S.Int>>, {
+            nullable: true;
+            default: () => 5;
+        }>;
+        minScore: S.optionalWith<S.filter<S.filter<typeof S.Number>>, {
+            nullable: true;
+            default: () => 0.6;
+        }>;
+    }>, {
+        nullable: true;
+    }>;
+    browserConfig: S.optionalWith<S.Struct<{
+        scrollFullPage: S.optionalWith<typeof S.Boolean, {
+            nullable: true;
+            default: () => false;
+        }>;
+    }>, {
+        nullable: true;
+    }>;
+}, S.Struct.Encoded<{
+    url: typeof S.String;
+    include: S.optionalWith<S.Struct<{
+        html: S.optionalWith<S.Union<[typeof S.Boolean, S.Record$<typeof S.String, typeof S.Unknown>]>, {
+            nullable: true;
+        }>;
+        markdown: S.optionalWith<S.Union<[typeof S.Boolean, S.Record$<typeof S.String, typeof S.Unknown>]>, {
+            nullable: true;
+        }>;
+        screenshot: S.optionalWith<S.Union<[typeof S.Boolean, S.Struct<{
+            fullPage: S.optionalWith<typeof S.Boolean, {
+                nullable: true;
+            }>;
+        }>]>, {
+            nullable: true;
+        }>;
+        summary: S.optionalWith<S.Union<[typeof S.Boolean, S.Struct<{
+            prompt: S.optionalWith<S.filter<typeof S.String>, {
+                nullable: true;
+            }>;
+        }>]>, {
+            nullable: true;
+        }>;
+        links: S.optionalWith<S.Union<[typeof S.Boolean, S.Struct<{
+            skipEmptyText: S.optionalWith<typeof S.Boolean, {
+                nullable: true;
+            }>;
+            includeNavigation: S.optionalWith<typeof S.Boolean, {
+                nullable: true;
+            }>;
+        }>]>, {
+            nullable: true;
+        }>;
+        meta: S.optionalWith<typeof S.Boolean, {
+            nullable: true;
+            default: () => false;
+        }>;
+        response: S.optionalWith<typeof S.Boolean, {
+            nullable: true;
+            default: () => false;
+        }>;
+        json: S.optionalWith<typeof S.Boolean, {
+            nullable: true;
+            default: () => false;
+        }>;
+        appendix: S.optionalWith<typeof S.Boolean, {
+            nullable: true;
+        }>;
+    }>, {
+        nullable: true;
+    }>;
+    search: S.optionalWith<S.Struct<{
+        query: typeof S.String;
+        maxResults: S.optionalWith<S.filter<S.filter<typeof S.Int>>, {
+            nullable: true;
+            default: () => 5;
+        }>;
+        minScore: S.optionalWith<S.filter<S.filter<typeof S.Number>>, {
+            nullable: true;
+            default: () => 0.6;
+        }>;
+    }>, {
+        nullable: true;
+    }>;
+    browserConfig: S.optionalWith<S.Struct<{
+        scrollFullPage: S.optionalWith<typeof S.Boolean, {
+            nullable: true;
+            default: () => false;
+        }>;
+    }>, {
+        nullable: true;
+    }>;
+}>, never, {
+    readonly include?: {
+        readonly html?: boolean | {
+            readonly [x: string]: unknown;
+        } | undefined;
+        readonly markdown?: boolean | {
+            readonly [x: string]: unknown;
+        } | undefined;
+        readonly screenshot?: boolean | {
+            readonly fullPage?: boolean | undefined;
+        } | undefined;
+        readonly summary?: boolean | {
+            readonly prompt?: string | undefined;
+        } | undefined;
+        readonly links?: boolean | {
+            readonly skipEmptyText?: boolean | undefined;
+            readonly includeNavigation?: boolean | undefined;
+        } | undefined;
+        readonly meta: boolean;
+        readonly response: boolean;
+        readonly json: boolean;
+        readonly appendix?: boolean | undefined;
+    } | undefined;
+} & {
+    readonly url: string;
+} & {
+    readonly search?: {
+        readonly query: string;
+        readonly maxResults: number;
+        readonly minScore: number;
+    } | undefined;
+} & {
+    readonly browserConfig?: {
+        readonly scrollFullPage: boolean;
+    } | undefined;
+}, {}, {}>;
+export declare class FetchFetchJsonRequest extends FetchFetchJsonRequest_base {
+}
+declare const FetchObjectModeMetaVersion_base: S.Literal<[1]>;
+export declare class FetchObjectModeMetaVersion extends FetchObjectModeMetaVersion_base {
+}
+declare const FetchObjectModeAppendixLinks_base: S.Struct<{
+    sameDomain: typeof S.Number;
+    external: typeof S.Number;
+}>;
+export declare class FetchObjectModeAppendixLinks extends FetchObjectModeAppendixLinks_base {
+}
+declare const FetchObjectModeAppendixHint_base: S.Struct<{
+    url: typeof S.String;
+    links: typeof FetchObjectModeAppendixLinks;
+}>;
+export declare class FetchObjectModeAppendixHint extends FetchObjectModeAppendixHint_base {
+}
+declare const FetchObjectModeStateJsonHint_base: S.Struct<{
+    moreTokens: typeof S.Number;
+}>;
+export declare class FetchObjectModeStateJsonHint extends FetchObjectModeStateJsonHint_base {
+}
+declare const FetchObjectModeMarkdownHint_base: S.Struct<{
+    url: typeof S.String;
+    moreTokens: typeof S.Number;
+}>;
+export declare class FetchObjectModeMarkdownHint extends FetchObjectModeMarkdownHint_base {
+}
+declare const FetchObjectModeMeta_base: S.Struct<{
+    version: typeof FetchObjectModeMetaVersion;
+    url: typeof S.String;
+    capturedAt: typeof S.String;
+    snapshotId: typeof S.String;
+    lang: typeof S.String;
+    pageType: typeof S.String;
+    playground: typeof S.String;
+    title: S.optionalWith<typeof S.String, {
+        nullable: true;
+    }>;
+    finalUrl: S.optionalWith<typeof S.String, {
+        nullable: true;
+    }>;
+    canonical: S.optionalWith<typeof S.String, {
+        nullable: true;
+    }>;
+    description: S.optionalWith<typeof S.String, {
+        nullable: true;
+    }>;
+    author: S.optionalWith<typeof S.String, {
+        nullable: true;
+    }>;
+    createdAt: S.optionalWith<typeof S.String, {
+        nullable: true;
+    }>;
+    updatedAt: S.optionalWith<typeof S.String, {
+        nullable: true;
+    }>;
+    image: S.optionalWith<typeof S.String, {
+        nullable: true;
+    }>;
+    paginationNext: S.optionalWith<typeof S.String, {
+        nullable: true;
+    }>;
+    appendix: S.optionalWith<typeof FetchObjectModeAppendixHint, {
+        nullable: true;
+    }>;
+    stateJson: S.optionalWith<typeof FetchObjectModeStateJsonHint, {
+        nullable: true;
+    }>;
+    markdown: S.optionalWith<typeof FetchObjectModeMarkdownHint, {
+        nullable: true;
+    }>;
+    blocked: S.optionalWith<typeof S.String, {
+        nullable: true;
+    }>;
+    loadingStatus: S.optionalWith<typeof S.String, {
+        nullable: true;
+    }>;
+}>;
+export declare class FetchObjectModeMeta extends FetchObjectModeMeta_base {
+}
+declare const FetchObjectModeEvidenceKind_base: S.Literal<["inline", "network"]>;
+export declare class FetchObjectModeEvidenceKind extends FetchObjectModeEvidenceKind_base {
+}
+declare const FetchObjectModeEvidenceRole_base: S.Literal<["ld+json", "next-data", "nuxt", "apollo-state", "initial-state", "application-json", "script-tag", "data-attribute", "network-json", "network-response", "other"]>;
+export declare class FetchObjectModeEvidenceRole extends FetchObjectModeEvidenceRole_base {
+}
+declare const FetchObjectModeEvidence_base: S.Struct<{
+    id: typeof S.Number;
+    kind: typeof FetchObjectModeEvidenceKind;
+    role: typeof FetchObjectModeEvidenceRole;
+    score: typeof S.Number;
+    url: S.optionalWith<typeof S.String, {
+        nullable: true;
+    }>;
+    method: S.optionalWith<typeof S.String, {
+        nullable: true;
+    }>;
+    moreTokens: S.optionalWith<typeof S.Number, {
+        nullable: true;
+    }>;
+    keys: S.optionalWith<S.Array$<typeof S.String>, {
+        nullable: true;
+    }>;
+}>;
+export declare class FetchObjectModeEvidence extends FetchObjectModeEvidence_base {
+}
+declare const FetchAssetReferenceKind_base: S.Literal<["data-url"]>;
+export declare class FetchAssetReferenceKind extends FetchAssetReferenceKind_base {
+}
+declare const FetchAssetReference_base: S.Struct<{
+    id: typeof S.String;
+    kind: typeof FetchAssetReferenceKind;
+    placeholder: typeof S.String;
+    archiveKey: typeof S.String;
+    mimeType: typeof S.String;
+    sha256: typeof S.String;
+    bytes: typeof S.Number;
+}>;
+export declare class FetchAssetReference extends FetchAssetReference_base {
+}
+declare const CaptureTelemetryInfoRequestedStyleMode_base: S.Literal<["compat_full", "native_default"]>;
+export declare class CaptureTelemetryInfoRequestedStyleMode extends CaptureTelemetryInfoRequestedStyleMode_base {
+}
+declare const CaptureTelemetryInfoSelected_base: S.Literal<["rust"]>;
+export declare class CaptureTelemetryInfoSelected extends CaptureTelemetryInfoSelected_base {
+}
+declare const CaptureTelemetryInfoActual_base: S.Literal<["rust"]>;
+export declare class CaptureTelemetryInfoActual extends CaptureTelemetryInfoActual_base {
+}
+declare const CaptureTelemetryInfoActualStyleMode_base: S.Literal<["compat_full", "native_default"]>;
+export declare class CaptureTelemetryInfoActualStyleMode extends CaptureTelemetryInfoActualStyleMode_base {
+}
+declare const CaptureTelemetryInfoIconBackendDecision_base: S.Literal<["cpu", "remote_gpu"]>;
+export declare class CaptureTelemetryInfoIconBackendDecision extends CaptureTelemetryInfoIconBackendDecision_base {
+}
+declare const CaptureTelemetryInfo_base: S.Struct<{
+    requestedStyleMode: S.optionalWith<typeof CaptureTelemetryInfoRequestedStyleMode, {
+        nullable: true;
+    }>;
+    selected: typeof CaptureTelemetryInfoSelected;
+    actual: typeof CaptureTelemetryInfoActual;
+    actualStyleMode: S.optionalWith<typeof CaptureTelemetryInfoActualStyleMode, {
+        nullable: true;
+    }>;
+    rolloutApplied: typeof S.Boolean;
+    preparedSessionHit: S.optionalWith<typeof S.Boolean, {
+        nullable: true;
+    }>;
+    nativePoolHit: S.optionalWith<typeof S.Boolean, {
+        nullable: true;
+    }>;
+    preparedPageHit: S.optionalWith<typeof S.Boolean, {
+        nullable: true;
+    }>;
+    nativePoolCapacity: S.optionalWith<typeof S.Number, {
+        nullable: true;
+    }>;
+    nativePoolProfile: S.optionalWith<typeof S.String, {
+        nullable: true;
+    }>;
+    poolHit: S.optionalWith<typeof S.Boolean, {
+        nullable: true;
+    }>;
+    connectMs: S.optionalWith<typeof S.Number, {
+        nullable: true;
+    }>;
+    warmConnectionAgeMs: S.optionalWith<typeof S.Number, {
+        nullable: true;
+    }>;
+    iconBackendDecision: S.optionalWith<typeof CaptureTelemetryInfoIconBackendDecision, {
+        nullable: true;
+    }>;
+}>;
+export declare class CaptureTelemetryInfo extends CaptureTelemetryInfo_base {
+}
+declare const FetchSearchSnippetLocation_base: S.Struct<{
+    markdownBlockId: S.optionalWith<typeof S.String, {
+        nullable: true;
+    }>;
+    nodeIds: S.optionalWith<S.Array$<typeof S.Number>, {
+        nullable: true;
+    }>;
+    stateJsonSourceId: S.optionalWith<typeof S.Number, {
+        nullable: true;
+    }>;
+    jsonPath: S.optionalWith<typeof S.String, {
+        nullable: true;
+    }>;
+}>;
+export declare class FetchSearchSnippetLocation extends FetchSearchSnippetLocation_base {
+}
+declare const FetchSearchSourceMetaSource_base: S.Literal<["markdown", "appendix", "statejson"]>;
+export declare class FetchSearchSourceMetaSource extends FetchSearchSourceMetaSource_base {
+}
+declare const FetchSearchSourceMetaRanker_base: S.Literal<["zeroentropy", "local_lexical"]>;
+export declare class FetchSearchSourceMetaRanker extends FetchSearchSourceMetaRanker_base {
+}
+declare const FetchSearchSourceMetaFallbackReason_base: S.Literal<["timeout", "error"]>;
+export declare class FetchSearchSourceMetaFallbackReason extends FetchSearchSourceMetaFallbackReason_base {
+}
+declare const FetchSearchSourceMeta_base: S.Struct<{
+    source: typeof FetchSearchSourceMetaSource;
+    chunkCount: S.filter<typeof S.Int>;
+    batchCount: S.filter<typeof S.Int>;
+    ranker: typeof FetchSearchSourceMetaRanker;
+    fallback: typeof S.Boolean;
+    fallbackReason: S.optionalWith<typeof FetchSearchSourceMetaFallbackReason, {
+        nullable: true;
+    }>;
+    durationMs: S.filter<typeof S.Number>;
+}>;
+export declare class FetchSearchSourceMeta extends FetchSearchSourceMeta_base {
+}
+declare const FetchSearchMeta_base: S.Struct<{
+    durationMs: S.filter<typeof S.Number>;
+    sources: S.Array$<typeof FetchSearchSourceMeta>;
+}>;
+export declare class FetchSearchMeta extends FetchSearchMeta_base {
+}
+declare const FetchSearchResult_base: S.Struct<{
+    query: typeof S.String;
+    snippets: S.Array$<S.Struct<{
+        type: S.optionalWith<S.Literal<["text"]>, {
+            nullable: true;
+            default: () => "text";
+        }>;
+        source: S.Literal<["markdown", "appendix", "statejson"]>;
+        text: typeof S.String;
+        score: S.filter<S.filter<typeof S.Number>>;
+        location: S.optionalWith<typeof FetchSearchSnippetLocation, {
+            nullable: true;
+        }>;
+    }>>;
+    meta: S.optionalWith<typeof FetchSearchMeta, {
+        nullable: true;
+    }>;
+}>;
+export declare class FetchSearchResult extends FetchSearchResult_base {
+}
+declare const FetchObjectModeResult_base: S.Class<FetchObjectModeResult, {
+    meta: typeof FetchObjectModeMeta;
+    markdown: typeof S.String;
+    json: S.Array$<typeof FetchObjectModeEvidence>;
+    data: S.optionalWith<S.Struct<{
+        assets: S.optionalWith<S.Array$<typeof FetchAssetReference>, {
+            nullable: true;
+        }>;
+        captureTelemetry: S.optionalWith<typeof CaptureTelemetryInfo, {
+            nullable: true;
+        }>;
+        search: S.optionalWith<typeof FetchSearchResult, {
+            nullable: true;
+        }>;
+        screenshot: S.optionalWith<S.Struct<{
+            url: typeof S.String;
+            fullPage: typeof S.Boolean;
+        }>, {
+            nullable: true;
+        }>;
+    }>, {
+        nullable: true;
+    }>;
+}, S.Struct.Encoded<{
+    meta: typeof FetchObjectModeMeta;
+    markdown: typeof S.String;
+    json: S.Array$<typeof FetchObjectModeEvidence>;
+    data: S.optionalWith<S.Struct<{
+        assets: S.optionalWith<S.Array$<typeof FetchAssetReference>, {
+            nullable: true;
+        }>;
+        captureTelemetry: S.optionalWith<typeof CaptureTelemetryInfo, {
+            nullable: true;
+        }>;
+        search: S.optionalWith<typeof FetchSearchResult, {
+            nullable: true;
+        }>;
+        screenshot: S.optionalWith<S.Struct<{
+            url: typeof S.String;
+            fullPage: typeof S.Boolean;
+        }>, {
+            nullable: true;
+        }>;
+    }>, {
+        nullable: true;
+    }>;
+}>, never, {
+    readonly markdown: string;
+} & {
+    readonly meta: {
+        readonly url: string;
+        readonly markdown?: {
+            readonly url: string;
+            readonly moreTokens: number;
+        } | undefined;
+        readonly appendix?: {
+            readonly url: string;
+            readonly links: {
+                readonly sameDomain: number;
+                readonly external: number;
+            };
+        } | undefined;
+        readonly description?: string | undefined;
+        readonly version: 1;
+        readonly capturedAt: string;
+        readonly snapshotId: string;
+        readonly lang: string;
+        readonly pageType: string;
+        readonly playground: string;
+        readonly title?: string | undefined;
+        readonly finalUrl?: string | undefined;
+        readonly canonical?: string | undefined;
+        readonly author?: string | undefined;
+        readonly createdAt?: string | undefined;
+        readonly updatedAt?: string | undefined;
+        readonly image?: string | undefined;
+        readonly paginationNext?: string | undefined;
+        readonly stateJson?: {
+            readonly moreTokens: number;
+        } | undefined;
+        readonly blocked?: string | undefined;
+        readonly loadingStatus?: string | undefined;
+    };
+} & {
+    readonly json: readonly {
+        readonly keys?: readonly string[] | undefined;
+        readonly url?: string | undefined;
+        readonly moreTokens?: number | undefined;
+        readonly id: number;
+        readonly kind: "inline" | "network";
+        readonly role: "ld+json" | "next-data" | "nuxt" | "apollo-state" | "initial-state" | "application-json" | "script-tag" | "data-attribute" | "network-json" | "network-response" | "other";
+        readonly score: number;
+        readonly method?: string | undefined;
+    }[];
+} & {
+    readonly data?: {
+        readonly search?: {
+            readonly meta?: {
+                readonly durationMs: number;
+                readonly sources: readonly {
+                    readonly source: "markdown" | "appendix" | "statejson";
+                    readonly chunkCount: number;
+                    readonly batchCount: number;
+                    readonly ranker: "zeroentropy" | "local_lexical";
+                    readonly fallback: boolean;
+                    readonly fallbackReason?: "timeout" | "error" | undefined;
+                    readonly durationMs: number;
+                }[];
+            } | undefined;
+            readonly query: string;
+            readonly snippets: readonly {
+                readonly score: number;
+                readonly source: "markdown" | "appendix" | "statejson";
+                readonly type: "text";
+                readonly text: string;
+                readonly location?: {
+                    readonly markdownBlockId?: string | undefined;
+                    readonly nodeIds?: readonly number[] | undefined;
+                    readonly stateJsonSourceId?: number | undefined;
+                    readonly jsonPath?: string | undefined;
+                } | undefined;
+            }[];
+        } | undefined;
+        readonly screenshot?: {
+            readonly url: string;
+            readonly fullPage: boolean;
+        } | undefined;
+        readonly assets?: readonly {
+            readonly id: string;
+            readonly kind: "data-url";
+            readonly placeholder: string;
+            readonly archiveKey: string;
+            readonly mimeType: string;
+            readonly sha256: string;
+            readonly bytes: number;
+        }[] | undefined;
+        readonly captureTelemetry?: {
+            readonly requestedStyleMode?: "compat_full" | "native_default" | undefined;
+            readonly selected: "rust";
+            readonly actual: "rust";
+            readonly actualStyleMode?: "compat_full" | "native_default" | undefined;
+            readonly rolloutApplied: boolean;
+            readonly preparedSessionHit?: boolean | undefined;
+            readonly nativePoolHit?: boolean | undefined;
+            readonly preparedPageHit?: boolean | undefined;
+            readonly nativePoolCapacity?: number | undefined;
+            readonly nativePoolProfile?: string | undefined;
+            readonly poolHit?: boolean | undefined;
+            readonly connectMs?: number | undefined;
+            readonly warmConnectionAgeMs?: number | undefined;
+            readonly iconBackendDecision?: "cpu" | "remote_gpu" | undefined;
+        } | undefined;
+    } | undefined;
+}, {}, {}>;
+export declare class FetchObjectModeResult extends FetchObjectModeResult_base {
+}
+declare const FetchFetchJson400_base: S.Union<[typeof HttpApiDecodeError, typeof BadRequest]>;
+export declare class FetchFetchJson400 extends FetchFetchJson400_base {
+}
+declare const FetchFetchJson403_base: S.Union<[S.Struct<{
+    organizationId: S.filter<typeof S.String>;
+    blockedUntil: S.optionalWith<S.Union<[typeof DateTimeUtc, typeof S.Null]>, {
+        nullable: true;
+    }>;
+    _tag: S.Literal<["AccessBlocked"]>;
+}>, typeof FetchBlocked]>;
+export declare class FetchFetchJson403 extends FetchFetchJson403_base {
+}
+declare const IncludeHtmlConfig_base: S.Record$<typeof S.String, typeof S.Unknown>;
+export declare class IncludeHtmlConfig extends IncludeHtmlConfig_base {
+}
+declare const IncludeMarkdownConfig_base: S.Record$<typeof S.String, typeof S.Unknown>;
+export declare class IncludeMarkdownConfig extends IncludeMarkdownConfig_base {
+}
+declare const IncludeScreenshotConfig_base: S.Struct<{
+    fullPage: S.optionalWith<typeof S.Boolean, {
+        nullable: true;
+    }>;
+}>;
+export declare class IncludeScreenshotConfig extends IncludeScreenshotConfig_base {
+}
+declare const FetchFetchSearchRequest_base: S.Class<FetchFetchSearchRequest, {
+    snapshotId: S.filter<typeof S.String>;
+    search: S.Struct<{
+        query: typeof S.String;
+        maxResults: S.optionalWith<S.filter<S.filter<typeof S.Int>>, {
+            nullable: true;
+            default: () => 5;
+        }>;
+        minScore: S.optionalWith<S.filter<S.filter<typeof S.Number>>, {
+            nullable: true;
+            default: () => 0.6;
+        }>;
+    }>;
+    include: S.optionalWith<S.Struct<{
+        html: S.optionalWith<S.Union<[typeof S.Boolean, typeof IncludeHtmlConfig]>, {
+            nullable: true;
+        }>;
+        markdown: S.optionalWith<S.Union<[typeof S.Boolean, typeof IncludeMarkdownConfig]>, {
+            nullable: true;
+        }>;
+        screenshot: S.optionalWith<S.Union<[typeof S.Boolean, typeof IncludeScreenshotConfig]>, {
+            nullable: true;
+        }>;
+        summary: S.optionalWith<S.Union<[typeof S.Boolean, S.Struct<{
+            prompt: S.optionalWith<S.filter<typeof S.String>, {
+                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<[typeof S.Boolean, S.Struct<{
+            sameDomainOnly: S.optionalWith<typeof S.Boolean, {
+                nullable: true;
+                default: () => true;
+            }>;
+            includePatterns: S.optionalWith<S.Array$<typeof S.String>, {
+                nullable: true;
+            }>;
+            excludePatterns: S.optionalWith<S.Array$<typeof S.String>, {
+                nullable: true;
+            }>;
+        }>]>, {
+            nullable: true;
+        }>;
+        meta: S.optionalWith<typeof S.Boolean, {
+            nullable: true;
+            default: () => true;
+        }>;
+        response: S.optionalWith<S.Struct<{
+            includeHeaders: S.optionalWith<typeof S.Boolean, {
+                nullable: true;
+                default: () => false;
+            }>;
+        }>, {
+            nullable: true;
+        }>;
+        json: S.optionalWith<typeof S.Boolean, {
+            nullable: true;
+            default: () => false;
+        }>;
+        appendix: S.optionalWith<typeof S.Boolean, {
+            nullable: true;
+        }>;
+    }>, {
+        nullable: true;
+    }>;
+}, S.Struct.Encoded<{
+    snapshotId: S.filter<typeof S.String>;
+    search: S.Struct<{
+        query: typeof S.String;
+        maxResults: S.optionalWith<S.filter<S.filter<typeof S.Int>>, {
+            nullable: true;
+            default: () => 5;
+        }>;
+        minScore: S.optionalWith<S.filter<S.filter<typeof S.Number>>, {
+            nullable: true;
+            default: () => 0.6;
+        }>;
+    }>;
+    include: S.optionalWith<S.Struct<{
+        html: S.optionalWith<S.Union<[typeof S.Boolean, typeof IncludeHtmlConfig]>, {
+            nullable: true;
+        }>;
+        markdown: S.optionalWith<S.Union<[typeof S.Boolean, typeof IncludeMarkdownConfig]>, {
+            nullable: true;
+        }>;
+        screenshot: S.optionalWith<S.Union<[typeof S.Boolean, typeof IncludeScreenshotConfig]>, {
+            nullable: true;
+        }>;
+        summary: S.optionalWith<S.Union<[typeof S.Boolean, S.Struct<{
+            prompt: S.optionalWith<S.filter<typeof S.String>, {
+                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<[typeof S.Boolean, S.Struct<{
+            sameDomainOnly: S.optionalWith<typeof S.Boolean, {
+                nullable: true;
+                default: () => true;
+            }>;
+            includePatterns: S.optionalWith<S.Array$<typeof S.String>, {
+                nullable: true;
+            }>;
+            excludePatterns: S.optionalWith<S.Array$<typeof S.String>, {
+                nullable: true;
+            }>;
+        }>]>, {
+            nullable: true;
+        }>;
+        meta: S.optionalWith<typeof S.Boolean, {
+            nullable: true;
+            default: () => true;
+        }>;
+        response: S.optionalWith<S.Struct<{
+            includeHeaders: S.optionalWith<typeof S.Boolean, {
+                nullable: true;
+                default: () => false;
+            }>;
+        }>, {
+            nullable: true;
+        }>;
+        json: S.optionalWith<typeof S.Boolean, {
+            nullable: true;
+            default: () => false;
+        }>;
+        appendix: S.optionalWith<typeof S.Boolean, {
+            nullable: true;
+        }>;
+    }>, {
+        nullable: true;
+    }>;
+}>, never, {
+    readonly include?: {
+        readonly html?: boolean | {
+            readonly [x: string]: unknown;
+        } | undefined;
+        readonly markdown?: boolean | {
+            readonly [x: string]: unknown;
+        } | undefined;
+        readonly screenshot?: boolean | {
+            readonly fullPage?: boolean | undefined;
+        } | undefined;
+        readonly summary?: boolean | {
+            readonly prompt: string;
+        } | undefined;
+        readonly links?: boolean | {
+            readonly sameDomainOnly: boolean;
+            readonly includePatterns?: readonly string[] | undefined;
+            readonly excludePatterns?: readonly string[] | undefined;
+        } | undefined;
+        readonly meta: boolean;
+        readonly response?: {
+            readonly includeHeaders: boolean;
+        } | undefined;
+        readonly json: boolean;
+        readonly appendix?: boolean | undefined;
+    } | undefined;
+} & {
+    readonly search: {
+        readonly query: string;
+        readonly maxResults: number;
+        readonly minScore: number;
+    };
+} & {
+    readonly snapshotId: string;
+}, {}, {}>;
+export declare class FetchFetchSearchRequest extends FetchFetchSearchRequest_base {
+}
+export declare class URL extends S.String {
+}
+declare const ResponseInfo_base: S.Struct<{
+    url: typeof S.String;
+    requestedUrl: S.optionalWith<typeof URL, {
+        nullable: true;
+    }>;
+    originStatusCode: S.optionalWith<typeof S.Number, {
+        nullable: true;
+    }>;
+    redirectStatusCode: S.optionalWith<typeof S.Number, {
+        nullable: true;
+    }>;
+    headers: S.optionalWith<S.Struct<{}>, {
+        nullable: true;
+    }>;
+}>;
+export declare class ResponseInfo extends ResponseInfo_base {
+}
+declare const FetchSnapshotSearchResult_base: S.Class<FetchSnapshotSearchResult, {
+    snapshotId: S.filter<typeof S.String>;
+    response: typeof ResponseInfo;
+    search: typeof FetchSearchResult;
+    durationMs: S.filter<typeof S.Number>;
+}, S.Struct.Encoded<{
+    snapshotId: S.filter<typeof S.String>;
+    response: typeof ResponseInfo;
+    search: typeof FetchSearchResult;
+    durationMs: S.filter<typeof S.Number>;
+}>, never, {
+    readonly search: {
+        readonly meta?: {
+            readonly durationMs: number;
+            readonly sources: readonly {
+                readonly source: "markdown" | "appendix" | "statejson";
+                readonly chunkCount: number;
+                readonly batchCount: number;
+                readonly ranker: "zeroentropy" | "local_lexical";
+                readonly fallback: boolean;
+                readonly fallbackReason?: "timeout" | "error" | undefined;
+                readonly durationMs: number;
+            }[];
+        } | undefined;
+        readonly query: string;
+        readonly snippets: readonly {
+            readonly score: number;
+            readonly source: "markdown" | "appendix" | "statejson";
+            readonly type: "text";
+            readonly text: string;
+            readonly location?: {
+                readonly markdownBlockId?: string | undefined;
+                readonly nodeIds?: readonly number[] | undefined;
+                readonly stateJsonSourceId?: number | undefined;
+                readonly jsonPath?: string | undefined;
+            } | undefined;
+        }[];
+    };
+} & {
+    readonly response: {
+        readonly url: string;
+        readonly requestedUrl?: string | undefined;
+        readonly originStatusCode?: number | undefined;
+        readonly redirectStatusCode?: number | undefined;
+        readonly headers?: {} | undefined;
+    };
+} & {
+    readonly snapshotId: string;
+} & {
+    readonly durationMs: number;
+}, {}, {}>;
+export declare class FetchSnapshotSearchResult extends FetchSnapshotSearchResult_base {
+}
+declare const FetchFetchSearch400_base: S.Union<[typeof HttpApiDecodeError, typeof BadRequest]>;
+export declare class FetchFetchSearch400 extends FetchFetchSearch400_base {
+}
+declare const FetchFetchSearch403Tag_base: S.Literal<["AccessBlocked"]>;
+export declare class FetchFetchSearch403Tag extends FetchFetchSearch403Tag_base {
+}
+declare const FetchFetchSearch403_base: S.Struct<{
+    organizationId: S.filter<typeof S.String>;
+    blockedUntil: S.optionalWith<S.Union<[typeof DateTimeUtc, typeof S.Null]>, {
+        nullable: true;
+    }>;
+    _tag: typeof FetchFetchSearch403Tag;
+}>;
+export declare class FetchFetchSearch403 extends FetchFetchSearch403_base {
+}
+declare const NonEmptyString_base: S.filter<typeof S.String>;
+export declare class NonEmptyString extends NonEmptyString_base {
+}
+declare const FetchSnapshotSearchNotFoundTag_base: S.Literal<["FetchSnapshotSearchNotFound"]>;
+export declare class FetchSnapshotSearchNotFoundTag extends FetchSnapshotSearchNotFoundTag_base {
+}
+declare const FetchSnapshotSearchNotFound_base: S.Class<FetchSnapshotSearchNotFound, {
+    snapshotId: typeof NonEmptyString;
+    _tag: typeof FetchSnapshotSearchNotFoundTag;
+}, S.Struct.Encoded<{
+    snapshotId: typeof NonEmptyString;
+    _tag: typeof FetchSnapshotSearchNotFoundTag;
+}>, never, {
+    readonly _tag: "FetchSnapshotSearchNotFound";
+} & {
+    readonly snapshotId: string;
+}, {}, {}>;
+export declare class FetchSnapshotSearchNotFound extends FetchSnapshotSearchNotFound_base {
+}
+declare const FetchBatchedRequest_base: S.Class<FetchBatchedRequest, {
+    urls: S.NonEmptyArray<typeof S.String>;
+    include: S.optionalWith<S.Struct<{
+        html: S.optionalWith<S.Union<[typeof S.Boolean, typeof IncludeHtmlConfig]>, {
+            nullable: true;
+        }>;
+        markdown: S.optionalWith<S.Union<[typeof S.Boolean, typeof IncludeMarkdownConfig]>, {
+            nullable: true;
+        }>;
+        screenshot: S.optionalWith<S.Union<[typeof S.Boolean, typeof IncludeScreenshotConfig]>, {
+            nullable: true;
+        }>;
+        summary: S.optionalWith<S.Union<[typeof S.Boolean, S.Struct<{
+            prompt: S.optionalWith<S.filter<typeof S.String>, {
+                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<[typeof S.Boolean, S.Struct<{
+            sameDomainOnly: S.optionalWith<typeof S.Boolean, {
+                nullable: true;
+                default: () => true;
+            }>;
+            includePatterns: S.optionalWith<S.Array$<typeof S.String>, {
+                nullable: true;
+            }>;
+            excludePatterns: S.optionalWith<S.Array$<typeof S.String>, {
+                nullable: true;
+            }>;
+        }>]>, {
+            nullable: true;
+        }>;
+        meta: S.optionalWith<typeof S.Boolean, {
+            nullable: true;
+            default: () => true;
+        }>;
+        response: S.optionalWith<S.Struct<{
+            includeHeaders: S.optionalWith<typeof S.Boolean, {
+                nullable: true;
+                default: () => false;
+            }>;
+        }>, {
+            nullable: true;
+        }>;
+        json: S.optionalWith<typeof S.Boolean, {
+            nullable: true;
+            default: () => false;
+        }>;
+        appendix: S.optionalWith<typeof S.Boolean, {
+            nullable: true;
+        }>;
+    }>, {
+        nullable: true;
+    }>;
+    browserConfig: S.optionalWith<S.Struct<{
+        scrollFullPage: S.optionalWith<typeof S.Boolean, {
+            nullable: true;
+            default: () => false;
+        }>;
+    }>, {
+        nullable: true;
+    }>;
+}, S.Struct.Encoded<{
+    urls: S.NonEmptyArray<typeof S.String>;
+    include: S.optionalWith<S.Struct<{
+        html: S.optionalWith<S.Union<[typeof S.Boolean, typeof IncludeHtmlConfig]>, {
+            nullable: true;
+        }>;
+        markdown: S.optionalWith<S.Union<[typeof S.Boolean, typeof IncludeMarkdownConfig]>, {
+            nullable: true;
+        }>;
+        screenshot: S.optionalWith<S.Union<[typeof S.Boolean, typeof IncludeScreenshotConfig]>, {
+            nullable: true;
+        }>;
+        summary: S.optionalWith<S.Union<[typeof S.Boolean, S.Struct<{
+            prompt: S.optionalWith<S.filter<typeof S.String>, {
+                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<[typeof S.Boolean, S.Struct<{
+            sameDomainOnly: S.optionalWith<typeof S.Boolean, {
+                nullable: true;
+                default: () => true;
+            }>;
+            includePatterns: S.optionalWith<S.Array$<typeof S.String>, {
+                nullable: true;
+            }>;
+            excludePatterns: S.optionalWith<S.Array$<typeof S.String>, {
+                nullable: true;
+            }>;
+        }>]>, {
+            nullable: true;
+        }>;
+        meta: S.optionalWith<typeof S.Boolean, {
+            nullable: true;
+            default: () => true;
+        }>;
+        response: S.optionalWith<S.Struct<{
+            includeHeaders: S.optionalWith<typeof S.Boolean, {
+                nullable: true;
+                default: () => false;
+            }>;
+        }>, {
+            nullable: true;
+        }>;
+        json: S.optionalWith<typeof S.Boolean, {
+            nullable: true;
+            default: () => false;
+        }>;
+        appendix: S.optionalWith<typeof S.Boolean, {
+            nullable: true;
+        }>;
+    }>, {
+        nullable: true;
+    }>;
+    browserConfig: S.optionalWith<S.Struct<{
+        scrollFullPage: S.optionalWith<typeof S.Boolean, {
+            nullable: true;
+            default: () => false;
+        }>;
+    }>, {
+        nullable: true;
+    }>;
+}>, never, {
+    readonly include?: {
+        readonly html?: boolean | {
+            readonly [x: string]: unknown;
+        } | undefined;
+        readonly markdown?: boolean | {
+            readonly [x: string]: unknown;
+        } | undefined;
+        readonly screenshot?: boolean | {
+            readonly fullPage?: boolean | undefined;
+        } | undefined;
+        readonly summary?: boolean | {
+            readonly prompt: string;
+        } | undefined;
+        readonly links?: boolean | {
+            readonly sameDomainOnly: boolean;
+            readonly includePatterns?: readonly string[] | undefined;
+            readonly excludePatterns?: readonly string[] | undefined;
+        } | undefined;
+        readonly meta: boolean;
+        readonly response?: {
+            readonly includeHeaders: boolean;
+        } | undefined;
+        readonly json: boolean;
+        readonly appendix?: boolean | undefined;
+    } | undefined;
+} & {
+    readonly browserConfig?: {
+        readonly scrollFullPage: boolean;
+    } | undefined;
+} & {
+    readonly urls: readonly [string, ...string[]];
+}, {}, {}>;
+export declare class FetchBatchedRequest extends FetchBatchedRequest_base {
+}
+declare const BatchedRun_base: S.Class<BatchedRun, {
+    id: typeof S.String;
+}, S.Struct.Encoded<{
+    id: typeof S.String;
+}>, never, {
+    readonly id: string;
+}, {}, {}>;
+export declare class BatchedRun extends BatchedRun_base {
+}
+declare const FetchBatched400_base: S.Union<[typeof HttpApiDecodeError, typeof BadRequest]>;
+export declare class FetchBatched400 extends FetchBatched400_base {
+}
+declare const FetchBatched403Tag_base: S.Literal<["AccessBlocked"]>;
+export declare class FetchBatched403Tag extends FetchBatched403Tag_base {
+}
+declare const FetchBatched403_base: S.Struct<{
+    organizationId: S.filter<typeof S.String>;
+    blockedUntil: S.optionalWith<S.Union<[typeof DateTimeUtc, typeof S.Null]>, {
+        nullable: true;
+    }>;
+    _tag: typeof FetchBatched403Tag;
+}>;
+export declare class FetchBatched403 extends FetchBatched403_base {
+}
+declare const FetchGetBatchedParams_base: S.Struct<{
+    limit: S.optionalWith<typeof S.String, {
+        nullable: true;
+    }>;
+    offset: S.optionalWith<typeof S.String, {
+        nullable: true;
+    }>;
+    include: S.optionalWith<typeof S.String, {
+        nullable: true;
+    }>;
+}>;
+export declare class FetchGetBatchedParams extends FetchGetBatchedParams_base {
+}
+declare const BatchedStatusStatus_base: S.Literal<["QUEUED", "RUNNING", "COMPLETED", "FAILED", "CANCELLED"]>;
+export declare class BatchedStatusStatus extends BatchedStatusStatus_base {
+}
+declare const BatchedStatusBatchedStatus_base: S.Literal<["QUEUED", "RUNNING", "COMPLETED", "FAILED", "CANCELLED"]>;
+export declare class BatchedStatusBatchedStatus extends BatchedStatusBatchedStatus_base {
+}
+declare const IconMeta_base: S.Struct<{
+    href: S.filter<typeof S.String>;
+    rel: S.filter<typeof S.String>;
+    type: S.optionalWith<S.filter<typeof S.String>, {
+        nullable: true;
+    }>;
+    sizes: S.optionalWith<S.filter<typeof S.String>, {
+        nullable: true;
+    }>;
+}>;
+export declare class IconMeta extends IconMeta_base {
+}
+declare const OgImage_base: S.Struct<{
+    url: S.filter<typeof S.String>;
+    width: S.optionalWith<typeof S.Number, {
+        nullable: true;
+    }>;
+    height: S.optionalWith<typeof S.Number, {
+        nullable: true;
+    }>;
+    alt: S.optionalWith<typeof S.String, {
+        nullable: true;
+    }>;
+}>;
+export declare class OgImage extends OgImage_base {
+}
+declare const OpenGraphMeta_base: S.Struct<{
+    title: S.optionalWith<typeof S.String, {
+        nullable: true;
+    }>;
+    description: S.optionalWith<typeof S.String, {
+        nullable: true;
+    }>;
+    type: S.optionalWith<S.filter<typeof S.String>, {
+        nullable: true;
+    }>;
+    url: S.optionalWith<S.filter<typeof S.String>, {
+        nullable: true;
+    }>;
+    siteName: S.optionalWith<typeof S.String, {
+        nullable: true;
+    }>;
+    locale: S.optionalWith<typeof S.String, {
+        nullable: true;
+    }>;
+    images: S.optionalWith<S.Array$<typeof OgImage>, {
+        nullable: true;
+    }>;
+}>;
+export declare class OpenGraphMeta extends OpenGraphMeta_base {
+}
+declare const TwitterCardMeta_base: S.Struct<{
+    card: S.optionalWith<S.filter<typeof S.String>, {
+        nullable: true;
+    }>;
+    site: S.optionalWith<typeof S.String, {
+        nullable: true;
+    }>;
+    creator: S.optionalWith<typeof S.String, {
+        nullable: true;
+    }>;
+    title: S.optionalWith<typeof S.String, {
+        nullable: true;
+    }>;
+    description: S.optionalWith<typeof S.String, {
+        nullable: true;
+    }>;
+    image: S.optionalWith<S.filter<typeof S.String>, {
+        nullable: true;
+    }>;
+}>;
+export declare class TwitterCardMeta extends TwitterCardMeta_base {
+}
+declare const PageMeta_base: S.Struct<{
+    title: S.optionalWith<typeof S.String, {
+        nullable: true;
+    }>;
+    description: S.optionalWith<typeof S.String, {
+        nullable: true;
+    }>;
+    canonicalUrl: S.optionalWith<S.filter<typeof S.String>, {
+        nullable: true;
+    }>;
+    language: S.optionalWith<S.filter<typeof S.String>, {
+        nullable: true;
+    }>;
+    charset: S.optionalWith<S.filter<typeof S.String>, {
+        nullable: true;
+    }>;
+    favicon: S.optionalWith<S.filter<typeof S.String>, {
+        nullable: true;
+    }>;
+    icons: S.optionalWith<S.Array$<typeof IconMeta>, {
+        nullable: true;
+    }>;
+    openGraph: S.optionalWith<typeof OpenGraphMeta, {
+        nullable: true;
+    }>;
+    twitter: S.optionalWith<typeof TwitterCardMeta, {
+        nullable: true;
+    }>;
+}>;
+export declare class PageMeta extends PageMeta_base {
+}
+declare const FetchLink_base: S.Struct<{
+    url: typeof S.String;
+    text: S.optionalWith<typeof S.String, {
+        nullable: true;
+    }>;
+}>;
+export declare class FetchLink extends FetchLink_base {
+}
+declare const RenderEnginesInfoCapture_base: S.Literal<["rust"]>;
+export declare class RenderEnginesInfoCapture extends RenderEnginesInfoCapture_base {
+}
+declare const RenderEnginesInfoMarkdown_base: S.Literal<["rust"]>;
+export declare class RenderEnginesInfoMarkdown extends RenderEnginesInfoMarkdown_base {
+}
+declare const RenderEnginesInfoTree_base: S.Literal<["rust"]>;
+export declare class RenderEnginesInfoTree extends RenderEnginesInfoTree_base {
+}
+declare const RenderEnginesInfo_base: S.Struct<{
+    capture: S.optionalWith<typeof RenderEnginesInfoCapture, {
+        nullable: true;
+    }>;
+    markdown: S.optionalWith<typeof RenderEnginesInfoMarkdown, {
+        nullable: true;
+    }>;
+    tree: S.optionalWith<typeof RenderEnginesInfoTree, {
+        nullable: true;
+    }>;
+}>;
+export declare class RenderEnginesInfo extends RenderEnginesInfo_base {
+}
+declare const PaginationMeta_base: S.Struct<{
+    total: typeof S.Number;
+    limit: typeof S.Number;
+    offset: typeof S.Number;
+    hasMore: typeof S.Boolean;
+}>;
+export declare class PaginationMeta extends PaginationMeta_base {
+}
+declare const BatchedStatus_base: S.Class<BatchedStatus, {
+    id: typeof S.String;
+    status: typeof BatchedStatusStatus;
+    batchedStatus: typeof BatchedStatusBatchedStatus;
+    totalUrls: typeof S.Number;
+    results: S.Array$<S.Struct<{
+        data: S.Struct<{
+            response: typeof ResponseInfo;
+            meta: S.optionalWith<typeof PageMeta, {
+                nullable: true;
+            }>;
+            json: S.optionalWith<S.Array$<S.Struct<{}>>, {
+                nullable: true;
+            }>;
+            snapshotId: S.optionalWith<typeof NonEmptyString, {
+                nullable: true;
+            }>;
+            html: S.optionalWith<S.filter<typeof S.String>, {
+                nullable: true;
+            }>;
+            markdown: S.optionalWith<S.filter<typeof S.String>, {
+                nullable: true;
+            }>;
+            screenshot: S.optionalWith<S.Struct<{
+                url: typeof S.String;
+                fullPage: typeof S.Boolean;
+            }>, {
+                nullable: true;
+            }>;
+            summary: S.optionalWith<S.filter<typeof S.String>, {
+                nullable: true;
+            }>;
+            search: S.optionalWith<typeof FetchSearchResult, {
+                nullable: true;
+            }>;
+            links: S.optionalWith<S.Array$<typeof FetchLink>, {
+                nullable: true;
+            }>;
+            appendix: S.optionalWith<S.filter<typeof S.String>, {
+                nullable: true;
+            }>;
+            renderEngines: S.optionalWith<typeof RenderEnginesInfo, {
+                nullable: true;
+            }>;
+            captureTelemetry: S.optionalWith<typeof CaptureTelemetryInfo, {
+                nullable: true;
+            }>;
+            assets: S.optionalWith<S.Array$<typeof FetchAssetReference>, {
+                nullable: true;
+            }>;
+            blocked: S.optionalWith<S.Struct<{
+                blockedType: S.optionalWith<typeof S.String, {
+                    nullable: true;
+                }>;
+            }>, {
+                nullable: true;
+            }>;
+        }>;
+    }>>;
+    pagination: typeof PaginationMeta;
+}, S.Struct.Encoded<{
+    id: typeof S.String;
+    status: typeof BatchedStatusStatus;
+    batchedStatus: typeof BatchedStatusBatchedStatus;
+    totalUrls: typeof S.Number;
+    results: S.Array$<S.Struct<{
+        data: S.Struct<{
+            response: typeof ResponseInfo;
+            meta: S.optionalWith<typeof PageMeta, {
+                nullable: true;
+            }>;
+            json: S.optionalWith<S.Array$<S.Struct<{}>>, {
+                nullable: true;
+            }>;
+            snapshotId: S.optionalWith<typeof NonEmptyString, {
+                nullable: true;
+            }>;
+            html: S.optionalWith<S.filter<typeof S.String>, {
+                nullable: true;
+            }>;
+            markdown: S.optionalWith<S.filter<typeof S.String>, {
+                nullable: true;
+            }>;
+            screenshot: S.optionalWith<S.Struct<{
+                url: typeof S.String;
+                fullPage: typeof S.Boolean;
+            }>, {
+                nullable: true;
+            }>;
+            summary: S.optionalWith<S.filter<typeof S.String>, {
+                nullable: true;
+            }>;
+            search: S.optionalWith<typeof FetchSearchResult, {
+                nullable: true;
+            }>;
+            links: S.optionalWith<S.Array$<typeof FetchLink>, {
+                nullable: true;
+            }>;
+            appendix: S.optionalWith<S.filter<typeof S.String>, {
+                nullable: true;
+            }>;
+            renderEngines: S.optionalWith<typeof RenderEnginesInfo, {
+                nullable: true;
+            }>;
+            captureTelemetry: S.optionalWith<typeof CaptureTelemetryInfo, {
+                nullable: true;
+            }>;
+            assets: S.optionalWith<S.Array$<typeof FetchAssetReference>, {
+                nullable: true;
+            }>;
+            blocked: S.optionalWith<S.Struct<{
+                blockedType: S.optionalWith<typeof S.String, {
+                    nullable: true;
+                }>;
+            }>, {
+                nullable: true;
+            }>;
+        }>;
+    }>>;
+    pagination: typeof PaginationMeta;
+}>, never, {
+    readonly status: "QUEUED" | "RUNNING" | "COMPLETED" | "FAILED" | "CANCELLED";
+} & {
+    readonly id: string;
+} & {
+    readonly batchedStatus: "QUEUED" | "RUNNING" | "COMPLETED" | "FAILED" | "CANCELLED";
+} & {
+    readonly totalUrls: number;
+} & {
+    readonly pagination: {
+        readonly limit: number;
+        readonly offset: number;
+        readonly total: number;
+        readonly hasMore: boolean;
+    };
+} & {
+    readonly results: readonly {
+        readonly data: {
+            readonly search?: {
+                readonly meta?: {
+                    readonly durationMs: number;
+                    readonly sources: readonly {
+                        readonly source: "markdown" | "appendix" | "statejson";
+                        readonly chunkCount: number;
+                        readonly batchCount: number;
+                        readonly ranker: "zeroentropy" | "local_lexical";
+                        readonly fallback: boolean;
+                        readonly fallbackReason?: "timeout" | "error" | undefined;
+                        readonly durationMs: number;
+                    }[];
+                } | undefined;
+                readonly query: string;
+                readonly snippets: readonly {
+                    readonly score: number;
+                    readonly source: "markdown" | "appendix" | "statejson";
+                    readonly type: "text";
+                    readonly text: string;
+                    readonly location?: {
+                        readonly markdownBlockId?: string | undefined;
+                        readonly nodeIds?: readonly number[] | undefined;
+                        readonly stateJsonSourceId?: number | undefined;
+                        readonly jsonPath?: string | undefined;
+                    } | undefined;
+                }[];
+            } | undefined;
+            readonly html?: string | undefined;
+            readonly markdown?: string | undefined;
+            readonly screenshot?: {
+                readonly url: string;
+                readonly fullPage: boolean;
+            } | undefined;
+            readonly summary?: string | undefined;
+            readonly links?: readonly {
+                readonly url: string;
+                readonly text?: string | undefined;
+            }[] | undefined;
+            readonly meta?: {
+                readonly description?: string | undefined;
+                readonly title?: string | undefined;
+                readonly canonicalUrl?: string | undefined;
+                readonly language?: string | undefined;
+                readonly charset?: string | undefined;
+                readonly favicon?: string | undefined;
+                readonly icons?: readonly {
+                    readonly type?: string | undefined;
+                    readonly href: string;
+                    readonly rel: string;
+                    readonly sizes?: string | undefined;
+                }[] | undefined;
+                readonly openGraph?: {
+                    readonly url?: string | undefined;
+                    readonly description?: string | undefined;
+                    readonly title?: string | undefined;
+                    readonly type?: string | undefined;
+                    readonly siteName?: string | undefined;
+                    readonly locale?: string | undefined;
+                    readonly images?: readonly {
+                        readonly url: string;
+                        readonly width?: number | undefined;
+                        readonly height?: number | undefined;
+                        readonly alt?: string | undefined;
+                    }[] | undefined;
+                } | undefined;
+                readonly twitter?: {
+                    readonly description?: string | undefined;
+                    readonly title?: string | undefined;
+                    readonly image?: string | undefined;
+                    readonly card?: string | undefined;
+                    readonly site?: string | undefined;
+                    readonly creator?: string | undefined;
+                } | undefined;
+            } | undefined;
+            readonly response: {
+                readonly url: string;
+                readonly requestedUrl?: string | undefined;
+                readonly originStatusCode?: number | undefined;
+                readonly redirectStatusCode?: number | undefined;
+                readonly headers?: {} | undefined;
+            };
+            readonly json?: readonly {}[] | undefined;
+            readonly appendix?: string | undefined;
+            readonly snapshotId?: string | undefined;
+            readonly blocked?: {
+                readonly blockedType?: string | undefined;
+            } | undefined;
+            readonly assets?: readonly {
+                readonly id: string;
+                readonly kind: "data-url";
+                readonly placeholder: string;
+                readonly archiveKey: string;
+                readonly mimeType: string;
+                readonly sha256: string;
+                readonly bytes: number;
+            }[] | undefined;
+            readonly captureTelemetry?: {
+                readonly requestedStyleMode?: "compat_full" | "native_default" | undefined;
+                readonly selected: "rust";
+                readonly actual: "rust";
+                readonly actualStyleMode?: "compat_full" | "native_default" | undefined;
+                readonly rolloutApplied: boolean;
+                readonly preparedSessionHit?: boolean | undefined;
+                readonly nativePoolHit?: boolean | undefined;
+                readonly preparedPageHit?: boolean | undefined;
+                readonly nativePoolCapacity?: number | undefined;
+                readonly nativePoolProfile?: string | undefined;
+                readonly poolHit?: boolean | undefined;
+                readonly connectMs?: number | undefined;
+                readonly warmConnectionAgeMs?: number | undefined;
+                readonly iconBackendDecision?: "cpu" | "remote_gpu" | undefined;
+            } | undefined;
+            readonly renderEngines?: {
+                readonly markdown?: "rust" | undefined;
+                readonly capture?: "rust" | undefined;
+                readonly tree?: "rust" | undefined;
+            } | undefined;
+        };
+    }[];
+}, {}, {}>;
+export declare class BatchedStatus extends BatchedStatus_base {
+}
+declare const BatchedIncludeUnsupportedTag_base: S.Literal<["BatchedIncludeUnsupported"]>;
+export declare class BatchedIncludeUnsupportedTag extends BatchedIncludeUnsupportedTag_base {
+}
+declare const BatchedIncludeUnsupported_base: S.Struct<{
+    unsupportedFields: S.Array$<typeof S.String>;
+    _tag: typeof BatchedIncludeUnsupportedTag;
+}>;
+export declare class BatchedIncludeUnsupported extends BatchedIncludeUnsupported_base {
+}
+declare const FetchGetBatched400_base: S.Union<[typeof HttpApiDecodeError, typeof BatchedIncludeUnsupported]>;
+export declare class FetchGetBatched400 extends FetchGetBatched400_base {
+}
+export declare const make: (httpClient: HttpClient.HttpClient, options?: {
+    readonly transformClient?: ((client: HttpClient.HttpClient) => Effect.Effect<HttpClient.HttpClient>) | undefined;
+}) => Client;
+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>;
+}
+export {};
+//# sourceMappingURL=Generated.d.ts.map