@objectstack/spec 0.6.1 → 0.7.1

package/dist/api/http-cache.zod.d.ts

@@ -0,0 +1,439 @@
+import { z } from 'zod';
+/**
+ * HTTP Metadata Cache Protocol
+ *
+ * Implements efficient HTTP-level metadata caching with ETag support.
+ * Implements P0 requirement for ObjectStack kernel.
+ *
+ * ## Caching in ObjectStack
+ *
+ * **HTTP Cache (`api/http-cache.zod.ts`) - This File**
+ * - **Purpose**: Cache API responses at HTTP protocol level
+ * - **Technologies**: HTTP headers (ETag, Last-Modified, Cache-Control), CDN
+ * - **Configuration**: Cache-Control headers, validation tokens
+ * - **Use case**: Reduce API response time for repeated metadata requests
+ * - **Scope**: HTTP layer, client-server communication
+ *
+ * **Application Cache (`system/cache.zod.ts`)**
+ * - **Purpose**: Cache computed data, query results, aggregations
+ * - **Technologies**: Redis, Memcached, in-memory LRU
+ * - **Configuration**: TTL, eviction policies, cache warming
+ * - **Use case**: Cache expensive database queries, computed values
+ * - **Scope**: Application layer, server-side data storage
+ *
+ * ## Features
+ * - ETag-based conditional requests (HTTP 304 Not Modified)
+ * - Cache-Control directives
+ * - Metadata versioning
+ * - Selective cache invalidation
+ *
+ * Industry alignment: HTTP Caching (RFC 7234), Salesforce Metadata API
+ *
+ * @see ../../system/cache.zod.ts for application-level caching
+ */
+/**
+ * Cache Control Directive Enum
+ * Standard HTTP cache control directives
+ */
+export declare const CacheDirective: z.ZodEnum<["public", "private", "no-cache", "no-store", "must-revalidate", "max-age"]>;
+export type CacheDirective = z.infer<typeof CacheDirective>;
+/**
+ * Cache Control Schema
+ * HTTP cache control configuration
+ *
+ * @example
+ * {
+ *   "directives": ["public", "max-age"],
+ *   "maxAge": 3600,
+ *   "staleWhileRevalidate": 86400
+ * }
+ */
+export declare const CacheControlSchema: z.ZodObject<{
+    directives: z.ZodArray<z.ZodEnum<["public", "private", "no-cache", "no-store", "must-revalidate", "max-age"]>, "many">;
+    maxAge: z.ZodOptional<z.ZodNumber>;
+    staleWhileRevalidate: z.ZodOptional<z.ZodNumber>;
+    staleIfError: z.ZodOptional<z.ZodNumber>;
+}, "strip", z.ZodTypeAny, {
+    directives: ("private" | "public" | "no-cache" | "no-store" | "must-revalidate" | "max-age")[];
+    maxAge?: number | undefined;
+    staleWhileRevalidate?: number | undefined;
+    staleIfError?: number | undefined;
+}, {
+    directives: ("private" | "public" | "no-cache" | "no-store" | "must-revalidate" | "max-age")[];
+    maxAge?: number | undefined;
+    staleWhileRevalidate?: number | undefined;
+    staleIfError?: number | undefined;
+}>;
+export type CacheControl = z.infer<typeof CacheControlSchema>;
+/**
+ * ETag Schema
+ * Entity tag for cache validation
+ *
+ * ETags can be:
+ * - Strong: Exact match required (e.g., "686897696a7c876b7e")
+ * - Weak: Semantic equivalence (e.g., W/"686897696a7c876b7e")
+ */
+export declare const ETagSchema: z.ZodObject<{
+    value: z.ZodString;
+    weak: z.ZodDefault<z.ZodOptional<z.ZodBoolean>>;
+}, "strip", z.ZodTypeAny, {
+    value: string;
+    weak: boolean;
+}, {
+    value: string;
+    weak?: boolean | undefined;
+}>;
+export type ETag = z.infer<typeof ETagSchema>;
+/**
+ * Metadata Cache Request Schema
+ * Request with cache validation headers
+ *
+ * @example
+ * // GET /api/v1/metadata/objects/account
+ * // Headers:
+ * // If-None-Match: "686897696a7c876b7e"
+ * // If-Modified-Since: Wed, 21 Oct 2015 07:28:00 GMT
+ */
+export declare const MetadataCacheRequestSchema: z.ZodObject<{
+    ifNoneMatch: z.ZodOptional<z.ZodString>;
+    ifModifiedSince: z.ZodOptional<z.ZodString>;
+    cacheControl: z.ZodOptional<z.ZodObject<{
+        directives: z.ZodArray<z.ZodEnum<["public", "private", "no-cache", "no-store", "must-revalidate", "max-age"]>, "many">;
+        maxAge: z.ZodOptional<z.ZodNumber>;
+        staleWhileRevalidate: z.ZodOptional<z.ZodNumber>;
+        staleIfError: z.ZodOptional<z.ZodNumber>;
+    }, "strip", z.ZodTypeAny, {
+        directives: ("private" | "public" | "no-cache" | "no-store" | "must-revalidate" | "max-age")[];
+        maxAge?: number | undefined;
+        staleWhileRevalidate?: number | undefined;
+        staleIfError?: number | undefined;
+    }, {
+        directives: ("private" | "public" | "no-cache" | "no-store" | "must-revalidate" | "max-age")[];
+        maxAge?: number | undefined;
+        staleWhileRevalidate?: number | undefined;
+        staleIfError?: number | undefined;
+    }>>;
+}, "strip", z.ZodTypeAny, {
+    cacheControl?: {
+        directives: ("private" | "public" | "no-cache" | "no-store" | "must-revalidate" | "max-age")[];
+        maxAge?: number | undefined;
+        staleWhileRevalidate?: number | undefined;
+        staleIfError?: number | undefined;
+    } | undefined;
+    ifNoneMatch?: string | undefined;
+    ifModifiedSince?: string | undefined;
+}, {
+    cacheControl?: {
+        directives: ("private" | "public" | "no-cache" | "no-store" | "must-revalidate" | "max-age")[];
+        maxAge?: number | undefined;
+        staleWhileRevalidate?: number | undefined;
+        staleIfError?: number | undefined;
+    } | undefined;
+    ifNoneMatch?: string | undefined;
+    ifModifiedSince?: string | undefined;
+}>;
+export type MetadataCacheRequest = z.infer<typeof MetadataCacheRequestSchema>;
+/**
+ * Metadata Cache Response Schema
+ * Response with cache control headers
+ *
+ * @example Success Response (200 OK)
+ * {
+ *   "data": { "object": "account" },
+ *   "etag": {
+ *     "value": "686897696a7c876b7e",
+ *     "weak": false
+ *   },
+ *   "lastModified": "2026-01-29T12:00:00Z",
+ *   "cacheControl": {
+ *     "directives": ["public", "max-age"],
+ *     "maxAge": 3600
+ *   }
+ * }
+ *
+ * @example Not Modified Response (304 Not Modified)
+ * {
+ *   "notModified": true,
+ *   "etag": {
+ *     "value": "686897696a7c876b7e"
+ *   }
+ * }
+ */
+export declare const MetadataCacheResponseSchema: z.ZodObject<{
+    data: z.ZodOptional<z.ZodAny>;
+    etag: z.ZodOptional<z.ZodObject<{
+        value: z.ZodString;
+        weak: z.ZodDefault<z.ZodOptional<z.ZodBoolean>>;
+    }, "strip", z.ZodTypeAny, {
+        value: string;
+        weak: boolean;
+    }, {
+        value: string;
+        weak?: boolean | undefined;
+    }>>;
+    lastModified: z.ZodOptional<z.ZodString>;
+    cacheControl: z.ZodOptional<z.ZodObject<{
+        directives: z.ZodArray<z.ZodEnum<["public", "private", "no-cache", "no-store", "must-revalidate", "max-age"]>, "many">;
+        maxAge: z.ZodOptional<z.ZodNumber>;
+        staleWhileRevalidate: z.ZodOptional<z.ZodNumber>;
+        staleIfError: z.ZodOptional<z.ZodNumber>;
+    }, "strip", z.ZodTypeAny, {
+        directives: ("private" | "public" | "no-cache" | "no-store" | "must-revalidate" | "max-age")[];
+        maxAge?: number | undefined;
+        staleWhileRevalidate?: number | undefined;
+        staleIfError?: number | undefined;
+    }, {
+        directives: ("private" | "public" | "no-cache" | "no-store" | "must-revalidate" | "max-age")[];
+        maxAge?: number | undefined;
+        staleWhileRevalidate?: number | undefined;
+        staleIfError?: number | undefined;
+    }>>;
+    notModified: z.ZodDefault<z.ZodOptional<z.ZodBoolean>>;
+    version: z.ZodOptional<z.ZodString>;
+}, "strip", z.ZodTypeAny, {
+    notModified: boolean;
+    cacheControl?: {
+        directives: ("private" | "public" | "no-cache" | "no-store" | "must-revalidate" | "max-age")[];
+        maxAge?: number | undefined;
+        staleWhileRevalidate?: number | undefined;
+        staleIfError?: number | undefined;
+    } | undefined;
+    version?: string | undefined;
+    data?: any;
+    lastModified?: string | undefined;
+    etag?: {
+        value: string;
+        weak: boolean;
+    } | undefined;
+}, {
+    cacheControl?: {
+        directives: ("private" | "public" | "no-cache" | "no-store" | "must-revalidate" | "max-age")[];
+        maxAge?: number | undefined;
+        staleWhileRevalidate?: number | undefined;
+        staleIfError?: number | undefined;
+    } | undefined;
+    version?: string | undefined;
+    data?: any;
+    lastModified?: string | undefined;
+    etag?: {
+        value: string;
+        weak?: boolean | undefined;
+    } | undefined;
+    notModified?: boolean | undefined;
+}>;
+export type MetadataCacheResponse = z.infer<typeof MetadataCacheResponseSchema>;
+/**
+ * Cache Invalidation Target Enum
+ * Specifies what to invalidate
+ */
+export declare const CacheInvalidationTarget: z.ZodEnum<["all", "object", "field", "permission", "layout", "custom"]>;
+export type CacheInvalidationTarget = z.infer<typeof CacheInvalidationTarget>;
+/**
+ * Cache Invalidation Request Schema
+ * Request to invalidate cached metadata
+ *
+ * @example
+ * // POST /api/v1/metadata/cache/invalidate
+ * {
+ *   "target": "object",
+ *   "identifiers": ["account", "contact"],
+ *   "cascade": true
+ * }
+ */
+export declare const CacheInvalidationRequestSchema: z.ZodObject<{
+    target: z.ZodEnum<["all", "object", "field", "permission", "layout", "custom"]>;
+    identifiers: z.ZodOptional<z.ZodArray<z.ZodString, "many">>;
+    cascade: z.ZodDefault<z.ZodOptional<z.ZodBoolean>>;
+    pattern: z.ZodOptional<z.ZodString>;
+}, "strip", z.ZodTypeAny, {
+    target: "object" | "custom" | "field" | "all" | "layout" | "permission";
+    cascade: boolean;
+    pattern?: string | undefined;
+    identifiers?: string[] | undefined;
+}, {
+    target: "object" | "custom" | "field" | "all" | "layout" | "permission";
+    pattern?: string | undefined;
+    cascade?: boolean | undefined;
+    identifiers?: string[] | undefined;
+}>;
+export type CacheInvalidationRequest = z.infer<typeof CacheInvalidationRequestSchema>;
+/**
+ * Cache Invalidation Response Schema
+ * Response for cache invalidation
+ *
+ * @example
+ * {
+ *   "success": true,
+ *   "invalidated": 5,
+ *   "targets": ["account", "contact", "opportunity"]
+ * }
+ */
+export declare const CacheInvalidationResponseSchema: z.ZodObject<{
+    success: z.ZodBoolean;
+    invalidated: z.ZodNumber;
+    targets: z.ZodOptional<z.ZodArray<z.ZodString, "many">>;
+}, "strip", z.ZodTypeAny, {
+    success: boolean;
+    invalidated: number;
+    targets?: string[] | undefined;
+}, {
+    success: boolean;
+    invalidated: number;
+    targets?: string[] | undefined;
+}>;
+export type CacheInvalidationResponse = z.infer<typeof CacheInvalidationResponseSchema>;
+/**
+ * Metadata Cache API Client Interface
+ *
+ * @example Usage
+ * // Get metadata with cache support
+ * const response = await client.meta.getCached('account', {
+ *   ifNoneMatch: '"686897696a7c876b7e"'
+ * });
+ *
+ * if (response.notModified) {
+ *   // Use cached version
+ * } else {
+ *   // Update cache with response.data
+ *   cache.set('account', response.data, {
+ *     etag: response.etag?.value,
+ *     maxAge: response.cacheControl?.maxAge
+ *   });
+ * }
+ */
+export declare const MetadataCacheApi: {
+    getCached: {
+        input: z.ZodObject<{
+            ifNoneMatch: z.ZodOptional<z.ZodString>;
+            ifModifiedSince: z.ZodOptional<z.ZodString>;
+            cacheControl: z.ZodOptional<z.ZodObject<{
+                directives: z.ZodArray<z.ZodEnum<["public", "private", "no-cache", "no-store", "must-revalidate", "max-age"]>, "many">;
+                maxAge: z.ZodOptional<z.ZodNumber>;
+                staleWhileRevalidate: z.ZodOptional<z.ZodNumber>;
+                staleIfError: z.ZodOptional<z.ZodNumber>;
+            }, "strip", z.ZodTypeAny, {
+                directives: ("private" | "public" | "no-cache" | "no-store" | "must-revalidate" | "max-age")[];
+                maxAge?: number | undefined;
+                staleWhileRevalidate?: number | undefined;
+                staleIfError?: number | undefined;
+            }, {
+                directives: ("private" | "public" | "no-cache" | "no-store" | "must-revalidate" | "max-age")[];
+                maxAge?: number | undefined;
+                staleWhileRevalidate?: number | undefined;
+                staleIfError?: number | undefined;
+            }>>;
+        }, "strip", z.ZodTypeAny, {
+            cacheControl?: {
+                directives: ("private" | "public" | "no-cache" | "no-store" | "must-revalidate" | "max-age")[];
+                maxAge?: number | undefined;
+                staleWhileRevalidate?: number | undefined;
+                staleIfError?: number | undefined;
+            } | undefined;
+            ifNoneMatch?: string | undefined;
+            ifModifiedSince?: string | undefined;
+        }, {
+            cacheControl?: {
+                directives: ("private" | "public" | "no-cache" | "no-store" | "must-revalidate" | "max-age")[];
+                maxAge?: number | undefined;
+                staleWhileRevalidate?: number | undefined;
+                staleIfError?: number | undefined;
+            } | undefined;
+            ifNoneMatch?: string | undefined;
+            ifModifiedSince?: string | undefined;
+        }>;
+        output: z.ZodObject<{
+            data: z.ZodOptional<z.ZodAny>;
+            etag: z.ZodOptional<z.ZodObject<{
+                value: z.ZodString;
+                weak: z.ZodDefault<z.ZodOptional<z.ZodBoolean>>;
+            }, "strip", z.ZodTypeAny, {
+                value: string;
+                weak: boolean;
+            }, {
+                value: string;
+                weak?: boolean | undefined;
+            }>>;
+            lastModified: z.ZodOptional<z.ZodString>;
+            cacheControl: z.ZodOptional<z.ZodObject<{
+                directives: z.ZodArray<z.ZodEnum<["public", "private", "no-cache", "no-store", "must-revalidate", "max-age"]>, "many">;
+                maxAge: z.ZodOptional<z.ZodNumber>;
+                staleWhileRevalidate: z.ZodOptional<z.ZodNumber>;
+                staleIfError: z.ZodOptional<z.ZodNumber>;
+            }, "strip", z.ZodTypeAny, {
+                directives: ("private" | "public" | "no-cache" | "no-store" | "must-revalidate" | "max-age")[];
+                maxAge?: number | undefined;
+                staleWhileRevalidate?: number | undefined;
+                staleIfError?: number | undefined;
+            }, {
+                directives: ("private" | "public" | "no-cache" | "no-store" | "must-revalidate" | "max-age")[];
+                maxAge?: number | undefined;
+                staleWhileRevalidate?: number | undefined;
+                staleIfError?: number | undefined;
+            }>>;
+            notModified: z.ZodDefault<z.ZodOptional<z.ZodBoolean>>;
+            version: z.ZodOptional<z.ZodString>;
+        }, "strip", z.ZodTypeAny, {
+            notModified: boolean;
+            cacheControl?: {
+                directives: ("private" | "public" | "no-cache" | "no-store" | "must-revalidate" | "max-age")[];
+                maxAge?: number | undefined;
+                staleWhileRevalidate?: number | undefined;
+                staleIfError?: number | undefined;
+            } | undefined;
+            version?: string | undefined;
+            data?: any;
+            lastModified?: string | undefined;
+            etag?: {
+                value: string;
+                weak: boolean;
+            } | undefined;
+        }, {
+            cacheControl?: {
+                directives: ("private" | "public" | "no-cache" | "no-store" | "must-revalidate" | "max-age")[];
+                maxAge?: number | undefined;
+                staleWhileRevalidate?: number | undefined;
+                staleIfError?: number | undefined;
+            } | undefined;
+            version?: string | undefined;
+            data?: any;
+            lastModified?: string | undefined;
+            etag?: {
+                value: string;
+                weak?: boolean | undefined;
+            } | undefined;
+            notModified?: boolean | undefined;
+        }>;
+    };
+    invalidate: {
+        input: z.ZodObject<{
+            target: z.ZodEnum<["all", "object", "field", "permission", "layout", "custom"]>;
+            identifiers: z.ZodOptional<z.ZodArray<z.ZodString, "many">>;
+            cascade: z.ZodDefault<z.ZodOptional<z.ZodBoolean>>;
+            pattern: z.ZodOptional<z.ZodString>;
+        }, "strip", z.ZodTypeAny, {
+            target: "object" | "custom" | "field" | "all" | "layout" | "permission";
+            cascade: boolean;
+            pattern?: string | undefined;
+            identifiers?: string[] | undefined;
+        }, {
+            target: "object" | "custom" | "field" | "all" | "layout" | "permission";
+            pattern?: string | undefined;
+            cascade?: boolean | undefined;
+            identifiers?: string[] | undefined;
+        }>;
+        output: z.ZodObject<{
+            success: z.ZodBoolean;
+            invalidated: z.ZodNumber;
+            targets: z.ZodOptional<z.ZodArray<z.ZodString, "many">>;
+        }, "strip", z.ZodTypeAny, {
+            success: boolean;
+            invalidated: number;
+            targets?: string[] | undefined;
+        }, {
+            success: boolean;
+            invalidated: number;
+            targets?: string[] | undefined;
+        }>;
+    };
+};
+//# sourceMappingURL=http-cache.zod.d.ts.map

package/dist/api/http-cache.zod.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"http-cache.zod.d.ts","sourceRoot":"","sources":["../../src/api/http-cache.zod.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,CAAC,EAAE,MAAM,KAAK,CAAC;AAExB;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GA+BG;AAMH;;;GAGG;AACH,eAAO,MAAM,cAAc,wFAOzB,CAAC;AAEH,MAAM,MAAM,cAAc,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,cAAc,CAAC,CAAC;AAE5D;;;;;;;;;;GAUG;AACH,eAAO,MAAM,kBAAkB;;;;;;;;;;;;;;;EAK7B,CAAC;AAEH,MAAM,MAAM,YAAY,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,kBAAkB,CAAC,CAAC;AAM9D;;;;;;;GAOG;AACH,eAAO,MAAM,UAAU;;;;;;;;;EAGrB,CAAC;AAEH,MAAM,MAAM,IAAI,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,UAAU,CAAC,CAAC;AAM9C;;;;;;;;;GASG;AACH,eAAO,MAAM,0BAA0B;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;EAIrC,CAAC;AAEH,MAAM,MAAM,oBAAoB,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,0BAA0B,CAAC,CAAC;AAM9E;;;;;;;;;;;;;;;;;;;;;;;;;GAyBG;AACH,eAAO,MAAM,2BAA2B;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;EAOtC,CAAC;AAEH,MAAM,MAAM,qBAAqB,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,2BAA2B,CAAC,CAAC;AAMhF;;;GAGG;AACH,eAAO,MAAM,uBAAuB,yEAOlC,CAAC;AAEH,MAAM,MAAM,uBAAuB,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,uBAAuB,CAAC,CAAC;AAE9E;;;;;;;;;;;GAWG;AACH,eAAO,MAAM,8BAA8B;;;;;;;;;;;;;;;EAKzC,CAAC;AAEH,MAAM,MAAM,wBAAwB,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,8BAA8B,CAAC,CAAC;AAEtF;;;;;;;;;;GAUG;AACH,eAAO,MAAM,+BAA+B;;;;;;;;;;;;EAI1C,CAAC;AAEH,MAAM,MAAM,yBAAyB,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,+BAA+B,CAAC,CAAC;AAMxF;;;;;;;;;;;;;;;;;;GAkBG;AACH,eAAO,MAAM,gBAAgB;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;CAS5B,CAAC"}

package/dist/api/http-cache.zod.js

@@ -0,0 +1,219 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.MetadataCacheApi = exports.CacheInvalidationResponseSchema = exports.CacheInvalidationRequestSchema = exports.CacheInvalidationTarget = exports.MetadataCacheResponseSchema = exports.MetadataCacheRequestSchema = exports.ETagSchema = exports.CacheControlSchema = exports.CacheDirective = void 0;
+const zod_1 = require("zod");
+/**
+ * HTTP Metadata Cache Protocol
+ *
+ * Implements efficient HTTP-level metadata caching with ETag support.
+ * Implements P0 requirement for ObjectStack kernel.
+ *
+ * ## Caching in ObjectStack
+ *
+ * **HTTP Cache (`api/http-cache.zod.ts`) - This File**
+ * - **Purpose**: Cache API responses at HTTP protocol level
+ * - **Technologies**: HTTP headers (ETag, Last-Modified, Cache-Control), CDN
+ * - **Configuration**: Cache-Control headers, validation tokens
+ * - **Use case**: Reduce API response time for repeated metadata requests
+ * - **Scope**: HTTP layer, client-server communication
+ *
+ * **Application Cache (`system/cache.zod.ts`)**
+ * - **Purpose**: Cache computed data, query results, aggregations
+ * - **Technologies**: Redis, Memcached, in-memory LRU
+ * - **Configuration**: TTL, eviction policies, cache warming
+ * - **Use case**: Cache expensive database queries, computed values
+ * - **Scope**: Application layer, server-side data storage
+ *
+ * ## Features
+ * - ETag-based conditional requests (HTTP 304 Not Modified)
+ * - Cache-Control directives
+ * - Metadata versioning
+ * - Selective cache invalidation
+ *
+ * Industry alignment: HTTP Caching (RFC 7234), Salesforce Metadata API
+ *
+ * @see ../../system/cache.zod.ts for application-level caching
+ */
+// ==========================================
+// Cache Control Headers
+// ==========================================
+/**
+ * Cache Control Directive Enum
+ * Standard HTTP cache control directives
+ */
+exports.CacheDirective = zod_1.z.enum([
+    'public', // Cacheable by any cache
+    'private', // Cacheable only by user-agent
+    'no-cache', // Must revalidate with server
+    'no-store', // Never cache
+    'must-revalidate', // Must revalidate stale responses
+    'max-age', // Maximum cache age in seconds
+]);
+/**
+ * Cache Control Schema
+ * HTTP cache control configuration
+ *
+ * @example
+ * {
+ *   "directives": ["public", "max-age"],
+ *   "maxAge": 3600,
+ *   "staleWhileRevalidate": 86400
+ * }
+ */
+exports.CacheControlSchema = zod_1.z.object({
+    directives: zod_1.z.array(exports.CacheDirective).describe('Cache control directives'),
+    maxAge: zod_1.z.number().optional().describe('Maximum cache age in seconds'),
+    staleWhileRevalidate: zod_1.z.number().optional().describe('Allow serving stale content while revalidating (seconds)'),
+    staleIfError: zod_1.z.number().optional().describe('Allow serving stale content on error (seconds)'),
+});
+// ==========================================
+// ETag Support
+// ==========================================
+/**
+ * ETag Schema
+ * Entity tag for cache validation
+ *
+ * ETags can be:
+ * - Strong: Exact match required (e.g., "686897696a7c876b7e")
+ * - Weak: Semantic equivalence (e.g., W/"686897696a7c876b7e")
+ */
+exports.ETagSchema = zod_1.z.object({
+    value: zod_1.z.string().describe('ETag value (hash or version identifier)'),
+    weak: zod_1.z.boolean().optional().default(false).describe('Whether this is a weak ETag'),
+});
+// ==========================================
+// Metadata Cache Request
+// ==========================================
+/**
+ * Metadata Cache Request Schema
+ * Request with cache validation headers
+ *
+ * @example
+ * // GET /api/v1/metadata/objects/account
+ * // Headers:
+ * // If-None-Match: "686897696a7c876b7e"
+ * // If-Modified-Since: Wed, 21 Oct 2015 07:28:00 GMT
+ */
+exports.MetadataCacheRequestSchema = zod_1.z.object({
+    ifNoneMatch: zod_1.z.string().optional().describe('ETag value for conditional request (If-None-Match header)'),
+    ifModifiedSince: zod_1.z.string().datetime().optional().describe('Timestamp for conditional request (If-Modified-Since header)'),
+    cacheControl: exports.CacheControlSchema.optional().describe('Client cache control preferences'),
+});
+// ==========================================
+// Metadata Cache Response
+// ==========================================
+/**
+ * Metadata Cache Response Schema
+ * Response with cache control headers
+ *
+ * @example Success Response (200 OK)
+ * {
+ *   "data": { "object": "account" },
+ *   "etag": {
+ *     "value": "686897696a7c876b7e",
+ *     "weak": false
+ *   },
+ *   "lastModified": "2026-01-29T12:00:00Z",
+ *   "cacheControl": {
+ *     "directives": ["public", "max-age"],
+ *     "maxAge": 3600
+ *   }
+ * }
+ *
+ * @example Not Modified Response (304 Not Modified)
+ * {
+ *   "notModified": true,
+ *   "etag": {
+ *     "value": "686897696a7c876b7e"
+ *   }
+ * }
+ */
+exports.MetadataCacheResponseSchema = zod_1.z.object({
+    data: zod_1.z.any().optional().describe('Metadata payload (omitted for 304 Not Modified)'),
+    etag: exports.ETagSchema.optional().describe('ETag for this resource version'),
+    lastModified: zod_1.z.string().datetime().optional().describe('Last modification timestamp'),
+    cacheControl: exports.CacheControlSchema.optional().describe('Cache control directives'),
+    notModified: zod_1.z.boolean().optional().default(false).describe('True if resource has not been modified (304 response)'),
+    version: zod_1.z.string().optional().describe('Metadata version identifier'),
+});
+// ==========================================
+// Metadata Cache Invalidation
+// ==========================================
+/**
+ * Cache Invalidation Target Enum
+ * Specifies what to invalidate
+ */
+exports.CacheInvalidationTarget = zod_1.z.enum([
+    'all', // Invalidate all cached metadata
+    'object', // Invalidate specific object metadata
+    'field', // Invalidate specific field metadata
+    'permission', // Invalidate permission metadata
+    'layout', // Invalidate layout metadata
+    'custom', // Custom invalidation pattern
+]);
+/**
+ * Cache Invalidation Request Schema
+ * Request to invalidate cached metadata
+ *
+ * @example
+ * // POST /api/v1/metadata/cache/invalidate
+ * {
+ *   "target": "object",
+ *   "identifiers": ["account", "contact"],
+ *   "cascade": true
+ * }
+ */
+exports.CacheInvalidationRequestSchema = zod_1.z.object({
+    target: exports.CacheInvalidationTarget.describe('What to invalidate'),
+    identifiers: zod_1.z.array(zod_1.z.string()).optional().describe('Specific resources to invalidate (e.g., object names)'),
+    cascade: zod_1.z.boolean().optional().default(false).describe('If true, invalidate dependent resources'),
+    pattern: zod_1.z.string().optional().describe('Pattern for custom invalidation (supports wildcards)'),
+});
+/**
+ * Cache Invalidation Response Schema
+ * Response for cache invalidation
+ *
+ * @example
+ * {
+ *   "success": true,
+ *   "invalidated": 5,
+ *   "targets": ["account", "contact", "opportunity"]
+ * }
+ */
+exports.CacheInvalidationResponseSchema = zod_1.z.object({
+    success: zod_1.z.boolean().describe('Whether invalidation succeeded'),
+    invalidated: zod_1.z.number().describe('Number of cache entries invalidated'),
+    targets: zod_1.z.array(zod_1.z.string()).optional().describe('List of invalidated resources'),
+});
+// ==========================================
+// Metadata Cache API Methods
+// ==========================================
+/**
+ * Metadata Cache API Client Interface
+ *
+ * @example Usage
+ * // Get metadata with cache support
+ * const response = await client.meta.getCached('account', {
+ *   ifNoneMatch: '"686897696a7c876b7e"'
+ * });
+ *
+ * if (response.notModified) {
+ *   // Use cached version
+ * } else {
+ *   // Update cache with response.data
+ *   cache.set('account', response.data, {
+ *     etag: response.etag?.value,
+ *     maxAge: response.cacheControl?.maxAge
+ *   });
+ * }
+ */
+exports.MetadataCacheApi = {
+    getCached: {
+        input: exports.MetadataCacheRequestSchema,
+        output: exports.MetadataCacheResponseSchema,
+    },
+    invalidate: {
+        input: exports.CacheInvalidationRequestSchema,
+        output: exports.CacheInvalidationResponseSchema,
+    },
+};

package/dist/api/index.d.ts

@@ -5,12 +5,22 @@
  * - Request/Response schemas
  * - Error handling
  * - OData v4 compatibility
+ * - Batch operations
+ * - Metadata caching
+ * - View storage
  */
 export * from './contract.zod';
 export * from './endpoint.zod';
 export * from './discovery.zod';
 export * from './realtime.zod';
+export * from './websocket.zod';
 export * from './router.zod';
 export * from './odata.zod';
-export * from './protocol';
+export * from './graphql.zod';
+export * from './batch.zod';
+export * from './http-cache.zod';
+export * from './errors.zod';
+export * from './view-storage.zod';
+export * from './protocol.zod';
+export * from './rest-server.zod';
 //# sourceMappingURL=index.d.ts.map