@digicap-web/sdk 0.1.0-dev.13

package/dist/index.js

@@ -0,0 +1,1500 @@
+// src/schema/article.ts
+import { z } from "zod";
+var ArticleIdSchema = z.uuid().transform((id) => id);
+var ArticleIdListSchema = z.array(ArticleIdSchema);
+var ArticleSchema = z.object({
+  id: ArticleIdSchema,
+  name: z.string().min(1).max(255),
+  body: z.string().min(0).max(4096),
+  published: z.boolean().default(false),
+  createdAt: z.union([
+    z.date(),
+    z.iso.datetime().transform((s) => new Date(s))
+  ]),
+  updatedAt: z.union([
+    z.date(),
+    z.iso.datetime().transform((s) => new Date(s))
+  ])
+}).strip();
+var CreateArticleSchema = ArticleSchema.pick({
+  name: true,
+  body: true,
+  published: true
+}).strip();
+var UpdateArticleSchema = CreateArticleSchema;
+var ArticleListSchema = z.array(ArticleSchema);
+
+// src/schema/area.ts
+import { z as z2 } from "zod";
+var AreaIdSchema = z2.uuid().transform((id) => id);
+var AreaIdListSchema = z2.array(AreaIdSchema);
+var AreaSchema = z2.object({
+  id: AreaIdSchema,
+  name: z2.string().min(1).max(255),
+  createdAt: z2.union([
+    z2.date(),
+    z2.iso.datetime().transform((s) => new Date(s))
+  ]),
+  updatedAt: z2.union([
+    z2.date(),
+    z2.iso.datetime().transform((s) => new Date(s))
+  ])
+}).strip();
+var CreateAreaSchema = AreaSchema.pick({
+  name: true
+}).strip();
+var UpdateAreaSchema = CreateAreaSchema;
+var AreaListSchema = z2.array(AreaSchema);
+
+// src/schema/spot.ts
+import { z as z3 } from "zod";
+var SpotIdSchema = z3.uuid().transform((id) => id);
+var SpotIdListSchema = z3.array(SpotIdSchema);
+var SpotSchema = z3.object({
+  id: SpotIdSchema,
+  name: z3.string().min(1).max(255),
+  createdAt: z3.union([
+    z3.date(),
+    z3.iso.datetime().transform((s) => new Date(s))
+  ]),
+  updatedAt: z3.union([
+    z3.date(),
+    z3.iso.datetime().transform((s) => new Date(s))
+  ]),
+  areaId: z3.lazy(() => AreaIdSchema),
+  articleId: z3.lazy(() => ArticleIdSchema.nullable())
+}).strip();
+var CreateSpotSchema = SpotSchema.pick({
+  name: true,
+  areaId: true
+}).strip();
+var UpdateSpotSchema = CreateSpotSchema;
+var SpotListSchema = z3.array(SpotSchema);
+
+// src/schema/tag.ts
+import { z as z4 } from "zod";
+var TagIdSchema = z4.uuid().transform((id) => id);
+var TagIdListSchema = z4.array(TagIdSchema);
+var TagSchema = z4.object({
+  id: TagIdSchema,
+  name: z4.string().min(1).max(255),
+  color: z4.string().min(1).max(255),
+  createdAt: z4.union([
+    z4.date(),
+    z4.iso.datetime().transform((s) => new Date(s))
+  ]),
+  updatedAt: z4.union([
+    z4.date(),
+    z4.iso.datetime().transform((s) => new Date(s))
+  ])
+}).strip();
+var CreateTagSchema = TagSchema.pick({
+  name: true,
+  color: true
+}).strip();
+var UpdateTagSchema = CreateTagSchema;
+var TagListSchema = z4.array(TagSchema);
+
+// src/schema/user.ts
+import { z as z5 } from "zod";
+var UserIdSchema = z5.uuid().transform((id) => id);
+var UserIdListSchema = z5.array(UserIdSchema);
+var UserSchema = z5.object({
+  id: UserIdSchema,
+  email: z5.email(),
+  createdAt: z5.union([
+    z5.date(),
+    z5.iso.datetime().transform((s) => new Date(s))
+  ]),
+  updatedAt: z5.union([
+    z5.date(),
+    z5.iso.datetime().transform((s) => new Date(s))
+  ])
+}).strip();
+var UserListSchema = z5.array(UserSchema);
+
+// src/schema/audio.ts
+import { z as z6 } from "zod";
+var AudioIdSchema = z6.uuid().transform((id) => id);
+var AudioIdListSchema = z6.array(AudioIdSchema);
+var AudioSchema = z6.object({
+  id: AudioIdSchema,
+  createdAt: z6.union([
+    z6.date(),
+    z6.iso.datetime().transform((s) => new Date(s))
+  ]),
+  updatedAt: z6.union([
+    z6.date(),
+    z6.iso.datetime().transform((s) => new Date(s))
+  ])
+}).strip();
+var AudioListSchema = z6.array(AudioSchema);
+
+// src/schema/picture.ts
+import { z as z7 } from "zod";
+var PictureIdSchema = z7.uuid().transform((id) => id);
+var PictureIdListSchema = z7.array(PictureIdSchema);
+var PictureSchema = z7.object({
+  id: PictureIdSchema,
+  createdAt: z7.union([
+    z7.date(),
+    z7.iso.datetime().transform((s) => new Date(s))
+  ]),
+  updatedAt: z7.union([
+    z7.date(),
+    z7.iso.datetime().transform((s) => new Date(s))
+  ])
+}).strip();
+var PictureListSchema = z7.array(PictureSchema);
+
+// src/schema/guide.ts
+import { z as z8 } from "zod";
+var GuideIdSchema = z8.uuid().transform((id) => id);
+var GuideIdListSchema = z8.array(GuideIdSchema);
+var GuideSchema = z8.object({
+  id: GuideIdSchema,
+  name: z8.string().min(1).max(255),
+  createdAt: z8.union([
+    z8.date(),
+    z8.iso.datetime().transform((s) => new Date(s))
+  ]),
+  updatedAt: z8.union([
+    z8.date(),
+    z8.iso.datetime().transform((s) => new Date(s))
+  ]),
+  pictureId: z8.lazy(() => PictureIdSchema).nullable()
+}).strip();
+var CreateGuideSchema = GuideSchema.pick({
+  name: true
+}).strip();
+var UpdateGuideSchema = CreateGuideSchema;
+var GuideListSchema = z8.array(GuideSchema);
+
+// src/schema/event.ts
+import { z as z9 } from "zod";
+var EventIdSchema = z9.uuid().transform((id) => id);
+var EventIdListSchema = z9.array(EventIdSchema);
+var EventSchema = z9.object({
+  id: EventIdSchema,
+  name: z9.string().min(1).max(255),
+  about: z9.string().min(0).max(1024),
+  createdAt: z9.union([
+    z9.date(),
+    z9.iso.datetime().transform((s) => new Date(s))
+  ]),
+  updatedAt: z9.union([
+    z9.date(),
+    z9.iso.datetime().transform((s) => new Date(s))
+  ]),
+  startTime: z9.iso.datetime().transform((s) => new Date(s)),
+  endTime: z9.iso.datetime().transform((s) => new Date(s)),
+  pictureId: z9.lazy(() => PictureIdSchema.nullable())
+}).strip();
+var CreateEventSchema = EventSchema.pick({
+  name: true,
+  about: true,
+  startTime: true,
+  endTime: true
+}).strip();
+var UpdateEventSchema = CreateEventSchema;
+var EventListSchema = z9.array(EventSchema);
+
+// src/schema/auth.ts
+import { z as z10 } from "zod";
+var CredentialsSchema = z10.object({
+  email: z10.email().transform((e) => e.toLowerCase()),
+  password: z10.string().min(8).max(32)
+}).strip();
+
+// src/schema/museum.ts
+import { z as z11 } from "zod";
+var MuseumIdSchema = z11.uuid().transform((id) => id);
+var MuseumIdListSchema = z11.array(MuseumIdSchema);
+var MuseumSchema = z11.object({
+  id: MuseumIdSchema,
+  name: z11.string().min(1).max(255),
+  createdAt: z11.union([
+    z11.date(),
+    z11.iso.datetime().transform((s) => new Date(s))
+  ]),
+  updatedAt: z11.union([
+    z11.date(),
+    z11.iso.datetime().transform((s) => new Date(s))
+  ]),
+  startTime: z11.iso.datetime().transform((s) => new Date(s)),
+  endTime: z11.iso.datetime().transform((s) => new Date(s))
+}).strip();
+var CreateMuseumSchema = MuseumSchema.pick({
+  name: true,
+  startTime: true,
+  endTime: true
+}).strip();
+var UpdateMuseumSchema = CreateMuseumSchema;
+var MuseumListSchema = z11.array(MuseumSchema);
+
+// src/repository/museum/article.ts
+var ArticleRepository = class {
+  baseURL;
+  constructor(baseURL, museumId) {
+    this.baseURL = `${baseURL}/museums/${museumId}/articles`;
+  }
+  async collect() {
+    const url = `${this.baseURL}`;
+    const response = await fetch(url, {
+      method: "GET",
+      credentials: "include"
+    });
+    if (!response.ok) {
+      throw new Error(response.statusText);
+    }
+    return ArticleListSchema.parse(await response.json());
+  }
+  async get(id) {
+    const url = `${this.baseURL}/${id}`;
+    const response = await fetch(url, {
+      method: "GET",
+      credentials: "include"
+    });
+    if (!response.ok) {
+      throw new Error(response.statusText);
+    }
+    return ArticleSchema.parse(await response.json());
+  }
+  async create(article) {
+    const url = `${this.baseURL}`;
+    const response = await fetch(url, {
+      method: "POST",
+      headers: { "Content-Type": "application/json" },
+      credentials: "include",
+      body: JSON.stringify(article)
+    });
+    if (!response.ok) {
+      throw new Error(response.statusText);
+    }
+    return ArticleSchema.parse(await response.json());
+  }
+  async update(id, article) {
+    const url = `${this.baseURL}/${id}`;
+    const response = await fetch(url, {
+      method: "PATCH",
+      headers: { "Content-Type": "application/json" },
+      credentials: "include",
+      body: JSON.stringify(article)
+    });
+    if (!response.ok) {
+      throw new Error(response.statusText);
+    }
+    return ArticleSchema.parse(await response.json());
+  }
+  async delete(id) {
+    const url = `${this.baseURL}/${id}`;
+    const response = await fetch(url, {
+      method: "DELETE",
+      headers: { "Content-Type": "application/json" },
+      credentials: "include",
+      body: JSON.stringify({})
+    });
+    if (!response.ok) {
+      throw new Error(response.statusText);
+    }
+  }
+  async setPublished(id, published) {
+    const url = `${this.baseURL}/${id}/published`;
+    const response = await fetch(url, {
+      method: "PATCH",
+      headers: { "Content-Type": "application/json" },
+      credentials: "include",
+      body: JSON.stringify({ published })
+    });
+    if (!response.ok) {
+      throw new Error(response.statusText);
+    }
+    return ArticleSchema.parse(await response.json());
+  }
+};
+
+// src/repository/museum/area.ts
+var AreaRepository = class {
+  baseURL;
+  constructor(baseURL, museumId) {
+    this.baseURL = `${baseURL}/museums/${museumId}/areas`;
+  }
+  async collect() {
+    const url = `${this.baseURL}`;
+    const response = await fetch(url, {
+      method: "GET",
+      credentials: "include"
+    });
+    if (!response.ok) {
+      throw new Error(response.statusText);
+    }
+    return AreaListSchema.parse(await response.json());
+  }
+  async get(id) {
+    const url = `${this.baseURL}/${id}`;
+    const response = await fetch(url, {
+      method: "GET",
+      headers: { "Content-Type": "application/json" },
+      credentials: "include"
+    });
+    if (!response.ok) {
+      throw new Error(response.statusText);
+    }
+    return AreaSchema.parse(await response.json());
+  }
+  async create(area) {
+    const url = `${this.baseURL}`;
+    const response = await fetch(url, {
+      method: "POST",
+      headers: { "Content-Type": "application/json" },
+      credentials: "include",
+      body: JSON.stringify(area)
+    });
+    if (!response.ok) {
+      throw new Error(response.statusText);
+    }
+    return AreaSchema.parse(await response.json());
+  }
+  async update(id, area) {
+    const url = `${this.baseURL}/${id}`;
+    const response = await fetch(url, {
+      method: "PATCH",
+      headers: { "Content-Type": "application/json" },
+      credentials: "include",
+      body: JSON.stringify(area)
+    });
+    if (!response.ok) {
+      throw new Error(response.statusText);
+    }
+    return AreaSchema.parse(await response.json());
+  }
+  async delete(id) {
+    const url = `${this.baseURL}/${id}`;
+    const response = await fetch(url, {
+      method: "DELETE",
+      headers: { "Content-Type": "application/json" },
+      credentials: "include",
+      body: JSON.stringify({})
+    });
+    if (!response.ok) {
+      throw new Error(response.statusText);
+    }
+  }
+};
+
+// src/repository/museum/spot.ts
+var SpotRepository = class {
+  baseURL;
+  constructor(baseURL, museumId) {
+    this.baseURL = `${baseURL}/museums/${museumId}/spots`;
+  }
+  async collect() {
+    const url = `${this.baseURL}`;
+    const response = await fetch(url, {
+      method: "GET",
+      credentials: "include"
+    });
+    if (!response.ok) {
+      throw new Error(response.statusText);
+    }
+    return SpotListSchema.parse(await response.json());
+  }
+  async get(id) {
+    const url = `${this.baseURL}/${id}`;
+    const response = await fetch(url, {
+      method: "GET",
+      credentials: "include"
+    });
+    if (!response.ok) {
+      throw new Error(response.statusText);
+    }
+    return SpotSchema.parse(await response.json());
+  }
+  async create(spot) {
+    const url = `${this.baseURL}`;
+    const response = await fetch(url, {
+      method: "POST",
+      headers: { "Content-Type": "application/json" },
+      credentials: "include",
+      body: JSON.stringify(spot)
+    });
+    if (!response.ok) {
+      throw new Error(response.statusText);
+    }
+    return SpotSchema.parse(await response.json());
+  }
+  async update(id, spot) {
+    const url = `${this.baseURL}/${id}`;
+    const response = await fetch(url, {
+      method: "PATCH",
+      headers: { "Content-Type": "application/json" },
+      credentials: "include",
+      body: JSON.stringify(spot)
+    });
+    if (!response.ok) {
+      throw new Error(response.statusText);
+    }
+    return SpotSchema.parse(await response.json());
+  }
+  async delete(id) {
+    const url = `${this.baseURL}/${id}`;
+    const response = await fetch(url, {
+      method: "DELETE",
+      headers: { "Content-Type": "application/json" },
+      credentials: "include",
+      body: JSON.stringify({})
+    });
+    if (!response.ok) {
+      throw new Error(response.statusText);
+    }
+  }
+};
+
+// src/repository/museum/tag.ts
+var TagRepository = class {
+  baseURL;
+  constructor(baseURL, museumId) {
+    this.baseURL = `${baseURL}/museums/${museumId}/tags`;
+  }
+  async collect() {
+    const url = `${this.baseURL}`;
+    const response = await fetch(url, {
+      method: "GET",
+      credentials: "include"
+    });
+    if (!response.ok) {
+      throw new Error(response.statusText);
+    }
+    return TagListSchema.parse(await response.json());
+  }
+  async get(id) {
+    const url = `${this.baseURL}/${id}`;
+    const response = await fetch(url, {
+      method: "GET",
+      credentials: "include"
+    });
+    if (!response.ok) {
+      throw new Error(response.statusText);
+    }
+    return TagSchema.parse(await response.json());
+  }
+  async create(tag) {
+    const url = `${this.baseURL}`;
+    const response = await fetch(url, {
+      method: "POST",
+      headers: { "Content-Type": "application/json" },
+      credentials: "include",
+      body: JSON.stringify(tag)
+    });
+    if (!response.ok) {
+      throw new Error(response.statusText);
+    }
+    return TagSchema.parse(await response.json());
+  }
+  async update(id, tag) {
+    const url = `${this.baseURL}/${id}`;
+    const response = await fetch(url, {
+      method: "PATCH",
+      headers: { "Content-Type": "application/json" },
+      credentials: "include",
+      body: JSON.stringify(tag)
+    });
+    if (!response.ok) {
+      throw new Error(response.statusText);
+    }
+    return TagSchema.parse(await response.json());
+  }
+  async delete(id) {
+    const url = `${this.baseURL}/${id}`;
+    const response = await fetch(url, {
+      method: "DELETE",
+      headers: { "Content-Type": "application/json" },
+      credentials: "include",
+      body: JSON.stringify({})
+    });
+    if (!response.ok) {
+      throw new Error(response.statusText);
+    }
+  }
+};
+
+// src/repository/museum/audio.ts
+var AudioRepository = class {
+  baseURL;
+  constructor(baseURL, museumId) {
+    this.baseURL = `${baseURL}/museums/${museumId}/audios`;
+  }
+  async collect() {
+    const url = `${this.baseURL}`;
+    const response = await fetch(url, {
+      method: "GET",
+      credentials: "include"
+    });
+    if (!response.ok) {
+      throw new Error(response.statusText);
+    }
+    return AudioListSchema.parse(await response.json());
+  }
+  async get(id) {
+    const url = `${this.baseURL}/${id}`;
+    const response = await fetch(url, {
+      method: "GET",
+      credentials: "include"
+    });
+    if (!response.ok) {
+      throw new Error(response.statusText);
+    }
+    return AudioSchema.parse(await response.json());
+  }
+  async create(file) {
+    const formData = new FormData();
+    formData.append("file", file);
+    const url = `${this.baseURL}`;
+    const response = await fetch(url, {
+      method: "POST",
+      credentials: "include",
+      body: formData
+    });
+    if (!response.ok) {
+      throw new Error(response.statusText);
+    }
+    return AudioSchema.parse(await response.json());
+  }
+  async delete(id) {
+    const url = `${this.baseURL}/${id}`;
+    const response = await fetch(url, {
+      method: "DELETE",
+      headers: { "Content-Type": "application/json" },
+      credentials: "include",
+      body: JSON.stringify({})
+    });
+    if (!response.ok) {
+      throw new Error(response.statusText);
+    }
+  }
+  embed(id) {
+    return `${this.baseURL}/${id}/embed`;
+  }
+};
+
+// src/repository/museum/picture.ts
+var PictureRepository = class {
+  baseURL;
+  constructor(baseURL, museumId) {
+    this.baseURL = `${baseURL}/museums/${museumId}/pictures`;
+  }
+  async collect() {
+    const url = `${this.baseURL}`;
+    const response = await fetch(url, {
+      method: "GET",
+      credentials: "include"
+    });
+    if (!response.ok) {
+      throw new Error(response.statusText);
+    }
+    return PictureListSchema.parse(await response.json());
+  }
+  async get(id) {
+    const url = `${this.baseURL}/${id}`;
+    const response = await fetch(url, {
+      method: "GET",
+      credentials: "include"
+    });
+    if (!response.ok) {
+      throw new Error(response.statusText);
+    }
+    return PictureSchema.parse(await response.json());
+  }
+  async create(file) {
+    const formData = new FormData();
+    formData.append("file", file);
+    const url = `${this.baseURL}`;
+    const response = await fetch(url, {
+      method: "POST",
+      credentials: "include",
+      body: formData
+    });
+    if (!response.ok) {
+      throw new Error(response.statusText);
+    }
+    return PictureSchema.parse(await response.json());
+  }
+  async delete(id) {
+    const url = `${this.baseURL}/${id}`;
+    const response = await fetch(url, {
+      method: "DELETE",
+      headers: { "Content-Type": "application/json" },
+      credentials: "include",
+      body: JSON.stringify({})
+    });
+    if (!response.ok) {
+      throw new Error(response.statusText);
+    }
+  }
+  embed(id) {
+    return `${this.baseURL}/${id}/embed`;
+  }
+};
+
+// src/repository/museum/guide.ts
+var GuideRepository = class {
+  baseURL;
+  constructor(baseURL, museumId) {
+    this.baseURL = `${baseURL}/museums/${museumId}/guides`;
+  }
+  async collect() {
+    const url = `${this.baseURL}`;
+    const response = await fetch(url, {
+      method: "GET",
+      credentials: "include"
+    });
+    if (!response.ok) {
+      throw new Error(response.statusText);
+    }
+    return GuideListSchema.parse(await response.json());
+  }
+  async get(id) {
+    const url = `${this.baseURL}/${id}`;
+    const response = await fetch(url, {
+      method: "GET",
+      credentials: "include"
+    });
+    if (!response.ok) {
+      throw new Error(response.statusText);
+    }
+    return GuideSchema.parse(await response.json());
+  }
+  async create(guide) {
+    const url = `${this.baseURL}`;
+    const response = await fetch(url, {
+      method: "POST",
+      headers: { "Content-Type": "application/json" },
+      credentials: "include",
+      body: JSON.stringify(guide)
+    });
+    if (!response.ok) {
+      throw new Error(response.statusText);
+    }
+    return GuideSchema.parse(await response.json());
+  }
+  async update(id, guide) {
+    const url = `${this.baseURL}/${id}`;
+    const response = await fetch(url, {
+      method: "PATCH",
+      headers: { "Content-Type": "application/json" },
+      credentials: "include",
+      body: JSON.stringify(guide)
+    });
+    if (!response.ok) {
+      throw new Error(response.statusText);
+    }
+    return GuideSchema.parse(await response.json());
+  }
+  async delete(id) {
+    const url = `${this.baseURL}/${id}`;
+    const response = await fetch(url, {
+      method: "DELETE",
+      headers: { "Content-Type": "application/json" },
+      credentials: "include",
+      body: JSON.stringify({})
+    });
+    if (!response.ok) {
+      throw new Error(response.statusText);
+    }
+  }
+};
+
+// src/repository/museum/event.ts
+var EventRepository = class {
+  baseURL;
+  constructor(baseURL, museumId) {
+    this.baseURL = `${baseURL}/museums/${museumId}/events`;
+  }
+  async collect() {
+    const url = `${this.baseURL}`;
+    const response = await fetch(url, {
+      method: "GET",
+      credentials: "include"
+    });
+    return EventListSchema.parse(await response.json());
+  }
+  async get(id) {
+    const url = `${this.baseURL}/${id}`;
+    const response = await fetch(url, {
+      method: "GET",
+      credentials: "include"
+    });
+    if (!response.ok) {
+      throw new Error(response.statusText);
+    }
+    return EventSchema.parse(await response.json());
+  }
+  async create(event) {
+    const url = `${this.baseURL}`;
+    const response = await fetch(url, {
+      method: "POST",
+      headers: { "Content-Type": "application/json" },
+      credentials: "include",
+      body: JSON.stringify(event)
+    });
+    if (!response.ok) {
+      throw new Error(response.statusText);
+    }
+    return EventSchema.parse(await response.json());
+  }
+  async update(id, event) {
+    const url = `${this.baseURL}/${id}`;
+    const response = await fetch(url, {
+      method: "PATCH",
+      headers: { "Content-Type": "application/json" },
+      credentials: "include",
+      body: JSON.stringify(event)
+    });
+    if (!response.ok) {
+      throw new Error(response.statusText);
+    }
+    return EventSchema.parse(await response.json());
+  }
+  async delete(id) {
+    const url = `${this.baseURL}/${id}`;
+    const response = await fetch(url, {
+      method: "DELETE",
+      headers: { "Content-Type": "application/json" },
+      credentials: "include",
+      body: JSON.stringify({})
+    });
+    if (!response.ok) {
+      throw new Error(response.statusText);
+    }
+  }
+};
+
+// src/repository/museum.ts
+import z12 from "zod";
+var RoleEnum = z12.enum(["admin", "owner", "staff", "guest"]);
+var MuseumRepository = class {
+  constructor(baseURL) {
+    this.baseURL = baseURL;
+    this.baseURL = `${baseURL}/museums`;
+  }
+  async collect() {
+    const url = `${this.baseURL}`;
+    const response = await fetch(url, {
+      method: "GET",
+      credentials: "include"
+    });
+    if (!response.ok) {
+      throw new Error(response.statusText);
+    }
+    return MuseumListSchema.parse(await response.json());
+  }
+  async get(id) {
+    const url = `${this.baseURL}/${id}`;
+    const response = await fetch(url, {
+      method: "GET",
+      credentials: "include"
+    });
+    if (!response.ok) {
+      throw new Error(response.statusText);
+    }
+    return MuseumSchema.parse(await response.json());
+  }
+  async create(museum) {
+    const url = `${this.baseURL}`;
+    const response = await fetch(url, {
+      method: "POST",
+      headers: { "Content-Type": "application/json" },
+      credentials: "include",
+      body: JSON.stringify(museum)
+    });
+    if (!response.ok) {
+      throw new Error(response.statusText);
+    }
+    return MuseumSchema.parse(await response.json());
+  }
+  async update(id, museum) {
+    const url = `${this.baseURL}/${id}`;
+    const response = await fetch(url, {
+      method: "PATCH",
+      headers: { "Content-Type": "application/json" },
+      credentials: "include",
+      body: JSON.stringify(museum)
+    });
+    if (!response.ok) {
+      throw new Error(response.statusText);
+    }
+    return MuseumSchema.parse(await response.json());
+  }
+  async delete(id) {
+    const url = `${this.baseURL}/${id}`;
+    const response = await fetch(url, {
+      method: "DELETE",
+      credentials: "include"
+    });
+    if (!response.ok) {
+      throw new Error(response.statusText);
+    }
+  }
+  async invite(museumId, email) {
+    const url = `${this.baseURL}/${museumId}/users`;
+    const response = await fetch(url, {
+      method: "POST",
+      headers: { "Content-Type": "application/json" },
+      credentials: "include",
+      body: JSON.stringify(email)
+    });
+    if (!response.ok) {
+      throw new Error(response.statusText);
+    }
+  }
+  async reject(museumId, userId) {
+    const url = `${this.baseURL}/${museumId}/users/${userId}`;
+    const response = await fetch(url, {
+      method: "DELETE",
+      credentials: "include"
+    });
+    if (!response.ok) {
+      throw new Error(response.statusText);
+    }
+  }
+  async everyone(museumId) {
+    const url = `${this.baseURL}/${museumId}/users`;
+    const response = await fetch(url, {
+      method: "GET",
+      credentials: "include"
+    });
+    if (!response.ok) {
+      throw new Error(response.statusText);
+    }
+    return UserListSchema.parse(await response.json());
+  }
+  async getThumbnail(museumId) {
+    const url = `${this.baseURL}/${museumId}/thumbnail-picture`;
+    const response = await fetch(url, {
+      method: "GET",
+      credentials: "include"
+    });
+    if (!response.ok) {
+      throw new Error(response.statusText);
+    }
+    return PictureSchema.parse(await response.json());
+  }
+  async setThumbnail(museumId, pictureId) {
+    const url = `${this.baseURL}/${museumId}/thumbnail-picture`;
+    const response = await fetch(url, {
+      method: "PUT",
+      headers: {
+        "Content-Type": "application/json"
+      },
+      credentials: "include",
+      body: JSON.stringify(pictureId)
+    });
+    if (!response.ok) {
+      throw new Error(response.statusText);
+    }
+  }
+  async deleteThumbnail(museumId) {
+    const url = `${this.baseURL}/${museumId}/thumbnail-picture`;
+    const response = await fetch(url, {
+      method: "DELETE",
+      headers: { "Content-Type": "application/json" },
+      credentials: "include",
+      body: JSON.stringify({})
+    });
+    if (!response.ok) {
+      throw new Error(response.statusText);
+    }
+  }
+  async getOwnerships(museumId) {
+    const url = `${this.baseURL}/${museumId}/users/ownership`;
+    const response = await fetch(url, {
+      method: "GET",
+      credentials: "include"
+    });
+    if (!response.ok) {
+      throw new Error(response.statusText);
+    }
+    return UserListSchema.parse(await response.json());
+  }
+  async grant(museumId, userId) {
+    const url = `${this.baseURL}/${museumId}/users/${userId}/ownership`;
+    const response = await fetch(url, {
+      method: "POST",
+      credentials: "include"
+    });
+    if (!response.ok) {
+      throw new Error(response.statusText);
+    }
+  }
+  async revoke(museumId, userId) {
+    const url = `${this.baseURL}/${museumId}/users/${userId}/ownership`;
+    const response = await fetch(url, {
+      method: "DELETE",
+      credentials: "include"
+    });
+    if (!response.ok) {
+      throw new Error(response.statusText);
+    }
+  }
+  async getRole(museumId, userId) {
+    const url = `${this.baseURL}/${museumId}/users/${userId}/role`;
+    const response = await fetch(url, {
+      method: "GET",
+      credentials: "include"
+    });
+    if (!response.ok) {
+      throw new Error(response.statusText);
+    }
+    return RoleEnum.parse(await response.json());
+  }
+};
+
+// src/repository/user.ts
+var UserRepository = class {
+  constructor(baseURL) {
+    this.baseURL = baseURL;
+  }
+  async get(userId) {
+    const url = `${this.baseURL}/users/${userId}`;
+    const response = await fetch(url, {
+      method: "GET",
+      headers: { "Content-Type": "application/json" },
+      credentials: "include"
+    });
+    if (!response.ok) {
+      throw new Error(response.statusText);
+    }
+    return UserSchema.parse(await response.json());
+  }
+  async getMe() {
+    const url = `${this.baseURL}/users/me`;
+    const response = await fetch(url, {
+      method: "GET",
+      headers: { "Content-Type": "application/json" },
+      credentials: "include"
+    });
+    if (!response.ok) {
+      throw new Error(response.statusText);
+    }
+    return UserSchema.parse(await response.json());
+  }
+  async getMuseums() {
+    const url = `${this.baseURL}/users/me/museums`;
+    const response = await fetch(url, {
+      method: "GET",
+      headers: { "Content-Type": "application/json" },
+      credentials: "include"
+    });
+    if (!response.ok) {
+      throw new Error(response.statusText);
+    }
+    return MuseumListSchema.parse(await response.json());
+  }
+  async delete(userId) {
+    const url = `${this.baseURL}/users/${userId}`;
+    const response = await fetch(url, {
+      method: "DELETE",
+      headers: { "Content-Type": "application/json" },
+      credentials: "include",
+      body: JSON.stringify({})
+    });
+    if (!response.ok) {
+      throw new Error(response.statusText);
+    }
+  }
+  //　isAdminの変更が必要なら変更
+  async getRole(userId) {
+    const url = `${this.baseURL}/users/${userId}/role`;
+    const response = await fetch(url, {
+      method: "GET",
+      headers: { "Content-Type": "application/json" },
+      credentials: "include"
+    });
+    if (!response.ok) {
+      throw new Error(response.statusText);
+    }
+    const data = await response.json();
+    return { isAdmin: data === "admin" };
+  }
+};
+
+// src/repository/auth.ts
+var AuthRepository = class {
+  constructor(baseURL) {
+    this.baseURL = baseURL;
+  }
+  async signup(creds) {
+    const url = `${this.baseURL}/auth/signup`;
+    const response = await fetch(url, {
+      method: "POST",
+      headers: { "Content-Type": "application/json" },
+      credentials: "include",
+      body: JSON.stringify(creds)
+    });
+    if (!response.ok) {
+      throw new Error(response.statusText);
+    }
+    return UserSchema.parse(await response.json());
+  }
+  async signin(creds) {
+    const url = `${this.baseURL}/auth/signin`;
+    const response = await fetch(url, {
+      method: "POST",
+      headers: { "Content-Type": "application/json" },
+      credentials: "include",
+      body: JSON.stringify(creds)
+    });
+    if (!response.ok) {
+      throw new Error(response.statusText);
+    }
+    return UserSchema.parse(await response.json());
+  }
+  async signout() {
+    const url = `${this.baseURL}/auth/signout`;
+    const response = await fetch(url, {
+      method: "POST",
+      credentials: "include"
+    });
+    if (!response.ok) {
+      throw new Error(response.statusText);
+    }
+  }
+  async refresh() {
+    const url = `${this.baseURL}/auth/refresh`;
+    const response = await fetch(url, {
+      method: "POST",
+      credentials: "include"
+    });
+    if (!response.ok) {
+      throw new Error(response.statusText);
+    }
+  }
+  async erasure() {
+    const url = `${this.baseURL}/auth/erasure`;
+    const response = await fetch(url, {
+      method: "POST",
+      credentials: "include"
+    });
+    if (!response.ok) {
+      throw new Error(response.statusText);
+    }
+  }
+};
+
+// src/repository/museum/article-audio.ts
+var ArticleAudioRepository = class {
+  baseURL;
+  constructor(baseURL, museumId, articleId) {
+    this.baseURL = `${baseURL}/museums/${museumId}/articles/${articleId}/audio`;
+  }
+  async get() {
+    const response = await fetch(this.baseURL, {
+      method: "GET",
+      credentials: "include"
+    });
+    if (response.status === 404) {
+      throw new Error("Audio_not_related");
+    }
+    if (!response.ok) {
+      throw new Error(response.statusText);
+    }
+    return AudioSchema.parse(await response.json());
+  }
+  async put(audioId) {
+    const response = await fetch(this.baseURL, {
+      method: "PUT",
+      headers: { "Content-Type": "application/json" },
+      credentials: "include",
+      body: JSON.stringify(audioId)
+    });
+    if (!response.ok) {
+      throw new Error(response.statusText);
+    }
+  }
+  async delete() {
+    const response = await fetch(this.baseURL, {
+      method: "DELETE",
+      headers: { "Content-Type": "application/json" },
+      credentials: "include",
+      body: JSON.stringify({})
+    });
+    if (!response.ok) {
+      throw new Error(response.statusText);
+    }
+  }
+};
+
+// src/repository/museum/article-spot.ts
+var ArticleSpotRepository = class {
+  baseURL;
+  constructor(baseURL, museumId, articleId) {
+    this.baseURL = `${baseURL}/museums/${museumId}/articles/${articleId}/spot`;
+  }
+  async get() {
+    const url = `${this.baseURL}`;
+    const response = await fetch(url, {
+      method: "GET",
+      credentials: "include"
+    });
+    if (response.status === 404) {
+      throw new Error("Spot_not_related");
+    }
+    if (!response.ok) {
+      throw new Error(response.statusText);
+    }
+    return SpotSchema.parse(await response.json());
+  }
+};
+
+// src/repository/museum/spot-article.ts
+var SpotArticleRepository = class {
+  baseURL;
+  constructor(baseURL, museumId, spotId) {
+    this.baseURL = `${baseURL}/museums/${museumId}/spots/${spotId}/article`;
+  }
+  async get() {
+    const response = await fetch(this.baseURL, {
+      method: "GET",
+      credentials: "include"
+    });
+    if (!response.ok) {
+      throw new Error(response.statusText);
+    }
+    return ArticleSchema.parse(await response.json());
+  }
+  async put(articleId) {
+    const response = await fetch(this.baseURL, {
+      method: "PUT",
+      headers: { "Content-Type": "application/json" },
+      credentials: "include",
+      body: JSON.stringify(articleId)
+    });
+    if (!response.ok) {
+      throw new Error(response.statusText);
+    }
+  }
+  async delete() {
+    const response = await fetch(this.baseURL, {
+      method: "DELETE",
+      headers: { "Content-Type": "application/json" },
+      credentials: "include",
+      body: JSON.stringify({})
+    });
+    if (!response.ok) {
+      throw new Error(response.statusText);
+    }
+  }
+};
+
+// src/repository/museum/area-spot.ts
+var AreaSpotRepository = class {
+  baseURL;
+  constructor(baseURL, museumId, areaId) {
+    this.baseURL = `${baseURL}/museums/${museumId}/areas/${areaId}/spots`;
+  }
+  async get() {
+    const url = `${this.baseURL}`;
+    const response = await fetch(url, {
+      method: "GET",
+      credentials: "include"
+    });
+    if (!response.ok) {
+      throw new Error(response.statusText);
+    }
+    return SpotListSchema.parse(await response.json());
+  }
+};
+
+// src/repository/museum/article-tag.ts
+var ArticleTagRepository = class {
+  baseURL;
+  constructor(baseURL, museumId, articleId) {
+    this.baseURL = `${baseURL}/museums/${museumId}/articles/${articleId}/tags`;
+  }
+  async get() {
+    const url = `${this.baseURL}`;
+    const response = await fetch(url, {
+      method: "GET",
+      credentials: "include"
+    });
+    if (!response.ok) {
+      throw new Error(response.statusText);
+    }
+    return TagListSchema.parse(await response.json());
+  }
+  async put(tagIds) {
+    const url = `${this.baseURL}`;
+    const response = await fetch(url, {
+      method: "PUT",
+      headers: { "Content-Type": "application/json" },
+      credentials: "include",
+      body: JSON.stringify(tagIds)
+    });
+    if (!response.ok) {
+      throw new Error(response.statusText);
+    }
+    return TagListSchema.parse(await response.json());
+  }
+};
+
+// src/repository/museum/article-picture.ts
+var ArticlePictureRepository = class {
+  baseURL;
+  constructor(baseURL, museumId, articleId) {
+    this.baseURL = `${baseURL}/museums/${museumId}/articles/${articleId}/pictures`;
+  }
+  async get() {
+    const url = `${this.baseURL}`;
+    const response = await fetch(url, {
+      method: "GET",
+      credentials: "include"
+    });
+    if (!response.ok) {
+      throw new Error(response.statusText);
+    }
+    return PictureListSchema.parse(await response.json());
+  }
+  async put(pictureIds) {
+    const url = `${this.baseURL}`;
+    const response = await fetch(url, {
+      method: "PUT",
+      headers: { "Content-Type": "application/json" },
+      credentials: "include",
+      body: JSON.stringify(pictureIds)
+    });
+    if (!response.ok) {
+      throw new Error(response.statusText);
+    }
+    return PictureListSchema.parse(await response.json());
+  }
+};
+
+// src/repository/museum/article-event.ts
+var ArticleEventRepository = class {
+  baseURL;
+  constructor(baseURL, museumId, articleId) {
+    this.baseURL = `${baseURL}/museums/${museumId}/articles/${articleId}/events`;
+  }
+  async get() {
+    const url = `${this.baseURL}`;
+    const response = await fetch(url, {
+      method: "GET",
+      credentials: "include"
+    });
+    if (!response.ok) {
+      throw new Error(response.statusText);
+    }
+    return EventListSchema.parse(await response.json());
+  }
+  async update(eventIds) {
+    const url = `${this.baseURL}`;
+    const response = await fetch(url, {
+      method: "PUT",
+      headers: { "Content-Type": "application/json" },
+      credentials: "include",
+      body: JSON.stringify(eventIds)
+    });
+    if (!response.ok) {
+      throw new Error(response.statusText);
+    }
+    return EventListSchema.parse(await response.json());
+  }
+};
+
+// src/repository/museum/event-article.ts
+var EventArticleRepository = class {
+  baseURL;
+  constructor(baseURL, museumId, eventId) {
+    this.baseURL = `${baseURL}/museums/${museumId}/events/${eventId}/articles`;
+  }
+  async get() {
+    const url = `${this.baseURL}`;
+    const response = await fetch(url, {
+      method: "GET",
+      headers: { "Content-Type": "application/json" },
+      credentials: "include"
+    });
+    if (!response.ok) {
+      throw new Error(response.statusText);
+    }
+    return ArticleListSchema.parse(await response.json());
+  }
+  async put(articleIds) {
+    const url = `${this.baseURL}`;
+    const response = await fetch(url, {
+      method: "PUT",
+      headers: { "Content-Type": "application/json" },
+      credentials: "include",
+      body: JSON.stringify(articleIds)
+    });
+    if (!response.ok) {
+      throw new Error(response.statusText);
+    }
+    return ArticleListSchema.parse(await response.json());
+  }
+};
+
+// src/repository/museum/event-picture.ts
+var EventPictureRepository = class {
+  baseURL;
+  constructor(baseURL, museumId, eventId) {
+    this.baseURL = `${baseURL}/museums/${museumId}/events/${eventId}/picture`;
+  }
+  async get() {
+    const url = `${this.baseURL}`;
+    const response = await fetch(url, {
+      method: "GET",
+      headers: { "Content-Type": "application/json" },
+      credentials: "include"
+    });
+    if (!response.ok) {
+      throw new Error(response.statusText);
+    }
+    return PictureSchema.parse(await response.json());
+  }
+  async put(pictureId) {
+    const url = `${this.baseURL}`;
+    const response = await fetch(url, {
+      method: "PUT",
+      headers: { "Content-Type": "application/json" },
+      credentials: "include",
+      body: JSON.stringify(pictureId)
+    });
+    if (!response.ok) {
+      throw new Error(response.statusText);
+    }
+    return PictureSchema.parse(await response.json());
+  }
+};
+
+// src/repository/museum/guide-picture.ts
+var GuidePictureRepository = class {
+  baseURL;
+  constructor(baseURL, museumId, guideId) {
+    this.baseURL = `${baseURL}/museums/${museumId}/guides/${guideId}/picture`;
+  }
+  async get() {
+    const url = `${this.baseURL}`;
+    const response = await fetch(url, {
+      method: "GET",
+      headers: { "Content-Type": "application/json" },
+      credentials: "include"
+    });
+    if (!response.ok) {
+      throw new Error(response.statusText);
+    }
+    return PictureSchema.parse(await response.json());
+  }
+  async put(pictureId) {
+    const url = `${this.baseURL}`;
+    const response = await fetch(url, {
+      method: "PUT",
+      headers: { "Content-Type": "application/json" },
+      credentials: "include",
+      body: JSON.stringify(pictureId)
+    });
+    if (!response.ok) {
+      throw new Error(response.statusText);
+    }
+    return PictureSchema.parse(await response.json());
+  }
+};
+
+// src/repository/museum/tag-article.ts
+var TagArticleRepository = class {
+  baseURL;
+  constructor(baseURL, museumId, tagId) {
+    this.baseURL = `${baseURL}/museums/${museumId}/tags/${tagId}/articles`;
+  }
+  async get() {
+    const url = `${this.baseURL}`;
+    const response = await fetch(url, {
+      method: "GET",
+      headers: { "Content-Type": "application/json" },
+      credentials: "include"
+    });
+    if (!response.ok) {
+      throw new Error(response.statusText);
+    }
+    return ArticleListSchema.parse(await response.json());
+  }
+};
+export {
+  AreaIdListSchema,
+  AreaIdSchema,
+  AreaListSchema,
+  AreaRepository,
+  AreaSchema,
+  AreaSpotRepository,
+  ArticleAudioRepository,
+  ArticleEventRepository,
+  ArticleIdListSchema,
+  ArticleIdSchema,
+  ArticleListSchema,
+  ArticlePictureRepository,
+  ArticleRepository,
+  ArticleSchema,
+  ArticleSpotRepository,
+  ArticleTagRepository,
+  AudioIdListSchema,
+  AudioIdSchema,
+  AudioListSchema,
+  AudioRepository,
+  AudioSchema,
+  AuthRepository,
+  CreateAreaSchema,
+  CreateArticleSchema,
+  CreateEventSchema,
+  CreateGuideSchema,
+  CreateMuseumSchema,
+  CreateSpotSchema,
+  CreateTagSchema,
+  CredentialsSchema,
+  EventArticleRepository,
+  EventIdListSchema,
+  EventIdSchema,
+  EventListSchema,
+  EventPictureRepository,
+  EventRepository,
+  EventSchema,
+  GuideIdListSchema,
+  GuideIdSchema,
+  GuideListSchema,
+  GuidePictureRepository,
+  GuideRepository,
+  GuideSchema,
+  MuseumIdListSchema,
+  MuseumIdSchema,
+  MuseumListSchema,
+  MuseumRepository,
+  MuseumSchema,
+  PictureIdListSchema,
+  PictureIdSchema,
+  PictureListSchema,
+  PictureRepository,
+  PictureSchema,
+  SpotArticleRepository,
+  SpotIdListSchema,
+  SpotIdSchema,
+  SpotListSchema,
+  SpotRepository,
+  SpotSchema,
+  TagArticleRepository,
+  TagIdListSchema,
+  TagIdSchema,
+  TagListSchema,
+  TagRepository,
+  TagSchema,
+  UpdateAreaSchema,
+  UpdateArticleSchema,
+  UpdateEventSchema,
+  UpdateGuideSchema,
+  UpdateMuseumSchema,
+  UpdateSpotSchema,
+  UpdateTagSchema,
+  UserIdListSchema,
+  UserIdSchema,
+  UserListSchema,
+  UserRepository,
+  UserSchema
+};