@studiocms/cfetch 0.1.5 → 0.2.0

package/dist/stub.js

@@ -2,90 +2,167 @@ import { createResolver } from "./utils/integration.js";
 const { resolve } = createResolver(import.meta.url);
 const stub = `
 declare module 'virtual:cfetch/config' {
-	/**
-	 * Default configuration for the cache passed from the user.
-	 *
-	 * @property lifetime - Specifies the duration for which the cache is valid.
-	 *                       The format should be a template literal string representing
-	 *                       either minutes (\`<number>m\`) or hours (\`<number>h\`).
-	 *                       For example: "5m" for 5 minutes or "2h" for 2 hours.
-	 */
-	const defaultConfig: import(${resolve("./types")}).CacheConfig;
+	type CacheConfig = import("${resolve("./types.js")}").CacheConfigLive;
+	const defaultConfig: CacheConfig;
 	export default defaultConfig;
 }
 
 declare module 'c:fetch' {
+	export type CacheConfig = import("${resolve("./types.js")}").CacheConfig;
+	export type CachedResponse<T> = import("${resolve("./wrappers.js")}").CachedResponse<T>;
+	export type CFetchConfig = import("${resolve("./wrappers.js")}").CFetchConfig;
+	
+	export const Duration: typeof import("${resolve("./wrappers.js")}").Duration;
+
+	declare const FetchError_base: new <A extends Record<string, any> = {}>(args: import("effect/Types").Equals<A, {}> extends true ? void : { readonly [P in keyof A as P extends "_tag" ? never : P]: A[P]; }) => import("effect/Cause").YieldableError & {
+		readonly _tag: "FetchError";
+	} & Readonly<A>;
+
 	/**
-	 * Represents the type of the global \`fetch\` function.
-	 *
-	 * This type is derived from the built-in \`fetch\` function, allowing you to
-	 * use it as a reference for type-safe operations involving \`fetch\`.
+	 * Custom error type for fetch-related errors.
 	 */
-	type FetchType = typeof fetch;
+	export declare class FetchError extends FetchError_base<{
+		message: string;
+		cause?: unknown;
+	}> {
+	}
+
 	/**
-	 * Represents the input parameter type for the \`FetchType\` function.
-	 * This type is derived from the first parameter of the \`FetchType\` function.
+	 * No-op parser for HEAD requests.
+	 * 
+	 * @template U - The type of the parsed data
+	 * @param _ - The Response object (ignored)
+	 * @returns A Promise that resolves to undefined
 	 */
-	type Input = Parameters<FetchType>[0];
+	export const noOpParser: typeof import("${resolve("./wrappers.js")}").noOpParser;
+
 	/**
-	 * Represents the \`init\` parameter of the\`fetch\` function, which is the second parameter
-	 * in the \`FetchType\` function signature. This type is used to configure the request,
-	 * including options such as method, headers, body, and other settings.
+	 * Fetches data from a URL with caching capabilities using Effect.
+	 * 
+	 * This function performs an HTTP request with built-in caching logic. It first checks
+	 * the cache for existing data, and if not found, fetches from the network, parses the
+	 * response, and caches successful responses for future use.
+	 * 
+	 * @template T - The type of the parsed response data
+	 * 
+	 * @param url - The URL to fetch data from
+	 * @param parser - A function that parses the Response object into type T
+	 * @param options - Optional RequestInit configuration for the fetch request
+	 * @param cacheConfig - Optional cache configuration object
+	 * @param cacheConfig.ttl - Time-to-live duration for the cached entry
+	 * @param cacheConfig.tags - Tags to associate with the cached entry for invalidation
+	 * @param cacheConfig.key - Custom cache key (defaults to URL and options hash)
+	 * 
+	 * @returns An Effect that yields a CachedResponse containing the parsed data and response metadata
+	 * 
+	 * @throws {FetchError} When the network request fails or response parsing fails
+	 * 
+	 * @remarks
+	 * - Cache keys are automatically generated from the URL and options if not provided
+	 * - Only successful responses (response.ok === true) are cached
+	 * - Cache hits are logged to console for debugging
+	 * - The effect is provided with CacheLive layer automatically
 	 */
-	type Init = Parameters<FetchType>[1];
+	export const cFetchEffect: typeof import("${resolve("./wrappers.js")}").cFetchEffect;
+
 	/**
-	 * Represents the structure of cached data.
-	 *
-	 * @property lastCheck - The date and time when the cache was last checked.
-	 * @property data - The cached response data.
+	 * Creates an Effect that fetches JSON data from a URL with caching support.
+	 * 
+	 * @template T - The expected type of the JSON response data
+	 * @param url - The URL to fetch data from
+	 * @param options - Optional fetch configuration options (headers, method, etc.)
+	 * @param cacheConfig - Optional cache configuration
+	 * @param cacheConfig.ttl - Time-to-live duration for the cached response
+	 * @param cacheConfig.tags - Tags to associate with the cached entry for invalidation
+	 * @param cacheConfig.key - Custom cache key to use instead of the default URL-based key
+	 * @returns An Effect that yields a CachedResponse containing the parsed JSON data, or fails with a FetchError
 	 */
-	type CacheDataValue = { lastCheck: Date; data: Response };
+	export const cFetchEffectJson: typeof import("${resolve("./wrappers.js")}").cFetchEffectJson;
+
+
 	/**
-	 * Represents the configuration for caching.
-	 *
-	 * @property lifetime - Specifies the duration for which the cache is valid.
-	 *                       The format should be a template literal string representing
-	 *                       either minutes (\`<number>m\`) or hours (\`<number>h\`).
-	 *                       For example: "5m" for 5 minutes or "2h" for 2 hours.
+	 * Fetches a resource from the specified URL and returns the response body as text.
+	 * 
+	 * @param url - The URL to fetch the resource from.
+	 * @param options - Optional fetch configuration including method, headers, body, etc.
+	 * @param cacheConfig - Optional cache configuration.
+	 * @param cacheConfig.ttl - Time-to-live duration for the cached response.
+	 * @param cacheConfig.tags - Array of tags to associate with the cached entry for invalidation purposes.
+	 * @param cacheConfig.key - Custom cache key. If not provided, the URL will be used as the key.
+	 * 
+	 * @returns An Effect that resolves to a CachedResponse containing the response text,
+	 *          or fails with a FetchError if the request fails.
 	 */
-	export interface CacheConfig {
-		/**
-		 * Specifies the duration for which the cache is valid.
-		 *     The format should be a template literal string representing
-		 *     either minutes (\`<number>m\`) or hours (\`<number>h\`).
-		 *     For example: "5m" for 5 minutes or "2h" for 2 hours.
-		 */
-		lifetime: \`<number>m\` | \`<number>h\`;
-	}
+	export const cFetchEffectText: typeof import("${resolve("./wrappers.js")}").cFetchEffectText;
+
+	/**
+	 * Fetches a resource and returns it as a Blob with caching support.
+	 * 
+	 * @param url - The URL of the resource to fetch
+	 * @param options - Optional fetch request configuration (headers, method, etc.)
+	 * @param cacheConfig - Optional cache configuration object
+	 * @param cacheConfig.ttl - Time-to-live duration for the cached response
+	 * @param cacheConfig.tags - Array of tags to associate with the cached entry
+	 * @param cacheConfig.key - Custom cache key to use instead of the default
+	 * 
+	 * @returns An Effect that resolves to a CachedResponse containing a Blob, or fails with a FetchError
+	 */
+	export const cFetchEffectBlob: typeof import("${resolve("./wrappers.js")}").cFetchEffectBlob;
+
+	/**
+	 * Executes a cached fetch request with configurable caching behavior.
+	 * 
+	 * @template T - The type of data returned after parsing the response
+	 * @param url - The URL to fetch from
+	 * @param parser - A function that parses the Response object into the desired type T
+	 * @param options - Optional fetch request configuration (headers, method, body, etc.)
+	 * @param cacheConfig - Optional cache configuration object
+	 * @param cacheConfig.ttl - Time-to-live duration for the cached response
+	 * @param cacheConfig.tags - Array of tags to associate with the cached entry for invalidation purposes
+	 * @param cacheConfig.key - Custom cache key; if not provided, a key will be generated from the URL and options
+	 * @returns A Promise that resolves to a CachedResponse containing the parsed data
+	 */
+	export const cFetch: typeof import("${resolve("./wrappers.js")}").cFetch;
+
+	/**
+	 * Fetches and parses JSON data from the specified URL with caching support.
+	 * 
+	 * @template T - The expected type of the parsed JSON response data
+	 * @param url - The URL to fetch data from
+	 * @param options - Optional fetch configuration options (headers, method, body, etc.)
+	 * @param cacheConfig - Optional cache configuration object
+	 * @param cacheConfig.ttl - Time-to-live duration for the cached response
+	 * @param cacheConfig.tags - Array of tags to associate with the cached entry for invalidation purposes
+	 * @param cacheConfig.key - Custom cache key to use instead of the default
+	 * @returns A Promise that resolves to a CachedResponse containing the parsed JSON data of type T
+	 */
+	export const cFetchJson: typeof import("${resolve("./wrappers.js")}").cFetchJson;
+
+	/**
+	 * Fetches a URL and returns the response as text with caching support.
+	 * 
+	 * @param url - The URL to fetch
+	 * @param options - Optional fetch configuration options (headers, method, etc.)
+	 * @param cacheConfig - Optional cache configuration
+	 * @param cacheConfig.ttl - Time-to-live duration for the cached response
+	 * @param cacheConfig.tags - Tags to associate with the cached response for invalidation
+	 * @param cacheConfig.key - Custom cache key (defaults to URL if not provided)
+	 * @returns A promise that resolves to a CachedResponse containing the response text
+	 */
+	export const cFetchText: typeof import("${resolve("./wrappers.js")}").cFetchText;
+
 	/**
-	 * Fetches data with caching capabilities. If the data is not present in the cache
-	 * or the cached data is older than the specified lifetime, it fetches new data
-	 * and updates the cache. Otherwise, it returns the cached data.
-	 *
-	 * @param input - The input to the fetch function, typically a URL or Request object.
-	 * @param init - An optional configuration object for the fetch request.
-	 * @param cacheConfig - Partial configuration for the cache behavior. Defaults to \`defaultConfig\`.
-	 * @param  type - Optional parameter specifying the expected response body format.
-	 *              Can be either 'json' or 'text'. Determines how the response body is processed.
-	 * @param metadata - A boolean indicating whether to return the full cached object (including metadata)
-	 *               or just the data. Defaults to \`false\`.
-	 * @returns The fetched or cached data. If \`full\` is \`true\`, returns an object containing
-	 *          both the data and metadata (e.g., \`lastCheck\`).
-	 * @throws An error if fetching new data fails and no cached data is available.
+	 * Fetches a Blob resource from the specified URL with optional caching configuration.
+	 * 
+	 * @param url - The URL to fetch the Blob resource from
+	 * @param options - Optional fetch request configuration (headers, method, etc.)
+	 * @param cacheConfig - Optional cache configuration object
+	 * @param cacheConfig.ttl - Time-to-live duration for the cached response
+	 * @param cacheConfig.tags - Array of cache tags for cache invalidation
+	 * @param cacheConfig.key - Custom cache key for storing the response
+	 * @returns A Promise that resolves to a CachedResponse containing a Blob
 	 */
-	export function cFetch(
-		input: Input,
-		init?: Init,
-		cacheConfig?: Partial<CacheConfig>,
-		type?: 'json' | 'text'
-	): Promise<Response>;
-	export function cFetch(
-		input: Input,
-		init?: Init,
-		cacheConfig?: Partial<CacheConfig>,
-		type?: 'json' | 'text',
-		metadata?: boolean
-	): Promise<CacheDataValue>;
+	export const cFetchBlob: typeof import("${resolve("./wrappers.js")}").cFetchBlob;
 }
 
 `;

package/dist/types.d.ts

@@ -1,49 +1,34 @@
+import type { Duration } from 'effect';
 /**
- * This module contains types for the cfetch package
- * @module
- */
-/**
- * Represents the type of the global `fetch` function.
+ * Configuration options for caching behavior.
  *
- * This type is derived from the built-in `fetch` function, allowing you to
- * use it as a reference for type-safe operations involving `fetch`.
- */
-export type FetchType = typeof fetch;
-/**
- * Represents the input parameter type for the `FetchType` function.
- * This type is derived from the first parameter of the `FetchType` function.
- */
-export type Input = Parameters<FetchType>[0];
-/**
- * Represents the `init` parameter of the `fetch` function, which is the second parameter
- * in the `FetchType` function signature. This type is used to configure the request,
- * including options such as method, headers, body, and other settings.
- */
-export type Init = Parameters<FetchType>[1];
-/**
- * Represents the structure of cached data.
+ * @remarks
+ * This type defines how long cached data should be retained before being considered stale.
  *
- * @property lastCheck - The date and time when the cache was last checked.
- * @property data - The cached response data.
+ * @example
+ * ```ts
+ * const config: CacheConfig = {
+ *   lifetime: Duration.seconds(60)
+ * };
+ * ```
  */
-export type CacheDataValue = {
-    lastCheck: Date;
-    data: Response;
+export type CacheConfig = {
+    lifetime: Duration.DurationInput;
 };
 /**
- * Represents the configuration for caching.
+ * Configuration options for cache lifetime management.
  *
- * @property lifetime - Specifies the duration for which the cache is valid.
- *                       The format should be a template literal string representing
- *                       either minutes (`<number>m`) or hours (`<number>h`).
- *                       For example: "5m" for 5 minutes or "2h" for 2 hours.
+ * @remarks
+ * This type defines the configuration for controlling how long cached data remains valid
+ * before it needs to be refreshed or invalidated.
+ *
+ * @example
+ * ```typescript
+ * const cacheConfig: CacheConfigLive = {
+ *   lifetime: 3600000 // Cache valid for 1 hour (in milliseconds)
+ * };
+ * ```
  */
-export interface CacheConfig {
-    /**
-     * Specifies the duration for which the cache is valid.
-     *     The format should be a template literal string representing
-     *     either minutes (`<number>m`) or hours (`<number>h`).
-     *     For example: "5m" for 5 minutes or "2h" for 2 hours.
-     */
-    lifetime: `${number}m` | `${number}h`;
-}
+export type CacheConfigLive = {
+    lifetime: number;
+};

package/dist/utils/integration.js

@@ -1,5 +1,4 @@
 import { fileURLToPath } from "node:url";
-import { AstroError } from "astro/errors";
 const _IS_ABSOLUTE_RE = /^[/\\](?![/\\])|^[/\\]{2}(?!\.)|^[A-Za-z]:[/\\]/;
 const _DRIVE_LETTER_RE = /^[A-Za-z]:$/;
 const _DRIVE_LETTER_START_RE = /^[A-Za-z]:\//;
@@ -200,7 +199,7 @@ const createVirtualModule = (name, _imports, bypassCoreValidation) => {
   }
   for (const [id, contexts] of Object.entries(duplicatedImports)) {
     if (contexts.length !== [...new Set(contexts)].length) {
-      throw new AstroError(
+      throw new Error(
         `Virtual import with id "${id}" has been registered several times with conflicting contexts.`
       );
     }
@@ -208,7 +207,7 @@ const createVirtualModule = (name, _imports, bypassCoreValidation) => {
   const resolutionMap = Object.fromEntries(
     imports.map(({ id }) => {
       if (!bypassCoreValidation && id.startsWith("astro:")) {
-        throw new AstroError(
+        throw new Error(
           `Virtual import name prefix can't be "astro:" (for "${id}") because it's reserved for Astro core.`
         );
       }

package/dist/wrappers.d.ts

@@ -1,15 +1,245 @@
 /**
- * This module contains functions that wrap and cache the native fetch function
- * @module
+ * @module cfetch/wrappers
+ *
+ * Provides cached fetch wrappers using Effect for caching capabilities.
+ *
+ * This module exports functions to perform HTTP requests with built-in caching logic.
+ * It defines types for cached responses and errors, and implements functions to fetch
+ * data with various parsing options (JSON, text, Blob) while leveraging an in-memory
+ * cache layer.
  */
-import type { CacheConfig, CacheDataValue, Init, Input } from './types.js';
-export type { CacheConfig };
+import { type Duration, Effect } from 'effect';
+export type { CacheConfig } from './types.js';
+export { Duration } from 'effect';
+declare const FetchError_base: new <A extends Record<string, any> = {}>(args: import("effect/Types").Equals<A, {}> extends true ? void : { readonly [P in keyof A as P extends "_tag" ? never : P]: A[P]; }) => import("effect/Cause").YieldableError & {
+    readonly _tag: "FetchError";
+} & Readonly<A>;
 /**
- * Exported for tests
+ * Custom error type for fetch-related errors.
  */
-export declare const cachedData: Map<string, {
-    lastCheck: Date;
-    data: any;
-}>;
-export declare function cFetch(input: Input, init?: Init, cacheConfig?: Partial<CacheConfig>, type?: 'json' | 'text'): Promise<Response>;
-export declare function cFetch(input: Input, init?: Init, cacheConfig?: Partial<CacheConfig>, type?: 'json' | 'text', metadata?: boolean): Promise<CacheDataValue>;
+export declare class FetchError extends FetchError_base<{
+    message: string;
+    cause?: unknown;
+}> {
+}
+export interface CachedResponse<T> {
+    data: T;
+    ok: boolean;
+    status: number;
+    statusText: string;
+    headers: Record<string, string>;
+}
+/**
+ * Configuration options for cached fetch requests.
+ */
+export interface CFetchConfig {
+    ttl?: Duration.DurationInput;
+    tags?: string[];
+    key?: string;
+    verbose?: boolean;
+}
+/**
+ * No-op parser for HEAD requests.
+ *
+ * @template U - The type of the parsed data
+ * @param _ - The Response object (ignored)
+ * @returns A Promise that resolves to undefined
+ */
+export declare const noOpParser: <U>(_: Response) => Promise<U>;
+/**
+ * Fetches data from a URL with caching capabilities using Effect.
+ *
+ * This function performs an HTTP request with built-in caching logic. It first checks
+ * the cache for existing data, and if not found, fetches from the network, parses the
+ * response, and caches successful responses for future use.
+ *
+ * @template T - The type of the parsed response data
+ *
+ * @param url - The URL to fetch data from
+ * @param parser - A function that parses the Response object into type T
+ * @param options - Optional RequestInit configuration for the fetch request
+ * @param cacheConfig - Optional cache configuration object
+ * @param cacheConfig.ttl - Time-to-live duration for the cached entry
+ * @param cacheConfig.tags - Tags to associate with the cached entry for invalidation
+ * @param cacheConfig.key - Custom cache key (defaults to URL and options hash)
+ *
+ * @returns An Effect that yields a CachedResponse containing the parsed data and response metadata
+ *
+ * @throws {FetchError} When the network request fails or response parsing fails
+ *
+ * @remarks
+ * - Cache keys are automatically generated from the URL and options if not provided
+ * - Only successful responses (response.ok === true) are cached
+ * - Only 2xx responses are cached
+ * - Users needing negative caching should implement custom logic
+ * - The effect is provided with CacheLive layer automatically
+ * - Non-cacheable HTTP methods (e.g. POST, PUT) bypass the cache entirely
+ * - The parser function is bypassed for HEAD requests, returning undefined data
+ * - Verbose logging can be enabled via cacheConfig.verbose
+ *
+ * @example
+ * ```typescript
+ * const effect = cFetchEffect(
+ *   'https://api.example.com/data',
+ *   (res) => res.json(),
+ *   { method: 'GET' },
+ *   { ttl: Duration.minutes(5), tags: ['api-data'] }
+ * );
+ * ```
+ */
+export declare const cFetchEffect: <T>(url: string | URL, parser: (response: Response) => Promise<T>, options?: RequestInit, cacheConfig?: CFetchConfig) => Effect.Effect<CachedResponse<T>, FetchError, never>;
+/**
+ * Creates an Effect that fetches JSON data from a URL with caching support.
+ *
+ * @template T - The expected type of the JSON response data
+ * @param url - The URL to fetch data from
+ * @param options - Optional fetch configuration options (headers, method, etc.)
+ * @param cacheConfig - Optional cache configuration
+ * @param cacheConfig.ttl - Time-to-live duration for the cached response
+ * @param cacheConfig.tags - Tags to associate with the cached entry for invalidation
+ * @param cacheConfig.key - Custom cache key to use instead of the default URL-based key
+ * @returns An Effect that yields a CachedResponse containing the parsed JSON data, or fails with a FetchError
+ *
+ * @example
+ * ```typescript
+ * const effect = cFetchEffectJson<User>(
+ *   'https://api.example.com/user/123',
+ *   { method: 'GET' },
+ *   { ttl: Duration.minutes(5), tags: ['user'] }
+ * );
+ * ```
+ */
+export declare const cFetchEffectJson: <T>(url: string | URL, options?: RequestInit, cacheConfig?: CFetchConfig) => Effect.Effect<CachedResponse<T>, FetchError, never>;
+/**
+ * Fetches a resource from the specified URL and returns the response body as text.
+ *
+ * @param url - The URL to fetch the resource from.
+ * @param options - Optional fetch configuration including method, headers, body, etc.
+ * @param cacheConfig - Optional cache configuration.
+ * @param cacheConfig.ttl - Time-to-live duration for the cached response.
+ * @param cacheConfig.tags - Array of tags to associate with the cached entry for invalidation purposes.
+ * @param cacheConfig.key - Custom cache key. If not provided, the URL will be used as the key.
+ *
+ * @returns An Effect that resolves to a CachedResponse containing the response text,
+ *          or fails with a FetchError if the request fails.
+ *
+ * @example
+ * ```typescript
+ * const textEffect = cFetchEffectText(
+ *   'https://api.example.com/data',
+ *   { method: 'GET' },
+ *   { ttl: Duration.minutes(5), tags: ['api', 'data'] }
+ * );
+ * ```
+ */
+export declare const cFetchEffectText: (url: string | URL, options?: RequestInit, cacheConfig?: CFetchConfig) => Effect.Effect<CachedResponse<string>, FetchError, never>;
+/**
+ * Fetches a resource and returns it as a Blob with caching support.
+ *
+ * @param url - The URL of the resource to fetch
+ * @param options - Optional fetch request configuration (headers, method, etc.)
+ * @param cacheConfig - Optional cache configuration object
+ * @param cacheConfig.ttl - Time-to-live duration for the cached response
+ * @param cacheConfig.tags - Array of tags to associate with the cached entry
+ * @param cacheConfig.key - Custom cache key to use instead of the default
+ *
+ * @returns An Effect that resolves to a CachedResponse containing a Blob, or fails with a FetchError
+ *
+ * @example
+ * ```typescript
+ * const imageEffect = cFetchEffectBlob(
+ *   'https://example.com/image.png',
+ *   { method: 'GET' },
+ *   { ttl: Duration.hours(1), tags: ['images'] }
+ * );
+ * ```
+ */
+export declare const cFetchEffectBlob: (url: string | URL, options?: RequestInit, cacheConfig?: CFetchConfig) => Effect.Effect<CachedResponse<Blob>, FetchError, never>;
+/**
+ * Executes a cached fetch request with configurable caching behavior.
+ *
+ * @template T - The type of data returned after parsing the response
+ * @param url - The URL to fetch from
+ * @param parser - A function that parses the Response object into the desired type T
+ * @param options - Optional fetch request configuration (headers, method, body, etc.)
+ * @param cacheConfig - Optional cache configuration object
+ * @param cacheConfig.ttl - Time-to-live duration for the cached response
+ * @param cacheConfig.tags - Array of tags to associate with the cached entry for invalidation purposes
+ * @param cacheConfig.key - Custom cache key; if not provided, a key will be generated from the URL and options
+ * @returns A Promise that resolves to a CachedResponse containing the parsed data
+ *
+ * @example
+ * ```typescript
+ * const result = await cFetch(
+ *   'https://api.example.com/data',
+ *   (res) => res.json(),
+ *   { method: 'GET' },
+ *   { ttl: Duration.minutes(5), tags: ['api-data'] }
+ * );
+ * ```
+ */
+export declare const cFetch: <T>(url: string | URL, parser: (response: Response) => Promise<T>, options?: RequestInit, cacheConfig?: CFetchConfig) => Promise<CachedResponse<T>>;
+/**
+ * Fetches and parses JSON data from the specified URL with caching support.
+ *
+ * @template T - The expected type of the parsed JSON response data
+ * @param url - The URL to fetch data from
+ * @param options - Optional fetch configuration options (headers, method, body, etc.)
+ * @param cacheConfig - Optional cache configuration object
+ * @param cacheConfig.ttl - Time-to-live duration for the cached response
+ * @param cacheConfig.tags - Array of tags to associate with the cached entry for invalidation purposes
+ * @param cacheConfig.key - Custom cache key to use instead of the default
+ * @returns A Promise that resolves to a CachedResponse containing the parsed JSON data of type T
+ *
+ * @example
+ * ```typescript
+ * const result = await cFetchJson<User>('https://api.example.com/user/123', {
+ *   method: 'GET',
+ *   headers: { 'Authorization': 'Bearer token' }
+ * }, {
+ *   ttl: Duration.minutes(5),
+ *   tags: ['user-data']
+ * });
+ * ```
+ */
+export declare const cFetchJson: <T>(url: string | URL, options?: RequestInit, cacheConfig?: CFetchConfig) => Promise<CachedResponse<T>>;
+/**
+ * Fetches a URL and returns the response as text with caching support.
+ *
+ * @param url - The URL to fetch
+ * @param options - Optional fetch configuration options (headers, method, etc.)
+ * @param cacheConfig - Optional cache configuration
+ * @param cacheConfig.ttl - Time-to-live duration for the cached response
+ * @param cacheConfig.tags - Tags to associate with the cached response for invalidation
+ * @param cacheConfig.key - Custom cache key (defaults to URL if not provided)
+ * @returns A promise that resolves to a CachedResponse containing the response text
+ *
+ * @example
+ * ```typescript
+ * const result = await cFetchText('https://api.example.com/data', {
+ *   method: 'GET'
+ * }, {
+ *   ttl: Duration.hours(1),
+ *   tags: ['api', 'data']
+ * });
+ * ```
+ */
+export declare const cFetchText: (url: string | URL, options?: RequestInit, cacheConfig?: CFetchConfig) => Promise<CachedResponse<string>>;
+/**
+ * Fetches a Blob resource from the specified URL with optional caching configuration.
+ *
+ * @param url - The URL to fetch the Blob resource from
+ * @param options - Optional fetch request configuration (headers, method, etc.)
+ * @param cacheConfig - Optional cache configuration object
+ * @param cacheConfig.ttl - Time-to-live duration for the cached response
+ * @param cacheConfig.tags - Array of cache tags for cache invalidation
+ * @param cacheConfig.key - Custom cache key for storing the response
+ * @returns A Promise that resolves to a CachedResponse containing a Blob
+ *
+ * @example
+ * ```typescript
+ * const response = await cFetchBlob('https://example.com/image.png', {}, { ttl: Duration.minutes(5) });
+ * const blob = response.data;
+ * ```
+ */
+export declare const cFetchBlob: (url: string | URL, options?: RequestInit, cacheConfig?: CFetchConfig) => Promise<CachedResponse<Blob>>;