Fetch API Types

/**
 * The Fetch API fetch() method starts the process of fetching a resource from the network.
 * @param input URL string or Request object
 * @param init Optional RequestInit configuration object
 * @return Promise that resolves to Response object
 */
external fun fetch(
    input: String, 
    init: RequestInit? = definedExternally
): Promise<Response>

external fun fetch(
    input: Request, 
    init: RequestInit? = definedExternally
): Promise<Response>

/**
 * The Request interface represents a resource request.
 */
external interface Request {
    val method: String
    val url: String
    val headers: Headers
    val body: dynamic
    val mode: String
    val credentials: String
    val cache: String
    val redirect: String
    val referrer: String
    val integrity: String
    val keepalive: Boolean
    val signal: AbortSignal?
    
    fun clone(): Request
}

/**
 * The Response interface represents the response to a request.
 */
external interface Response {
    val status: Short
    val statusText: String
    val headers: Headers
    val body: ReadableStream<Uint8Array>?
    val bodyUsed: Boolean
    val ok: Boolean
    val redirected: Boolean
    val type: String
    val url: String
    
    fun clone(): Response
    fun arrayBuffer(): Promise<ArrayBuffer>
    fun blob(): Promise<Blob>
    fun formData(): Promise<FormData>
    fun json(): Promise<dynamic>
    fun text(): Promise<String>
}

/**
 * RequestInit interface for configuring fetch requests.
 * All properties are optional.
 */
external interface RequestInit {
    /** HTTP method (GET, POST, PUT, DELETE, etc.) */
    var method: String?
    
    /** Request headers as Headers object or dynamic object */
    var headers: dynamic
    
    /** Request body data */
    var body: dynamic
    
    /** Request mode: "cors", "no-cors", "same-origin", "navigate" */
    var mode: String?
    
    /** Credentials policy: "omit", "same-origin", "include" */
    var credentials: String?
    
    /** Cache control: "default", "no-store", "reload", "no-cache", "force-cache", "only-if-cached" */
    var cache: String?
    
    /** Redirect handling: "follow", "error", "manual" */
    var redirect: String?
    
    /** Referrer: URL string, "no-referrer", or "client" */
    var referrer: String?
    
    /** Referrer policy for privacy control */
    var referrerPolicy: String?
    
    /** Subresource integrity hash */
    var integrity: String?
    
    /** Keep connection alive for background requests */
    var keepalive: Boolean?
    
    /** AbortController signal for request cancellation */
    var signal: AbortSignal?
    
    /** Window object (browser environments only) */
    var window: dynamic
}

/**
 * The Headers interface allows you to perform various actions on HTTP request and response headers.
 */
external interface Headers {
    fun append(name: String, value: String)
    fun delete(name: String)
    fun entries(): dynamic
    fun forEach(callback: (String, String) -> Unit)
    fun get(name: String): String?
    fun has(name: String): Boolean
    fun keys(): dynamic
    fun set(name: String, value: String)
    fun values(): dynamic
}

/**
 * Headers constructor for creating new Headers objects.
 */
external fun Headers(): Headers
external fun Headers(init: dynamic): Headers

**Usage Examples:**

```kotlin
// Create headers
val headers = Headers()
headers.append("Content-Type", "application/json")
headers.set("Authorization", "Bearer token")

// Check and get headers
if (headers.has("Content-Type")) {
    val contentType = headers.get("Content-Type")
    console.log("Content-Type: $contentType")
}

// Iterate over headers
headers.forEach { value, name ->
    console.log("$name: $value")
}

/**
 * The AbortController interface provides the abort() method that cancels a fetch request.
 */
external interface AbortController {
    val signal: AbortSignal
    fun abort()
}

/**
 * The AbortSignal interface represents a signal object that allows you to abort requests.
 */
external interface AbortSignal : EventTarget {
    val aborted: Boolean
    val reason: dynamic
    fun throwIfAborted()
}

import org.w3c.dom.AbortController

// Create abort controller
val controller = AbortController()

// Use in fetch request
val response = fetch("https://api.example.com/data", RequestInit().apply {
    signal = controller.signal
})

// Cancel the request
controller.abort()

/**
 * The Blob interface represents a blob, which is a file-like object of immutable, raw data.
 */
external interface Blob {
    val size: Long
    val type: String
    
    fun arrayBuffer(): Promise<ArrayBuffer>
    fun slice(start: Long = definedExternally, end: Long = definedExternally, contentType: String = definedExternally): Blob
    fun stream(): ReadableStream<Uint8Array>
    fun text(): Promise<String>
}

/**
 * The FormData interface provides a way to construct key/value pairs for form data.
 */
external interface FormData {
    fun append(name: String, value: String)
    fun append(name: String, value: Blob, filename: String = definedExternally)
    fun delete(name: String)
    fun entries(): dynamic
    fun forEach(callback: (String, String) -> Unit)
    fun get(name: String): dynamic
    fun getAll(name: String): Array<dynamic>
    fun has(name: String): Boolean
    fun keys(): dynamic
    fun set(name: String, value: String)
    fun set(name: String, value: Blob, filename: String = definedExternally)
    fun values(): dynamic
}

/**
 * FormData constructor for creating new FormData objects.
 */
external fun FormData(): FormData
external fun FormData(form: dynamic): FormData

**Usage Examples:**

```kotlin
// Create form data
val formData = FormData()
formData.append("username", "john_doe")
formData.append("email", "john@example.com")

// Add file
val fileBlob = Blob(arrayOf("file content"), BlobPropertyBag().apply {
    type = "text/plain"
})
formData.append("file", fileBlob, "document.txt")

// Use in request
val response = fetch("https://api.example.com/upload", RequestInit().apply {
    method = "POST"
    body = formData
})

/**
 * The ReadableStream interface provides a generic, readable stream of data.
 */
external interface ReadableStream<R> {
    val locked: Boolean
    
    fun cancel(reason: dynamic = definedExternally): Promise<Unit>
    fun getReader(): ReadableStreamDefaultReader<R>
    fun pipeThrough(transform: dynamic, options: dynamic = definedExternally): ReadableStream<dynamic>
    fun pipeTo(destination: WritableStream<R>, options: dynamic = definedExternally): Promise<Unit>
    fun tee(): Array<ReadableStream<R>>
}

/**
 * Reader for ReadableStream.
 */
external interface ReadableStreamDefaultReader<R> {
    val closed: Promise<Unit>
    
    fun cancel(reason: dynamic = definedExternally): Promise<Unit>
    fun read(): Promise<ReadableStreamReadResult<R>>
    fun releaseLock()
}

/**
 * Result of reading from a ReadableStream.
 */
external interface ReadableStreamReadResult<R> {
    val done: Boolean
    val value: R?
}

/**
 * The WritableStream interface provides a standard abstraction for writing streaming data.
 */
external interface WritableStream<W> {
    val locked: Boolean
    
    fun abort(reason: dynamic = definedExternally): Promise<Unit>
    fun close(): Promise<Unit>
    fun getWriter(): WritableStreamDefaultWriter<W>
}

/**
 * Writer for WritableStream.
 */
external interface WritableStreamDefaultWriter<W> {
    val closed: Promise<Unit>
    val desiredSize: Long?
    val ready: Promise<Unit>
    
    fun abort(reason: dynamic = definedExternally): Promise<Unit>
    fun close(): Promise<Unit>
    fun releaseLock()
    fun write(chunk: W): Promise<Unit>
}

/**
 * Type alias for ArrayBuffer-like objects.
 */
typealias ArrayBufferLike = Any

/**
 * The ArrayBuffer interface represents a raw buffer of binary data.
 */
external interface ArrayBuffer : ArrayBufferLike {
    val byteLength: Int
    fun slice(begin: Int, end: Int = definedExternally): ArrayBuffer
}

/**
 * Base interface for array buffer views.
 */
external interface ArrayBufferView {
    val buffer: ArrayBuffer
    val byteLength: Int
    val byteOffset: Int
}

/**
 * Array-like interface for collections.
 */
external interface ArrayLike<T> {
    val length: Int
}

/**
 * The Uint8Array typed array represents an array of 8-bit unsigned integers.
 */
external interface Uint8Array : ArrayBufferView, ArrayLike<Byte> {
    override val length: Int
    
    fun copyWithin(target: Int, start: Int, end: Int = definedExternally): Uint8Array
    fun entries(): dynamic
    fun every(callback: (Byte, Int, Uint8Array) -> Boolean): Boolean
    fun fill(value: Byte, start: Int = definedExternally, end: Int = definedExternally): Uint8Array
    fun filter(callback: (Byte, Int, Uint8Array) -> Boolean): Uint8Array
    fun find(callback: (Byte, Int, Uint8Array) -> Boolean): Byte?
    fun findIndex(callback: (Byte, Int, Uint8Array) -> Boolean): Int
    fun forEach(callback: (Byte, Int, Uint8Array) -> Unit)
    fun includes(value: Byte, fromIndex: Int = definedExternally): Boolean
    fun indexOf(value: Byte, fromIndex: Int = definedExternally): Int
    fun join(separator: String = definedExternally): String
    fun keys(): dynamic
    fun lastIndexOf(value: Byte, fromIndex: Int = definedExternally): Int
    fun map(callback: (Byte, Int, Uint8Array) -> Byte): Uint8Array
    fun reduce(callback: (Any, Byte, Int, Uint8Array) -> Any, initialValue: Any = definedExternally): Any
    fun reduceRight(callback: (Any, Byte, Int, Uint8Array) -> Any, initialValue: Any = definedExternally): Any
    fun reverse(): Uint8Array
    fun set(array: ArrayLike<Byte>, offset: Int = definedExternally)
    fun slice(start: Int = definedExternally, end: Int = definedExternally): Uint8Array
    fun some(callback: (Byte, Int, Uint8Array) -> Boolean): Boolean
    fun sort(compareFn: ((Byte, Byte) -> Int)? = definedExternally): Uint8Array
    fun subarray(begin: Int = definedExternally, end: Int = definedExternally): Uint8Array
    fun values(): dynamic
}

/**
 * EventTarget is an interface implemented by objects that can receive events.
 */
external interface EventTarget {
    fun addEventListener(type: String, callback: ((Event) -> Unit)?, options: dynamic = definedExternally)
    fun dispatchEvent(event: Event): Boolean
    fun removeEventListener(type: String, callback: ((Event) -> Unit)?, options: dynamic = definedExternally)
}

/**
 * The Event interface represents an event which takes place in the DOM.
 */
external interface Event {
    val bubbles: Boolean
    val cancelable: Boolean
    val composed: Boolean
    val currentTarget: EventTarget?
    val defaultPrevented: Boolean
    val eventPhase: Short
    val isTrusted: Boolean
    val target: EventTarget?
    val timeStamp: Double
    val type: String
    
    fun composedPath(): Array<EventTarget>
    fun preventDefault()
    fun stopImmediatePropagation()
    fun stopPropagation()
}

import io.ktor.client.*
import io.ktor.client.engine.js.*
import io.ktor.client.request.*
import io.ktor.http.*

// Using fetch types with Ktor
val client = HttpClient(Js) {
    engine {
        configureRequest {
            // RequestInit properties
            credentials = "include"
            cache = "no-cache"
            mode = "cors"
        }
    }
}

// Working with Response in request interceptors
client.requestPipeline.intercept(HttpRequestPipeline.Before) { content ->
    // Access to RequestInit configuration
    context.fetchOptions {
        referrerPolicy = "strict-origin-when-cross-origin"
    }
}

// Direct fetch usage alongside Ktor
suspend fun customFetch(url: String): String {
    val response = fetch(url, RequestInit().apply {
        method = "GET"
        headers = js("""{
            "Accept": "application/json",
            "User-Agent": "Custom Client"
        }""")
    }).await()
    
    return response.text().await()
}

// Combining with Ktor client
val ktorResponse = client.get("https://api.example.com/ktor-endpoint")
val customResponse = customFetch("https://api.example.com/custom-endpoint")