@helix3/helix-cli 0.1.11-helix3.50 → 0.1.13-helix3.100

package/README.md

@@ -4,6 +4,12 @@
 backend. It shares bundle validation with the server via `@hypersoniclabs/helix-manifest`, so "validate passed but
 publish failed" can't happen for contract reasons.
 
+## Architecture boundary
+
+All creator feature and operational logic, validation, file mutation, network behavior, and tests
+live here. MCP packages may expose transport schemas, resources, instructions, and thin delegation
+to these commands, but must not reimplement this logic.
+
 ## Install
 
 ```bash
@@ -35,8 +41,24 @@ The token is stored in `~/.helix/credentials.json` (mode `600`). It's sent as
 | `helix init <dir>` | Scaffold a minimal Three.js world (`helix.json` + `index.html` + `main.js`). |
 | `helix install [--update]` | Resolve a world's `systems`/`abilities` pins (a v0.2 **or v0.3** manifest) → materialize the modules, the `three` import map, and `helix.runtime.ts`. |
 | `helix validate [dir]` | Validate a bundle locally — the exact rules the server enforces. |
-| `helix publish [dir]` | Validate → resolve/create the world → upload files → finalize → print the play URL. |
+| `helix publish [dir] [--thumbnail <file>] [--upload-source] [--source-dir <path>]` | Validate → resolve/create the world → upload files → finalize → set the cover image → print the play URL. `--upload-source` additionally sends the project's source through a separate private channel so the world can be edited on the website later — **off by default**. |
 | `helix list` | List your worlds. |
+| `helix item list-slots [--json]` | Print the Character-Creator vocabulary a wearable declares: the cosmetic slot tags, and the genders. |
+| `helix item publish <mesh.glb> --title <t> [--collectible-supply <n>] [initial distribution flags] [--dry-run\|--quote]` | Publish a Standard item by default, or one fixed-supply Collectible. The item definition is separate from acquisition routes. |
+| `helix item distribution create\|list\|update\|disable …` | Manage Marketplace/World Claim or Buy routes without republishing the item or paying another publish fee. |
+| `helix preview-video <slug> <youtube-url>` | Set or clear a published world's YouTube preview. |
+| `helix thumbnail set <slug> <file>` | Upload a thumbnail or preview image through the CLI-owned media path. |
+| `helix assets search\|get\|versions\|track\|install\|update` | Search the typed Vault with explainable ranking; inspect/manage annotations and immutable versions; install by durable ID with verified SHA-256 receipts. Material installs default to lean runtime KTX2 maps; use `--material-renditions source` for source PNGs or `all` for both families. |
+| `helix assets start\|status\|generate\|resume` | Start or poll generation without duplicates. Props/characters use the main Dreamer path; standalone assets use the shared broker and report the auto-published `vaultAssetId`. `generate` and `resume` block waiting for the job (see `--timeout`/`--poll-interval` below). |
+| `helix assets voices [--search <text>] [--category premade\|professional] [--page-size <n>] [--page-token <token>] [--json]` | Discover safe text-to-speech voices through the authenticated HELIX catalog, including language, labels, preview, default/recommended selection, and pagination. |
+| `helix assets generate-image\|generate-material\|generate-audio\|generate-environment` | Run the supported standalone generation adapters. Material is a validated PBR bundle (1K default, explicit 2K); splats declare object/environment scope. Animation remains an explicit unavailable boundary. |
+| `helix assets start-reference\|generate-reference` | Start or fully drive a character job from a local four-view PNG/JPEG/WebP. The backend validates and reuses the exact sheet; it skips image generation while preserving mesh, texture, rig, LOD, thumbnail, billing, and Vault publication. `generate-reference` blocks waiting for the job (see `--timeout`/`--poll-interval` below). |
+| `helix assets generate\|generate-reference\|resume [--timeout <ms>] [--poll-interval <ms>]` | These three drive a Dreamer prop/character job to completion (concept → mesh → texture → rig → publish) and block until it finishes. `--timeout` bounds how long the CLI process waits before giving up (default **1200000ms / 20min**, unchanged if omitted); `--poll-interval` sets how often it checks job status while waiting (default **2000ms**). A timeout is a CLIENT-SIDE giveup, not a job failure — the Dreamer job keeps running server-side. The error prints the exact `helix assets resume <job-id>` command to check on or continue it; on a genuinely slow stage (e.g. mesh generation), rerun with a larger `--timeout`, or just poll separately with `helix assets status <job-id> --pipeline dreamer`. |
+| `helix assets materials [--resolution <res>] [--human]` | Discover the small built-in material palette. `--resolution` keeps only materials carrying that texture resolution. |
+| `helix assets material <id> [--resolution <res>] [--human]` | Resolve one material to its immutable map URLs at the resolution you pick (default: the pack's own default). |
+| `helix assets credits\|check-loaders` | Render asset credits from provenance and reject models requiring unsupported loaders. |
+| `helix character retarget-animation <clip.fbx\|clip.glb>` | Retarget a raw Mixamo/Meshy clip directly to `helix-humanoid@1`. FBX conversion is deterministic and runs inside the CLI; no hidden Blender/DCC pre-export is required. |
+| `helix world audit\|source-audit\|perf-gate\|prove-live` | Run the blocking world QA, performance, and deployed-build identity gates. |
 | `helix doctor [--project <dir>]` | Print the environment + whether the @helix toolchain (CLI/MCP/SDK/manifest) is current. |
 
 ## Publish flow
@@ -51,8 +73,247 @@ The token is stored in `~/.helix/credentials.json` (mode `600`). It's sent as
 5. `POST /api/v1/instant-worlds/:id/builds/:buildId/finalize` → byte-exact verify, activate, publish.
 6. `GET /api/v1/instant-worlds/:slug` → the play URL.
 
-The programmatic surface (`publishWorld`, `checkBundle`, `whoAmI`, …) is exported from the package
-main, so an MCP server can drive the exact same code paths an agent would.
+### Opt-in source upload
+
+A published world ships only its **built bundle**, so there is nothing on the server to edit later.
+`--upload-source` adds a second, separate upload that fixes that:
+
+7. `POST /api/v1/instant-worlds/:id/source` → a presigned PUT into a **private** bucket (this call
+   also adopts the world into a project, which is the key its future workspace hangs from).
+8. `helix-source.tar.gz` PUT with `cache-control: no-store`.
+9. `POST /api/v1/instant-worlds/:id/source/finalize` → the server verifies the stored byte count
+   equals the declared one, then records the version.
+
+- **Off by default.** Source is never sent unless you pass the flag. Not a prompt — an interactive
+  confirm would break CI and agent-driven publishes.
+- **What goes in**: the project directory, honouring `.gitignore`, always excluding `node_modules`,
+  `.git`, `dist` and `.vite` — the same exclude set the website's own workspace checkpoints use.
+- **Which directory**: `[dir]` is the BUILT bundle, so the source defaults to its parent. Override
+  with `--source-dir <path>`.
+- **Never part of the build.** The bundle's content-type allowlist rejects archives, raw `.ts` is
+  excluded from a bundle by design, the bundle size budget is the playable budget, and every build
+  file lands on a public CDN path with a year-long immutable cache. Source uses its own private
+  channel for exactly that reason.
+- **Limit**: 128 MiB compressed, checked locally before anything is uploaded.
+
+The programmatic surface (`publishWorld`, `checkBundle`, `whoAmI`, …) is exported for other CLI
+modules. Agent integrations should instruct or delegate to the `helix` commands above rather than
+reimplementing operational behavior in a transport package.
+
+## Vault lifecycle
+
+Use the durable Vault UUID as the handle. Search results include independent lexical, hard-filter,
+measured-performance, reuse, and availability explanations; they do not collapse those signals into
+a made-up score. `helix assets install` resolves an immutable version, follows the `/download`
+indirection, verifies its server checksum and byte count, installs related material maps, and writes
+`public/helix.assets.json`. Material installs keep the descriptor and default to the runtime KTX2
+map family only; choose source PNGs with `--material-renditions source`, or both families with
+`--material-renditions all`. Reinstalling with a different selection removes the stale opposite
+family. Non-material assets keep their existing related-artifact behavior. For a reproducible agent build, pass `--asset-version`,
+`--checksum-sha256`, and `--size-bytes` together; a partial pin or any metadata/download mismatch
+fails before a provenance receipt is written.
+
+Generation is source-agnostic at the backend:
+
+- `prop` and `character` start through the main Dreamer route because they use its verified
+  universal-item flow.
+- `image`, `material`, `audio`, and `gaussian_splat` start through the shared asset route.
+  Gaussian splats must declare `object` or `environment` scope.
+- `animation` fails locally with `CAPABILITY_UNAVAILABLE`; it never starts a chargeable job.
+
+Run `helix assets status <job-id> --pipeline dreamer|asset` to poll an existing job. A successful
+default-on generation reports `vaultAssetId` and `vaultAutoPublish: "published"`; an explicit
+creator opt-out reports `"disabled"`.
+
+For `.helix-scene.json`, the open Vault catalog is not the scene-local budget. Reuse a small
+material palette and instance repeated assets. The canonical ceilings are:
+
+| Profile | Unique materials | Draw calls | Decoded texture memory | Triangles | Particles |
+| --- | ---: | ---: | ---: | ---: | ---: |
+| mobile | 48 | 300 | 256 MiB | 750,000 | 5,000 |
+| desktop | 128 | 1,200 | 1 GiB | 4,000,000 | 50,000 |
+| cinematic | 256 | 4,000 | 4 GiB | 15,000,000 | 250,000 |
+
+These are publish-contract ceilings, not frame-rate promises; world runtime QA still applies.
+
+The lifecycle acceptance harness intentionally has no CLI-local demo. Point it
+at a built world in `helix-web-demo-worlds` that consumes the published SDK and
+humanoid runtime:
+
+```bash
+npm run qa:vault-lifecycle -- \
+  --world-template /path/to/helix-web-demo-worlds/worlds/sdk-showcase
+```
+
+Publishing is an explicit release-only action and additionally requires a new
+approved slug:
+
+```bash
+npm run qa:vault-lifecycle -- \
+  --world-template /path/to/helix-web-demo-worlds/worlds/sdk-showcase \
+  --publish --world-slug ch1146-vault-lifecycle-qa-<unique-suffix>
+```
+
+The publish receipt requires one usage increment, one world association, and
+an idempotent second publish with no additional increment.
+
+### Audio generation
+
+All three audio modes use the same authenticated Dreamer route and automatically publish the
+completed MP3 to Vault. The command waits up to 30 minutes so a ten-minute music request has enough
+time to render, ingest, and publish. It prints the durable `vaultAssetId`, measured Spark charge,
+provider cost, and server-stamped `billingEvidence`. It does not download another local copy unless
+`--output` is supplied.
+
+```bash
+# Sound effect
+helix assets generate-audio "heavy metal door slamming shut" \
+  --mode sound_effect --duration-seconds 3 --prompt-influence 0.4 --output door.mp3
+
+# Music
+helix assets generate-audio "hopeful orchestral exploration theme" \
+  --mode music --duration-seconds 180 --force-instrumental
+
+# Text to speech
+helix assets voices --search narrator --page-size 10
+helix assets generate-audio --mode text_to_speech \
+  --text "Welcome to HELIX." --voice-id <id-from-catalog> \
+  --language-code en --stability 0.5 --speaker-boost
+```
+
+Use the opaque `--page-token` printed by a page to continue. Voice cloning and
+voice administration are deliberately not exposed.
+
+Use a deterministic four-view sheet when you already have approved FRONT, BACK,
+LEFT, and RIGHT character art and do not want Dreamer to generate another image:
+
+```bash
+helix assets generate-reference ./character-four-views.png \
+  "compact friendly service robot, game-ready humanoid proportions" \
+  --title "Service Robot" \
+  --target-polycount 12000
+```
+
+The reference endpoint is character-only. The file is image-guarded, normalized,
+checksum-bound to the job, semantically validated, and mirrored before approval.
+Retries reuse those same bytes and never invoke or charge the image provider.
+
+## Material texture resolution
+
+A platform material can ship more than one texture resolution. `--resolution` picks which one you
+get; without it you get the pack's declared default, byte-for-byte what every earlier CLI returned.
+
+```bash
+helix assets material brick-block                      # the pack's default resolution
+helix assets material brick-block --resolution 2k      # the 2K variant's map URLs
+helix assets material brick-block --resolution 2048    # same thing — numeric spelling
+helix assets materials --resolution 2k --human         # only materials that carry 2K
+```
+
+Accepted values are the keys the catalog itself declares (`1k`, `2k`, …), case-insensitively, plus
+the numeric aliases `1024`/`2048`, which map onto the variant authored at that pixel edge.
+
+Both commands print JSON by default (agents and the MCP delegation parse it); `--human` prints a
+readable summary instead. Either way the output states **which resolution was resolved and which
+ones the material offers**, under `resolution`:
+
+```jsonc
+"resolution": {
+  "requested": "2k", "resolved": "2k", "pixels": 2048, "default": "1k",
+  "available": [{ "key": "1k", "pixels": 1024 }, { "key": "2k", "pixels": 2048 }],
+  "applicable": true
+}
+```
+
+Three rules make this safe to rely on:
+
+- **No silent fallback, ever.** Asking for a resolution the material does not carry is an error that
+  names the ones it does. You never receive a different resolution than the one you asked for.
+- **Old packs keep working.** A catalog with no `resolutions` block (`schemaVersion: 1`) is treated
+  as having exactly one resolution, keyed `default`, derived from its existing `maps`. Such a pack
+  never claims to be "1k" — it does not say how big its textures are, so neither do we.
+- **Procedural materials are not an error.** `glass` and `procedural_water` carry no texture maps;
+  a resolution request against them is ignored and the output says so in `resolution.note`.
+
+`helix assets install` has no resolution flag: Vault related-artifact roles are semantic
+(`source.albedo`, `runtime.ktx2.normal`, `sky.backdrop`), never resolution-tagged, so a filter there
+would filter nothing.
+
+## Item publish flow
+
+`helix item publish` creates an item definition. It defaults to **Standard**: unlimited issuance,
+no public serial, and no resale. `--collectible-supply N` is the only edition selector: it fixes a
+positive supply, assigns public serials, makes instances Marketplace-resellable, and reserves
+serial `#1` for the creator. There are no separate tradable, serial, giftable, personal, or
+discoverability switches.
+
+1. Local validation, before anything leaves the machine: the `--kind`, the Character-Creator
+   `--slot` and `--gender` (**both required** for a wearable, exact-match), the title/slug/tag
+   limits, and the GLB container magic. `--dry-run` stops here and prints exactly what would be
+   sent.
+
+`--kind` accepts `wearable`, `avatar`, `prop`, and `home` — `prop` and `home` are the current
+product names (see helixgame.com) for what the API still calls `home_item` and `home_shell`; both
+spellings work identically and `helix item publish --kind prop …` sends the exact same
+`"kind":"home_item"` on the wire as `--kind home_item …` does. This is a CLI-vocabulary alias only —
+it is unrelated to the backend's separate `prop` universal-item kind (art/collectible items).
+2. `--quote` asks the server for the definition publish fee, the creator tier's included free-
+   Collectible units, excess issuance authorization cost, creator serial `#1`, price floor and
+   resale policy. It uploads nothing and charges nothing.
+3. `POST /api/v1/universal-items/upload` — `multipart/form-data` with a `mesh` file part, an
+   optional `thumbnail` file part, and the metadata as ONE JSON string in `payload`.
+4. The server verifies the mesh **inline** (triangles, texture edges, materials, and — for a
+   wearable — whether it is a skinned garment or a rigid socketed accessory) and returns the
+   created item together with the verification verdict and warnings.
+
+Price, world, schedule and limits live on a separate distribution. Price `0` means a shell-
+confirmed **Claim**; a positive price means **Buy** and must meet the server-owned floor. A world
+route also has a stable key, which world code passes to
+`Helix.marketplace.purchaseDistributionKey(key)`. `--max-per-player unlimited` explicitly clears a
+cap; free Collectibles default to one per player when omitted. Distribution changes never republish
+the definition.
+
+```bash
+# Standard, free Marketplace Claim
+helix item publish ./postcard.glb --title "Harbor Postcard"
+helix item distribution create <item-id> --channel marketplace --price-lix 0
+
+# Standard, paid World Buy
+helix item distribution create <item-id> --channel world --world fishing-cove \
+  --key fishing_rod --price-lix 250 --max-per-player unlimited
+
+# Collectible, free World Claim (creator receives #1 from the 500 fixed units)
+helix item publish ./trophy.glb --title "Season One Trophy" --collectible-supply 500 \
+  --distribution-channel world --distribution-price-lix 0 --world tournament \
+  --distribution-key season_one --max-per-player 1 --quote
+# Review the quote, then run the same command without --quote to publish.
+
+# Collectible, paid Marketplace Buy
+helix item publish ./bluefin.glb --title "Legendary Bluefin" --collectible-supply 10000
+helix item distribution create <item-id> --channel marketplace --price-lix 500 --max-claims 9000
+
+helix item distribution update <distribution-id> --price-lix 600 --ends-at 2026-12-01T00:00:00Z
+helix item distribution disable <distribution-id>
+```
+
+Collectible resale uses Marketplace escrow. The creator royalty is fixed at 5%; the launch seller
+platform fee is 10% for Free and 5% for Plus (future Gold 2.5%, Diamond 0%). The buyer pays no
+surcharge, creator self-sale omits a redundant royalty leg, and self-purchase is prohibited.
+Every acquisition has one 24-hour relisting cooldown. Basic requires email; Verified means a unique
+verified mobile plus good standing and may resell immediately subject to that cooldown. Identity Verified
+is reserved for later high-risk capability, and tooling accepts future Business Verified. Payout holds are
+separate: 3 days base, risk-extendable up to 15 days.
+
+The slot table in `src/item.ts` MIRRORS `helix-backend-api → src/universal-items/cc-wearable-slot.ts`,
+and the gender list mirrors `src/universal-items/cc-gender.ts` the same way. They are a local fast
+path so a typo costs no upload; the server remains the authority and its 400 lists every valid
+value. Adding a slot or a gender means editing both, in the same PR wave.
+
+`--gender` takes `male`, `female`, or `male,female`, and is **required** for `--kind wearable`.
+There is no `both`/`unisex`/`all`: Unreal's cosmetics enum has exactly Male and Female, so a garment
+that fits every body names both — one HELIX row with `{male, female}` is the web equivalent of
+Unreal's two entries sharing one mesh. The field goes on the wire as `genders`; `ccGenders` is the
+database column and the backend rejects it by name rather than dropping it in silence.
 
 ## Develop
 

package/dist/achievement.d.ts

@@ -0,0 +1,123 @@
+/** 2–80 chars, lowercase letters/digits/`_`/`-`, starting alphanumeric. */
+export declare const ACHIEVEMENT_KEY_PATTERN: RegExp;
+/**
+ * WHO may award the badge — the trust marker a player and the platform UI read.
+ * `platform` is first-party code only; it is in the list because the backend
+ * accepts it, not because a world should use it (see `assertUnlockModeForWorld`).
+ */
+export declare const ACHIEVEMENT_UNLOCK_MODES: readonly ["room", "criteria", "platform"];
+export type AchievementUnlockMode = (typeof ACHIEVEMENT_UNLOCK_MODES)[number];
+export declare const ACHIEVEMENT_CRITERIA_SIGNALS: readonly ["datastore", "iwp", "analytics", "playtime"];
+export type AchievementCriteriaSignal = (typeof ACHIEVEMENT_CRITERIA_SIGNALS)[number];
+export declare const ACHIEVEMENT_CRITERIA_OPS: readonly ["gte", "lte", "eq"];
+export type AchievementCriteriaOp = (typeof ACHIEVEMENT_CRITERIA_OPS)[number];
+export declare const ACHIEVEMENT_CRITERIA_METRICS: readonly ["count", "lix"];
+export type AchievementCriteriaMetric = (typeof ACHIEVEMENT_CRITERIA_METRICS)[number];
+/**
+ * The only two documents a `datastore` criteria may read, and WHICH ONE IS THE
+ * TRUST DECISION: `mp:player:{userId}` is the room's flushed persistent
+ * playerVars (room-only writable ⇒ server-authoritative), `player:{userId}` is
+ * the player's own client-written save (forgeable by its owner, accepted
+ * deliberately — it is how a single-player world unlocks anything).
+ */
+export declare const DATA_STORE_CRITERIA_KEY_TEMPLATES: readonly ["player:{userId}", "mp:player:{userId}"];
+export type DataStoreCriteriaKeyTemplate = (typeof DATA_STORE_CRITERIA_KEY_TEMPLATES)[number];
+/** A `datastore` criteria's `field`: a dot-path of letters, digits and underscores. */
+export declare const DATA_STORE_CRITERIA_FIELD_PATTERN: RegExp;
+/** Backend caps (`ACHIEVEMENT_ICON_MAX_BYTES` / `ACHIEVEMENT_MESH_MAX_BYTES` defaults). */
+export declare const ACHIEVEMENT_ICON_MAX_BYTES: number;
+export declare const ACHIEVEMENT_TROPHY_MAX_BYTES: number;
+/** Smallest square an icon can be and still read as a graphic on a plaque. */
+export declare const MIN_ICON_EDGE = 16;
+/**
+ * Per-channel standard deviation below which the backend treats an image as one
+ * flat colour. Not zero — a real icon that has been through lossy encoding
+ * carries a little noise.
+ */
+export declare const MIN_ICON_STDDEV = 1;
+export declare const isAchievementKey: (value: unknown) => value is string;
+/** Content type for the required `image` part — the 2D badge graphic. */
+export declare function iconContentTypeFromExtension(file: string): string;
+/**
+ * What the backend's `assertValidAchievementIcon` checks, mirrored so a
+ * placeholder fails in a second instead of after an upload + a moderation pass.
+ * The two rejections are the two placeholders creators actually send: an image
+ * too small to read, and a single flat colour. Deliberately NOT a quality
+ * judgement — a two-tone glyph or a flat logo on a plate passes.
+ */
+export declare function assertIconLooksReal(bytes: Uint8Array, file: string): Promise<void>;
+export type AchievementCriteria = {
+    signal: AchievementCriteriaSignal;
+    op: AchievementCriteriaOp;
+    value: number;
+    eventName?: string;
+    key?: DataStoreCriteriaKeyTemplate;
+    field?: string;
+    metric?: AchievementCriteriaMetric;
+};
+export type AchievementCriteriaInput = {
+    signal?: string;
+    op?: string;
+    value?: number;
+    eventName?: string;
+    key?: string;
+    field?: string;
+    metric?: string;
+};
+/** True when any criteria field was supplied — i.e. the caller means `criteria`. */
+export declare function hasCriteriaInput(input: AchievementCriteriaInput | undefined): boolean;
+/**
+ * Validate + normalize the criteria the way the backend's `normalizeCriteria`
+ * does, and throw the same failures. Returns the exact object sent as the
+ * multipart `criteria` JSON string — no key the caller did not set.
+ */
+export declare function buildAchievementCriteria(input: AchievementCriteriaInput): AchievementCriteria;
+/** One-line human summary of a stored criteria — the `list` column and the register echo. */
+export declare function formatAchievementCriteria(criteria: AchievementCriteria | null | undefined): string;
+export type AchievementRegistrationInput = {
+    key: string;
+    name: string;
+    description?: string;
+    points?: number;
+    hidden?: boolean;
+    unlockMode?: string;
+    criteria?: AchievementCriteriaInput;
+};
+export type AchievementRegistrationFields = {
+    key: string;
+    name: string;
+    description?: string;
+    points?: number;
+    hidden?: boolean;
+    unlockMode: AchievementUnlockMode;
+    criteria?: AchievementCriteria;
+};
+export type AchievementRegistrationPlan = {
+    fields: AchievementRegistrationFields;
+    warnings: string[];
+};
+/**
+ * Resolve the trust marker. The backend's DTO defaults to `platform` because the
+ * ADMIN path (worldId omitted) is the one that needs it; for a WORLD
+ * registration `platform` is a mislabel — nothing in a world is first-party
+ * code. So this CLI always sends an explicit mode: `criteria` when a condition
+ * was declared, otherwise `room`, the only thing a world can actually award
+ * (the `awardAchievement` rule effect).
+ */
+export declare function resolveUnlockMode(explicit: string | undefined, hasCriteria: boolean): AchievementUnlockMode;
+/**
+ * Build the multipart text fields, applying every local rule first. Keys the
+ * caller did not set are OMITTED rather than sent empty — an empty description
+ * and no description are the same row, and sending "" would overwrite nothing
+ * while looking like intent.
+ */
+export declare function buildAchievementRegistration(input: AchievementRegistrationInput): AchievementRegistrationPlan;
+export type AchievementUpdateInput = {
+    name?: string;
+    description?: string;
+    points?: number;
+    hidden?: boolean;
+    active?: boolean;
+};
+/** Validate a PATCH body locally and refuse an empty one (a no-op round trip that reads as success). */
+export declare function buildAchievementUpdate(input: AchievementUpdateInput): AchievementUpdateInput;