@frontal-labs/ontology 1.0.1 → 1.0.4

package/dist/index.mjs

@@ -1,1132 +1,23 @@
-// ../core/dist/index.js
-import { z } from "zod";
-
-// ../../node_modules/.bun/@t3-oss+env-core@0.13.11+dcb9db7a51b27bde/node_modules/@t3-oss/env-core/dist/standard.js
-function ensureSynchronous(value, message) {
-  if (value instanceof Promise) throw new Error(message);
-}
-function parseWithDictionary(dictionary, value) {
-  const result = {};
-  const issues = [];
-  for (const key in dictionary) {
-    const propResult = dictionary[key]["~standard"].validate(value[key]);
-    ensureSynchronous(propResult, `Validation must be synchronous, but ${key} returned a Promise.`);
-    if (propResult.issues) {
-      issues.push(...propResult.issues.map((issue) => ({
-        ...issue,
-        message: issue.message,
-        path: [key, ...issue.path ?? []]
-      })));
-      continue;
-    }
-    result[key] = propResult.value;
-  }
-  if (issues.length) return { issues };
-  return { value: result };
-}
-
-// ../../node_modules/.bun/@t3-oss+env-core@0.13.11+dcb9db7a51b27bde/node_modules/@t3-oss/env-core/dist/index.js
-function createEnv(opts) {
-  const runtimeEnv = opts.runtimeEnvStrict ?? opts.runtimeEnv ?? process.env;
-  if (opts.emptyStringAsUndefined ?? false) {
-    for (const [key, value] of Object.entries(runtimeEnv)) if (value === "") delete runtimeEnv[key];
-  }
-  if (!!opts.skipValidation) {
-    if (opts.extends) for (const preset of opts.extends) preset.skipValidation = true;
-    return runtimeEnv;
-  }
-  const _client = typeof opts.client === "object" ? opts.client : {};
-  const _server = typeof opts.server === "object" ? opts.server : {};
-  const _shared = typeof opts.shared === "object" ? opts.shared : {};
-  const isServer = opts.isServer ?? (typeof window === "undefined" || "Deno" in window);
-  const finalSchemaShape = isServer ? {
-    ..._server,
-    ..._shared,
-    ..._client
-  } : {
-    ..._client,
-    ..._shared
-  };
-  const parsed = opts.createFinalSchema?.(finalSchemaShape, isServer)?.["~standard"].validate(runtimeEnv) ?? parseWithDictionary(finalSchemaShape, runtimeEnv);
-  ensureSynchronous(parsed, "Validation must be synchronous");
-  const onValidationError = opts.onValidationError ?? ((issues) => {
-    console.error("\u274C Invalid environment variables:", issues);
-    throw new Error("Invalid environment variables");
-  });
-  const onInvalidAccess = opts.onInvalidAccess ?? (() => {
-    throw new Error("\u274C Attempted to access a server-side environment variable on the client");
-  });
-  if (parsed.issues) return onValidationError(parsed.issues);
-  const isServerAccess = (prop) => {
-    if (!opts.clientPrefix) return true;
-    return !prop.startsWith(opts.clientPrefix) && !(prop in _shared);
-  };
-  const isValidServerAccess = (prop) => {
-    return isServer || !isServerAccess(prop);
-  };
-  const ignoreProp = (prop) => {
-    return prop === "__esModule" || prop === "$$typeof";
-  };
-  const extendedObj = (opts.extends ?? []).reduce((acc, curr) => {
-    return Object.assign(acc, curr);
-  }, {});
-  const fullObj = Object.assign(extendedObj, parsed.value);
-  return new Proxy(fullObj, { get(target, prop) {
-    if (typeof prop !== "string") return void 0;
-    if (ignoreProp(prop)) return void 0;
-    if (!isValidServerAccess(prop)) return onInvalidAccess(prop);
-    return Reflect.get(target, prop);
-  } });
-}
-
-// ../core/dist/index.js
-import { z as z2 } from "zod";
-import { z as z3 } from "zod";
-import { z as z4 } from "zod";
-var DEFAULT_BASE_URL = "https://api.frontal.dev/v1";
-var API_KEY_PREFIX = "frt_";
-var BACKOFF_STRATEGIES = [
-  "exponential",
-  "linear",
-  "constant"
-];
-var DEFAULT_RETRY_ON = [429, 500, 502, 503, 504];
-var EXPONENTIAL_BASE = 2;
-var JITTER_MAX = 200;
-var SDK_VERSION = "1.0.1";
-var timestampSchema = z.date().transform((date) => new Date(date));
-var responseMetaSchema = z.object({
-  requestId: z.string().min(1),
-  timestamp: timestampSchema,
-  version: z.string().optional(),
-  substrate: z.string().optional(),
-  latency: z.object({
-    total: z.number().int().min(0),
-    substrate: z.number().int().min(0).optional()
-  }).optional()
-}).strict();
-var paginationMetaSchema = z.object({
-  cursor: z.string().min(1),
-  hasMore: z.boolean(),
-  limit: z.number().int().positive().optional(),
-  total: z.number().int().min(0).optional(),
-  offset: z.number().int().min(0).optional()
-}).strict();
-var errorFieldSchema = z.object({
-  field: z.string().describe("Field name"),
-  code: z.string().describe("Error code"),
-  message: z.string().describe("Error message")
-}).strict();
-var docsUrlSchema = z.string().url().refine((url) => /^https?:\/\//.test(url), {
-  message: "docs must be an http or https URL"
-});
-var errorResponseSchema = z.object({
-  code: z.string().min(1).describe("Error code"),
-  message: z.string().min(1).describe("Error message"),
-  requestId: z.string().min(1).describe("Request ID"),
-  docs: docsUrlSchema.optional().describe("Documentation URL"),
-  fields: z.array(errorFieldSchema).optional().describe("Array of error fields")
-}).strict();
-var retryStatusCodeSchema = z.number().int().refine((status) => status === 429 || status >= 500 && status <= 599, {
-  message: "Retry status codes must be 429 or 5xx"
-});
-var retryConfigSchema = z.object({
-  maxAttempts: z.number().int().positive().default(3),
-  baseDelay: z.number().int().positive().default(1e3),
-  strategy: z.enum(BACKOFF_STRATEGIES).default("exponential"),
-  on: z.array(retryStatusCodeSchema).default(DEFAULT_RETRY_ON),
-  jitter: z.boolean().default(true)
-}).strict().default({
-  maxAttempts: 3,
-  baseDelay: 1e3,
-  strategy: "exponential",
-  on: DEFAULT_RETRY_ON,
-  jitter: true
-});
-var numericValueSchema = z.union([
-  z.number(),
-  z.literal(Number.POSITIVE_INFINITY),
-  z.literal(Number.NEGATIVE_INFINITY)
-]);
-var arrayFilterValueSchema = z.union([
-  z.array(z.string()),
-  z.array(numericValueSchema)
-]);
-var scalarFilterValueSchema = z.union([
-  z.string(),
-  numericValueSchema,
-  z.boolean(),
-  z.date(),
-  z.null(),
-  arrayFilterValueSchema
-]);
-var comparableValueSchema = z.union([numericValueSchema, z.date()]);
-var filterOperatorSchema = z.object({
-  eq: scalarFilterValueSchema.optional(),
-  ne: scalarFilterValueSchema.optional(),
-  gt: comparableValueSchema.optional(),
-  gte: comparableValueSchema.optional(),
-  lt: comparableValueSchema.optional(),
-  lte: comparableValueSchema.optional(),
-  in: arrayFilterValueSchema.optional(),
-  nin: arrayFilterValueSchema.optional(),
-  contains: z.string().optional(),
-  startsWith: z.string().optional(),
-  endsWith: z.string().optional()
-}).strict().refine(
-  (value) => Object.values(value).some((entry) => entry !== void 0),
-  {
-    message: "At least one filter operator is required"
-  }
-);
-var filterValueSchema = z.union([
-  scalarFilterValueSchema,
-  filterOperatorSchema
-]);
-var filterConditionsSchema = z.record(z.string(), filterValueSchema);
-var pageResultSchema = z.object({
-  data: z.array(z.unknown()),
-  meta: responseMetaSchema.optional(),
-  pagination: paginationMetaSchema
-}).strict();
-var FrontalError = class extends Error {
-  code;
-  requestId;
-  statusCode;
-  docs;
-  rateLimit;
-  /**
-   * @param response - The parsed error response from the API.
-   * @param statusCode - The HTTP status code.
-   * @param rateLimit - Optional rate-limit headers from the response.
-   */
-  constructor(response, statusCode, rateLimit) {
-    super(response.message);
-    this.name = "FrontalError";
-    this.code = response.code;
-    this.requestId = response.requestId;
-    this.statusCode = statusCode;
-    this.docs = response.docs;
-    this.rateLimit = rateLimit;
-    Object.setPrototypeOf(this, new.target.prototype);
-    if (Error.captureStackTrace) {
-      Error.captureStackTrace(this);
-    }
-  }
-};
-var NotFoundError = class extends FrontalError {
-  constructor(r, rateLimit) {
-    super(r, 404, rateLimit);
-    this.name = "NotFoundError";
-  }
-};
-var UnauthorizedError = class extends FrontalError {
-  constructor(r, rateLimit) {
-    super(r, 401, rateLimit);
-    this.name = "UnauthorizedError";
-  }
-};
-var ForbiddenError = class extends FrontalError {
-  constructor(r, rateLimit) {
-    super(r, 403, rateLimit);
-    this.name = "ForbiddenError";
-  }
-};
-var ValidationError = class extends FrontalError {
-  /** Per-field validation errors returned by the API. */
-  fields;
-  constructor(r, rateLimit) {
-    super(r, 400, rateLimit);
-    this.name = "ValidationError";
-    this.fields = r.fields ?? [];
-  }
-};
-var ConflictError = class extends FrontalError {
-  constructor(r, rateLimit) {
-    super(r, 409, rateLimit);
-    this.name = "ConflictError";
-  }
-};
-var RateLimitError = class extends FrontalError {
-  /** Recommended delay in seconds before retrying. */
-  retryAfter;
-  constructor(r, retryAfter, rateLimit) {
-    super(r, 429, rateLimit);
-    this.name = "RateLimitError";
-    this.retryAfter = retryAfter;
-  }
-};
-var ServiceError = class extends FrontalError {
-  constructor(r, status, rateLimit) {
-    super(r, status, rateLimit);
-    this.name = "ServiceError";
-  }
-};
-var NetworkError = class extends Error {
-  constructor(cause) {
-    super("Network error \u2014 could not reach Frontal API");
-    this.cause = cause;
-    this.name = "NetworkError";
-    Object.setPrototypeOf(this, new.target.prototype);
-    if (Error.captureStackTrace) {
-      Error.captureStackTrace(this, new.target);
-    }
-  }
-};
-function normalizeErrorBody(body) {
-  const parsed = errorResponseSchema.safeParse(body);
-  if (parsed.success) return parsed.data;
-  const fallback = typeof body === "object" && body !== null ? body : {};
-  const code = typeof fallback.code === "string" && fallback.code.length > 0 ? fallback.code : "UNKNOWN_ERROR";
-  const hasExplicitCode = typeof fallback.code === "string" && fallback.code.length > 0;
-  const message = hasExplicitCode && typeof fallback.message === "string" && fallback.message.length > 0 ? fallback.message : "An unknown error occurred";
-  return {
-    code,
-    message,
-    requestId: typeof fallback.requestId === "string" && fallback.requestId.length > 0 ? fallback.requestId : "unknown",
-    docs: typeof fallback.docs === "string" ? fallback.docs : void 0,
-    fields: Array.isArray(fallback.fields) ? fallback.fields : void 0
-  };
-}
-function parseFrontalError(body, status, retryAfter, rateLimit) {
-  const normalized = normalizeErrorBody(body);
-  switch (status) {
-    case 400:
-      return new ValidationError(normalized, rateLimit);
-    case 401:
-      return new UnauthorizedError(normalized, rateLimit);
-    case 403:
-      return new ForbiddenError(normalized, rateLimit);
-    case 404:
-      return new NotFoundError(normalized, rateLimit);
-    case 409:
-      return new ConflictError(normalized, rateLimit);
-    case 429: {
-      const parsedRetry = retryAfter ? Number.parseInt(retryAfter, 10) : Number.NaN;
-      return new RateLimitError(
-        normalized,
-        Number.isFinite(parsedRetry) ? parsedRetry : 60,
-        rateLimit
-      );
-    }
-    default:
-      return new ServiceError(normalized, status, rateLimit);
-  }
-}
-var CircuitBreaker = class {
-  failures = 0;
-  lastFailureTime = 0;
-  state = "CLOSED";
-  config;
-  constructor(config) {
-    this.config = config;
-  }
-  /** Returns the current circuit state. */
-  getState() {
-    return this.state;
-  }
-  /** Returns the current consecutive failure count. */
-  getFailures() {
-    return this.failures;
-  }
-  reset() {
-    this.failures = 0;
-    this.state = "CLOSED";
-    this.config.onClose?.();
-  }
-  /**
-   * Executes an async function through the circuit breaker.
-   * Throws CircuitBreakerOpenError immediately if the circuit is OPEN
-   * and the reset timeout has not elapsed. On success in HALF_OPEN state,
-   * resets the circuit to CLOSED.
-   *
-   * @param fn - The async operation to protect.
-   * @throws {CircuitBreakerOpenError} If the circuit is OPEN.
-   */
-  async execute(fn) {
-    if (this.state === "OPEN") {
-      if (Date.now() - this.lastFailureTime > this.config.resetTimeoutMs) {
-        this.state = "HALF_OPEN";
-        this.config.onHalfOpen?.();
-      } else {
-        throw new CircuitBreakerOpenError(
-          this.config.resetTimeoutMs - (Date.now() - this.lastFailureTime)
-        );
-      }
-    }
-    try {
-      const result = await fn();
-      if (this.state === "HALF_OPEN") {
-        this.reset();
-      }
-      return result;
-    } catch (error) {
-      this.failures++;
-      this.lastFailureTime = Date.now();
-      if (this.failures >= this.config.failureThreshold) {
-        this.state = "OPEN";
-        this.config.onOpen?.();
-      }
-      throw error;
-    }
-  }
-  /** Manually forces the circuit into the OPEN state. */
-  forceOpen() {
-    this.state = "OPEN";
-    this.lastFailureTime = Date.now();
-  }
-  /** Manually resets the circuit to the CLOSED state. */
-  forceClose() {
-    this.reset();
-  }
-};
-var CircuitBreakerOpenError = class extends Error {
-  /** Milliseconds remaining until the circuit transitions to HALF_OPEN. */
-  retryAfterMs;
-  constructor(retryAfterMs) {
-    super(
-      `Circuit breaker is open \u2014 retry after ${Math.ceil(retryAfterMs / 1e3)}s`
-    );
-    this.name = "CircuitBreakerOpenError";
-    this.retryAfterMs = retryAfterMs;
-    Object.setPrototypeOf(this, new.target.prototype);
-  }
-};
-function computeBaseDelay(attempt, strategy, baseDelay) {
-  const normalizedAttempt = Math.floor(attempt);
-  switch (strategy) {
-    case "linear":
-      return Math.max(0, baseDelay * (normalizedAttempt + 1));
-    case "constant":
-      return baseDelay;
-    default:
-      return baseDelay * EXPONENTIAL_BASE ** normalizedAttempt;
-  }
-}
-function calculateDelay(attempt, strategyOrConfig, baseDelay, withJitter = false) {
-  if (typeof strategyOrConfig === "object") {
-    const strategy = "strategy" in strategyOrConfig ? strategyOrConfig.strategy : strategyOrConfig.backoff;
-    const delayBase = "baseDelay" in strategyOrConfig ? strategyOrConfig.baseDelay : strategyOrConfig.retryDelay;
-    const delay2 = computeBaseDelay(attempt, strategy, delayBase);
-    const shouldJitter = "jitter" in strategyOrConfig ? Boolean(strategyOrConfig.jitter) : true;
-    if (!shouldJitter) return delay2;
-    return delay2 + Math.random() * (JITTER_MAX / 2);
-  }
-  const delay = computeBaseDelay(
-    attempt,
-    strategyOrConfig,
-    Math.max(0, baseDelay ?? 0)
-  );
-  if (!withJitter) return delay;
-  return delay + Math.random() * (JITTER_MAX / 2);
-}
-function snakeToCamel(str) {
-  const prefix = str.match(/^_+/)?.[0] ?? "";
-  const body = str.slice(prefix.length);
-  if (!body) return str;
-  return prefix + body.replace(/_([a-z0-9])/g, (_, c) => c.toUpperCase());
-}
-function camelToSnake(str) {
-  return str.replace(/([A-Z]+)([A-Z][a-z])/g, "$1_$2").replace(/([a-z0-9])([A-Z])/g, "$1_$2").toLowerCase();
-}
-var NEVER_TRANSFORM_KEYS = /* @__PURE__ */ new Set(["$ref", "$schema", "$id"]);
-function isStream(obj) {
-  return typeof obj === "object" && obj !== null && (typeof obj.pipe === "function" || typeof obj.getReader === "function");
-}
-function deepTransformKeys(obj, transform, skipKeys) {
-  if (obj === null || obj === void 0) return obj;
-  if (typeof obj !== "object") return obj;
-  if (obj instanceof Date || typeof Buffer !== "undefined" && obj instanceof Buffer || obj instanceof RegExp || obj instanceof FormData || obj instanceof File || obj instanceof Blob)
-    return obj;
-  if (isStream(obj)) return obj;
-  if (Array.isArray(obj)) {
-    return obj.map(
-      (item) => deepTransformKeys(item, transform, skipKeys)
-    );
-  }
-  const proto = Object.getPrototypeOf(obj);
-  if (proto !== Object.prototype && proto !== null) return obj;
-  const result = {};
-  for (const key of Object.keys(obj)) {
-    const shouldSkip = skipKeys?.has(key) || NEVER_TRANSFORM_KEYS.has(key);
-    const newKey = shouldSkip ? key : transform(key);
-    result[newKey] = deepTransformKeys(
-      obj[key],
-      transform,
-      skipKeys
-    );
-  }
-  return result;
-}
-function deepCamelToSnake(obj, skipKeys) {
-  return deepTransformKeys(obj, camelToSnake, skipKeys);
-}
-function deepSnakeToCamel(obj, skipKeys) {
-  return deepTransformKeys(obj, snakeToCamel, skipKeys);
-}
-var HttpClient = class {
-  constructor(config) {
-    this.config = config;
-    if (config.circuitBreaker) {
-      this.breaker = new CircuitBreaker({
-        failureThreshold: config.circuitBreaker.failureThreshold,
-        resetTimeoutMs: config.circuitBreaker.resetTimeoutMs
-      });
-    }
-  }
-  breaker;
-  /**
-   * Sends a GET request.
-   * @param path - API endpoint path.
-   * @param params - Optional query parameters.
-   * @param schema - Optional Zod schema for response validation.
-   */
-  async get(path, params, schema) {
-    return this.request("GET", path, void 0, params, schema);
-  }
-  /**
-   * Sends a POST request with a JSON body.
-   * @param path - API endpoint path.
-   * @param body - Request payload (converted to snake_case automatically).
-   * @param schema - Optional Zod schema for response validation.
-   */
-  async post(path, body, schema) {
-    return this.request("POST", path, body ?? {}, void 0, schema);
-  }
-  /**
-   * Sends a PUT request with a JSON body.
-   * @param path - API endpoint path.
-   * @param body - Request payload (converted to snake_case automatically).
-   * @param schema - Optional Zod schema for response validation.
-   */
-  async put(path, body, schema) {
-    return this.request("PUT", path, body ?? {}, void 0, schema);
-  }
-  /**
-   * Sends a PATCH request with a JSON body.
-   * @param path - API endpoint path.
-   * @param body - Request payload (converted to snake_case automatically).
-   * @param schema - Optional Zod schema for response validation.
-   */
-  async patch(path, body, schema) {
-    return this.request("PATCH", path, body ?? {}, void 0, schema);
-  }
-  /**
-   * Sends a DELETE request.
-   * @param path - API endpoint path.
-   * @param params - Optional query parameters.
-   * @param schema - Optional Zod schema for response validation.
-   */
-  async delete(path, params, schema) {
-    return this.request("DELETE", path, {}, params, schema);
-  }
-  /**
-   * Sends a raw PUT request with a binary/stream body.
-   * @param path - API endpoint path.
-   * @param body - Binary buffer or readable stream.
-   * @param contentType - MIME type of the body.
-   * @param headers - Additional request headers.
-   * @returns The parsed JSON response with keys converted to camelCase.
-   */
-  async putRaw(path, body, contentType, headers = {}) {
-    const url = this.buildUrl(path);
-    const res = await this.fetchWithTimeout(url, {
-      method: "PUT",
-      headers: this.buildHeaders({ "Content-Type": contentType, ...headers }),
-      body
-    });
-    if (!res.ok) await this.throwError(res);
-    if (res.status === 204) return void 0;
-    const json = await res.json();
-    return typeof json === "object" && json !== null ? deepSnakeToCamel(json) : json;
-  }
-  /**
-   * Opens a GET SSE stream, yielding parsed server-sent events.
-   * @param path - API endpoint path.
-   * @param params - Optional query parameters.
-   * @yields SSE event objects with `type`, `data`, and optional `id` fields.
-   */
-  async *stream(path, params) {
-    const url = this.buildUrl(path, params);
-    const res = await this.fetchWithTimeout(url, {
-      method: "GET",
-      headers: this.buildHeaders({ Accept: "text/event-stream" })
-    });
-    if (!res.ok) await this.throwError(res);
-    yield* this.parseSSEResponse(res);
-  }
-  /**
-   * Sends a POST request that returns an SSE stream.
-   * @param path - API endpoint path.
-   * @param body - Request payload (converted to snake_case automatically).
-   * @yields SSE event objects with `type`, `data`, and optional `id` fields.
-   */
-  async *postStream(path, body) {
-    const url = this.buildUrl(path);
-    const res = await this.fetchWithTimeout(url, {
-      method: "POST",
-      headers: this.buildHeaders({ Accept: "text/event-stream" }),
-      body: JSON.stringify(body ?? {})
-    });
-    if (!res.ok) await this.throwError(res);
-    yield* this.parseSSEResponse(res);
-  }
-  /**
-   * Sends a POST request and returns the raw Response object.
-   * @param path - API endpoint path.
-   * @param body - Request payload.
-   * @param headers - Additional request headers.
-   * @returns The raw fetch Response (caller must handle parsing).
-   */
-  async postRaw(path, body, headers = {}) {
-    const url = this.buildUrl(path);
-    const res = await this.fetchWithTimeout(url, {
-      method: "POST",
-      headers: new Headers(this.buildHeaders(headers)),
-      body: JSON.stringify(body ?? {})
-    });
-    if (!res.ok) await this.throwError(res);
-    return res;
-  }
-  /**
-   * Sends a POST request with a FormData body (multipart/form-data).
-   * Automatically removes the Content-Type header so the browser sets the
-   * correct multipart boundary.
-   * @param path - API endpoint path.
-   * @param formData - FormData payload.
-   * @param headers - Additional request headers.
-   * @returns The parsed JSON response with keys converted to camelCase.
-   */
-  async postFormData(path, formData, headers = {}) {
-    const url = this.buildUrl(path);
-    const merged = new Headers(this.buildHeaders(headers));
-    merged.delete("Content-Type");
-    const res = await this.fetchWithTimeout(url, {
-      method: "POST",
-      headers: merged,
-      body: formData
-    });
-    if (!res.ok) await this.throwError(res);
-    const json = await res.json();
-    return deepSnakeToCamel(json);
-  }
-  /**
-   * Sends a raw GET request and returns the Response object directly.
-   * @param path - API endpoint path.
-   * @param params - Optional query parameters.
-   * @param headers - Additional request headers.
-   * @returns The raw fetch Response (caller must handle parsing).
-   */
-  async getRaw(path, params, headers = {}) {
-    const url = this.buildUrl(path, params);
-    const res = await this.fetchWithTimeout(url, {
-      method: "GET",
-      headers: this.buildHeaders(headers)
-    });
-    if (!res.ok) await this.throwError(res);
-    return res;
-  }
-  async *parseSSEResponse(res) {
-    if (!res.body) return;
-    const reader = res.body.getReader();
-    const decoder = new TextDecoder();
-    let buffer = "";
-    while (true) {
-      const { done, value } = await reader.read();
-      if (done) break;
-      buffer += decoder.decode(value, { stream: true });
-      const lines = buffer.split("\n");
-      buffer = lines.pop() ?? "";
-      let event = {
-        type: "message",
-        data: null
-      };
-      for (const rawLine of lines) {
-        const line = rawLine.trimEnd();
-        if (line.startsWith("id:")) {
-          event.id = line.slice(3).trim();
-        } else if (line.startsWith("event:")) {
-          event.type = line.slice(6).trim();
-        } else if (line.startsWith("data:")) {
-          const payload = line.slice(5).trim();
-          try {
-            const parsed = JSON.parse(payload);
-            event.data = typeof parsed === "object" && parsed !== null ? deepSnakeToCamel(parsed) : parsed;
-          } catch {
-            event.data = payload;
-          }
-        } else if (line === "") {
-          if (event.data !== null) yield event;
-          event = { type: "message", data: null };
-        }
-      }
-    }
-  }
-  async request(method, path, body, params, schema, attempt = 0) {
-    const url = this.buildUrl(path, params);
-    const requestId = crypto.randomUUID();
-    const transformedBody = body !== void 0 && body !== null ? deepCamelToSnake(body) : body;
-    const reqInit = {
-      method,
-      headers: this.buildHeaders({ "X-Request-Id": requestId }),
-      ...method !== "GET" ? { body: JSON.stringify(transformedBody ?? {}) } : { body: void 0 }
-    };
-    this.config.logger?.request?.(method, url, reqInit);
-    const executeRequest = async () => {
-      try {
-        return await this.fetchWithTimeout(url, reqInit);
-      } catch (error) {
-        this.config.logger?.error?.(error);
-        throw new NetworkError(error);
-      }
-    };
-    let res;
-    try {
-      res = this.breaker ? await this.breaker.execute(executeRequest) : await executeRequest();
-    } catch (error) {
-      if (error instanceof CircuitBreakerOpenError) {
-        throw new Error(
-          `Circuit breaker is open. Retry after ${Math.ceil(error.retryAfterMs / 1e3)}s.`
-        );
-      }
-      throw error;
-    }
-    this.config.logger?.response?.(res);
-    if (!res.ok) {
-      const shouldRetry = [429, 500, 502, 503, 504].includes(res.status) && attempt < this.config.maxRetries;
-      if (shouldRetry) {
-        const retryAfterValue = res.headers.get("Retry-After");
-        const retryAfterSeconds = retryAfterValue ? Number.parseInt(retryAfterValue, 10) : Number.NaN;
-        const delay = Number.isFinite(retryAfterSeconds) ? retryAfterSeconds * 1e3 : calculateDelay(
-          attempt,
-          "exponential",
-          this.config.retryDelay,
-          true
-        );
-        await sleep(delay);
-        return this.request(method, path, body, params, schema, attempt + 1);
-      }
-      await this.throwError(res);
-    }
-    if (res.status === 204) return void 0;
-    const contentType = (res.headers.get("content-type") || "").toLowerCase();
-    const payload = contentType.includes("application/json") ? await res.json() : await res.text();
-    const transformedPayload = typeof payload === "object" && payload !== null ? deepSnakeToCamel(payload) : payload;
-    if (schema) {
-      try {
-        const parsed = schema.safeParse(transformedPayload);
-        if (!parsed.success) {
-          this.config.logger?.error?.(parsed.error);
-          throw parsed.error;
-        }
-        return parsed.data;
-      } catch (error) {
-        if (error instanceof Error && error.message.includes("_zod")) {
-          return transformedPayload;
-        }
-        throw error;
-      }
-    }
-    return transformedPayload;
-  }
-  parseRateLimit(res) {
-    const limit = res.headers.get("X-RateLimit-Limit");
-    const remaining = res.headers.get("X-RateLimit-Remaining");
-    const reset = res.headers.get("X-RateLimit-Reset");
-    if (limit && remaining && reset) {
-      return {
-        limit: Number.parseInt(limit, 10),
-        remaining: Number.parseInt(remaining, 10),
-        reset: Number.parseInt(reset, 10)
-      };
-    }
-    return void 0;
-  }
-  async throwError(res) {
-    let body;
-    try {
-      body = await res.json();
-    } catch {
-      body = {};
-    }
-    const retryAfter = res.headers.get("Retry-After") ?? void 0;
-    const rateLimit = this.parseRateLimit(res);
-    throw parseFrontalError(body, res.status, retryAfter, rateLimit);
-  }
-  buildUrl(path, params) {
-    const base = this.config.baseUrl.replace(/\/$/, "");
-    let normalizedPath = path.startsWith("/") ? path : `/${path}`;
-    if (base.endsWith("/v1") && normalizedPath.startsWith("/v1/")) {
-      if (this.config.debug) {
-        console.warn(
-          `[SDK] Double /v1/ prefix detected and normalized. The base URL already includes "/v1" but the route "${normalizedPath}" also starts with "/v1/". Write routes without a leading "/v1".`
-        );
-      }
-      normalizedPath = normalizedPath.slice("/v1".length);
-    }
-    const url = `${base}${normalizedPath}`;
-    const transformedParams = params ? deepCamelToSnake(params) : params;
-    if (!transformedParams || Object.keys(transformedParams).length === 0) {
-      return url;
-    }
-    const query = Object.entries(transformedParams).filter(([, value]) => value !== void 0 && value !== null).map(
-      ([key, value]) => `${encodeURIComponent(key)}=${encodeURIComponent(String(value))}`
-    ).join("&");
-    return query ? `${url}?${query}` : url;
-  }
-  buildHeaders(extra = {}) {
-    return {
-      // The opaque API key (`frt_…`) is the sole public credential. The platform
-      // edge validates it and exchanges it for a short-lived JWT before reaching
-      // any service — the SDK never sees or sends a JWT.
-      Authorization: `Bearer ${this.config.apiKey}`,
-      "Content-Type": "application/json",
-      Accept: "application/json",
-      "User-Agent": "@frontal-labs/core",
-      "X-Frontal-Core": `typescript@${SDK_VERSION}`,
-      "X-Frontal-Environment": this.config.environment,
-      ...this.config.headers,
-      ...extra
-    };
-  }
-  async fetchWithTimeout(url, init) {
-    const controller = new AbortController();
-    const timer = setTimeout(() => controller.abort(), this.config.timeout);
-    try {
-      return await (this.config.fetch ?? fetch)(url, {
-        ...init,
-        signal: controller.signal
-      });
-    } finally {
-      clearTimeout(timer);
-    }
-  }
-};
-var sleep = async (ms) => new Promise((resolve) => {
-  setTimeout(resolve, ms);
-});
-var apiKeySchema = z2.string().min(9, "FRONTAL_API_KEY must be at least 9 characters").max(128, "FRONTAL_API_KEY must be at most 128 characters").refine(
-  (val) => /^frt_[A-Za-z0-9_]+$/.test(val) || /^fr_typed[A-Za-z0-9_]+$/.test(val),
-  "FRONTAL_API_KEY must start with frt_"
-);
-var debugSchema = z2.union([
-  z2.literal("true"),
-  z2.literal("false"),
-  z2.literal("1"),
-  z2.literal("0")
-]).optional().default("false").transform((val) => val === "true" || val === "1");
-var env = createEnv({
-  server: {
-    FRONTAL_ENV: z2.enum(["development", "test", "production"]).default("development"),
-    FRONTAL_API_KEY: apiKeySchema.optional(),
-    FRONTAL_API_URL: z2.url("FRONTAL_API_URL must be a valid URL").optional(),
-    FRONTAL_DEBUG: debugSchema
-  },
-  runtimeEnv: {
-    FRONTAL_ENV: process.env.FRONTAL_ENV,
-    FRONTAL_API_KEY: process.env.FRONTAL_API_KEY,
-    FRONTAL_API_URL: process.env.FRONTAL_API_URL,
-    FRONTAL_DEBUG: process.env.FRONTAL_DEBUG
-  },
-  emptyStringAsUndefined: true
-});
-var unwrapClientError = (error) => {
-  if (error instanceof NetworkError) {
-    if (error.cause instanceof Error) {
-      throw error.cause;
-    }
-    throw new Error(String(error.cause));
-  }
-  throw error;
-};
-var FrontalClient = class {
-  config;
-  _http;
-  /**
-   * @param config - Validated client configuration output from clientConfigSchema.
-   */
-  constructor(config) {
-    Object.defineProperty(this, "config", {
-      value: config,
-      writable: false,
-      enumerable: true
-    });
-    const http = new HttpClient(config);
-    Object.defineProperty(this, "_http", {
-      value: http,
-      writable: false,
-      enumerable: true
-    });
-    Object.defineProperty(this, "httpClient", {
-      get() {
-        return http;
-      },
-      enumerable: true
-    });
-  }
-  /** Public accessor for the underlying HttpClient. */
-  get httpClient() {
-    return this._http;
-  }
-  /**
-   * Sends a GET request and optionally validates the response against a schema.
-   * @param path - API endpoint path.
-   * @param schema - Optional Zod schema for response validation.
-   */
-  async get(path, schema) {
-    try {
-      return await this._http.get(path, void 0, schema);
-    } catch (error) {
-      throw unwrapClientError(error);
-    }
-  }
-  /**
-   * Sends a POST request with an optional JSON body and response schema.
-   * @param path - API endpoint path.
-   * @param body - Request payload (converted to snake_case automatically).
-   * @param schema - Optional Zod schema for response validation.
-   */
-  async post(path, body, schema) {
-    try {
-      return await this._http.post(path, body, schema);
-    } catch (error) {
-      throw unwrapClientError(error);
-    }
-  }
-  /**
-   * Sends a PUT request with an optional JSON body and response schema.
-   * @param path - API endpoint path.
-   * @param body - Request payload (converted to snake_case automatically).
-   * @param schema - Optional Zod schema for response validation.
-   */
-  async put(path, body, schema) {
-    try {
-      return await this._http.put(path, body, schema);
-    } catch (error) {
-      throw unwrapClientError(error);
-    }
-  }
-  /**
-   * Sends a PATCH request with an optional JSON body and response schema.
-   * @param path - API endpoint path.
-   * @param body - Request payload (converted to snake_case automatically).
-   * @param schema - Optional Zod schema for response validation.
-   */
-  async patch(path, body, schema) {
-    try {
-      return await this._http.patch(path, body, schema);
-    } catch (error) {
-      throw unwrapClientError(error);
-    }
-  }
-  /**
-   * Sends a DELETE request with optional query parameters and response schema.
-   * @param path - API endpoint path.
-   * @param params - Query parameters (converted to snake_case automatically).
-   * @param schema - Optional Zod schema for response validation.
-   */
-  async delete(path, params, schema) {
-    try {
-      return await this._http.delete(path, params, schema);
-    } catch (error) {
-      throw unwrapClientError(error);
-    }
-  }
-  /**
-   * Opens a GET SSE stream and yields parsed server-sent events.
-   * @param path - API endpoint path.
-   * @param params - Optional query parameters.
-   * @yields Objects with `type`, `data`, and optional `id` fields from SSE events.
-   */
-  async *stream(path, params) {
-    try {
-      yield* this._http.stream(path, params);
-    } catch (error) {
-      throw unwrapClientError(error);
-    }
-  }
-  /**
-   * Sends a raw PUT request with a binary/stream body and custom content type.
-   * @param path - API endpoint path.
-   * @param body - Binary buffer or readable stream to upload.
-   * @param contentType - MIME type of the body.
-   * @param headers - Additional request headers.
-   * @returns The parsed JSON response (keys converted to camelCase).
-   */
-  async putRaw(path, body, contentType, headers = {}) {
-    try {
-      return await this._http.putRaw(path, body, contentType, headers);
-    } catch (error) {
-      throw unwrapClientError(error);
-    }
-  }
-};
-var getDefaultClient = () => {
-  if (!env.FRONTAL_API_KEY) {
-    throw new Error(
-      "FRONTAL_API_KEY environment variable is required. Set it in your environment or pass apiKey explicitly to new FrontalClient()."
-    );
-  }
-  return new FrontalClient({
-    apiKey: env.FRONTAL_API_KEY,
-    baseUrl: env.FRONTAL_API_URL ?? DEFAULT_BASE_URL,
-    timeout: 3e4,
-    maxRetries: 3,
-    retryDelay: 1e3,
-    headers: {},
-    environment: env.FRONTAL_ENV,
-    debug: env.FRONTAL_DEBUG
-  });
-};
-var API_KEY_PATTERN = new RegExp(`^${API_KEY_PREFIX}[A-Za-z0-9_-]+$`);
-var loggerFnSchema = z3.custom(
-  (value) => typeof value === "function",
-  "Expected function"
-);
-var headersSchema = z3.record(z3.string(), z3.string()).superRefine((headers, ctx) => {
-  for (const key of Object.keys(headers)) {
-    if (key.trim().length === 0) {
-      ctx.addIssue({
-        code: z3.ZodIssueCode.custom,
-        message: "Header names must be non-empty",
-        path: []
-      });
-      return;
-    }
-  }
-}).default({});
-var clientConfigSchema = z3.object({
-  apiKey: z3.string().min(9, "apiKey is required").regex(API_KEY_PATTERN, `apiKey must start with "${API_KEY_PREFIX}"`),
-  baseUrl: z3.string().url().refine(
-    (value) => value.startsWith("https://") || value.startsWith("http://"),
-    {
-      message: "baseUrl must use http or https"
-    }
-  ).default(DEFAULT_BASE_URL),
-  timeout: z3.number().int().positive().default(3e4),
-  maxRetries: z3.number().int().min(0).max(10).default(3),
-  retryDelay: z3.number().int().positive().default(1e3),
-  headers: headersSchema,
-  environment: z3.string().default("production"),
-  debug: z3.boolean().default(false),
-  fetch: z3.custom((value) => typeof value === "function").optional(),
-  logger: z3.object({
-    request: loggerFnSchema.optional(),
-    response: loggerFnSchema.optional(),
-    error: loggerFnSchema.optional()
-  }).optional(),
-  circuitBreaker: z3.object({
-    failureThreshold: z3.number().int().positive().default(5),
-    resetTimeoutMs: z3.number().int().positive().default(3e4)
-  }).optional()
-}).strict();
-function asPagePayload(raw) {
-  return raw;
-}
-var paginationSchema = z4.object({
-  cursor: z4.string().min(1),
-  hasMore: z4.boolean(),
-  total: z4.number().int().min(0).optional(),
-  limit: z4.number().int().positive().optional(),
-  offset: z4.number().int().min(0).optional()
-}).strict();
-function buildPageResult(data, pagination, fetchNext, meta) {
-  let nextPagePromise = null;
-  const page = {
-    data,
-    meta,
-    pagination,
-    _fetchNextPage: fetchNext,
-    async nextPage() {
-      if (!this.pagination.hasMore) return null;
-      if (!nextPagePromise) {
-        nextPagePromise = (async () => {
-          let result = await this._fetchNextPage();
-          if (!result && this._fallbackFetchNextPage) {
-            result = await this._fallbackFetchNextPage();
-          }
-          if (result) {
-            const mutableResult = result;
-            mutableResult._fallbackFetchNextPage = this._fallbackFetchNextPage ?? this._fetchNextPage;
-          }
-          return result;
-        })().finally(() => {
-          nextPagePromise = null;
-        });
-      }
-      return nextPagePromise;
-    },
-    async all() {
-      const items = [...this.data];
-      let current = this;
-      while (current) {
-        if (!current.pagination.hasMore) break;
-        current = await current.nextPage();
-        if (!current) break;
-        items.push(...current.data);
-      }
-      return items;
-    },
-    [Symbol.asyncIterator]() {
-      let current = this;
-      let index = 0;
-      return {
-        async next() {
-          while (current) {
-            if (index < current.data.length) {
-              return { done: false, value: current.data[index++] };
-            }
-            if (!current.pagination.hasMore) {
-              current = null;
-              break;
-            }
-            current = await current.nextPage();
-            index = 0;
-          }
-          return { done: true, value: void 0 };
-        }
-      };
-    }
-  };
-  return page;
-}
-function createPageResult(dataOrRaw, paginationOrFetchNext, fetchNextOrMeta, meta) {
-  if (Array.isArray(dataOrRaw)) {
-    const data = dataOrRaw;
-    const pagination = paginationOrFetchNext;
-    const fetchNextPage2 = fetchNextOrMeta;
-    const fetchNext2 = async () => {
-      if (!fetchNextPage2) return null;
-      return fetchNextPage2.length > 0 ? fetchNextPage2(
-        pagination.cursor
-      ) : fetchNextPage2();
-    };
-    return buildPageResult(data, pagination, fetchNext2, meta);
-  }
-  const raw = dataOrRaw;
-  const fetchNextPage = paginationOrFetchNext;
-  const fetchNext = async () => {
-    if (!fetchNextPage) return null;
-    return fetchNextPage.length > 0 ? fetchNextPage(
-      raw.pagination.cursor
-    ) : fetchNextPage();
-  };
-  return buildPageResult(
-    Array.isArray(raw.data) ? raw.data : [],
-    raw.pagination,
-    fetchNext,
-    raw.meta
-  );
-}
+// src/client.ts
+import {
+  env,
+  FrontalClient,
+  getDefaultClient,
+  HttpClient
+} from "@frontal-labs/core";
 
 // src/constants.ts
 var DEFAULT_ONTOLOGY_BASE_URL = "https://api.frontal.dev/v1";
-var VERSION = "0.0.1";
+var VERSION = "1.0.4";
 var DEFAULT_TIMEOUT = 3e4;
 var DEFAULT_MAX_RETRIES = 3;
 var DEFAULT_RETRY_DELAY = 1e3;
 
 // src/sdk.ts
+import {
+  asPagePayload,
+  createPageResult
+} from "@frontal-labs/core";
 var OntologySdk = class {
   engine;
   objects;
@@ -1923,9 +814,10 @@ function createOntologyClient(clientOrConfig) {
     retryDelay: DEFAULT_RETRY_DELAY,
     headers: {},
     environment: env.FRONTAL_ENV,
-    debug: env.FRONTAL_DEBUG ?? false
+    debug: env.FRONTAL_DEBUG ?? false,
+    interceptors: clientOrConfig.interceptors
   });
-  return new OntologySdk(http);
+  return new OntologySdk(http.intercepted);
 }
 var _ontologyCache;
 var ontology = new Proxy({}, {
@@ -1940,8 +832,9 @@ var ontology = new Proxy({}, {
 });
 
 // src/schemas.ts
-import { z as z5 } from "zod";
-var FieldTypeSchema = z5.enum([
+import { timestampSchema } from "@frontal-labs/core";
+import { z } from "zod";
+var FieldTypeSchema = z.enum([
   "string",
   "integer",
   "float",
@@ -1955,126 +848,126 @@ var FieldTypeSchema = z5.enum([
   "vector",
   "text"
 ]);
-var RelationshipTypeSchema = z5.enum([
+var RelationshipTypeSchema = z.enum([
   "hasOne",
   "hasMany",
   "belongsTo",
   "manyToMany"
 ]);
-var FieldDefinitionSchema = z5.object({
+var FieldDefinitionSchema = z.object({
   type: FieldTypeSchema,
-  required: z5.boolean().default(false),
-  primary: z5.boolean().default(false),
-  unique: z5.boolean().default(false),
-  default: z5.unknown().optional(),
-  substrate: z5.string().optional(),
-  computed: z5.boolean().optional(),
-  derivedBy: z5.string().optional(),
-  cache: z5.object({
-    ttl: z5.string()
+  required: z.boolean().default(false),
+  primary: z.boolean().default(false),
+  unique: z.boolean().default(false),
+  default: z.unknown().optional(),
+  substrate: z.string().optional(),
+  computed: z.boolean().optional(),
+  derivedBy: z.string().optional(),
+  cache: z.object({
+    ttl: z.string()
   }).optional(),
-  auto: z5.boolean().optional(),
-  enum: z5.array(z5.string()).optional(),
-  dimensions: z5.number().int().optional(),
-  items: z5.string().optional(),
-  description: z5.string().optional()
+  auto: z.boolean().optional(),
+  enum: z.array(z.string()).optional(),
+  dimensions: z.number().int().optional(),
+  items: z.string().optional(),
+  description: z.string().optional()
 }).loose();
-var RelationshipDefinitionSchema = z5.object({
-  name: z5.string().optional(),
+var RelationshipDefinitionSchema = z.object({
+  name: z.string().optional(),
   type: RelationshipTypeSchema,
-  targetEntity: z5.string(),
-  foreignKey: z5.string().optional(),
-  substrate: z5.string().optional(),
-  cascade: z5.object({
-    delete: z5.enum(["hard", "soft", "restrict", "nullify"]),
-    update: z5.enum(["cascade", "restrict"])
+  targetEntity: z.string(),
+  foreignKey: z.string().optional(),
+  substrate: z.string().optional(),
+  cascade: z.object({
+    delete: z.enum(["hard", "soft", "restrict", "nullify"]),
+    update: z.enum(["cascade", "restrict"])
   }).optional(),
-  computed: z5.record(z5.string(), z5.unknown()).optional(),
-  description: z5.string().optional()
+  computed: z.record(z.string(), z.unknown()).optional(),
+  description: z.string().optional()
 }).loose();
-var SubstrateRoutingSchema = z5.object({
-  operational: z5.string().optional(),
-  analytical: z5.string().optional(),
-  semantic: z5.string().optional(),
-  cache: z5.string().optional()
+var SubstrateRoutingSchema = z.object({
+  operational: z.string().optional(),
+  analytical: z.string().optional(),
+  semantic: z.string().optional(),
+  cache: z.string().optional()
 }).loose();
-var SemanticMetadataSchema = z5.object({
-  description: z5.string().optional(),
-  lifecycle: z5.array(z5.string()).optional(),
-  criticalFields: z5.array(z5.string()).optional(),
-  significantEvents: z5.array(z5.string()).optional(),
-  tags: z5.array(z5.string()).optional()
+var SemanticMetadataSchema = z.object({
+  description: z.string().optional(),
+  lifecycle: z.array(z.string()).optional(),
+  criticalFields: z.array(z.string()).optional(),
+  significantEvents: z.array(z.string()).optional(),
+  tags: z.array(z.string()).optional()
 }).loose();
-var IndexDefinitionSchema = z5.object({
-  name: z5.string().optional(),
-  fields: z5.array(z5.string()).min(1),
-  substrate: z5.string().optional(),
-  unique: z5.boolean().default(false),
-  type: z5.enum(["btree", "hash", "gin", "gist", "brin"]).default("btree")
+var IndexDefinitionSchema = z.object({
+  name: z.string().optional(),
+  fields: z.array(z.string()).min(1),
+  substrate: z.string().optional(),
+  unique: z.boolean().default(false),
+  type: z.enum(["btree", "hash", "gin", "gist", "brin"]).default("btree")
 }).loose();
-var ModelDefinitionSchema = z5.object({
-  name: z5.string(),
-  displayName: z5.string().optional(),
-  description: z5.string().optional(),
-  extends: z5.string().optional(),
-  mixins: z5.array(z5.string()).optional(),
-  fields: z5.record(z5.string(), FieldDefinitionSchema),
-  relationships: z5.record(z5.string(), RelationshipDefinitionSchema).optional(),
+var ModelDefinitionSchema = z.object({
+  name: z.string(),
+  displayName: z.string().optional(),
+  description: z.string().optional(),
+  extends: z.string().optional(),
+  mixins: z.array(z.string()).optional(),
+  fields: z.record(z.string(), FieldDefinitionSchema),
+  relationships: z.record(z.string(), RelationshipDefinitionSchema).optional(),
   substrates: SubstrateRoutingSchema.optional(),
   semantics: SemanticMetadataSchema.optional(),
-  indexes: z5.array(IndexDefinitionSchema).optional(),
-  status: z5.enum(["draft", "active", "deprecated"]).default("draft")
+  indexes: z.array(IndexDefinitionSchema).optional(),
+  status: z.enum(["draft", "active", "deprecated"]).default("draft")
 }).strict();
 var ModelSchema = ModelDefinitionSchema.extend({
-  id: z5.string(),
-  version: z5.number().int(),
+  id: z.string(),
+  version: z.number().int(),
   createdAt: timestampSchema,
   updatedAt: timestampSchema,
-  entityCount: z5.number().int().optional()
+  entityCount: z.number().int().optional()
 }).loose();
-var MigrationPlanSchema = z5.object({
-  id: z5.string(),
-  modelId: z5.string(),
-  fromVersion: z5.number().int(),
-  toVersion: z5.number().int(),
-  changes: z5.array(
-    z5.object({
-      type: z5.enum([
+var MigrationPlanSchema = z.object({
+  id: z.string(),
+  modelId: z.string(),
+  fromVersion: z.number().int(),
+  toVersion: z.number().int(),
+  changes: z.array(
+    z.object({
+      type: z.enum([
         "add-field",
         "remove-field",
         "modify-field",
         "add-relationship",
         "remove-relationship"
       ]),
-      description: z5.string(),
-      impact: z5.enum(["breaking", "non-breaking", "data-loss"]),
-      sql: z5.string().optional()
+      description: z.string(),
+      impact: z.enum(["breaking", "non-breaking", "data-loss"]),
+      sql: z.string().optional()
     })
   ),
-  riskLevel: z5.enum(["low", "medium", "high", "critical"]),
-  estimatedDowntime: z5.string().optional(),
-  rolloutStrategy: z5.enum([
+  riskLevel: z.enum(["low", "medium", "high", "critical"]),
+  estimatedDowntime: z.string().optional(),
+  rolloutStrategy: z.enum([
     "zero-downtime",
     "maintenance-window",
     "immediate"
   ]),
   createdAt: timestampSchema
 }).loose();
-var RuleDefinitionSchema = z5.object({
-  name: z5.string(),
-  description: z5.string().optional(),
-  entityTypes: z5.array(z5.string()).min(1),
-  condition: z5.string(),
-  action: z5.enum(["validate", "transform", "notify"]),
-  severity: z5.enum(["error", "warning", "info"]),
-  enabled: z5.boolean().default(true)
+var RuleDefinitionSchema = z.object({
+  name: z.string(),
+  description: z.string().optional(),
+  entityTypes: z.array(z.string()).min(1),
+  condition: z.string(),
+  action: z.enum(["validate", "transform", "notify"]),
+  severity: z.enum(["error", "warning", "info"]),
+  enabled: z.boolean().default(true)
 }).strict();
-var MixinDefinitionSchema = z5.object({
-  name: z5.string(),
-  description: z5.string().optional(),
-  fields: z5.record(z5.string(), FieldDefinitionSchema),
-  relationships: z5.record(z5.string(), RelationshipDefinitionSchema).optional(),
-  appliesTo: z5.array(z5.string()).optional()
+var MixinDefinitionSchema = z.object({
+  name: z.string(),
+  description: z.string().optional(),
+  fields: z.record(z.string(), FieldDefinitionSchema),
+  relationships: z.record(z.string(), RelationshipDefinitionSchema).optional(),
+  appliesTo: z.array(z.string()).optional()
 }).strict();
 export {
   DEFAULT_ONTOLOGY_BASE_URL,