@smartcrab/contracts-management 0.1.0

package/dist/users.d.ts

@@ -0,0 +1,193 @@
+import { z } from "zod";
+/**
+ * `users` (design.md §12.1) projected with `user_emails` (§12.2)'s decrypted
+ * display value. Excluded: `auth_partition_id` (assignment's forbidden-field
+ * list — internal Auth D1 co-location routing, §12), `security_version`
+ * (internal invalidation counter, excluded by the same rationale
+ * `@smartcrab/contracts-public`'s `/v1/me` uses), `primary_email_id`
+ * (internal FK, superseded here by the resolved `email` field itself), and
+ * `deleted_at` (status `pending_deletion` already reports this, matching
+ * `@smartcrab/contracts-public`'s `meUserSchema`).
+ *
+ * `email` is the plaintext address: `user_emails.email_ciphertext` (the
+ * forbidden column) is decrypted server-side before this projection is
+ * built, exactly as `/v1/me` does for the same underlying table.
+ * `metadata` (from `metadata_json`) IS exposed here — unlike `/v1/me`, this
+ * is the admin-facing Management API, and arbitrary app-defined user
+ * metadata is a normal, non-secret admin/dashboard field (design.md does not
+ * name it a secret column).
+ */
+export declare const USER_STATUSES: readonly ["active", "blocked", "pending_deletion"];
+export declare const userStatusSchema: z.ZodEnum<{
+    active: "active";
+    blocked: "blocked";
+    pending_deletion: "pending_deletion";
+}>;
+export type UserStatus = (typeof USER_STATUSES)[number];
+export declare const userSchema: z.ZodObject<{
+    id: z.ZodString;
+    environment_id: z.ZodString;
+    email: z.ZodNullable<z.ZodEmail>;
+    email_verified: z.ZodBoolean;
+    name: z.ZodNullable<z.ZodString>;
+    avatar_url: z.ZodNullable<z.ZodURL>;
+    locale: z.ZodNullable<z.ZodString>;
+    timezone: z.ZodNullable<z.ZodString>;
+    status: z.ZodEnum<{
+        active: "active";
+        blocked: "blocked";
+        pending_deletion: "pending_deletion";
+    }>;
+    metadata: z.ZodRecord<z.ZodString, z.ZodUnknown>;
+    created_at: z.ZodISODateTime;
+    updated_at: z.ZodISODateTime;
+    last_login_at: z.ZodNullable<z.ZodISODateTime>;
+}, z.core.$strict>;
+export type User = z.infer<typeof userSchema>;
+export declare const userListQuerySchema: z.ZodObject<{
+    cursor: z.ZodOptional<z.ZodString>;
+    limit: z.ZodDefault<z.ZodCoercedNumber<unknown>>;
+    environment_id: z.ZodString;
+    status: z.ZodOptional<z.ZodEnum<{
+        active: "active";
+        blocked: "blocked";
+        pending_deletion: "pending_deletion";
+    }>>;
+    search: z.ZodOptional<z.ZodString>;
+}, z.core.$strip>;
+export type UserListQuery = z.infer<typeof userListQuerySchema>;
+export declare const userListResponseSchema: z.ZodObject<{
+    items: z.ZodArray<z.ZodObject<{
+        id: z.ZodString;
+        environment_id: z.ZodString;
+        email: z.ZodNullable<z.ZodEmail>;
+        email_verified: z.ZodBoolean;
+        name: z.ZodNullable<z.ZodString>;
+        avatar_url: z.ZodNullable<z.ZodURL>;
+        locale: z.ZodNullable<z.ZodString>;
+        timezone: z.ZodNullable<z.ZodString>;
+        status: z.ZodEnum<{
+            active: "active";
+            blocked: "blocked";
+            pending_deletion: "pending_deletion";
+        }>;
+        metadata: z.ZodRecord<z.ZodString, z.ZodUnknown>;
+        created_at: z.ZodISODateTime;
+        updated_at: z.ZodISODateTime;
+        last_login_at: z.ZodNullable<z.ZodISODateTime>;
+    }, z.core.$strict>>;
+    next_cursor: z.ZodNullable<z.ZodString>;
+}, z.core.$strict>;
+export type UserListResponse = z.infer<typeof userListResponseSchema>;
+export declare const userCreateRequestSchema: z.ZodObject<{
+    environment_id: z.ZodString;
+    email: z.ZodEmail;
+    email_verified: z.ZodDefault<z.ZodBoolean>;
+    name: z.ZodOptional<z.ZodString>;
+    avatar_url: z.ZodOptional<z.ZodURL>;
+    locale: z.ZodOptional<z.ZodString>;
+    timezone: z.ZodOptional<z.ZodString>;
+    metadata: z.ZodDefault<z.ZodRecord<z.ZodString, z.ZodUnknown>>;
+}, z.core.$strict>;
+export type UserCreateRequest = z.infer<typeof userCreateRequestSchema>;
+export declare const userCreateResponseSchema: z.ZodObject<{
+    id: z.ZodString;
+    environment_id: z.ZodString;
+    email: z.ZodNullable<z.ZodEmail>;
+    email_verified: z.ZodBoolean;
+    name: z.ZodNullable<z.ZodString>;
+    avatar_url: z.ZodNullable<z.ZodURL>;
+    locale: z.ZodNullable<z.ZodString>;
+    timezone: z.ZodNullable<z.ZodString>;
+    status: z.ZodEnum<{
+        active: "active";
+        blocked: "blocked";
+        pending_deletion: "pending_deletion";
+    }>;
+    metadata: z.ZodRecord<z.ZodString, z.ZodUnknown>;
+    created_at: z.ZodISODateTime;
+    updated_at: z.ZodISODateTime;
+    last_login_at: z.ZodNullable<z.ZodISODateTime>;
+}, z.core.$strict>;
+export type UserCreateResponse = z.infer<typeof userCreateResponseSchema>;
+/** Environment context required by every individual-user route. */
+export declare const userEnvironmentQuerySchema: z.ZodObject<{
+    environment_id: z.ZodString;
+}, z.core.$strict>;
+export type UserEnvironmentQuery = z.infer<typeof userEnvironmentQuerySchema>;
+export declare const userGetResponseSchema: z.ZodObject<{
+    id: z.ZodString;
+    environment_id: z.ZodString;
+    email: z.ZodNullable<z.ZodEmail>;
+    email_verified: z.ZodBoolean;
+    name: z.ZodNullable<z.ZodString>;
+    avatar_url: z.ZodNullable<z.ZodURL>;
+    locale: z.ZodNullable<z.ZodString>;
+    timezone: z.ZodNullable<z.ZodString>;
+    status: z.ZodEnum<{
+        active: "active";
+        blocked: "blocked";
+        pending_deletion: "pending_deletion";
+    }>;
+    metadata: z.ZodRecord<z.ZodString, z.ZodUnknown>;
+    created_at: z.ZodISODateTime;
+    updated_at: z.ZodISODateTime;
+    last_login_at: z.ZodNullable<z.ZodISODateTime>;
+}, z.core.$strict>;
+export type UserGetResponse = z.infer<typeof userGetResponseSchema>;
+/**
+ * `email` is deliberately excluded, same as `@smartcrab/contracts-public`'s
+ * `meUpdateRequestSchema`: changing it is a dual-verification recovery flow
+ * (design.md §25), not a generic field patch — for admin-initiated changes,
+ * design.md §25 additionally requires Owner/Admin, a reason, and an audit
+ * record, which this generic `PATCH` does not carry.
+ */
+export declare const userUpdateRequestSchema: z.ZodObject<{
+    name: z.ZodOptional<z.ZodString>;
+    avatar_url: z.ZodOptional<z.ZodURL>;
+    locale: z.ZodOptional<z.ZodString>;
+    timezone: z.ZodOptional<z.ZodString>;
+    metadata: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodUnknown>>;
+}, z.core.$strict>;
+export type UserUpdateRequest = z.infer<typeof userUpdateRequestSchema>;
+export declare const userUpdateResponseSchema: z.ZodObject<{
+    id: z.ZodString;
+    environment_id: z.ZodString;
+    email: z.ZodNullable<z.ZodEmail>;
+    email_verified: z.ZodBoolean;
+    name: z.ZodNullable<z.ZodString>;
+    avatar_url: z.ZodNullable<z.ZodURL>;
+    locale: z.ZodNullable<z.ZodString>;
+    timezone: z.ZodNullable<z.ZodString>;
+    status: z.ZodEnum<{
+        active: "active";
+        blocked: "blocked";
+        pending_deletion: "pending_deletion";
+    }>;
+    metadata: z.ZodRecord<z.ZodString, z.ZodUnknown>;
+    created_at: z.ZodISODateTime;
+    updated_at: z.ZodISODateTime;
+    last_login_at: z.ZodNullable<z.ZodISODateTime>;
+}, z.core.$strict>;
+export type UserUpdateResponse = z.infer<typeof userUpdateResponseSchema>;
+export declare const userDeleteResponseSchema: z.ZodObject<{
+    id: z.ZodString;
+    status: z.ZodLiteral<"pending_deletion">;
+}, z.core.$strict>;
+export type UserDeleteResponse = z.infer<typeof userDeleteResponseSchema>;
+export declare const userBlockRequestSchema: z.ZodObject<{
+    reason: z.ZodOptional<z.ZodString>;
+}, z.core.$strict>;
+export type UserBlockRequest = z.infer<typeof userBlockRequestSchema>;
+export declare const userBlockResponseSchema: z.ZodObject<{
+    id: z.ZodString;
+    status: z.ZodLiteral<"blocked">;
+}, z.core.$strict>;
+export type UserBlockResponse = z.infer<typeof userBlockResponseSchema>;
+export declare const userUnblockRequestSchema: z.ZodObject<{}, z.core.$strict>;
+export type UserUnblockRequest = z.infer<typeof userUnblockRequestSchema>;
+export declare const userUnblockResponseSchema: z.ZodObject<{
+    id: z.ZodString;
+    status: z.ZodLiteral<"active">;
+}, z.core.$strict>;
+export type UserUnblockResponse = z.infer<typeof userUnblockResponseSchema>;

package/dist/users.js

@@ -0,0 +1,112 @@
+import { z } from "zod";
+import { cursorPageSchema, paginationQuerySchema } from "./common.js";
+import { environmentIdSchema, userIdSchema } from "./primitives.js";
+/**
+ * `users` (design.md §12.1) projected with `user_emails` (§12.2)'s decrypted
+ * display value. Excluded: `auth_partition_id` (assignment's forbidden-field
+ * list — internal Auth D1 co-location routing, §12), `security_version`
+ * (internal invalidation counter, excluded by the same rationale
+ * `@smartcrab/contracts-public`'s `/v1/me` uses), `primary_email_id`
+ * (internal FK, superseded here by the resolved `email` field itself), and
+ * `deleted_at` (status `pending_deletion` already reports this, matching
+ * `@smartcrab/contracts-public`'s `meUserSchema`).
+ *
+ * `email` is the plaintext address: `user_emails.email_ciphertext` (the
+ * forbidden column) is decrypted server-side before this projection is
+ * built, exactly as `/v1/me` does for the same underlying table.
+ * `metadata` (from `metadata_json`) IS exposed here — unlike `/v1/me`, this
+ * is the admin-facing Management API, and arbitrary app-defined user
+ * metadata is a normal, non-secret admin/dashboard field (design.md does not
+ * name it a secret column).
+ */
+export const USER_STATUSES = ["active", "blocked", "pending_deletion"];
+export const userStatusSchema = z.enum(USER_STATUSES);
+const userMetadataSchema = z.record(z.string(), z.unknown());
+export const userSchema = z.strictObject({
+    id: userIdSchema,
+    environment_id: environmentIdSchema,
+    email: z.email().nullable(),
+    email_verified: z.boolean(),
+    name: z.string().nullable(),
+    avatar_url: z.url().nullable(),
+    locale: z.string().nullable(),
+    timezone: z.string().nullable(),
+    status: userStatusSchema,
+    metadata: userMetadataSchema,
+    created_at: z.iso.datetime(),
+    updated_at: z.iso.datetime(),
+    last_login_at: z.iso.datetime().nullable(),
+});
+// ---------------------------------------------------------------------------
+// GET /users
+// ---------------------------------------------------------------------------
+export const userListQuerySchema = paginationQuerySchema.extend({
+    environment_id: environmentIdSchema,
+    status: userStatusSchema.optional(),
+    /** Free-text search over name/email (matched server-side against the decrypted/normalized values). */
+    search: z.string().min(1).max(200).optional(),
+});
+export const userListResponseSchema = cursorPageSchema(userSchema);
+// ---------------------------------------------------------------------------
+// POST /users
+// ---------------------------------------------------------------------------
+export const userCreateRequestSchema = z.strictObject({
+    environment_id: environmentIdSchema,
+    email: z.email(),
+    /** Admin-created users may be marked pre-verified (e.g. bulk import from a trusted source). */
+    email_verified: z.boolean().default(false),
+    name: z.string().min(1).max(200).optional(),
+    avatar_url: z.url().optional(),
+    locale: z.string().min(1).max(35).optional(),
+    timezone: z.string().min(1).max(64).optional(),
+    metadata: userMetadataSchema.default({}),
+});
+export const userCreateResponseSchema = userSchema;
+// ---------------------------------------------------------------------------
+// GET /users/:userId
+// ---------------------------------------------------------------------------
+/** Environment context required by every individual-user route. */
+export const userEnvironmentQuerySchema = z.strictObject({
+    environment_id: environmentIdSchema,
+});
+export const userGetResponseSchema = userSchema;
+// ---------------------------------------------------------------------------
+// PATCH /users/:userId
+// ---------------------------------------------------------------------------
+/**
+ * `email` is deliberately excluded, same as `@smartcrab/contracts-public`'s
+ * `meUpdateRequestSchema`: changing it is a dual-verification recovery flow
+ * (design.md §25), not a generic field patch — for admin-initiated changes,
+ * design.md §25 additionally requires Owner/Admin, a reason, and an audit
+ * record, which this generic `PATCH` does not carry.
+ */
+export const userUpdateRequestSchema = z.strictObject({
+    name: z.string().min(1).max(200).optional(),
+    avatar_url: z.url().optional(),
+    locale: z.string().min(1).max(35).optional(),
+    timezone: z.string().min(1).max(64).optional(),
+    metadata: userMetadataSchema.optional(),
+});
+export const userUpdateResponseSchema = userSchema;
+// ---------------------------------------------------------------------------
+// DELETE /users/:userId (design.md §33.1: logical delete first)
+// ---------------------------------------------------------------------------
+export const userDeleteResponseSchema = z.strictObject({
+    id: userIdSchema,
+    status: z.literal("pending_deletion"),
+});
+// ---------------------------------------------------------------------------
+// POST /users/:userId/block, /users/:userId/unblock
+// ---------------------------------------------------------------------------
+export const userBlockRequestSchema = z.strictObject({
+    reason: z.string().min(1).max(1000).optional(),
+});
+export const userBlockResponseSchema = z.strictObject({
+    id: userIdSchema,
+    status: z.literal("blocked"),
+});
+export const userUnblockRequestSchema = z.strictObject({});
+export const userUnblockResponseSchema = z.strictObject({
+    id: userIdSchema,
+    status: z.literal("active"),
+});

package/dist/webhooks.d.ts

@@ -0,0 +1,306 @@
+import { z } from "zod";
+/**
+ * `webhook_endpoints` (design.md §11.13) and the Customer Webhook event
+ * catalog (design.md §29.4's "イベント例" list, treated as the canonical
+ * enum since no other source enumerates event types). `secret_ciphertext`/
+ * `secret_iv` are excluded per the assignment's forbidden-field list; like
+ * `management_api_keys` (§11.12) and client secrets, the plaintext webhook
+ * signing secret is shown exactly once, on create/rotate.
+ */
+export declare const WEBHOOK_EVENT_TYPES: readonly ["user.created", "user.updated", "user.deleted", "user.blocked", "identity.linked", "identity.unlinked", "passkey.created", "passkey.deleted", "session.created", "session.revoked", "login.succeeded", "login.failed", "email.delivery.bounced", "mau.threshold_reached"];
+export declare const webhookEventTypeSchema: z.ZodEnum<{
+    "user.created": "user.created";
+    "user.updated": "user.updated";
+    "user.deleted": "user.deleted";
+    "user.blocked": "user.blocked";
+    "identity.linked": "identity.linked";
+    "identity.unlinked": "identity.unlinked";
+    "passkey.created": "passkey.created";
+    "passkey.deleted": "passkey.deleted";
+    "session.created": "session.created";
+    "session.revoked": "session.revoked";
+    "login.succeeded": "login.succeeded";
+    "login.failed": "login.failed";
+    "email.delivery.bounced": "email.delivery.bounced";
+    "mau.threshold_reached": "mau.threshold_reached";
+}>;
+export type WebhookEventType = (typeof WEBHOOK_EVENT_TYPES)[number];
+export declare const WEBHOOK_STATUSES: readonly ["active", "disabled"];
+export declare const webhookStatusSchema: z.ZodEnum<{
+    active: "active";
+    disabled: "disabled";
+}>;
+export type WebhookStatus = (typeof WEBHOOK_STATUSES)[number];
+export declare const webhookSchema: z.ZodObject<{
+    id: z.ZodString;
+    environment_id: z.ZodString;
+    url: z.ZodURL;
+    event_types: z.ZodArray<z.ZodEnum<{
+        "user.created": "user.created";
+        "user.updated": "user.updated";
+        "user.deleted": "user.deleted";
+        "user.blocked": "user.blocked";
+        "identity.linked": "identity.linked";
+        "identity.unlinked": "identity.unlinked";
+        "passkey.created": "passkey.created";
+        "passkey.deleted": "passkey.deleted";
+        "session.created": "session.created";
+        "session.revoked": "session.revoked";
+        "login.succeeded": "login.succeeded";
+        "login.failed": "login.failed";
+        "email.delivery.bounced": "email.delivery.bounced";
+        "mau.threshold_reached": "mau.threshold_reached";
+    }>>;
+    status: z.ZodEnum<{
+        active: "active";
+        disabled: "disabled";
+    }>;
+    created_at: z.ZodISODateTime;
+    updated_at: z.ZodISODateTime;
+}, z.core.$strict>;
+export type Webhook = z.infer<typeof webhookSchema>;
+export declare const webhookListQuerySchema: z.ZodObject<{
+    cursor: z.ZodOptional<z.ZodString>;
+    limit: z.ZodDefault<z.ZodCoercedNumber<unknown>>;
+    environment_id: z.ZodString;
+}, z.core.$strip>;
+export type WebhookListQuery = z.infer<typeof webhookListQuerySchema>;
+export declare const webhookListResponseSchema: z.ZodObject<{
+    items: z.ZodArray<z.ZodObject<{
+        id: z.ZodString;
+        environment_id: z.ZodString;
+        url: z.ZodURL;
+        event_types: z.ZodArray<z.ZodEnum<{
+            "user.created": "user.created";
+            "user.updated": "user.updated";
+            "user.deleted": "user.deleted";
+            "user.blocked": "user.blocked";
+            "identity.linked": "identity.linked";
+            "identity.unlinked": "identity.unlinked";
+            "passkey.created": "passkey.created";
+            "passkey.deleted": "passkey.deleted";
+            "session.created": "session.created";
+            "session.revoked": "session.revoked";
+            "login.succeeded": "login.succeeded";
+            "login.failed": "login.failed";
+            "email.delivery.bounced": "email.delivery.bounced";
+            "mau.threshold_reached": "mau.threshold_reached";
+        }>>;
+        status: z.ZodEnum<{
+            active: "active";
+            disabled: "disabled";
+        }>;
+        created_at: z.ZodISODateTime;
+        updated_at: z.ZodISODateTime;
+    }, z.core.$strict>>;
+    next_cursor: z.ZodNullable<z.ZodString>;
+}, z.core.$strict>;
+export type WebhookListResponse = z.infer<typeof webhookListResponseSchema>;
+export declare const webhookCreateRequestSchema: z.ZodObject<{
+    environment_id: z.ZodString;
+    url: z.ZodURL;
+    event_types: z.ZodArray<z.ZodEnum<{
+        "user.created": "user.created";
+        "user.updated": "user.updated";
+        "user.deleted": "user.deleted";
+        "user.blocked": "user.blocked";
+        "identity.linked": "identity.linked";
+        "identity.unlinked": "identity.unlinked";
+        "passkey.created": "passkey.created";
+        "passkey.deleted": "passkey.deleted";
+        "session.created": "session.created";
+        "session.revoked": "session.revoked";
+        "login.succeeded": "login.succeeded";
+        "login.failed": "login.failed";
+        "email.delivery.bounced": "email.delivery.bounced";
+        "mau.threshold_reached": "mau.threshold_reached";
+    }>>;
+}, z.core.$strict>;
+export type WebhookCreateRequest = z.infer<typeof webhookCreateRequestSchema>;
+/** One-time plaintext signing secret (design.md §11.12's display-once rule, applied here too; §29.4 HMAC). */
+export declare const webhookCreateResponseSchema: z.ZodObject<{
+    id: z.ZodString;
+    environment_id: z.ZodString;
+    url: z.ZodURL;
+    event_types: z.ZodArray<z.ZodEnum<{
+        "user.created": "user.created";
+        "user.updated": "user.updated";
+        "user.deleted": "user.deleted";
+        "user.blocked": "user.blocked";
+        "identity.linked": "identity.linked";
+        "identity.unlinked": "identity.unlinked";
+        "passkey.created": "passkey.created";
+        "passkey.deleted": "passkey.deleted";
+        "session.created": "session.created";
+        "session.revoked": "session.revoked";
+        "login.succeeded": "login.succeeded";
+        "login.failed": "login.failed";
+        "email.delivery.bounced": "email.delivery.bounced";
+        "mau.threshold_reached": "mau.threshold_reached";
+    }>>;
+    status: z.ZodEnum<{
+        active: "active";
+        disabled: "disabled";
+    }>;
+    created_at: z.ZodISODateTime;
+    updated_at: z.ZodISODateTime;
+    secret: z.ZodString;
+}, z.core.$strict>;
+export type WebhookCreateResponse = z.infer<typeof webhookCreateResponseSchema>;
+export declare const webhookUpdateRequestSchema: z.ZodObject<{
+    url: z.ZodOptional<z.ZodURL>;
+    event_types: z.ZodOptional<z.ZodArray<z.ZodEnum<{
+        "user.created": "user.created";
+        "user.updated": "user.updated";
+        "user.deleted": "user.deleted";
+        "user.blocked": "user.blocked";
+        "identity.linked": "identity.linked";
+        "identity.unlinked": "identity.unlinked";
+        "passkey.created": "passkey.created";
+        "passkey.deleted": "passkey.deleted";
+        "session.created": "session.created";
+        "session.revoked": "session.revoked";
+        "login.succeeded": "login.succeeded";
+        "login.failed": "login.failed";
+        "email.delivery.bounced": "email.delivery.bounced";
+        "mau.threshold_reached": "mau.threshold_reached";
+    }>>>;
+    status: z.ZodOptional<z.ZodEnum<{
+        active: "active";
+        disabled: "disabled";
+    }>>;
+}, z.core.$strict>;
+export type WebhookUpdateRequest = z.infer<typeof webhookUpdateRequestSchema>;
+export declare const webhookUpdateResponseSchema: z.ZodObject<{
+    id: z.ZodString;
+    environment_id: z.ZodString;
+    url: z.ZodURL;
+    event_types: z.ZodArray<z.ZodEnum<{
+        "user.created": "user.created";
+        "user.updated": "user.updated";
+        "user.deleted": "user.deleted";
+        "user.blocked": "user.blocked";
+        "identity.linked": "identity.linked";
+        "identity.unlinked": "identity.unlinked";
+        "passkey.created": "passkey.created";
+        "passkey.deleted": "passkey.deleted";
+        "session.created": "session.created";
+        "session.revoked": "session.revoked";
+        "login.succeeded": "login.succeeded";
+        "login.failed": "login.failed";
+        "email.delivery.bounced": "email.delivery.bounced";
+        "mau.threshold_reached": "mau.threshold_reached";
+    }>>;
+    status: z.ZodEnum<{
+        active: "active";
+        disabled: "disabled";
+    }>;
+    created_at: z.ZodISODateTime;
+    updated_at: z.ZodISODateTime;
+}, z.core.$strict>;
+export type WebhookUpdateResponse = z.infer<typeof webhookUpdateResponseSchema>;
+export declare const webhookDeleteResponseSchema: z.ZodObject<{
+    id: z.ZodString;
+    deleted: z.ZodLiteral<true>;
+}, z.core.$strict>;
+export type WebhookDeleteResponse = z.infer<typeof webhookDeleteResponseSchema>;
+export declare const webhookRotateSecretRequestSchema: z.ZodObject<{}, z.core.$strict>;
+export type WebhookRotateSecretRequest = z.infer<typeof webhookRotateSecretRequestSchema>;
+export declare const webhookRotateSecretResponseSchema: z.ZodObject<{
+    id: z.ZodString;
+    secret: z.ZodString;
+    rotated_at: z.ZodISODateTime;
+}, z.core.$strict>;
+export type WebhookRotateSecretResponse = z.infer<typeof webhookRotateSecretResponseSchema>;
+export declare const webhookTestRequestSchema: z.ZodObject<{
+    event_type: z.ZodOptional<z.ZodEnum<{
+        "user.created": "user.created";
+        "user.updated": "user.updated";
+        "user.deleted": "user.deleted";
+        "user.blocked": "user.blocked";
+        "identity.linked": "identity.linked";
+        "identity.unlinked": "identity.unlinked";
+        "passkey.created": "passkey.created";
+        "passkey.deleted": "passkey.deleted";
+        "session.created": "session.created";
+        "session.revoked": "session.revoked";
+        "login.succeeded": "login.succeeded";
+        "login.failed": "login.failed";
+        "email.delivery.bounced": "email.delivery.bounced";
+        "mau.threshold_reached": "mau.threshold_reached";
+    }>>;
+}, z.core.$strict>;
+export type WebhookTestRequest = z.infer<typeof webhookTestRequestSchema>;
+/** design.md §29.4: "2xxだけ成功". `delivered` reports whether the endpoint returned 2xx. */
+export declare const webhookTestResponseSchema: z.ZodObject<{
+    delivered: z.ZodBoolean;
+    response_status: z.ZodNullable<z.ZodNumber>;
+    response_time_ms: z.ZodNullable<z.ZodNumber>;
+    requested_at: z.ZodISODateTime;
+}, z.core.$strict>;
+export type WebhookTestResponse = z.infer<typeof webhookTestResponseSchema>;
+/**
+ * `webhook_delivery_history` (design.md §29.4, §10.10): one row per delivery
+ * attempt. Deliberately excludes any request/response body, header, or
+ * signature — only status/attempt/response code/duration are ever recorded
+ * or exposed here, matching `@smartcrab/database-control`'s
+ * `WebhookDeliveryHistoryRecord`.
+ */
+export declare const WEBHOOK_DELIVERY_STATUSES: readonly ["pending", "delivered", "failed", "exhausted"];
+export declare const webhookDeliveryStatusSchema: z.ZodEnum<{
+    failed: "failed";
+    pending: "pending";
+    delivered: "delivered";
+    exhausted: "exhausted";
+}>;
+export type WebhookDeliveryStatus = (typeof WEBHOOK_DELIVERY_STATUSES)[number];
+export declare const webhookDeliverySchema: z.ZodObject<{
+    id: z.ZodString;
+    webhook_id: z.ZodString;
+    event_id: z.ZodString;
+    event_type: z.ZodString;
+    attempt: z.ZodNumber;
+    status: z.ZodEnum<{
+        failed: "failed";
+        pending: "pending";
+        delivered: "delivered";
+        exhausted: "exhausted";
+    }>;
+    response_status_code: z.ZodNullable<z.ZodNumber>;
+    duration_ms: z.ZodNumber;
+    occurred_at: z.ZodISODateTime;
+}, z.core.$strict>;
+export type WebhookDelivery = z.infer<typeof webhookDeliverySchema>;
+export declare const webhookDeliveryListQuerySchema: z.ZodObject<{
+    cursor: z.ZodOptional<z.ZodString>;
+    limit: z.ZodDefault<z.ZodCoercedNumber<unknown>>;
+    status: z.ZodOptional<z.ZodEnum<{
+        failed: "failed";
+        pending: "pending";
+        delivered: "delivered";
+        exhausted: "exhausted";
+    }>>;
+    occurred_after: z.ZodOptional<z.ZodISODateTime>;
+    occurred_before: z.ZodOptional<z.ZodISODateTime>;
+}, z.core.$strip>;
+export type WebhookDeliveryListQuery = z.infer<typeof webhookDeliveryListQuerySchema>;
+export declare const webhookDeliveryListResponseSchema: z.ZodObject<{
+    items: z.ZodArray<z.ZodObject<{
+        id: z.ZodString;
+        webhook_id: z.ZodString;
+        event_id: z.ZodString;
+        event_type: z.ZodString;
+        attempt: z.ZodNumber;
+        status: z.ZodEnum<{
+            failed: "failed";
+            pending: "pending";
+            delivered: "delivered";
+            exhausted: "exhausted";
+        }>;
+        response_status_code: z.ZodNullable<z.ZodNumber>;
+        duration_ms: z.ZodNumber;
+        occurred_at: z.ZodISODateTime;
+    }, z.core.$strict>>;
+    next_cursor: z.ZodNullable<z.ZodString>;
+}, z.core.$strict>;
+export type WebhookDeliveryListResponse = z.infer<typeof webhookDeliveryListResponseSchema>;