@digicap-web/sdk 0.1.0-dev.13

package/dist/index.cjs

@@ -0,0 +1,1613 @@
+"use strict";
+var __create = Object.create;
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __getProtoOf = Object.getPrototypeOf;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__getProtoOf(mod)) : {}, __copyProps(
+  // If the importer is in node compatibility mode or this is not an ESM
+  // file that has been converted to a CommonJS file using a Babel-
+  // compatible transform (i.e. "__esModule" has not been set), then set
+  // "default" to the CommonJS "module.exports" for node compatibility.
+  isNodeMode || !mod || !mod.__esModule ? __defProp(target, "default", { value: mod, enumerable: true }) : target,
+  mod
+));
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+
+// src/index.ts
+var index_exports = {};
+__export(index_exports, {
+  AreaIdListSchema: () => AreaIdListSchema,
+  AreaIdSchema: () => AreaIdSchema,
+  AreaListSchema: () => AreaListSchema,
+  AreaRepository: () => AreaRepository,
+  AreaSchema: () => AreaSchema,
+  AreaSpotRepository: () => AreaSpotRepository,
+  ArticleAudioRepository: () => ArticleAudioRepository,
+  ArticleEventRepository: () => ArticleEventRepository,
+  ArticleIdListSchema: () => ArticleIdListSchema,
+  ArticleIdSchema: () => ArticleIdSchema,
+  ArticleListSchema: () => ArticleListSchema,
+  ArticlePictureRepository: () => ArticlePictureRepository,
+  ArticleRepository: () => ArticleRepository,
+  ArticleSchema: () => ArticleSchema,
+  ArticleSpotRepository: () => ArticleSpotRepository,
+  ArticleTagRepository: () => ArticleTagRepository,
+  AudioIdListSchema: () => AudioIdListSchema,
+  AudioIdSchema: () => AudioIdSchema,
+  AudioListSchema: () => AudioListSchema,
+  AudioRepository: () => AudioRepository,
+  AudioSchema: () => AudioSchema,
+  AuthRepository: () => AuthRepository,
+  CreateAreaSchema: () => CreateAreaSchema,
+  CreateArticleSchema: () => CreateArticleSchema,
+  CreateEventSchema: () => CreateEventSchema,
+  CreateGuideSchema: () => CreateGuideSchema,
+  CreateMuseumSchema: () => CreateMuseumSchema,
+  CreateSpotSchema: () => CreateSpotSchema,
+  CreateTagSchema: () => CreateTagSchema,
+  CredentialsSchema: () => CredentialsSchema,
+  EventArticleRepository: () => EventArticleRepository,
+  EventIdListSchema: () => EventIdListSchema,
+  EventIdSchema: () => EventIdSchema,
+  EventListSchema: () => EventListSchema,
+  EventPictureRepository: () => EventPictureRepository,
+  EventRepository: () => EventRepository,
+  EventSchema: () => EventSchema,
+  GuideIdListSchema: () => GuideIdListSchema,
+  GuideIdSchema: () => GuideIdSchema,
+  GuideListSchema: () => GuideListSchema,
+  GuidePictureRepository: () => GuidePictureRepository,
+  GuideRepository: () => GuideRepository,
+  GuideSchema: () => GuideSchema,
+  MuseumIdListSchema: () => MuseumIdListSchema,
+  MuseumIdSchema: () => MuseumIdSchema,
+  MuseumListSchema: () => MuseumListSchema,
+  MuseumRepository: () => MuseumRepository,
+  MuseumSchema: () => MuseumSchema,
+  PictureIdListSchema: () => PictureIdListSchema,
+  PictureIdSchema: () => PictureIdSchema,
+  PictureListSchema: () => PictureListSchema,
+  PictureRepository: () => PictureRepository,
+  PictureSchema: () => PictureSchema,
+  SpotArticleRepository: () => SpotArticleRepository,
+  SpotIdListSchema: () => SpotIdListSchema,
+  SpotIdSchema: () => SpotIdSchema,
+  SpotListSchema: () => SpotListSchema,
+  SpotRepository: () => SpotRepository,
+  SpotSchema: () => SpotSchema,
+  TagArticleRepository: () => TagArticleRepository,
+  TagIdListSchema: () => TagIdListSchema,
+  TagIdSchema: () => TagIdSchema,
+  TagListSchema: () => TagListSchema,
+  TagRepository: () => TagRepository,
+  TagSchema: () => TagSchema,
+  UpdateAreaSchema: () => UpdateAreaSchema,
+  UpdateArticleSchema: () => UpdateArticleSchema,
+  UpdateEventSchema: () => UpdateEventSchema,
+  UpdateGuideSchema: () => UpdateGuideSchema,
+  UpdateMuseumSchema: () => UpdateMuseumSchema,
+  UpdateSpotSchema: () => UpdateSpotSchema,
+  UpdateTagSchema: () => UpdateTagSchema,
+  UserIdListSchema: () => UserIdListSchema,
+  UserIdSchema: () => UserIdSchema,
+  UserListSchema: () => UserListSchema,
+  UserRepository: () => UserRepository,
+  UserSchema: () => UserSchema
+});
+module.exports = __toCommonJS(index_exports);
+
+// src/schema/article.ts
+var import_zod = require("zod");
+var ArticleIdSchema = import_zod.z.uuid().transform((id) => id);
+var ArticleIdListSchema = import_zod.z.array(ArticleIdSchema);
+var ArticleSchema = import_zod.z.object({
+  id: ArticleIdSchema,
+  name: import_zod.z.string().min(1).max(255),
+  body: import_zod.z.string().min(0).max(4096),
+  published: import_zod.z.boolean().default(false),
+  createdAt: import_zod.z.union([
+    import_zod.z.date(),
+    import_zod.z.iso.datetime().transform((s) => new Date(s))
+  ]),
+  updatedAt: import_zod.z.union([
+    import_zod.z.date(),
+    import_zod.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 = import_zod.z.array(ArticleSchema);
+
+// src/schema/area.ts
+var import_zod2 = require("zod");
+var AreaIdSchema = import_zod2.z.uuid().transform((id) => id);
+var AreaIdListSchema = import_zod2.z.array(AreaIdSchema);
+var AreaSchema = import_zod2.z.object({
+  id: AreaIdSchema,
+  name: import_zod2.z.string().min(1).max(255),
+  createdAt: import_zod2.z.union([
+    import_zod2.z.date(),
+    import_zod2.z.iso.datetime().transform((s) => new Date(s))
+  ]),
+  updatedAt: import_zod2.z.union([
+    import_zod2.z.date(),
+    import_zod2.z.iso.datetime().transform((s) => new Date(s))
+  ])
+}).strip();
+var CreateAreaSchema = AreaSchema.pick({
+  name: true
+}).strip();
+var UpdateAreaSchema = CreateAreaSchema;
+var AreaListSchema = import_zod2.z.array(AreaSchema);
+
+// src/schema/spot.ts
+var import_zod3 = require("zod");
+var SpotIdSchema = import_zod3.z.uuid().transform((id) => id);
+var SpotIdListSchema = import_zod3.z.array(SpotIdSchema);
+var SpotSchema = import_zod3.z.object({
+  id: SpotIdSchema,
+  name: import_zod3.z.string().min(1).max(255),
+  createdAt: import_zod3.z.union([
+    import_zod3.z.date(),
+    import_zod3.z.iso.datetime().transform((s) => new Date(s))
+  ]),
+  updatedAt: import_zod3.z.union([
+    import_zod3.z.date(),
+    import_zod3.z.iso.datetime().transform((s) => new Date(s))
+  ]),
+  areaId: import_zod3.z.lazy(() => AreaIdSchema),
+  articleId: import_zod3.z.lazy(() => ArticleIdSchema.nullable())
+}).strip();
+var CreateSpotSchema = SpotSchema.pick({
+  name: true,
+  areaId: true
+}).strip();
+var UpdateSpotSchema = CreateSpotSchema;
+var SpotListSchema = import_zod3.z.array(SpotSchema);
+
+// src/schema/tag.ts
+var import_zod4 = require("zod");
+var TagIdSchema = import_zod4.z.uuid().transform((id) => id);
+var TagIdListSchema = import_zod4.z.array(TagIdSchema);
+var TagSchema = import_zod4.z.object({
+  id: TagIdSchema,
+  name: import_zod4.z.string().min(1).max(255),
+  color: import_zod4.z.string().min(1).max(255),
+  createdAt: import_zod4.z.union([
+    import_zod4.z.date(),
+    import_zod4.z.iso.datetime().transform((s) => new Date(s))
+  ]),
+  updatedAt: import_zod4.z.union([
+    import_zod4.z.date(),
+    import_zod4.z.iso.datetime().transform((s) => new Date(s))
+  ])
+}).strip();
+var CreateTagSchema = TagSchema.pick({
+  name: true,
+  color: true
+}).strip();
+var UpdateTagSchema = CreateTagSchema;
+var TagListSchema = import_zod4.z.array(TagSchema);
+
+// src/schema/user.ts
+var import_zod5 = require("zod");
+var UserIdSchema = import_zod5.z.uuid().transform((id) => id);
+var UserIdListSchema = import_zod5.z.array(UserIdSchema);
+var UserSchema = import_zod5.z.object({
+  id: UserIdSchema,
+  email: import_zod5.z.email(),
+  createdAt: import_zod5.z.union([
+    import_zod5.z.date(),
+    import_zod5.z.iso.datetime().transform((s) => new Date(s))
+  ]),
+  updatedAt: import_zod5.z.union([
+    import_zod5.z.date(),
+    import_zod5.z.iso.datetime().transform((s) => new Date(s))
+  ])
+}).strip();
+var UserListSchema = import_zod5.z.array(UserSchema);
+
+// src/schema/audio.ts
+var import_zod6 = require("zod");
+var AudioIdSchema = import_zod6.z.uuid().transform((id) => id);
+var AudioIdListSchema = import_zod6.z.array(AudioIdSchema);
+var AudioSchema = import_zod6.z.object({
+  id: AudioIdSchema,
+  createdAt: import_zod6.z.union([
+    import_zod6.z.date(),
+    import_zod6.z.iso.datetime().transform((s) => new Date(s))
+  ]),
+  updatedAt: import_zod6.z.union([
+    import_zod6.z.date(),
+    import_zod6.z.iso.datetime().transform((s) => new Date(s))
+  ])
+}).strip();
+var AudioListSchema = import_zod6.z.array(AudioSchema);
+
+// src/schema/picture.ts
+var import_zod7 = require("zod");
+var PictureIdSchema = import_zod7.z.uuid().transform((id) => id);
+var PictureIdListSchema = import_zod7.z.array(PictureIdSchema);
+var PictureSchema = import_zod7.z.object({
+  id: PictureIdSchema,
+  createdAt: import_zod7.z.union([
+    import_zod7.z.date(),
+    import_zod7.z.iso.datetime().transform((s) => new Date(s))
+  ]),
+  updatedAt: import_zod7.z.union([
+    import_zod7.z.date(),
+    import_zod7.z.iso.datetime().transform((s) => new Date(s))
+  ])
+}).strip();
+var PictureListSchema = import_zod7.z.array(PictureSchema);
+
+// src/schema/guide.ts
+var import_zod8 = require("zod");
+var GuideIdSchema = import_zod8.z.uuid().transform((id) => id);
+var GuideIdListSchema = import_zod8.z.array(GuideIdSchema);
+var GuideSchema = import_zod8.z.object({
+  id: GuideIdSchema,
+  name: import_zod8.z.string().min(1).max(255),
+  createdAt: import_zod8.z.union([
+    import_zod8.z.date(),
+    import_zod8.z.iso.datetime().transform((s) => new Date(s))
+  ]),
+  updatedAt: import_zod8.z.union([
+    import_zod8.z.date(),
+    import_zod8.z.iso.datetime().transform((s) => new Date(s))
+  ]),
+  pictureId: import_zod8.z.lazy(() => PictureIdSchema).nullable()
+}).strip();
+var CreateGuideSchema = GuideSchema.pick({
+  name: true
+}).strip();
+var UpdateGuideSchema = CreateGuideSchema;
+var GuideListSchema = import_zod8.z.array(GuideSchema);
+
+// src/schema/event.ts
+var import_zod9 = require("zod");
+var EventIdSchema = import_zod9.z.uuid().transform((id) => id);
+var EventIdListSchema = import_zod9.z.array(EventIdSchema);
+var EventSchema = import_zod9.z.object({
+  id: EventIdSchema,
+  name: import_zod9.z.string().min(1).max(255),
+  about: import_zod9.z.string().min(0).max(1024),
+  createdAt: import_zod9.z.union([
+    import_zod9.z.date(),
+    import_zod9.z.iso.datetime().transform((s) => new Date(s))
+  ]),
+  updatedAt: import_zod9.z.union([
+    import_zod9.z.date(),
+    import_zod9.z.iso.datetime().transform((s) => new Date(s))
+  ]),
+  startTime: import_zod9.z.iso.datetime().transform((s) => new Date(s)),
+  endTime: import_zod9.z.iso.datetime().transform((s) => new Date(s)),
+  pictureId: import_zod9.z.lazy(() => PictureIdSchema.nullable())
+}).strip();
+var CreateEventSchema = EventSchema.pick({
+  name: true,
+  about: true,
+  startTime: true,
+  endTime: true
+}).strip();
+var UpdateEventSchema = CreateEventSchema;
+var EventListSchema = import_zod9.z.array(EventSchema);
+
+// src/schema/auth.ts
+var import_zod10 = require("zod");
+var CredentialsSchema = import_zod10.z.object({
+  email: import_zod10.z.email().transform((e) => e.toLowerCase()),
+  password: import_zod10.z.string().min(8).max(32)
+}).strip();
+
+// src/schema/museum.ts
+var import_zod11 = require("zod");
+var MuseumIdSchema = import_zod11.z.uuid().transform((id) => id);
+var MuseumIdListSchema = import_zod11.z.array(MuseumIdSchema);
+var MuseumSchema = import_zod11.z.object({
+  id: MuseumIdSchema,
+  name: import_zod11.z.string().min(1).max(255),
+  createdAt: import_zod11.z.union([
+    import_zod11.z.date(),
+    import_zod11.z.iso.datetime().transform((s) => new Date(s))
+  ]),
+  updatedAt: import_zod11.z.union([
+    import_zod11.z.date(),
+    import_zod11.z.iso.datetime().transform((s) => new Date(s))
+  ]),
+  startTime: import_zod11.z.iso.datetime().transform((s) => new Date(s)),
+  endTime: import_zod11.z.iso.datetime().transform((s) => new Date(s))
+}).strip();
+var CreateMuseumSchema = MuseumSchema.pick({
+  name: true,
+  startTime: true,
+  endTime: true
+}).strip();
+var UpdateMuseumSchema = CreateMuseumSchema;
+var MuseumListSchema = import_zod11.z.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
+var import_zod12 = __toESM(require("zod"), 1);
+var RoleEnum = import_zod12.default.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());
+  }
+};
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  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
+});