@relyio/sdk 0.16.0 → 0.18.0

package/dist/{chunk-NIUOPIIB.js → chunk-ZHTJ7GXH.js}

@@ -1,7 +1,8 @@
-import { parseDevEnv, DEV_CONTEXT_DIR, DEV_CONTEXT_FILENAME, parseDevContextFile } from './chunk-BBUB7C2Z.js';
-import { VISITOR_CLOSE_CODES, HEADER_RETRY_AFTER, HEADER_IDEMPOTENCY_KEY, UNKNOWN_PREVIEW_RECHECK_MS, entityTag, HEADER_IF_MATCH, FRESH_PARAMETER, VISITOR_KEEPALIVE, parseVisitorFrame, VISITOR_FRAMES, VISITOR_POLL_INTERVAL_MS, VISITOR_CLOSE_RETRY, readVisitorPollAnswer, VISITOR_POLL_RETRY, VISITOR_LIVE_PATH, VISITOR_QUERY, previewAtRequest, previewDatasetSlug } from './chunk-CQHEG7QA.js';
-import { isBrowser } from './chunk-H6IBQSMM.js';
-import { __name, __publicField } from './chunk-XQ4QHWZE.js';
+import { isBrowser } from './chunk-NJQK5STK.js';
+import { parseDevEnv, DEV_CONTEXT_DIR, DEV_CONTEXT_FILENAME, parseDevContextFile } from './chunk-W2A4OTCI.js';
+import { UNKNOWN_PREVIEW_RECHECK_MS, previewAtRequest } from './chunk-HDHBYYEY.js';
+import { VISITOR_CLOSE_CODES, HEADER_RETRY_AFTER, HEADER_IDEMPOTENCY_KEY, entityTag, HEADER_IF_MATCH, FRESH_PARAMETER, VISITOR_KEEPALIVE, parseVisitorFrame, VISITOR_FRAMES, VISITOR_POLL_INTERVAL_MS, VISITOR_CLOSE_RETRY, readVisitorPollAnswer, VISITOR_POLL_RETRY, VISITOR_LIVE_PATH, VISITOR_QUERY, previewDatasetSlug } from './chunk-EDE2H37D.js';
+import { __name, __publicField } from './chunk-DI6KFDBO.js';
 
 /* RelyIO SDK - Built with ❤️ by the RelyIO Team */
 
@@ -167,6 +168,70 @@ var _ReadOnlyKeyError = class _ReadOnlyKeyError extends SDKError {
 };
 __name(_ReadOnlyKeyError, "ReadOnlyKeyError");
 var ReadOnlyKeyError = _ReadOnlyKeyError;
+var _PublishableKeyRefusedError = class _PublishableKeyRefusedError extends SDKError {
+  constructor(message = "A publishable key cannot read or write Records or run Functions", context) {
+    super(message, 403, void 0, context);
+    __publicField(this, "code", "PUBLISHABLE_KEY_REFUSED");
+    __publicField(this, "retryable", false);
+  }
+  getUserMessage() {
+    return "A publishable key cannot reach Records or Functions. Call them from your server with a secret key.";
+  }
+};
+__name(_PublishableKeyRefusedError, "PublishableKeyRefusedError");
+var PublishableKeyRefusedError = _PublishableKeyRefusedError;
+var _FunctionRunFailedError = class _FunctionRunFailedError extends SDKError {
+  constructor(message = "The Function ended without an answer", run = {}, context) {
+    super(message, 500, void 0, context);
+    __publicField(this, "code", "FUNCTION_RUN_FAILED");
+    __publicField(this, "retryable", false);
+    __publicField(this, "runId");
+    __publicField(this, "failure");
+    __publicField(this, "runError");
+    this.runId = run.runId;
+    this.failure = run.failure;
+    this.runError = run.runError;
+  }
+  getUserMessage() {
+    return this.runId === void 0 ? "The Function ended without an answer." : `The Function ended without an answer; its run is ${this.runId}.`;
+  }
+};
+__name(_FunctionRunFailedError, "FunctionRunFailedError");
+var FunctionRunFailedError = _FunctionRunFailedError;
+var _FunctionContainersBusyError = class _FunctionContainersBusyError extends SDKError {
+  constructor(message = "The project is running as many Containers as its plan includes", name, context, retryAfterMs) {
+    super(message, 429, void 0, context);
+    __publicField(this, "code", "FUNCTION_CONTAINERS_BUSY");
+    __publicField(this, "retryable", false);
+    /** The Function that was not started. */
+    __publicField(this, "function");
+    /** `Retry-After`, in milliseconds, where the response carried a readable one. */
+    __publicField(this, "retryAfterMs");
+    this.function = name;
+    this.retryAfterMs = retryAfterMs;
+  }
+  getUserMessage() {
+    return "Every Container this project may run at once is busy. Call again shortly.";
+  }
+};
+__name(_FunctionContainersBusyError, "FunctionContainersBusyError");
+var FunctionContainersBusyError = _FunctionContainersBusyError;
+var _FunctionRunTimedOutError = class _FunctionRunTimedOutError extends SDKError {
+  constructor(message = "The Function had not answered within the wait", run = {}, context) {
+    super(message, 504, void 0, context);
+    __publicField(this, "code", "FUNCTION_RUN_TIMED_OUT");
+    __publicField(this, "retryable", false);
+    __publicField(this, "runId");
+    __publicField(this, "waitedMs");
+    this.runId = run.runId;
+    this.waitedMs = run.waitedMs;
+  }
+  getUserMessage() {
+    return this.runId === void 0 ? "The Function had not answered within the wait; it runs on." : `The Function had not answered within the wait; run ${this.runId} runs on.`;
+  }
+};
+__name(_FunctionRunTimedOutError, "FunctionRunTimedOutError");
+var FunctionRunTimedOutError = _FunctionRunTimedOutError;
 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);
@@ -534,6 +599,9 @@ var _ErrorMapper = class _ErrorMapper {
       case "READ_ONLY_KEY": {
         return new ReadOnlyKeyError(message, context);
       }
+      case "PUBLISHABLE_KEY_REFUSED": {
+        return new PublishableKeyRefusedError(message, context);
+      }
       case "PLAN_FEATURE_UNAVAILABLE": {
         return new PlanFeatureUnavailableError(message, detailString(refusal, "feature"), context);
       }
@@ -577,7 +645,8 @@ var _ErrorMapper = class _ErrorMapper {
         return new ResourceConflictError(guidance, 409, void 0, {
           ...context,
           // What stands in the way, as a declared kind a program switches on: `draft-exists`,
-          // `release-locked` or `slug-taken` from the Content API (REL-2446).
+          // `release-locked`, `slug-taken` or `value-taken` from the Content API (REL-2446,
+          // REL-3767).
           blockage,
           expectedVersion,
           actualVersion: detailNumber(refusal, "actualVersion"),
@@ -614,6 +683,32 @@ var _ErrorMapper = class _ErrorMapper {
           retryAfterMs
         );
       }
+      case "FUNCTION_RUN_FAILED": {
+        return new FunctionRunFailedError(
+          message,
+          {
+            runId: detailString(refusal, "runId"),
+            failure: detailString(refusal, "failure"),
+            runError: runErrorOf(refusal)
+          },
+          context
+        );
+      }
+      case "FUNCTION_RUN_TIMED_OUT": {
+        return new FunctionRunTimedOutError(
+          message,
+          { runId: detailString(refusal, "runId"), waitedMs: detailNumber(refusal, "waitedMs") },
+          context
+        );
+      }
+      case "FUNCTION_CONTAINERS_BUSY": {
+        return new FunctionContainersBusyError(
+          message,
+          detailString(refusal, "function"),
+          context,
+          retryAfterMs
+        );
+      }
       case "INTERNAL_ERROR": {
         return new ServerError(message, status, context);
       }
@@ -678,6 +773,13 @@ function detailNumber(refusal, key) {
   return typeof value === "number" ? value : void 0;
 }
 __name(detailNumber, "detailNumber");
+function runErrorOf(refusal) {
+  const error = detailBag(refusal)?.error;
+  if (typeof error !== "object" || error === null) return void 0;
+  const { name, message } = error;
+  return typeof name === "string" && typeof message === "string" ? { name, message } : void 0;
+}
+__name(runErrorOf, "runErrorOf");
 function blockageOf(refusal) {
   const blockage = detailBag(refusal)?.blockage;
   if (typeof blockage !== "object" || blockage === null) return void 0;
@@ -725,6 +827,17 @@ var DECLARED_PATHS = {
   "/health/cache": true,
   "/health/live": true,
   "/health/ready": true,
+  "/internal/functions/runs/{runId}/actions": true,
+  "/internal/functions/runs/{runId}/bundle": true,
+  "/internal/functions/runs/{runId}/content": true,
+  "/internal/functions/runs/{runId}/outcome": true,
+  "/internal/functions/runs/{runId}/recorded": true,
+  "/internal/functions/runs/{runId}/records/batch": true,
+  "/internal/functions/runs/{runId}/records/file": true,
+  "/internal/functions/runs/{runId}/records/read": true,
+  "/internal/functions/tasks/{taskId}/run": true,
+  "/internal/functions/test-runs/{projectId}/{name}": true,
+  "/internal/functions/tool-calls/{projectId}/{name}": true,
   "/internal/live/visitor-feed/{projectId}/{datasetId}/changes": true,
   "/internal/live/visitor-key": true,
   "/internal/media/claim": true,
@@ -761,6 +874,11 @@ var DECLARED_PATHS = {
   "/v1/project": true,
   "/v1/queries/{name}": true,
   "/v1/query": true,
+  "/v1/functions/{name}": true,
+  "/v1/records/batch": true,
+  "/v1/records/{recordType}": true,
+  "/v1/records/{recordType}/files": true,
+  "/v1/records/{recordType}/{uid}": true,
   "/v1/search": true,
   "/v1/search/autocomplete": true,
   "/v1/search/similar": true,
@@ -1734,7 +1852,10 @@ var EntryHandle = _EntryHandle;
 // src/content/content-client.ts
 var _ContentClient = class _ContentClient extends EntryHandle {
   /**
-   * Create a new content entry.
+   * Create a new content entry, published. The answer's `_metadata.warnings` lists each reference
+   * the content type declares `weak` that the create made live while the entry it points at is
+   * unpublished (`REFERENCE_NOT_PUBLISHED`) — `[]` when there are none; the create is never refused
+   * for them.
    *
    * `locale` defaults to the client's own, and `dataset` to the client's (`client.with({ dataset })`
    * sets it for every call).
@@ -2640,7 +2761,10 @@ var _SingletonClient = class _SingletonClient extends DocumentHandle {
       throw error;
     }
   }
-  /** The API publishes on PATCH: there is no separate publish route. */
+  /**
+   * The API publishes on PATCH: there is no separate publish route. The answer's `_metadata` also
+   * lists the links the write left pointing nowhere and its `warnings` (REL-3097).
+   */
   patch(write, options) {
     return this.httpClient.fetchPayload(
       "/v1/singletons/{key}",
@@ -2700,15 +2824,11 @@ var _SettingsClient = class _SettingsClient extends DocumentHandle {
   async reset(...args) {
     const [first, second] = args;
     const write = first !== void 0 && isRead(first) ? { ...versionCheckOf(first), options: second } : { locale: this.localeOf(first?.locale), ifMatch: void 0, options: first };
-    return this.httpClient.fetchPayload(
-      "/v1/settings/{groupId}/reset",
-      "post",
-      {
-        path: { groupId: this.name },
-        query: write.locale === void 0 ? void 0 : { locale: write.locale },
-        headers: DocumentHandle.headersOf(write, write.options)
-      }
-    );
+    return this.httpClient.fetchPayload("/v1/settings/{groupId}/reset", "post", {
+      path: { groupId: this.name },
+      query: write.locale === void 0 ? void 0 : { locale: write.locale },
+      headers: DocumentHandle.headersOf(write, write.options)
+    });
   }
   /** The group's default values, as the schema declares them. */
   async getDefaults() {
@@ -2742,6 +2862,199 @@ var _SettingsClient = class _SettingsClient extends DocumentHandle {
 __name(_SettingsClient, "SettingsClient");
 var SettingsClient = _SettingsClient;
 
+// src/content/records-client.ts
+function isMissingRecord(error) {
+  return error instanceof ResourceNotFoundError && error.context?.resourceType === "record";
+}
+__name(isMissingRecord, "isMissingRecord");
+var _RecordsClient = class _RecordsClient {
+  constructor(httpClient, recordType) {
+    this.httpClient = httpClient;
+    this.recordType = recordType;
+  }
+  /**
+   * Store a Record, live the moment it lands. Values that break the Record type's fields are
+   * refused with `ValidationError` naming each field, and nothing is stored. Values a unique set of
+   * the type claims, held by another Record, are refused with `ResourceConflictError` — its
+   * `blockage` is `{ kind: 'value-taken', facts: { fields, recordId } }` (REL-3782).
+   */
+  async create(fields, options = {}) {
+    return this.httpClient.fetchPayload(
+      "/v1/records/{recordType}",
+      "post",
+      {
+        path: { recordType: this.recordType },
+        body: { fields },
+        headers: readHeaders(options),
+        ...signalOf(options)
+      }
+    );
+  }
+  /** One page of the Records `where` keeps, newest first unless `sort` names one key. */
+  async list(options = {}) {
+    const response = await this.httpClient.send(
+      "/v1/records/{recordType}",
+      "get",
+      {
+        path: { recordType: this.recordType },
+        query: {
+          ...options.where === void 0 ? {} : { filters: JSON.stringify(options.where) },
+          ...options.sort === void 0 ? {} : { sort: options.sort },
+          ...options.limit === void 0 ? {} : { limit: options.limit },
+          ...options.cursor === void 0 ? {} : { cursor: options.cursor },
+          ...options.count === true ? { count: "true" } : {},
+          ...options.facets === void 0 || options.facets.length === 0 ? {} : { facets: options.facets.join(",") },
+          ...includeQuery(options)
+        },
+        headers: readHeaders(options),
+        ...signalOf(options)
+      }
+    );
+    return response.body;
+  }
+  /**
+   * Upload a File for one of this Record type's file fields (REL-3824), and answer what a create or
+   * update sets the field to. The bytes go straight to object storage at the address the upload
+   * names, never through RelyIO; a File outside the field's `accept` or over its `maxSize` is
+   * refused with `ValidationError` naming the field before any byte is sent. An upload no write
+   * names within a day is deleted with its bytes. Server-side only, as every Record call is.
+   *
+   * @example
+   * ```typescript
+   * const invoice = await relyio.records('order').upload('invoice', pdfBytes, {
+   *   name: 'invoice-1001.pdf',
+   *   type: 'application/pdf',
+   * })
+   * await relyio.records('order').update(id, { invoice }, { revision })
+   * ```
+   */
+  async upload(field, bytes, options) {
+    const size = bytes instanceof Blob ? bytes.size : bytes.byteLength;
+    const upload = await this.httpClient.fetchPayload("/v1/records/{recordType}/files", "post", {
+      path: { recordType: this.recordType },
+      body: { field, name: options.name, type: options.type, size },
+      headers: readHeaders(options),
+      ...signalOf(options)
+    });
+    const response = await HttpClient.transfer(this.httpClient, upload.url, {
+      method: upload.method,
+      headers: upload.headers,
+      body: bytes,
+      ...signalOf(options)
+    });
+    if (!response.ok) {
+      throw new FileUploadError(
+        "INTERNAL",
+        `Upload failed (${response.status} ${response.statusText}) for ${this.recordType}.${field}`,
+        { retriable: response.status >= 500, statusCode: response.status }
+      );
+    }
+    return { upload: upload.id };
+  }
+  /**
+   * One Record by its id, or `null` when none is stored. A Record type nobody deployed throws
+   * `ResourceNotFoundError` naming it, so it never reads as a missing Record.
+   */
+  async get(id, options = {}) {
+    try {
+      return await this.httpClient.fetchPayload(
+        "/v1/records/{recordType}/{uid}",
+        "get",
+        {
+          path: { recordType: this.recordType, uid: id },
+          query: includeQuery(options),
+          headers: readHeaders(options),
+          ...signalOf(options)
+        }
+      );
+    } catch (error) {
+      if (isMissingRecord(error)) return null;
+      throw error;
+    }
+  }
+  /**
+   * Change the fields named, against the revision the change was made on, and answer the Record at
+   * its next revision. A field given `null` is removed; one not named keeps its value. A Record
+   * written since `revision` is refused with `ResourceConflictError` — its `blockage` is
+   * `{ kind: 'revision-stale', facts: { changedFields } }` — and nothing is written. Values that
+   * break the Record type are refused with `ValidationError` naming each field, and values another
+   * Record holds under a unique set with `ResourceConflictError`, its blockage `value-taken`.
+   *
+   * @example
+   * ```typescript
+   * const order = await relyio.records('order').get(id)
+   * await relyio.records('order').update(id, { status: 'shipped' }, {
+   *   revision: order._metadata.revision,
+   * })
+   * ```
+   */
+  async update(id, fields, options) {
+    return this.httpClient.fetchPayload(
+      "/v1/records/{recordType}/{uid}",
+      "patch",
+      {
+        path: { recordType: this.recordType, uid: id },
+        body: { fields },
+        headers: { ...readHeaders(options), "If-Match": `"${options.revision}"` },
+        ...signalOf(options)
+      }
+    );
+  }
+  /**
+   * Remove a Record. Another Record holding it through a reference declared to block its delete —
+   * the default — is refused with `ResourceConflictError`, its `blockage`
+   * (`{ kind: 'referenced', facts: { referrers } }`) naming each; one declared `nullify` is cleared.
+   */
+  async delete(id, options = {}) {
+    await this.httpClient.send(
+      "/v1/records/{recordType}/{uid}",
+      "delete",
+      {
+        path: { recordType: this.recordType, uid: id },
+        headers: readHeaders(options),
+        ...signalOf(options)
+      }
+    );
+  }
+};
+__name(_RecordsClient, "RecordsClient");
+var RecordsClient = _RecordsClient;
+function includeQuery(options) {
+  return {
+    ...options.include === void 0 || options.include.length === 0 ? {} : { include: options.include.join(",") },
+    ...options.locale === void 0 ? {} : { locale: options.locale }
+  };
+}
+__name(includeQuery, "includeQuery");
+
+// src/content/record-batch.ts
+async function sendRecordBatch(httpClient, operations, options = {}) {
+  const { idempotencyKey, ...call } = options;
+  return httpClient.fetchPayload(
+    "/v1/records/batch",
+    "post",
+    {
+      body: { operations },
+      headers: { ...readHeaders(call), ...writeHeaders({ idempotencyKey }) },
+      ...signalOf(call)
+    }
+  );
+}
+__name(sendRecordBatch, "sendRecordBatch");
+var OPERATION_PATH = /^operations\[(\d+)\]/;
+function refusedOperationOf(error) {
+  if (typeof error !== "object" || error === null) return void 0;
+  const { context, violations } = error;
+  const operation = context?.blockage?.facts?.operation;
+  if (typeof operation === "number") return operation;
+  for (const violation of violations ?? []) {
+    const match = typeof violation.field === "string" ? OPERATION_PATH.exec(violation.field) : null;
+    if (match?.[1] !== void 0) return Number(match[1]);
+  }
+  return void 0;
+}
+__name(refusedOperationOf, "refusedOperationOf");
+
 // src/changes/changes.ts
 var CHANGES_POLL_TIMEOUT_MS = 25e3 + 5e3;
 var EXPIRED_REASONS2 = {
@@ -3360,6 +3673,32 @@ function hasOwn(object, key) {
 }
 __name(hasOwn, "hasOwn");
 
+// src/content/functions-client.ts
+var FUNCTION_CALL_TIMEOUT_MS = 31e4;
+async function callFunction(http, name, input, options) {
+  return await http.fetchPayload("/v1/functions/{name}", "post", {
+    path: { name },
+    body: { input },
+    headers: {
+      ...readHeaders({ dataset: options.dataset }),
+      ...options.idempotencyKey === void 0 ? {} : { [HEADER_IDEMPOTENCY_KEY.name]: options.idempotencyKey }
+    },
+    timeout: options.timeout ?? FUNCTION_CALL_TIMEOUT_MS,
+    ...signalOf(options)
+  });
+}
+__name(callFunction, "callFunction");
+function functionsAccessor(http) {
+  return new Proxy({}, {
+    get: /* @__PURE__ */ __name((_target, property) => {
+      if (typeof property !== "string" || property === "then") return void 0;
+      const call = /* @__PURE__ */ __name((input = {}, options = {}) => callFunction(http(), property, input, options), "call");
+      return call;
+    }, "get")
+  });
+}
+__name(functionsAccessor, "functionsAccessor");
+
 // src/search/search-options.ts
 function scopeOf(contentType) {
   if (contentType === void 0) return { contentTypes: "*" };
@@ -3910,6 +4249,48 @@ var _TypedRelyIOClient = class _TypedRelyIOClient {
     __publicField(this, "defaults", {});
     /** The live edge's poll client id: chosen once, when first needed, and kept for this client's life. */
     __publicField(this, "_liveClientId");
+    /**
+     * The Records of one Record type (spec 1, REL-3771): `create`, `list`, `get`, `update`, `delete`.
+     * Type-safe when a schema is provided — the names autocomplete its `recordTypes` and the fields
+     * are the type's. `relyio.records.batch([...])` writes Records of any types in one transaction,
+     * all or none (REL-3774).
+     *
+     * A Record is an app's data, written by your server with a secret key and live the moment it
+     * lands; a publishable key is refused on every Record route (`PUBLISHABLE_KEY_REFUSED`).
+     *
+     * @example
+     * ```typescript
+     * const order = await relyio.records('order').create({ shopperEmail: 'ada@example.com', total: 19 })
+     * const { data: orders } = await relyio.records('order').list({ where: { status: 'paid' } })
+     * await relyio.records.batch([
+     *   { op: 'decrement', type: 'inventory', where: { product: mugId }, field: 'available', by: 1 },
+     *   { op: 'create', type: 'order', fields: { shopperEmail: 'ada@example.com', total: 19 } },
+     * ])
+     * ```
+     */
+    __publicField(this, "records", Object.assign(
+      (recordType) => new RecordsClient(this.httpClient, recordType),
+      {
+        // Read when called, never when made: `with()` and `updateConfig()` move `httpClient`
+        batch: /* @__PURE__ */ __name((operations, options) => sendRecordBatch(this.httpClient, operations, options), "batch")
+      }
+      // The one function both call signatures describe; the cast restates the schema's typing of its
+      // argument and answer, as `content()` does, and widens nothing it is called with.
+    ));
+    /**
+     * The project's Functions, by name (spec 2, REL-3821): `relyio.functions.checkout({ cartId })`
+     * runs the Function `checkout` that the key's Branch runs, on the key's Dataset, and answers its
+     * output. Call it from your server with a secret key; a run that failed throws
+     * `FunctionRunFailedError` and one past five minutes `FunctionRunTimedOutError`, each naming the
+     * run. Never retried: a Function may write.
+     *
+     * @example
+     * ```typescript
+     * const { orderId } = (await relyio.functions.checkout({ cartId })) as { orderId: string }
+     * ```
+     */
+    // Read when called, never when made: `with()` and `updateConfig()` move `httpClient`
+    __publicField(this, "functions", functionsAccessor(() => this.httpClient));
     const { schema, ...clientConfig } = config;
     this._schema = schema;
     const resolved = resolveConfig(clientConfig);
@@ -4430,6 +4811,6 @@ function randomClientId() {
 }
 __name(randomClientId, "randomClientId");
 
-export { AssetClient, AssetFileBuilder, AssetUploadBuilder, AuthorizationError, BaseValidationError, ChangesExpiredError, ConnectionError, ContentClient, DefaultRetryPolicy, ErrorMapper, FileUploadError, FileValidationError, HttpClient, InvalidApiKeyError, InvalidPayloadError, LIVE_KEEPALIVE_INTERVAL_MS, LIVE_SOCKET_OPEN_TIMEOUT_MS, LiveEdgeError, MethodNotAllowedError, MissingApiKeyError, NetworkError, PREVIEW_KEY_PREFIX, PUBLISHABLE_KEY_PREFIX, PayloadTooLargeError, PlanFeatureUnavailableError, RateLimitError, ReadOnlyKeyError, ResourceConflictError, ResourceExpiredError, ResourceNotFoundError, SDKError, ServerError, ServiceIndeterminateError, SettingsClient, SingletonClient, TimeoutError, TransactionRolledBackError, TypedRelyIOClient, UnknownContractError, UsageQuotaExceededError, ValidationError, createClient, isAborted, isAssetEntry, isMissingEntry, isPreviewKey, isPublishableKey, isReplaySafe, isResourceNotFound, matchRoute, retryPolicyFor, serviceInstructedDelayMs, sleep, validateFile, versionCheckOf };
-//# sourceMappingURL=chunk-NIUOPIIB.js.map
-//# sourceMappingURL=chunk-NIUOPIIB.js.map
+export { AssetClient, AssetFileBuilder, AssetUploadBuilder, AuthorizationError, BaseValidationError, ChangesExpiredError, ConnectionError, ContentClient, DefaultRetryPolicy, ErrorMapper, FileUploadError, FileValidationError, FunctionContainersBusyError, FunctionRunFailedError, FunctionRunTimedOutError, HttpClient, InvalidApiKeyError, InvalidPayloadError, LIVE_KEEPALIVE_INTERVAL_MS, LIVE_SOCKET_OPEN_TIMEOUT_MS, LiveEdgeError, MethodNotAllowedError, MissingApiKeyError, NetworkError, PREVIEW_KEY_PREFIX, PUBLISHABLE_KEY_PREFIX, PayloadTooLargeError, PlanFeatureUnavailableError, PublishableKeyRefusedError, RateLimitError, ReadOnlyKeyError, RecordsClient, ResourceConflictError, ResourceExpiredError, ResourceNotFoundError, SDKError, ServerError, ServiceIndeterminateError, SettingsClient, SingletonClient, TimeoutError, TransactionRolledBackError, TypedRelyIOClient, UnknownContractError, UsageQuotaExceededError, ValidationError, createClient, isAborted, isAssetEntry, isMissingEntry, isPreviewKey, isPublishableKey, isReplaySafe, isResourceNotFound, matchRoute, refusedOperationOf, retryPolicyFor, serviceInstructedDelayMs, sleep, validateFile, versionCheckOf };
+//# sourceMappingURL=chunk-ZHTJ7GXH.js.map
+//# sourceMappingURL=chunk-ZHTJ7GXH.js.map

package/dist/{chunk-LSRPMNPT.cjs → chunk-ZO6QDYJG.cjs}

@@ -1,6 +1,6 @@
 'use strict';
 
-var chunkMWMSFIWN_cjs = require('./chunk-MWMSFIWN.cjs');
+var chunkL6DXCKVQ_cjs = require('./chunk-L6DXCKVQ.cjs');
 
 /* RelyIO SDK - Built with ❤️ by the RelyIO Team */
 
@@ -20,7 +20,7 @@ function readDeadline(raw, now) {
   if (!Number.isFinite(deadline)) return { state: "unreadable" };
   return deadline <= now ? { state: "passed", expiredAt: raw } : { state: "live", expiresAt: raw };
 }
-chunkMWMSFIWN_cjs.__name(readDeadline, "readDeadline");
+chunkL6DXCKVQ_cjs.__name(readDeadline, "readDeadline");
 function parseDevContextFile(raw, now) {
   let parsed;
   try {
@@ -46,7 +46,7 @@ function parseDevContextFile(raw, now) {
   };
   return deadline.state === "passed" ? { state: "expired", context, expiredAt: deadline.expiredAt } : { state: "active", context };
 }
-chunkMWMSFIWN_cjs.__name(parseDevContextFile, "parseDevContextFile");
+chunkL6DXCKVQ_cjs.__name(parseDevContextFile, "parseDevContextFile");
 function buildDevEnv(context) {
   const env = {
     [DEV_ENV.dataset]: context.datasetId,
@@ -57,7 +57,7 @@ function buildDevEnv(context) {
   }
   return env;
 }
-chunkMWMSFIWN_cjs.__name(buildDevEnv, "buildDevEnv");
+chunkL6DXCKVQ_cjs.__name(buildDevEnv, "buildDevEnv");
 function parseDevEnv(env, now) {
   const dataset = env?.[DEV_ENV.dataset];
   const apiKey = env?.[DEV_ENV.apiKey];
@@ -76,7 +76,7 @@ function parseDevEnv(env, now) {
       return { state: "active", credentials: { dataset, apiKey }, expiresAt: null };
   }
 }
-chunkMWMSFIWN_cjs.__name(parseDevEnv, "parseDevEnv");
+chunkL6DXCKVQ_cjs.__name(parseDevEnv, "parseDevEnv");
 
 exports.DEV_CONTEXT_DIR = DEV_CONTEXT_DIR;
 exports.DEV_CONTEXT_FILE = DEV_CONTEXT_FILE;
@@ -85,5 +85,5 @@ exports.DEV_ENV = DEV_ENV;
 exports.buildDevEnv = buildDevEnv;
 exports.parseDevContextFile = parseDevContextFile;
 exports.parseDevEnv = parseDevEnv;
-//# sourceMappingURL=chunk-LSRPMNPT.cjs.map
-//# sourceMappingURL=chunk-LSRPMNPT.cjs.map
+//# sourceMappingURL=chunk-ZO6QDYJG.cjs.map
+//# sourceMappingURL=chunk-ZO6QDYJG.cjs.map

package/dist/client/index.cjs

@@ -1,20 +1,21 @@
 'use strict';
 
-var chunkRLLZUFDB_cjs = require('../chunk-RLLZUFDB.cjs');
-require('../chunk-LSRPMNPT.cjs');
-require('../chunk-7BZW6XYJ.cjs');
-require('../chunk-TZL374LS.cjs');
-require('../chunk-MWMSFIWN.cjs');
+var chunkIFKF72VJ_cjs = require('../chunk-IFKF72VJ.cjs');
+require('../chunk-M7MWNV3Q.cjs');
+require('../chunk-ZO6QDYJG.cjs');
+require('../chunk-7I3SC7SV.cjs');
+require('../chunk-SHSK7UUY.cjs');
+require('../chunk-L6DXCKVQ.cjs');
 
 
 
 Object.defineProperty(exports, "TypedRelyIOClient", {
   enumerable: true,
-  get: function () { return chunkRLLZUFDB_cjs.TypedRelyIOClient; }
+  get: function () { return chunkIFKF72VJ_cjs.TypedRelyIOClient; }
 });
 Object.defineProperty(exports, "createClient", {
   enumerable: true,
-  get: function () { return chunkRLLZUFDB_cjs.createClient; }
+  get: function () { return chunkIFKF72VJ_cjs.createClient; }
 });
 //# sourceMappingURL=index.cjs.map
 //# sourceMappingURL=index.cjs.map

package/dist/client/index.d.cts

@@ -1,5 +1,6 @@
-export { e as ClientDefaults, f as ClientSchema, R as Register, h as RegisteredSchema, d as TypedClientConfig, T as TypedRelyIOClient, c as createClient } from '../index-D80MXUkf.cjs';
-import '../define-content-type-LkI0rS2W.cjs';
+export { e as ClientDefaults, f as ClientSchema, d as TypedClientConfig, T as TypedRelyIOClient, c as createClient } from '../index-DwHcL6x5.cjs';
+export { d as Register, R as RegisteredSchema } from '../register-BYCs0FpF.cjs';
+import '../define-content-type-NEQDrvdq.cjs';
 import '../rich-text.d-BWc-5gX1.cjs';
-import '../define-schema-wlsJOrnY.cjs';
+import '../define-schema-DZhtvLiK.cjs';
 import '../dev-handshake/index.cjs';

package/dist/client/index.d.ts

@@ -1,5 +1,6 @@
-export { e as ClientDefaults, f as ClientSchema, R as Register, h as RegisteredSchema, d as TypedClientConfig, T as TypedRelyIOClient, c as createClient } from '../index-BH8JksfG.js';
-import '../define-content-type-CAWSlgn0.js';
+export { e as ClientDefaults, f as ClientSchema, d as TypedClientConfig, T as TypedRelyIOClient, c as createClient } from '../index-M3luH06A.js';
+export { d as Register, R as RegisteredSchema } from '../register-B53i97A9.js';
+import '../define-content-type-fb-WCD5e.js';
 import '../rich-text.d-BWc-5gX1.js';
-import '../define-schema-Dxu3RoHV.js';
+import '../define-schema-Dlwh6l_J.js';
 import '../dev-handshake/index.js';

package/dist/client/index.js

@@ -1,7 +1,8 @@
-export { TypedRelyIOClient, createClient } from '../chunk-NIUOPIIB.js';
-import '../chunk-BBUB7C2Z.js';
-import '../chunk-CQHEG7QA.js';
-import '../chunk-H6IBQSMM.js';
-import '../chunk-XQ4QHWZE.js';
+export { TypedRelyIOClient, createClient } from '../chunk-ZHTJ7GXH.js';
+import '../chunk-NJQK5STK.js';
+import '../chunk-W2A4OTCI.js';
+import '../chunk-HDHBYYEY.js';
+import '../chunk-EDE2H37D.js';
+import '../chunk-DI6KFDBO.js';
 //# sourceMappingURL=index.js.map
 //# sourceMappingURL=index.js.map