@oxyhq/contracts 0.14.0 → 0.14.2

package/dist/types/deviceSession.d.ts

@@ -315,3 +315,45 @@ export type DeviceHubTicketIssueRequest = z.infer<typeof deviceHubTicketIssueReq
 export type DeviceHubTicketIssueResponse = z.infer<typeof deviceHubTicketIssueResponseSchema>;
 export type DeviceHubTicketRedeemRequest = z.infer<typeof deviceHubTicketRedeemRequestSchema>;
 export type DeviceHubTicketRedeemResponse = z.infer<typeof deviceHubTicketRedeemResponseSchema>;
+/**
+ * Name of the token-free Socket.IO event emitted to room `user:<userId>` on
+ * every DeviceSession mutation that changes what is signed in for that user.
+ *
+ * This is a pure SIGNAL — it carries NO access token, NO deviceSecret and NO
+ * account bodies. A client that receives it re-fetches its authenticated
+ * session/account state (`GET /session/device/state`, `GET /accounts`). Unlike
+ * `session_state` (scoped to `device:<deviceId>`, i.e. a single origin), this
+ * reaches ALL of a user's connected sockets across their devices/origins so
+ * every Oxy app reflects an add / switch / signout instantly.
+ */
+export declare const SESSION_ACCOUNTS_CHANGED_EVENT = "session_accounts_changed";
+/**
+ * Why the signed-in set changed:
+ *  - `login`   — a brand-new session was minted for the user (QR / cross-app authorize)
+ *  - `add`     — an account was registered onto a device set
+ *  - `switch`  — the active account on a device changed
+ *  - `signout` — one or all accounts were signed out of a device
+ *  - `revoke`  — a dead/revoked account was healed out of a device set
+ */
+export declare const sessionAccountsChangedReasonSchema: z.ZodEnum<["login", "add", "switch", "signout", "revoke"]>;
+/**
+ * Payload of {@link SESSION_ACCOUNTS_CHANGED_EVENT}. `revision` is the mutated
+ * DeviceSession revision for device-scoped reasons (`add`/`switch`/`signout`/
+ * `revoke`); for `login` (no device mutation at emit time) it is `0`. The
+ * payload is deliberately minimal and secret-free — the client refetches.
+ */
+export declare const sessionAccountsChangedEventSchema: z.ZodObject<{
+    userId: z.ZodString;
+    revision: z.ZodNumber;
+    reason: z.ZodEnum<["login", "add", "switch", "signout", "revoke"]>;
+}, "strip", z.ZodTypeAny, {
+    userId: string;
+    reason: "login" | "add" | "switch" | "signout" | "revoke";
+    revision: number;
+}, {
+    userId: string;
+    reason: "login" | "add" | "switch" | "signout" | "revoke";
+    revision: number;
+}>;
+export type SessionAccountsChangedReason = z.infer<typeof sessionAccountsChangedReasonSchema>;
+export type SessionAccountsChangedEvent = z.infer<typeof sessionAccountsChangedEventSchema>;

package/dist/types/identity.d.ts

@@ -277,12 +277,17 @@ export type DomainVerificationInstructions = z.infer<typeof domainVerificationIn
  * One linked authentication method. Mirrors a `User.authMethods[]` entry.
  * `verificationMethodId` is present for `identity` methods (a key) and absent
  * for `password`/social methods, linking the auth method to its DID
- * verification-method fragment.
+ * verification-method fragment. For `webauthn` methods `credentialId` identifies
+ * the specific passkey (one entry per registered credential) and `name` is its
+ * user-facing label; a passkey is NOT a DID verification method, so it carries
+ * no `verificationMethodId` (a passkey-only account stays custodial).
  */
 export interface AuthMethodEntry {
-    type: 'identity' | 'password' | 'google' | 'apple' | 'github';
+    type: 'identity' | 'password' | 'google' | 'apple' | 'github' | 'webauthn';
     linkedAt: string | Date;
     verificationMethodId?: string;
+    credentialId?: string;
+    name?: string;
 }
 export declare const authMethodEntrySchema: z.ZodType<AuthMethodEntry>;
 /**

package/dist/types/index.d.ts

@@ -27,7 +27,11 @@ export { publicCardSchema, signedPublicCardSchema, realLifeAttestationRecordSche
 export type { CardTrustTier, PersonhoodStatus, PublicCard, SignedPublicCard, RealLifeAttestationRecord, RealLifeAttestationResult, ValidationVerdict, ValidationRequestStatus, ValidationVerdictRecord, ValidationOpenRequest, ValidationOpenResult, ValidationRequestSummary, ValidationVoteResult, PersonhoodVouchRecord, PersonhoodBreakdown, PersonhoodStatusResult, VouchResult, CredentialStatus, CredentialRecord, VerifiableCredentialResponse, CredentialIssueResult, CredentialListResult, CredentialVerifyResult, } from './civic';
 export { linkPreviewSchema, linkPreviewBatchRequestSchema, linkPreviewBatchResponseSchema, linkPreviewResponseSchema, } from './links';
 export type { LinkPreviewStatus, LinkPreview, LinkPreviewBatchRequest, LinkPreviewBatchResponse, } from './links';
-export { sessionAccountSchema, deviceSessionStateSchema, activeTokenSchema, deviceSessionSyncSchema, deviceTokenMintRequestSchema, deviceTokenMintResponseSchema, deviceHubTicketIssueRequestSchema, deviceHubTicketIssueResponseSchema, deviceHubTicketRedeemRequestSchema, deviceHubTicketRedeemResponseSchema, } from './deviceSession';
-export type { SessionAccount, DeviceSessionState, ActiveToken, DeviceSessionSync, DeviceTokenMintRequest, DeviceTokenMintResponse, DeviceHubTicketIssueRequest, DeviceHubTicketIssueResponse, DeviceHubTicketRedeemRequest, DeviceHubTicketRedeemResponse, } from './deviceSession';
+export { sessionAccountSchema, deviceSessionStateSchema, activeTokenSchema, deviceSessionSyncSchema, deviceTokenMintRequestSchema, deviceTokenMintResponseSchema, deviceHubTicketIssueRequestSchema, deviceHubTicketIssueResponseSchema, deviceHubTicketRedeemRequestSchema, deviceHubTicketRedeemResponseSchema, SESSION_ACCOUNTS_CHANGED_EVENT, sessionAccountsChangedReasonSchema, sessionAccountsChangedEventSchema, } from './deviceSession';
+export type { SessionAccount, DeviceSessionState, ActiveToken, DeviceSessionSync, DeviceTokenMintRequest, DeviceTokenMintResponse, DeviceHubTicketIssueRequest, DeviceHubTicketIssueResponse, DeviceHubTicketRedeemRequest, DeviceHubTicketRedeemResponse, SessionAccountsChangedReason, SessionAccountsChangedEvent, } from './deviceSession';
 export { loginResultSchema, } from './deviceBoot';
 export type { LoginTwoFactorRequired, LoginSessionResult, LoginResult, SecurityAlert, SecurityAlertAnomaly, } from './deviceBoot';
+export { updatePlatformSchema, updateStatusSchema, updateAssetStatusSchema, sha256HexSchema, channelNameSchema, runtimeVersionSchema, rolloutPercentSchema, assetInitItemSchema, assetInitRequestSchema, assetUploadTicketSchema, assetInitResponseSchema, assetCompleteRequestSchema, assetCompleteResultItemSchema, assetCompleteResponseSchema, updateAssetRefSchema, createUpdateRequestSchema, updateSchema, createUpdateResponseSchema, rollbackToEmbeddedEntrySchema, channelSchema, channelListResponseSchema, updateListResponseSchema, rollbackRequestSchema, rollbackToEmbeddedRequestSchema, promoteRequestSchema, updateRolloutPatchSchema, } from './updates';
+export type { UpdatePlatform, UpdateStatus, UpdateAssetStatus, AssetInitItem, AssetInitRequest, AssetUploadTicket, AssetInitResponse, AssetCompleteRequest, AssetCompleteResultItem, AssetCompleteResponse, UpdateAssetRef, CreateUpdateRequest, Update, CreateUpdateResponse, RollbackToEmbeddedEntry, Channel, ChannelListResponse, UpdateListResponse, RollbackRequest, RollbackToEmbeddedRequest, PromoteRequest, UpdateRolloutPatch, } from './updates';
+export { webauthnRegisterOptionsRequestSchema, webauthnLoginOptionsRequestSchema, webauthnRegisterVerifyRequestSchema, webauthnLoginVerifyRequestSchema, } from './webauthn';
+export type { WebauthnRegisterOptionsRequest, WebauthnLoginOptionsRequest, WebauthnRegisterVerifyRequest, WebauthnLoginVerifyRequest, } from './webauthn';

package/dist/types/updates.d.ts

@@ -0,0 +1,535 @@
+/**
+ * Oxy Updates (self-hosted expo-updates protocol) — publish/admin API contracts.
+ *
+ * SINGLE SOURCE OF TRUTH for the wire shape of the AUTHENTICATED publish/admin
+ * surface that the `oxy-ship` CLI and the console Updates tab call. The PUBLIC
+ * manifest endpoint (`GET /updates/v1/apps/:clientId/manifest`) speaks the
+ * expo-updates v1 protocol verbatim (multipart/mixed, signed) and is therefore
+ * NOT modelled here — its shape is dictated by the Expo spec, not by us.
+ *
+ * The API validates its OUTPUT against these schemas; every consumer (the ship
+ * CLI, the console hook) validates its INPUT against the same definitions, so
+ * producer and consumers cannot drift.
+ *
+ * Domain model (mirrors the Mongoose models in `@oxyhq/api`):
+ *  - A `channel` (e.g. `production`, `preview`, `pr-123`) is a named release
+ *    track for one application.
+ *  - An `update` is one published bundle for a single `(channel, runtimeVersion,
+ *    platform)`. Its `updateId` is a UUIDv4 (the client parses it as a UUID).
+ *    The HEAD of a track is the newest `published` update for that tuple.
+ *  - An `asset` is content-addressed by its `sha256`; assets are shared across
+ *    updates and applications (an unchanged JS bundle is uploaded once).
+ *
+ * Platform-agnostic — zod only, no react/react-native/expo. ESM-safe (no
+ * `require()`).
+ */
+import { z } from 'zod';
+/** The two platforms the expo-updates protocol addresses. */
+export declare const updatePlatformSchema: z.ZodEnum<["ios", "android"]>;
+export type UpdatePlatform = z.infer<typeof updatePlatformSchema>;
+/** Lifecycle of a single published update row. */
+export declare const updateStatusSchema: z.ZodEnum<["published", "superseded", "rolled_back"]>;
+export type UpdateStatus = z.infer<typeof updateStatusSchema>;
+/** Upload lifecycle of a content-addressed asset. */
+export declare const updateAssetStatusSchema: z.ZodEnum<["pending", "uploaded"]>;
+export type UpdateAssetStatus = z.infer<typeof updateAssetStatusSchema>;
+/** Lowercase-hex SHA-256 content hash (64 hex chars). */
+export declare const sha256HexSchema: z.ZodString;
+/**
+ * A channel name. Constrained to a URL/path-safe slug so it can appear in the
+ * `expo-channel-name` header and be used CI-friendly for `pr-<n>` tracks. No
+ * colon (BullMQ/id safety) and no slash (path safety).
+ */
+export declare const channelNameSchema: z.ZodString;
+/** A runtime version string (expo-updates `runtimeVersion`, e.g. an appVersion). */
+export declare const runtimeVersionSchema: z.ZodString;
+/** A rollout percentage: 0 rolls out to nobody, 100 to everybody. */
+export declare const rolloutPercentSchema: z.ZodNumber;
+/**
+ * One asset the client intends to upload as part of an update. `sha256` is the
+ * content hash (dedup key); `contentType` and `size` describe the object the
+ * server will accept at the presigned URL.
+ */
+export declare const assetInitItemSchema: z.ZodObject<{
+    sha256: z.ZodString;
+    contentType: z.ZodString;
+    size: z.ZodNumber;
+}, "strip", z.ZodTypeAny, {
+    sha256: string;
+    contentType: string;
+    size: number;
+}, {
+    sha256: string;
+    contentType: string;
+    size: number;
+}>;
+export type AssetInitItem = z.infer<typeof assetInitItemSchema>;
+/**
+ * `POST /updates/v1/assets/init` request. Declares the full asset set of an
+ * update; the server replies with a presigned PUT for every asset it does NOT
+ * already hold (content-addressed dedup — unchanged assets are never re-uploaded).
+ */
+export declare const assetInitRequestSchema: z.ZodObject<{
+    applicationId: z.ZodString;
+    assets: z.ZodArray<z.ZodObject<{
+        sha256: z.ZodString;
+        contentType: z.ZodString;
+        size: z.ZodNumber;
+    }, "strip", z.ZodTypeAny, {
+        sha256: string;
+        contentType: string;
+        size: number;
+    }, {
+        sha256: string;
+        contentType: string;
+        size: number;
+    }>, "many">;
+}, "strip", z.ZodTypeAny, {
+    applicationId: string;
+    assets: {
+        sha256: string;
+        contentType: string;
+        size: number;
+    }[];
+}, {
+    applicationId: string;
+    assets: {
+        sha256: string;
+        contentType: string;
+        size: number;
+    }[];
+}>;
+export type AssetInitRequest = z.infer<typeof assetInitRequestSchema>;
+/** One presigned upload the client must PUT its bytes to before completing. */
+export declare const assetUploadTicketSchema: z.ZodObject<{
+    sha256: z.ZodString;
+    /** Presigned S3 PUT URL. The client PUTs the exact bytes here. */
+    uploadUrl: z.ZodString;
+    /** The S3 key the object will live at (`public/updates/assets/<sha256>`). */
+    storageKey: z.ZodString;
+    /** The Content-Type the presigned URL was signed for; echo it on the PUT. */
+    contentType: z.ZodString;
+    /**
+     * The Cache-Control the presigned URL was signed for; the client MUST send it
+     * verbatim on the PUT so the SigV4 signature matches and the stored object
+     * carries the long immutable cache header (assets are content-addressed).
+     */
+    cacheControl: z.ZodString;
+}, "strip", z.ZodTypeAny, {
+    sha256: string;
+    contentType: string;
+    uploadUrl: string;
+    storageKey: string;
+    cacheControl: string;
+}, {
+    sha256: string;
+    contentType: string;
+    uploadUrl: string;
+    storageKey: string;
+    cacheControl: string;
+}>;
+export type AssetUploadTicket = z.infer<typeof assetUploadTicketSchema>;
+/**
+ * `POST /updates/v1/assets/init` response. `missing` holds a presigned upload
+ * for each asset the server does not yet have; `existing` lists the sha256s it
+ * already holds (the client skips those).
+ */
+export declare const assetInitResponseSchema: z.ZodObject<{
+    missing: z.ZodArray<z.ZodObject<{
+        sha256: z.ZodString;
+        /** Presigned S3 PUT URL. The client PUTs the exact bytes here. */
+        uploadUrl: z.ZodString;
+        /** The S3 key the object will live at (`public/updates/assets/<sha256>`). */
+        storageKey: z.ZodString;
+        /** The Content-Type the presigned URL was signed for; echo it on the PUT. */
+        contentType: z.ZodString;
+        /**
+         * The Cache-Control the presigned URL was signed for; the client MUST send it
+         * verbatim on the PUT so the SigV4 signature matches and the stored object
+         * carries the long immutable cache header (assets are content-addressed).
+         */
+        cacheControl: z.ZodString;
+    }, "strip", z.ZodTypeAny, {
+        sha256: string;
+        contentType: string;
+        uploadUrl: string;
+        storageKey: string;
+        cacheControl: string;
+    }, {
+        sha256: string;
+        contentType: string;
+        uploadUrl: string;
+        storageKey: string;
+        cacheControl: string;
+    }>, "many">;
+    existing: z.ZodArray<z.ZodString, "many">;
+}, "strip", z.ZodTypeAny, {
+    missing: {
+        sha256: string;
+        contentType: string;
+        uploadUrl: string;
+        storageKey: string;
+        cacheControl: string;
+    }[];
+    existing: string[];
+}, {
+    missing: {
+        sha256: string;
+        contentType: string;
+        uploadUrl: string;
+        storageKey: string;
+        cacheControl: string;
+    }[];
+    existing: string[];
+}>;
+export type AssetInitResponse = z.infer<typeof assetInitResponseSchema>;
+/**
+ * `POST /updates/v1/assets/complete` request. Sent after the client has PUT
+ * every `missing` asset. The server HEADs each object and flips it to
+ * `uploaded`; an object that is absent or size-mismatched is rejected.
+ */
+export declare const assetCompleteRequestSchema: z.ZodObject<{
+    applicationId: z.ZodString;
+    sha256s: z.ZodArray<z.ZodString, "many">;
+}, "strip", z.ZodTypeAny, {
+    applicationId: string;
+    sha256s: string[];
+}, {
+    applicationId: string;
+    sha256s: string[];
+}>;
+export type AssetCompleteRequest = z.infer<typeof assetCompleteRequestSchema>;
+/** Per-asset verification outcome from `assets/complete`. */
+export declare const assetCompleteResultItemSchema: z.ZodObject<{
+    sha256: z.ZodString;
+    status: z.ZodEnum<["pending", "uploaded"]>;
+    size: z.ZodNumber;
+}, "strip", z.ZodTypeAny, {
+    status: "pending" | "uploaded";
+    sha256: string;
+    size: number;
+}, {
+    status: "pending" | "uploaded";
+    sha256: string;
+    size: number;
+}>;
+export type AssetCompleteResultItem = z.infer<typeof assetCompleteResultItemSchema>;
+export declare const assetCompleteResponseSchema: z.ZodObject<{
+    assets: z.ZodArray<z.ZodObject<{
+        sha256: z.ZodString;
+        status: z.ZodEnum<["pending", "uploaded"]>;
+        size: z.ZodNumber;
+    }, "strip", z.ZodTypeAny, {
+        status: "pending" | "uploaded";
+        sha256: string;
+        size: number;
+    }, {
+        status: "pending" | "uploaded";
+        sha256: string;
+        size: number;
+    }>, "many">;
+}, "strip", z.ZodTypeAny, {
+    assets: {
+        status: "pending" | "uploaded";
+        sha256: string;
+        size: number;
+    }[];
+}, {
+    assets: {
+        status: "pending" | "uploaded";
+        sha256: string;
+        size: number;
+    }[];
+}>;
+export type AssetCompleteResponse = z.infer<typeof assetCompleteResponseSchema>;
+/**
+ * A single asset reference inside a create-update request. `key` is the
+ * expo-export asset key (the md5-basename the client uses to look the asset up
+ * and skip embedded ones); `fileExtension` is the suggested on-disk extension.
+ */
+export declare const updateAssetRefSchema: z.ZodObject<{
+    sha256: z.ZodString;
+    /** expo-export asset key (md5 basename) — how app code references the asset. */
+    key: z.ZodString;
+    contentType: z.ZodString;
+    /** Suggested file extension including the leading dot (e.g. `.js`, `.png`). */
+    fileExtension: z.ZodOptional<z.ZodString>;
+}, "strip", z.ZodTypeAny, {
+    sha256: string;
+    contentType: string;
+    key: string;
+    fileExtension?: string | undefined;
+}, {
+    sha256: string;
+    contentType: string;
+    key: string;
+    fileExtension?: string | undefined;
+}>;
+export type UpdateAssetRef = z.infer<typeof updateAssetRefSchema>;
+/**
+ * `POST /updates/v1/updates` request. Publishes one bundle for one platform to a
+ * channel (the channel is created on demand — CI-friendly for `pr-<n>`). All
+ * referenced assets MUST already be `uploaded` (via init/complete). `extra`
+ * MUST carry `expoClient` so `Constants.expoConfig` works after an OTA update.
+ */
+export declare const createUpdateRequestSchema: z.ZodObject<{
+    applicationId: z.ZodString;
+    channel: z.ZodString;
+    runtimeVersion: z.ZodString;
+    platform: z.ZodEnum<["ios", "android"]>;
+    /** The launch (entry-point) asset — its `fileExtension` is ignored by clients. */
+    launchAsset: z.ZodObject<{
+        sha256: z.ZodString;
+        /** expo-export asset key (md5 basename) — how app code references the asset. */
+        key: z.ZodString;
+        contentType: z.ZodString;
+        /** Suggested file extension including the leading dot (e.g. `.js`, `.png`). */
+        fileExtension: z.ZodOptional<z.ZodString>;
+    }, "strip", z.ZodTypeAny, {
+        sha256: string;
+        contentType: string;
+        key: string;
+        fileExtension?: string | undefined;
+    }, {
+        sha256: string;
+        contentType: string;
+        key: string;
+        fileExtension?: string | undefined;
+    }>;
+    assets: z.ZodArray<z.ZodObject<{
+        sha256: z.ZodString;
+        /** expo-export asset key (md5 basename) — how app code references the asset. */
+        key: z.ZodString;
+        contentType: z.ZodString;
+        /** Suggested file extension including the leading dot (e.g. `.js`, `.png`). */
+        fileExtension: z.ZodOptional<z.ZodString>;
+    }, "strip", z.ZodTypeAny, {
+        sha256: string;
+        contentType: string;
+        key: string;
+        fileExtension?: string | undefined;
+    }, {
+        sha256: string;
+        contentType: string;
+        key: string;
+        fileExtension?: string | undefined;
+    }>, "many">;
+    /**
+     * Opaque `extra` blob embedded verbatim in the signed manifest. MUST contain
+     * `expoClient` (the public expo config) so `Constants.expoConfig` resolves
+     * after an OTA update; MAY carry other third-party config.
+     */
+    extra: z.ZodObject<{
+        expoClient: z.ZodRecord<z.ZodString, z.ZodUnknown>;
+    }, "strip", z.ZodUnknown, z.objectOutputType<{
+        expoClient: z.ZodRecord<z.ZodString, z.ZodUnknown>;
+    }, z.ZodUnknown, "strip">, z.objectInputType<{
+        expoClient: z.ZodRecord<z.ZodString, z.ZodUnknown>;
+    }, z.ZodUnknown, "strip">>;
+    /** String→string metadata dict; filtered client-side via manifest filters. */
+    metadata: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodString>>;
+    /** Initial rollout percentage (default 100 — full rollout). */
+    rolloutPercent: z.ZodOptional<z.ZodNumber>;
+    /** Git commit the bundle was built from (audit / console display). */
+    gitCommit: z.ZodOptional<z.ZodString>;
+    /** Git branch the bundle was built from (audit / console display). */
+    gitBranch: z.ZodOptional<z.ZodString>;
+    /** Human-readable publish message (console display). */
+    message: z.ZodOptional<z.ZodString>;
+}, "strip", z.ZodTypeAny, {
+    applicationId: string;
+    assets: {
+        sha256: string;
+        contentType: string;
+        key: string;
+        fileExtension?: string | undefined;
+    }[];
+    channel: string;
+    runtimeVersion: string;
+    platform: "ios" | "android";
+    launchAsset: {
+        sha256: string;
+        contentType: string;
+        key: string;
+        fileExtension?: string | undefined;
+    };
+    extra: {
+        expoClient: Record<string, unknown>;
+    } & {
+        [k: string]: unknown;
+    };
+    message?: string | undefined;
+    metadata?: Record<string, string> | undefined;
+    rolloutPercent?: number | undefined;
+    gitCommit?: string | undefined;
+    gitBranch?: string | undefined;
+}, {
+    applicationId: string;
+    assets: {
+        sha256: string;
+        contentType: string;
+        key: string;
+        fileExtension?: string | undefined;
+    }[];
+    channel: string;
+    runtimeVersion: string;
+    platform: "ios" | "android";
+    launchAsset: {
+        sha256: string;
+        contentType: string;
+        key: string;
+        fileExtension?: string | undefined;
+    };
+    extra: {
+        expoClient: Record<string, unknown>;
+    } & {
+        [k: string]: unknown;
+    };
+    message?: string | undefined;
+    metadata?: Record<string, string> | undefined;
+    rolloutPercent?: number | undefined;
+    gitCommit?: string | undefined;
+    gitBranch?: string | undefined;
+}>;
+export type CreateUpdateRequest = z.infer<typeof createUpdateRequestSchema>;
+/**
+ * A published update as returned by the read/admin endpoints. `id` is the
+ * update's UUIDv4 (the manifest `id`). Declared as an explicit interface (schema
+ * annotated `z.ZodType<Update>`) so the nested shape survives a consumer's
+ * `moduleResolution: "node"`, matching the convention in the other contracts.
+ */
+export interface Update {
+    id: string;
+    applicationId: string;
+    channel: string;
+    runtimeVersion: string;
+    platform: UpdatePlatform;
+    status: UpdateStatus;
+    rolloutPercent: number;
+    launchAssetSha256: string;
+    assetSha256s: string[];
+    gitCommit?: string;
+    gitBranch?: string;
+    message?: string;
+    /** The updateId this update was promoted from, when it is a promotion. */
+    promotedFromUpdateId?: string;
+    createdAt: string;
+    updatedAt: string;
+}
+export declare const updateSchema: z.ZodType<Update>;
+export declare const createUpdateResponseSchema: z.ZodObject<{
+    update: z.ZodType<Update, z.ZodTypeDef, Update>;
+}, "strip", z.ZodTypeAny, {
+    update: Update;
+}, {
+    update: Update;
+}>;
+export type CreateUpdateResponse = z.infer<typeof createUpdateResponseSchema>;
+/** One `rollBackToEmbedded` directive currently active on a channel. */
+export interface RollbackToEmbeddedEntry {
+    runtimeVersion: string;
+    platform: UpdatePlatform;
+    /** ISO 8601 datetime; the client rolls back updates created before this. */
+    commitTime: string;
+}
+export declare const rollbackToEmbeddedEntrySchema: z.ZodType<RollbackToEmbeddedEntry>;
+/** A release channel with its currently-active rollback-to-embedded directives. */
+export interface Channel {
+    id: string;
+    applicationId: string;
+    name: string;
+    rollbacksToEmbedded: RollbackToEmbeddedEntry[];
+    createdAt: string;
+    updatedAt: string;
+}
+export declare const channelSchema: z.ZodType<Channel>;
+export declare const channelListResponseSchema: z.ZodObject<{
+    channels: z.ZodArray<z.ZodType<Channel, z.ZodTypeDef, Channel>, "many">;
+}, "strip", z.ZodTypeAny, {
+    channels: Channel[];
+}, {
+    channels: Channel[];
+}>;
+export type ChannelListResponse = z.infer<typeof channelListResponseSchema>;
+export declare const updateListResponseSchema: z.ZodObject<{
+    updates: z.ZodArray<z.ZodType<Update, z.ZodTypeDef, Update>, "many">;
+}, "strip", z.ZodTypeAny, {
+    updates: Update[];
+}, {
+    updates: Update[];
+}>;
+export type UpdateListResponse = z.infer<typeof updateListResponseSchema>;
+/**
+ * `POST /updates/v1/channels/:channel/rollback` request. Marks the current head
+ * for `(runtimeVersion, platform)` `rolled_back` so the previous published
+ * update (if any) becomes head again. Nothing is deleted.
+ */
+export declare const rollbackRequestSchema: z.ZodObject<{
+    applicationId: z.ZodString;
+    runtimeVersion: z.ZodString;
+    platform: z.ZodEnum<["ios", "android"]>;
+}, "strip", z.ZodTypeAny, {
+    applicationId: string;
+    runtimeVersion: string;
+    platform: "ios" | "android";
+}, {
+    applicationId: string;
+    runtimeVersion: string;
+    platform: "ios" | "android";
+}>;
+export type RollbackRequest = z.infer<typeof rollbackRequestSchema>;
+/**
+ * `POST /updates/v1/channels/:channel/rollback-to-embedded` request. Records a
+ * `rollBackToEmbedded` directive so clients on this `(runtimeVersion, platform)`
+ * fall back to the update embedded in their binary.
+ */
+export declare const rollbackToEmbeddedRequestSchema: z.ZodObject<{
+    applicationId: z.ZodString;
+    runtimeVersion: z.ZodString;
+    platform: z.ZodEnum<["ios", "android"]>;
+}, "strip", z.ZodTypeAny, {
+    applicationId: string;
+    runtimeVersion: string;
+    platform: "ios" | "android";
+}, {
+    applicationId: string;
+    runtimeVersion: string;
+    platform: "ios" | "android";
+}>;
+export type RollbackToEmbeddedRequest = z.infer<typeof rollbackToEmbeddedRequestSchema>;
+/**
+ * `POST /updates/v1/channels/:channel/promote` request. Promotes an existing
+ * update (by `updateId`) into the target channel by creating a NEW update (new
+ * UUID) pointing at the SAME assets. `toChannel` defaults to the path channel.
+ */
+export declare const promoteRequestSchema: z.ZodObject<{
+    applicationId: z.ZodString;
+    updateId: z.ZodString;
+    /** Target channel to promote into. Defaults to the path `:channel`. */
+    toChannel: z.ZodOptional<z.ZodString>;
+    /** Rollout percentage for the promoted update (default 100). */
+    rolloutPercent: z.ZodOptional<z.ZodNumber>;
+}, "strip", z.ZodTypeAny, {
+    applicationId: string;
+    updateId: string;
+    rolloutPercent?: number | undefined;
+    toChannel?: string | undefined;
+}, {
+    applicationId: string;
+    updateId: string;
+    rolloutPercent?: number | undefined;
+    toChannel?: string | undefined;
+}>;
+export type PromoteRequest = z.infer<typeof promoteRequestSchema>;
+/** `PATCH /updates/v1/updates/:updateId` request — adjust a rollout in place. */
+export declare const updateRolloutPatchSchema: z.ZodObject<{
+    applicationId: z.ZodString;
+    rolloutPercent: z.ZodNumber;
+}, "strip", z.ZodTypeAny, {
+    applicationId: string;
+    rolloutPercent: number;
+}, {
+    applicationId: string;
+    rolloutPercent: number;
+}>;
+export type UpdateRolloutPatch = z.infer<typeof updateRolloutPatchSchema>;