@uxnan/shared 0.0.1-alpha.20260627

package/dist/src/models/git.d.ts

@@ -0,0 +1,191 @@
+/**
+ * Git models exchanged over JSON-RPC (git/* methods).
+ *
+ * Source: architecture/02a-system-architecture.md §5.8.6 and
+ * architecture/02b-contracts-and-requirements.md.
+ */
+export type GitFileStatus = 'added' | 'modified' | 'deleted' | 'renamed' | 'untracked' | 'conflicted';
+export interface GitChangedFile {
+    path: string;
+    status: GitFileStatus;
+    /** Lines added (working tree vs HEAD). Untracked files report 0. */
+    additions?: number;
+    /** Lines removed (working tree vs HEAD). Untracked files report 0. */
+    deletions?: number;
+}
+export interface GitDiffTotals {
+    additions: number;
+    deletions: number;
+    changedFileCount: number;
+}
+export interface GitRepoStatus {
+    branch: string;
+    upstream?: string;
+    isDirty: boolean;
+    ahead: number;
+    behind: number;
+    files: GitChangedFile[];
+    /** Aggregate working-tree counters. */
+    diffTotals?: GitDiffTotals;
+}
+export interface GitDiff {
+    /** Unified diff text. */
+    diff: string;
+    additions: number;
+    deletions: number;
+}
+export interface GitCommitResult {
+    sha: string;
+    message: string;
+}
+export interface GitPushResult {
+    success: boolean;
+    remote: string;
+    branch: string;
+}
+export interface GitPullResult {
+    success: boolean;
+}
+export interface GitBranchResult {
+    branch: string;
+}
+export interface GitWorktreeResult {
+    path: string;
+    branch: string;
+}
+export interface GitBranchList {
+    /** The currently checked-out branch (`HEAD` when detached). */
+    current: string;
+    /** Local branch names. */
+    local: string[];
+    /** Remote-tracking branch names (e.g. `origin/main`). */
+    remote: string[];
+}
+export interface GitPrResult {
+    /** URL of the created (or pre-existing) pull request. */
+    url: string;
+    /** PR number when the host CLI reports it. */
+    number?: number;
+}
+/** Kind of ref pointing at a commit (decoration parsed from `git log %D`). */
+export type GitRefType = 'head' | 'branch' | 'remoteBranch' | 'tag';
+/**
+ * A ref (branch / remote branch / tag / HEAD) that points at a commit.
+ * Parsed from `git log`'s `%D` decoration so the phone can render branch
+ * and tag chips and colour HEAD distinctly in the graph.
+ */
+export interface GitRef {
+    /** Display name (e.g. `main`, `origin/main`, `v1.2.0`, `HEAD`). */
+    name: string;
+    /** What the ref is. */
+    type: GitRefType;
+}
+/**
+ * A single commit in the repository log. The bridge parses `git log` into
+ * this shape; the phone renders it in either the flat list view or the
+ * graph (GitKraken-style) view. `parents` is what powers the graph —
+ * each parent is a "lane" the commit sits on.
+ */
+export interface GitCommit {
+    /** Full 40-char SHA. */
+    sha: string;
+    /** Abbreviated SHA (7 chars, git's default). */
+    shortSha: string;
+    /** Parent commit SHAs in order (zero, one or two — merge commits have two). */
+    parents: string[];
+    /** Commit author display name. */
+    authorName: string;
+    /** Commit author email. */
+    authorEmail: string;
+    /** Author date, unix epoch seconds. */
+    authorTimestamp: number;
+    /** Committer display name (often equal to author). */
+    committerName: string;
+    /** Committer email. */
+    committerEmail: string;
+    /** Committer date, unix epoch seconds. */
+    committerTimestamp: number;
+    /** First line of the commit message (the "title"). */
+    messageTitle: string;
+    /** Rest of the commit message after the title (may be empty). */
+    messageBody: string;
+    /** Aggregate +/-/file-count stats for the commit (git log --shortstat). */
+    stats?: GitDiffTotals;
+    /**
+     * Refs that point at this commit (branches, remote branches, tags, HEAD),
+     * parsed from `git log`'s `%D` decoration. Absent/empty for commits with no
+     * decoration.
+     */
+    refs?: GitRef[];
+}
+/**
+ * A page of commits for a repository, newest-first in topological order.
+ * Pagination is by opaque cursor: when `hasMore` is true, pass `nextCursor`
+ * back as `GitLogParams.cursor` to fetch the next (older) page.
+ */
+export interface GitLogResult {
+    commits: GitCommit[];
+    hasMore: boolean;
+    /**
+     * Opaque pagination token to pass back as `GitLogParams.cursor` for the next
+     * page. Undefined when `hasMore` is false. (Currently an offset over a
+     * topologically-ordered log — treat it as opaque.)
+     */
+    nextCursor?: string;
+}
+/** Parameters for `git/log`. */
+export interface GitLogParams {
+    cwd: string;
+    /** Max commits to return. Defaults to 50 on the bridge. */
+    limit?: number;
+    /**
+     * Opaque pagination cursor from the previous result's `nextCursor`. Omit for
+     * the first (newest) page. Paging is offset-based over a topologically
+     * ordered log, so no commit is skipped across a merge boundary.
+     */
+    cursor?: string;
+    /**
+     * Optional ref (branch / tag / remote) to start from. Defaults to
+     ` HEAD. Use `origin/main` etc. for an explicit starting point.
+     */
+    ref?: string;
+}
+/**
+ * A single file touched by a commit (`git show --name-status --numstat`).
+ * Rename/copy entries carry the previous path in `oldPath`.
+ */
+export interface GitCommitFile {
+    /** Repository-relative path after the change (the new path on a rename). */
+    path: string;
+    /** Previous path, set only for renames/copies. */
+    oldPath?: string;
+    /** Per-file change kind. */
+    status: GitFileStatus;
+    /** Lines added in this commit (0 for binary/unknown). */
+    additions: number;
+    /** Lines removed in this commit (0 for binary/unknown). */
+    deletions: number;
+    /** True when git reported the file as binary (no line counts). */
+    binary?: boolean;
+}
+/**
+ * Full detail of one commit: its metadata (incl. refs), the list of files it
+ * touched with per-file +/- counts, and the complete unified diff. Powers the
+ * mobile commit-detail view (`git/commitShow`).
+ */
+export interface GitCommitDetails {
+    /** The commit's metadata (same shape as a `git/log` entry). */
+    commit: GitCommit;
+    /** Files touched by the commit, with per-file stats. */
+    files: GitCommitFile[];
+    /** The commit's full unified diff (may be truncated — see `diffTruncated`). */
+    diff: string;
+    /** True when `diff` was capped because the patch exceeded the size budget. */
+    diffTruncated?: boolean;
+}
+/** Parameters for `git/commitShow`. */
+export interface GitCommitShowParams {
+    cwd: string;
+    /** The commit to inspect (full or abbreviated SHA, or any rev). */
+    sha: string;
+}

package/dist/src/models/git.js

@@ -0,0 +1,8 @@
+/**
+ * Git models exchanged over JSON-RPC (git/* methods).
+ *
+ * Source: architecture/02a-system-architecture.md §5.8.6 and
+ * architecture/02b-contracts-and-requirements.md.
+ */
+export {};
+//# sourceMappingURL=git.js.map

package/dist/src/models/git.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"git.js","sourceRoot":"","sources":["../../../src/models/git.ts"],"names":[],"mappings":"AAAA;;;;;GAKG"}

package/dist/src/models/project.d.ts

@@ -0,0 +1,22 @@
+/**
+ * Project models exchanged over JSON-RPC (project/* methods).
+ */
+export interface Project {
+    id: string;
+    name: string;
+    /** Absolute working directory on the PC (never sent verbatim to mobile if sensitive). */
+    cwd: string;
+    /** Agent pinned for this project in bridge config (the thread's default agent). */
+    agentId?: string;
+    /** Model pinned for this project's agent in bridge config, when set. */
+    model?: string;
+}
+export interface AuthStatus {
+    agentId: string;
+    requiresLogin: boolean;
+    loginInProgress: boolean;
+    authenticatedProvider?: string;
+    displayName?: string;
+    transportMode: 'local' | 'relay';
+    platform: NodeJS.Platform | string;
+}

package/dist/src/models/project.js

@@ -0,0 +1,5 @@
+/**
+ * Project models exchanged over JSON-RPC (project/* methods).
+ */
+export {};
+//# sourceMappingURL=project.js.map

package/dist/src/models/project.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"project.js","sourceRoot":"","sources":["../../../src/models/project.ts"],"names":[],"mappings":"AAAA;;GAEG"}

package/dist/src/models/session.d.ts

@@ -0,0 +1,28 @@
+/**
+ * Session and trust models.
+ *
+ * Dart equivalents: `uxnanmobile/lib/domain/entities/{secure_session,trusted_device}.dart`.
+ */
+export type HandshakeMode = 'qr_bootstrap' | 'trusted_reconnect';
+export interface ConnectedPhone {
+    deviceId: string;
+    displayName: string;
+    connectedAt: number;
+    lastSeen: number;
+}
+export interface TrustedDevice {
+    deviceId: string;
+    displayName: string;
+    /** Phone Ed25519 identity public key (hex). */
+    publicKey: string;
+    pairedAt: number;
+    lastSeen?: number;
+}
+export interface BridgeStatus {
+    version: string;
+    relayConnected: boolean;
+    lanEnabled: boolean;
+    activeSessions: number;
+    platform: NodeJS.Platform | string;
+    uptimeMs: number;
+}

package/dist/src/models/session.js

@@ -0,0 +1,7 @@
+/**
+ * Session and trust models.
+ *
+ * Dart equivalents: `uxnanmobile/lib/domain/entities/{secure_session,trusted_device}.dart`.
+ */
+export {};
+//# sourceMappingURL=session.js.map

package/dist/src/models/session.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"session.js","sourceRoot":"","sources":["../../../src/models/session.ts"],"names":[],"mappings":"AAAA;;;;GAIG"}

package/dist/src/models/thread.d.ts

@@ -0,0 +1,104 @@
+/**
+ * Conversation models: Thread, Turn, Message.
+ *
+ * The Dart equivalents live in `uxnanmobile/lib/domain/entities/{thread,turn,message}.dart`
+ * and are kept in sync manually (see 02e-bridge-integration.md §4.2).
+ */
+export type MessageRole = 'user' | 'assistant' | 'system' | 'tool';
+export type TurnStatus = 'pending' | 'streaming' | 'completed' | 'error' | 'aborted';
+export type ThreadStatus = 'active' | 'idle' | 'archived';
+export interface Message {
+    id: string;
+    turnId: string;
+    role: MessageRole;
+    /** Serialized MessageContent blocks (text/code/image/tool/diff/...). */
+    content: unknown;
+    /** The agent's reasoning ("thinking") for this message, when it emitted any. */
+    thinking?: string;
+    /** Structured content blocks (command_execution/diff/tool) produced this turn. */
+    blocks?: unknown[];
+    /**
+     * The assistant message's text runs and structured blocks **in the exact
+     * order the agent produced them** — each entry is a serialized MessageContent
+     * (text runs as `{ type:'text', text }`, work-log/diff blocks as their own
+     * types). When present, a client SHOULD render from this so the work log sits
+     * inline with the response it precedes, instead of all activity collapsing
+     * above one merged paragraph. `content` (the full concatenated text) and
+     * `blocks` are retained for older clients and for re-sync reconciliation: the
+     * text runs in `segments` concatenate to `content`, and its non-text entries
+     * are exactly `blocks`. Absent for turns recovered without ordering info (an
+     * older bridge, or the on-disk history fallback) — clients fall back to
+     * `content` + `blocks` then. Only set on assistant messages.
+     */
+    segments?: unknown[];
+    /** Token usage for this turn, so the phone restores the context meter on re-sync. */
+    usage?: {
+        tokens: number;
+        contextWindow?: number;
+    };
+    createdAt: number;
+}
+export interface Turn {
+    id: string;
+    threadId: string;
+    status: TurnStatus;
+    messages: Message[];
+    createdAt: number;
+    completedAt?: number;
+}
+/**
+ * Per-thread access (approval) mode: how much the agent may do before it must
+ * pause for the user. Persisted on the bridge so the phone's choice survives a
+ * restart and is the source of truth across devices.
+ * - `requestApproval` — ask before each risky action.
+ * - `approveForMe` — auto-approve routine edits.
+ * - `fullAccess` — no approval gating.
+ */
+export type AccessMode = 'requestApproval' | 'approveForMe' | 'fullAccess';
+export interface Thread {
+    id: string;
+    projectId: string;
+    title: string;
+    status: ThreadStatus;
+    turnCount: number;
+    createdAt: number;
+    updatedAt: number;
+    /** Agent driving this thread (e.g. `opencode`, `echo`). */
+    agentId?: string;
+    /** Model the agent uses for this thread (e.g. `provider/model`). */
+    model?: string;
+    /** Absolute working directory the agent and git operations run in. */
+    cwd?: string;
+    /**
+     * The agent CLI's NATIVE session id (Claude `session_id`, Codex `thread_id`,
+     * OpenCode `sessionID`, pi session id), when known. Surfaced so the phone can
+     * show "resume this conversation from the CLI" beyond the bridge thread id.
+     */
+    agentSessionId?: string;
+    /** Per-thread access (approval) mode; see {@link AccessMode}. */
+    accessMode?: AccessMode;
+}
+export interface ThreadList {
+    threads: Thread[];
+}
+export interface TurnList {
+    turns: Turn[];
+    nextCursor?: string;
+    /**
+     * Total number of turns available for the thread, regardless of the page
+     * returned. Lets a client page from the end (newest-first) by computing
+     * offsets without first pulling the whole thread.
+     */
+    total?: number;
+    /**
+     * The turn currently in-flight for this thread (an agent is actively
+     * producing it RIGHT NOW in the bridge process), when one exists. This is the
+     * LIVE AgentManager state, NOT a stored turn's `streaming` status — the latter
+     * can be left dangling after a bridge restart (the agent child process died),
+     * whereas this is cleared the moment the turn completes/errors/aborts and is
+     * absent after a restart. The phone uses it on resync/reconnect to re-attach
+     * its streaming view (the "responding…" indicator + Stop button) to a turn it
+     * stopped tracking while backgrounded, instead of treating the turn as ended.
+     */
+    activeTurnId?: string;
+}

package/dist/src/models/thread.js

@@ -0,0 +1,8 @@
+/**
+ * Conversation models: Thread, Turn, Message.
+ *
+ * The Dart equivalents live in `uxnanmobile/lib/domain/entities/{thread,turn,message}.dart`
+ * and are kept in sync manually (see 02e-bridge-integration.md §4.2).
+ */
+export {};
+//# sourceMappingURL=thread.js.map

package/dist/src/models/thread.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"thread.js","sourceRoot":"","sources":["../../../src/models/thread.ts"],"names":[],"mappings":"AAAA;;;;;GAKG"}

package/dist/src/models/workspace.d.ts

@@ -0,0 +1,133 @@
+/**
+ * Workspace models exchanged over JSON-RPC (workspace/* methods).
+ *
+ * Source: architecture/02a-system-architecture.md §5.8.7.
+ */
+export interface FileContent {
+    path: string;
+    content: string;
+    encoding: 'utf-8' | 'base64';
+}
+export interface ImageContent {
+    path: string;
+    base64Data: string;
+    mimeType: string;
+}
+/**
+ * An image (or other media) attached to a user turn (`turn/send { attachments }`).
+ * Tolerant by design — the phone sends inline base64 with the original
+ * `mimeType`; `path`/`width`/`height` are best-effort metadata. At least one of
+ * `base64Data`/`path` must be present for the bridge to deliver it to the agent.
+ */
+export interface TurnAttachment {
+    /** Wire discriminator (always `image` today). */
+    type?: 'image';
+    /** MIME type, e.g. `image/png`. */
+    mimeType: string;
+    /** Inline base64 payload (no `data:` URI prefix). */
+    base64Data?: string;
+    /** Original/workspace path the image came from, if any. */
+    path?: string;
+    /** Pixel width, if known. */
+    width?: number;
+    /** Pixel height, if known. */
+    height?: number;
+}
+/**
+ * Result of a `workspace/exists` probe: whether a thread's `cwd` still exists
+ * on disk (folders/worktrees can be removed outside the app), so the phone can
+ * mark a thread unavailable instead of failing every action.
+ */
+export interface WorkspaceExistsResult {
+    /** Whether the directory exists. */
+    exists: boolean;
+    /** Whether it is (still) a git repository / worktree, when it exists. */
+    isGitRepo?: boolean;
+}
+export type WorkspaceEntryType = 'file' | 'dir';
+export interface WorkspaceEntry {
+    name: string;
+    type: WorkspaceEntryType;
+    /** Size in bytes (files only; absent for directories or unreadable entries). */
+    size?: number;
+    /**
+     * Last-modified time as epoch milliseconds (files only; absent for
+     * directories or unreadable entries). Lets the file browser show a "modified"
+     * timestamp without a second stat round-trip.
+     */
+    mtime?: number;
+    /**
+     * Whether git ignores this entry (matches a `.gitignore` / exclude rule),
+     * computed per-listing via `git check-ignore`. The file browser dims ignored
+     * entries (muted + italic) to set them apart from tracked/untracked files.
+     * `undefined`/`false` when the entry isn't ignored or the directory isn't a
+     * git repository. This is *not* a `GitFileStatus` — ignored entries never
+     * appear in `git/status`, so the flag rides on the listing instead.
+     */
+    ignored?: boolean;
+}
+export interface WorkspaceListing {
+    cwd: string;
+    entries: WorkspaceEntry[];
+}
+export interface Checkpoint {
+    id: string;
+    threadId?: string;
+    label?: string;
+    createdAt: number;
+}
+export type CheckpointFileStatus = 'added' | 'modified' | 'deleted';
+export interface CheckpointDiff {
+    diff: string;
+    files: {
+        path: string;
+        status: CheckpointFileStatus;
+    }[];
+}
+export type PatchOp = 'add' | 'modify' | 'delete';
+export interface PatchChange {
+    op: PatchOp;
+    path: string;
+    content?: string;
+}
+export interface ApplyResult {
+    success: boolean;
+    applied: number;
+}
+/**
+ * A configured base directory the phone may browse under. The phone can descend
+ * into sub-directories but never above the root (no per-project pre-config).
+ */
+export interface BrowseRoot {
+    /** Stable id derived from the absolute path. */
+    id: string;
+    /** Display name (the root's basename). */
+    name: string;
+    /** Absolute path of the root. */
+    cwd: string;
+}
+/** A sub-directory under the current browse path. */
+export interface BrowseDirEntry {
+    name: string;
+    /** Path relative to the browse root, POSIX separators (e.g. `projects/foo`). */
+    path: string;
+    /** Whether this directory is a git repository. */
+    isGitRepo: boolean;
+}
+/** Result of browsing one directory under a configured {@link BrowseRoot}. */
+export interface BrowseResult {
+    /** All configured roots, so the phone can offer a root picker. */
+    roots: BrowseRoot[];
+    /** Id of the root currently being browsed. */
+    rootId: string;
+    /** Current path relative to the root (`''` = the root itself). */
+    path: string;
+    /** Parent path relative to the root, or `null` at the root (cannot go above it). */
+    parent: string | null;
+    /** Absolute directory — pass as `thread/start { cwd }` to root an agent here. */
+    cwd: string;
+    /** Whether the current directory is itself a git repository. */
+    isGitRepo: boolean;
+    /** Sub-directories the phone may open or descend into. */
+    dirs: BrowseDirEntry[];
+}

package/dist/src/models/workspace.js

@@ -0,0 +1,7 @@
+/**
+ * Workspace models exchanged over JSON-RPC (workspace/* methods).
+ *
+ * Source: architecture/02a-system-architecture.md §5.8.7.
+ */
+export {};
+//# sourceMappingURL=workspace.js.map

package/dist/src/models/workspace.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"workspace.js","sourceRoot":"","sources":["../../../src/models/workspace.ts"],"names":[],"mappings":"AAAA;;;;GAIG"}

package/dist/src/notifications/push-payload.d.ts

@@ -0,0 +1,23 @@
+/**
+ * Push notification payload sent from the bridge to the relay (POST /push/notify).
+ *
+ * Source: architecture/02a-system-architecture.md §5.10.2.
+ */
+export type PushPlatform = 'ios' | 'android';
+export interface PushNotifyRequest {
+    sessionId: string;
+    /** Secret that authenticates the bridge to the relay for this session. */
+    notificationSecret: string;
+    threadId: string;
+    turnId: string;
+    title: string;
+    body: string;
+}
+export interface PushRegisterRequest {
+    pushToken: string;
+    platform: PushPlatform;
+}
+export interface PushRegisterResult {
+    registered: boolean;
+    notificationSecret: string;
+}

package/dist/src/notifications/push-payload.js

@@ -0,0 +1,7 @@
+/**
+ * Push notification payload sent from the bridge to the relay (POST /push/notify).
+ *
+ * Source: architecture/02a-system-architecture.md §5.10.2.
+ */
+export {};
+//# sourceMappingURL=push-payload.js.map

package/dist/src/notifications/push-payload.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"push-payload.js","sourceRoot":"","sources":["../../../src/notifications/push-payload.ts"],"names":[],"mappings":"AAAA;;;;GAIG"}

package/dist/src/validators/json-schema/schemas.d.ts

@@ -0,0 +1,13 @@
+/**
+ * JSON Schemas (draft-07) for runtime validation of messages at system
+ * boundaries. Authored as typed TS objects (instead of standalone `.json`
+ * files) so they are bundled, type-checked and import-attribute free.
+ *
+ * Source: architecture/02b-contracts-and-requirements.md §5 (validation).
+ */
+import type { SchemaObject } from 'ajv';
+export declare const jsonRpcRequestSchema: SchemaObject;
+export declare const jsonRpcResponseSchema: SchemaObject;
+export declare const e2eeEnvelopeSchema: SchemaObject;
+export declare const pairingPayloadSchema: SchemaObject;
+export declare const pushPayloadSchema: SchemaObject;

package/dist/src/validators/json-schema/schemas.js

@@ -0,0 +1,82 @@
+import { JSONRPC_VERSION, PAIRING_QR_VERSION } from '../../constants.js';
+export const jsonRpcRequestSchema = {
+    $id: 'uxnan:jsonrpc-request',
+    type: 'object',
+    required: ['jsonrpc', 'id', 'method'],
+    properties: {
+        jsonrpc: { const: JSONRPC_VERSION },
+        id: { type: ['string', 'integer'] },
+        method: { type: 'string', minLength: 1 },
+        params: { type: ['object', 'array'] },
+    },
+    additionalProperties: false,
+};
+export const jsonRpcResponseSchema = {
+    $id: 'uxnan:jsonrpc-response',
+    type: 'object',
+    required: ['jsonrpc', 'id'],
+    properties: {
+        jsonrpc: { const: JSONRPC_VERSION },
+        id: { type: ['string', 'integer', 'null'] },
+        result: {},
+        error: {
+            type: 'object',
+            required: ['code', 'message'],
+            properties: {
+                code: { type: 'integer' },
+                message: { type: 'string' },
+                data: {},
+            },
+            additionalProperties: false,
+        },
+    },
+    oneOf: [{ required: ['result'] }, { required: ['error'] }],
+    additionalProperties: false,
+};
+export const e2eeEnvelopeSchema = {
+    $id: 'uxnan:e2ee-envelope',
+    type: 'object',
+    required: ['kind', 'sessionId', 'seq', 'nonce', 'ciphertext', 'tag'],
+    properties: {
+        kind: { const: 'encryptedEnvelope' },
+        sessionId: { type: 'string', minLength: 1 },
+        seq: { type: 'integer', minimum: 0 },
+        nonce: { type: 'string', minLength: 1 },
+        ciphertext: { type: 'string' },
+        tag: { type: 'string', minLength: 1 },
+    },
+    additionalProperties: false,
+};
+export const pairingPayloadSchema = {
+    $id: 'uxnan:pairing-payload',
+    type: 'object',
+    required: ['v', 'sessionId', 'macDeviceId', 'macIdentityPublicKey', 'expiresAt', 'displayName'],
+    // `relay` (string) and `hosts` (string[]) are optional transports — at least one.
+    anyOf: [{ required: ['relay'] }, { required: ['hosts'] }],
+    properties: {
+        v: { const: PAIRING_QR_VERSION },
+        relay: { type: 'string', minLength: 1 },
+        hosts: { type: 'array', items: { type: 'string', minLength: 1 }, minItems: 1 },
+        sessionId: { type: 'string', minLength: 1 },
+        macDeviceId: { type: 'string', minLength: 1 },
+        macIdentityPublicKey: { type: 'string', minLength: 1 },
+        expiresAt: { type: 'integer' },
+        displayName: { type: 'string', minLength: 1 },
+    },
+    additionalProperties: false,
+};
+export const pushPayloadSchema = {
+    $id: 'uxnan:push-payload',
+    type: 'object',
+    required: ['sessionId', 'notificationSecret', 'threadId', 'turnId', 'title', 'body'],
+    properties: {
+        sessionId: { type: 'string', minLength: 1 },
+        notificationSecret: { type: 'string', minLength: 1 },
+        threadId: { type: 'string', minLength: 1 },
+        turnId: { type: 'string', minLength: 1 },
+        title: { type: 'string' },
+        body: { type: 'string' },
+    },
+    additionalProperties: false,
+};
+//# sourceMappingURL=schemas.js.map