@bedrock-rbx/ocale 0.1.0-beta.8 → 0.1.0

package/dist/retry-r1TXe5Zd.d.mts

@@ -0,0 +1,189 @@
+import { d as OpenCloudError } from "./types-CRiJg5EQ.mjs";
+
+//#region src/errors/api-error.d.ts
+/**
+* Options for constructing an {@link ApiError}.
+*
+* @since 0.1.0
+*/
+interface ApiErrorOptions extends ErrorOptions {
+  /** Optional machine-readable error code from the API. */
+  code?: string | undefined;
+  /** Parsed response body, when present. */
+  details?: JSONValue | undefined;
+  /** HTTP status code from the API response. */
+  statusCode: number;
+}
+/**
+* Thrown when the Roblox Open Cloud API returns a non-2xx response
+* that is not a rate limit (429).
+*
+* @since 0.1.0
+*
+* @example
+*
+* ```ts
+* import { ApiError } from "@bedrock-rbx/ocale";
+*
+* const error = new ApiError("HTTP 404: Pass not found (code NotFound)", {
+*     code: "NotFound",
+*     details: { errorCode: "NotFound", message: "Pass not found" },
+*     statusCode: 404,
+* });
+*
+* expect(error).toBeInstanceOf(ApiError);
+* expect(error.statusCode).toBe(404);
+* expect(error.code).toBe("NotFound");
+* expect(error.details).toEqual({
+*     errorCode: "NotFound",
+*     message: "Pass not found",
+* });
+* ```
+*/
+declare class ApiError extends OpenCloudError {
+  readonly code: string | undefined;
+  readonly details: JSONValue | undefined;
+  override readonly name: string;
+  readonly statusCode: number;
+  /**
+  * Creates a new ApiError.
+  *
+  * @param message - Human-readable error description.
+  * @param options - Error options including status code, optional error
+  *   code, and the parsed response body when present.
+  */
+  constructor(message: string, options: ApiErrorOptions);
+}
+//#endregion
+//#region src/errors/network-error.d.ts
+/**
+* Options for constructing a {@link NetworkError}.
+*
+* @since 0.1.0
+*/
+interface NetworkErrorOptions extends ErrorOptions {
+  /** HTTP method of the request that failed. */
+  method?: string | undefined;
+  /** Fully-qualified URL of the request that failed. */
+  url?: string | undefined;
+}
+/**
+* Thrown when a network-level failure prevents the request from reaching
+* the Roblox Open Cloud API (e.g., DNS resolution failure, connection reset).
+* The `method` and `url` name the failing call so a transport failure that
+* survives every retry can be diagnosed; the underlying transport error is
+* carried on `cause`.
+*
+* @since 0.1.0
+*/
+declare class NetworkError extends OpenCloudError {
+  readonly method: string | undefined;
+  override readonly name: string;
+  readonly url: string | undefined;
+  /**
+  * Creates a new NetworkError.
+  *
+  * @param message - Human-readable error description.
+  * @param options - Error options including the optional `cause` and the
+  *   `method` / `url` of the request that failed.
+  */
+  constructor(message: string, options?: NetworkErrorOptions);
+}
+//#endregion
+//#region src/errors/rate-limit.d.ts
+/**
+* Options for constructing a {@link RateLimitError}.
+*
+* @since 0.1.0
+*/
+interface RateLimitErrorOptions extends ErrorOptions {
+  /**
+  * Requests still allowed in the throttled window, read from
+  * `x-ratelimit-remaining` (the most-constrained window). `undefined` when
+  * the header is absent or carries no finite numeric token; parsed
+  * independently of `x-ratelimit-reset`, so a valid value survives a
+  * non-numeric reset. Typically `0` on a genuine 429.
+  */
+  remaining?: number | undefined;
+  /** Seconds to wait before retrying the request. */
+  retryAfterSeconds: number;
+}
+/**
+* Thrown when the Roblox Open Cloud API returns a 429 Too Many Requests response.
+* Contains the server-suggested retry delay.
+*
+* @since 0.1.0
+*
+* @example
+*
+* ```ts
+* import { RateLimitError } from "@bedrock-rbx/ocale";
+*
+* const error = new RateLimitError("Too many requests", {
+*     retryAfterSeconds: 30,
+* });
+*
+* expect(error).toBeInstanceOf(RateLimitError);
+* expect(error.retryAfterSeconds).toBe(30);
+* ```
+*/
+declare class RateLimitError extends OpenCloudError {
+  override readonly name = "RateLimitError";
+  /** Requests left in the throttled window, or `undefined` if not reported. */
+  readonly remaining: number | undefined;
+  readonly retryAfterSeconds: number;
+  /**
+  * Creates a new RateLimitError.
+  *
+  * @param message - Human-readable error description.
+  * @param options - Error options including the retry delay.
+  */
+  constructor(message: string, options: RateLimitErrorOptions);
+}
+//#endregion
+//#region src/internal/http/retry.d.ts
+/**
+* Fully-resolved retry config shape that {@link mergeConfig} and
+* {@link shouldRetry} operate on. Fields are required because this represents
+* the post-defaulting, internal view; callers should supply every field (or
+* resolve them via a test factory / client constructor). The partial,
+* user-facing type lives on client construction options; method defaults and
+* per-request overrides use `Partial<RetryResolvable>`.
+*/
+interface RetryResolvable {
+  /** Roblox Open Cloud API key. */
+  readonly apiKey: string;
+  /** Base URL for the Open Cloud API. */
+  readonly baseUrl: string;
+  /** Maximum retry attempts before giving up. */
+  readonly maxRetries: number;
+  /** Status codes that are eligible for retry. */
+  readonly retryableStatuses: ReadonlyArray<number>;
+  /**
+  * Node-style transport error codes ({@link findErrorCode}) eligible for
+  * retry when surfaced as a {@link NetworkError}. Empty for create
+  * operations by default; consumers opt a create in via a per-request
+  * override.
+  */
+  readonly retryableTransportCodes: ReadonlyArray<string>;
+  /** Fallback delay function when no server hint is available. */
+  readonly retryDelay: (attempt: number) => number;
+  /** Per-request timeout in milliseconds. */
+  readonly timeout: number;
+}
+/**
+* Transient transport error codes that are safe to retry for idempotent
+* operations. Connection resets, timeouts, and DNS hiccups are recoverable on
+* a retry. A self-aborted request timeout carries no OS-level `code`, so
+* {@link shouldRetry} folds it into this set as `ETIMEDOUT` (via
+* {@link isTimeoutAbort}) for idempotent methods; create methods retry no
+* transport codes and so still never re-issue a timed-out write.
+*
+* @since 0.1.0
+*/
+declare const TRANSIENT_TRANSPORT_CODES: ReadonlyArray<string>;
+/** Kind of HTTP method the merge is being performed for. */
+type MethodKind = "create" | "idempotent";
+//#endregion
+export { RateLimitErrorOptions as a, ApiError as c, RateLimitError as i, ApiErrorOptions as l, RetryResolvable as n, NetworkError as o, TRANSIENT_TRANSPORT_CODES as r, NetworkErrorOptions as s, MethodKind as t };
+//# sourceMappingURL=retry-r1TXe5Zd.d.mts.map

package/dist/retry-r1TXe5Zd.d.mts.map

@@ -0,0 +1 @@
+{"version":3,"file":"retry-r1TXe5Zd.d.mts","names":[],"sources":["../src/errors/api-error.ts","../src/errors/network-error.ts","../src/errors/rate-limit.ts","../src/internal/http/retry.ts"],"mappings":";;;;;AAOA;;;UAAiB,eAAA,SAAwB,YAAA;;EAExC,IAAA;;EAEA,OAAA,GAAU,SAAA;;EAEV,UAAA;AAAA;AA6BD;;;;;;;;;;;;;;;;;;;AAauC;;;;AChDvC;;;ADmCA,cAAa,QAAA,SAAiB,cAAA;EAAA,SACb,IAAA;EAAA,SACA,OAAA,EAAS,SAAA;EAAA,kBACA,IAAA;EAAA,SACT,UAAA;ECnChB;AAYD;;;;;;EDgCC,WAAA,CAAY,OAAA,UAAiB,OAAA,EAAS,eAAA;AAAA;;;;;AAhDvC;;;UCAiB,mBAAA,SAA4B,YAAA;;EAE5C,MAAA;;EAEA,GAAA;AAAA;;ADEA;AA6BD;;;;;;;cCnBa,YAAA,SAAqB,cAAA;EAAA,SACjB,MAAA;EAAA,kBACS,IAAA;EAAA,SACT,GAAA;;;;;;;;EAShB,WAAA,CAAY,OAAA,UAAiB,OAAA,GAAU,mBAAA;AAAA;;;;;AD5BxC;;;UEAiB,qBAAA,SAA8B,YAAA;;;;;;;AFM9C;EEEA,SAAA;EF2BY;EEzBZ,iBAAA;AAAA;;;;;;;;;;;;;;;;AFsCsC;;;;cEhB1B,cAAA,SAAuB,cAAA;EAAA,kBACV,IAAA;;WAET,SAAA;EAAA,SACA,iBAAA;;;;ADhChB;AAYD;;EC4BC,WAAA,CAAY,OAAA,UAAiB,OAAA,EAAS,qBAAA;AAAA;;;AF5CvC;;;;;;;;AAAA,UGMiB,eAAA;EHAhB;EAAA,SGES,MAAA;EH2BV;EAAA,SGzBU,OAAA;;WAEA,UAAA;;WAEA,iBAAA,EAAmB,aAAA;EHqBC;;;;;;EAAA,SGdpB,uBAAA,EAAyB,aAAA;;WAEzB,UAAA,GAAa,OAAA;;WAEb,OAAA;AAAA;;AHuB6B;;;;AChDvC;;;;;cEsCa,yBAAA,EAA2B,aAAA;;KAsC5B,UAAA"}

package/dist/{signatures-B5Fojgn0.mjs → signatures-JF-7Psce.mjs}

@@ -56,4 +56,4 @@ function matchesSignature(body, signature) {
 //#endregion
 export { RBXL_SIGNATURE as n, matchesSignature as r, RBXLX_SIGNATURE as t };
 
-//# sourceMappingURL=signatures-B5Fojgn0.mjs.map
+//# sourceMappingURL=signatures-JF-7Psce.mjs.map

package/dist/{signatures-B5Fojgn0.mjs.map → signatures-JF-7Psce.mjs.map}

@@ -1 +1 @@
-{"version":3,"file":"signatures-B5Fojgn0.mjs","names":[],"sources":["../src/domains/universes/places/signatures.ts"],"sourcesContent":["/**\n * Magic-byte prefix every Roblox binary place file (`.rbxl`) starts with.\n * The first 8 bytes spell out `<roblox!` in ASCII; the remaining 6 bytes\n * (`\\x89\\xff\\r\\n\\x1a\\n`) are the binary-format marker that distinguishes a\n * binary place file from the XML form (`.rbxlx`), whose ASCII-only header\n * begins with `<roblox `.\n */\nexport const RBXL_SIGNATURE: Readonly<Uint8Array<ArrayBuffer>> = new Uint8Array([\n\t0x3c, 0x72, 0x6f, 0x62, 0x6c, 0x6f, 0x78, 0x21, 0x89, 0xff, 0x0d, 0x0a, 0x1a, 0x0a,\n]);\n\n/**\n * Magic-byte prefix every Roblox XML place file (`.rbxlx`) starts with.\n * Equivalent to the ASCII string `<roblox ` (note the trailing space): a\n * well-formed rbxlx file opens with `<roblox` followed by attributes, while\n * an rbxl file uses `<roblox!` (exclamation mark) as the eighth byte. The\n * trailing space is what proves the file is the XML variant rather than\n * the binary one.\n */\nexport const RBXLX_SIGNATURE: Readonly<Uint8Array<ArrayBuffer>> = new Uint8Array([\n\t0x3c, 0x72, 0x6f, 0x62, 0x6c, 0x6f, 0x78, 0x20,\n]);\n\n/**\n * Reports whether `body` begins with `signature`. A pure byte-prefix check\n * with no allocation; used by the place builder to disambiguate `.rbxl` and\n * `.rbxlx` payloads against their declared `format`.\n *\n * @param body - The caller-supplied place file bytes.\n * @param signature - One of the frozen signature constants from this module.\n * @returns `true` if every byte of `signature` matches `body[0..signature.length]`.\n */\nexport function matchesSignature(\n\tbody: Uint8Array,\n\tsignature: Readonly<Uint8Array<ArrayBuffer>>,\n): boolean {\n\tfor (const [index, expected] of signature.entries()) {\n\t\tif (body[index] !== expected) {\n\t\t\treturn false;\n\t\t}\n\t}\n\n\treturn true;\n}\n"],"mappings":";;;;;;;;AAOA,MAAa,iBAAoD,IAAI,WAAW;CAC/E;CAAM;CAAM;CAAM;CAAM;CAAM;CAAM;CAAM;CAAM;CAAM;CAAM;CAAM;CAAM;CAAM;CAC9E,CAAC;;;;;;;;;AAUF,MAAa,kBAAqD,IAAI,WAAW;CAChF;CAAM;CAAM;CAAM;CAAM;CAAM;CAAM;CAAM;CAC1C,CAAC;;;;;;;;;;AAWF,SAAgB,iBACf,MACA,WACU;AACV,MAAK,MAAM,CAAC,OAAO,aAAa,UAAU,SAAS,CAClD,KAAI,KAAK,WAAW,SACnB,QAAO;AAIT,QAAO"}
+{"version":3,"file":"signatures-JF-7Psce.mjs","names":[],"sources":["../src/domains/universes/places/signatures.ts"],"sourcesContent":["/**\n * Magic-byte prefix every Roblox binary place file (`.rbxl`) starts with.\n * The first 8 bytes spell out `<roblox!` in ASCII; the remaining 6 bytes\n * (`\\x89\\xff\\r\\n\\x1a\\n`) are the binary-format marker that distinguishes a\n * binary place file from the XML form (`.rbxlx`), whose ASCII-only header\n * begins with `<roblox `.\n */\nexport const RBXL_SIGNATURE: Readonly<Uint8Array<ArrayBuffer>> = new Uint8Array([\n\t0x3c, 0x72, 0x6f, 0x62, 0x6c, 0x6f, 0x78, 0x21, 0x89, 0xff, 0x0d, 0x0a, 0x1a, 0x0a,\n]);\n\n/**\n * Magic-byte prefix every Roblox XML place file (`.rbxlx`) starts with.\n * Equivalent to the ASCII string `<roblox ` (note the trailing space): a\n * well-formed rbxlx file opens with `<roblox` followed by attributes, while\n * an rbxl file uses `<roblox!` (exclamation mark) as the eighth byte. The\n * trailing space is what proves the file is the XML variant rather than\n * the binary one.\n */\nexport const RBXLX_SIGNATURE: Readonly<Uint8Array<ArrayBuffer>> = new Uint8Array([\n\t0x3c, 0x72, 0x6f, 0x62, 0x6c, 0x6f, 0x78, 0x20,\n]);\n\n/**\n * Reports whether `body` begins with `signature`. A pure byte-prefix check\n * with no allocation; used by the place builder to disambiguate `.rbxl` and\n * `.rbxlx` payloads against their declared `format`.\n *\n * @param body - The caller-supplied place file bytes.\n * @param signature - One of the frozen signature constants from this module.\n * @returns `true` if every byte of `signature` matches `body[0..signature.length]`.\n */\nexport function matchesSignature(\n\tbody: Uint8Array,\n\tsignature: Readonly<Uint8Array<ArrayBuffer>>,\n): boolean {\n\tfor (const [index, expected] of signature.entries()) {\n\t\tif (body[index] !== expected) {\n\t\t\treturn false;\n\t\t}\n\t}\n\n\treturn true;\n}\n"],"mappings":";;;;;;;;AAOA,MAAa,iBAAoD,IAAI,WAAW;CAC/E;CAAM;CAAM;CAAM;CAAM;CAAM;CAAM;CAAM;CAAM;CAAM;CAAM;CAAM;CAAM;CAAM;AAC/E,CAAC;;;;;;;;;AAUD,MAAa,kBAAqD,IAAI,WAAW;CAChF;CAAM;CAAM;CAAM;CAAM;CAAM;CAAM;CAAM;AAC3C,CAAC;;;;;;;;;;AAWD,SAAgB,iBACf,MACA,WACU;CACV,KAAK,MAAM,CAAC,OAAO,aAAa,UAAU,QAAQ,GACjD,IAAI,KAAK,WAAW,UACnB,OAAO;CAIT,OAAO;AACR"}

package/dist/storage.d.mts

@@ -1,9 +1,12 @@
-import { d as OpenCloudError, i as OpenCloudClientOptions, l as Result, n as HttpRequest, r as HttpResponse, s as RequestOptions, u as SleepFunc } from "./types-CwtZT1ek.mjs";
+import { d as OpenCloudError, i as OpenCloudClientOptions, l as Result, n as HttpRequest, r as HttpResponse, s as RequestOptions, u as SleepFunc } from "./types-CRiJg5EQ.mjs";
+import { n as RetryResolvable, t as MethodKind } from "./retry-r1TXe5Zd.mjs";
 
 //#region src/domains/cloud-v2/memory-store-queues/types.d.ts
 /**
 * Caller-supplied input for the `enqueue` method on `StorageClient.queues`.
 * Mirrors `Cloud_CreateMemoryStoreQueueItem` on the Open Cloud API.
+*
+* @since 0.1.0
 */
 interface EnqueueQueueItemParameters {
   /**
@@ -34,6 +37,8 @@ interface EnqueueQueueItemParameters {
 * Parsed representation of a memory-store queue item, as returned by the
 * Open Cloud `Cloud_CreateMemoryStoreQueueItem` and (inside the array)
 * `Cloud_ReadMemoryStoreQueueItems` endpoints.
+*
+* @since 0.1.0
 */
 interface QueueItem {
   /** Server-generated item identifier, parsed from the wire `path`. */
@@ -55,6 +60,8 @@ interface QueueItem {
 /**
 * Caller-supplied input for the `dequeue` method on
 * `StorageClient.queues`. Mirrors `Cloud_ReadMemoryStoreQueueItems`.
+*
+* @since 0.1.0
 */
 interface DequeueQueueItemsParameters {
   /**
@@ -84,6 +91,8 @@ interface DequeueQueueItemsParameters {
 * response. The `readId` value must be passed to a subsequent
 * `discard` call to acknowledge the items; otherwise the items reappear
 * once the invisibility window elapses.
+*
+* @since 0.1.0
 */
 interface DequeueResult {
   /** Items dequeued from the front of the queue, in dequeue order. */
@@ -100,6 +109,8 @@ interface DequeueResult {
 * Acknowledging a `readId` removes the dequeued batch from the queue
 * permanently; without `discard`, the items reappear once their
 * invisibility window elapses.
+*
+* @since 0.1.0
 */
 interface DiscardQueueItemsParameters {
   /** Stringified queue identifier. */
@@ -110,6 +121,204 @@ interface DiscardQueueItemsParameters {
   readonly universeId: string;
 }
 //#endregion
+//#region src/domains/cloud-v2/memory-store-sorted-maps/types.d.ts
+/**
+* Discriminated union describing a sorted-map item's sort key. The
+* server contract requires at most one of `stringSortKey` or
+* `numericSortKey`; the union surfaces that constraint at the type
+* level so callers cannot accidentally set both.
+*
+* @since 0.1.0
+*/
+type SortKey = {
+  readonly kind: "numeric";
+  readonly value: number;
+} | {
+  readonly kind: "string";
+  readonly value: string;
+};
+/**
+* Caller-supplied input for the `create` method on
+* `StorageClient.sortedMaps`. Mirrors
+* `Cloud_CreateMemoryStoreSortedMapItem` on the Open Cloud API.
+*
+* @since 0.1.0
+*/
+interface CreateSortedMapItemParameters {
+  /**
+  * Caller-supplied item identifier. The server stores items
+  * case-sensitively; the value is URL-encoded by the builder.
+  */
+  readonly itemId: string;
+  /** Stringified sorted-map identifier. */
+  readonly mapId: string;
+  /** Optional sort key driving the item's position in the map. */
+  readonly sortKey?: SortKey;
+  /**
+  * Optional time-to-live in seconds. After this many seconds the
+  * item is automatically removed. Omitted entries inherit the
+  * server-default TTL.
+  */
+  readonly ttl?: number;
+  /** Stringified ID of the universe that owns the sorted map. */
+  readonly universeId: string;
+  /**
+  * Opaque item payload. May be any JSON value, including `null`,
+  * matching the protobuf `Value` contract on the wire.
+  */
+  readonly value: JSONValue;
+}
+/**
+* Caller-supplied input for the `list` method on
+* `StorageClient.sortedMaps`. Mirrors
+* `Cloud_ListMemoryStoreSortedMapItems` on the Open Cloud API. All
+* paging and filtering parameters are optional; omitting them returns
+* up to one item server-side (`maxPageSize` defaults to `1`).
+*
+* @since 0.1.0
+*/
+interface ListSortedMapItemsParameters {
+  /**
+  * Optional CEL filter on `id` and `sortKey`. The server supports
+  * `<`, `>`, and `&&` operators only; other operators are rejected
+  * server-side with a validation error.
+  */
+  readonly filter?: string;
+  /** Stringified sorted-map identifier. */
+  readonly mapId: string;
+  /**
+  * Maximum items per page. Capped at `100` server-side; values above
+  * the cap are clamped. Defaults to `1` when omitted.
+  */
+  readonly maxPageSize?: number;
+  /**
+  * Sort order. The server supports the `id` field only, with an
+  * optional ` desc` suffix.
+  */
+  readonly orderBy?: string;
+  /**
+  * Page token returned by a previous call. When supplied, all other
+  * parameters must match the previous call exactly.
+  */
+  readonly pageToken?: string;
+  /** Stringified ID of the universe that owns the sorted map. */
+  readonly universeId: string;
+}
+/**
+* Parsed representation of a sorted-map item, as returned by every
+* sorted-map operation that yields a single item.
+*
+* @since 0.1.0
+*/
+interface SortedMapItem {
+  /** Item identifier, parsed from the wire `path`. */
+  readonly id: string;
+  /**
+  * Server-generated etag for optimistic concurrency. Surfaced for
+  * caller inspection; the SDK does not yet emit an `If-Match` header
+  * for conditional update or delete.
+  */
+  readonly etag: string;
+  /** Timestamp at which the server removes the item from the map. */
+  readonly expiresAt: Date;
+  /** Stringified sorted-map identifier, parsed from the wire `path`. */
+  readonly mapId: string;
+  /**
+  * Parsed sort key, or `undefined` when the item has none. The server
+  * contract is one-of: a response carrying both `stringSortKey` and
+  * `numericSortKey` is rejected as malformed.
+  */
+  readonly sortKey: SortKey | undefined;
+  /** Stringified universe identifier, parsed from the wire `path`. */
+  readonly universeId: string;
+  /**
+  * Opaque item payload. Round-trips as JSON, including nested `null`
+  * values inside objects and arrays, and `null` at the top level.
+  */
+  readonly value: JSONValue;
+}
+/**
+* Parsed result of a successful `Cloud_ListMemoryStoreSortedMapItems`
+* response.
+*
+* @since 0.1.0
+*/
+interface ListSortedMapItemsResult {
+  /** Items returned in the current page, ordered per `orderBy`. */
+  readonly items: ReadonlyArray<SortedMapItem>;
+  /**
+  * Page token for the next call, or `undefined` when no more pages
+  * exist. Pass back through `pageToken` to retrieve the next page.
+  */
+  readonly nextPageToken: string | undefined;
+}
+/**
+* Caller-supplied input for the `delete` method on
+* `StorageClient.sortedMaps`. Mirrors
+* `Cloud_DeleteMemoryStoreSortedMapItem` on the Open Cloud API.
+*
+* @since 0.1.0
+*/
+interface DeleteSortedMapItemParameters {
+  /** Caller-supplied item identifier. URL-encoded by the builder. */
+  readonly itemId: string;
+  /** Stringified sorted-map identifier. */
+  readonly mapId: string;
+  /** Stringified ID of the universe that owns the sorted map. */
+  readonly universeId: string;
+}
+/**
+* Caller-supplied input for the `get` method on
+* `StorageClient.sortedMaps`. Mirrors
+* `Cloud_GetMemoryStoreSortedMapItem` on the Open Cloud API.
+*
+* @since 0.1.0
+*/
+interface GetSortedMapItemParameters {
+  /** Caller-supplied item identifier. URL-encoded by the builder. */
+  readonly itemId: string;
+  /** Stringified sorted-map identifier. */
+  readonly mapId: string;
+  /** Stringified ID of the universe that owns the sorted map. */
+  readonly universeId: string;
+}
+/**
+* Caller-supplied input for the `update` method on
+* `StorageClient.sortedMaps`. Mirrors
+* `Cloud_UpdateMemoryStoreSortedMapItem` on the Open Cloud API. Body
+* fields (`value`, `ttl`, `sortKey`) are optional under PATCH
+* semantics; omitted fields are left unchanged on the server.
+*
+* @since 0.1.0
+*/
+interface UpdateSortedMapItemParameters {
+  /**
+  * When `true`, the server creates the item if it does not exist
+  * instead of returning 404. Travels as the `allowMissing` query
+  * string parameter.
+  */
+  readonly allowMissing?: boolean;
+  /** Caller-supplied item identifier. URL-encoded by the builder. */
+  readonly itemId: string;
+  /** Stringified sorted-map identifier. */
+  readonly mapId: string;
+  /**
+  * Replacement sort key. Either kind of {@link SortKey} resets the
+  * field on the wire; omit the field to leave the existing sort key
+  * untouched.
+  */
+  readonly sortKey?: SortKey;
+  /**
+  * Replacement time-to-live in seconds. Omitted entries leave the
+  * existing TTL unchanged.
+  */
+  readonly ttl?: number;
+  /** Stringified ID of the universe that owns the sorted map. */
+  readonly universeId: string;
+  /** Replacement value. Omitted entries leave the existing value unchanged. */
+  readonly value?: JSONValue;
+}
+//#endregion
 //#region src/internal/http/rate-limit-queue.d.ts
 /**
 * Identifies and bounds a single Roblox Open Cloud operation for rate
@@ -126,32 +335,6 @@ interface OperationLimit {
   readonly operationKey: string;
 }
 //#endregion
-//#region src/internal/http/retry.d.ts
-/**
-* Fully-resolved retry config shape that {@link mergeConfig} and
-* {@link shouldRetry} operate on. Fields are required because this represents
-* the post-defaulting, internal view — callers should supply every field (or
-* resolve them via a test factory / client constructor). The partial,
-* user-facing type lives on client construction options; method defaults and
-* per-request overrides use `Partial<RetryResolvable>`.
-*/
-interface RetryResolvable {
-  /** Roblox Open Cloud API key. */
-  readonly apiKey: string;
-  /** Base URL for the Open Cloud API. */
-  readonly baseUrl: string;
-  /** Maximum retry attempts before giving up. */
-  readonly maxRetries: number;
-  /** Status codes that are eligible for retry. */
-  readonly retryableStatuses: ReadonlyArray<number>;
-  /** Fallback delay function when no server hint is available. */
-  readonly retryDelay: (attempt: number) => number;
-  /** Per-request timeout in milliseconds. */
-  readonly timeout: number;
-}
-/** Kind of HTTP method the merge is being performed for. */
-type MethodKind = "create" | "idempotent";
-//#endregion
 //#region src/internal/resource-client.d.ts
 /**
 * Describes a single resource method's shape for dispatch through
@@ -344,17 +527,117 @@ declare class MemoryStoreQueuesGroup {
   enqueue(parameters: EnqueueQueueItemParameters, options?: RequestOptions): Promise<Result<QueueItem, OpenCloudError>>;
 }
 //#endregion
+//#region src/resources/storage/sorted-maps-group.d.ts
+/**
+* Operation Group on `StorageClient` that exposes the memory-store
+* sorted-map endpoints. Sorted maps are ordered collections of
+* (id, value, sortKey) triples; consumers create, read, update, list,
+* and delete items keyed by a caller-supplied identifier and ordered
+* by an optional string or numeric sort key.
+*/
+declare class MemoryStoreSortedMapsGroup {
+  #private;
+  /**
+  * Wraps the shared {@link ResourceClient} so the Operation Group
+  * routes calls through the same retry, hooks, and rate-limit queues
+  * as the rest of the parent client.
+  *
+  * @param inner - The shared {@link ResourceClient} owned by the
+  *   parent client.
+  */
+  constructor(inner: ResourceClient);
+  /**
+  * Creates a single item in a sorted map. The sorted map is
+  * auto-created on first use; the map identifier is any string the
+  * caller picks. Items are keyed by `itemId` (case-sensitive) and
+  * ordered by an optional `sortKey`. Items expire and are removed
+  * automatically after `ttl` seconds, or after a server-default
+  * lifetime when omitted.
+  *
+  * On 5xx, create does not retry: Roblox Open Cloud has no
+  * idempotency-key support, so a retry of a transient failure risks
+  * producing a duplicate item.
+  *
+  * @param parameters - Universe, sorted-map, item identifiers, the
+  *   value to store, and optional `sortKey` and `ttl`.
+  * @param options - Optional per-request overrides (e.g. A different
+  *   {@link OpenCloudClientOptions.apiKey} for this call only).
+  * @returns A {@link Result} wrapping the parsed {@link SortedMapItem}
+  *   or the {@link OpenCloudError} that caused the request to fail.
+  */
+  create(parameters: CreateSortedMapItemParameters, options?: RequestOptions): Promise<Result<SortedMapItem, OpenCloudError>>;
+  /**
+  * Removes a single item from a sorted map. The call is idempotent:
+  * a second `delete` against the same item is a no-op once the
+  * server has dropped the row. The retry policy retries both 429
+  * and 5xx.
+  *
+  * @param parameters - Universe, sorted-map, and item identifiers.
+  * @param options - Optional per-request overrides.
+  * @returns A {@link Result} wrapping `undefined` on success or the
+  *   {@link OpenCloudError} that caused the request to fail.
+  */
+  delete(parameters: DeleteSortedMapItemParameters, options?: RequestOptions): Promise<Result<undefined, OpenCloudError>>;
+  /**
+  * Reads a single item from a sorted map. Returns the parsed
+  * {@link SortedMapItem} with the server-recorded `etag` for use in
+  * subsequent conditional updates (once the SDK begins emitting
+  * `If-Match`; see the package README).
+  *
+  * @param parameters - Universe, sorted-map, and item identifiers.
+  * @param options - Optional per-request overrides.
+  * @returns A {@link Result} wrapping the parsed {@link SortedMapItem}
+  *   or the {@link OpenCloudError} that caused the request to fail.
+  */
+  get(parameters: GetSortedMapItemParameters, options?: RequestOptions): Promise<Result<SortedMapItem, OpenCloudError>>;
+  /**
+  * Lists items in a sorted map. The server caps `maxPageSize` at
+  * `100` and defaults it to `1` when omitted, so callers explicitly
+  * pass `maxPageSize` to retrieve more than a single item per page.
+  * The `filter` parameter accepts a CEL expression on `id` and
+  * `sortKey` (operators `<`, `>`, `&&` only).
+  *
+  * @param parameters - Universe and sorted-map identifiers, plus
+  *   optional pagination and filter parameters.
+  * @param options - Optional per-request overrides.
+  * @returns A {@link Result} wrapping the parsed
+  *   {@link ListSortedMapItemsResult} or the {@link OpenCloudError}
+  *   that caused the request to fail.
+  */
+  list(parameters: ListSortedMapItemsParameters, options?: RequestOptions): Promise<Result<ListSortedMapItemsResult, OpenCloudError>>;
+  /**
+  * Updates a sorted-map item under PATCH semantics: omitted body
+  * fields are left unchanged on the server, supplied fields replace
+  * their existing values. Passing `allowMissing: true` creates the
+  * item when no row exists instead of returning 404.
+  *
+  * Retries 5xx because PATCH with the same body produces the same
+  * server state.
+  *
+  * @param parameters - Universe, sorted-map, and item identifiers,
+  *   plus any subset of `value`, `ttl`, `sortKey`, and
+  *   `allowMissing`.
+  * @param options - Optional per-request overrides.
+  * @returns A {@link Result} wrapping the parsed {@link SortedMapItem}
+  *   or the {@link OpenCloudError} that caused the request to fail.
+  */
+  update(parameters: UpdateSortedMapItemParameters, options?: RequestOptions): Promise<Result<SortedMapItem, OpenCloudError>>;
+}
+//#endregion
 //#region src/resources/storage/client.d.ts
 /**
 * Public client for the Roblox Open Cloud `Data and memory stores`
 * Feature. Today it covers memory-store queues via the
-* {@link StorageClient.queues} Operation Group; future Operation
-* Groups for sorted maps and data stores slot in as siblings on the
-* same client.
+* {@link StorageClient.queues} Operation Group and memory-store sorted
+* maps via the {@link StorageClient.sortedMaps} Operation Group; a
+* future data-stores Operation Group slots in as a sibling on the same
+* client.
 *
 * Every method returns a `Result` so callers handle failure
 * explicitly; no thrown error ever escapes the client.
 *
+* @since 0.1.0
+*
 * @example
 *
 * ```ts
@@ -367,6 +650,8 @@ declare class MemoryStoreQueuesGroup {
 declare class StorageClient {
   /** Memory-store queue Operation Group. */
   readonly queues: MemoryStoreQueuesGroup;
+  /** Memory-store sorted-map Operation Group. */
+  readonly sortedMaps: MemoryStoreSortedMapsGroup;
   /**
   * Creates a new {@link StorageClient}. Configuration is frozen on
   * construction; per-request overrides are accepted on each method.
@@ -376,5 +661,5 @@ declare class StorageClient {
   constructor(options: OpenCloudClientOptions);
 }
 //#endregion
-export { type DequeueQueueItemsParameters, type DequeueResult, type DiscardQueueItemsParameters, type EnqueueQueueItemParameters, type QueueItem, StorageClient };
+export { type CreateSortedMapItemParameters, type DeleteSortedMapItemParameters, type DequeueQueueItemsParameters, type DequeueResult, type DiscardQueueItemsParameters, type EnqueueQueueItemParameters, type GetSortedMapItemParameters, type ListSortedMapItemsParameters, type ListSortedMapItemsResult, type QueueItem, type SortKey, type SortedMapItem, StorageClient, type UpdateSortedMapItemParameters };
 //# sourceMappingURL=storage.d.mts.map

package/dist/storage.d.mts.map

@@ -1 +1 @@
-{"version":3,"file":"storage.d.mts","names":[],"sources":["../src/domains/cloud-v2/memory-store-queues/types.ts","../src/internal/http/rate-limit-queue.ts","../src/internal/http/retry.ts","../src/internal/resource-client.ts","../src/resources/storage/queues-group.ts","../src/resources/storage/client.ts"],"mappings":";;;;;;AAIA;UAAiB,0BAAA;;;;;;;WAOP,IAAA,EAAM,OAAA,CAAQ,SAAA;;;;;AAwBxB;WAlBU,QAAA;;WAEA,OAAA;;;;;;WAMA,GAAA;;WAEA,UAAA;AAAA;;;;;;UAQO,SAAA;EAsBjB;EAAA,SApBU,EAAA;;;;;WAKA,IAAA,EAAM,OAAA,CAAQ,SAAA;;WAEd,SAAA,EAAW,IAAA;;WAEX,QAAA;EAyCV;EAAA,SAvCU,OAAA;;WAEA,UAAA;AAAA;;;;;UAOO,2BAAA;EA+CjB;;;;;EAAA,SAzCU,YAAA;;;;;WAKA,KAAA;;AC7DV;;;;WDmEU,kBAAA;;WAEA,OAAA;;WAEA,UAAA;AAAA;;;;;;;UASO,aAAA;;WAEP,KAAA,EAAO,aAAA,CAAc,SAAA;;;;AE3C/B;WFgDU,MAAA;AAAA;;;;;;AGxDV;;UHkEiB,2BAAA;;WAEP,OAAA;;WAEA,MAAA;;WAEA,UAAA;AAAA;;;;AA1GV;;;UCGiB,cAAA;;WAEP,YAAA;;;;;;WAMA,YAAA;AAAA;;;;ADXV;;;;;;;UEOiB,eAAA;;WAEP,MAAA;;WAEA,OAAA;EFYA;EAAA,SEVA,UAAA;EFkBO;EAAA,SEhBP,iBAAA,EAAmB,aAAA;;WAEnB,UAAA,GAAa,OAAA;;WAEb,OAAA;AAAA;AFkCV;AAAA,KEXY,UAAA;;;;;;;;;;;;;;AFXZ;UGGiB,kBAAA;;;;;;;;WAQP,YAAA,GAAe,UAAA,EAAY,CAAA,KAAM,MAAA,CAAO,WAAA,EAAa,cAAA;;WAErD,cAAA,EAAgB,OAAA,CAAQ,eAAA;;;;;AHSlC;;WGFU,UAAA,EAAY,UAAA;EHEL;EAAA,SGAP,cAAA,EAAgB,cAAA;;;;;;WAMhB,KAAA,GAAQ,QAAA,EAAU,YAAA,KAAiB,MAAA,CAAO,CAAA,EAAG,cAAA;EHwBvD;;;;;;;;;EAAA,SGdU,cAAA,GAAiB,aAAA;AAAA;;;;;;;;;UAWjB,WAAA;EF7EO;EAAA,SE+EP,OAAA,GAAU,cAAA;EF/EH;EAAA,SEiFP,UAAA,EAAY,CAAA;;WAEZ,IAAA,EAAM,kBAAA,CAAmB,CAAA,EAAG,CAAA;AAAA;AD/EtC;;;;;;;;;;;;;AC2BA;;;;;cAgGa,cAAA;EAAA;;;;;;;;;EAeZ,WAAA,CAAY,OAAA,EAAS,sBAAA;;;;;;;;;;;;;EAyBrB,OAAA,MAAA,CAA2B,IAAA,EAAM,WAAA,CAAY,CAAA,EAAG,CAAA,IAAK,OAAA,CAAQ,MAAA,CAAO,CAAA,EAAG,cAAA;;;;;;MAsC5D,KAAA,CAAA,GAAS,SAAA;AAAA;;;;;;;;;;cCtIR,sBAAA;EAAA;;;AJ3Cb;;;;;;EIsDC,WAAA,CAAY,KAAA,EAAO,cAAA;EJ7CC;;;;;;;;;;;;AAarB;;;;;;;;EIwDC,OAAA,CACC,UAAA,EAAY,2BAAA,EACZ,OAAA,GAAU,cAAA,GACR,OAAA,CAAQ,MAAA,CAAO,aAAA,EAAe,cAAA;;;AJ7BlC;;;;;;;;;;AAiBA;;;;;EIiCC,OAAA,CACC,UAAA,EAAY,2BAAA,EACZ,OAAA,GAAU,cAAA,GACR,OAAA,CAAQ,MAAA,YAAkB,cAAA;;;;;;;AHrI9B;;;;;;;;ACIA;EEoJC,OAAA,CACC,UAAA,EAAY,0BAAA,EACZ,OAAA,GAAU,cAAA,GACR,OAAA,CAAQ,MAAA,CAAO,SAAA,EAAW,cAAA;AAAA;;;;AJ9J9B;;;;;;;;;;;;;AA+BA;;;;;cKZa,aAAA;;WAEI,MAAA,EAAQ,sBAAA;;;;;;;EAQxB,WAAA,CAAY,OAAA,EAAS,sBAAA;AAAA"}
+{"version":3,"file":"storage.d.mts","names":[],"sources":["../src/domains/cloud-v2/memory-store-queues/types.ts","../src/domains/cloud-v2/memory-store-sorted-maps/types.ts","../src/internal/http/rate-limit-queue.ts","../src/internal/resource-client.ts","../src/resources/storage/queues-group.ts","../src/resources/storage/sorted-maps-group.ts","../src/resources/storage/client.ts"],"mappings":";;;;;;;;AAMA;;UAAiB,0BAAA;EAOD;;;;;;EAAA,SAAN,IAAA,EAAM,OAAA,CAAQ,SAAA;;;AAgBd;AAUV;;WApBU,QAAA;;WAEA,OAAA;;;;;;WAMA,GAAA;;WAEA,UAAA;AAAA;;;;;AAyBA;AASV;;UAxBiB,SAAA;EAwBA;EAAA,SAtBP,EAAA;;;;;WAKA,IAAA,EAAM,OAAA,CAAQ,SAAA;EAsCd;EAAA,SApCA,SAAA,EAAW,IAAA;EA+CJ;EAAA,SA7CP,QAAA;EA+CO;EAAA,SA7CP,OAAA;;WAEA,UAAA;AAAA;;AAgDA;AAYV;;;;UAnDiB,2BAAA;;;;AAyDP;;WAnDA,YAAA;;AC7DV;;;WDkEU,KAAA;;;;;;WAMA,kBAAA;EC7DV;EAAA,SD+DU,OAAA;;WAEA,UAAA;AAAA;;;;;;;;;UAWO,aAAA;EC1CjB;EAAA,SD4CU,KAAA,EAAO,aAAA,CAAc,SAAA;;;;;WAKrB,MAAA;AAAA;;;;ACxBA;AASV;;;;;UD2BiB,2BAAA;ECFA;EAAA,SDIP,OAAA;;WAEA,MAAA;;WAEA,UAAA;AAAA;;;;;;;AAlHV;;;;KCEY,OAAA;EAAA,SACE,IAAA;EAAA,SAA0B,KAAA;AAAA;EAAA,SAC1B,IAAA;EAAA,SAAyB,KAAA;AAAA;;ADmB7B;AAUV;;;;;UCpBiB,6BAAA;ED6BI;;;;EAAA,SCxBX,MAAA;;WAEA,KAAA;;WAEA,OAAA,GAAU,OAAA;;;;AD0BV;AASV;WC7BU,GAAA;;WAEA,UAAA;;;;;WAKA,KAAA,EAAO,SAAA;AAAA;AD2CP;AAWV;;;;;;;;AAXU,UC/BO,4BAAA;EDiDP;AAYV;;;;EAZU,SC3CA,MAAA;;WAEA,KAAA;ED2DA;AAAA;;;EAAA,SCtDA,WAAA;EA1DV;;;;EAAA,SA+DU,OAAA;;;;;WAKA,SAAA;EAzDV;EAAA,SA2DU,UAAA;AAAA;;;;;;;UASO,aAAA;;WAEP,EAAA;EAhDO;AAAA;AAYjB;;;EAZiB,SAsDP,IAAA;;WAEA,SAAA,EAAW,IAAA;;WAEX,KAAA;;;;AArBA;AASV;WAkBU,OAAA,EAAS,OAAA;;WAET,UAAA;;;;;WAKA,KAAA,EAAO,SAAA;AAAA;;;;;;;UASA,wBAAA;;WAEP,KAAA,EAAO,aAAA,CAAc,aAAA;EAXd;AASjB;;;EATiB,SAgBP,aAAA;AAAA;;;;;AAAA;AAUV;;UAAiB,6BAAA;EAAA;EAAA,SAEP,MAAA;;WAEA,KAAA;EAEA;EAAA,SAAA,UAAA;AAAA;;;;;;;;UAUO,0BAAA;EAkBjB;EAAA,SAhBU,MAAA;;WAEA,KAAA;;WAEA,UAAA;AAAA;;;;;;;;AAqCQ;;UAzBD,6BAAA;;ACrKjB;;;;WD2KU,YAAA;;WAEA,MAAA;;WAEA,KAAA;EE5IO;;;;;EAAA,SFkJP,OAAA,GAAU,OAAA;;;;;WAKV,GAAA;;WAEA,UAAA;;WAEA,KAAA,GAAQ,SAAA;AAAA;;;;;AD/LlB;;UECiB,cAAA;EFMD;EAAA,SEJN,YAAA;;;;;;WAMA,YAAA;AAAA;;;;;;;;;;;;;;AFcA;UGaO,kBAAA;;;;;;;;WAQP,YAAA,GAAe,UAAA,EAAY,CAAA,KAAM,MAAA,CAAO,WAAA,EAAa,cAAA;;WAErD,cAAA,EAAgB,OAAA,CAAQ,eAAA;;;;;AHExB;AASV;WGJU,UAAA,EAAY,UAAA;;WAEZ,cAAA,EAAgB,cAAA;;;;;;WAMhB,KAAA,GAAQ,QAAA,EAAU,YAAA,KAAiB,MAAA,CAAO,CAAA,EAAG,cAAA;EHiB7C;AAWV;;;;;;;;EAXU,SGPA,cAAA,GAAiB,aAAA;AAAA;AHqC3B;;;;;;;;AAAA,UG1BU,WAAA;EFhFV;EAAA,SEkFU,OAAA,GAAU,cAAA;;WAEV,UAAA,EAAY,CAAA;;WAEZ,IAAA,EAAM,kBAAA,CAAmB,CAAA,EAAG,CAAA;AAAA;;;AFpFC;AASvC;;;;;;;;;;;;;;;cEoIa,cAAA;EAAA;EFhEb;;;;;;;;EEgFC,WAAA,CAAY,OAAA,EAAS,sBAAA;;;;;;;;;;;AFvDL;AASjB;EEwEC,OAAA,OAA2B,IAAA,EAAM,WAAA,CAAY,CAAA,EAAG,CAAA,IAAK,OAAA,CAAQ,MAAA,CAAO,CAAA,EAAG,cAAA;;;;;AFjE9D;MEmGE,KAAA,IAAS,SAAA;AAAA;;;;;;;;;;cCrJR,sBAAA;EAAA;;;AJjDH;AAUV;;;;;EIkDC,WAAA,CAAY,KAAA,EAAO,cAAA;EJzCC;;;;;;;;;;;;AAMX;AASV;;;;;;;EIkDC,OAAA,CACC,UAAA,EAAY,2BAAA,EACZ,OAAA,GAAU,cAAA,GACR,OAAA,CAAQ,MAAA,CAAO,aAAA,EAAe,cAAA;;;AJhCxB;AAWV;;;;;;;;;AAOU;AAYV;;;;EIuBC,OAAA,CACC,UAAA,EAAY,2BAAA,EACZ,OAAA,GAAU,cAAA,GACR,OAAA,CAAQ,MAAA,YAAkB,cAAA;;;;AJpBpB;;;;AChHV;;;;;;;;EGuJC,OAAA,CACC,UAAA,EAAY,0BAAA,EACZ,OAAA,GAAU,cAAA,GACR,OAAA,CAAQ,MAAA,CAAO,SAAA,EAAW,cAAA;AAAA;;;;;;;;;;cC/DjB,0BAAA;EAAA;;;ALtEH;AAUV;;;;;EKuEC,WAAA,CAAY,KAAA,EAAO,cAAA;EL9DC;;;;;;;;;;;;AAMX;AASV;;;;;;EKsEC,MAAA,CACC,UAAA,EAAY,6BAAA,EACZ,OAAA,GAAU,cAAA,GACR,OAAA,CAAQ,MAAA,CAAO,aAAA,EAAe,cAAA;;;;ALpDxB;AAWV;;;;;;;EKwDC,MAAA,CACC,UAAA,EAAY,6BAAA,EACZ,OAAA,GAAU,cAAA,GACR,OAAA,CAAQ,MAAA,YAAkB,cAAA;ELpDpB;AAAA;AAYV;;;;;;;;AAMU;EKiDT,GAAA,CACC,UAAA,EAAY,0BAAA,EACZ,OAAA,GAAU,cAAA,GACR,OAAA,CAAQ,MAAA,CAAO,aAAA,EAAe,cAAA;;;AJpKlC;;;;;;;;;AAEuC;AASvC;;EI2KC,IAAA,CACC,UAAA,EAAY,4BAAA,EACZ,OAAA,GAAU,cAAA,GACR,OAAA,CAAQ,MAAA,CAAO,wBAAA,EAA0B,cAAA;EJxJ5B;;;;;;;;;;AAAA;AAYjB;;;;;EIgKC,MAAA,CACC,UAAA,EAAY,6BAAA,EACZ,OAAA,GAAU,cAAA,GACR,OAAA,CAAQ,MAAA,CAAO,aAAA,EAAe,cAAA;AAAA;;;;ALlNlC;;;;;;;;;;;;AAuBU;AAUV;;;;;;;;cMZa,aAAA;;WAEI,MAAA,EAAQ,sBAAA;;WAER,UAAA,EAAY,0BAAA;;;;;;ANuBnB;EMfT,WAAA,CAAY,OAAA,EAAS,sBAAA;AAAA"}