@sylphx/contract 0.2.0

package/dist/endpoints/storage.js

@@ -0,0 +1,117 @@
+/**
+ * Storage endpoints — BaaS plane. Paths mirror `@sylphx/sdk/storage.ts`.
+ */
+import { Schema } from 'effect';
+import { defineEndpoint } from '../endpoint.js';
+import { DeleteFileResult, FileInfo, ListFilesQuery, ListFilesResult, ListFileVersionsResult, RestoreFileResult, RestoreVersionResult, SignedUrlInput, SignedUrlResult, SoftDeleteFileResult, UploadTokenInput, UploadTokenResult, UploadUrlInput, UploadUrlResult, } from '../schemas/storage.js';
+const IdPath = Schema.Struct({ id: Schema.String });
+const FileVersionPath = Schema.Struct({
+    id: Schema.String,
+    versionId: Schema.String,
+});
+export const storageEndpoints = {
+    /**
+     * Mint an upload token for client-direct uploads. Returns either a
+     * simple `{ uploadUrl, publicUrl }` pair or a Vercel-Blob-style
+     * `{ uploadEndpoint, clientPayload, instructions }` envelope.
+     * This is the SDK's primary upload path (`uploadFile` / `uploadAvatar`).
+     */
+    upload: defineEndpoint({
+        method: 'POST',
+        path: '/storage/upload',
+        body: UploadTokenInput,
+        response: UploadTokenResult,
+        plane: 'baas',
+        summary: 'Mint an upload token for client-direct file uploads',
+        tags: ['storage'],
+    }),
+    presignedUrl: defineEndpoint({
+        method: 'POST',
+        path: '/storage/upload-url',
+        body: UploadUrlInput,
+        response: UploadUrlResult,
+        plane: 'baas',
+        summary: 'Mint a short-lived presigned upload URL',
+        tags: ['storage'],
+    }),
+    /**
+     * Generate a time-limited signed URL for accessing a private file.
+     * Signed URLs avoid exposing permanent credentials and can be scoped
+     * to a specific user via the `userId` field.
+     */
+    signedUrl: defineEndpoint({
+        method: 'POST',
+        path: '/storage/signed-url',
+        body: SignedUrlInput,
+        response: SignedUrlResult,
+        plane: 'baas',
+        summary: 'Mint a short-lived signed download URL for a private file',
+        tags: ['storage'],
+    }),
+    list: defineEndpoint({
+        method: 'GET',
+        path: '/storage/files',
+        query: ListFilesQuery,
+        response: ListFilesResult,
+        plane: 'baas',
+        summary: 'List files stored by the app (cursor-paginated)',
+        tags: ['storage'],
+    }),
+    get: defineEndpoint({
+        method: 'GET',
+        path: '/storage/files/:id',
+        params: IdPath,
+        response: FileInfo,
+        plane: 'baas',
+        summary: 'Get file metadata by ID',
+        tags: ['storage'],
+    }),
+    delete: defineEndpoint({
+        method: 'DELETE',
+        path: '/storage/files/:id',
+        params: IdPath,
+        response: DeleteFileResult,
+        plane: 'baas',
+        summary: 'Soft-delete a stored file (ADR-089 Phase 5.8)',
+        tags: ['storage'],
+    }),
+    // ADR-089 Phase 5.8 — versioning + soft-delete restore
+    listVersions: defineEndpoint({
+        method: 'GET',
+        path: '/storage/files/:id/versions',
+        params: IdPath,
+        response: ListFileVersionsResult,
+        plane: 'baas',
+        summary: 'List all versions of a file, newest first',
+        tags: ['storage'],
+    }),
+    restoreVersion: defineEndpoint({
+        method: 'POST',
+        path: '/storage/files/:id/versions/:versionId/restore',
+        params: FileVersionPath,
+        response: RestoreVersionResult,
+        plane: 'baas',
+        summary: 'Restore an older version as the current version',
+        tags: ['storage'],
+    }),
+    restoreFile: defineEndpoint({
+        method: 'POST',
+        path: '/storage/files/:id/restore',
+        params: IdPath,
+        response: RestoreFileResult,
+        plane: 'baas',
+        summary: 'Restore a soft-deleted file',
+        tags: ['storage'],
+    }),
+    // Alias of `delete` — explicit endpoint name so SDK `softDeleteFile()`
+    // is unambiguous; same underlying route.
+    softDelete: defineEndpoint({
+        method: 'DELETE',
+        path: '/storage/files/:id',
+        params: IdPath,
+        response: SoftDeleteFileResult,
+        plane: 'baas',
+        summary: 'Soft-delete a stored file (explicit alias of delete)',
+        tags: ['storage'],
+    }),
+};

package/dist/endpoints/tasks.d.ts

@@ -0,0 +1,141 @@
+/**
+ * Tasks endpoints — Console-plane customer background job management.
+ * Mirrors `apps/api/src/server/platform/routes/tasks/{status,one-off,cron}.ts`.
+ *
+ * Production mount: `/tasks/*`. Distinct from `adminTasksEndpoints` (which
+ * targets the super-admin dashboard over the platform DB).
+ */
+export declare const tasksEndpoints: {
+    readonly getStatus: import("../endpoint.js").Endpoint<"GET", "/tasks/status", import("effect/Schema").Schema.AnyNoContext | undefined, import("effect/Schema").Struct<{
+        projectId: typeof import("effect/Schema").String;
+    }>, import("effect/Schema").Schema.AnyNoContext | undefined, import("effect/Schema").Struct<{
+        available: typeof import("effect/Schema").Boolean;
+        provider: typeof import("effect/Schema").String;
+    }>>;
+    readonly list: import("../endpoint.js").Endpoint<"GET", "/tasks", import("effect/Schema").Schema.AnyNoContext | undefined, import("effect/Schema").Struct<{
+        projectId: typeof import("effect/Schema").String;
+        status: import("effect/Schema").optional<import("effect/Schema").Literal<["all", "pending", "queued", "running", "completed", "failed", "scheduled", "paused", "cancelled", "deleted"]>>;
+        type: import("effect/Schema").optional<import("effect/Schema").Literal<["all", "one-time", "cron"]>>;
+        limit: import("effect/Schema").optional<typeof import("effect/Schema").String>;
+        offset: import("effect/Schema").optional<typeof import("effect/Schema").String>;
+    }>, import("effect/Schema").Schema.AnyNoContext | undefined, import("effect/Schema").Struct<{
+        jobs: import("effect/Schema").Array$<import("effect/Schema").Struct<{
+            id: typeof import("effect/Schema").String;
+            name: import("effect/Schema").NullOr<typeof import("effect/Schema").String>;
+            type: import("effect/Schema").Literal<["one-time", "cron"]>;
+            status: import("effect/Schema").Literal<["pending", "queued", "running", "completed", "failed", "scheduled", "paused", "cancelled", "deleted"]>;
+            callbackUrl: typeof import("effect/Schema").String;
+            payload: import("effect/Schema").NullOr<import("effect/Schema").Record$<typeof import("effect/Schema").String, typeof import("effect/Schema").Unknown>>;
+            method: import("effect/Schema").NullOr<import("effect/Schema").Literal<["GET", "POST", "PUT", "DELETE", "PATCH"]>>;
+            headers: import("effect/Schema").NullOr<import("effect/Schema").Record$<typeof import("effect/Schema").String, typeof import("effect/Schema").String>>;
+            scheduledFor: import("effect/Schema").NullOr<typeof import("effect/Schema").String>;
+            startedAt: import("effect/Schema").NullOr<typeof import("effect/Schema").String>;
+            completedAt: import("effect/Schema").NullOr<typeof import("effect/Schema").String>;
+            failedAt: import("effect/Schema").NullOr<typeof import("effect/Schema").String>;
+            cronExpression: import("effect/Schema").NullOr<typeof import("effect/Schema").String>;
+            retries: typeof import("effect/Schema").Number;
+            maxRetries: typeof import("effect/Schema").Number;
+            lastError: import("effect/Schema").NullOr<typeof import("effect/Schema").String>;
+            qstashMessageId: import("effect/Schema").NullOr<typeof import("effect/Schema").String>;
+            qstashScheduleId: import("effect/Schema").NullOr<typeof import("effect/Schema").String>;
+            createdAt: typeof import("effect/Schema").String;
+        }>>;
+        total: typeof import("effect/Schema").Number;
+        limit: typeof import("effect/Schema").Number;
+        offset: typeof import("effect/Schema").Number;
+    }>>;
+    readonly get: import("../endpoint.js").Endpoint<"GET", "/tasks/:jobId", import("effect/Schema").Struct<{
+        jobId: typeof import("effect/Schema").String;
+    }>, import("effect/Schema").Struct<{
+        projectId: typeof import("effect/Schema").String;
+    }>, import("effect/Schema").Schema.AnyNoContext | undefined, import("effect/Schema").Struct<{
+        job: import("effect/Schema").Struct<{
+            id: typeof import("effect/Schema").String;
+            name: import("effect/Schema").NullOr<typeof import("effect/Schema").String>;
+            type: import("effect/Schema").Literal<["one-time", "cron"]>;
+            status: import("effect/Schema").Literal<["pending", "queued", "running", "completed", "failed", "scheduled", "paused", "cancelled", "deleted"]>;
+            callbackUrl: typeof import("effect/Schema").String;
+            payload: import("effect/Schema").NullOr<import("effect/Schema").Record$<typeof import("effect/Schema").String, typeof import("effect/Schema").Unknown>>;
+            method: import("effect/Schema").NullOr<import("effect/Schema").Literal<["GET", "POST", "PUT", "DELETE", "PATCH"]>>;
+            headers: import("effect/Schema").NullOr<import("effect/Schema").Record$<typeof import("effect/Schema").String, typeof import("effect/Schema").String>>;
+            scheduledFor: import("effect/Schema").NullOr<typeof import("effect/Schema").String>;
+            startedAt: import("effect/Schema").NullOr<typeof import("effect/Schema").String>;
+            completedAt: import("effect/Schema").NullOr<typeof import("effect/Schema").String>;
+            failedAt: import("effect/Schema").NullOr<typeof import("effect/Schema").String>;
+            cronExpression: import("effect/Schema").NullOr<typeof import("effect/Schema").String>;
+            retries: typeof import("effect/Schema").Number;
+            maxRetries: typeof import("effect/Schema").Number;
+            lastError: import("effect/Schema").NullOr<typeof import("effect/Schema").String>;
+            qstashMessageId: import("effect/Schema").NullOr<typeof import("effect/Schema").String>;
+            qstashScheduleId: import("effect/Schema").NullOr<typeof import("effect/Schema").String>;
+            createdAt: typeof import("effect/Schema").String;
+        }>;
+    }>>;
+    readonly schedule: import("../endpoint.js").Endpoint<"POST", "/tasks", import("effect/Schema").Schema.AnyNoContext | undefined, import("effect/Schema").Schema.AnyNoContext | undefined, import("effect/Schema").Struct<{
+        projectId: typeof import("effect/Schema").String;
+        environmentId: import("effect/Schema").optional<typeof import("effect/Schema").String>;
+        callbackUrl: typeof import("effect/Schema").String;
+        payload: import("effect/Schema").optional<import("effect/Schema").Record$<typeof import("effect/Schema").String, typeof import("effect/Schema").Unknown>>;
+        method: import("effect/Schema").optional<import("effect/Schema").Literal<["GET", "POST", "PUT", "DELETE", "PATCH"]>>;
+        headers: import("effect/Schema").optional<import("effect/Schema").Record$<typeof import("effect/Schema").String, typeof import("effect/Schema").String>>;
+        delay: import("effect/Schema").optional<typeof import("effect/Schema").Number>;
+        scheduledFor: import("effect/Schema").optional<typeof import("effect/Schema").String>;
+        retries: import("effect/Schema").optional<typeof import("effect/Schema").Number>;
+        name: import("effect/Schema").optional<typeof import("effect/Schema").String>;
+        type: import("effect/Schema").optional<typeof import("effect/Schema").String>;
+        timeout: import("effect/Schema").optional<typeof import("effect/Schema").Number>;
+    }>, import("effect/Schema").Struct<{
+        jobId: typeof import("effect/Schema").String;
+        messageId: import("effect/Schema").optional<typeof import("effect/Schema").String>;
+        scheduledFor: import("effect/Schema").NullOr<typeof import("effect/Schema").String>;
+    }>>;
+    readonly cancel: import("../endpoint.js").Endpoint<"POST", "/tasks/:jobId/cancel", import("effect/Schema").Struct<{
+        jobId: typeof import("effect/Schema").String;
+    }>, import("effect/Schema").Schema.AnyNoContext | undefined, import("effect/Schema").Struct<{
+        projectId: typeof import("effect/Schema").String;
+    }>, import("effect/Schema").Struct<{
+        success: typeof import("effect/Schema").Boolean;
+    }>>;
+    readonly createCron: import("../endpoint.js").Endpoint<"POST", "/tasks/cron", import("effect/Schema").Schema.AnyNoContext | undefined, import("effect/Schema").Schema.AnyNoContext | undefined, import("effect/Schema").Struct<{
+        projectId: typeof import("effect/Schema").String;
+        callbackUrl: typeof import("effect/Schema").String;
+        cron: typeof import("effect/Schema").String;
+        payload: import("effect/Schema").optional<import("effect/Schema").Record$<typeof import("effect/Schema").String, typeof import("effect/Schema").Unknown>>;
+        method: import("effect/Schema").optional<import("effect/Schema").Literal<["GET", "POST", "PUT", "DELETE", "PATCH"]>>;
+        headers: import("effect/Schema").optional<import("effect/Schema").Record$<typeof import("effect/Schema").String, typeof import("effect/Schema").String>>;
+        retries: import("effect/Schema").optional<typeof import("effect/Schema").Number>;
+        name: typeof import("effect/Schema").String;
+        type: import("effect/Schema").optional<typeof import("effect/Schema").String>;
+        paused: import("effect/Schema").optional<typeof import("effect/Schema").Boolean>;
+        environmentId: import("effect/Schema").optional<typeof import("effect/Schema").String>;
+        taskName: import("effect/Schema").optional<typeof import("effect/Schema").String>;
+        handlerPath: import("effect/Schema").optional<typeof import("effect/Schema").String>;
+    }>, import("effect/Schema").Struct<{
+        jobId: typeof import("effect/Schema").String;
+        scheduleId: typeof import("effect/Schema").String;
+        cron: typeof import("effect/Schema").String;
+        paused: typeof import("effect/Schema").Boolean;
+    }>>;
+    readonly pauseCron: import("../endpoint.js").Endpoint<"POST", "/tasks/cron/:scheduleId/pause", import("effect/Schema").Struct<{
+        scheduleId: typeof import("effect/Schema").String;
+    }>, import("effect/Schema").Schema.AnyNoContext | undefined, import("effect/Schema").Struct<{
+        projectId: typeof import("effect/Schema").String;
+    }>, import("effect/Schema").Struct<{
+        success: typeof import("effect/Schema").Boolean;
+    }>>;
+    readonly resumeCron: import("../endpoint.js").Endpoint<"POST", "/tasks/cron/:scheduleId/resume", import("effect/Schema").Struct<{
+        scheduleId: typeof import("effect/Schema").String;
+    }>, import("effect/Schema").Schema.AnyNoContext | undefined, import("effect/Schema").Struct<{
+        projectId: typeof import("effect/Schema").String;
+    }>, import("effect/Schema").Struct<{
+        success: typeof import("effect/Schema").Boolean;
+    }>>;
+    readonly deleteCron: import("../endpoint.js").Endpoint<"DELETE", "/tasks/cron/:scheduleId", import("effect/Schema").Struct<{
+        scheduleId: typeof import("effect/Schema").String;
+    }>, import("effect/Schema").Schema.AnyNoContext | undefined, import("effect/Schema").Struct<{
+        projectId: typeof import("effect/Schema").String;
+    }>, import("effect/Schema").Struct<{
+        success: typeof import("effect/Schema").Boolean;
+    }>>;
+};
+//# sourceMappingURL=tasks.d.ts.map

package/dist/endpoints/tasks.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"tasks.d.ts","sourceRoot":"","sources":["../../src/endpoints/tasks.ts"],"names":[],"mappings":"AAAA;;;;;;GAMG;AAsBH,eAAO,MAAM,cAAc;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;CAuFjB,CAAA"}

package/dist/endpoints/tasks.js

@@ -0,0 +1,97 @@
+/**
+ * Tasks endpoints — Console-plane customer background job management.
+ * Mirrors `apps/api/src/server/platform/routes/tasks/{status,one-off,cron}.ts`.
+ *
+ * Production mount: `/tasks/*`. Distinct from `adminTasksEndpoints` (which
+ * targets the super-admin dashboard over the platform DB).
+ */
+import { defineEndpoint } from '../endpoint.js';
+import { CancelTaskInput, CancelTaskResult, CreateCronTaskInput, CreateCronTaskResult, CronActionInput, CronActionResult, DeleteCronInput, GetTaskResult, ListTasksQuery, ListTasksResult, ScheduleIdParam, ScheduleTaskInput, ScheduleTaskResult, TaskIdParam, TasksProjectIdQuery, TasksStatusResult, } from '../schemas/tasks.js';
+export const tasksEndpoints = {
+    getStatus: defineEndpoint({
+        method: 'GET',
+        path: '/tasks/status',
+        query: TasksProjectIdQuery,
+        response: TasksStatusResult,
+        plane: 'management',
+        summary: 'Get background jobs service status',
+        tags: ['tasks'],
+    }),
+    list: defineEndpoint({
+        method: 'GET',
+        path: '/tasks',
+        query: ListTasksQuery,
+        response: ListTasksResult,
+        plane: 'management',
+        summary: 'List scheduled jobs for an app',
+        tags: ['tasks'],
+    }),
+    get: defineEndpoint({
+        method: 'GET',
+        path: '/tasks/:jobId',
+        params: TaskIdParam,
+        query: TasksProjectIdQuery,
+        response: GetTaskResult,
+        plane: 'management',
+        summary: 'Get details for a scheduled job',
+        tags: ['tasks'],
+    }),
+    schedule: defineEndpoint({
+        method: 'POST',
+        path: '/tasks',
+        body: ScheduleTaskInput,
+        response: ScheduleTaskResult,
+        plane: 'management',
+        summary: 'Schedule a one-time background job',
+        tags: ['tasks'],
+    }),
+    cancel: defineEndpoint({
+        method: 'POST',
+        path: '/tasks/:jobId/cancel',
+        params: TaskIdParam,
+        body: CancelTaskInput,
+        response: CancelTaskResult,
+        plane: 'management',
+        summary: 'Cancel a pending / queued job',
+        tags: ['tasks'],
+    }),
+    createCron: defineEndpoint({
+        method: 'POST',
+        path: '/tasks/cron',
+        body: CreateCronTaskInput,
+        response: CreateCronTaskResult,
+        plane: 'management',
+        summary: 'Create a recurring cron job',
+        tags: ['tasks'],
+    }),
+    pauseCron: defineEndpoint({
+        method: 'POST',
+        path: '/tasks/cron/:scheduleId/pause',
+        params: ScheduleIdParam,
+        body: CronActionInput,
+        response: CronActionResult,
+        plane: 'management',
+        summary: 'Pause a cron job',
+        tags: ['tasks'],
+    }),
+    resumeCron: defineEndpoint({
+        method: 'POST',
+        path: '/tasks/cron/:scheduleId/resume',
+        params: ScheduleIdParam,
+        body: CronActionInput,
+        response: CronActionResult,
+        plane: 'management',
+        summary: 'Resume a paused cron job',
+        tags: ['tasks'],
+    }),
+    deleteCron: defineEndpoint({
+        method: 'DELETE',
+        path: '/tasks/cron/:scheduleId',
+        params: ScheduleIdParam,
+        body: DeleteCronInput,
+        response: CronActionResult,
+        plane: 'management',
+        summary: 'Delete a cron job',
+        tags: ['tasks'],
+    }),
+};

package/dist/endpoints/users.d.ts

@@ -0,0 +1,103 @@
+/**
+ * Users endpoints — Console-plane profile, security, sessions, GDPR
+ * export/erasure. Production mounts at `/user/*`. Mirrors
+ * `apps/api/src/server/platform/routes/user.ts` (ADR-084 Wave 2b).
+ */
+import { Schema } from 'effect';
+export declare const usersEndpoints: {
+    readonly whoami: import("../endpoint.js").Endpoint<"GET", "/user/me", Schema.Schema.AnyNoContext | undefined, Schema.Schema.AnyNoContext | undefined, Schema.Schema.AnyNoContext | undefined, Schema.Struct<{
+        user: Schema.Struct<{
+            id: Schema.brand<Schema.filter<typeof Schema.String>, "UserId">;
+            email: typeof Schema.String;
+            name: Schema.NullOr<typeof Schema.String>;
+        }>;
+        orgs: Schema.Array$<Schema.Struct<{
+            id: Schema.brand<Schema.filter<typeof Schema.String>, "OrgId">;
+            slug: typeof Schema.String;
+            name: typeof Schema.String;
+            email: Schema.optional<Schema.NullOr<typeof Schema.String>>;
+            billingEmail: Schema.optional<Schema.NullOr<typeof Schema.String>>;
+            logoUrl: Schema.optional<Schema.NullOr<typeof Schema.String>>;
+            metadata: Schema.optional<Schema.NullOr<Schema.Record$<typeof Schema.String, typeof Schema.Unknown>>>;
+            createdAt: Schema.optional<typeof Schema.String>;
+        }>>;
+    }>>;
+    readonly getProfile: import("../endpoint.js").Endpoint<"GET", "/user/profile", Schema.Schema.AnyNoContext | undefined, Schema.Schema.AnyNoContext | undefined, Schema.Schema.AnyNoContext | undefined, Schema.Struct<{
+        id: Schema.brand<Schema.filter<typeof Schema.String>, "UserId">;
+        email: typeof Schema.String;
+        name: Schema.NullOr<typeof Schema.String>;
+        image: Schema.NullOr<typeof Schema.String>;
+        emailVerified: typeof Schema.Boolean;
+        timezone: Schema.NullOr<typeof Schema.String>;
+        locale: Schema.NullOr<typeof Schema.String>;
+        createdAt: typeof Schema.String;
+    }>>;
+    readonly updateProfile: import("../endpoint.js").Endpoint<"PATCH", "/user/profile", Schema.Schema.AnyNoContext | undefined, Schema.Schema.AnyNoContext | undefined, Schema.Struct<{
+        name: Schema.optional<Schema.NullOr<typeof Schema.String>>;
+        image: Schema.optional<Schema.NullOr<typeof Schema.String>>;
+        timezone: Schema.optional<Schema.NullOr<typeof Schema.String>>;
+        locale: Schema.optional<Schema.NullOr<typeof Schema.String>>;
+    }>, Schema.Struct<{
+        id: Schema.brand<Schema.filter<typeof Schema.String>, "UserId">;
+        email: typeof Schema.String;
+        name: Schema.NullOr<typeof Schema.String>;
+        image: Schema.NullOr<typeof Schema.String>;
+        emailVerified: typeof Schema.Boolean;
+        timezone: Schema.NullOr<typeof Schema.String>;
+        locale: Schema.NullOr<typeof Schema.String>;
+        createdAt: typeof Schema.String;
+    }>>;
+    readonly getSecurity: import("../endpoint.js").Endpoint<"GET", "/user/security", Schema.Schema.AnyNoContext | undefined, Schema.Schema.AnyNoContext | undefined, Schema.Schema.AnyNoContext | undefined, Schema.Struct<{
+        twoFactorEnabled: typeof Schema.Boolean;
+        hasPassword: typeof Schema.Boolean;
+        emailVerified: typeof Schema.Boolean;
+    }>>;
+    readonly changePassword: import("../endpoint.js").Endpoint<"POST", "/user/password", Schema.Schema.AnyNoContext | undefined, Schema.Schema.AnyNoContext | undefined, Schema.Struct<{
+        currentPassword: typeof Schema.String;
+        newPassword: typeof Schema.String;
+    }>, Schema.Struct<{
+        success: typeof Schema.Boolean;
+    }>>;
+    readonly getConnectedAccounts: import("../endpoint.js").Endpoint<"GET", "/user/connected-accounts", Schema.Schema.AnyNoContext | undefined, Schema.Schema.AnyNoContext | undefined, Schema.Schema.AnyNoContext | undefined, Schema.Array$<Schema.Struct<{
+        provider: typeof Schema.String;
+        connectedAt: typeof Schema.String;
+    }>>>;
+    readonly getLoginHistory: import("../endpoint.js").Endpoint<"GET", "/user/login-history", Schema.Schema.AnyNoContext | undefined, Schema.Schema.AnyNoContext | undefined, Schema.Schema.AnyNoContext | undefined, Schema.Array$<Schema.Struct<{
+        id: typeof Schema.String;
+        ipAddress: Schema.NullOr<typeof Schema.String>;
+        userAgent: Schema.NullOr<typeof Schema.String>;
+        country: Schema.NullOr<typeof Schema.String>;
+        city: Schema.NullOr<typeof Schema.String>;
+        device: Schema.NullOr<typeof Schema.String>;
+        success: typeof Schema.Boolean;
+        createdAt: typeof Schema.String;
+    }>>>;
+    readonly getSessions: import("../endpoint.js").Endpoint<"GET", "/user/sessions", Schema.Schema.AnyNoContext | undefined, Schema.Schema.AnyNoContext | undefined, Schema.Schema.AnyNoContext | undefined, Schema.Array$<Schema.Struct<{
+        id: Schema.brand<Schema.filter<typeof Schema.String>, "SessionId">;
+        isCurrent: Schema.optional<typeof Schema.Boolean>;
+        deviceName: Schema.NullOr<typeof Schema.String>;
+        browser: Schema.NullOr<typeof Schema.String>;
+        os: Schema.NullOr<typeof Schema.String>;
+        deviceType: Schema.NullOr<typeof Schema.String>;
+        ipAddress: Schema.NullOr<typeof Schema.String>;
+        country: Schema.NullOr<typeof Schema.String>;
+        city: Schema.NullOr<typeof Schema.String>;
+        lastActiveAt: typeof Schema.String;
+        createdAt: typeof Schema.String;
+    }>>>;
+    readonly revokeSession: import("../endpoint.js").Endpoint<"DELETE", "/user/sessions/:sessionId", Schema.Struct<{
+        sessionId: typeof Schema.String;
+    }>, Schema.Schema.AnyNoContext | undefined, Schema.Schema.AnyNoContext | undefined, Schema.Struct<{
+        success: typeof Schema.Boolean;
+    }>>;
+    readonly revokeAllSessions: import("../endpoint.js").Endpoint<"POST", "/user/sessions/revoke-all", Schema.Schema.AnyNoContext | undefined, Schema.Schema.AnyNoContext | undefined, Schema.Schema.AnyNoContext | undefined, Schema.Struct<{
+        success: typeof Schema.Boolean;
+        count: typeof Schema.Number;
+    }>>;
+    readonly exportData: import("../endpoint.js").Endpoint<"GET", "/user/export", Schema.Schema.AnyNoContext | undefined, Schema.Schema.AnyNoContext | undefined, Schema.Schema.AnyNoContext | undefined, Schema.Record$<typeof Schema.String, typeof Schema.Unknown>>;
+    readonly deleteAccount: import("../endpoint.js").Endpoint<"DELETE", "/user/account", Schema.Schema.AnyNoContext | undefined, Schema.Schema.AnyNoContext | undefined, Schema.Schema.AnyNoContext | undefined, Schema.Struct<{
+        success: typeof Schema.Boolean;
+        deletedData: Schema.optional<Schema.Record$<typeof Schema.String, typeof Schema.Unknown>>;
+    }>>;
+};
+//# sourceMappingURL=users.d.ts.map

package/dist/endpoints/users.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"users.d.ts","sourceRoot":"","sources":["../../src/endpoints/users.ts"],"names":[],"mappings":"AAAA;;;;GAIG;AAEH,OAAO,EAAE,MAAM,EAAE,MAAM,QAAQ,CAAA;AAkB/B,eAAO,MAAM,cAAc;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;CAwFjB,CAAA"}

package/dist/endpoints/users.js

@@ -0,0 +1,98 @@
+/**
+ * Users endpoints — Console-plane profile, security, sessions, GDPR
+ * export/erasure. Production mounts at `/user/*`. Mirrors
+ * `apps/api/src/server/platform/routes/user.ts` (ADR-084 Wave 2b).
+ */
+import { Schema } from 'effect';
+import { defineEndpoint } from '../endpoint.js';
+import { ChangePasswordInput, ConnectedAccount, DeleteAccountResult, LoginHistoryEntry, RevokeAllSessionsResult, SecuritySettings, UpdateProfileInput, UserDataExport, UserProfile, UserSession, WhoAmI, } from '../schemas/user.js';
+const SessionIdPath = Schema.Struct({ sessionId: Schema.String });
+export const usersEndpoints = {
+    whoami: defineEndpoint({
+        method: 'GET',
+        path: '/user/me',
+        response: WhoAmI,
+        summary: 'Get the authenticated principal + their org memberships',
+        tags: ['users'],
+    }),
+    getProfile: defineEndpoint({
+        method: 'GET',
+        path: '/user/profile',
+        response: UserProfile,
+        summary: 'Get current user profile',
+        tags: ['users'],
+    }),
+    updateProfile: defineEndpoint({
+        method: 'PATCH',
+        path: '/user/profile',
+        body: UpdateProfileInput,
+        response: UserProfile,
+        summary: 'Update current user profile',
+        tags: ['users'],
+    }),
+    getSecurity: defineEndpoint({
+        method: 'GET',
+        path: '/user/security',
+        response: SecuritySettings,
+        summary: 'Get security settings (2FA status, password status, email verification)',
+        tags: ['users'],
+    }),
+    changePassword: defineEndpoint({
+        method: 'POST',
+        path: '/user/password',
+        body: ChangePasswordInput,
+        response: Schema.Struct({ success: Schema.Boolean }),
+        summary: 'Change password (requires current password)',
+        tags: ['users'],
+    }),
+    getConnectedAccounts: defineEndpoint({
+        method: 'GET',
+        path: '/user/connected-accounts',
+        response: Schema.Array(ConnectedAccount),
+        summary: 'List OAuth providers connected to the current account',
+        tags: ['users'],
+    }),
+    getLoginHistory: defineEndpoint({
+        method: 'GET',
+        path: '/user/login-history',
+        response: Schema.Array(LoginHistoryEntry),
+        summary: 'Get recent login attempts (last 20)',
+        tags: ['users'],
+    }),
+    getSessions: defineEndpoint({
+        method: 'GET',
+        path: '/user/sessions',
+        response: Schema.Array(UserSession),
+        summary: 'List active sessions',
+        tags: ['users'],
+    }),
+    revokeSession: defineEndpoint({
+        method: 'DELETE',
+        path: '/user/sessions/:sessionId',
+        params: SessionIdPath,
+        response: Schema.Struct({ success: Schema.Boolean }),
+        summary: 'Revoke a specific session',
+        tags: ['users'],
+    }),
+    revokeAllSessions: defineEndpoint({
+        method: 'POST',
+        path: '/user/sessions/revoke-all',
+        response: RevokeAllSessionsResult,
+        summary: 'Revoke all sessions except the current one',
+        tags: ['users'],
+    }),
+    exportData: defineEndpoint({
+        method: 'GET',
+        path: '/user/export',
+        response: UserDataExport,
+        summary: 'Export all personal data (GDPR data portability)',
+        tags: ['users'],
+    }),
+    deleteAccount: defineEndpoint({
+        method: 'DELETE',
+        path: '/user/account',
+        response: DeleteAccountResult,
+        summary: 'Permanently delete account (GDPR right to erasure)',
+        tags: ['users'],
+    }),
+};