@relyio/sdk 0.2.0

package/dist/chunk-RJBIJ2ZK.js

@@ -0,0 +1,4375 @@
+import { __name, __publicField } from './chunk-XQ4QHWZE.js';
+
+/* RelyIO SDK - Built with ❤️ by the RelyIO Team */
+
+// src/errors/sdk-error.ts
+var _SDKError = class _SDKError extends Error {
+  constructor(message, statusCode, cause, context) {
+    super(message);
+    /** HTTP status code if applicable */
+    __publicField(this, "statusCode");
+    /** Original error that caused this error */
+    __publicField(this, "cause");
+    /** Additional context about the error */
+    __publicField(this, "context");
+    /** Timestamp when the error occurred */
+    __publicField(this, "timestamp");
+    this.name = this.constructor.name;
+    this.statusCode = statusCode;
+    this.cause = cause;
+    this.context = context;
+    this.timestamp = Date.now();
+    Object.setPrototypeOf(this, new.target.prototype);
+  }
+  /**
+   * Convert error to JSON for logging and debugging
+   */
+  toJSON() {
+    return {
+      name: this.name,
+      message: this.message,
+      code: this.code,
+      statusCode: this.statusCode,
+      retryable: this.retryable,
+      context: this.context,
+      timestamp: this.timestamp,
+      stack: this.stack
+    };
+  }
+  /**
+   * Get a user-friendly error message
+   */
+  getUserMessage() {
+    return this.message;
+  }
+  /**
+   * Get detailed error information for debugging
+   */
+  getDebugInfo() {
+    return `${this.name}: ${this.message} (${this.code})`;
+  }
+  /**
+   * Check if this error is of a specific type
+   */
+  isType(errorType) {
+    return this.code === errorType;
+  }
+  /**
+   * Create a new error with additional context
+   */
+  withContext(context) {
+    const Constructor = this.constructor;
+    return new Constructor(this.message, this.statusCode, this.cause, {
+      ...this.context,
+      ...context
+    });
+  }
+};
+__name(_SDKError, "SDKError");
+var SDKError = _SDKError;
+
+// src/errors/auth-errors.ts
+var _AuthenticationError = class _AuthenticationError extends SDKError {
+  constructor(message = "Authentication failed", statusCode = 401, cause, context) {
+    super(message, statusCode, cause, context);
+    __publicField(this, "code", "AUTHENTICATION_ERROR");
+    __publicField(this, "retryable", false);
+  }
+  getUserMessage() {
+    return "Authentication failed. Please check your API key and try again.";
+  }
+};
+__name(_AuthenticationError, "AuthenticationError");
+var AuthenticationError = _AuthenticationError;
+var _AuthorizationError = class _AuthorizationError extends SDKError {
+  constructor(message = "Authorization failed", statusCode = 403, cause, context) {
+    super(message, statusCode, cause, context);
+    __publicField(this, "code", "AUTHORIZATION_ERROR");
+    __publicField(this, "retryable", false);
+  }
+  getUserMessage() {
+    return "You do not have permission to access this resource.";
+  }
+};
+__name(_AuthorizationError, "AuthorizationError");
+var AuthorizationError = _AuthorizationError;
+var _InvalidApiKeyError = class _InvalidApiKeyError extends SDKError {
+  constructor(message = "Invalid API key", cause, context) {
+    super(message, 401, cause, context);
+    __publicField(this, "code", "INVALID_API_KEY");
+    __publicField(this, "retryable", false);
+  }
+  getUserMessage() {
+    return "Invalid API key. Please check your API key and try again.";
+  }
+};
+__name(_InvalidApiKeyError, "InvalidApiKeyError");
+var InvalidApiKeyError = _InvalidApiKeyError;
+
+// src/errors/contract-errors.ts
+var _MissingApiKeyError = class _MissingApiKeyError extends SDKError {
+  constructor(message = "No API key was sent", context) {
+    super(message, 401, void 0, context);
+    __publicField(this, "code", "MISSING_API_KEY");
+    __publicField(this, "retryable", false);
+  }
+  getUserMessage() {
+    return "No API key was sent. Set `apiKey` when creating the client.";
+  }
+};
+__name(_MissingApiKeyError, "MissingApiKeyError");
+var MissingApiKeyError = _MissingApiKeyError;
+var _ReadOnlyKeyError = class _ReadOnlyKeyError extends SDKError {
+  constructor(message = "This API key is read-only", context) {
+    super(message, 403, void 0, context);
+    __publicField(this, "code", "READ_ONLY_KEY");
+    __publicField(this, "retryable", false);
+  }
+  getUserMessage() {
+    return "This API key is read-only. Use a key with write access for this operation.";
+  }
+};
+__name(_ReadOnlyKeyError, "ReadOnlyKeyError");
+var ReadOnlyKeyError = _ReadOnlyKeyError;
+var _PlanFeatureUnavailableError = class _PlanFeatureUnavailableError extends SDKError {
+  constructor(message = "This feature is not available on the current plan", feature, context) {
+    super(message, 403, void 0, context);
+    __publicField(this, "code", "PLAN_FEATURE_UNAVAILABLE");
+    __publicField(this, "retryable", false);
+    /** The entitlement key the service named, when it named one. */
+    __publicField(this, "feature");
+    this.feature = feature;
+  }
+  getUserMessage() {
+    return this.feature === void 0 ? "This feature is not available on the current plan." : `The current plan does not include "${this.feature}".`;
+  }
+};
+__name(_PlanFeatureUnavailableError, "PlanFeatureUnavailableError");
+var PlanFeatureUnavailableError = _PlanFeatureUnavailableError;
+var _UsageQuotaExceededError = class _UsageQuotaExceededError extends SDKError {
+  constructor(message = "Usage quota exceeded", meter, limit, context) {
+    super(message, 403, void 0, context);
+    __publicField(this, "code", "USAGE_QUOTA_EXCEEDED");
+    __publicField(this, "retryable", false);
+    /** The meter the service named. Always present on a refusal from the contract. */
+    __publicField(this, "meter");
+    /** The threshold, where the deciding seam carried one — often it does not. */
+    __publicField(this, "limit");
+    this.meter = meter;
+    this.limit = limit;
+  }
+  getUserMessage() {
+    return this.meter === void 0 ? "A usage quota for this account has been exceeded." : `The "${this.meter}" quota for this account has been exceeded.`;
+  }
+};
+__name(_UsageQuotaExceededError, "UsageQuotaExceededError");
+var UsageQuotaExceededError = _UsageQuotaExceededError;
+var _RateLimitError = class _RateLimitError extends SDKError {
+  constructor(message = "Rate limit exceeded", limit, resetAt, context) {
+    super(message, 429, void 0, context);
+    __publicField(this, "code", "RATE_LIMIT_EXCEEDED");
+    __publicField(this, "retryable", true);
+    __publicField(this, "limit");
+    __publicField(this, "resetAt");
+    this.limit = limit;
+    this.resetAt = resetAt;
+  }
+  getUserMessage() {
+    return this.resetAt === void 0 ? "Too many requests. Please retry shortly." : `Too many requests. The window resets at ${this.resetAt}.`;
+  }
+};
+__name(_RateLimitError, "RateLimitError");
+var RateLimitError = _RateLimitError;
+var _MethodNotAllowedError = class _MethodNotAllowedError extends SDKError {
+  constructor(message = "Method not allowed", context) {
+    super(message, 405, void 0, context);
+    __publicField(this, "code", "METHOD_NOT_ALLOWED");
+    __publicField(this, "retryable", false);
+  }
+  getUserMessage() {
+    return "That operation is not available on this resource.";
+  }
+};
+__name(_MethodNotAllowedError, "MethodNotAllowedError");
+var MethodNotAllowedError = _MethodNotAllowedError;
+var _PayloadTooLargeError = class _PayloadTooLargeError extends SDKError {
+  constructor(message = "Payload too large", limitBytes, context) {
+    super(message, 413, void 0, context);
+    __publicField(this, "code", "PAYLOAD_TOO_LARGE");
+    __publicField(this, "retryable", false);
+    __publicField(this, "limitBytes");
+    this.limitBytes = limitBytes;
+  }
+  getUserMessage() {
+    return this.limitBytes === void 0 ? "The request body is larger than this endpoint accepts." : `The request body is larger than the ${this.limitBytes}-byte limit.`;
+  }
+};
+__name(_PayloadTooLargeError, "PayloadTooLargeError");
+var PayloadTooLargeError = _PayloadTooLargeError;
+var _TransactionRolledBackError = class _TransactionRolledBackError extends SDKError {
+  constructor(message = "Transaction rolled back", failedIndex, context) {
+    super(message, 409, void 0, context);
+    __publicField(this, "code", "TRANSACTION_ROLLED_BACK");
+    __publicField(this, "retryable", false);
+    __publicField(this, "failedIndex");
+    this.failedIndex = failedIndex;
+  }
+  getUserMessage() {
+    return this.failedIndex === void 0 ? "The batch was rolled back; nothing was written." : `The batch was rolled back at operation ${this.failedIndex}; nothing was written.`;
+  }
+};
+__name(_TransactionRolledBackError, "TransactionRolledBackError");
+var TransactionRolledBackError = _TransactionRolledBackError;
+var _ServiceIndeterminateError = class _ServiceIndeterminateError extends SDKError {
+  constructor(message = "The service could not decide this request", missing, context) {
+    super(message, 503, void 0, context);
+    __publicField(this, "code", "SERVICE_INDETERMINATE");
+    __publicField(this, "retryable", true);
+    __publicField(this, "missing");
+    this.missing = missing;
+  }
+  getUserMessage() {
+    return "The service is temporarily unable to answer. Please retry.";
+  }
+};
+__name(_ServiceIndeterminateError, "ServiceIndeterminateError");
+var ServiceIndeterminateError = _ServiceIndeterminateError;
+var _ServerError = class _ServerError extends SDKError {
+  constructor(message = "The service failed to handle the request", statusCode = 500, context) {
+    super(message, statusCode, void 0, context);
+    __publicField(this, "code", "INTERNAL_ERROR");
+    __publicField(this, "retryable", true);
+  }
+  getUserMessage() {
+    return "Something went wrong on the RelyIO side. Please retry.";
+  }
+};
+__name(_ServerError, "ServerError");
+var ServerError = _ServerError;
+var _UnknownContractError = class _UnknownContractError extends SDKError {
+  constructor(code, message, statusCode, context) {
+    super(message, statusCode, void 0, context);
+    __publicField(this, "code");
+    __publicField(this, "retryable", false);
+    this.code = code;
+  }
+  getUserMessage() {
+    return `The service refused this request with "${this.code}".`;
+  }
+};
+__name(_UnknownContractError, "UnknownContractError");
+var UnknownContractError = _UnknownContractError;
+
+// src/errors/content-errors.ts
+var _ResourceNotFoundError = class _ResourceNotFoundError extends SDKError {
+  constructor(message = "Resource not found", statusCode = 404, cause, context) {
+    super(message, statusCode, cause, context);
+    __publicField(this, "code", "RESOURCE_NOT_FOUND");
+    __publicField(this, "retryable", false);
+  }
+  getUserMessage() {
+    const resourceType = this.context?.resourceType;
+    const resourceId = this.context?.resourceId;
+    if (resourceType != null && resourceId != null) {
+      return `${resourceType} with ID "${resourceId}" was not found.`;
+    }
+    return "The requested resource was not found.";
+  }
+};
+__name(_ResourceNotFoundError, "ResourceNotFoundError");
+var ResourceNotFoundError = _ResourceNotFoundError;
+var _ResourceConflictError = class _ResourceConflictError extends SDKError {
+  constructor(message = "Resource conflict", statusCode = 409, cause, context) {
+    super(message, statusCode, cause, context);
+    __publicField(this, "code", "RESOURCE_CONFLICT");
+    __publicField(this, "retryable", false);
+  }
+  getUserMessage() {
+    return "The resource could not be created or updated due to a conflict.";
+  }
+};
+__name(_ResourceConflictError, "ResourceConflictError");
+var ResourceConflictError = _ResourceConflictError;
+var _ResourceExpiredError = class _ResourceExpiredError extends SDKError {
+  constructor(message = "Resource has expired", statusCode = 410, cause, context) {
+    super(message, statusCode, cause, context);
+    __publicField(this, "code", "RESOURCE_EXPIRED");
+    __publicField(this, "retryable", false);
+  }
+  getUserMessage() {
+    return "The resource is no longer available.";
+  }
+};
+__name(_ResourceExpiredError, "ResourceExpiredError");
+var ResourceExpiredError = _ResourceExpiredError;
+function isResourceNotFound(error) {
+  return error instanceof ResourceNotFoundError;
+}
+__name(isResourceNotFound, "isResourceNotFound");
+
+// src/errors/network-errors.ts
+var _NetworkError = class _NetworkError extends SDKError {
+  constructor(message = "Network request failed", statusCode, cause, context) {
+    super(message, statusCode, cause, context);
+    __publicField(this, "code", "NETWORK_ERROR");
+    __publicField(this, "retryable", true);
+  }
+  getUserMessage() {
+    return "Network connection failed. Please check your internet connection and try again.";
+  }
+};
+__name(_NetworkError, "NetworkError");
+var NetworkError = _NetworkError;
+var _TimeoutError = class _TimeoutError extends SDKError {
+  constructor(message = "Request timed out", timeout, statusCode, cause) {
+    super(message, statusCode, cause, { timeout });
+    __publicField(this, "code", "TIMEOUT_ERROR");
+    __publicField(this, "retryable", true);
+  }
+  getUserMessage() {
+    const timeout = this.context?.timeout;
+    return `Request timed out${timeout != null ? ` after ${timeout}ms` : ""}. Please try again.`;
+  }
+};
+__name(_TimeoutError, "TimeoutError");
+var TimeoutError = _TimeoutError;
+var _ConnectionError = class _ConnectionError extends SDKError {
+  constructor(message = "Connection failed", statusCode, cause, context) {
+    super(message, statusCode, cause, context);
+    __publicField(this, "code", "CONNECTION_ERROR");
+    __publicField(this, "retryable", true);
+  }
+  getUserMessage() {
+    return "Failed to connect to RelyIO servers. Please check your connection and try again.";
+  }
+};
+__name(_ConnectionError, "ConnectionError");
+var ConnectionError = _ConnectionError;
+
+// src/errors/validation-errors.ts
+var _BaseValidationError = class _BaseValidationError extends SDKError {
+  constructor(message = "Validation failed", violations = [], statusCode = 400, cause) {
+    super(message, statusCode, cause, { violations });
+    __publicField(this, "retryable", false);
+    __publicField(this, "violations");
+    this.violations = violations;
+  }
+  getUserMessage() {
+    if (this.violations.length === 0) {
+      return "Validation failed. Please check your input and try again.";
+    }
+    if (this.violations.length === 1) {
+      const violation = this.violations[0];
+      return `Validation failed: ${violation?.message ?? "Unknown error"}`;
+    }
+    return `Validation failed with ${this.violations.length} errors. Please check your input and try again.`;
+  }
+  /**
+   * Get violations for a specific field
+   */
+  getViolationsForField(fieldName) {
+    return this.violations.filter((v) => v.field === fieldName);
+  }
+  /**
+   * Check if a specific field has validation errors
+   */
+  hasFieldError(fieldName) {
+    return this.violations.some((v) => v.field === fieldName);
+  }
+  /**
+   * Get all validation messages as a formatted string
+   */
+  getFormattedMessages() {
+    return this.violations.map((v) => `${v.field}: ${v.message}`).join("\n");
+  }
+};
+__name(_BaseValidationError, "BaseValidationError");
+var BaseValidationError = _BaseValidationError;
+var _ValidationError = class _ValidationError extends BaseValidationError {
+  constructor() {
+    super(...arguments);
+    __publicField(this, "code", "VALIDATION_ERROR");
+  }
+};
+__name(_ValidationError, "ValidationError");
+var ValidationError = _ValidationError;
+var _InvalidPayloadError = class _InvalidPayloadError extends BaseValidationError {
+  constructor(message = "Invalid payload", violations = [], cause) {
+    super(message, violations, 400, cause);
+    __publicField(this, "code", "INVALID_PAYLOAD");
+  }
+  getUserMessage() {
+    return "The request payload is invalid. Please check your data and try again.";
+  }
+};
+__name(_InvalidPayloadError, "InvalidPayloadError");
+var InvalidPayloadError = _InvalidPayloadError;
+var _SchemaValidationError = class _SchemaValidationError extends BaseValidationError {
+  constructor(message = "Schema validation failed", violations = [], cause) {
+    super(message, violations, 400, cause);
+    __publicField(this, "code", "SCHEMA_VALIDATION_ERROR");
+  }
+  getUserMessage() {
+    return "The data does not match the expected schema. Please check your content structure.";
+  }
+};
+__name(_SchemaValidationError, "SchemaValidationError");
+var SchemaValidationError = _SchemaValidationError;
+var _RequiredFieldError = class _RequiredFieldError extends BaseValidationError {
+  constructor(fieldName, message, cause) {
+    const violation = {
+      field: fieldName,
+      message: message ?? `Field "${fieldName}" is required`,
+      code: "REQUIRED"
+    };
+    super(`Required field "${fieldName}" is missing`, [violation], 400, cause);
+    __publicField(this, "code", "REQUIRED_FIELD_ERROR");
+  }
+  getUserMessage() {
+    const violation = this.violations[0];
+    const fieldName = violation?.field;
+    return `The field "${fieldName}" is required and cannot be empty.`;
+  }
+};
+__name(_RequiredFieldError, "RequiredFieldError");
+var RequiredFieldError = _RequiredFieldError;
+var _InvalidFieldTypeError = class _InvalidFieldTypeError extends BaseValidationError {
+  constructor(fieldName, expectedType, actualType, value, cause) {
+    const violation = {
+      field: fieldName,
+      message: `Expected ${expectedType}, got ${actualType}`,
+      code: "INVALID_TYPE",
+      value
+    };
+    super(
+      `Invalid type for field "${fieldName}": expected ${expectedType}, got ${actualType}`,
+      [violation],
+      400,
+      cause
+    );
+    __publicField(this, "code", "INVALID_FIELD_TYPE");
+  }
+  getUserMessage() {
+    const violation = this.violations[0];
+    return `The field "${violation?.field}" has an invalid type. ${violation?.message}.`;
+  }
+};
+__name(_InvalidFieldTypeError, "InvalidFieldTypeError");
+var InvalidFieldTypeError = _InvalidFieldTypeError;
+
+// ../../platform/api-contract/dist/client/index.js
+var _a;
+var ContractBodyError = (_a = class extends Error {
+  constructor(message, body) {
+    super(message);
+    __publicField(this, "body");
+    this.name = "ContractBodyError";
+    this.body = body;
+  }
+}, __name(_a, "ContractBodyError"), _a);
+function describe(body) {
+  try {
+    return JSON.stringify(body)?.slice(0, 200) ?? String(body);
+  } catch {
+    return String(body);
+  }
+}
+__name(describe, "describe");
+function readPayload(body) {
+  if (typeof body !== "object" || body === null || !("data" in body)) {
+    throw new ContractBodyError(
+      `expected a contract success body carrying \`data\`, got ${describe(body)}`,
+      body
+    );
+  }
+  return body.data;
+}
+__name(readPayload, "readPayload");
+function readError(body) {
+  if (typeof body !== "object" || body === null || !("error" in body)) return void 0;
+  const error = body.error;
+  if (typeof error !== "object" || error === null || !("code" in error)) return void 0;
+  const code = error.code;
+  if (typeof code !== "string") return void 0;
+  const messages = error.messages;
+  return {
+    code,
+    messages: Array.isArray(messages) ? messages.filter((m) => typeof m === "string") : [],
+    ..."details" in error ? { details: error.details } : {}
+  };
+}
+__name(readError, "readError");
+
+// src/errors/error-mapper.ts
+var _ErrorMapper = class _ErrorMapper {
+  /** Map a non-2xx response to an SDK error. */
+  static mapHttpError(response, requestContext) {
+    const { status, statusText, body } = response;
+    const refusal = readError(body);
+    const context = { ...requestContext, response: body };
+    if (refusal === void 0) {
+      return new NetworkError(`HTTP ${status}: ${statusText}`.trim(), status, void 0, context);
+    }
+    return this.fromContractCode(refusal, status, context);
+  }
+  static fromContractCode(refusal, status, context) {
+    const message = refusal.messages[0] ?? `RelyIO refused with ${refusal.code}`;
+    switch (refusal.code) {
+      case "MISSING_API_KEY": {
+        return new MissingApiKeyError(message, context);
+      }
+      case "INVALID_API_KEY": {
+        return new InvalidApiKeyError(message, void 0, context);
+      }
+      case "ACCESS_DENIED": {
+        return new AuthorizationError(message, 403, void 0, context);
+      }
+      case "READ_ONLY_KEY": {
+        return new ReadOnlyKeyError(message, context);
+      }
+      case "PLAN_FEATURE_UNAVAILABLE": {
+        return new PlanFeatureUnavailableError(message, detailString(refusal, "feature"), context);
+      }
+      case "USAGE_QUOTA_EXCEEDED": {
+        return new UsageQuotaExceededError(
+          message,
+          detailString(refusal, "meter"),
+          detailNumber(refusal, "limit"),
+          context
+        );
+      }
+      case "RATE_LIMIT_EXCEEDED": {
+        return new RateLimitError(
+          message,
+          detailNumber(refusal, "limit"),
+          detailString(refusal, "resetAt"),
+          context
+        );
+      }
+      case "REQUEST_INVALID": {
+        return new InvalidPayloadError(message, violationsOf(refusal));
+      }
+      case "CONTENT_INVALID": {
+        return new ValidationError(message, violationsOf(refusal), 400);
+      }
+      case "METHOD_NOT_ALLOWED": {
+        return new MethodNotAllowedError(message, context);
+      }
+      case "RESOURCE_NOT_FOUND": {
+        return new ResourceNotFoundError(message, 404, void 0, {
+          ...context,
+          resourceType: detailString(refusal, "kind"),
+          resourceId: detailString(refusal, "id")
+        });
+      }
+      case "RESOURCE_CONFLICT": {
+        return new ResourceConflictError(message, 409, void 0, {
+          ...context,
+          expectedVersion: detailNumber(refusal, "expectedVersion"),
+          actualVersion: detailNumber(refusal, "actualVersion")
+        });
+      }
+      case "RESOURCE_EXPIRED": {
+        return new ResourceExpiredError(message, 410, void 0, context);
+      }
+      case "REQUEST_TIMEOUT": {
+        return new TimeoutError(message, void 0, void 0, void 0);
+      }
+      case "PAYLOAD_TOO_LARGE": {
+        return new PayloadTooLargeError(message, detailNumber(refusal, "limitBytes"), context);
+      }
+      case "TRANSACTION_ROLLED_BACK": {
+        return new TransactionRolledBackError(
+          message,
+          detailNumber(refusal, "failedIndex"),
+          context
+        );
+      }
+      case "SERVICE_INDETERMINATE": {
+        return new ServiceIndeterminateError(message, detailString(refusal, "missing"), context);
+      }
+      case "INTERNAL_ERROR": {
+        return new ServerError(message, status, context);
+      }
+      default: {
+        return new UnknownContractError(refusal.code, message, status, context);
+      }
+    }
+  }
+  /**
+   * Map generic JavaScript errors to SDK errors
+   */
+  static mapGenericError(error, _context) {
+    if (error instanceof SDKError) {
+      return error;
+    }
+    if (error.name === "TypeError" && error.message.includes("fetch")) {
+      return new NetworkError("Network request failed", void 0, error, _context);
+    }
+    if (error.name === "AbortError" || error.message.includes("timeout")) {
+      return new TimeoutError("Request timed out", void 0, void 0, error);
+    }
+    if (error.message.includes("Network Error") || error.message.includes("ECONNREFUSED")) {
+      return new ConnectionError("Connection failed", void 0, error, _context);
+    }
+    return new NetworkError(
+      error.message ?? "An unknown error occurred",
+      void 0,
+      error,
+      _context
+    );
+  }
+  /**
+   * Check if an error is retryable
+   */
+  static isRetryable(error) {
+    if (error instanceof SDKError) {
+      return error.retryable;
+    }
+    return error.name === "TypeError" && error.message.includes("fetch") || error.message.includes("timeout") || error.message.includes("Network Error") || error.message.includes("ECONNREFUSED");
+  }
+  /**
+   * Extract retry delay from error
+   */
+  static getRetryDelay(_error) {
+    return 0;
+  }
+};
+__name(_ErrorMapper, "ErrorMapper");
+var ErrorMapper = _ErrorMapper;
+function knownCode(refusal) {
+  return typeof refusal.code === "string" ? refusal.code : void 0;
+}
+__name(knownCode, "knownCode");
+function detailBag(refusal) {
+  if (knownCode(refusal) === void 0) return void 0;
+  const details = refusal.details;
+  if (typeof details !== "object" || details === null) return void 0;
+  return details;
+}
+__name(detailBag, "detailBag");
+function detailString(refusal, key) {
+  const value = detailBag(refusal)?.[key];
+  return typeof value === "string" ? value : void 0;
+}
+__name(detailString, "detailString");
+function detailNumber(refusal, key) {
+  const value = detailBag(refusal)?.[key];
+  return typeof value === "number" ? value : void 0;
+}
+__name(detailNumber, "detailNumber");
+function violationsOf(refusal) {
+  const issues = detailBag(refusal)?.issues;
+  if (!Array.isArray(issues)) return [];
+  return issues.filter((issue) => typeof issue === "object" && issue !== null).map((issue) => ({
+    field: issue.path,
+    message: issue.message,
+    code: issue.code,
+    path: issue.path === "" ? void 0 : issue.path.split(".")
+  }));
+}
+__name(violationsOf, "violationsOf");
+
+// src/http/api-routes.ts
+function fillPath(template, params) {
+  const missing = [];
+  const filled = template.replace(/\{(\w+)\}/g, (_match, name) => {
+    const value = params[name];
+    if (value === void 0) {
+      missing.push(name);
+      return "";
+    }
+    return encodeURIComponent(value);
+  });
+  if (missing.length > 0) {
+    throw new Error(`${template} needs path parameter(s) ${missing.join(", ")}`);
+  }
+  const extra = Object.keys(params).filter((name) => !template.includes(`{${name}}`));
+  if (extra.length > 0) {
+    throw new Error(`${template} declares no path parameter(s) ${extra.join(", ")}`);
+  }
+  return filled;
+}
+__name(fillPath, "fillPath");
+
+// src/http/http-client.ts
+var _HttpClient = class _HttpClient {
+  constructor(config) {
+    __publicField(this, "baseUrl");
+    __publicField(this, "defaultHeaders");
+    __publicField(this, "timeout");
+    __publicField(this, "retryConfig");
+    __publicField(this, "debug");
+    __publicField(this, "logger");
+    __publicField(this, "config");
+    this.config = config;
+    this.baseUrl = config.baseUrl;
+    this.timeout = config.timeout;
+    this.debug = config.debug.enabled ?? false;
+    this.logger = config.debug.logger;
+    this.defaultHeaders = {
+      "Content-Type": "application/json",
+      "X-API-Key": config.apiKey,
+      ...config.headers
+    };
+    if (config.dataset != null) {
+      this.defaultHeaders["X-RelyIO-Dataset"] = config.dataset;
+    }
+    if (typeof window === "undefined") {
+      const globalWithVersion = globalThis;
+      this.defaultHeaders["User-Agent"] = `RelyIO-SDK/${globalWithVersion.__VERSION__ ?? "0.0.0"}`;
+    }
+    this.retryConfig = {
+      maxAttempts: config.retryAttempts,
+      baseDelay: 1e3,
+      maxDelay: 1e4,
+      backoffFactor: 2,
+      jitter: true,
+      retryCondition: /* @__PURE__ */ __name((error, attempt) => {
+        return ErrorMapper.isRetryable(error) && attempt < config.retryAttempts;
+      }, "retryCondition")
+    };
+    this.log("debug", "HttpClient initialized", {
+      baseUrl: this.baseUrl,
+      timeout: this.timeout,
+      retryAttempts: config.retryAttempts,
+      environment: typeof window === "undefined" ? "node" : "browser"
+    });
+  }
+  /**
+   * Call a route the committed document declares, and get back the body that
+   * document says it serves.
+   */
+  async send(path, method, options) {
+    const pathParams = options.path === void 0 ? {} : { ...options.path };
+    return this.request({
+      method: method.toUpperCase(),
+      url: fillPath(path, pathParams),
+      params: options.query,
+      body: options.body,
+      headers: options.headers,
+      signal: options.signal,
+      timeout: options.timeout
+    });
+  }
+  /**
+   * Call a route and return its payload — `send` plus the one unwrap, which is
+   * what all but a handful of call sites want.
+   */
+  async fetchPayload(path, method, options) {
+    const response = await this.send(path, method, options);
+    return readPayload(response.body);
+  }
+  /**
+   * Make an HTTP request with retry logic
+   */
+  async request(config) {
+    const mergedConfig = this.mergeRequestConfig(config);
+    this.log("debug", "Making request", {
+      method: mergedConfig.method,
+      url: mergedConfig.url
+      // Show the final URL with query params
+    });
+    let lastError;
+    let attempt = 0;
+    while (attempt < this.retryConfig.maxAttempts) {
+      attempt++;
+      try {
+        if (config.method === "DELETE" && mergedConfig.headers) {
+          delete mergedConfig.headers["Content-Type"];
+        }
+        const response = await this.makeRequest(mergedConfig.url, mergedConfig);
+        this.log("debug", "Request successful", {
+          status: response.status,
+          attempt,
+          url: mergedConfig.url
+        });
+        return response;
+      } catch (error) {
+        lastError = error;
+        this.log("warn", "Request failed", {
+          error: error instanceof Error ? error.message : "Unknown error",
+          attempt,
+          url: mergedConfig.url
+        });
+        if (attempt < this.retryConfig.maxAttempts && this.retryConfig.retryCondition?.(lastError, attempt) === true) {
+          const delay = this.calculateRetryDelay(attempt);
+          this.log("debug", "Retrying request", { attempt, delay });
+          await this.sleep(delay);
+          continue;
+        }
+        break;
+      }
+    }
+    const sdkError = ErrorMapper.mapGenericError(lastError, {
+      url: mergedConfig.url,
+      method: mergedConfig.method,
+      attempt
+    });
+    this.log("error", "Request failed after all retries", {
+      error: sdkError.toJSON(),
+      url: mergedConfig.url
+    });
+    throw sdkError;
+  }
+  /**
+   * Make a GET request
+   */
+  async get(url, params) {
+    return this.request({
+      method: "GET",
+      url,
+      params
+    });
+  }
+  /**
+   * Make a POST request
+   */
+  async post(url, data, params) {
+    return this.request({
+      method: "POST",
+      url,
+      body: data,
+      params
+    });
+  }
+  /**
+   * Make a PUT request
+   */
+  async put(url, data, params) {
+    return this.request({
+      method: "PUT",
+      url,
+      body: data,
+      params
+    });
+  }
+  /**
+   * Make a DELETE request
+   */
+  async delete(url, params) {
+    return this.request({
+      method: "DELETE",
+      url,
+      params
+    });
+  }
+  /**
+   * Make a PATCH request
+   */
+  async patch(url, data, params) {
+    return this.request({
+      method: "PATCH",
+      url,
+      body: data,
+      params
+    });
+  }
+  /**
+   * Set default headers for all requests
+   */
+  setDefaultHeaders(headers) {
+    this.defaultHeaders = { ...this.defaultHeaders, ...headers };
+  }
+  /**
+   * Set authentication token
+   */
+  setAuthToken(token) {
+    this.defaultHeaders.Authorization = `Bearer ${token}`;
+  }
+  /**
+   * Get current default headers
+   */
+  getDefaultHeaders() {
+    return { ...this.defaultHeaders };
+  }
+  /**
+   * Update base URL
+   */
+  setBaseUrl(baseUrl) {
+    this.baseUrl = baseUrl;
+  }
+  /**
+   * Get current base URL
+   */
+  getBaseUrl() {
+    return this.baseUrl;
+  }
+  async makeRequest(url, config) {
+    const controller = new AbortController();
+    const timeoutId = setTimeout(() => controller.abort(), config.timeout ?? this.timeout);
+    try {
+      const filteredHeaders = this.filterHeadersForBrowser(config.headers ?? {});
+      const requestInit = {
+        method: config.method,
+        headers: filteredHeaders,
+        body: this.prepareRequestBody(config),
+        signal: config.signal ?? controller.signal,
+        // Include credentials for CORS requests if in browser and configured
+        ...typeof window !== "undefined" && this.config.browser.includeCredentials != null && { credentials: "include" }
+      };
+      const response = await fetch(url, requestInit);
+      clearTimeout(timeoutId);
+      const responseBody = await this.parseResponse(response);
+      if (!response.ok) {
+        const error = ErrorMapper.mapHttpError(
+          {
+            status: response.status,
+            statusText: response.statusText,
+            body: responseBody,
+            headers: this.headersToObject(response.headers)
+          },
+          {
+            url: config.url,
+            method: config.method
+          }
+        );
+        throw error;
+      }
+      return {
+        body: responseBody,
+        status: response.status,
+        statusText: response.statusText,
+        headers: this.headersToObject(response.headers),
+        config
+      };
+    } catch (error) {
+      clearTimeout(timeoutId);
+      if (error instanceof SDKError) {
+        throw error;
+      }
+      if (error instanceof DOMException && error.name === "AbortError") {
+        throw new TimeoutError(
+          `Request timed out after ${config.timeout ?? this.timeout}ms`,
+          config.timeout ?? this.timeout
+        );
+      }
+      if (error instanceof TypeError && error.message.includes("CORS")) {
+        const corsError = new NetworkError(
+          "CORS policy error: The request was blocked by CORS policy. This usually means the server is not configured to allow requests from this origin. Please check the server CORS configuration.",
+          void 0,
+          error,
+          {
+            url: config.url,
+            method: config.method,
+            corsError: true,
+            suggestion: "Check if the API server allows requests from your domain and has proper CORS headers configured."
+          }
+        );
+        if (typeof window !== "undefined" && this.config.browser.onCorsError) {
+          try {
+            this.config.browser.onCorsError(corsError, {
+              url: config.url,
+              method: config.method,
+              originalError: error
+            });
+          } catch (handlerError) {
+            this.log("warn", "Custom CORS error handler threw an error", handlerError);
+          }
+        }
+        throw corsError;
+      }
+      throw error;
+    }
+  }
+  /**
+   * Filter headers that browsers don't allow to be set manually
+   */
+  filterHeadersForBrowser(headers) {
+    if (typeof window !== "undefined") {
+      const filteredHeaders = { ...headers };
+      const forbiddenHeaders = ["user-agent", "referer", "origin", "host", "connection", "upgrade"];
+      forbiddenHeaders.forEach((header) => {
+        delete filteredHeaders[header];
+        delete filteredHeaders[header.toLowerCase()];
+        delete filteredHeaders[header.toUpperCase()];
+      });
+      return filteredHeaders;
+    }
+    return headers;
+  }
+  /**
+   * Prepare request body based on content type and environment
+   */
+  prepareRequestBody(config) {
+    if (config.body == null) return void 0;
+    if (config.body instanceof FormData || config.body instanceof Blob || typeof config.body === "string") {
+      return config.body;
+    }
+    return JSON.stringify(config.body);
+  }
+  async parseResponse(response) {
+    if (response.status === 204 || response.status === 205) {
+      return void 0;
+    }
+    const contentType = response.headers.get("content-type");
+    if (contentType == null) {
+      return await response.text();
+    }
+    if (contentType.includes("application/json")) {
+      return await response.json();
+    }
+    if (contentType.includes("text/")) {
+      return await response.text();
+    }
+    try {
+      return await response.json();
+    } catch {
+      return await response.text();
+    }
+  }
+  resolveUrl(url) {
+    if (url.startsWith("http://") || url.startsWith("https://")) {
+      return url;
+    }
+    return `${this.baseUrl}${url.startsWith("/") ? "" : "/"}${url}`;
+  }
+  mergeRequestConfig(config) {
+    const url = this.resolveUrl(config.url);
+    const queryString = config.params != null ? this.buildQueryString(config.params) : "";
+    const finalUrl = queryString.length > 0 ? `${url}?${queryString}` : url;
+    return {
+      ...config,
+      url: finalUrl,
+      headers: {
+        ...this.defaultHeaders,
+        ...config.headers
+      },
+      timeout: config.timeout ?? this.timeout
+    };
+  }
+  buildQueryString(params) {
+    const searchParams = new URLSearchParams();
+    for (const [key, value] of Object.entries(params)) {
+      if (value !== void 0 && value !== null) {
+        if (Array.isArray(value)) {
+          value.forEach((v) => searchParams.append(key, String(v)));
+        } else {
+          searchParams.append(key, String(value));
+        }
+      }
+    }
+    return searchParams.toString();
+  }
+  headersToObject(headers) {
+    const obj = {};
+    headers.forEach((value, key) => {
+      obj[key] = value;
+    });
+    return obj;
+  }
+  calculateRetryDelay(attempt) {
+    const exponentialDelay = this.retryConfig.baseDelay * Math.pow(this.retryConfig.backoffFactor, attempt - 1);
+    const delay = Math.min(exponentialDelay, this.retryConfig.maxDelay);
+    if (this.retryConfig.jitter) {
+      return delay * (0.5 + Math.random() * 0.5);
+    }
+    return delay;
+  }
+  sleep(ms) {
+    return new Promise((resolve) => setTimeout(resolve, ms));
+  }
+  log(level, message, data) {
+    if (!this.debug) return;
+    if (this.logger != null) {
+      this.logger(level, message, data);
+    } else {
+      console.log(`[RelyIO SDK ${level.toUpperCase()}] ${message}`, data ?? "");
+    }
+  }
+};
+__name(_HttpClient, "HttpClient");
+var HttpClient = _HttpClient;
+
+// src/content/query-builder.ts
+var _ContentQueryBuilder = class _ContentQueryBuilder {
+  constructor(httpClient, contentType, defaultLocale) {
+    this.httpClient = httpClient;
+    this.contentType = contentType;
+    this.defaultLocale = defaultLocale;
+    __publicField(this, "queryOptions", {});
+    __publicField(this, "localeValue");
+    __publicField(this, "localesArray");
+    __publicField(this, "fetchAllLocales", false);
+    __publicField(this, "fieldsProjection");
+    __publicField(this, "childrenOptions");
+    __publicField(this, "pageNumber");
+    __publicField(this, "pageSizeValue");
+  }
+  /**
+   * Add where conditions to the query
+   */
+  where(conditions) {
+    this.queryOptions.where = {
+      ...this.queryOptions.where,
+      ...conditions
+    };
+    return this;
+  }
+  /**
+   * Select specific fields to return
+   */
+  select(fields) {
+    this.queryOptions.select = fields;
+    return this;
+  }
+  /**
+   * Include related content in the response
+   */
+  include(relations) {
+    this.queryOptions.include = [...this.queryOptions.include ?? [], ...relations];
+    return this;
+  }
+  sort(fieldOrOptions, direction) {
+    if (typeof fieldOrOptions === "string") {
+      this.queryOptions.sort = {
+        ...this.queryOptions.sort,
+        [fieldOrOptions]: direction ?? "asc"
+      };
+    } else {
+      this.queryOptions.sort = {
+        ...this.queryOptions.sort,
+        ...fieldOrOptions
+      };
+    }
+    return this;
+  }
+  /**
+   * Sort by a specific field in ascending order
+   */
+  sortAsc(field) {
+    return this.sort(field, "asc");
+  }
+  /**
+   * Sort by a specific field in descending order
+   */
+  sortDesc(field) {
+    return this.sort(field, "desc");
+  }
+  /**
+   * Limit the number of results
+   */
+  limit(count) {
+    this.queryOptions.limit = count;
+    return this;
+  }
+  /**
+   * Set offset for pagination
+   */
+  offset(count) {
+    this.queryOptions.offset = count;
+    return this;
+  }
+  /**
+   * Set cursor for cursor-based pagination
+   */
+  cursor(cursor) {
+    this.queryOptions.cursor = cursor;
+    return this;
+  }
+  /**
+   * Set locale for localized content
+   * @param locale - Locale code (e.g., 'en-US', 'de-DE', 'fr-FR')
+   *
+   * @example
+   * ```typescript
+   * // Fetch in Spanish
+   * .locale('es-ES')
+   * ```
+   */
+  locale(locale) {
+    this.localeValue = locale;
+    this.localesArray = void 0;
+    this.fetchAllLocales = false;
+    return this;
+  }
+  /**
+   * Fetch content in multiple specific locales
+   * Returns primary locale at top level, others in _metadata.localizations
+   *
+   * @param localeCodes - Array of locale codes to fetch
+   *
+   * @example
+   * ```typescript
+   * const product = await client.content('product')
+   *   .findById('prod_123')
+   *   .locales(['en-US', 'es-ES', 'de-DE'])
+   *   .execute()
+   *
+   * // Access: product.title (first locale)
+   * // Access: product._metadata.localizations['es-ES'].title
+   * ```
+   */
+  locales(localeCodes) {
+    this.localesArray = localeCodes;
+    this.localeValue = void 0;
+    this.fetchAllLocales = false;
+    return this;
+  }
+  /**
+   * Fetch content in all available locales
+   * Returns default locale at top level, others in _metadata.localizations
+   *
+   * @example
+   * ```typescript
+   * const product = await client.content('product')
+   *   .findById('prod_123')
+   *   .allLocales()
+   *   .execute()
+   *
+   * // Access: product.title (default locale)
+   * // Access: product._metadata.localizations['es-ES'].title
+   * // Access: product._metadata.availableLocales
+   * ```
+   */
+  allLocales() {
+    this.fetchAllLocales = true;
+    this.localeValue = void 0;
+    this.localesArray = void 0;
+    return this;
+  }
+  /**
+   * Select specific fields to return (projection)
+   * @param fieldNames - Array of field names to include
+   *
+   * @example
+   * ```typescript
+   * .fields(['id', 'title', 'price', 'brand.name'])
+   * ```
+   */
+  fields(fieldNames) {
+    this.fieldsProjection = fieldNames;
+    return this;
+  }
+  /**
+   * Include children in results (for hierarchical content)
+   * @param options - Children options or boolean to enable with defaults
+   *
+   * @example
+   * ```typescript
+   * // Include all children
+   * .children(true)
+   *
+   * // Include with options
+   * .children({ contentTypes: ['variant'], limit: 10 })
+   * ```
+   */
+  children(options) {
+    if (typeof options === "boolean") {
+      this.childrenOptions = options ? {} : void 0;
+    } else {
+      this.childrenOptions = options;
+    }
+    return this;
+  }
+  /**
+   * Set page number for page-based pagination
+   * @param pageNum - Page number (1-based)
+   */
+  page(pageNum) {
+    this.pageNumber = pageNum;
+    return this;
+  }
+  /**
+   * Set page size for page-based pagination
+   * @param size - Items per page
+   */
+  pageSize(size) {
+    this.pageSizeValue = size;
+    return this;
+  }
+  /**
+   * Execute the query and return all matching results
+   */
+  async execute() {
+    return readPayload(await this.executeWithMeta());
+  }
+  /**
+   * Execute the query and return the whole body — the items under `data`, the
+   * cursor facts under `page`.
+   */
+  async executeWithMeta() {
+    const response = await this.httpClient.send(
+      "/v1/{contentType}",
+      "get",
+      { path: { contentType: this.contentType }, query: this.buildQueryParams() }
+    );
+    return response.body;
+  }
+  /**
+   * Execute the query and return a single result (first match)
+   */
+  async first() {
+    const originalLimit = this.queryOptions.limit;
+    this.limit(1);
+    try {
+      const results = await this.execute();
+      return results.length > 0 ? results[0] ?? null : null;
+    } finally {
+      if (originalLimit !== void 0) {
+        this.queryOptions.limit = originalLimit;
+      } else {
+        delete this.queryOptions.limit;
+      }
+    }
+  }
+  /**
+   * Get paginated results
+   */
+  async paginate(limit = 20) {
+    return this.limit(limit).executeWithMeta();
+  }
+  /**
+   * Create an async iterator for streaming results
+   */
+  async *[Symbol.asyncIterator]() {
+    const limit = this.queryOptions.limit ?? 100;
+    let cursor;
+    let hasMore = true;
+    while (hasMore) {
+      if (cursor != null && cursor !== "") {
+        this.cursor(cursor);
+      }
+      const result = await this.limit(limit).executeWithMeta();
+      for (const item of readPayload(result)) {
+        yield item;
+      }
+      hasMore = result.page.hasMore;
+      cursor = result.page.nextCursor ?? void 0;
+    }
+  }
+  /**
+   * Execute the query and return all results as an array (for large datasets)
+   */
+  async all() {
+    const allItems = [];
+    for await (const item of this) {
+      allItems.push(item);
+    }
+    return allItems;
+  }
+  /**
+   * Clone the query builder
+   */
+  clone() {
+    const cloned = new _ContentQueryBuilder(this.httpClient, this.contentType, this.defaultLocale);
+    cloned.queryOptions = JSON.parse(JSON.stringify(this.queryOptions));
+    cloned.localeValue = this.localeValue;
+    cloned.localesArray = this.localesArray ? [...this.localesArray] : void 0;
+    cloned.fetchAllLocales = this.fetchAllLocales;
+    cloned.fieldsProjection = this.fieldsProjection ? [...this.fieldsProjection] : void 0;
+    cloned.pageNumber = this.pageNumber;
+    cloned.pageSizeValue = this.pageSizeValue;
+    return cloned;
+  }
+  /**
+   * Get the current query options
+   */
+  getQueryOptions() {
+    return { ...this.queryOptions };
+  }
+  /**
+   * Execute the query and return the whole body.
+   *
+   * Identical to {@link executeWithMeta} now that the list serves one shape;
+   * kept as the name callers already import.
+   */
+  async executeWithMetaExtended() {
+    return this.executeWithMeta();
+  }
+  /**
+   * `count()` and `exists()` are gone, and their absence is the honest answer
+   * rather than an omission (`INV-RD-CAPABILITY-IS-HONEST`).
+   *
+   * `count()` sent `withCount` and read `pagination.total`; API2 moved the
+   * customer list onto the **cursor** dialect, whose page facts are
+   * `{ nextCursor, hasMore }` and nothing else, so no total reaches this
+   * surface at all. Keeping the method would have meant either a request that
+   * always throws or a number assembled from a page the caller happened to
+   * fetch — a count of what was returned, presented as a count of what matched
+   * (rule 6). The plan's §3.3 listed `count` among six methods a type would
+   * repair; what the type actually shows is that the capability is no longer
+   * there. A caller that wants "is there at least one" fetches one and looks at
+   * `data.length`; a caller that wants a true total uses `POST /v1/search`,
+   * which is the offset dialect precisely because a facet-bearing result wants
+   * one (Decision 5).
+   */
+  /**
+   * Build query parameters for the HTTP request
+   */
+  buildQueryParams() {
+    const params = {};
+    if (this.queryOptions.where && Object.keys(this.queryOptions.where).length > 0) {
+      params.filters = JSON.stringify(this.queryOptions.where);
+    }
+    if (this.queryOptions.select) {
+      params.fields = this.queryOptions.select.join(",");
+    }
+    if (this.fieldsProjection) {
+      params.fields = this.fieldsProjection.join(",");
+    }
+    if (this.queryOptions.include) {
+      params.include = this.queryOptions.include.join(",");
+    }
+    if (this.queryOptions.sort) {
+      const sortArray = Object.entries(this.queryOptions.sort).map(
+        ([field, direction]) => `${field}:${direction}`
+      );
+      params.sort = sortArray.join(",");
+    }
+    if (this.queryOptions.limit !== void 0) {
+      params.limit = this.queryOptions.limit;
+    }
+    if (this.queryOptions.offset !== void 0) {
+      params.offset = this.queryOptions.offset;
+    }
+    if (this.queryOptions.cursor !== void 0) {
+      params.cursor = this.queryOptions.cursor;
+    }
+    if (this.localeValue != null && this.localeValue !== "") {
+      params.locale = this.localeValue;
+    } else if (this.fetchAllLocales) {
+      params.locale = "*";
+    } else if (this.localesArray && this.localesArray.length > 0) {
+      params.locales = this.localesArray.join(",");
+    } else if (this.defaultLocale != null && this.defaultLocale !== "") {
+      params.locale = this.defaultLocale;
+    }
+    if (this.pageNumber !== void 0) {
+      params.page = this.pageNumber;
+    }
+    if (this.pageSizeValue !== void 0) {
+      params.pageSize = this.pageSizeValue;
+    }
+    if (this.childrenOptions) {
+      if (this.childrenOptions.contentTypes) {
+        params.children = this.childrenOptions.contentTypes.join(",");
+      } else {
+        params.children = "true";
+      }
+      if (this.childrenOptions.limit !== void 0) {
+        params.childrenLimit = this.childrenOptions.limit;
+      }
+    }
+    return params;
+  }
+};
+__name(_ContentQueryBuilder, "ContentQueryBuilder");
+var ContentQueryBuilder = _ContentQueryBuilder;
+var _ContentByIdBuilder = class _ContentByIdBuilder {
+  constructor(httpClient, contentType, id, defaultLocale) {
+    this.httpClient = httpClient;
+    this.contentType = contentType;
+    this.id = id;
+    this.defaultLocale = defaultLocale;
+    __publicField(this, "includeRelations");
+    __publicField(this, "localeValue");
+    __publicField(this, "localesArray");
+    __publicField(this, "fetchAllLocales", false);
+    __publicField(this, "childrenOptions");
+  }
+  /**
+   * Include related content in the response
+   */
+  include(relations) {
+    this.includeRelations = relations;
+    return this;
+  }
+  /**
+   * Set locale for localized content
+   * @param locale - Locale code (e.g., 'en-US', 'de-DE', 'fr-FR')
+   */
+  locale(locale) {
+    this.localeValue = locale;
+    this.localesArray = void 0;
+    this.fetchAllLocales = false;
+    return this;
+  }
+  /**
+   * Fetch content in multiple specific locales
+   * Returns primary locale at top level, others in _metadata.localizations
+   *
+   * @param localeCodes - Array of locale codes to fetch
+   */
+  locales(localeCodes) {
+    this.localesArray = localeCodes;
+    this.localeValue = void 0;
+    this.fetchAllLocales = false;
+    return this;
+  }
+  /**
+   * Fetch content in all available locales
+   * Returns default locale at top level, others in _metadata.localizations
+   */
+  allLocales() {
+    this.fetchAllLocales = true;
+    this.localeValue = void 0;
+    this.localesArray = void 0;
+    return this;
+  }
+  /**
+   * Include children in results (for hierarchical content)
+   * @param options - Children options or boolean to enable with defaults
+   */
+  children(options) {
+    if (typeof options === "boolean") {
+      this.childrenOptions = options ? {} : void 0;
+    } else {
+      this.childrenOptions = options;
+    }
+    return this;
+  }
+  /**
+   * Execute the query and return the content item
+   */
+  async execute() {
+    const params = {};
+    if (this.includeRelations != null) {
+      params.include = this.includeRelations.join(",");
+    }
+    if (this.localeValue != null && this.localeValue !== "") {
+      params.locale = this.localeValue;
+    } else if (this.fetchAllLocales) {
+      params.locale = "*";
+    } else if (this.localesArray && this.localesArray.length > 0) {
+      params.locales = this.localesArray.join(",");
+    } else if (this.defaultLocale != null && this.defaultLocale !== "") {
+      params.locale = this.defaultLocale;
+    }
+    if (this.childrenOptions != null) {
+      if (this.childrenOptions.contentTypes) {
+        params.children = this.childrenOptions.contentTypes.join(",");
+      } else {
+        params.children = "true";
+      }
+      if (this.childrenOptions.limit !== void 0) {
+        params.childrenLimit = this.childrenOptions.limit;
+      }
+    }
+    try {
+      return await this.httpClient.fetchPayload(
+        "/v1/{contentType}/{id}",
+        "get",
+        { path: { contentType: this.contentType, id: this.id }, query: params }
+      );
+    } catch (error) {
+      if (isResourceNotFound(error)) return null;
+      throw error;
+    }
+  }
+};
+__name(_ContentByIdBuilder, "ContentByIdBuilder");
+var ContentByIdBuilder = _ContentByIdBuilder;
+
+// ../../platform/api-contract/dist/index.js
+var HEADER_ENTITY_TAG = { name: "X-Entity-Tag" };
+var HEADER_IF_MATCH = {
+  name: "If-Match"};
+var HEADER_IDEMPOTENCY_KEY = {
+  name: "Idempotency-Key"};
+
+// src/http/write-options.ts
+function writeHeaders(options) {
+  if (options === void 0) return void 0;
+  const headers = {};
+  if ("ifMatch" in options && options.ifMatch !== void 0) {
+    headers[HEADER_IF_MATCH.name] = options.ifMatch;
+  }
+  if (options.idempotencyKey !== void 0) {
+    headers[HEADER_IDEMPOTENCY_KEY.name] = options.idempotencyKey;
+  }
+  return Object.keys(headers).length > 0 ? headers : void 0;
+}
+__name(writeHeaders, "writeHeaders");
+function entityTagOf(response) {
+  const wanted = HEADER_ENTITY_TAG.name.toLowerCase();
+  for (const [name, value] of Object.entries(response.headers)) {
+    if (name.toLowerCase() === wanted) return value;
+  }
+  return void 0;
+}
+__name(entityTagOf, "entityTagOf");
+
+// src/content/content-client.ts
+var _ContentClient = class _ContentClient {
+  constructor(httpClient, contentType, defaultLocale) {
+    this.httpClient = httpClient;
+    this.contentType = contentType;
+    this.defaultLocale = defaultLocale;
+  }
+  /**
+   * Create a new query builder for this content type
+   */
+  query() {
+    return new ContentQueryBuilder(this.httpClient, this.contentType, this.defaultLocale);
+  }
+  /**
+   * Find content by ID with fluent options
+   */
+  findById(id) {
+    return new ContentByIdBuilder(this.httpClient, this.contentType, id, this.defaultLocale);
+  }
+  /**
+   * Fetch all content items
+   * @param locale - Optional locale for localized content
+   */
+  async fetchAll(locale) {
+    const builder = this.query();
+    if (locale != null && locale !== "") {
+      builder.locale(locale);
+    }
+    return builder.execute();
+  }
+  /**
+   * Fetch content with query options
+   */
+  async fetch(options) {
+    const builder = this.query();
+    if (options?.where) {
+      builder.where(options.where);
+    }
+    if (options?.limit != null) {
+      builder.limit(options.limit);
+    }
+    if (options?.offset != null) {
+      builder.offset(options.offset);
+    }
+    if (options?.sort) {
+      builder.sort(options.sort);
+    }
+    if (options?.include) {
+      builder.include(options.include);
+    }
+    if (options?.locale != null && options.locale !== "") {
+      builder.locale(options.locale);
+    }
+    if (options?.fields != null) {
+      builder.fields(options.fields);
+    }
+    if (options?.children != null) {
+      builder.children(options.children);
+    }
+    return builder.execute();
+  }
+  /**
+   * Fetch a single content item by ID
+   * @param id - Entry ID or slug
+   * @param options - Fetch options (include, locale)
+   */
+  async fetchOne(id, options) {
+    const builder = this.findById(id);
+    if (options?.include != null) {
+      builder.include(options.include);
+    }
+    if (options?.locale != null && options.locale !== "") {
+      builder.locale(options.locale);
+    }
+    return builder.execute();
+  }
+  /**
+   * Fetch one entry **and the entity tag that read served**.
+   *
+   * This is the read half of a conditional write. `X-Entity-Tag` is minted from
+   * `(entryUid, locale, localeVersion)` and is exactly what `If-Match` takes,
+   * so a caller reads here, edits, and hands the same string back to `update`
+   * — with nothing to assemble in between
+   * (`INV-API-CONDITIONAL-WRITE-IS-REACHABLE`).
+   *
+   * `entityTag` is `undefined` when the response came from the cache: a cached
+   * body cannot know the current version, and an absent tag beats a stale one
+   * that would refuse the next write.
+   */
+  async fetchOneWithTag(id, options) {
+    const query = {};
+    if (options?.include != null) query.include = options.include.join(",");
+    const locale = options?.locale ?? this.defaultLocale;
+    if (locale != null && locale !== "") query.locale = locale;
+    const response = await this.httpClient.send(
+      "/v1/{contentType}/{id}",
+      "get",
+      { path: { contentType: this.contentType, id }, query }
+    );
+    return { entry: readPayload(response.body), entityTag: entityTagOf(response) };
+  }
+  /**
+   * Fetch the first content item matching the conditions
+   * @param where - Filter conditions
+   * @param locale - Optional locale
+   */
+  async fetchFirst(where, locale) {
+    const builder = this.query();
+    if (where != null) {
+      builder.where(where);
+    }
+    if (locale != null && locale !== "") {
+      builder.locale(locale);
+    }
+    return builder.first();
+  }
+  /**
+   * Create a new content item
+   * @param data - Content data
+   * @param options - Create options (slug, locale, parentId, sortOrder)
+   */
+  async create(data, options) {
+    const { idempotencyKey, ...body } = options ?? {};
+    return this.httpClient.fetchPayload(
+      "/v1/{contentType}",
+      "post",
+      {
+        path: { contentType: this.contentType },
+        body: { content: data, ...body },
+        headers: writeHeaders({ idempotencyKey })
+      }
+    );
+  }
+  /**
+   * Update a content item by ID (partial update)
+   * @param id - Entry ID
+   * @param data - Fields to update
+   * @param options - Update options (slug, locale, parentId, sortOrder)
+   */
+  async update(id, data, options) {
+    const { idempotencyKey, ifMatch, ...body } = options ?? {};
+    return this.httpClient.fetchPayload(
+      "/v1/{contentType}/{id}",
+      "patch",
+      {
+        path: { contentType: this.contentType, id },
+        body: { content: data, ...body },
+        headers: writeHeaders({ idempotencyKey, ifMatch })
+      }
+    );
+  }
+  /**
+   * Delete a content item by ID
+   */
+  async delete(id, options) {
+    await this.httpClient.send("/v1/{contentType}/{id}", "delete", {
+      path: { contentType: this.contentType, id },
+      headers: writeHeaders(options)
+    });
+  }
+  /**
+   * Check if content exists by ID
+   */
+  async exists(id) {
+    try {
+      const item = await this.fetchOne(id);
+      return item !== null;
+    } catch (error) {
+      if (error instanceof ResourceNotFoundError) {
+        return false;
+      }
+      throw error;
+    }
+  }
+  /**
+   * Get version history for one locale of an entry.
+   *
+   * Versions are numbered per locale, so this is one locale's timeline: `locale` defaults to the
+   * schema default, no fallback is applied, and a locale with no history returns an empty array
+   * rather than another locale's rows. Every row names the locale it belongs to.
+   */
+  async versions(id, options) {
+    return this.httpClient.fetchPayload("/v1/{contentType}/{id}/versions", "get", {
+      path: { contentType: this.contentType, id },
+      query: {
+        limit: options?.limit ?? 10,
+        ...options?.locale === void 0 ? {} : { locale: options.locale }
+      }
+    });
+  }
+  /**
+   * Get a specific version of an entry.
+   *
+   * `locale` defaults to the schema default. Version numbers are per locale, so version 2 is
+   * different content in each one.
+   */
+  async version(id, versionNumber, options) {
+    return this.httpClient.fetchPayload("/v1/{contentType}/{id}/versions/{versionNumber}", "get", {
+      path: {
+        contentType: this.contentType,
+        id,
+        versionNumber: String(versionNumber)
+      },
+      query: options?.locale === void 0 ? void 0 : { locale: options.locale }
+    });
+  }
+  /**
+   * Revert one locale of an entry to a previous version.
+   *
+   * `locale` is **required**, and that is not a convention: versions are numbered per locale, so
+   * `versionNumber` alone is ambiguous, and defaulting it would silently revert the wrong
+   * translation. Only that locale's fields change — shared fields and every other locale are left
+   * untouched.
+   *
+   * The restore is validated as strictly as a publish, so it cannot publish invalid content, and it
+   * records a new version of its own rather than rewinding the counter — so the revert is auditable
+   * and itself reversible.
+   */
+  async restore(id, versionNumber, locale, options) {
+    return this.httpClient.fetchPayload("/v1/{contentType}/{id}/versions/{versionNumber}/restore", "post", {
+      path: {
+        contentType: this.contentType,
+        id,
+        versionNumber: String(versionNumber)
+      },
+      body: { locale },
+      headers: writeHeaders(options)
+    });
+  }
+  /**
+   * Get children of a hierarchical entry
+   * @param id - Parent entry ID
+   * @param options - Fetch options
+   */
+  async children(id, options) {
+    const params = {};
+    if (options?.depth != null) {
+      params.depth = options.depth;
+    }
+    if (options?.include != null) {
+      params.include = options.include.join(",");
+    }
+    if (options?.locale != null && options.locale !== "") {
+      params.locale = options.locale;
+    }
+    return this.httpClient.fetchPayload(
+      "/v1/{contentType}/{id}/children",
+      "get",
+      { path: { contentType: this.contentType, id }, query: params }
+    );
+  }
+  /**
+   * Get the content type name
+   */
+  getContentType() {
+    return this.contentType;
+  }
+  /**
+   * Create a new ContentClient for a different content type
+   */
+  ofType(contentType) {
+    return new _ContentClient(this.httpClient, contentType, this.defaultLocale);
+  }
+  /**
+   * Create a new ContentClient with a different default locale
+   */
+  withLocale(locale) {
+    return new _ContentClient(this.httpClient, this.contentType, locale);
+  }
+  /**
+   * Get the current default locale
+   */
+  getDefaultLocale() {
+    return this.defaultLocale;
+  }
+};
+__name(_ContentClient, "ContentClient");
+var ContentClient = _ContentClient;
+
+// src/errors/file-errors.ts
+var _FileUploadError = class _FileUploadError extends SDKError {
+  constructor(code, message, options = {}) {
+    super(message, options.statusCode, options.cause, { fileErrorCode: code });
+    __publicField(this, "code");
+    __publicField(this, "retryable");
+    this.code = code;
+    this.retryable = options.retriable ?? false;
+  }
+  getUserMessage() {
+    return this.message;
+  }
+};
+__name(_FileUploadError, "FileUploadError");
+var FileUploadError = _FileUploadError;
+var _FileValidationError = class _FileValidationError extends BaseValidationError {
+  constructor(message, violations = [], cause) {
+    super(message, violations, 400, cause);
+    __publicField(this, "code", "FILE_VALIDATION_ERROR");
+  }
+  getUserMessage() {
+    if (this.violations.length === 1) return this.violations[0]?.message ?? this.message;
+    return this.message;
+  }
+};
+__name(_FileValidationError, "FileValidationError");
+var FileValidationError = _FileValidationError;
+function validateFile(file, constraints = {}) {
+  const violations = [];
+  const { allowedMimeTypes, maxSizeBytes } = constraints;
+  if (allowedMimeTypes && allowedMimeTypes.length > 0 && file.type != null && file.type !== "" && !allowedMimeTypes.includes(file.type)) {
+    violations.push({
+      field: "file",
+      code: "UNSUPPORTED_MIME",
+      message: `Unsupported file type "${file.type}". Allowed: ${allowedMimeTypes.join(", ")}`,
+      value: file.type
+    });
+  }
+  if (typeof maxSizeBytes === "number" && maxSizeBytes > 0 && typeof file.size === "number" && file.size > maxSizeBytes) {
+    violations.push({
+      field: "file",
+      code: "UPLOAD_TOO_LARGE",
+      message: `File is too large (${file.size} bytes); max is ${maxSizeBytes} bytes`,
+      value: file.size
+    });
+  }
+  return violations;
+}
+__name(validateFile, "validateFile");
+
+// src/content/asset-client.ts
+function hasText(value) {
+  return value != null && value !== "";
+}
+__name(hasText, "hasText");
+async function computeSha256Hex(blob) {
+  try {
+    const subtle = globalThis.crypto?.subtle;
+    if (subtle === void 0 || typeof blob.arrayBuffer !== "function") return void 0;
+    const digest = await subtle.digest("SHA-256", await blob.arrayBuffer());
+    const bytes = new Uint8Array(digest);
+    let hex = "";
+    for (const byte of bytes) hex += byte.toString(16).padStart(2, "0");
+    return hex;
+  } catch {
+    return void 0;
+  }
+}
+__name(computeSha256Hex, "computeSha256Hex");
+var _AssetFileBuilder = class _AssetFileBuilder {
+  constructor(httpClient, assetType, entryUid, defaultLocale) {
+    this.httpClient = httpClient;
+    this.assetType = assetType;
+    this.entryUid = entryUid;
+    this.defaultLocale = defaultLocale;
+  }
+  /**
+   * The path parameters every `/file/*` route on this builder takes.
+   *
+   * The path *template* is the document's; only these two values are the
+   * builder's, so a route that gains or loses a segment is a compile error here
+   * rather than a hand-built string that silently misses.
+   */
+  get target() {
+    return { contentType: this.assetType, id: this.entryUid };
+  }
+  withLocale(locale) {
+    return locale ?? this.defaultLocale;
+  }
+  /**
+   * Issue a single upload target — an R2 presigned PUT (image/file) or a
+   * Cloudflare Stream direct-creator URL (video). Resumable multipart is plan 17.
+   */
+  async presign(input) {
+    const locale = this.withLocale(input.locale);
+    return this.httpClient.fetchPayload("/v1/{contentType}/{id}/file/presign", "post", {
+      path: this.target,
+      body: {
+        fileName: input.fileName,
+        ...hasText(input.contentType) ? { contentType: input.contentType } : {},
+        ...input.size != null ? { size: input.size } : {},
+        ...hasText(locale) ? { locale } : {},
+        ...hasText(input.hash) ? { hash: input.hash } : {}
+      }
+    });
+  }
+  /**
+   * Acknowledge a completed client upload (kicks off the fast-path intake for
+   * R2; a no-op for Stream, whose readiness is webhook-driven).
+   */
+  async confirm(input = {}) {
+    const locale = this.withLocale(input.locale);
+    return this.httpClient.fetchPayload("/v1/{contentType}/{id}/file/confirm", "post", {
+      path: this.target,
+      body: {
+        ...hasText(locale) ? { locale } : {},
+        ...hasText(input.hash) ? { hash: input.hash } : {}
+      }
+    });
+  }
+  // ──────────────────────────────────────────────────────────────────────────
+  // MULTIPART (resumable large-file uploads) — same 5-call protocol the
+  // Studio Uppy path uses. No Uppy dependency in the SDK.
+  // ──────────────────────────────────────────────────────────────────────────
+  /** Open an R2 multipart session for a large file (standalone of `presign`). */
+  async createMultipart(input) {
+    const locale = this.withLocale(input.locale);
+    return this.httpClient.fetchPayload("/v1/{contentType}/{id}/file/multipart/create", "post", {
+      path: this.target,
+      body: {
+        fileName: input.fileName,
+        ...hasText(input.contentType) ? { contentType: input.contentType } : {},
+        ...input.size != null ? { size: input.size } : {},
+        ...hasText(locale) ? { locale } : {},
+        ...hasText(input.hash) ? { hash: input.hash } : {}
+      }
+    });
+  }
+  /** Presign a single part PUT (1-based `partNumber`). */
+  async signPart(target) {
+    return this.httpClient.fetchPayload("/v1/{contentType}/{id}/file/multipart/sign-part", "post", {
+      path: this.target,
+      body: {
+        uploadId: target.uploadId,
+        objectKey: target.objectKey,
+        partNumber: target.partNumber,
+        ...hasText(target.locale) ? { locale: target.locale } : {}
+      }
+    });
+  }
+  /** List parts already uploaded (cross-session resume). */
+  async listParts(target) {
+    const payload = await this.httpClient.fetchPayload("/v1/{contentType}/{id}/file/multipart/list-parts", "post", {
+      path: this.target,
+      body: {
+        uploadId: target.uploadId,
+        objectKey: target.objectKey,
+        ...hasText(target.locale) ? { locale: target.locale } : {}
+      }
+    });
+    return payload.parts;
+  }
+  /** Finalize a multipart session. */
+  async completeMultipart(target) {
+    return this.httpClient.fetchPayload("/v1/{contentType}/{id}/file/multipart/complete", "post", {
+      path: this.target,
+      body: {
+        uploadId: target.uploadId,
+        objectKey: target.objectKey,
+        parts: target.parts.map((p) => ({ partNumber: p.partNumber, etag: p.etag })),
+        ...hasText(target.locale) ? { locale: target.locale } : {}
+      }
+    });
+  }
+  /** Abort a multipart session, freeing staged parts. */
+  async abortMultipart(target) {
+    return this.httpClient.fetchPayload("/v1/{contentType}/{id}/file/multipart/abort", "post", {
+      path: this.target,
+      body: {
+        uploadId: target.uploadId,
+        objectKey: target.objectKey,
+        ...hasText(target.locale) ? { locale: target.locale } : {}
+      }
+    });
+  }
+  /**
+   * Resolve a single gateway delivery URL for the requested locale/variant/purpose.
+   * Throws if the binding is not `ready`.
+   */
+  async url(input = {}) {
+    const params = {};
+    const locale = this.withLocale(input.locale);
+    if (hasText(locale)) params.locale = locale;
+    if (hasText(input.variantId)) params.variantId = input.variantId;
+    if (input.purpose !== void 0) params.purpose = input.purpose;
+    return this.httpClient.fetchPayload(
+      "/v1/{contentType}/{id}/file/url",
+      "get",
+      { path: this.target, query: params }
+    );
+  }
+  /**
+   * Update the binding's delivery visibility (token-based; no byte relocation —
+   * a downgrade purges the gateway cache). Returns the refreshed asset entry.
+   */
+  async updateVisibility(visibility, options = {}) {
+    const locale = this.withLocale(options.locale);
+    return this.httpClient.fetchPayload("/v1/{contentType}/{id}/file", "patch", {
+      path: this.target,
+      body: { visibility, ...hasText(locale) ? { locale } : {} }
+    });
+  }
+  /**
+   * Set the binding's normalized (0..1, origin top-left) smart-crop focal point
+   * (plan 18) so `cover`/`crop` variants frame the subject. Per locale for
+   * file-localized asset types; token-based (no byte change). Returns the
+   * refreshed asset entry.
+   */
+  async setFocalPoint(focalPoint, options = {}) {
+    const locale = this.withLocale(options.locale);
+    return this.httpClient.fetchPayload("/v1/{contentType}/{id}/file", "patch", {
+      path: this.target,
+      body: { focalPoint, ...hasText(locale) ? { locale } : {} }
+    });
+  }
+  /**
+   * Remove the file binding, clean up the underlying bytes, and purge the
+   * gateway cache. The asset entry itself is preserved.
+   */
+  async delete(options = {}) {
+    const params = {};
+    const locale = this.withLocale(options.locale);
+    if (hasText(locale)) params.locale = locale;
+    await this.httpClient.send("/v1/{contentType}/{id}/file", "delete", {
+      path: this.target,
+      query: params
+    });
+  }
+  /**
+   * Poll the asset entry until its file binding reaches `ready` (resolves with
+   * the ready entry) or `failed` (throws). Times out after `timeoutMs`.
+   */
+  async waitUntilReady(options = {}) {
+    const timeoutMs = options.timeoutMs ?? 6e4;
+    const pollIntervalMs = options.pollIntervalMs ?? 1500;
+    const locale = this.withLocale(options.locale);
+    const deadline = Date.now() + timeoutMs;
+    for (; ; ) {
+      const builder = new ContentByIdBuilder(
+        this.httpClient,
+        this.assetType,
+        this.entryUid,
+        locale
+      );
+      if (hasText(locale)) builder.locale(locale);
+      const entry = await builder.execute();
+      const status = entry?.file?.status;
+      if (entry && status === "ready") return entry;
+      if (status === "failed") {
+        const message = entry?.file?.processing?.error?.message ?? "File processing failed";
+        throw new Error(`Asset ${this.assetType}/${this.entryUid}: ${message}`);
+      }
+      if (Date.now() >= deadline) {
+        throw new Error(
+          `Timed out after ${timeoutMs}ms waiting for ${this.assetType}/${this.entryUid} (status: ${status ?? "unknown"})`
+        );
+      }
+      await new Promise((resolve) => setTimeout(resolve, pollIntervalMs));
+    }
+  }
+};
+__name(_AssetFileBuilder, "AssetFileBuilder");
+var AssetFileBuilder = _AssetFileBuilder;
+var _AssetUploadBuilder = class _AssetUploadBuilder {
+  constructor(httpClient, assetType, file, defaultLocale) {
+    this.httpClient = httpClient;
+    this.assetType = assetType;
+    this.file = file;
+    this.defaultLocale = defaultLocale;
+    __publicField(this, "_fileName");
+    __publicField(this, "_visibility");
+    __publicField(this, "_locale");
+    __publicField(this, "_publish");
+    __publicField(this, "_content", {});
+    __publicField(this, "_slug");
+    __publicField(this, "_waitForReady", false);
+    __publicField(this, "_waitOptions", {});
+    __publicField(this, "_onProgress");
+    __publicField(this, "_validate");
+    __publicField(this, "_maxPartRetries", 3);
+  }
+  /** Subscribe to client → storage upload progress (single PUT + multipart). */
+  onProgress(callback) {
+    this._onProgress = callback;
+    return this;
+  }
+  /**
+   * Validate the file client-side (UX only) against explicit constraints before
+   * any bytes leave the machine. Rejects instantly with a {@link FileValidationError}.
+   */
+  validate(constraints) {
+    this._validate = constraints;
+    return this;
+  }
+  /** Bounded per-part retry attempts for multipart (default 3). */
+  maxPartRetries(attempts) {
+    this._maxPartRetries = Math.max(0, attempts);
+    return this;
+  }
+  /** Set the original file name (defaults to `file.name` for `File` inputs). */
+  filename(name) {
+    this._fileName = name;
+    return this;
+  }
+  /** Set the initial delivery visibility (default `public`). */
+  visibility(visibility) {
+    this._visibility = visibility;
+    return this;
+  }
+  /** Target locale for file-localized asset types. */
+  locale(locale) {
+    this._locale = locale;
+    return this;
+  }
+  /** Suppress (or enable) auto-publish on ready. */
+  publish(publish) {
+    this._publish = publish;
+    return this;
+  }
+  /** Set the asset's metadata field values (e.g. `{ alt: '...' }`). */
+  content(content) {
+    this._content = content;
+    return this;
+  }
+  /** Set an explicit slug for the new entry. */
+  slug(slug) {
+    this._slug = slug;
+    return this;
+  }
+  /** Wait until the file binding becomes `ready` before resolving. */
+  waitForReady(options = true) {
+    if (options === false) {
+      this._waitForReady = false;
+    } else {
+      this._waitForReady = true;
+      if (typeof options === "object") this._waitOptions = options;
+    }
+    return this;
+  }
+  /** Execute the full upload flow and resolve with the asset entry. */
+  async execute() {
+    const fileName = this._fileName ?? this.file.name;
+    if (!fileName) {
+      throw new Error('A file name is required: pass a File, or call .filename("name.ext")');
+    }
+    const locale = this._locale ?? this.defaultLocale;
+    if (this._validate) {
+      const violations = validateFile(this.file, this._validate);
+      if (violations.length > 0) {
+        throw new FileValidationError(
+          `File validation failed: ${violations.map((v) => v.message).join("; ")}`,
+          violations
+        );
+      }
+    }
+    const hash = await computeSha256Hex(this.file);
+    const client = new AssetClient(this.httpClient, this.assetType, this.defaultLocale);
+    const created = await client.create(this._content, {
+      ...hasText(this._slug) ? { slug: this._slug } : {},
+      ...hasText(locale) ? { locale } : {},
+      fileName,
+      ...this._visibility !== void 0 ? { visibility: this._visibility } : {},
+      ...this._publish != null ? { publish: this._publish } : {}
+    });
+    const entryUid = created._metadata.id;
+    const fileBuilder = client.file(entryUid);
+    const presigned = await fileBuilder.presign({
+      fileName,
+      ...hasText(this.file.type) ? { contentType: this.file.type } : {},
+      ...this.file.size > 0 ? { size: this.file.size } : {},
+      ...hasText(locale) ? { locale } : {},
+      ...hasText(hash) ? { hash } : {}
+    });
+    if (presigned.mode === "multipart") {
+      await this.uploadMultipart(fileBuilder, presigned, entryUid, locale);
+    } else {
+      await this.uploadSingle(presigned, entryUid);
+    }
+    await fileBuilder.confirm({
+      ...hasText(locale) ? { locale } : {},
+      ...hasText(hash) ? { hash } : {}
+    });
+    if (this._waitForReady) {
+      return fileBuilder.waitUntilReady({
+        ...this._waitOptions,
+        ...hasText(locale) ? { locale } : {}
+      });
+    }
+    return created;
+  }
+  /** Single presigned PUT (≤ 50 MB / Stream POST). */
+  async uploadSingle(presigned, entryUid) {
+    if (!hasText(presigned.uploadUrl)) {
+      throw new FileUploadError("INTERNAL", "Presign did not return an upload URL", {});
+    }
+    const total = this.file.size;
+    this.emitProgress(0, total);
+    const uploadResponse = await fetch(presigned.uploadUrl, {
+      method: presigned.method,
+      headers: presigned.headers,
+      body: this.file
+    });
+    if (!uploadResponse.ok) {
+      throw new FileUploadError(
+        "INTERNAL",
+        `Upload failed (${uploadResponse.status} ${uploadResponse.statusText}) for ${this.assetType}/${entryUid}`,
+        { retriable: uploadResponse.status >= 500, statusCode: uploadResponse.status }
+      );
+    }
+    this.emitProgress(total, total);
+  }
+  /**
+   * Resumable R2 multipart: slice into `partSize` chunks, skip already-uploaded
+   * parts (resume via `list-parts`), PUT each remaining part with bounded retry,
+   * then `complete`. Aborts the session on unrecoverable failure.
+   */
+  async uploadMultipart(fileBuilder, presigned, entryUid, locale) {
+    const { uploadId, objectKey, partSize } = presigned;
+    if (!hasText(uploadId) || !hasText(objectKey) || partSize == null || partSize <= 0) {
+      throw new FileUploadError("INTERNAL", "Incomplete multipart session from presign", {});
+    }
+    const target = { uploadId, objectKey, ...hasText(locale) ? { locale } : {} };
+    const total = this.file.size;
+    const partCount = Math.max(1, Math.ceil(total / partSize));
+    const existing = /* @__PURE__ */ new Map();
+    try {
+      for (const part of await fileBuilder.listParts(target)) existing.set(part.partNumber, part);
+    } catch {
+    }
+    const parts = [];
+    let uploaded = [...existing.values()].reduce((sum, p) => sum + (p.size ?? 0), 0);
+    this.emitProgress(uploaded, total);
+    try {
+      for (let partNumber = 1; partNumber <= partCount; partNumber += 1) {
+        const already = existing.get(partNumber);
+        if (already) {
+          parts.push(already);
+          continue;
+        }
+        const start = (partNumber - 1) * partSize;
+        const blob = this.file.slice(start, Math.min(start + partSize, total));
+        const etag = await this.putPartWithRetry(fileBuilder, target, partNumber, blob);
+        parts.push({ partNumber, etag, size: blob.size });
+        uploaded += blob.size;
+        this.emitProgress(uploaded, total);
+      }
+      await fileBuilder.completeMultipart({ ...target, parts });
+    } catch (error) {
+      await fileBuilder.abortMultipart(target).catch(() => {
+      });
+      if (error instanceof FileUploadError) throw error;
+      throw new FileUploadError(
+        "INTERNAL",
+        `Multipart upload failed for ${this.assetType}/${entryUid}: ${error instanceof Error ? error.message : String(error)}`,
+        { retriable: true, cause: error instanceof Error ? error : void 0 }
+      );
+    }
+  }
+  /** PUT a single part, retrying transient failures up to `_maxPartRetries`. */
+  async putPartWithRetry(fileBuilder, target, partNumber, blob) {
+    let lastError;
+    for (let attempt = 0; attempt <= this._maxPartRetries; attempt += 1) {
+      try {
+        const { url } = await fileBuilder.signPart({ ...target, partNumber });
+        const response = await fetch(url, { method: "PUT", body: blob });
+        if (!response.ok) {
+          const retriable = response.status >= 500 || response.status === 408 || response.status === 429;
+          if (!retriable) {
+            throw new FileUploadError(
+              "INTERNAL",
+              `Part ${partNumber} upload failed (${response.status} ${response.statusText})`,
+              { statusCode: response.status }
+            );
+          }
+          lastError = new Error(`part ${partNumber} -> ${response.status}`);
+        } else {
+          const etag = response.headers.get("etag") ?? response.headers.get("ETag");
+          if (etag == null || etag === "") {
+            throw new FileUploadError(
+              "INTERNAL",
+              `Part ${partNumber} response is missing an ETag header`,
+              {}
+            );
+          }
+          return etag;
+        }
+      } catch (error) {
+        if (error instanceof FileUploadError && !error.retryable) throw error;
+        lastError = error;
+      }
+      if (attempt < this._maxPartRetries) await new Promise((r) => setTimeout(r, 200 * 2 ** attempt));
+    }
+    throw new FileUploadError(
+      "INTERNAL",
+      `Part ${partNumber} failed after ${this._maxPartRetries + 1} attempts: ${lastError instanceof Error ? lastError.message : String(lastError)}`,
+      { retriable: true, cause: lastError instanceof Error ? lastError : void 0 }
+    );
+  }
+  emitProgress(loaded, total) {
+    if (!this._onProgress) return;
+    const progress = total > 0 ? Math.max(0, Math.min(100, Math.round(loaded / total * 100))) : 0;
+    this._onProgress({ phase: "upload", loaded, total, progress });
+  }
+};
+__name(_AssetUploadBuilder, "AssetUploadBuilder");
+var AssetUploadBuilder = _AssetUploadBuilder;
+var _AssetClient = class _AssetClient {
+  constructor(httpClient, assetType, defaultLocale) {
+    this.httpClient = httpClient;
+    this.assetType = assetType;
+    this.defaultLocale = defaultLocale;
+  }
+  /** Create a query builder for this asset type. */
+  query() {
+    return new ContentQueryBuilder(
+      this.httpClient,
+      this.assetType,
+      this.defaultLocale
+    );
+  }
+  /** Find an asset entry by id (or slug) with fluent options. */
+  findById(id) {
+    return new ContentByIdBuilder(
+      this.httpClient,
+      this.assetType,
+      id,
+      this.defaultLocale
+    );
+  }
+  /** Fetch a single asset entry by id (or slug), or `null` if not found. */
+  async fetchOne(id, options) {
+    const builder = this.findById(id);
+    if (options?.include != null) builder.include(options.include);
+    if (options?.locale != null && options.locale !== "") builder.locale(options.locale);
+    return builder.execute();
+  }
+  /** Fetch the first asset entry matching the conditions, or `null`. */
+  async fetchFirst(where, locale) {
+    const builder = this.query();
+    if (where != null) builder.where(where);
+    if (locale != null && locale !== "") builder.locale(locale);
+    return builder.first();
+  }
+  /**
+   * Create a new asset entry as a draft. The binary is uploaded separately via
+   * `file(uid)` (or use the high-level `upload()` helper), and the entry
+   * auto-publishes when its file becomes ready (unless `publish: false`).
+   */
+  async create(data, options) {
+    const { idempotencyKey, ...rest } = options ?? {};
+    return this.httpClient.fetchPayload(
+      "/v1/{contentType}",
+      "post",
+      {
+        path: { contentType: this.assetType },
+        body: { content: data, ...rest },
+        headers: writeHeaders({ idempotencyKey })
+      }
+    );
+  }
+  /** Update an asset entry's metadata fields (and/or slug). */
+  async update(id, data, options) {
+    const { idempotencyKey, ifMatch, ...rest } = options ?? {};
+    return this.httpClient.fetchPayload(
+      "/v1/{contentType}/{id}",
+      "patch",
+      {
+        path: { contentType: this.assetType, id },
+        body: { content: data, ...rest },
+        headers: writeHeaders({ idempotencyKey, ifMatch })
+      }
+    );
+  }
+  /** Delete an asset entry (cascades file-byte cleanup + gateway purge). */
+  async delete(id, options) {
+    await this.httpClient.send("/v1/{contentType}/{id}", "delete", {
+      path: { contentType: this.assetType, id },
+      headers: writeHeaders(options)
+    });
+  }
+  /** Get the file sub-resource builder for a specific asset entry. */
+  file(entryUid) {
+    return new AssetFileBuilder(this.httpClient, this.assetType, entryUid, this.defaultLocale);
+  }
+  /** Start a high-level upload (create → presign → PUT → confirm). */
+  upload(file) {
+    return new AssetUploadBuilder(this.httpClient, this.assetType, file, this.defaultLocale);
+  }
+  /** Get the asset type id. */
+  getAssetType() {
+    return this.assetType;
+  }
+  /** Get the current default locale. */
+  getDefaultLocale() {
+    return this.defaultLocale;
+  }
+  /** Create a new AssetClient for this type with a different default locale. */
+  withLocale(locale) {
+    return new _AssetClient(this.httpClient, this.assetType, locale);
+  }
+};
+__name(_AssetClient, "AssetClient");
+var AssetClient = _AssetClient;
+function isAssetEntry(entry) {
+  if (entry == null || typeof entry !== "object") return false;
+  const metadata = entry._metadata;
+  return metadata?.entryType === "asset";
+}
+__name(isAssetEntry, "isAssetEntry");
+
+// src/content/singleton-client.ts
+var _SingletonClient = class _SingletonClient {
+  constructor(httpClient, singletonKey) {
+    this.httpClient = httpClient;
+    this.singletonKey = singletonKey;
+    __publicField(this, "includeFields");
+    __publicField(this, "localeValue");
+  }
+  /**
+   * Include reference fields in the response
+   * @param fields - Reference field names to populate
+   */
+  include(fields) {
+    this.includeFields = fields;
+    return this;
+  }
+  /**
+   * Set locale for localized content
+   * @param locale - Locale code (e.g., 'en', 'de', 'fr')
+   */
+  locale(locale) {
+    this.localeValue = locale;
+    return this;
+  }
+  /**
+   * Fetch the singleton content
+   * @param options - Optional fetch options (alternative to fluent methods)
+   */
+  async fetch(options) {
+    const includeValue = options?.include ?? this.includeFields;
+    options?.locale ?? this.localeValue;
+    if (includeValue) {
+      includeValue.join(",");
+    }
+    try {
+      return (await this.fetchWithTag(options)).content;
+    } catch (error) {
+      if (isResourceNotFound(error)) return null;
+      throw error;
+    }
+  }
+  /**
+   * Fetch the singleton **and the entity tag that read served**, which is what
+   * `update`'s `ifMatch` takes (`INV-API-CONDITIONAL-WRITE-IS-REACHABLE`).
+   *
+   * `entityTag` is absent on a cache HIT: a cached body cannot know the current
+   * version, and a stale tag would refuse the very next write.
+   */
+  async fetchWithTag(options) {
+    const query = {};
+    const includeValue = options?.include ?? this.includeFields;
+    const localeValueFinal = options?.locale ?? this.localeValue;
+    if (includeValue) query.include = includeValue.join(",");
+    if (localeValueFinal != null && localeValueFinal !== "") query.locale = localeValueFinal;
+    const response = await this.httpClient.send(
+      "/v1/singletons/{key}",
+      "get",
+      { path: { key: this.singletonKey }, query }
+    );
+    return { content: readPayload(response.body), entityTag: entityTagOf(response) };
+  }
+  /**
+   * Update singleton content. The API auto-publishes on PATCH — there is no
+   * separate publish route; calling `update()` writes and publishes.
+   * @param data - The content fields to update
+   * @param locale - Optional locale for localized content (overrides fluent locale)
+   * @param options - `If-Match` / `Idempotency-Key`, both declared on this route
+   */
+  async update(data, locale, options) {
+    const finalLocale = locale ?? this.localeValue;
+    return this.httpClient.fetchPayload(
+      "/v1/singletons/{key}",
+      "patch",
+      {
+        path: { key: this.singletonKey },
+        body: {
+          content: data,
+          ...finalLocale != null && finalLocale !== "" && { locale: finalLocale }
+        },
+        headers: writeHeaders(options)
+      }
+    );
+  }
+  /**
+   * Check if singleton exists
+   */
+  async exists() {
+    try {
+      const result = await this.fetch();
+      return result !== null;
+    } catch {
+      return false;
+    }
+  }
+  /**
+   * Get version history for one locale of the singleton.
+   *
+   * Versions are numbered per locale, so this is one locale's timeline: `locale` defaults to the
+   * schema default, no fallback is applied, and a locale with no history returns an empty array
+   * rather than another locale's rows. Every row names the locale it belongs to.
+   */
+  async versions(options) {
+    const payload = await this.httpClient.fetchPayload("/v1/singletons/{key}/versions", "get", {
+      path: { key: this.singletonKey },
+      query: {
+        limit: options?.limit ?? 10,
+        ...options?.locale === void 0 ? {} : { locale: options.locale }
+      }
+    });
+    return payload.versions;
+  }
+  /**
+   * Get a specific version of the singleton.
+   *
+   * `locale` defaults to the schema default. Version numbers are per locale, so version 2 is
+   * different content in each one.
+   */
+  async version(versionNumber, options) {
+    try {
+      return await this.httpClient.fetchPayload("/v1/singletons/{key}/versions/{versionNumber}", "get", {
+        path: { key: this.singletonKey, versionNumber: String(versionNumber) },
+        query: options?.locale === void 0 ? void 0 : { locale: options.locale }
+      });
+    } catch (error) {
+      if (isResourceNotFound(error)) return null;
+      throw error;
+    }
+  }
+  /**
+   * Get the singleton key
+   */
+  getSingletonKey() {
+    return this.singletonKey;
+  }
+  /**
+   * Reset fluent options for reuse
+   */
+  reset() {
+    this.includeFields = void 0;
+    this.localeValue = void 0;
+    return this;
+  }
+};
+__name(_SingletonClient, "SingletonClient");
+var SingletonClient = _SingletonClient;
+
+// src/content/settings-client.ts
+var _SettingsClient = class _SettingsClient {
+  constructor(httpClient, groupId) {
+    this.httpClient = httpClient;
+    this.groupId = groupId;
+    __publicField(this, "includeFields");
+    __publicField(this, "localeValue");
+  }
+  /**
+   * Include reference fields in the response
+   * @param fields - Reference field names to populate
+   */
+  include(fields) {
+    this.includeFields = fields;
+    return this;
+  }
+  /**
+   * Set locale for localized settings
+   * @param locale - Locale code (e.g., 'en', 'de', 'fr')
+   */
+  locale(locale) {
+    this.localeValue = locale;
+    return this;
+  }
+  /**
+   * Fetch the settings group
+   * @param options - Optional fetch options (alternative to fluent methods)
+   */
+  async fetch(options) {
+    const includeValue = options?.include ?? this.includeFields;
+    options?.locale ?? this.localeValue;
+    if (includeValue) {
+      includeValue.join(",");
+    }
+    try {
+      return (await this.fetchWithTag(options)).settings;
+    } catch (error) {
+      if (isResourceNotFound(error)) return null;
+      throw error;
+    }
+  }
+  /**
+   * Update settings group
+   * @param settings - The settings fields to update
+   * @param locale - Optional locale for localized settings (overrides fluent locale)
+   */
+  async update(settings, locale, options) {
+    const finalLocale = locale ?? this.localeValue;
+    const body = finalLocale != null && finalLocale !== "" ? { ...settings, locale: finalLocale } : settings;
+    return this.httpClient.fetchPayload(
+      "/v1/settings/{groupId}",
+      "patch",
+      { path: { groupId: this.groupId }, body, headers: writeHeaders(options) }
+    );
+  }
+  /**
+   * Fetch the group **and the entity tag that read served**, which is what
+   * `update`'s and `reset`'s `ifMatch` take
+   * (`INV-API-CONDITIONAL-WRITE-IS-REACHABLE`).
+   */
+  async fetchWithTag(options) {
+    const query = {};
+    const includeValue = options?.include ?? this.includeFields;
+    const localeValueFinal = options?.locale ?? this.localeValue;
+    if (includeValue) query.include = includeValue.join(",");
+    if (localeValueFinal != null && localeValueFinal !== "") query.locale = localeValueFinal;
+    const response = await this.httpClient.send(
+      "/v1/settings/{groupId}",
+      "get",
+      { path: { groupId: this.groupId }, query }
+    );
+    return { settings: readPayload(response.body), entityTag: entityTagOf(response) };
+  }
+  /**
+   * Reset settings to default values
+   * @param locale - Optional locale for localized settings
+   */
+  async reset(locale, options) {
+    const finalLocale = locale ?? this.localeValue;
+    return this.httpClient.fetchPayload(
+      "/v1/settings/{groupId}/reset",
+      "post",
+      {
+        path: { groupId: this.groupId },
+        body: finalLocale != null && finalLocale !== "" ? { locale: finalLocale } : void 0,
+        headers: writeHeaders(options)
+      }
+    );
+  }
+  /**
+   * Get default settings for this group
+   */
+  async getDefaults() {
+    return this.httpClient.fetchPayload(
+      "/v1/settings/{groupId}/defaults",
+      "get",
+      { path: { groupId: this.groupId } }
+    );
+  }
+  /**
+   * Check if settings group exists
+   */
+  async exists() {
+    try {
+      const result = await this.fetch();
+      return result !== null;
+    } catch (error) {
+      if (isResourceNotFound(error)) return false;
+      throw error;
+    }
+  }
+  /**
+   * Get version history for one locale of the settings group.
+   *
+   * Versions are numbered per locale, so this is one locale's timeline: `locale` defaults to the
+   * schema default, no fallback is applied, and a locale with no history returns an empty array
+   * rather than another locale's rows. Every row names the locale it belongs to.
+   */
+  async versions(options) {
+    const payload = await this.httpClient.fetchPayload("/v1/settings/{groupId}/versions", "get", {
+      path: { groupId: this.groupId },
+      query: {
+        limit: options?.limit ?? 10,
+        ...options?.locale === void 0 ? {} : { locale: options.locale }
+      }
+    });
+    return payload.versions;
+  }
+  /**
+   * Get a specific version of the settings.
+   *
+   * `locale` defaults to the schema default. Version numbers are per locale, so version 2 is
+   * different content in each one.
+   */
+  async version(versionNumber, options) {
+    try {
+      return await this.httpClient.fetchPayload("/v1/settings/{groupId}/versions/{versionNumber}", "get", {
+        path: { groupId: this.groupId, versionNumber: String(versionNumber) },
+        query: options?.locale === void 0 ? void 0 : { locale: options.locale }
+      });
+    } catch (error) {
+      if (isResourceNotFound(error)) return null;
+      throw error;
+    }
+  }
+  /**
+   * Get the settings group ID
+   */
+  getGroupId() {
+    return this.groupId;
+  }
+  /**
+   * Reset fluent options for reuse
+   */
+  resetOptions() {
+    this.includeFields = void 0;
+    this.localeValue = void 0;
+    return this;
+  }
+};
+__name(_SettingsClient, "SettingsClient");
+var SettingsClient = _SettingsClient;
+
+// src/search/search-client.ts
+var _SearchBuilder = class _SearchBuilder {
+  constructor(httpClient, query) {
+    this.httpClient = httpClient;
+    __publicField(this, "query");
+    __publicField(this, "searchOptions", {});
+    this.query = query;
+  }
+  /**
+   * Search within a single content type
+   * @param contentType - Content type to search in
+   */
+  in(contentType) {
+    this.searchOptions.contentType = contentType;
+    this.searchOptions.contentTypes = void 0;
+    return this;
+  }
+  /**
+   * Search across multiple content types
+   * @param contentTypes - Array of content types or '*' for all
+   */
+  across(contentTypes) {
+    this.searchOptions.contentTypes = contentTypes;
+    this.searchOptions.contentType = void 0;
+    return this;
+  }
+  /**
+   * Add filter conditions
+   * @param conditions - Filter conditions
+   */
+  where(conditions) {
+    this.searchOptions.where = {
+      ...this.searchOptions.where,
+      ...conditions
+    };
+    return this;
+  }
+  /**
+   * Specify which fields to search in
+   * @param fields - Field names to search
+   */
+  searchFields(fields) {
+    this.searchOptions.searchFields = fields;
+    return this;
+  }
+  /**
+   * Project specific fields in results
+   * @param projection - Field mapping
+   */
+  fields(projection) {
+    this.searchOptions.fields = projection;
+    return this;
+  }
+  /**
+   * Limit number of results
+   * @param count - Maximum results
+   */
+  limit(count) {
+    this.searchOptions.limit = count;
+    return this;
+  }
+  /**
+   * Skip results for pagination
+   * @param count - Number to skip
+   */
+  offset(count) {
+    this.searchOptions.offset = count;
+    return this;
+  }
+  /**
+   * Include relevance scores in results
+   */
+  includeScore() {
+    this.searchOptions.includeScore = true;
+    return this;
+  }
+  /**
+   * Include score breakdown explanation
+   */
+  explain() {
+    this.searchOptions.explain = true;
+    return this;
+  }
+  /**
+   * Set locale for localized content
+   * @param locale - Locale code
+   */
+  locale(locale) {
+    this.searchOptions.locale = locale;
+    return this;
+  }
+  /**
+   * Execute the search query
+   */
+  async execute() {
+    const body = {
+      q: this.query
+    };
+    if (this.searchOptions.contentType != null && this.searchOptions.contentType !== "") {
+      body.contentType = this.searchOptions.contentType;
+    }
+    if (this.searchOptions.contentTypes != null) {
+      body.contentTypes = this.searchOptions.contentTypes;
+    }
+    if (this.searchOptions.where && Object.keys(this.searchOptions.where).length > 0) {
+      body.where = this.searchOptions.where;
+    }
+    if (this.searchOptions.searchFields) {
+      body.searchFields = this.searchOptions.searchFields;
+    }
+    if (this.searchOptions.fields) {
+      body.fields = this.searchOptions.fields;
+    }
+    if (this.searchOptions.limit !== void 0) {
+      body.limit = this.searchOptions.limit;
+    }
+    if (this.searchOptions.offset !== void 0) {
+      body.offset = this.searchOptions.offset;
+    }
+    if (this.searchOptions.includeScore === true) {
+      body.includeScore = true;
+    }
+    if (this.searchOptions.explain === true) {
+      body.explain = true;
+    }
+    if (this.searchOptions.locale != null && this.searchOptions.locale !== "") {
+      body.locale = this.searchOptions.locale;
+    }
+    const response = await this.httpClient.send(
+      "/v1/search",
+      "post",
+      { body }
+    );
+    return response.body;
+  }
+  /**
+   * Execute and return just the items (convenience method)
+   */
+  async items() {
+    return readPayload(await this.execute());
+  }
+  /**
+   * Get the first result
+   */
+  async first() {
+    return readPayload(await this.limit(1).execute())[0] ?? null;
+  }
+};
+__name(_SearchBuilder, "SearchBuilder");
+var SearchBuilder = _SearchBuilder;
+var _AutocompleteBuilder = class _AutocompleteBuilder {
+  constructor(httpClient, query) {
+    this.httpClient = httpClient;
+    __publicField(this, "query");
+    __publicField(this, "autocompleteOptions", {});
+    this.query = query;
+  }
+  /**
+   * Autocomplete within a content type
+   * @param contentType - Content type to search
+   */
+  in(contentType) {
+    this.autocompleteOptions.contentType = contentType;
+    return this;
+  }
+  /**
+   * Field to autocomplete on
+   * @param fieldName - Field name (supports nested like 'category.name')
+   */
+  field(fieldName) {
+    this.autocompleteOptions.field = fieldName;
+    return this;
+  }
+  /**
+   * Enable fuzzy matching for typo tolerance
+   */
+  fuzzy() {
+    this.autocompleteOptions.fuzzy = true;
+    return this;
+  }
+  /**
+   * Add filter conditions
+   * @param conditions - Filter conditions
+   */
+  where(conditions) {
+    this.autocompleteOptions.where = {
+      ...this.autocompleteOptions.where,
+      ...conditions
+    };
+    return this;
+  }
+  /**
+   * Limit number of suggestions
+   * @param count - Maximum suggestions
+   */
+  limit(count) {
+    this.autocompleteOptions.limit = count;
+    return this;
+  }
+  /**
+   * Set locale for localized content
+   * @param locale - Locale code
+   */
+  locale(locale) {
+    this.autocompleteOptions.locale = locale;
+    return this;
+  }
+  /**
+   * Execute the autocomplete query
+   */
+  async execute() {
+    if (this.autocompleteOptions.contentType == null || this.autocompleteOptions.contentType === "") {
+      throw new Error('Content type is required for autocomplete. Use .in("contentType")');
+    }
+    if (this.autocompleteOptions.field == null || this.autocompleteOptions.field === "") {
+      throw new Error('Field is required for autocomplete. Use .field("fieldName")');
+    }
+    const body = {
+      q: this.query,
+      contentType: this.autocompleteOptions.contentType,
+      field: this.autocompleteOptions.field
+    };
+    if (this.autocompleteOptions.fuzzy === true) {
+      body.fuzzy = true;
+    }
+    if (this.autocompleteOptions.where && Object.keys(this.autocompleteOptions.where).length > 0) {
+      body.where = this.autocompleteOptions.where;
+    }
+    if (this.autocompleteOptions.limit !== void 0) {
+      body.limit = this.autocompleteOptions.limit;
+    }
+    if (this.autocompleteOptions.locale != null && this.autocompleteOptions.locale !== "") {
+      body.locale = this.autocompleteOptions.locale;
+    }
+    const response = await this.httpClient.send("/v1/search/autocomplete", "post", { body });
+    return response.body;
+  }
+  /**
+   * Get just the suggestion texts
+   */
+  async texts() {
+    return readPayload(await this.execute()).map((suggestion) => suggestion.text);
+  }
+};
+__name(_AutocompleteBuilder, "AutocompleteBuilder");
+var AutocompleteBuilder = _AutocompleteBuilder;
+var _SimilarBuilder = class _SimilarBuilder {
+  constructor(httpClient, sourceId) {
+    this.httpClient = httpClient;
+    __publicField(this, "sourceId");
+    __publicField(this, "similarOptions", {});
+    this.sourceId = sourceId;
+  }
+  /**
+   * Find similar content within a content type
+   * @param contentType - Content type to search
+   */
+  in(contentType) {
+    this.similarOptions.contentType = contentType;
+    return this;
+  }
+  /**
+   * Add filter conditions
+   * @param conditions - Filter conditions
+   */
+  where(conditions) {
+    this.similarOptions.where = {
+      ...this.similarOptions.where,
+      ...conditions
+    };
+    return this;
+  }
+  /**
+   * Limit number of results
+   * @param count - Maximum results
+   */
+  limit(count) {
+    this.similarOptions.limit = count;
+    return this;
+  }
+  /**
+   * Set locale for localized content
+   * @param locale - Locale code
+   */
+  locale(locale) {
+    this.similarOptions.locale = locale;
+    return this;
+  }
+  /**
+   * Execute the similar query
+   */
+  async execute() {
+    if (this.similarOptions.contentType == null || this.similarOptions.contentType === "") {
+      throw new Error('Content type is required for similar search. Use .in("contentType")');
+    }
+    const body = {
+      source: this.sourceId,
+      contentType: this.similarOptions.contentType
+    };
+    if (this.similarOptions.where && Object.keys(this.similarOptions.where).length > 0) {
+      body.where = this.similarOptions.where;
+    }
+    if (this.similarOptions.limit !== void 0) {
+      body.limit = this.similarOptions.limit;
+    }
+    if (this.similarOptions.locale != null && this.similarOptions.locale !== "") {
+      body.locale = this.similarOptions.locale;
+    }
+    const response = await this.httpClient.send(
+      "/v1/search/similar",
+      "post",
+      { body }
+    );
+    return response.body;
+  }
+  /**
+   * Get just the similar items
+   */
+  async items() {
+    return readPayload(await this.execute());
+  }
+  /**
+   * Get the most similar item
+   */
+  async first() {
+    return readPayload(await this.limit(1).execute())[0] ?? null;
+  }
+};
+__name(_SimilarBuilder, "SimilarBuilder");
+var SimilarBuilder = _SimilarBuilder;
+var _SearchClient = class _SearchClient {
+  constructor(httpClient) {
+    this.httpClient = httpClient;
+  }
+  /**
+   * Start a search query
+   * @param query - Search query string
+   */
+  search(query) {
+    return new SearchBuilder(this.httpClient, query);
+  }
+  /**
+   * Start an autocomplete query
+   * @param query - Partial query to autocomplete
+   */
+  autocomplete(query) {
+    return new AutocompleteBuilder(this.httpClient, query);
+  }
+  /**
+   * Find content similar to a given entry
+   * @param sourceId - Entry ID to find similar content for
+   */
+  similar(sourceId) {
+    return new SimilarBuilder(this.httpClient, sourceId);
+  }
+  /**
+   * Quick search helper - searches all content types
+   * @param query - Search query
+   * @param limit - Max results (default 20)
+   */
+  async global(query, limit = 20) {
+    return this.search(query).across("*").limit(limit).execute();
+  }
+};
+__name(_SearchClient, "SearchClient");
+var SearchClient = _SearchClient;
+
+// src/batch/batch-client.ts
+var _BatchBuilder = class _BatchBuilder {
+  constructor(httpClient) {
+    this.httpClient = httpClient;
+    __publicField(this, "operations", []);
+    __publicField(this, "defaultOptions", {
+      atomic: false,
+      dryRun: false,
+      returnData: true,
+      continueOnError: true
+    });
+  }
+  // ==========================================================================
+  // ENTRY OPERATIONS
+  // ==========================================================================
+  /**
+   * Add a create operation
+   * @param contentType - Content type to create
+   * @param data - Entry data with content field
+   * @param id - Optional operation ID for tracking
+   */
+  create(contentType, data, id) {
+    this.operations.push({
+      id,
+      method: "POST",
+      path: `/${contentType}`,
+      body: data
+    });
+    return this;
+  }
+  /**
+   * Add an update operation (partial update).
+   *
+   * The submitted fields are merged into the entry and the rest are left as they are. The merge is
+   * field-level rather than deep: sending an object-typed field replaces that field's whole value.
+   *
+   * @param contentType - Content type
+   * @param entryId - Entry ID to update
+   * @param data - Fields to update
+   * @param id - Optional operation ID for tracking
+   */
+  update(contentType, entryId, data, id) {
+    this.operations.push({
+      id,
+      method: "PATCH",
+      path: `/${contentType}/${entryId}`,
+      body: data
+    });
+    return this;
+  }
+  /**
+   * Add a replace operation (full replacement).
+   *
+   * The payload becomes the entry's content for the addressed locale: fields you do not send are
+   * cleared. Send the whole entry, or use {@link BatchClient.update} to change part of one.
+   *
+   * @param contentType - Content type
+   * @param entryId - Entry ID to replace
+   * @param data - Complete entry data
+   * @param id - Optional operation ID for tracking
+   */
+  replace(contentType, entryId, data, id) {
+    this.operations.push({
+      id,
+      method: "PUT",
+      path: `/${contentType}/${entryId}`,
+      body: data
+    });
+    return this;
+  }
+  /**
+   * Add a delete operation
+   * @param contentType - Content type
+   * @param entryId - Entry ID to delete
+   * @param id - Optional operation ID for tracking
+   */
+  delete(contentType, entryId, id) {
+    this.operations.push({
+      id,
+      method: "DELETE",
+      path: `/${contentType}/${entryId}`
+    });
+    return this;
+  }
+  // ==========================================================================
+  // SINGLETON OPERATIONS
+  // ==========================================================================
+  /**
+   * Add a singleton upsert operation
+   * @param singletonKey - Singleton key
+   * @param data - Singleton content
+   * @param id - Optional operation ID for tracking
+   */
+  upsertSingleton(singletonKey, data, id) {
+    this.operations.push({
+      id,
+      method: "PATCH",
+      path: `/_singletons/${singletonKey}`,
+      body: data
+    });
+    return this;
+  }
+  /**
+   * Add a singleton create operation (alias for upsert with POST)
+   * @param singletonKey - Singleton key
+   * @param data - Singleton content
+   * @param id - Optional operation ID for tracking
+   */
+  createSingleton(singletonKey, data, id) {
+    this.operations.push({
+      id,
+      method: "POST",
+      path: `/_singletons/${singletonKey}`,
+      body: data
+    });
+    return this;
+  }
+  // ==========================================================================
+  // RAW OPERATIONS
+  // ==========================================================================
+  /**
+   * Add a raw operation (for advanced use cases)
+   * @param operation - The operation to add
+   */
+  raw(operation) {
+    this.operations.push(operation);
+    return this;
+  }
+  /**
+   * Add multiple raw operations
+   * @param operations - Operations to add
+   */
+  rawMany(operations) {
+    this.operations.push(...operations);
+    return this;
+  }
+  // ==========================================================================
+  // BULK HELPERS
+  // ==========================================================================
+  /**
+   * Bulk create multiple entries of the same content type
+   * @param contentType - Content type
+   * @param items - Array of entry data
+   */
+  bulkCreate(contentType, items) {
+    for (const item of items) {
+      const { id, ...data } = item;
+      this.create(contentType, data, id);
+    }
+    return this;
+  }
+  /**
+   * Bulk update multiple entries
+   * @param contentType - Content type
+   * @param updates - Array of { entryId, data } pairs
+   */
+  bulkUpdate(contentType, updates) {
+    for (const update of updates) {
+      this.update(contentType, update.entryId, update.data, update.id);
+    }
+    return this;
+  }
+  /**
+   * Bulk delete multiple entries
+   * @param contentType - Content type
+   * @param entryIds - Entry IDs to delete
+   */
+  bulkDelete(contentType, entryIds) {
+    for (const entryId of entryIds) {
+      this.delete(contentType, entryId);
+    }
+    return this;
+  }
+  // ==========================================================================
+  // CONFIGURATION
+  // ==========================================================================
+  /**
+   * Configure default options for execution
+   * @param options - Batch options
+   */
+  configure(options) {
+    this.defaultOptions = { ...this.defaultOptions, ...options };
+    return this;
+  }
+  /**
+   * Enable atomic mode (all-or-nothing)
+   */
+  atomic() {
+    this.defaultOptions.atomic = true;
+    return this;
+  }
+  /**
+   * Enable dry-run mode (validate without executing)
+   */
+  dryRun() {
+    this.defaultOptions.dryRun = true;
+    return this;
+  }
+  /**
+   * Disable returning full data in response
+   */
+  noData() {
+    this.defaultOptions.returnData = false;
+    return this;
+  }
+  /**
+   * Stop on first error (non-atomic mode)
+   */
+  stopOnError() {
+    this.defaultOptions.continueOnError = false;
+    return this;
+  }
+  // ==========================================================================
+  // EXECUTION
+  // ==========================================================================
+  /**
+   * Get the current list of operations
+   */
+  getOperations() {
+    return [...this.operations];
+  }
+  /**
+   * Get the number of operations
+   */
+  size() {
+    return this.operations.length;
+  }
+  /**
+   * Clear all operations
+   */
+  clear() {
+    this.operations = [];
+    return this;
+  }
+  /**
+   * Clone the builder
+   */
+  clone() {
+    const cloned = new _BatchBuilder(this.httpClient);
+    cloned.operations = [...this.operations];
+    cloned.defaultOptions = { ...this.defaultOptions };
+    return cloned;
+  }
+  /**
+   * Execute the batch operations
+   * @param options - Override default options
+   */
+  async execute(options) {
+    if (this.operations.length === 0) {
+      throw new Error(
+        "No operations to execute. Add operations using .create(), .update(), .delete(), etc."
+      );
+    }
+    if (this.operations.length > 100) {
+      throw new Error("Maximum 100 operations per batch. Split into multiple batches.");
+    }
+    const finalOptions = { ...this.defaultOptions, ...options };
+    return this.httpClient.fetchPayload("/v1/batch", "post", {
+      body: { operations: this.operations, options: finalOptions }
+    });
+  }
+  /**
+   * Validate operations without executing (convenience for dry-run)
+   */
+  async validate() {
+    return this.execute({ dryRun: true });
+  }
+  /**
+   * Execute and throw if any operation failed
+   */
+  async executeOrThrow(options) {
+    const response = await this.execute(options);
+    if (response.summary.failed > 0) {
+      const failedOps = response.results.filter(
+        (result) => "error" in result
+      );
+      const errorMessages = failedOps.map(
+        (op) => `Operation ${op.index}${op.id != null && op.id !== "" ? ` (${op.id})` : ""}: ${op.error.code} \u2014 ${op.error.messages.join(" ")}`
+      ).join("; ");
+      throw new Error(
+        `Batch execution failed: ${response.summary.failed} of ${response.summary.total} operations failed. ${errorMessages}`
+      );
+    }
+    return response;
+  }
+};
+__name(_BatchBuilder, "BatchBuilder");
+var BatchBuilder = _BatchBuilder;
+var _BatchClient = class _BatchClient {
+  constructor(httpClient) {
+    this.httpClient = httpClient;
+  }
+  /**
+   * Create a new batch builder
+   */
+  create() {
+    return new BatchBuilder(this.httpClient);
+  }
+  /**
+   * Quick bulk create entries
+   * @param contentType - Content type
+   * @param items - Array of entry data
+   * @param options - Batch options
+   */
+  async bulkCreate(contentType, items, options) {
+    return this.create().bulkCreate(contentType, items).execute(options);
+  }
+  /**
+   * Quick bulk update entries
+   * @param contentType - Content type
+   * @param updates - Array of updates
+   * @param options - Batch options
+   */
+  async bulkUpdate(contentType, updates, options) {
+    return this.create().bulkUpdate(contentType, updates).execute(options);
+  }
+  /**
+   * Quick bulk delete entries
+   * @param contentType - Content type
+   * @param entryIds - Entry IDs to delete
+   * @param options - Batch options
+   */
+  async bulkDelete(contentType, entryIds, options) {
+    return this.create().bulkDelete(contentType, entryIds).execute(options);
+  }
+  /**
+   * Execute raw batch operations
+   * @param operations - Array of operations
+   * @param options - Batch options
+   */
+  async execute(operations, options) {
+    return this.create().rawMany(operations).execute(options);
+  }
+};
+__name(_BatchClient, "BatchClient");
+var BatchClient = _BatchClient;
+
+// src/queries/adhoc-query-client.ts
+var _AdhocQueryBuilder = class _AdhocQueryBuilder {
+  constructor(httpClient) {
+    this.httpClient = httpClient;
+    __publicField(this, "queryDef", {});
+    __publicField(this, "parameters", {});
+    __publicField(this, "options", {});
+  }
+  // ==========================================================================
+  // QUERY BLOCKS
+  // ==========================================================================
+  /**
+   * Add a fetch block to retrieve content
+   * @param config - Fetch configuration
+   */
+  fetch(config) {
+    this.queryDef.fetch = config;
+    return this;
+  }
+  /**
+   * Fetch from a content type
+   * @param contentType - Content type to fetch
+   */
+  from(contentType) {
+    this.queryDef.fetch = { ...this.queryDef.fetch, contentType };
+    return this;
+  }
+  /**
+   * Fetch a singleton
+   * @param singletonKey - Singleton key
+   */
+  singleton(singletonKey) {
+    this.queryDef.fetch = { ...this.queryDef.fetch, singleton: singletonKey };
+    return this;
+  }
+  /**
+   * Add aggregate block
+   * @param config - Aggregate configuration
+   */
+  aggregate(config) {
+    this.queryDef.aggregate = config;
+    return this;
+  }
+  /**
+   * Add search block
+   * @param config - Search configuration
+   */
+  search(config) {
+    this.queryDef.search = config;
+    return this;
+  }
+  /**
+   * Add similar block
+   * @param config - Similar configuration
+   */
+  similar(config) {
+    this.queryDef.similar = config;
+    return this;
+  }
+  // ==========================================================================
+  // FETCH MODIFIERS
+  // ==========================================================================
+  /**
+   * Add where conditions to fetch
+   * @param conditions - Filter conditions
+   */
+  where(conditions) {
+    this.queryDef.fetch = {
+      ...this.queryDef.fetch,
+      where: { ...this.queryDef.fetch?.where, ...conditions }
+    };
+    return this;
+  }
+  /**
+   * Add include for reference population
+   * @param fields - Reference fields to include
+   */
+  include(fields) {
+    this.queryDef.fetch = {
+      ...this.queryDef.fetch,
+      include: fields
+    };
+    return this;
+  }
+  /**
+   * Add sort specification
+   * @param sort - Sort configuration
+   */
+  sort(sort) {
+    this.queryDef.fetch = {
+      ...this.queryDef.fetch,
+      sort: { ...this.queryDef.fetch?.sort, ...sort }
+    };
+    return this;
+  }
+  /**
+   * Sort by field ascending
+   * @param field - Field to sort by
+   */
+  sortAsc(field) {
+    return this.sort({ [field]: "asc" });
+  }
+  /**
+   * Sort by field descending
+   * @param field - Field to sort by
+   */
+  sortDesc(field) {
+    return this.sort({ [field]: "desc" });
+  }
+  /**
+   * Limit results
+   * @param count - Maximum results
+   */
+  limit(count) {
+    this.queryDef.fetch = {
+      ...this.queryDef.fetch,
+      limit: count
+    };
+    return this;
+  }
+  /**
+   * Skip results
+   * @param count - Number to skip
+   */
+  offset(count) {
+    this.queryDef.fetch = {
+      ...this.queryDef.fetch,
+      offset: count
+    };
+    return this;
+  }
+  // ==========================================================================
+  // PROJECTIONS & FILTERS
+  // ==========================================================================
+  /**
+   * Select and transform fields in output
+   * @param projection - Field mapping (outputField: sourceField)
+   */
+  select(projection) {
+    this.queryDef.select = { ...this.queryDef.select, ...projection };
+    return this;
+  }
+  /**
+   * Add a post-fetch filter (supports ${param} syntax)
+   * @param field - Field path to filter
+   * @param condition - Filter condition
+   */
+  filter(field, condition) {
+    this.queryDef.filters = { ...this.queryDef.filters, [field]: condition };
+    return this;
+  }
+  /**
+   * Add full-text search
+   * @param config - Full-text configuration
+   */
+  fullText(config) {
+    this.queryDef.fullText = config;
+    return this;
+  }
+  // ==========================================================================
+  // PARAMETERS
+  // ==========================================================================
+  /**
+   * Set query parameters
+   * @param params - Parameter values
+   */
+  params(params) {
+    this.parameters = { ...this.parameters, ...params };
+    return this;
+  }
+  /**
+   * Set a single parameter
+   * @param name - Parameter name
+   * @param value - Parameter value
+   */
+  param(name, value) {
+    this.parameters[name] = value;
+    return this;
+  }
+  // ==========================================================================
+  // OPTIONS
+  // ==========================================================================
+  /**
+   * Enable debug mode
+   */
+  debug() {
+    this.options.debug = true;
+    return this;
+  }
+  /**
+   * Skip cache for this request
+   */
+  skipCache() {
+    this.options.skipCache = true;
+    return this;
+  }
+  /**
+   * Set custom timeout
+   * @param ms - Timeout in milliseconds (1000-60000)
+   */
+  timeout(ms) {
+    if (ms < 1e3 || ms > 6e4) {
+      throw new Error("Timeout must be between 1000 and 60000 milliseconds");
+    }
+    this.options.timeout = ms;
+    return this;
+  }
+  /**
+   * Set cache policy
+   * @param ttl - Cache TTL in seconds
+   * @param strategy - Cache strategy
+   */
+  cache(ttl, strategy) {
+    this.queryDef.cache = { ttl, strategy };
+    return this;
+  }
+  // ==========================================================================
+  // EXECUTION
+  // ==========================================================================
+  /**
+   * Get the query definition (for debugging)
+   */
+  getDefinition() {
+    return { ...this.queryDef };
+  }
+  /**
+   * Get the parameters (for debugging)
+   */
+  getParameters() {
+    return { ...this.parameters };
+  }
+  /**
+   * Execute the query
+   */
+  async execute() {
+    if (!this.queryDef.fetch && !this.queryDef.aggregate && !this.queryDef.search && !this.queryDef.similar) {
+      throw new Error(
+        "Query must have at least one of: fetch, aggregate, search, or similar. Use .from(), .aggregate(), .search(), or .similar()"
+      );
+    }
+    const body = {
+      query: this.queryDef
+    };
+    if (Object.keys(this.parameters).length > 0) {
+      body.parameters = this.parameters;
+    }
+    if (Object.keys(this.options).length > 0) {
+      body.options = this.options;
+    }
+    return this.httpClient.fetchPayload(
+      "/v1/query",
+      "post",
+      { body }
+    );
+  }
+  /**
+   * Execute and return the records as an array (for list queries).
+   */
+  async items() {
+    const { result } = await this.execute();
+    if (result === void 0) return [];
+    return Array.isArray(result) ? result : [result];
+  }
+  /**
+   * Execute and return the single record (for singleton queries).
+   */
+  async data() {
+    const { result } = await this.execute();
+    if (Array.isArray(result)) return result[0];
+    return result;
+  }
+  /**
+   * Clone the builder
+   */
+  clone() {
+    const cloned = new _AdhocQueryBuilder(this.httpClient);
+    cloned.queryDef = JSON.parse(JSON.stringify(this.queryDef));
+    cloned.parameters = { ...this.parameters };
+    cloned.options = { ...this.options };
+    return cloned;
+  }
+};
+__name(_AdhocQueryBuilder, "AdhocQueryBuilder");
+var AdhocQueryBuilder = _AdhocQueryBuilder;
+var _AdhocQueryClient = class _AdhocQueryClient {
+  constructor(httpClient) {
+    this.httpClient = httpClient;
+  }
+  /**
+   * Create a new query builder
+   */
+  build() {
+    return new AdhocQueryBuilder(this.httpClient);
+  }
+  /**
+   * Execute a query definition directly
+   * @param definition - Query definition
+   * @param parameters - Parameter values
+   * @param options - Execution options
+   */
+  async execute(definition, parameters, options) {
+    const body = {
+      query: definition
+    };
+    if (parameters && Object.keys(parameters).length > 0) {
+      body.parameters = parameters;
+    }
+    if (options && Object.keys(options).length > 0) {
+      body.options = options;
+    }
+    return this.httpClient.fetchPayload(
+      "/v1/query",
+      "post",
+      { body }
+    );
+  }
+  /**
+   * Quick fetch helper
+   * @param contentType - Content type
+   * @param options - Fetch options
+   */
+  async fetch(contentType, options) {
+    const { result } = await this.execute({ fetch: { contentType, ...options } });
+    if (result === void 0) return [];
+    return Array.isArray(result) ? result : [result];
+  }
+  /**
+   * Quick singleton fetch helper
+   * @param singletonKey - Singleton key
+   */
+  async fetchSingleton(singletonKey) {
+    const { result } = await this.execute({ fetch: { singleton: singletonKey } });
+    if (Array.isArray(result)) return result[0];
+    return result;
+  }
+  /**
+   * Quick aggregate helper
+   * @param source - Source content type
+   * @param metrics - Metrics to compute
+   * @param groupBy - Optional grouping field
+   */
+  async aggregate(source, metrics, groupBy) {
+    const { result } = await this.execute({ aggregate: { source, metrics, by: groupBy } });
+    if (result === void 0) return [];
+    return Array.isArray(result) ? result : [result];
+  }
+};
+__name(_AdhocQueryClient, "AdhocQueryClient");
+var AdhocQueryClient = _AdhocQueryClient;
+
+// src/config/dev-detection.ts
+function getProcess() {
+  return typeof process !== "undefined" ? process : void 0;
+}
+__name(getProcess, "getProcess");
+function getBuiltin(proc, id) {
+  if (proc == null || typeof proc.getBuiltinModule !== "function") return null;
+  try {
+    return proc.getBuiltinModule(id);
+  } catch {
+    return null;
+  }
+}
+__name(getBuiltin, "getBuiltin");
+function isProduction(proc) {
+  return proc?.env?.NODE_ENV === "production";
+}
+__name(isProduction, "isProduction");
+function resolveFromEnv(proc) {
+  const dataset = proc?.env?.RELYIO_DEV_DATASET;
+  const apiKey = proc?.env?.RELYIO_DEV_API_KEY;
+  if (dataset != null && dataset !== "" && apiKey != null && apiKey !== "") {
+    return { dataset, apiKey, source: "env" };
+  }
+  return null;
+}
+__name(resolveFromEnv, "resolveFromEnv");
+function resolveFromFile(proc) {
+  if (proc == null || typeof proc.cwd !== "function") return null;
+  const fs = getBuiltin(proc, "node:fs");
+  const path = getBuiltin(proc, "node:path");
+  if (fs == null || path == null) return null;
+  let dir = proc.cwd();
+  for (; ; ) {
+    const candidate = path.join(dir, ".relyio", "dev.json");
+    try {
+      if (fs.existsSync(candidate)) {
+        const parsed = JSON.parse(fs.readFileSync(candidate, "utf8"));
+        if (parsed.datasetId != null && parsed.datasetId !== "" && parsed.previewApiKey != null && parsed.previewApiKey !== "") {
+          if (parsed.expiresAt != null && Number.isFinite(new Date(parsed.expiresAt).getTime()) && new Date(parsed.expiresAt).getTime() < Date.now()) {
+            return null;
+          }
+          return { dataset: parsed.datasetId, apiKey: parsed.previewApiKey, source: "file" };
+        }
+      }
+    } catch {
+    }
+    const parent = path.dirname(dir);
+    if (parent === dir) break;
+    dir = parent;
+  }
+  return null;
+}
+__name(resolveFromFile, "resolveFromFile");
+function resolveDevOverride(dev) {
+  if (dev === false) return null;
+  const proc = getProcess();
+  if (dev !== true && isProduction(proc)) return null;
+  return resolveFromEnv(proc) ?? resolveFromFile(proc);
+}
+__name(resolveDevOverride, "resolveDevOverride");
+
+// src/config/types.ts
+var DEFAULT_CONFIG = {
+  baseUrl: "https://api.relyio.com",
+  timeout: 3e4,
+  retryAttempts: 3,
+  useSsl: true,
+  environment: "production",
+  headers: {},
+  browser: {
+    includeCredentials: true,
+    useRelativeUrls: false
+  },
+  cache: {
+    enabled: true,
+    ttl: 5 * 60 * 1e3,
+    // 5 minutes
+    maxEntries: 1e3,
+    maxSize: 50 * 1024 * 1024,
+    // 50MB
+    strategies: ["memory", "stale-while-revalidate"]
+  },
+  realtime: {
+    enabled: true,
+    maxReconnectAttempts: 10,
+    reconnectDelay: 1e3,
+    heartbeatInterval: 3e4
+  },
+  debug: {
+    enabled: false,
+    logRequests: false,
+    logCache: false,
+    logWebSocket: false
+  }
+};
+function validateConfig(config) {
+  if (!config.apiKey || config.apiKey.length === 0) {
+    throw new Error("API key is required");
+  }
+  if (typeof config.apiKey !== "string") {
+    throw new Error("API key must be a string");
+  }
+  if (config.baseUrl != null && typeof config.baseUrl !== "string") {
+    throw new Error("Base URL must be a string");
+  }
+  if (config.timeout != null && (typeof config.timeout !== "number" || config.timeout < 0)) {
+    throw new Error("Timeout must be a positive number");
+  }
+  if (config.retryAttempts != null && (typeof config.retryAttempts !== "number" || config.retryAttempts < 0)) {
+    throw new Error("Retry attempts must be a positive number");
+  }
+}
+__name(validateConfig, "validateConfig");
+var devOverrideNotified = false;
+function mergeConfig(userConfig) {
+  validateConfig(userConfig);
+  const merged = {
+    ...DEFAULT_CONFIG,
+    ...userConfig,
+    headers: {
+      ...DEFAULT_CONFIG.headers,
+      ...userConfig.headers
+    },
+    browser: {
+      ...DEFAULT_CONFIG.browser,
+      ...userConfig.browser
+    },
+    cache: {
+      ...DEFAULT_CONFIG.cache,
+      ...userConfig.cache
+    },
+    realtime: {
+      ...DEFAULT_CONFIG.realtime,
+      ...userConfig.realtime
+    },
+    debug: {
+      ...DEFAULT_CONFIG.debug,
+      ...userConfig.debug
+    }
+  };
+  const devOverride = resolveDevOverride(userConfig.dev);
+  if (devOverride != null) {
+    merged.apiKey = devOverride.apiKey;
+    merged.dataset = devOverride.dataset;
+    if (!devOverrideNotified) {
+      devOverrideNotified = true;
+      console.info(
+        `[RelyIO] Sandbox dev mode active (${devOverride.source}) \u2014 targeting dataset "${devOverride.dataset}" with a scoped preview key.`
+      );
+    }
+  }
+  return merged;
+}
+__name(mergeConfig, "mergeConfig");
+
+// src/client/create-client.ts
+var API_VERSION_SEGMENT = "v1";
+var _TypedRelyIOClient = class _TypedRelyIOClient {
+  constructor(config) {
+    __publicField(this, "httpClient");
+    __publicField(this, "config");
+    __publicField(this, "_search");
+    __publicField(this, "_batch");
+    __publicField(this, "_adhocQuery");
+    __publicField(this, "_schema");
+    const { schema, ...clientConfig } = config;
+    this._schema = schema;
+    this.config = mergeConfig(clientConfig);
+    this.httpClient = new HttpClient(this.config);
+    this._search = new SearchClient(this.httpClient);
+    this._batch = new BatchClient(this.httpClient);
+    this._adhocQuery = new AdhocQueryClient(this.httpClient);
+  }
+  // ============================================================================
+  // CORE CLIENTS
+  // ============================================================================
+  /**
+   * Get the schema definition
+   */
+  get schema() {
+    return this._schema;
+  }
+  /**
+   * Get the ad-hoc query client
+   */
+  get query() {
+    return this._adhocQuery;
+  }
+  // ============================================================================
+  // CONTENT OPERATIONS
+  // ============================================================================
+  /**
+   * Get a content client for a specific content type
+   * Type-safe when schema is provided: autocompletes content type names AND field names
+   *
+   * @example
+   * ```typescript
+   * const products = await relyio.content('product')
+   *   .query()
+   *   .where({ status: 'active' })  // ← Field names autocomplete with schema!
+   *   .locale('en-US')
+   *   .limit(20)
+   *   .execute()
+   * ```
+   */
+  content(contentType) {
+    return new ContentClient(this.httpClient, contentType, this.config.locale);
+  }
+  /**
+   * Get an asset client for a specific asset type.
+   *
+   * Mirrors `content()` but targets `entryType: 'asset'` entries on the same
+   * dynamic `/{assetTypeId}` routes, and adds the `file(entryUid)` sub-resource
+   * builder + a high-level `upload()` helper. Type-safe when a schema is
+   * provided: autocompletes asset type names AND metadata field names.
+   *
+   * @example
+   * ```typescript
+   * const photo = await relyio.asset('productPhoto').upload(file)
+   *   .filename('shoe.jpg')
+   *   .visibility('public')
+   *   .execute()
+   *
+   * const heroUrl = await relyio.asset('productPhoto').file(photo._metadata.id).url({ variantId: 'hero' })
+   * ```
+   */
+  asset(assetType) {
+    return new AssetClient(this.httpClient, assetType, this.config.locale);
+  }
+  /**
+   * Get a singleton client for a specific singleton key
+   * Type-safe when schema is provided: autocompletes singleton names AND field names
+   *
+   * @example
+   * ```typescript
+   * const homepage = await relyio.singleton('homepage')
+   *   .include(['featuredProducts'])
+   *   .locale('en')
+   *   .fetch()
+   * ```
+   */
+  singleton(key) {
+    return new SingletonClient(this.httpClient, key);
+  }
+  /**
+   * Get a settings client for a specific settings group
+   * Type-safe when schema is provided: autocompletes settings group names AND field names
+   *
+   * @example
+   * ```typescript
+   * const emailConfig = await relyio.settings('email-config')
+   *   .include(['defaultTemplate'])
+   *   .fetch()
+   * ```
+   */
+  settings(groupId) {
+    return new SettingsClient(this.httpClient, groupId);
+  }
+  // ============================================================================
+  // SEARCH OPERATIONS
+  // ============================================================================
+  /**
+   * Start a search query with full-text, semantic, or hybrid search
+   *
+   * @example
+   * ```typescript
+   * const results = await relyio.search('wireless headphones')
+   *   .in('product')
+   *   .where({ status: 'active' })
+   *   .limit(20)
+   *   .includeScore()
+   *   .execute()
+   * ```
+   */
+  search(query) {
+    return this._search.search(query);
+  }
+  /**
+   * Start an autocomplete query for search suggestions
+   *
+   * @example
+   * ```typescript
+   * const suggestions = await relyio.autocomplete('wire')
+   *   .in('product')
+   *   .field('title')
+   *   .fuzzy()
+   *   .limit(10)
+   *   .execute()
+   * ```
+   */
+  autocomplete(query) {
+    return this._search.autocomplete(query);
+  }
+  /**
+   * Find content similar to a given entry using vector search
+   *
+   * @example
+   * ```typescript
+   * const similar = await relyio.similar('entry_abc123')
+   *   .in('product')
+   *   .locale('fr-FR')
+   *   .limit(5)
+   *   .execute()
+   * ```
+   */
+  similar(sourceId) {
+    return this._search.similar(sourceId);
+  }
+  // ============================================================================
+  // BATCH OPERATIONS
+  // ============================================================================
+  /**
+   * Start a batch operation for bulk create/update/delete
+   *
+   * @example
+   * ```typescript
+   * const result = await relyio.batch()
+   *   .create('product', { content: { title: 'iPhone', price: 999 } })
+   *   .update('product', 'entry_abc', { content: { price: 899 } })
+   *   .delete('product', 'entry_xyz')
+   *   .upsertSingleton('homepage', { content: { hero: 'Welcome!' } })
+   *   .execute({ atomic: true })
+   *
+   * console.log(result.summary.succeeded)
+   * ```
+   */
+  batch() {
+    return this._batch.create();
+  }
+  // ============================================================================
+  // QUERY OPERATIONS
+  // ============================================================================
+  /**
+   * Build and execute an ad-hoc query dynamically
+   *
+   * @example
+   * ```typescript
+   * const result = await relyio.adhoc()
+   *   .from('product')
+   *   .where({ status: 'active' })
+   *   .include(['brand', 'categories'])
+   *   .select({
+   *     id: 'id',
+   *     title: 'title',
+   *     price: 'pricing.basePrice'
+   *   })
+   *   .limit(20)
+   *   .execute()
+   * ```
+   */
+  adhoc() {
+    return this._adhocQuery.build();
+  }
+  /**
+   * Execute a predefined query by name (from schema)
+   * Type-safe when schema is provided: autocompletes query names
+   *
+   * @example
+   * ```typescript
+   * const featured = await relyio.executeQuery('featured-products', {
+   *   limit: 10,
+   *   category: 'electronics'
+   * })
+   * ```
+   */
+  async executeQuery(queryName, params) {
+    const response = await this.httpClient.request({
+      method: "GET",
+      url: `/${API_VERSION_SEGMENT}/${String(queryName)}`,
+      params: params ?? {}
+    });
+    const payload = readPayload(response.body);
+    return Array.isArray(payload) ? payload : [payload];
+  }
+  /**
+   * Get schema information from the API
+   */
+  async getSchemaInfo(contentType) {
+    return contentType == null ? this.httpClient.fetchPayload("/v1/meta/schema", "get", {}) : this.httpClient.fetchPayload("/v1/meta/schema/{contentType}", "get", {
+      path: { contentType }
+    });
+  }
+  /**
+   * List all content types from the API
+   */
+  async listContentTypes() {
+    return this.httpClient.fetchPayload("/v1/meta/content-types", "get", {});
+  }
+  /**
+   * Get API health status
+   */
+  async health() {
+    return this.httpClient.fetchPayload("/health", "get", {});
+  }
+  /**
+   * Check if the API is ready
+   */
+  async ready() {
+    try {
+      const payload = await this.httpClient.fetchPayload("/health/ready", "get", {});
+      return payload.status === "ok";
+    } catch {
+      return false;
+    }
+  }
+  /**
+   * Test the connection to the API
+   */
+  async testConnection() {
+    try {
+      await this.health();
+      return true;
+    } catch {
+      return false;
+    }
+  }
+  /**
+   * Update the configuration and reinitialize all clients
+   */
+  updateConfig(newConfig) {
+    this.config = mergeConfig({ ...this.config, ...newConfig });
+    this.httpClient = new HttpClient(this.config);
+    this._search = new SearchClient(this.httpClient);
+    this._batch = new BatchClient(this.httpClient);
+    this._adhocQuery = new AdhocQueryClient(this.httpClient);
+  }
+  /**
+   * Get the current configuration
+   */
+  getConfig() {
+    return { ...this.config };
+  }
+  /**
+   * Set the API key
+   */
+  setApiKey(apiKey) {
+    this.config.apiKey = apiKey;
+    this.httpClient.setAuthToken(apiKey);
+  }
+  /**
+   * Get the HTTP client instance (for advanced usage)
+   */
+  getHttpClient() {
+    return this.httpClient;
+  }
+  // ============================================================================
+  // LOCALE OPERATIONS
+  // ============================================================================
+  /**
+   * Create a locale-scoped client
+   * All content operations on the returned client will use the specified locale
+   *
+   * Type-safe when schema is provided: autocompletes valid locale codes!
+   *
+   * @example
+   * ```typescript
+   * const spanish = relyio.withLocale('es-ES')  // ← Autocompletes with schema!
+   *
+   * // All operations use Spanish
+   * const products = await spanish.content('product').query().execute()
+   * const homepage = await spanish.singleton('homepage').fetch()
+   *
+   * // Original client unchanged
+   * const englishProducts = await relyio.content('product').query().execute()
+   * ```
+   */
+  withLocale(locale) {
+    const newConfig = {
+      ...this.getConfig(),
+      locale,
+      schema: this._schema
+    };
+    return new _TypedRelyIOClient(newConfig);
+  }
+  /**
+   * Get the current default locale
+   */
+  getLocale() {
+    return this.config.locale;
+  }
+  /**
+   * Get available locales from the API
+   *
+   * @example
+   * ```typescript
+   * const { locales, defaultLocale } = await relyio.getLocales()
+   *
+   * // Build language switcher
+   * const options = locales.map(l => ({
+   *   code: l.code,
+   *   label: l.displayName,
+   *   isDefault: l.default,
+   * }))
+   * ```
+   */
+  async getLocales(search) {
+    const params = {};
+    if (search !== void 0 && search !== "") {
+      params.search = search;
+    }
+    return this.httpClient.fetchPayload("/v1/meta/locales", "get", { query: params });
+  }
+  /**
+   * Get the default locale from the API
+   */
+  async getDefaultLocale() {
+    const { defaultLocale } = await this.getLocales();
+    return defaultLocale;
+  }
+};
+__name(_TypedRelyIOClient, "TypedRelyIOClient");
+var TypedRelyIOClient = _TypedRelyIOClient;
+function createClient(config) {
+  return new TypedRelyIOClient(config);
+}
+__name(createClient, "createClient");
+
+export { AdhocQueryBuilder, AdhocQueryClient, AssetClient, AssetFileBuilder, AssetUploadBuilder, AuthenticationError, AuthorizationError, AutocompleteBuilder, BaseValidationError, BatchBuilder, BatchClient, ConnectionError, ContentByIdBuilder, ContentClient, ContentQueryBuilder, ErrorMapper, FileUploadError, FileValidationError, HttpClient, InvalidApiKeyError, InvalidFieldTypeError, InvalidPayloadError, MethodNotAllowedError, MissingApiKeyError, NetworkError, PayloadTooLargeError, PlanFeatureUnavailableError, RateLimitError, ReadOnlyKeyError, RequiredFieldError, ResourceConflictError, ResourceExpiredError, ResourceNotFoundError, SDKError, SchemaValidationError, SearchBuilder, SearchClient, ServerError, ServiceIndeterminateError, SettingsClient, SimilarBuilder, SingletonClient, TimeoutError, TransactionRolledBackError, TypedRelyIOClient, UnknownContractError, UsageQuotaExceededError, ValidationError, createClient, entityTagOf, isAssetEntry, isResourceNotFound, validateFile };
+//# sourceMappingURL=chunk-RJBIJ2ZK.js.map
+//# sourceMappingURL=chunk-RJBIJ2ZK.js.map