Remove session methods and client from httpd-client — radicle-explorer

👉 Preview 👉 Workflow runs 👉 Branch on GitHub

 } from "./lib/project.js";
 import type {
   Config,
   SuccessResponse,
   CodeLocation,
   Range,
   SeedingPolicy,

 import * as project from "./lib/project.js";
 import * as profile from "./lib/profile.js";
 import * as session from "./lib/session.js";
 import { Fetcher } from "./lib/fetcher.js";
 import {
   nodeConfigSchema,
   scopeSchema,
   seedingPolicySchema,
   successResponseSchema,
 } from "./lib/shared.js";
 export type {

   public baseUrl: BaseUrl;
   public project: project.Client;
   public profile: profile.Client;
   public session: session.Client;
   public constructor(baseUrl: BaseUrl) {
     this.baseUrl = baseUrl;

     this.project = new project.Client(this.#fetcher);
     this.profile = new profile.Client(this.#fetcher);
     this.session = new session.Client(this.#fetcher);
   }
   public changePort(port: number): void {

     );
   }
   public async seedById(
     id: string,
     authToken: string,
     options?: RequestOptions,
   ): Promise<SuccessResponse> {
     return this.#fetcher.fetchOk(
       {
         method: "PUT",
         path: `node/policies/repos/${id}`,
         headers: { Authorization: `Bearer ${authToken}` },
         options,
       },
       successResponseSchema,
     );
   }
   public async stopSeedingById(
     id: string,
     authToken: string,
     options?: RequestOptions,
   ): Promise<SuccessResponse> {
     return this.#fetcher.fetchOk(
       {
         method: "DELETE",
         path: `node/policies/repos/${id}`,
         headers: { Authorization: `Bearer ${authToken}` },
         options,
       },
       successResponseSchema,
     );
   }
   public async getNode(options?: RequestOptions): Promise<Node> {
     return this.#fetcher.fetchOk(
       {

 import type { ZodSchema } from "zod";
 import type { Fetcher, RequestOptions } from "./fetcher.js";
 import type { Embed } from "./project/comment.js";
 import type { Commit, Commits } from "./project/commit.js";
 import type {
   Issue,
   IssueCreated,
   IssueUpdateAction,
 } from "./project/issue.js";
 import type {
   Patch,
   PatchCreate,
   PatchCreated,
   PatchUpdateAction,
 } from "./project/patch.js";
 import type { SuccessResponse } from "./shared.js";
 import type { Issue } from "./project/issue.js";
 import type { Patch } from "./project/patch.js";
 import {
   array,

   diffBlobSchema,
   diffSchema,
 } from "./project/commit.js";
 import {
   issueCreatedSchema,
   issueSchema,
   issuesSchema,
 } from "./project/issue.js";
 import {
   patchCreatedSchema,
   patchSchema,
   patchesSchema,
 } from "./project/patch.js";
 import { issueSchema, issuesSchema } from "./project/issue.js";
 import { patchSchema, patchesSchema } from "./project/patch.js";
 const projectSchema = object({
   id: string(),

 import type { Fetcher, RequestOptions } from "./fetcher.js";
 import type { SuccessResponse } from "./shared.js";
 import type { z } from "zod";
 import { number, object, string } from "zod";
 import { successResponseSchema } from "./shared.js";
 export const sessionPayloadSchema = object({
   sessionId: string(),
   signature: string(),
   publicKey: string(),
 });
 export type SessionPayload = z.infer<typeof sessionPayloadSchema>;
 const sessionSchema = object({
   sessionId: string(),
   status: string(),
   publicKey: string(),
   alias: string(),
   issuedAt: number(),
   expiresAt: number(),
 });
 export type Session = z.infer<typeof sessionSchema>;
 export class Client {
   #fetcher: Fetcher;
   public constructor(fetcher: Fetcher) {
     this.#fetcher = fetcher;
   }
   public async getById(id: string, options?: RequestOptions): Promise<Session> {
     return this.#fetcher.fetchOk(
       {
         method: "GET",
         path: `sessions/${id}`,
         options,
       },
       sessionSchema,
     );
   }
   public async create(options?: RequestOptions): Promise<Session> {
     return this.#fetcher.fetchOk(
       {
         method: "POST",
         path: "sessions",
         options,
       },
       sessionSchema,
     );
   }
   public async update(
     id: string,
     body: {
       sig: string;
       pk: string;
     },
     options?: RequestOptions,
   ): Promise<SuccessResponse> {
     return this.#fetcher.fetchOk(
       {
         method: "PUT",
         path: `sessions/${id}`,
         body,
         options,
       },
       successResponseSchema,
     );
   }
   public async delete(
     id: string,
     options?: RequestOptions,
   ): Promise<SuccessResponse> {
     return this.#fetcher.fetchOk(
       {
         method: "DELETE",
         path: `sessions/${id}`,
         headers: { Authorization: `Bearer ${id}` },
         options,
       },
       successResponseSchema,
     );
   }
 }

 import type { ZodSchema, z } from "zod";
 import type { z } from "zod";
 import { array, boolean, literal, number, object, string, union } from "zod";

   success: true;
 }
 export const successResponseSchema = object({
   success: literal(true),
 }) satisfies ZodSchema<SuccessResponse>;
 export const scopeSchema = union([literal("followed"), literal("all")]);
 export const seedingPolicySchema = union([