@game-infra/story-schemas 0.2.0

package/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2026 Igor Savin
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

package/README.md

@@ -0,0 +1,133 @@
+# @game-infra/story-schemas
+
+API contract for authored design content and story mode: valibot schemas plus [toad-contracts](https://github.com/kibertoad/toad-contracts) `defineApiContract` definitions. Covers worlds, the content written against them (locations, characters, skill definitions, lore entries), the story arcs chosen for a world, and the branching beats those arcs are told in. Builds on `@game-infra/api-schemas-core` for the shared success-response wrapper.
+
+Published to npm. Also consumable as sibling source (`exports` points at `src/`).
+
+## Install
+
+```jsonc
+// pnpm sibling checkout
+"@game-infra/story-schemas": "link:../../game-infra/packages/schemas/story-schemas"
+// or from npm
+"@game-infra/story-schemas": "^0.1.0"
+```
+
+`valibot` is a peer dependency (`^1.4.0`); the consumer provides it. `@game-infra/api-schemas-core` is a runtime dependency (re-uses `createSuccessResponseSchema`).
+
+## One resource, not a family
+
+All of it is the same shape — a keyed JSON payload, scoped to a parent, tagged with a type — so it is **one** resource with five endpoints rather than a CRUD family per kind. `contentType` and `scopeId` do the work a separate resource per kind would otherwise do:
+
+| `contentType`                                                                        | `scopeId`  | `contentId`             |
+| ------------------------------------------------------------------------------------ | ---------- | ----------------------- |
+| `world`                                                                              | `-`        | the world id            |
+| `locations`, `characters`, `events`, `stats`, `skills`, `perks`, `resources`, `lore` | a world id | the entity id           |
+| `story-arc`                                                                          | a world id | the story id            |
+| `story-node`                                                                         | a story id | the trail of choice ids |
+
+`data` is an opaque JSON string. The service stores and indexes it, never parses it — a game's design vocabulary changes far more often than this contract should, which is the same rule `GameEntitySaveRequestSchema` already follows in `api-schemas-core`. `contentType` is likewise plain `string()`; `DESIGN_CONTENT_TYPES` is the suggested vocabulary, not a closed one.
+
+## Usage
+
+```ts
+import { designContentListContract, designContentLoadContract } from "@game-infra/story-schemas";
+import { mapApiContractToPath } from "@toad-contracts/valibot";
+
+designContentListContract.pathResolver({ gameId: "g1" }); // '/games/g1/design-content'
+mapApiContractToPath(designContentLoadContract);
+// '/games/:gameId/design-content/:contentType/:scopeId/:contentId'
+```
+
+Register on a Hono service with `@toad-contracts/hono` (`buildHonoRoute`) and call from a frontend with `@toad-contracts/frontend-http-client` (`sendByApiContract`) — both drive off the same contract objects.
+
+### The five endpoints
+
+| Contract                        | Method + path                               | What it is for                                     |
+| ------------------------------- | ------------------------------------------- | -------------------------------------------------- |
+| `designContentListContract`     | `GET /games/:gameId/design-content`         | every listing, narrowed by `contentType`/`scopeId` |
+| `designContentLoadContract`     | `GET …/:contentType/:scopeId/:contentId`    | one row by key                                     |
+| `designContentSaveContract`     | `POST /games/:gameId/design-content`        | upsert one row                                     |
+| `designContentBulkSaveContract` | `POST /games/:gameId/design-content/bulk`   | upsert many, optionally as a snapshot              |
+| `designContentDeleteContract`   | `DELETE …/:contentType/:scopeId/:contentId` | delete one row, with an optional cascade           |
+
+The listing answers every question story mode asks:
+
+```ts
+// the worlds to choose between
+{ contentType: "world" }
+// a world's whole design document, payloads included
+{ scopeId: "the-ash-reckoning", includeData: "true" }
+// the arcs offered for that world
+{ contentType: "story-arc", scopeId: "the-ash-reckoning" }
+// every beat already written for an arc — the map of what is pregenerated
+{ contentType: "story-node", scopeId: "the-quiet-forge-answers", includeData: "true" }
+```
+
+`includeData` is off by default: a picker needs names and counts, not every character's biography.
+
+### Snapshots and cascades
+
+`designContentBulkSaveContract` takes a `replace` list. Each entry clears a scope (or one type within it) before the write, which is what makes a bulk save a snapshot rather than a merge — without it, content the author deleted locally would survive on the server forever.
+
+`designContentDeleteContract` takes `?cascade=`:
+
+- `none` (default) — the row alone.
+- `prefix` — the row and every row whose `contentId` sits under it. Discarding a story branch takes its descendants with it this way.
+- `scope` — the row and everything scoped to it, transitively. Deleting a world also removes its content, its arcs, and their beats.
+
+### Payload shapes — the event editor's, not new ones
+
+A branching story and a multi-stage event are the same object seen from two angles: both are prose with gated, consequential branches out of it. So a story beat **is** an `EncounterStageDTO` and a branch **is** a `ChoiceDefinitionDTO`, straight from `@game-infra/event-schemas`:
+
+| Story mode | event-editor DTO                                          |
+| ---------- | --------------------------------------------------------- |
+| arc        | `EventDefinitionDTO` header (multi-stage) + `hook`/`tags` |
+| beat       | `EncounterStageDTO` + `model`/`origin`/`revision`/`notes` |
+| branch     | `ChoiceDefinitionDTO`, unchanged                          |
+
+A branch therefore carries `conditionsToShow`, `conditionsToEnable`, `consumableConditions`, `effects` and an outcome config exactly as an event's choice does, and a finished arc assembles into an `event_definitions` row by collecting its beats into `stages` — a copy, not a translation.
+
+`data` is opaque to the _service_, but two clients writing and reading the same rows still have to agree, so the shapes ship alongside the contract and are parsed client-side:
+
+```ts
+import { StoryBeatPayloadSchema } from "@game-infra/story-schemas";
+import { safeParse } from "valibot";
+
+const parsed = safeParse(StoryBeatPayloadSchema, JSON.parse(row.data ?? "{}"));
+if (parsed.success) console.log(parsed.output.description, parsed.output.choices);
+```
+
+`WorldPayloadSchema`, `StoryArcPayloadSchema` and `StoryBeatPayloadSchema` are exported for this, along with the underlying `ChoiceDefinitionDTOSchema`, `PreconditionDTOSchema`, `ActivationDTOSchema` and `ConsumableConditionDTOSchema` so a story client needs one import rather than two. They are deliberately _not_ attached to any endpoint.
+
+**Use the lenient DTOs, not the strict ones.** `StrictPreconditionDTOSchema` and `StrictActivationDTOSchema` enumerate one game's vocabulary (`strength`, `mana`, `LearnSpell`, `SpecificLecture`). A design world declares its own stats, skills, perks and resources, so a story client uses the lenient `{ type, params }` forms and validates `type` and the ids in `params` against the world it belongs to.
+
+### Beat addressing
+
+A beat's identity is the trail of choices taken to reach it — that is what makes "has this branch been travelled before?" a lookup rather than a search. The client minting ids and the service sweeping subtrees import the same helpers:
+
+```ts
+import { storyNodeId, childStoryNodeId, isStoryNodeAtOrBelow } from "@game-infra/story-schemas";
+
+storyNodeId([]); // 'root'
+childStoryNodeId("root", "take-the-tunnel"); // 'root.take-the-tunnel'
+isStoryNodeAtOrBelow("root.take.left", "root.take"); // true
+isStoryNodeAtOrBelow("root.taken", "root.take"); // false
+```
+
+Segments join with `.` rather than `/` because a beat id travels as a single URL path segment, which a slash would split; the dot is also what `cascade=prefix` sweeps on.
+
+## Extension points
+
+- **`contentType`**: typed `string()`; `DESIGN_CONTENT_TYPES` is the suggested vocabulary and a game re-tightens it in its own validation layer.
+- **`data`**: opaque to the contract, so a game evolves its design document without a contract bump. Add a payload schema next to the existing three when a new type needs one.
+- **`origin`**: a beat is `generated` or `authored` — the latter is a branch a player wrote themselves.
+- **Condition and effect vocabulary**: `type` is free text in the lenient DTOs, so each game declares the set it evaluates and drops the rest.
+
+## Dependencies
+
+`@game-infra/api-schemas-core` (the success-response wrapper), `@game-infra/event-schemas` (the stage and choice DTOs), `@toad-contracts/core`, `@toad-contracts/valibot`; peer `valibot`.
+
+## Consumers
+
+`services/game-content-service` (the Hono service registering these routes) and the design/story clients that call them — currently the Fluid Emerald game editor.

package/dist/contracts.d.ts

@@ -0,0 +1,165 @@
+/**
+ * Rows for a game, narrowed by type and scope.
+ *
+ * This one endpoint answers every listing story mode needs: the worlds to
+ * choose between (`contentType=world`), a world's whole design document
+ * (`scopeId=<worldId>&includeData=true`), the arcs offered for it
+ * (`contentType=story-arc&scopeId=<worldId>`), and the beats already written
+ * for an arc (`contentType=story-node&scopeId=<storyId>&includeData=true`) —
+ * which is the map of what is pregenerated and must not be generated again.
+ */
+export declare const designContentListContract: {
+    readonly method: "get";
+    readonly requestPathParamsSchema: import("valibot").ObjectSchema<{
+        readonly gameId: import("valibot").StringSchema<undefined>;
+    }, undefined> & import("@toad-contracts/valibot").StandardObjectKeysV1<unknown, unknown>;
+    readonly requestQuerySchema: import("valibot").ObjectSchema<{
+        readonly contentType: import("valibot").OptionalSchema<import("valibot").StringSchema<undefined>, undefined>;
+        readonly scopeId: import("valibot").OptionalSchema<import("valibot").StringSchema<undefined>, undefined>;
+        readonly includeData: import("valibot").OptionalSchema<import("valibot").StringSchema<undefined>, undefined>;
+    }, undefined>;
+    readonly pathResolver: ({ gameId }: {
+        gameId: string;
+    }) => string;
+    readonly responsesByStatusCode: {
+        200: import("valibot").ObjectSchema<{
+            readonly success: import("valibot").BooleanSchema<undefined>;
+            readonly error: import("valibot").OptionalSchema<import("valibot").StringSchema<undefined>, undefined>;
+        } & {
+            items: import("valibot").OptionalSchema<import("valibot").ArraySchema<import("valibot").ObjectSchema<{
+                readonly contentType: import("valibot").StringSchema<undefined>;
+                readonly scopeId: import("valibot").StringSchema<undefined>;
+                readonly contentId: import("valibot").StringSchema<undefined>;
+                readonly name: import("valibot").StringSchema<undefined>;
+                readonly data: import("valibot").OptionalSchema<import("valibot").StringSchema<undefined>, undefined>;
+                readonly createdAt: import("valibot").StringSchema<undefined>;
+                readonly updatedAt: import("valibot").StringSchema<undefined>;
+            }, undefined>, undefined>, undefined>;
+        }, undefined>;
+    };
+};
+/** One row by key, or `item: undefined` when nothing is stored there. */
+export declare const designContentLoadContract: {
+    readonly method: "get";
+    readonly requestPathParamsSchema: import("valibot").ObjectSchema<{
+        readonly gameId: import("valibot").StringSchema<undefined>;
+        readonly contentType: import("valibot").StringSchema<undefined>;
+        readonly scopeId: import("valibot").StringSchema<undefined>;
+        readonly contentId: import("valibot").StringSchema<undefined>;
+    }, undefined> & import("@toad-contracts/valibot").StandardObjectKeysV1<unknown, unknown>;
+    readonly pathResolver: ({ gameId, contentType, scopeId, contentId }: {
+        gameId: string;
+        contentType: string;
+        scopeId: string;
+        contentId: string;
+    }) => string;
+    readonly responsesByStatusCode: {
+        200: import("valibot").ObjectSchema<{
+            readonly success: import("valibot").BooleanSchema<undefined>;
+            readonly error: import("valibot").OptionalSchema<import("valibot").StringSchema<undefined>, undefined>;
+        } & {
+            item: import("valibot").OptionalSchema<import("valibot").ObjectSchema<{
+                readonly contentType: import("valibot").StringSchema<undefined>;
+                readonly scopeId: import("valibot").StringSchema<undefined>;
+                readonly contentId: import("valibot").StringSchema<undefined>;
+                readonly name: import("valibot").StringSchema<undefined>;
+                readonly data: import("valibot").OptionalSchema<import("valibot").StringSchema<undefined>, undefined>;
+                readonly createdAt: import("valibot").StringSchema<undefined>;
+                readonly updatedAt: import("valibot").StringSchema<undefined>;
+            }, undefined>, undefined>;
+        }, undefined>;
+    };
+};
+/** Create or replace one row. Re-saving the same key keeps its `createdAt`. */
+export declare const designContentSaveContract: {
+    readonly method: "post";
+    readonly requestPathParamsSchema: import("valibot").ObjectSchema<{
+        readonly gameId: import("valibot").StringSchema<undefined>;
+    }, undefined> & import("@toad-contracts/valibot").StandardObjectKeysV1<unknown, unknown>;
+    readonly pathResolver: ({ gameId }: {
+        gameId: string;
+    }) => string;
+    readonly requestBodySchema: import("valibot").ObjectSchema<{
+        readonly contentType: import("valibot").StringSchema<undefined>;
+        readonly scopeId: import("valibot").StringSchema<undefined>;
+        readonly contentId: import("valibot").StringSchema<undefined>;
+        readonly name: import("valibot").StringSchema<undefined>;
+        readonly data: import("valibot").StringSchema<undefined>;
+    }, undefined>;
+    readonly responsesByStatusCode: {
+        200: import("valibot").ObjectSchema<{
+            readonly success: import("valibot").BooleanSchema<undefined>;
+            readonly error: import("valibot").OptionalSchema<import("valibot").StringSchema<undefined>, undefined>;
+        } & {
+            contentId: import("valibot").OptionalSchema<import("valibot").StringSchema<undefined>, undefined>;
+        }, undefined>;
+    };
+};
+/**
+ * Write many rows at once; `replace` makes it a snapshot rather than a merge,
+ * which is how a whole design document lands in one request.
+ */
+export declare const designContentBulkSaveContract: {
+    readonly method: "post";
+    readonly requestPathParamsSchema: import("valibot").ObjectSchema<{
+        readonly gameId: import("valibot").StringSchema<undefined>;
+    }, undefined> & import("@toad-contracts/valibot").StandardObjectKeysV1<unknown, unknown>;
+    readonly pathResolver: ({ gameId }: {
+        gameId: string;
+    }) => string;
+    readonly requestBodySchema: import("valibot").ObjectSchema<{
+        readonly items: import("valibot").ArraySchema<import("valibot").ObjectSchema<{
+            readonly contentType: import("valibot").StringSchema<undefined>;
+            readonly scopeId: import("valibot").StringSchema<undefined>;
+            readonly contentId: import("valibot").StringSchema<undefined>;
+            readonly name: import("valibot").StringSchema<undefined>;
+            readonly data: import("valibot").StringSchema<undefined>;
+        }, undefined>, undefined>;
+        readonly replace: import("valibot").OptionalSchema<import("valibot").ArraySchema<import("valibot").ObjectSchema<{
+            readonly scopeId: import("valibot").StringSchema<undefined>;
+            readonly contentType: import("valibot").OptionalSchema<import("valibot").StringSchema<undefined>, undefined>;
+        }, undefined>, undefined>, undefined>;
+    }, undefined>;
+    readonly responsesByStatusCode: {
+        200: import("valibot").ObjectSchema<{
+            readonly success: import("valibot").BooleanSchema<undefined>;
+            readonly error: import("valibot").OptionalSchema<import("valibot").StringSchema<undefined>, undefined>;
+        } & {
+            savedCount: import("valibot").OptionalSchema<import("valibot").NumberSchema<undefined>, undefined>;
+            removedCount: import("valibot").OptionalSchema<import("valibot").NumberSchema<undefined>, undefined>;
+        }, undefined>;
+    };
+};
+/**
+ * Delete one row, and — depending on `?cascade=` — what hangs off it:
+ * `prefix` also removes the rows whose `contentId` sits under this one (a story
+ * branch and its descendants), `scope` also removes everything scoped to it,
+ * transitively (a world, its content, its arcs, and their beats).
+ */
+export declare const designContentDeleteContract: {
+    readonly method: "delete";
+    readonly requestPathParamsSchema: import("valibot").ObjectSchema<{
+        readonly gameId: import("valibot").StringSchema<undefined>;
+        readonly contentType: import("valibot").StringSchema<undefined>;
+        readonly scopeId: import("valibot").StringSchema<undefined>;
+        readonly contentId: import("valibot").StringSchema<undefined>;
+    }, undefined> & import("@toad-contracts/valibot").StandardObjectKeysV1<unknown, unknown>;
+    readonly requestQuerySchema: import("valibot").ObjectSchema<{
+        readonly cascade: import("valibot").OptionalSchema<import("valibot").StringSchema<undefined>, undefined>;
+    }, undefined>;
+    readonly pathResolver: ({ gameId, contentType, scopeId, contentId }: {
+        gameId: string;
+        contentType: string;
+        scopeId: string;
+        contentId: string;
+    }) => string;
+    readonly responsesByStatusCode: {
+        200: import("valibot").ObjectSchema<{
+            readonly success: import("valibot").BooleanSchema<undefined>;
+            readonly error: import("valibot").OptionalSchema<import("valibot").StringSchema<undefined>, undefined>;
+        } & {
+            deletedCount: import("valibot").OptionalSchema<import("valibot").NumberSchema<undefined>, undefined>;
+        }, undefined>;
+    };
+};
+//# sourceMappingURL=contracts.d.ts.map

package/dist/contracts.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"contracts.d.ts","sourceRoot":"","sources":["../src/contracts.ts"],"names":[],"mappings":"AA8DA;;;;;;;;;GASG;AACH,eAAO,MAAM,yBAAyB;;;;;;;;;;;;;;QAKX,GAAG;;;;;;;;;;;;;;;CAC5B,CAAC;AAEH,yEAAyE;AACzE,eAAO,MAAM,yBAAyB;;;;;;;;;;;;;;;QAKX,GAAG;;;;;;;;;;;;;;;CAC5B,CAAC;AAEH,+EAA+E;AAC/E,eAAO,MAAM,yBAAyB;;;;;;;;;;;;;;;;QAKX,GAAG;;;;;;;CAC5B,CAAC;AAEH;;;GAGG;AACH,eAAO,MAAM,6BAA6B;;;;;;;;;;;;;;;;;;;;;;QAKf,GAAG;;;;;;;;CAC5B,CAAC;AAEH;;;;;GAKG;AACH,eAAO,MAAM,2BAA2B;;;;;;;;;;;;;;;;;;QAMb,GAAG;;;;;;;CAC5B,CAAC"}

package/dist/contracts.js

@@ -0,0 +1,104 @@
+import { defineApiContract, withObjectKeys } from "@toad-contracts/valibot";
+import { object, optional, string } from "valibot";
+import { DesignContentBulkSaveRequestSchema, DesignContentBulkSaveResponseSchema, DesignContentDeleteResponseSchema, DesignContentListResponseSchema, DesignContentLoadResponseSchema, DesignContentSaveRequestSchema, DesignContentSaveResponseSchema, } from "./designContent.js";
+/**
+ * Typed endpoint contracts for authored design content — worlds, the content
+ * written against them, story arcs, and story beats.
+ *
+ * There are five, not one family per type, because all of it is the same shape:
+ * a keyed JSON payload, scoped to a parent, tagged with a type. `contentType`
+ * and `scopeId` do the work that a separate resource per kind would otherwise
+ * do, and `data` stays opaque to the service.
+ *
+ * Register them on a Hono service with `@toad-contracts/hono` (`buildHonoRoute`)
+ * and call them from a client with `@toad-contracts/frontend-http-client`
+ * (`sendByApiContract`) — both drive off these same objects.
+ *
+ * @example
+ * ```ts
+ * import { designContentListContract, designContentLoadContract } from '@game-infra/story-schemas'
+ * import { mapApiContractToPath } from '@toad-contracts/valibot'
+ *
+ * designContentListContract.pathResolver({ gameId: 'g1' }) // '/games/g1/design-content'
+ * designContentLoadContract.pathResolver({
+ *   gameId: 'g1', contentType: 'story-node', scopeId: 's1', contentId: 'root',
+ * }) // '/games/g1/design-content/story-node/s1/root'
+ * mapApiContractToPath(designContentLoadContract)
+ * // '/games/:gameId/design-content/:contentType/:scopeId/:contentId'
+ * ```
+ */
+const gameParams = withObjectKeys(object({ gameId: string() }));
+const itemParams = withObjectKeys(object({
+    gameId: string(),
+    contentType: string(),
+    scopeId: string(),
+    contentId: string(),
+}));
+/**
+ * `contentType` and `scopeId` narrow the listing; `includeData=true` opts into
+ * the payloads, which a picker does not need and a play session does.
+ */
+const listQuery = object({
+    contentType: optional(string()),
+    scopeId: optional(string()),
+    includeData: optional(string()),
+});
+/** `cascade` is one of `none` (default), `prefix`, or `scope`. */
+const deleteQuery = object({ cascade: optional(string()) });
+/**
+ * Rows for a game, narrowed by type and scope.
+ *
+ * This one endpoint answers every listing story mode needs: the worlds to
+ * choose between (`contentType=world`), a world's whole design document
+ * (`scopeId=<worldId>&includeData=true`), the arcs offered for it
+ * (`contentType=story-arc&scopeId=<worldId>`), and the beats already written
+ * for an arc (`contentType=story-node&scopeId=<storyId>&includeData=true`) —
+ * which is the map of what is pregenerated and must not be generated again.
+ */
+export const designContentListContract = defineApiContract({
+    method: "get",
+    requestPathParamsSchema: gameParams,
+    requestQuerySchema: listQuery,
+    pathResolver: ({ gameId }) => `/games/${gameId}/design-content`,
+    responsesByStatusCode: { 200: DesignContentListResponseSchema },
+});
+/** One row by key, or `item: undefined` when nothing is stored there. */
+export const designContentLoadContract = defineApiContract({
+    method: "get",
+    requestPathParamsSchema: itemParams,
+    pathResolver: ({ gameId, contentType, scopeId, contentId }) => `/games/${gameId}/design-content/${contentType}/${scopeId}/${contentId}`,
+    responsesByStatusCode: { 200: DesignContentLoadResponseSchema },
+});
+/** Create or replace one row. Re-saving the same key keeps its `createdAt`. */
+export const designContentSaveContract = defineApiContract({
+    method: "post",
+    requestPathParamsSchema: gameParams,
+    pathResolver: ({ gameId }) => `/games/${gameId}/design-content`,
+    requestBodySchema: DesignContentSaveRequestSchema,
+    responsesByStatusCode: { 200: DesignContentSaveResponseSchema },
+});
+/**
+ * Write many rows at once; `replace` makes it a snapshot rather than a merge,
+ * which is how a whole design document lands in one request.
+ */
+export const designContentBulkSaveContract = defineApiContract({
+    method: "post",
+    requestPathParamsSchema: gameParams,
+    pathResolver: ({ gameId }) => `/games/${gameId}/design-content/bulk`,
+    requestBodySchema: DesignContentBulkSaveRequestSchema,
+    responsesByStatusCode: { 200: DesignContentBulkSaveResponseSchema },
+});
+/**
+ * Delete one row, and — depending on `?cascade=` — what hangs off it:
+ * `prefix` also removes the rows whose `contentId` sits under this one (a story
+ * branch and its descendants), `scope` also removes everything scoped to it,
+ * transitively (a world, its content, its arcs, and their beats).
+ */
+export const designContentDeleteContract = defineApiContract({
+    method: "delete",
+    requestPathParamsSchema: itemParams,
+    requestQuerySchema: deleteQuery,
+    pathResolver: ({ gameId, contentType, scopeId, contentId }) => `/games/${gameId}/design-content/${contentType}/${scopeId}/${contentId}`,
+    responsesByStatusCode: { 200: DesignContentDeleteResponseSchema },
+});
+//# sourceMappingURL=contracts.js.map

package/dist/contracts.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"contracts.js","sourceRoot":"","sources":["../src/contracts.ts"],"names":[],"mappings":"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"}