@smartcrab/contracts-management 0.1.0

package/dist/user-jobs.d.ts

@@ -0,0 +1,253 @@
+import { z } from "zod";
+/**
+ * `user-import-jobs` / `user-export-jobs` (design.md §26.2 route list).
+ *
+ * DEVIATION: design.md §11/§12 do not define a D1 table for either job kind
+ * (unlike every other resource in this package, whose field set is a direct
+ * projection of a named table). The shape below is derived from:
+ * - design.md §33.3 ("Export"): the fixed list of data an export contains
+ *   (profile, emails, linked identities, passkey metadata, sessions,
+ *   consent, the user's own audit events) and its explicit exclusion list
+ *   (private key, provider token, internal risk score).
+ * - the async job lifecycle convention used elsewhere in the schema, e.g.
+ *   `email_deliveries.status` (§12.8) and `outbox_events.status` (§11.16).
+ * - design.md §14.0's "1 row/valueは64 KB以下" (rows/values capped at 64 KB) —
+ *   bulk import records and export output are therefore referenced by an R2
+ *   URL, never embedded inline in the job resource itself.
+ *
+ * Should a future design.md revision add explicit
+ * `user_import_jobs`/`user_export_jobs` tables, this file's field set should
+ * be reconciled against them.
+ */
+export declare const JOB_STATUSES: readonly ["pending", "processing", "completed", "failed"];
+export declare const jobStatusSchema: z.ZodEnum<{
+    failed: "failed";
+    pending: "pending";
+    processing: "processing";
+    completed: "completed";
+}>;
+export type JobStatus = (typeof JOB_STATUSES)[number];
+export declare const USER_IMPORT_FORMATS: readonly ["json", "csv"];
+export declare const userImportFormatSchema: z.ZodEnum<{
+    json: "json";
+    csv: "csv";
+}>;
+export type UserImportFormat = (typeof USER_IMPORT_FORMATS)[number];
+export declare const userImportJobSchema: z.ZodObject<{
+    id: z.ZodString;
+    environment_id: z.ZodString;
+    status: z.ZodEnum<{
+        failed: "failed";
+        pending: "pending";
+        processing: "processing";
+        completed: "completed";
+    }>;
+    format: z.ZodEnum<{
+        json: "json";
+        csv: "csv";
+    }>;
+    source_url: z.ZodURL;
+    total_records: z.ZodNullable<z.ZodNumber>;
+    processed_records: z.ZodNumber;
+    succeeded_records: z.ZodNumber;
+    failed_records: z.ZodNumber;
+    error_report_url: z.ZodNullable<z.ZodURL>;
+    created_by: z.ZodObject<{
+        actor_type: z.ZodEnum<{
+            workspace_member: "workspace_member";
+            api_key: "api_key";
+        }>;
+        actor_id: z.ZodString;
+    }, z.core.$strict>;
+    created_at: z.ZodISODateTime;
+    updated_at: z.ZodISODateTime;
+    completed_at: z.ZodNullable<z.ZodISODateTime>;
+}, z.core.$strict>;
+export type UserImportJob = z.infer<typeof userImportJobSchema>;
+export declare const userImportJobCreateRequestSchema: z.ZodObject<{
+    environment_id: z.ZodString;
+    format: z.ZodEnum<{
+        json: "json";
+        csv: "csv";
+    }>;
+    source_url: z.ZodURL;
+}, z.core.$strict>;
+export type UserImportJobCreateRequest = z.infer<typeof userImportJobCreateRequestSchema>;
+export declare const userImportJobCreateResponseSchema: z.ZodObject<{
+    id: z.ZodString;
+    environment_id: z.ZodString;
+    status: z.ZodEnum<{
+        failed: "failed";
+        pending: "pending";
+        processing: "processing";
+        completed: "completed";
+    }>;
+    format: z.ZodEnum<{
+        json: "json";
+        csv: "csv";
+    }>;
+    source_url: z.ZodURL;
+    total_records: z.ZodNullable<z.ZodNumber>;
+    processed_records: z.ZodNumber;
+    succeeded_records: z.ZodNumber;
+    failed_records: z.ZodNumber;
+    error_report_url: z.ZodNullable<z.ZodURL>;
+    created_by: z.ZodObject<{
+        actor_type: z.ZodEnum<{
+            workspace_member: "workspace_member";
+            api_key: "api_key";
+        }>;
+        actor_id: z.ZodString;
+    }, z.core.$strict>;
+    created_at: z.ZodISODateTime;
+    updated_at: z.ZodISODateTime;
+    completed_at: z.ZodNullable<z.ZodISODateTime>;
+}, z.core.$strict>;
+export type UserImportJobCreateResponse = z.infer<typeof userImportJobCreateResponseSchema>;
+export declare const userImportJobGetResponseSchema: z.ZodObject<{
+    id: z.ZodString;
+    environment_id: z.ZodString;
+    status: z.ZodEnum<{
+        failed: "failed";
+        pending: "pending";
+        processing: "processing";
+        completed: "completed";
+    }>;
+    format: z.ZodEnum<{
+        json: "json";
+        csv: "csv";
+    }>;
+    source_url: z.ZodURL;
+    total_records: z.ZodNullable<z.ZodNumber>;
+    processed_records: z.ZodNumber;
+    succeeded_records: z.ZodNumber;
+    failed_records: z.ZodNumber;
+    error_report_url: z.ZodNullable<z.ZodURL>;
+    created_by: z.ZodObject<{
+        actor_type: z.ZodEnum<{
+            workspace_member: "workspace_member";
+            api_key: "api_key";
+        }>;
+        actor_id: z.ZodString;
+    }, z.core.$strict>;
+    created_at: z.ZodISODateTime;
+    updated_at: z.ZodISODateTime;
+    completed_at: z.ZodNullable<z.ZodISODateTime>;
+}, z.core.$strict>;
+export type UserImportJobGetResponse = z.infer<typeof userImportJobGetResponseSchema>;
+/** design.md §33.3's fixed export content list; not caller-configurable. */
+export declare const USER_EXPORT_CONTENTS: readonly ["profile", "emails", "linked_identities", "passkey_metadata", "sessions", "consent", "audit_events"];
+export declare const userExportContentSchema: z.ZodEnum<{
+    profile: "profile";
+    sessions: "sessions";
+    emails: "emails";
+    linked_identities: "linked_identities";
+    passkey_metadata: "passkey_metadata";
+    consent: "consent";
+    audit_events: "audit_events";
+}>;
+export type UserExportContent = (typeof USER_EXPORT_CONTENTS)[number];
+export declare const userExportJobSchema: z.ZodObject<{
+    id: z.ZodString;
+    environment_id: z.ZodString;
+    target_user_id: z.ZodString;
+    status: z.ZodEnum<{
+        failed: "failed";
+        pending: "pending";
+        processing: "processing";
+        completed: "completed";
+    }>;
+    contents: z.ZodArray<z.ZodEnum<{
+        profile: "profile";
+        sessions: "sessions";
+        emails: "emails";
+        linked_identities: "linked_identities";
+        passkey_metadata: "passkey_metadata";
+        consent: "consent";
+        audit_events: "audit_events";
+    }>>;
+    download_url: z.ZodNullable<z.ZodURL>;
+    download_url_expires_at: z.ZodNullable<z.ZodISODateTime>;
+    created_by: z.ZodObject<{
+        actor_type: z.ZodEnum<{
+            workspace_member: "workspace_member";
+            api_key: "api_key";
+        }>;
+        actor_id: z.ZodString;
+    }, z.core.$strict>;
+    created_at: z.ZodISODateTime;
+    updated_at: z.ZodISODateTime;
+    completed_at: z.ZodNullable<z.ZodISODateTime>;
+}, z.core.$strict>;
+export type UserExportJob = z.infer<typeof userExportJobSchema>;
+export declare const userExportJobCreateRequestSchema: z.ZodObject<{
+    environment_id: z.ZodString;
+    target_user_id: z.ZodString;
+}, z.core.$strict>;
+export type UserExportJobCreateRequest = z.infer<typeof userExportJobCreateRequestSchema>;
+export declare const userExportJobCreateResponseSchema: z.ZodObject<{
+    id: z.ZodString;
+    environment_id: z.ZodString;
+    target_user_id: z.ZodString;
+    status: z.ZodEnum<{
+        failed: "failed";
+        pending: "pending";
+        processing: "processing";
+        completed: "completed";
+    }>;
+    contents: z.ZodArray<z.ZodEnum<{
+        profile: "profile";
+        sessions: "sessions";
+        emails: "emails";
+        linked_identities: "linked_identities";
+        passkey_metadata: "passkey_metadata";
+        consent: "consent";
+        audit_events: "audit_events";
+    }>>;
+    download_url: z.ZodNullable<z.ZodURL>;
+    download_url_expires_at: z.ZodNullable<z.ZodISODateTime>;
+    created_by: z.ZodObject<{
+        actor_type: z.ZodEnum<{
+            workspace_member: "workspace_member";
+            api_key: "api_key";
+        }>;
+        actor_id: z.ZodString;
+    }, z.core.$strict>;
+    created_at: z.ZodISODateTime;
+    updated_at: z.ZodISODateTime;
+    completed_at: z.ZodNullable<z.ZodISODateTime>;
+}, z.core.$strict>;
+export type UserExportJobCreateResponse = z.infer<typeof userExportJobCreateResponseSchema>;
+export declare const userExportJobGetResponseSchema: z.ZodObject<{
+    id: z.ZodString;
+    environment_id: z.ZodString;
+    target_user_id: z.ZodString;
+    status: z.ZodEnum<{
+        failed: "failed";
+        pending: "pending";
+        processing: "processing";
+        completed: "completed";
+    }>;
+    contents: z.ZodArray<z.ZodEnum<{
+        profile: "profile";
+        sessions: "sessions";
+        emails: "emails";
+        linked_identities: "linked_identities";
+        passkey_metadata: "passkey_metadata";
+        consent: "consent";
+        audit_events: "audit_events";
+    }>>;
+    download_url: z.ZodNullable<z.ZodURL>;
+    download_url_expires_at: z.ZodNullable<z.ZodISODateTime>;
+    created_by: z.ZodObject<{
+        actor_type: z.ZodEnum<{
+            workspace_member: "workspace_member";
+            api_key: "api_key";
+        }>;
+        actor_id: z.ZodString;
+    }, z.core.$strict>;
+    created_at: z.ZodISODateTime;
+    updated_at: z.ZodISODateTime;
+    completed_at: z.ZodNullable<z.ZodISODateTime>;
+}, z.core.$strict>;
+export type UserExportJobGetResponse = z.infer<typeof userExportJobGetResponseSchema>;

package/dist/user-jobs.js

@@ -0,0 +1,95 @@
+import { httpsUrlSchema } from "@smartcrab/contracts-public";
+import { z } from "zod";
+import { environmentIdSchema, jobIdSchema, userIdSchema } from "./primitives.js";
+/**
+ * `user-import-jobs` / `user-export-jobs` (design.md §26.2 route list).
+ *
+ * DEVIATION: design.md §11/§12 do not define a D1 table for either job kind
+ * (unlike every other resource in this package, whose field set is a direct
+ * projection of a named table). The shape below is derived from:
+ * - design.md §33.3 ("Export"): the fixed list of data an export contains
+ *   (profile, emails, linked identities, passkey metadata, sessions,
+ *   consent, the user's own audit events) and its explicit exclusion list
+ *   (private key, provider token, internal risk score).
+ * - the async job lifecycle convention used elsewhere in the schema, e.g.
+ *   `email_deliveries.status` (§12.8) and `outbox_events.status` (§11.16).
+ * - design.md §14.0's "1 row/valueは64 KB以下" (rows/values capped at 64 KB) —
+ *   bulk import records and export output are therefore referenced by an R2
+ *   URL, never embedded inline in the job resource itself.
+ *
+ * Should a future design.md revision add explicit
+ * `user_import_jobs`/`user_export_jobs` tables, this file's field set should
+ * be reconciled against them.
+ */
+export const JOB_STATUSES = ["pending", "processing", "completed", "failed"];
+export const jobStatusSchema = z.enum(JOB_STATUSES);
+/** Who requested the job (design.md §12.11 `audit_events.actor_type` narrowed to the kinds that can trigger a job). */
+const JOB_ACTOR_TYPES = ["workspace_member", "api_key"];
+const jobActorSchema = z.strictObject({
+    actor_type: z.enum(JOB_ACTOR_TYPES),
+    actor_id: z.string().min(1),
+});
+// ---------------------------------------------------------------------------
+// POST /user-import-jobs, GET /user-import-jobs/:jobId
+// ---------------------------------------------------------------------------
+export const USER_IMPORT_FORMATS = ["json", "csv"];
+export const userImportFormatSchema = z.enum(USER_IMPORT_FORMATS);
+export const userImportJobSchema = z.strictObject({
+    id: jobIdSchema,
+    environment_id: environmentIdSchema,
+    status: jobStatusSchema,
+    format: userImportFormatSchema,
+    /** Where the platform fetched the source records from (an R2/customer-hosted HTTPS URL). */
+    source_url: httpsUrlSchema,
+    total_records: z.number().int().nonnegative().nullable(),
+    processed_records: z.number().int().nonnegative(),
+    succeeded_records: z.number().int().nonnegative(),
+    failed_records: z.number().int().nonnegative(),
+    /** Present once the job has processed at least one failing record; an R2-hosted per-row error report. */
+    error_report_url: httpsUrlSchema.nullable(),
+    created_by: jobActorSchema,
+    created_at: z.iso.datetime(),
+    updated_at: z.iso.datetime(),
+    completed_at: z.iso.datetime().nullable(),
+});
+export const userImportJobCreateRequestSchema = z.strictObject({
+    environment_id: environmentIdSchema,
+    format: userImportFormatSchema,
+    source_url: httpsUrlSchema,
+});
+export const userImportJobCreateResponseSchema = userImportJobSchema;
+export const userImportJobGetResponseSchema = userImportJobSchema;
+// ---------------------------------------------------------------------------
+// POST /user-export-jobs, GET /user-export-jobs/:jobId
+// ---------------------------------------------------------------------------
+/** design.md §33.3's fixed export content list; not caller-configurable. */
+export const USER_EXPORT_CONTENTS = [
+    "profile",
+    "emails",
+    "linked_identities",
+    "passkey_metadata",
+    "sessions",
+    "consent",
+    "audit_events",
+];
+export const userExportContentSchema = z.enum(USER_EXPORT_CONTENTS);
+export const userExportJobSchema = z.strictObject({
+    id: jobIdSchema,
+    environment_id: environmentIdSchema,
+    target_user_id: userIdSchema,
+    status: jobStatusSchema,
+    contents: z.array(userExportContentSchema),
+    /** Present once `status: "completed"`: a time-limited presigned R2 URL for the JSON export. */
+    download_url: httpsUrlSchema.nullable(),
+    download_url_expires_at: z.iso.datetime().nullable(),
+    created_by: jobActorSchema,
+    created_at: z.iso.datetime(),
+    updated_at: z.iso.datetime(),
+    completed_at: z.iso.datetime().nullable(),
+});
+export const userExportJobCreateRequestSchema = z.strictObject({
+    environment_id: environmentIdSchema,
+    target_user_id: userIdSchema,
+});
+export const userExportJobCreateResponseSchema = userExportJobSchema;
+export const userExportJobGetResponseSchema = userExportJobSchema;

package/dist/user-subresources.d.ts

@@ -0,0 +1,161 @@
+import { z } from "zod";
+/**
+ * Admin-facing projections of a user's sub-resources: `identities` (design.md
+ * §12.3), `passkeys` (§12.5), `sessions` (§12.4). Same exclusions as
+ * `@smartcrab/contracts-public`'s `/v1/me` sub-resource schemas
+ * (`provider_subject`, `profile_json`, token ciphertexts, `credential_id`,
+ * `public_key`, `sign_count`, `token_mac` (assignment's forbidden list),
+ * `ip_prefix_hash`/`user_agent_hash`), plus `user_id` added back in since
+ * these admin routes are not scoped to "the current session's own user" the
+ * way `/v1/me` is.
+ */
+/** Environment context required by every user sub-resource route. */
+export declare const userSubresourceQuerySchema: z.ZodObject<{
+    environment_id: z.ZodString;
+}, z.core.$strict>;
+export type UserSubresourceQuery = z.infer<typeof userSubresourceQuerySchema>;
+export declare const userIdentitySchema: z.ZodObject<{
+    identity_id: z.ZodString;
+    user_id: z.ZodString;
+    provider: z.ZodEnum<{
+        google: "google";
+        apple: "apple";
+        github: "github";
+        microsoft: "microsoft";
+        generic_oidc: "generic_oidc";
+    }>;
+    linked_at: z.ZodISODateTime;
+    last_used_at: z.ZodNullable<z.ZodISODateTime>;
+}, z.core.$strict>;
+export type UserIdentity = z.infer<typeof userIdentitySchema>;
+export declare const userIdentityListQuerySchema: z.ZodObject<{
+    cursor: z.ZodOptional<z.ZodString>;
+    limit: z.ZodDefault<z.ZodCoercedNumber<unknown>>;
+    environment_id: z.ZodString;
+}, z.core.$strip>;
+export type UserIdentityListQuery = z.infer<typeof userIdentityListQuerySchema>;
+export declare const userIdentityListResponseSchema: z.ZodObject<{
+    items: z.ZodArray<z.ZodObject<{
+        identity_id: z.ZodString;
+        user_id: z.ZodString;
+        provider: z.ZodEnum<{
+            google: "google";
+            apple: "apple";
+            github: "github";
+            microsoft: "microsoft";
+            generic_oidc: "generic_oidc";
+        }>;
+        linked_at: z.ZodISODateTime;
+        last_used_at: z.ZodNullable<z.ZodISODateTime>;
+    }, z.core.$strict>>;
+    next_cursor: z.ZodNullable<z.ZodString>;
+}, z.core.$strict>;
+export type UserIdentityListResponse = z.infer<typeof userIdentityListResponseSchema>;
+export declare const userIdentityDeleteResponseSchema: z.ZodObject<{
+    identity_id: z.ZodString;
+    deleted: z.ZodLiteral<true>;
+}, z.core.$strict>;
+export type UserIdentityDeleteResponse = z.infer<typeof userIdentityDeleteResponseSchema>;
+export declare const PASSKEY_DEVICE_TYPES: readonly ["single_device", "multi_device"];
+export declare const passkeyDeviceTypeSchema: z.ZodEnum<{
+    single_device: "single_device";
+    multi_device: "multi_device";
+}>;
+export type PasskeyDeviceType = (typeof PASSKEY_DEVICE_TYPES)[number];
+export declare const userPasskeySchema: z.ZodObject<{
+    passkey_id: z.ZodString;
+    user_id: z.ZodString;
+    name: z.ZodNullable<z.ZodString>;
+    created_at: z.ZodISODateTime;
+    last_used_at: z.ZodNullable<z.ZodISODateTime>;
+    device_type: z.ZodNullable<z.ZodEnum<{
+        single_device: "single_device";
+        multi_device: "multi_device";
+    }>>;
+    backed_up: z.ZodBoolean;
+    transports: z.ZodOptional<z.ZodArray<z.ZodEnum<{
+        ble: "ble";
+        hybrid: "hybrid";
+        internal: "internal";
+        nfc: "nfc";
+        usb: "usb";
+    }>>>;
+}, z.core.$strict>;
+export type UserPasskey = z.infer<typeof userPasskeySchema>;
+export declare const userPasskeyListQuerySchema: z.ZodObject<{
+    cursor: z.ZodOptional<z.ZodString>;
+    limit: z.ZodDefault<z.ZodCoercedNumber<unknown>>;
+    environment_id: z.ZodString;
+}, z.core.$strip>;
+export type UserPasskeyListQuery = z.infer<typeof userPasskeyListQuerySchema>;
+export declare const userPasskeyListResponseSchema: z.ZodObject<{
+    items: z.ZodArray<z.ZodObject<{
+        passkey_id: z.ZodString;
+        user_id: z.ZodString;
+        name: z.ZodNullable<z.ZodString>;
+        created_at: z.ZodISODateTime;
+        last_used_at: z.ZodNullable<z.ZodISODateTime>;
+        device_type: z.ZodNullable<z.ZodEnum<{
+            single_device: "single_device";
+            multi_device: "multi_device";
+        }>>;
+        backed_up: z.ZodBoolean;
+        transports: z.ZodOptional<z.ZodArray<z.ZodEnum<{
+            ble: "ble";
+            hybrid: "hybrid";
+            internal: "internal";
+            nfc: "nfc";
+            usb: "usb";
+        }>>>;
+    }, z.core.$strict>>;
+    next_cursor: z.ZodNullable<z.ZodString>;
+}, z.core.$strict>;
+export type UserPasskeyListResponse = z.infer<typeof userPasskeyListResponseSchema>;
+export declare const userPasskeyDeleteResponseSchema: z.ZodObject<{
+    passkey_id: z.ZodString;
+    deleted: z.ZodLiteral<true>;
+}, z.core.$strict>;
+export type UserPasskeyDeleteResponse = z.infer<typeof userPasskeyDeleteResponseSchema>;
+export declare const userSessionSchema: z.ZodObject<{
+    session_id: z.ZodString;
+    user_id: z.ZodString;
+    client_id: z.ZodString;
+    device_name: z.ZodNullable<z.ZodString>;
+    created_at: z.ZodISODateTime;
+    last_active_at: z.ZodISODateTime;
+    idle_expires_at: z.ZodISODateTime;
+    absolute_expires_at: z.ZodISODateTime;
+    revoked_at: z.ZodNullable<z.ZodISODateTime>;
+}, z.core.$strict>;
+export type UserSession = z.infer<typeof userSessionSchema>;
+export declare const userSessionListQuerySchema: z.ZodObject<{
+    cursor: z.ZodOptional<z.ZodString>;
+    limit: z.ZodDefault<z.ZodCoercedNumber<unknown>>;
+    environment_id: z.ZodString;
+}, z.core.$strip>;
+export type UserSessionListQuery = z.infer<typeof userSessionListQuerySchema>;
+export declare const userSessionListResponseSchema: z.ZodObject<{
+    items: z.ZodArray<z.ZodObject<{
+        session_id: z.ZodString;
+        user_id: z.ZodString;
+        client_id: z.ZodString;
+        device_name: z.ZodNullable<z.ZodString>;
+        created_at: z.ZodISODateTime;
+        last_active_at: z.ZodISODateTime;
+        idle_expires_at: z.ZodISODateTime;
+        absolute_expires_at: z.ZodISODateTime;
+        revoked_at: z.ZodNullable<z.ZodISODateTime>;
+    }, z.core.$strict>>;
+    next_cursor: z.ZodNullable<z.ZodString>;
+}, z.core.$strict>;
+export type UserSessionListResponse = z.infer<typeof userSessionListResponseSchema>;
+export declare const userSessionRevokeResponseSchema: z.ZodObject<{
+    session_id: z.ZodString;
+    revoked: z.ZodLiteral<true>;
+}, z.core.$strict>;
+export type UserSessionRevokeResponse = z.infer<typeof userSessionRevokeResponseSchema>;
+/** design.md §24.3: revoking all of a user's sessions bumps `UserSecurityDO.securityVersion`. */
+export declare const userSessionsRevokeAllResponseSchema: z.ZodObject<{
+    revoked: z.ZodLiteral<true>;
+}, z.core.$strict>;
+export type UserSessionsRevokeAllResponse = z.infer<typeof userSessionsRevokeAllResponseSchema>;

package/dist/user-subresources.js

@@ -0,0 +1,85 @@
+import { socialProviderSchema } from "@smartcrab/contracts-public";
+import { z } from "zod";
+import { cursorPageSchema, paginationQuerySchema } from "./common.js";
+import { clientIdSchema, environmentIdSchema, identityIdSchema, passkeyIdSchema, sessionIdSchema, userIdSchema, } from "./primitives.js";
+/**
+ * Admin-facing projections of a user's sub-resources: `identities` (design.md
+ * §12.3), `passkeys` (§12.5), `sessions` (§12.4). Same exclusions as
+ * `@smartcrab/contracts-public`'s `/v1/me` sub-resource schemas
+ * (`provider_subject`, `profile_json`, token ciphertexts, `credential_id`,
+ * `public_key`, `sign_count`, `token_mac` (assignment's forbidden list),
+ * `ip_prefix_hash`/`user_agent_hash`), plus `user_id` added back in since
+ * these admin routes are not scoped to "the current session's own user" the
+ * way `/v1/me` is.
+ */
+/** Environment context required by every user sub-resource route. */
+export const userSubresourceQuerySchema = z.strictObject({
+    environment_id: environmentIdSchema,
+});
+const userSubresourceListQuerySchema = paginationQuerySchema.extend({
+    environment_id: environmentIdSchema,
+});
+// ---------------------------------------------------------------------------
+// GET /users/:userId/identities, DELETE /users/:userId/identities/:identityId
+// ---------------------------------------------------------------------------
+export const userIdentitySchema = z.strictObject({
+    identity_id: identityIdSchema,
+    user_id: userIdSchema,
+    provider: socialProviderSchema,
+    linked_at: z.iso.datetime(),
+    last_used_at: z.iso.datetime().nullable(),
+});
+export const userIdentityListQuerySchema = userSubresourceListQuerySchema;
+export const userIdentityListResponseSchema = cursorPageSchema(userIdentitySchema);
+export const userIdentityDeleteResponseSchema = z.strictObject({
+    identity_id: identityIdSchema,
+    deleted: z.literal(true),
+});
+// ---------------------------------------------------------------------------
+// GET /users/:userId/passkeys, DELETE /users/:userId/passkeys/:passkeyId
+// ---------------------------------------------------------------------------
+const AUTHENTICATOR_TRANSPORTS = ["ble", "hybrid", "internal", "nfc", "usb"];
+const authenticatorTransportSchema = z.enum(AUTHENTICATOR_TRANSPORTS);
+export const PASSKEY_DEVICE_TYPES = ["single_device", "multi_device"];
+export const passkeyDeviceTypeSchema = z.enum(PASSKEY_DEVICE_TYPES);
+export const userPasskeySchema = z.strictObject({
+    passkey_id: passkeyIdSchema,
+    user_id: userIdSchema,
+    name: z.string().nullable(),
+    created_at: z.iso.datetime(),
+    last_used_at: z.iso.datetime().nullable(),
+    device_type: passkeyDeviceTypeSchema.nullable(),
+    backed_up: z.boolean(),
+    transports: z.array(authenticatorTransportSchema).optional(),
+});
+export const userPasskeyListQuerySchema = userSubresourceListQuerySchema;
+export const userPasskeyListResponseSchema = cursorPageSchema(userPasskeySchema);
+export const userPasskeyDeleteResponseSchema = z.strictObject({
+    passkey_id: passkeyIdSchema,
+    deleted: z.literal(true),
+});
+// ---------------------------------------------------------------------------
+// GET /users/:userId/sessions, DELETE /users/:userId/sessions/:sessionId,
+// DELETE /users/:userId/sessions
+// ---------------------------------------------------------------------------
+export const userSessionSchema = z.strictObject({
+    session_id: sessionIdSchema,
+    user_id: userIdSchema,
+    client_id: clientIdSchema,
+    device_name: z.string().nullable(),
+    created_at: z.iso.datetime(),
+    last_active_at: z.iso.datetime(),
+    idle_expires_at: z.iso.datetime(),
+    absolute_expires_at: z.iso.datetime(),
+    revoked_at: z.iso.datetime().nullable(),
+});
+export const userSessionListQuerySchema = userSubresourceListQuerySchema;
+export const userSessionListResponseSchema = cursorPageSchema(userSessionSchema);
+export const userSessionRevokeResponseSchema = z.strictObject({
+    session_id: sessionIdSchema,
+    revoked: z.literal(true),
+});
+/** design.md §24.3: revoking all of a user's sessions bumps `UserSecurityDO.securityVersion`. */
+export const userSessionsRevokeAllResponseSchema = z.strictObject({
+    revoked: z.literal(true),
+});