@bedrock-rbx/ocale 0.1.0-beta.1 → 0.1.0-beta.10

package/dist/storage.mjs

@@ -0,0 +1,858 @@
+import { r as ApiError } from "./rate-limit-D1q2Js-z.mjs";
+import { a as IDEMPOTENT_METHOD_DEFAULTS, c as isDateTimeString, i as CREATE_METHOD_DEFAULTS, n as okRequest, r as parseEmptyResponse, s as isRecord, t as ResourceClient } from "./resource-client-D6Efj9fU.mjs";
+//#region src/domains/cloud-v2/memory-store-queues/builders.ts
+/**
+* Builds a `POST` request for the Open Cloud
+* `Cloud_CreateMemoryStoreQueueItem` endpoint. Serializes the optional
+* `ttl` field as a Google protobuf `Duration` string in seconds (`"30s"`)
+* to match the wire contract.
+*
+* @param parameters - Universe and queue identifiers, the opaque payload,
+*   and optional priority and TTL.
+* @returns A pure {@link HttpRequest} describing the enqueue call.
+*/
+function buildEnqueueRequest(parameters) {
+	const { data, priority, queueId, ttl, universeId } = parameters;
+	const body = { data };
+	if (priority !== void 0) body["priority"] = priority;
+	if (ttl !== void 0) body["ttl"] = `${ttl}s`;
+	return {
+		body,
+		headers: { "content-type": "application/json" },
+		method: "POST",
+		url: `/cloud/v2/universes/${universeId}/memory-store/queues/${queueId}/items`
+	};
+}
+/**
+* Builds a `GET` request for the Open Cloud
+* `Cloud_ReadMemoryStoreQueueItems` endpoint. The `:read` suffix is a
+* custom-method marker; the call is HTTP `GET` despite the AIP-136
+* convention that custom methods use `POST`. Parameters travel as query
+* string only; there is no request body.
+*
+* `invisibilityWindow` is serialized as a Google protobuf `Duration`
+* string in seconds (`"30s"`), matching the wire contract.
+*
+* @param parameters - Universe and queue identifiers, plus optional
+*   `count`, `allOrNothing`, and `invisibilityWindow`.
+* @returns A pure {@link HttpRequest} describing the dequeue call.
+*/
+function buildDequeueRequest(parameters) {
+	const query = new URLSearchParams();
+	if (parameters.count !== void 0) query.append("count", String(parameters.count));
+	if (parameters.allOrNothing !== void 0) query.append("allOrNothing", String(parameters.allOrNothing));
+	if (parameters.invisibilityWindow !== void 0) query.append("invisibilityWindow", `${parameters.invisibilityWindow}s`);
+	const queryString = query.toString();
+	const { queueId, universeId } = parameters;
+	const base = `/cloud/v2/universes/${universeId}/memory-store/queues/${queueId}/items:read`;
+	return {
+		method: "GET",
+		url: queryString === "" ? base : `${base}?${queryString}`
+	};
+}
+/**
+* Builds a `POST` request for the Open Cloud
+* `Cloud_DiscardMemoryStoreQueueItems` endpoint. The request body uses
+* `{ readId }`, matching the schema (the dequeue *response* uses `id`,
+* but the discard *request* matches the schema and is not patched).
+*
+* @param parameters - Universe and queue identifiers, plus the
+*   `readId` returned from a prior dequeue.
+* @returns A pure {@link HttpRequest} describing the discard call.
+*/
+function buildDiscardRequest(parameters) {
+	const { queueId, readId, universeId } = parameters;
+	return {
+		body: { readId },
+		headers: { "content-type": "application/json" },
+		method: "POST",
+		url: `/cloud/v2/universes/${universeId}/memory-store/queues/${queueId}/items:discard`
+	};
+}
+//#endregion
+//#region src/domains/cloud-v2/memory-store-queues/operations.ts
+const ENQUEUE_PER_MINUTE = 1e6;
+const SECONDS_PER_MINUTE$1 = 60;
+/**
+* Per-second request ceiling for enqueueing a memory-store queue item,
+* from the Open Cloud OpenAPI schema (1,000,000 requests per minute per
+* API key owner). Keyed independently from the dequeue and discard
+* operations so the three do not share a queue; upstream quota
+* accounting is documented per-operation, and the conservative default
+* is fewer cross-method contention surprises.
+*/
+const ENQUEUE_OPERATION_LIMIT = Object.freeze({
+	maxPerSecond: ENQUEUE_PER_MINUTE / SECONDS_PER_MINUTE$1,
+	operationKey: "memory-store-queues.enqueue"
+});
+/**
+* Scopes required to enqueue a memory-store queue item, sourced from
+* `x-roblox-scopes` on the `Cloud_CreateMemoryStoreQueueItem` operation
+* in the vendored OpenAPI schema.
+*/
+const ENQUEUE_REQUIRED_SCOPES = Object.freeze(["memory-store.queue:add"]);
+/**
+* Per-second request ceiling for dequeueing memory-store queue items,
+* from the Open Cloud OpenAPI schema (1,000,000 requests per minute
+* per API key owner). Keyed independently from enqueue and discard.
+*/
+const DEQUEUE_OPERATION_LIMIT = Object.freeze({
+	maxPerSecond: 1e6 / SECONDS_PER_MINUTE$1,
+	operationKey: "memory-store-queues.dequeue"
+});
+/**
+* Scopes required to dequeue memory-store queue items, sourced from
+* `x-roblox-scopes` on the `Cloud_ReadMemoryStoreQueueItems` operation
+* in the vendored OpenAPI schema.
+*/
+const DEQUEUE_REQUIRED_SCOPES = Object.freeze(["memory-store.queue:dequeue"]);
+/**
+* Per-second request ceiling for discarding (acknowledging) memory-store
+* queue items, from the Open Cloud OpenAPI schema (1,000,000 requests
+* per minute per API key owner). Keyed independently from enqueue and
+* dequeue.
+*/
+const DISCARD_OPERATION_LIMIT = Object.freeze({
+	maxPerSecond: 1e6 / SECONDS_PER_MINUTE$1,
+	operationKey: "memory-store-queues.discard"
+});
+/**
+* Scopes required to discard memory-store queue items, sourced from
+* `x-roblox-scopes` on the `Cloud_DiscardMemoryStoreQueueItems`
+* operation in the vendored OpenAPI schema.
+*/
+const DISCARD_REQUIRED_SCOPES = Object.freeze(["memory-store.queue:discard"]);
+//#endregion
+//#region src/domains/cloud-v2/memory-store-queues/parsers.ts
+const PATH_PATTERN$1 = /^cloud\/v2\/universes\/(\d+)\/memory-store\/queues\/([^/]+)\/items\/([^/]+)$/;
+const MALFORMED_QUEUE_ITEM_MESSAGE = "Malformed memory-store queue item response";
+const MALFORMED_DEQUEUE_MESSAGE = "Malformed memory-store dequeue response";
+/**
+* Parses a successful memory-store queue-item response body (the
+* `Cloud_CreateMemoryStoreQueueItem` happy path) into the public
+* {@link QueueItem} shape.
+*
+* @param response - The full {@link HttpResponse} from the Open Cloud API.
+* @returns A success result wrapping the parsed {@link QueueItem}, or an
+*   {@link ApiError} when the body does not match the wire schema.
+*/
+function parseQueueItemResponse(response) {
+	const item = wireBodyToQueueItem(response.body);
+	if (item === void 0) return malformedQueueItem(response.status);
+	return {
+		data: item,
+		success: true
+	};
+}
+/**
+* Parses a successful `Cloud_ReadMemoryStoreQueueItems` response body
+* into the public {@link DequeueResult} shape. Each item in the
+* `queueItems` array is validated through the same path-and-shape
+* checks as {@link parseQueueItemResponse}; a malformed entry rejects
+* the whole response.
+*
+* @param response - The full {@link HttpResponse} from the Open Cloud API.
+* @returns A success result wrapping the parsed {@link DequeueResult},
+*   or an {@link ApiError} when the response shape is wrong.
+*/
+function parseDequeueResponse(response) {
+	const { body, status: statusCode } = response;
+	if (!isRecord(body)) return malformedDequeue(statusCode);
+	const { id, queueItems } = body;
+	if (typeof id !== "string") return malformedDequeue(statusCode);
+	if (queueItems !== void 0 && queueItems !== null && !Array.isArray(queueItems)) return malformedDequeue(statusCode);
+	const items = (queueItems ?? []).map(wireBodyToQueueItem);
+	if (!items.every(isQueueItem)) return malformedDequeue(statusCode);
+	return {
+		data: {
+			items,
+			readId: id
+		},
+		success: true
+	};
+}
+function isQueueItemWire(body) {
+	if (!isRecord(body)) return false;
+	const { data, expireTime, path, priority } = body;
+	return typeof path === "string" && isDateTimeString(expireTime) && data !== void 0 && data !== null && (priority === void 0 || priority === null || typeof priority === "number");
+}
+function wireBodyToQueueItem(body) {
+	if (!isQueueItemWire(body)) return;
+	const match = PATH_PATTERN$1.exec(body.path);
+	const universeId = match?.[1];
+	const queueId = match?.[2];
+	const id = match?.[3];
+	if (universeId === void 0 || queueId === void 0 || id === void 0) return;
+	return {
+		id,
+		data: body.data,
+		expiresAt: new Date(body.expireTime),
+		priority: body.priority ?? void 0,
+		queueId,
+		universeId
+	};
+}
+function malformedQueueItem(statusCode) {
+	return {
+		err: new ApiError(MALFORMED_QUEUE_ITEM_MESSAGE, { statusCode }),
+		success: false
+	};
+}
+function isQueueItem(item) {
+	return item !== void 0;
+}
+function malformedDequeue(statusCode) {
+	return {
+		err: new ApiError(MALFORMED_DEQUEUE_MESSAGE, { statusCode }),
+		success: false
+	};
+}
+//#endregion
+//#region src/resources/storage/queues-group.ts
+function makeSpec$1(spec) {
+	return Object.freeze(spec);
+}
+const ENQUEUE_SPEC = makeSpec$1({
+	buildRequest: (parameters) => okRequest(buildEnqueueRequest(parameters)),
+	methodDefaults: CREATE_METHOD_DEFAULTS,
+	methodKind: "create",
+	operationLimit: ENQUEUE_OPERATION_LIMIT,
+	parse: parseQueueItemResponse,
+	requiredScopes: ENQUEUE_REQUIRED_SCOPES
+});
+const DEQUEUE_SPEC = makeSpec$1({
+	buildRequest: (parameters) => okRequest(buildDequeueRequest(parameters)),
+	methodDefaults: CREATE_METHOD_DEFAULTS,
+	methodKind: "create",
+	operationLimit: DEQUEUE_OPERATION_LIMIT,
+	parse: parseDequeueResponse,
+	requiredScopes: DEQUEUE_REQUIRED_SCOPES
+});
+const DISCARD_SPEC = makeSpec$1({
+	buildRequest: (parameters) => okRequest(buildDiscardRequest(parameters)),
+	methodDefaults: IDEMPOTENT_METHOD_DEFAULTS,
+	methodKind: "idempotent",
+	operationLimit: DISCARD_OPERATION_LIMIT,
+	parse: parseEmptyResponse,
+	requiredScopes: DISCARD_REQUIRED_SCOPES
+});
+/**
+* Operation Group on `StorageClient` that exposes the memory-store
+* queue endpoints. Queues are FIFO collections of opaque JSON values
+* with optional priority and TTL; consumers enqueue items, dequeue
+* them in batches, and acknowledge processed batches with a read
+* identifier.
+*/
+var MemoryStoreQueuesGroup = class {
+	#inner;
+	/**
+	* 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) {
+		this.#inner = inner;
+	}
+	/**
+	* Dequeues up to `count` items from the front of the queue. Items
+	* returned become invisible to subsequent reads for
+	* `invisibilityWindow` seconds (default 30 server-side); they
+	* reappear once the window elapses unless acknowledged via
+	* `discard` with the returned `readId`.
+	*
+	* On 5xx, dequeue does not retry: the server may have set
+	* invisibility on a batch before the response failed, so a retry
+	* would return a *different* batch and the first one is lost until
+	* the window expires. Callers that can detect duplicates externally
+	* may opt back into 5xx retry per call by passing `retryableStatuses`
+	* on `options`.
+	*
+	* @param parameters - Universe and queue identifiers, plus optional
+	*   `count`, `allOrNothing`, and `invisibilityWindow`.
+	* @param options - Optional per-request overrides.
+	* @returns A {@link Result} wrapping the parsed {@link DequeueResult}
+	*   or the {@link OpenCloudError} that caused the request to fail.
+	*/
+	async dequeue(parameters, options) {
+		return this.#inner.execute({
+			options,
+			parameters,
+			spec: DEQUEUE_SPEC
+		});
+	}
+	/**
+	* Acknowledges a dequeued batch of items, removing them from the
+	* queue permanently. Pass the `readId` returned from the prior
+	* `dequeue` call. Without `discard`, the items reappear once the
+	* invisibility window elapses.
+	*
+	* The call is idempotent: a second `discard` with the same `readId`
+	* is a no-op once the batch has been acknowledged. The retry policy
+	* therefore retries both 429 and 5xx.
+	*
+	* @param parameters - Universe and queue identifiers, plus the
+	*   `readId` returned from a prior dequeue.
+	* @param options - Optional per-request overrides.
+	* @returns A {@link Result} wrapping `undefined` on success (the
+	*   server returns an empty body) or the {@link OpenCloudError}
+	*   that caused the request to fail.
+	*/
+	async discard(parameters, options) {
+		return this.#inner.execute({
+			options,
+			parameters,
+			spec: DISCARD_SPEC
+		});
+	}
+	/**
+	* Enqueues a single item onto a memory-store queue. The queue is
+	* auto-created on first use; the queue identifier is any string the
+	* caller picks. Items with higher `priority` values are dequeued
+	* first; equal priorities preserve insertion order. Items expire
+	* and are removed automatically after `ttl` seconds, or after a
+	* server-default lifetime when omitted.
+	*
+	* @param parameters - Universe and queue identifiers, the opaque
+	*   payload, and optional `priority` 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 QueueItem} or
+	*   the {@link OpenCloudError} that caused the request to fail.
+	*/
+	async enqueue(parameters, options) {
+		return this.#inner.execute({
+			options,
+			parameters,
+			spec: ENQUEUE_SPEC
+		});
+	}
+};
+//#endregion
+//#region src/domains/cloud-v2/memory-store-sorted-maps/builders.ts
+/**
+* Builds a `POST` request for the Open Cloud
+* `Cloud_CreateMemoryStoreSortedMapItem` endpoint. The caller-supplied
+* `itemId` travels as the `id` query parameter (URL-encoded by
+* `URLSearchParams`); the body carries `value`, the optional `ttl`
+* (serialized as a Google protobuf `Duration` string in seconds), and
+* one of `stringSortKey`/`numericSortKey` projected from the
+* {@link SortKey} discriminated union.
+*
+* @param parameters - Universe, sorted-map, item identifiers, the
+*   value to store, and optional `sortKey` and `ttl`.
+* @returns A pure {@link HttpRequest} describing the create call.
+*/
+function buildCreateRequest(parameters) {
+	const { itemId, mapId, sortKey, ttl, universeId, value } = parameters;
+	const body = { value };
+	if (ttl !== void 0) body["ttl"] = `${ttl}s`;
+	applySortKeyToBody(body, sortKey);
+	const query = new URLSearchParams({ id: itemId });
+	return {
+		body,
+		headers: { "content-type": "application/json" },
+		method: "POST",
+		url: `/cloud/v2/universes/${encodeURIComponent(universeId)}/memory-store/sorted-maps/${encodeURIComponent(mapId)}/items?${query.toString()}`
+	};
+}
+/**
+* Builds a `DELETE` request for the Open Cloud
+* `Cloud_DeleteMemoryStoreSortedMapItem` endpoint. Every path segment
+* (universe, sorted-map, item identifiers) is URL-encoded so callers
+* can pass values containing reserved characters without manual
+* escaping.
+*
+* @param parameters - Universe, sorted-map, and item identifiers.
+* @returns A pure {@link HttpRequest} describing the delete call.
+*/
+function buildDeleteRequest(parameters) {
+	const { itemId, mapId, universeId } = parameters;
+	return {
+		method: "DELETE",
+		url: `/cloud/v2/universes/${encodeURIComponent(universeId)}/memory-store/sorted-maps/${encodeURIComponent(mapId)}/items/${encodeURIComponent(itemId)}`
+	};
+}
+/**
+* Builds a `GET` request for the Open Cloud
+* `Cloud_GetMemoryStoreSortedMapItem` endpoint. Every path segment
+* (universe, sorted-map, item identifiers) is URL-encoded so callers
+* can pass values containing reserved characters without manual
+* escaping.
+*
+* @param parameters - Universe, sorted-map, and item identifiers.
+* @returns A pure {@link HttpRequest} describing the get call.
+*/
+function buildGetRequest(parameters) {
+	const { itemId, mapId, universeId } = parameters;
+	return {
+		method: "GET",
+		url: `/cloud/v2/universes/${encodeURIComponent(universeId)}/memory-store/sorted-maps/${encodeURIComponent(mapId)}/items/${encodeURIComponent(itemId)}`
+	};
+}
+/**
+* Builds a `GET` request for the Open Cloud
+* `Cloud_ListMemoryStoreSortedMapItems` endpoint. Optional `filter`,
+* `maxPageSize`, `orderBy`, and `pageToken` parameters travel as query
+* string parameters and are omitted when unset.
+*
+* @param parameters - Universe and sorted-map identifiers, plus
+*   optional pagination and filter parameters.
+* @returns A pure {@link HttpRequest} describing the list call.
+*/
+function buildListRequest(parameters) {
+	const { filter, mapId, maxPageSize, orderBy, pageToken, universeId } = parameters;
+	const query = new URLSearchParams();
+	if (maxPageSize !== void 0) query.append("maxPageSize", String(maxPageSize));
+	if (pageToken !== void 0) query.append("pageToken", pageToken);
+	if (orderBy !== void 0) query.append("orderBy", orderBy);
+	if (filter !== void 0) query.append("filter", filter);
+	const base = `/cloud/v2/universes/${encodeURIComponent(universeId)}/memory-store/sorted-maps/${encodeURIComponent(mapId)}/items`;
+	const queryString = query.toString();
+	return {
+		method: "GET",
+		url: queryString === "" ? base : `${base}?${queryString}`
+	};
+}
+/**
+* Builds a `PATCH` request for the Open Cloud
+* `Cloud_UpdateMemoryStoreSortedMapItem` endpoint. Body fields are
+* conditionally included so a partial update sends only the changed
+* fields; the optional `allowMissing` query string drives
+* upsert-on-missing behaviour server-side.
+*
+* @param parameters - Universe, sorted-map, and item identifiers,
+*   plus any subset of `value`, `ttl`, `sortKey`, and `allowMissing`.
+* @returns A pure {@link HttpRequest} describing the update call.
+*/
+function buildUpdateRequest(parameters) {
+	const { allowMissing: shouldAllowMissing, itemId, mapId, universeId } = parameters;
+	const base = `/cloud/v2/universes/${encodeURIComponent(universeId)}/memory-store/sorted-maps/${encodeURIComponent(mapId)}/items/${encodeURIComponent(itemId)}`;
+	const query = new URLSearchParams();
+	if (shouldAllowMissing !== void 0) query.append("allowMissing", String(shouldAllowMissing));
+	const queryString = query.toString();
+	return {
+		body: buildUpdateBody(parameters),
+		headers: { "content-type": "application/json" },
+		method: "PATCH",
+		url: queryString === "" ? base : `${base}?${queryString}`
+	};
+}
+function applySortKeyToBody(body, sortKey) {
+	if (sortKey === void 0) return;
+	if (sortKey.kind === "string") {
+		body["stringSortKey"] = sortKey.value;
+		return;
+	}
+	body["numericSortKey"] = sortKey.value;
+}
+function buildUpdateBody(parameters) {
+	const { sortKey, ttl, value } = parameters;
+	const body = {};
+	if (value !== void 0) body["value"] = value;
+	if (ttl !== void 0) body["ttl"] = `${ttl}s`;
+	applySortKeyToBody(body, sortKey);
+	return body;
+}
+//#endregion
+//#region src/domains/cloud-v2/memory-store-sorted-maps/operations.ts
+const CREATE_PER_MINUTE = 1e6;
+const SECONDS_PER_MINUTE = 60;
+const WRITE_SCOPE = "memory-store.sorted-map:write";
+/**
+* Per-second request ceiling for creating a memory-store sorted-map
+* item, from the Open Cloud OpenAPI schema (1,000,000 requests per
+* minute per API key owner). Keyed independently from the get, update,
+* delete, and list operations so the five do not share a queue.
+*/
+const CREATE_OPERATION_LIMIT = Object.freeze({
+	maxPerSecond: CREATE_PER_MINUTE / SECONDS_PER_MINUTE,
+	operationKey: "memory-store-sorted-maps.create"
+});
+/**
+* Scopes required to create a memory-store sorted-map item, sourced
+* from `x-roblox-scopes` on the `Cloud_CreateMemoryStoreSortedMapItem`
+* operation in the vendored OpenAPI schema.
+*/
+const CREATE_REQUIRED_SCOPES = Object.freeze([WRITE_SCOPE]);
+/**
+* Per-second request ceiling for deleting a memory-store sorted-map
+* item, from the Open Cloud OpenAPI schema (1,000,000 requests per
+* minute per API key owner).
+*/
+const DELETE_OPERATION_LIMIT = Object.freeze({
+	maxPerSecond: 1e6 / SECONDS_PER_MINUTE,
+	operationKey: "memory-store-sorted-maps.delete"
+});
+/**
+* Scopes required to delete a memory-store sorted-map item, sourced
+* from `x-roblox-scopes` on the `Cloud_DeleteMemoryStoreSortedMapItem`
+* operation in the vendored OpenAPI schema.
+*/
+const DELETE_REQUIRED_SCOPES = Object.freeze([WRITE_SCOPE]);
+/**
+* Per-second request ceiling for reading a memory-store sorted-map
+* item, from the Open Cloud OpenAPI schema (1,000,000 requests per
+* minute per API key owner).
+*/
+const GET_OPERATION_LIMIT = Object.freeze({
+	maxPerSecond: 1e6 / SECONDS_PER_MINUTE,
+	operationKey: "memory-store-sorted-maps.get"
+});
+/**
+* Scopes required to read a memory-store sorted-map item, sourced from
+* `x-roblox-scopes` on the `Cloud_GetMemoryStoreSortedMapItem`
+* operation in the vendored OpenAPI schema.
+*/
+const GET_REQUIRED_SCOPES = Object.freeze(["memory-store.sorted-map:read"]);
+/**
+* Per-second request ceiling for listing memory-store sorted-map
+* items, from the Open Cloud OpenAPI schema (1,000,000 requests per
+* minute per API key owner).
+*/
+const LIST_OPERATION_LIMIT = Object.freeze({
+	maxPerSecond: 1e6 / SECONDS_PER_MINUTE,
+	operationKey: "memory-store-sorted-maps.list"
+});
+/**
+* Scopes required to list memory-store sorted-map items, sourced from
+* `x-roblox-scopes` on the `Cloud_ListMemoryStoreSortedMapItems`
+* operation in the vendored OpenAPI schema.
+*/
+const LIST_REQUIRED_SCOPES = Object.freeze(["memory-store.sorted-map:read"]);
+/**
+* Per-second request ceiling for updating a memory-store sorted-map
+* item, from the Open Cloud OpenAPI schema (1,000,000 requests per
+* minute per API key owner).
+*/
+const UPDATE_OPERATION_LIMIT = Object.freeze({
+	maxPerSecond: 1e6 / SECONDS_PER_MINUTE,
+	operationKey: "memory-store-sorted-maps.update"
+});
+/**
+* Scopes required to update a memory-store sorted-map item, sourced
+* from `x-roblox-scopes` on the `Cloud_UpdateMemoryStoreSortedMapItem`
+* operation in the vendored OpenAPI schema.
+*/
+const UPDATE_REQUIRED_SCOPES = Object.freeze([WRITE_SCOPE]);
+//#endregion
+//#region src/domains/cloud-v2/memory-store-sorted-maps/parsers.ts
+const PATH_PATTERN = /^cloud\/v2\/universes\/(\d+)\/memory-store\/sorted-maps\/([^/]+)\/items\/([^/]+)$/;
+const MALFORMED_MESSAGE = "Malformed memory-store sorted-map item response";
+const MALFORMED_LIST_MESSAGE = "Malformed memory-store sorted-map list response";
+/**
+* Parses a successful memory-store sorted-map item response body (the
+* happy path for create, get, and update) into the public
+* {@link SortedMapItem} shape.
+*
+* @param response - The full {@link HttpResponse} from the Open Cloud API.
+* @returns A success result wrapping the parsed {@link SortedMapItem},
+*   or an {@link ApiError} when the body does not match the wire schema.
+*/
+function parseSortedMapItemResponse(response) {
+	const item = wireBodyToSortedMapItem(response.body);
+	if (item === void 0) return malformedSortedMapItem(response.status);
+	return {
+		data: item,
+		success: true
+	};
+}
+/**
+* Parses a successful `Cloud_ListMemoryStoreSortedMapItems` response
+* body into the public {@link ListSortedMapItemsResult} shape. Each
+* item in the `memoryStoreSortedMapItems` array is validated through
+* the same path-and-shape checks as
+* {@link parseSortedMapItemResponse}; a malformed entry rejects the
+* whole response.
+*
+* @param response - The full {@link HttpResponse} from the Open Cloud API.
+* @returns A success result wrapping the parsed
+*   {@link ListSortedMapItemsResult}, or an {@link ApiError} when the
+*   response shape is wrong.
+*/
+function parseListResponse(response) {
+	const { body, status: statusCode } = response;
+	if (!isRecord(body)) return malformedList(statusCode);
+	const { memoryStoreSortedMapItems, nextPageToken } = body;
+	if (memoryStoreSortedMapItems !== void 0 && memoryStoreSortedMapItems !== null && !Array.isArray(memoryStoreSortedMapItems)) return malformedList(statusCode);
+	const normalizedToken = nextPageToken ?? void 0;
+	if (normalizedToken !== void 0 && typeof normalizedToken !== "string") return malformedList(statusCode);
+	const items = (memoryStoreSortedMapItems ?? []).map(wireBodyToSortedMapItem);
+	if (!items.every(isSortedMapItem)) return malformedList(statusCode);
+	return {
+		data: {
+			items,
+			nextPageToken: normalizedToken
+		},
+		success: true
+	};
+}
+function isSortedMapItemWire(body) {
+	if (!isRecord(body)) return false;
+	const { id, etag, expireTime, numericSortKey, path, stringSortKey, value } = body;
+	return typeof path === "string" && typeof etag === "string" && typeof id === "string" && isDateTimeString(expireTime) && value !== void 0 && (stringSortKey === void 0 || stringSortKey === null || typeof stringSortKey === "string") && (numericSortKey === void 0 || numericSortKey === null || typeof numericSortKey === "number");
+}
+function extractSortKey(body) {
+	const hasStringKey = typeof body.stringSortKey === "string";
+	const hasNumericKey = typeof body.numericSortKey === "number";
+	if (hasStringKey && hasNumericKey) return "conflict";
+	if (hasStringKey) return {
+		kind: "string",
+		value: body.stringSortKey
+	};
+	if (hasNumericKey) return {
+		kind: "numeric",
+		value: body.numericSortKey
+	};
+}
+function wireBodyToSortedMapItem(body) {
+	if (!isSortedMapItemWire(body)) return;
+	const match = PATH_PATTERN.exec(body.path);
+	const universeId = match?.[1];
+	const mapId = match?.[2];
+	const id = match?.[3];
+	if (universeId === void 0 || mapId === void 0 || id === void 0) return;
+	const sortKey = extractSortKey(body);
+	if (sortKey === "conflict") return;
+	return {
+		id,
+		etag: body.etag,
+		expiresAt: new Date(body.expireTime),
+		mapId,
+		sortKey,
+		universeId,
+		value: body.value
+	};
+}
+function malformedSortedMapItem(statusCode) {
+	return {
+		err: new ApiError(MALFORMED_MESSAGE, { statusCode }),
+		success: false
+	};
+}
+function isSortedMapItem(item) {
+	return item !== void 0;
+}
+function malformedList(statusCode) {
+	return {
+		err: new ApiError(MALFORMED_LIST_MESSAGE, { statusCode }),
+		success: false
+	};
+}
+//#endregion
+//#region src/resources/storage/sorted-maps-group.ts
+function makeSpec(spec) {
+	return Object.freeze(spec);
+}
+const CREATE_SPEC = makeSpec({
+	buildRequest: (parameters) => okRequest(buildCreateRequest(parameters)),
+	methodDefaults: CREATE_METHOD_DEFAULTS,
+	methodKind: "create",
+	operationLimit: CREATE_OPERATION_LIMIT,
+	parse: parseSortedMapItemResponse,
+	requiredScopes: CREATE_REQUIRED_SCOPES
+});
+const DELETE_SPEC = makeSpec({
+	buildRequest: (parameters) => okRequest(buildDeleteRequest(parameters)),
+	methodDefaults: IDEMPOTENT_METHOD_DEFAULTS,
+	methodKind: "idempotent",
+	operationLimit: DELETE_OPERATION_LIMIT,
+	parse: parseEmptyResponse,
+	requiredScopes: DELETE_REQUIRED_SCOPES
+});
+const GET_SPEC = makeSpec({
+	buildRequest: (parameters) => okRequest(buildGetRequest(parameters)),
+	methodDefaults: IDEMPOTENT_METHOD_DEFAULTS,
+	methodKind: "idempotent",
+	operationLimit: GET_OPERATION_LIMIT,
+	parse: parseSortedMapItemResponse,
+	requiredScopes: GET_REQUIRED_SCOPES
+});
+const LIST_SPEC = makeSpec({
+	buildRequest: (parameters) => okRequest(buildListRequest(parameters)),
+	methodDefaults: IDEMPOTENT_METHOD_DEFAULTS,
+	methodKind: "idempotent",
+	operationLimit: LIST_OPERATION_LIMIT,
+	parse: parseListResponse,
+	requiredScopes: LIST_REQUIRED_SCOPES
+});
+const UPDATE_SPEC = makeSpec({
+	buildRequest: (parameters) => okRequest(buildUpdateRequest(parameters)),
+	methodDefaults: IDEMPOTENT_METHOD_DEFAULTS,
+	methodKind: "idempotent",
+	operationLimit: UPDATE_OPERATION_LIMIT,
+	parse: parseSortedMapItemResponse,
+	requiredScopes: UPDATE_REQUIRED_SCOPES
+});
+/**
+* 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.
+*/
+var MemoryStoreSortedMapsGroup = class {
+	#inner;
+	/**
+	* 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) {
+		this.#inner = inner;
+	}
+	/**
+	* 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.
+	*/
+	async create(parameters, options) {
+		return this.#inner.execute({
+			options,
+			parameters,
+			spec: CREATE_SPEC
+		});
+	}
+	/**
+	* 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.
+	*/
+	async delete(parameters, options) {
+		return this.#inner.execute({
+			options,
+			parameters,
+			spec: DELETE_SPEC
+		});
+	}
+	/**
+	* 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.
+	*/
+	async get(parameters, options) {
+		return this.#inner.execute({
+			options,
+			parameters,
+			spec: GET_SPEC
+		});
+	}
+	/**
+	* 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.
+	*/
+	async list(parameters, options) {
+		return this.#inner.execute({
+			options,
+			parameters,
+			spec: LIST_SPEC
+		});
+	}
+	/**
+	* 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.
+	*/
+	async update(parameters, options) {
+		return this.#inner.execute({
+			options,
+			parameters,
+			spec: UPDATE_SPEC
+		});
+	}
+};
+//#endregion
+//#region src/resources/storage/client.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 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.
+*
+* @example
+*
+* ```ts
+* import { StorageClient } from "@bedrock-rbx/ocale/storage";
+*
+* const client = new StorageClient({ apiKey: "your-key" });
+* expect(client).toBeInstanceOf(StorageClient);
+* ```
+*/
+var StorageClient = class {
+	/** Memory-store queue Operation Group. */
+	queues;
+	/** Memory-store sorted-map Operation Group. */
+	sortedMaps;
+	/**
+	* Creates a new {@link StorageClient}. Configuration is frozen on
+	* construction; per-request overrides are accepted on each method.
+	*
+	* @param options - Client-level configuration including the API key.
+	*/
+	constructor(options) {
+		const inner = new ResourceClient(options);
+		this.queues = new MemoryStoreQueuesGroup(inner);
+		this.sortedMaps = new MemoryStoreSortedMapsGroup(inner);
+	}
+};
+//#endregion
+export { StorageClient };
+
+//# sourceMappingURL=storage.mjs.map