@izak0s/spacebring-api 0.1.0

package/dist/index.cjs

@@ -0,0 +1,2098 @@
+"use strict";
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+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 __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+
+// src/index.ts
+var index_exports = {};
+__export(index_exports, {
+  Spacebring: () => Spacebring,
+  SpacebringError: () => SpacebringError
+});
+module.exports = __toCommonJS(index_exports);
+
+// node_modules/openapi-fetch/dist/index.mjs
+var PATH_PARAM_RE = /\{[^{}]+\}/g;
+var supportsRequestInitExt = () => {
+  return typeof process === "object" && Number.parseInt(process?.versions?.node?.substring(0, 2)) >= 18 && process.versions.undici;
+};
+function randomID() {
+  return Math.random().toString(36).slice(2, 11);
+}
+function createClient(clientOptions) {
+  let {
+    baseUrl = "",
+    Request: CustomRequest = globalThis.Request,
+    fetch: baseFetch = globalThis.fetch,
+    querySerializer: globalQuerySerializer,
+    bodySerializer: globalBodySerializer,
+    headers: baseHeaders,
+    requestInitExt = void 0,
+    ...baseOptions
+  } = { ...clientOptions };
+  requestInitExt = supportsRequestInitExt() ? requestInitExt : void 0;
+  baseUrl = removeTrailingSlash(baseUrl);
+  const middlewares = [];
+  async function coreFetch(schemaPath, fetchOptions) {
+    const {
+      baseUrl: localBaseUrl,
+      fetch = baseFetch,
+      Request = CustomRequest,
+      headers,
+      params = {},
+      parseAs = "json",
+      querySerializer: requestQuerySerializer,
+      bodySerializer = globalBodySerializer ?? defaultBodySerializer,
+      body,
+      ...init
+    } = fetchOptions || {};
+    let finalBaseUrl = baseUrl;
+    if (localBaseUrl) {
+      finalBaseUrl = removeTrailingSlash(localBaseUrl) ?? baseUrl;
+    }
+    let querySerializer = typeof globalQuerySerializer === "function" ? globalQuerySerializer : createQuerySerializer(globalQuerySerializer);
+    if (requestQuerySerializer) {
+      querySerializer = typeof requestQuerySerializer === "function" ? requestQuerySerializer : createQuerySerializer({
+        ...typeof globalQuerySerializer === "object" ? globalQuerySerializer : {},
+        ...requestQuerySerializer
+      });
+    }
+    const serializedBody = body === void 0 ? void 0 : bodySerializer(
+      body,
+      // Note: we declare mergeHeaders() both here and below because it’s a bit of a chicken-or-egg situation:
+      // bodySerializer() needs all headers so we aren’t dropping ones set by the user, however,
+      // the result of this ALSO sets the lowest-priority content-type header. So we re-merge below,
+      // setting the content-type at the very beginning to be overwritten.
+      // Lastly, based on the way headers work, it’s not a simple “present-or-not” check becauase null intentionally un-sets headers.
+      mergeHeaders(baseHeaders, headers, params.header)
+    );
+    const finalHeaders = mergeHeaders(
+      // with no body, we should not to set Content-Type
+      serializedBody === void 0 || // if serialized body is FormData; browser will correctly set Content-Type & boundary expression
+      serializedBody instanceof FormData ? {} : {
+        "Content-Type": "application/json"
+      },
+      baseHeaders,
+      headers,
+      params.header
+    );
+    const requestInit = {
+      redirect: "follow",
+      ...baseOptions,
+      ...init,
+      body: serializedBody,
+      headers: finalHeaders
+    };
+    let id;
+    let options;
+    let request = new Request(
+      createFinalURL(schemaPath, { baseUrl: finalBaseUrl, params, querySerializer }),
+      requestInit
+    );
+    let response;
+    for (const key in init) {
+      if (!(key in request)) {
+        request[key] = init[key];
+      }
+    }
+    if (middlewares.length) {
+      id = randomID();
+      options = Object.freeze({
+        baseUrl: finalBaseUrl,
+        fetch,
+        parseAs,
+        querySerializer,
+        bodySerializer
+      });
+      for (const m of middlewares) {
+        if (m && typeof m === "object" && typeof m.onRequest === "function") {
+          const result = await m.onRequest({
+            request,
+            schemaPath,
+            params,
+            options,
+            id
+          });
+          if (result) {
+            if (result instanceof Request) {
+              request = result;
+            } else if (result instanceof Response) {
+              response = result;
+              break;
+            } else {
+              throw new Error("onRequest: must return new Request() or Response() when modifying the request");
+            }
+          }
+        }
+      }
+    }
+    if (!response) {
+      try {
+        response = await fetch(request, requestInitExt);
+      } catch (error2) {
+        let errorAfterMiddleware = error2;
+        if (middlewares.length) {
+          for (let i = middlewares.length - 1; i >= 0; i--) {
+            const m = middlewares[i];
+            if (m && typeof m === "object" && typeof m.onError === "function") {
+              const result = await m.onError({
+                request,
+                error: errorAfterMiddleware,
+                schemaPath,
+                params,
+                options,
+                id
+              });
+              if (result) {
+                if (result instanceof Response) {
+                  errorAfterMiddleware = void 0;
+                  response = result;
+                  break;
+                }
+                if (result instanceof Error) {
+                  errorAfterMiddleware = result;
+                  continue;
+                }
+                throw new Error("onError: must return new Response() or instance of Error");
+              }
+            }
+          }
+        }
+        if (errorAfterMiddleware) {
+          throw errorAfterMiddleware;
+        }
+      }
+      if (middlewares.length) {
+        for (let i = middlewares.length - 1; i >= 0; i--) {
+          const m = middlewares[i];
+          if (m && typeof m === "object" && typeof m.onResponse === "function") {
+            const result = await m.onResponse({
+              request,
+              response,
+              schemaPath,
+              params,
+              options,
+              id
+            });
+            if (result) {
+              if (!(result instanceof Response)) {
+                throw new Error("onResponse: must return new Response() when modifying the response");
+              }
+              response = result;
+            }
+          }
+        }
+      }
+    }
+    if (response.status === 204 || request.method === "HEAD" || response.headers.get("Content-Length") === "0") {
+      return response.ok ? { data: void 0, response } : { error: void 0, response };
+    }
+    if (response.ok) {
+      if (parseAs === "stream") {
+        return { data: response.body, response };
+      }
+      return { data: await response[parseAs](), response };
+    }
+    let error = await response.text();
+    try {
+      error = JSON.parse(error);
+    } catch {
+    }
+    return { error, response };
+  }
+  return {
+    request(method, url, init) {
+      return coreFetch(url, { ...init, method: method.toUpperCase() });
+    },
+    /** Call a GET endpoint */
+    GET(url, init) {
+      return coreFetch(url, { ...init, method: "GET" });
+    },
+    /** Call a PUT endpoint */
+    PUT(url, init) {
+      return coreFetch(url, { ...init, method: "PUT" });
+    },
+    /** Call a POST endpoint */
+    POST(url, init) {
+      return coreFetch(url, { ...init, method: "POST" });
+    },
+    /** Call a DELETE endpoint */
+    DELETE(url, init) {
+      return coreFetch(url, { ...init, method: "DELETE" });
+    },
+    /** Call a OPTIONS endpoint */
+    OPTIONS(url, init) {
+      return coreFetch(url, { ...init, method: "OPTIONS" });
+    },
+    /** Call a HEAD endpoint */
+    HEAD(url, init) {
+      return coreFetch(url, { ...init, method: "HEAD" });
+    },
+    /** Call a PATCH endpoint */
+    PATCH(url, init) {
+      return coreFetch(url, { ...init, method: "PATCH" });
+    },
+    /** Call a TRACE endpoint */
+    TRACE(url, init) {
+      return coreFetch(url, { ...init, method: "TRACE" });
+    },
+    /** Register middleware */
+    use(...middleware) {
+      for (const m of middleware) {
+        if (!m) {
+          continue;
+        }
+        if (typeof m !== "object" || !("onRequest" in m || "onResponse" in m || "onError" in m)) {
+          throw new Error("Middleware must be an object with one of `onRequest()`, `onResponse() or `onError()`");
+        }
+        middlewares.push(m);
+      }
+    },
+    /** Unregister middleware */
+    eject(...middleware) {
+      for (const m of middleware) {
+        const i = middlewares.indexOf(m);
+        if (i !== -1) {
+          middlewares.splice(i, 1);
+        }
+      }
+    }
+  };
+}
+function serializePrimitiveParam(name, value, options) {
+  if (value === void 0 || value === null) {
+    return "";
+  }
+  if (typeof value === "object") {
+    throw new Error(
+      "Deeply-nested arrays/objects aren\u2019t supported. Provide your own `querySerializer()` to handle these."
+    );
+  }
+  return `${name}=${options?.allowReserved === true ? value : encodeURIComponent(value)}`;
+}
+function serializeObjectParam(name, value, options) {
+  if (!value || typeof value !== "object") {
+    return "";
+  }
+  const values = [];
+  const joiner = {
+    simple: ",",
+    label: ".",
+    matrix: ";"
+  }[options.style] || "&";
+  if (options.style !== "deepObject" && options.explode === false) {
+    for (const k in value) {
+      values.push(k, options.allowReserved === true ? value[k] : encodeURIComponent(value[k]));
+    }
+    const final2 = values.join(",");
+    switch (options.style) {
+      case "form": {
+        return `${name}=${final2}`;
+      }
+      case "label": {
+        return `.${final2}`;
+      }
+      case "matrix": {
+        return `;${name}=${final2}`;
+      }
+      default: {
+        return final2;
+      }
+    }
+  }
+  for (const k in value) {
+    const finalName = options.style === "deepObject" ? `${name}[${k}]` : k;
+    values.push(serializePrimitiveParam(finalName, value[k], options));
+  }
+  const final = values.join(joiner);
+  return options.style === "label" || options.style === "matrix" ? `${joiner}${final}` : final;
+}
+function serializeArrayParam(name, value, options) {
+  if (!Array.isArray(value)) {
+    return "";
+  }
+  if (options.explode === false) {
+    const joiner2 = { form: ",", spaceDelimited: "%20", pipeDelimited: "|" }[options.style] || ",";
+    const final = (options.allowReserved === true ? value : value.map((v) => encodeURIComponent(v))).join(joiner2);
+    switch (options.style) {
+      case "simple": {
+        return final;
+      }
+      case "label": {
+        return `.${final}`;
+      }
+      case "matrix": {
+        return `;${name}=${final}`;
+      }
+      // case "spaceDelimited":
+      // case "pipeDelimited":
+      default: {
+        return `${name}=${final}`;
+      }
+    }
+  }
+  const joiner = { simple: ",", label: ".", matrix: ";" }[options.style] || "&";
+  const values = [];
+  for (const v of value) {
+    if (options.style === "simple" || options.style === "label") {
+      values.push(options.allowReserved === true ? v : encodeURIComponent(v));
+    } else {
+      values.push(serializePrimitiveParam(name, v, options));
+    }
+  }
+  return options.style === "label" || options.style === "matrix" ? `${joiner}${values.join(joiner)}` : values.join(joiner);
+}
+function createQuerySerializer(options) {
+  return function querySerializer(queryParams) {
+    const search = [];
+    if (queryParams && typeof queryParams === "object") {
+      for (const name in queryParams) {
+        const value = queryParams[name];
+        if (value === void 0 || value === null) {
+          continue;
+        }
+        if (Array.isArray(value)) {
+          if (value.length === 0) {
+            continue;
+          }
+          search.push(
+            serializeArrayParam(name, value, {
+              style: "form",
+              explode: true,
+              ...options?.array,
+              allowReserved: options?.allowReserved || false
+            })
+          );
+          continue;
+        }
+        if (typeof value === "object") {
+          search.push(
+            serializeObjectParam(name, value, {
+              style: "deepObject",
+              explode: true,
+              ...options?.object,
+              allowReserved: options?.allowReserved || false
+            })
+          );
+          continue;
+        }
+        search.push(serializePrimitiveParam(name, value, options));
+      }
+    }
+    return search.join("&");
+  };
+}
+function defaultPathSerializer(pathname, pathParams) {
+  let nextURL = pathname;
+  for (const match of pathname.match(PATH_PARAM_RE) ?? []) {
+    let name = match.substring(1, match.length - 1);
+    let explode = false;
+    let style = "simple";
+    if (name.endsWith("*")) {
+      explode = true;
+      name = name.substring(0, name.length - 1);
+    }
+    if (name.startsWith(".")) {
+      style = "label";
+      name = name.substring(1);
+    } else if (name.startsWith(";")) {
+      style = "matrix";
+      name = name.substring(1);
+    }
+    if (!pathParams || pathParams[name] === void 0 || pathParams[name] === null) {
+      continue;
+    }
+    const value = pathParams[name];
+    if (Array.isArray(value)) {
+      nextURL = nextURL.replace(match, serializeArrayParam(name, value, { style, explode }));
+      continue;
+    }
+    if (typeof value === "object") {
+      nextURL = nextURL.replace(match, serializeObjectParam(name, value, { style, explode }));
+      continue;
+    }
+    if (style === "matrix") {
+      nextURL = nextURL.replace(match, `;${serializePrimitiveParam(name, value)}`);
+      continue;
+    }
+    nextURL = nextURL.replace(match, style === "label" ? `.${encodeURIComponent(value)}` : encodeURIComponent(value));
+  }
+  return nextURL;
+}
+function defaultBodySerializer(body, headers) {
+  if (body instanceof FormData) {
+    return body;
+  }
+  if (headers) {
+    const contentType = headers.get instanceof Function ? headers.get("Content-Type") ?? headers.get("content-type") : headers["Content-Type"] ?? headers["content-type"];
+    if (contentType === "application/x-www-form-urlencoded") {
+      return new URLSearchParams(body).toString();
+    }
+  }
+  return JSON.stringify(body);
+}
+function createFinalURL(pathname, options) {
+  let finalURL = `${options.baseUrl}${pathname}`;
+  if (options.params?.path) {
+    finalURL = defaultPathSerializer(finalURL, options.params.path);
+  }
+  let search = options.querySerializer(options.params.query ?? {});
+  if (search.startsWith("?")) {
+    search = search.substring(1);
+  }
+  if (search) {
+    finalURL += `?${search}`;
+  }
+  return finalURL;
+}
+function mergeHeaders(...allHeaders) {
+  const finalHeaders = new Headers();
+  for (const h of allHeaders) {
+    if (!h || typeof h !== "object") {
+      continue;
+    }
+    const iterator = h instanceof Headers ? h.entries() : Object.entries(h);
+    for (const [k, v] of iterator) {
+      if (v === null) {
+        finalHeaders.delete(k);
+      } else if (Array.isArray(v)) {
+        for (const v2 of v) {
+          finalHeaders.append(k, v2);
+        }
+      } else if (v !== void 0) {
+        finalHeaders.set(k, v);
+      }
+    }
+  }
+  return finalHeaders;
+}
+function removeTrailingSlash(url) {
+  if (url.endsWith("/")) {
+    return url.substring(0, url.length - 1);
+  }
+  return url;
+}
+
+// src/error.ts
+var SpacebringError = class extends Error {
+  /** HTTP status code of the failed response. */
+  status;
+  /** Parsed error body returned by the API, if any. */
+  body;
+  constructor(status, body) {
+    const parsed = isErrorBody(body) ? body : void 0;
+    super(parsed?.message ?? `Spacebring API request failed with status ${status}`);
+    this.name = "SpacebringError";
+    this.status = status;
+    this.body = parsed;
+  }
+};
+function isErrorBody(body) {
+  return typeof body === "object" && body !== null;
+}
+
+// src/core.ts
+function unwrap(result) {
+  if (result.error !== void 0 || !result.response.ok) {
+    throw new SpacebringError(result.response.status, result.error);
+  }
+  return result.data;
+}
+function unwrapProp(result, key) {
+  const value = unwrap(result)?.[key];
+  if (value === void 0 || value === null) {
+    throw new SpacebringError(result.response.status, {
+      message: `Response is missing the "${String(key)}" property`
+    });
+  }
+  return value;
+}
+async function* paginate(fetchPage, itemsKey) {
+  let token;
+  do {
+    const page = await fetchPage(token);
+    const items = page[itemsKey] ?? [];
+    yield* items;
+    const next = page.nextPageToken;
+    if (next !== void 0 && next === token) {
+      throw new Error("Pagination did not advance: the API returned the same nextPageToken twice");
+    }
+    token = next;
+  } while (token);
+}
+
+// src/generated/resources/altCurrencies.ts
+function createAltcurrencies(client, defaults) {
+  return {
+    /**
+     * Retrieve alt currencies
+     *
+     * Retrieve all alt currencies in the location.
+     */
+    async list(query) {
+      return unwrap(await client.GET("/alt_currencies/v1", { params: { query } }));
+    },
+    /**
+     * Retrieve alt currencies — iterates every item across all pages.
+     *
+     * Retrieve all alt currencies in the location.
+     */
+    iterate(query) {
+      return paginate(
+        async (nextPageToken) => unwrap(await client.GET("/alt_currencies/v1", { params: { query: { ...query, nextPageToken } } })),
+        "altCurrencies"
+      );
+    },
+    /** Create an alt currency */
+    async create(body) {
+      return unwrapProp(await client.POST("/alt_currencies/v1", { body }), "altCurrency");
+    },
+    /** Update an alt currency */
+    async update(id, body) {
+      return unwrap(await client.PATCH("/alt_currencies/v1/{id}", { params: { path: { id } }, body }));
+    },
+    /** Delete an alt currency */
+    async delete(id) {
+      return unwrap(await client.DELETE("/alt_currencies/v1/{id}", { params: { path: { id } } }));
+    }
+  };
+}
+
+// src/generated/resources/benefits.ts
+function createBenefits(client, defaults) {
+  return {
+    /**
+     * Retrieve benefits
+     *
+     * Retrieve all benefits in the location.
+     */
+    async list(query) {
+      return unwrap(await client.GET("/benefits/v1", { params: { query } }));
+    },
+    /**
+     * Retrieve benefits — iterates every item across all pages.
+     *
+     * Retrieve all benefits in the location.
+     */
+    iterate(query) {
+      return paginate(
+        async (nextPageToken) => unwrap(await client.GET("/benefits/v1", { params: { query: { ...query, nextPageToken } } })),
+        "benefits"
+      );
+    },
+    /** Retrieve a benefit */
+    async get(benefitId) {
+      return unwrapProp(await client.GET("/benefits/v1/{benefitId}", { params: { path: { benefitId } } }), "benefit");
+    },
+    /** Create a benefit */
+    async create(body) {
+      return unwrap(await client.POST("/benefits/v1", { body }));
+    },
+    /** Update a benefit */
+    async update(benefitId, body) {
+      return unwrapProp(await client.PUT("/benefits/v1/{benefitId}", { params: { path: { benefitId } }, body }), "benefit");
+    },
+    /** Delete a benefit */
+    async delete(benefitId) {
+      return unwrap(await client.DELETE("/benefits/v1/{benefitId}", { params: { path: { benefitId } } }));
+    },
+    applications: {
+      /**
+       * Retrieve applications
+       *
+       * Retrieve all benefit applications in the location or for certain benefit.
+       */
+      async list(query) {
+        return unwrap(await client.GET("/benefits/applications/v1", { params: { query } }));
+      },
+      /**
+       * Retrieve applications — iterates every item across all pages.
+       *
+       * Retrieve all benefit applications in the location or for certain benefit.
+       */
+      iterate(query) {
+        return paginate(
+          async (nextPageToken) => unwrap(await client.GET("/benefits/applications/v1", { params: { query: { ...query, nextPageToken } } })),
+          "applications"
+        );
+      },
+      /**
+       * Retrieve an application
+       *
+       * Retrieve a benefit application by id.
+       */
+      async get(benefitApplicationId) {
+        return unwrapProp(await client.GET("/benefits/applications/v1/{benefitApplicationId}", { params: { path: { benefitApplicationId } } }), "application");
+      },
+      /** Apply for a benefit */
+      async create(body) {
+        return unwrapProp(await client.POST("/benefits/applications/v1", { body }), "application");
+      }
+    },
+    categories: {
+      /**
+       * Retrieve categories
+       *
+       * Retrieve all benefit categories in the location.
+       */
+      async list(query) {
+        return unwrapProp(await client.GET("/benefits/categories/v1", { params: { query } }), "categories");
+      },
+      /**
+       * Get a category
+       *
+       * Get a benefit category.
+       */
+      async get(categoryId) {
+        return unwrapProp(await client.GET("/benefits/categories/v1/{categoryId}", { params: { path: { categoryId } } }), "category");
+      },
+      /**
+       * Create a category
+       *
+       * Create a benefit category.
+       */
+      async create(body) {
+        return unwrapProp(await client.POST("/benefits/categories/v1", { body }), "category");
+      },
+      /**
+       * Update a category
+       *
+       * Update a benefit category.
+       */
+      async update(categoryId, body) {
+        return unwrapProp(await client.PUT("/benefits/categories/v1/{categoryId}", { params: { path: { categoryId } }, body }), "category");
+      },
+      /**
+       * Delete a category
+       *
+       * Delete a benefit category.
+       */
+      async delete(categoryId) {
+        return unwrap(await client.DELETE("/benefits/categories/v1/{categoryId}", { params: { path: { categoryId } } }));
+      }
+    }
+  };
+}
+
+// src/generated/resources/billing.ts
+function createBilling(client, defaults) {
+  return {
+    creditNotes: {
+      /**
+       * Retrieve credit notes
+       *
+       * Retrieve all credit notes for a specific invoice or location. One of invoiceRef or locationRef is required.
+       */
+      async list(query) {
+        return unwrap(await client.GET("/billing/credit_notes/v1", { params: { query } }));
+      },
+      /**
+       * Retrieve credit notes — iterates every item across all pages.
+       *
+       * Retrieve all credit notes for a specific invoice or location. One of invoiceRef or locationRef is required.
+       */
+      iterate(query) {
+        return paginate(
+          async (nextPageToken) => unwrap(await client.GET("/billing/credit_notes/v1", { params: { query: { ...query, nextPageToken } } })),
+          "creditNotes"
+        );
+      },
+      /**
+       * Retrieve a credit note
+       *
+       * Retrieve a specific credit note.
+       */
+      async get(id) {
+        return unwrapProp(await client.GET("/billing/credit_notes/v1/{id}", { params: { path: { id } } }), "creditNote");
+      },
+      /**
+       * Create a credit note
+       *
+       * Create a credit note for an invoice.
+       */
+      async create(body) {
+        return unwrapProp(await client.POST("/billing/credit_notes/v1", { body }), "creditNote");
+      },
+      /** Update a credit note */
+      async update(id, body) {
+        return unwrap(await client.PATCH("/billing/credit_notes/v1/{id}", { params: { path: { id } }, body }));
+      },
+      /**
+       * Preview a credit note
+       *
+       * Preview a credit note for an invoice without creating it.
+       */
+      async preview(body) {
+        return unwrapProp(await client.POST("/billing/credit_notes/v1/preview", { body }), "creditNote");
+      }
+    },
+    invoices: {
+      /**
+       * Retrieve invoices
+       *
+       * Retrieve all invoices based on certain parameters.
+       */
+      async list(query) {
+        return unwrap(await client.GET("/billing/invoices/v1", { params: { query } }));
+      },
+      /**
+       * Retrieve invoices — iterates every item across all pages.
+       *
+       * Retrieve all invoices based on certain parameters.
+       */
+      iterate(query) {
+        return paginate(
+          async (nextPageToken) => unwrap(await client.GET("/billing/invoices/v1", { params: { query: { ...query, nextPageToken } } })),
+          "invoices"
+        );
+      },
+      /**
+       * Retrieve an invoice
+       *
+       * Retrieve a certain invoice.
+       */
+      async get(invoiceId) {
+        return unwrapProp(await client.GET("/billing/invoices/v1/{invoiceId}", { params: { path: { invoiceId } } }), "invoice");
+      },
+      /**
+       * Create an invoice
+       *
+       * Create an invoice for a member or a company.
+       */
+      async create(body) {
+        return unwrapProp(await client.POST("/billing/invoices/v1", { body }), "invoice");
+      },
+      /**
+       * Update an invoice
+       *
+       * Update a draft invoice.
+       */
+      async update(invoiceId, body) {
+        return unwrap(await client.PATCH("/billing/invoices/v1/{invoiceId}", { params: { path: { invoiceId } }, body }));
+      },
+      /**
+       * Delete an invoice
+       *
+       * Delete a draft invoice.
+       */
+      async delete(invoiceId) {
+        return unwrap(await client.DELETE("/billing/invoices/v1/{invoiceId}", { params: { path: { invoiceId } } }));
+      },
+      /**
+       * Cancel a payment
+       *
+       * Cancel a payment on an invoice.
+       */
+      async cancelPayment(invoiceId) {
+        return unwrap(await client.POST("/billing/invoices/v1/{invoiceId}/cancel_payment", { params: { path: { invoiceId } } }));
+      },
+      /**
+       * Duplicate an invoice
+       *
+       * Duplicate an invoice, creating a new draft invoice with the same items.
+       */
+      async duplicate(invoiceId) {
+        return unwrapProp(await client.POST("/billing/invoices/v1/{invoiceId}/duplicate", { params: { path: { invoiceId } } }), "invoice");
+      },
+      /**
+       * List invoice items
+       *
+       * List all items for a specific invoice.
+       */
+      async getItems(invoiceId) {
+        return unwrap(await client.GET("/billing/invoices/v1/{invoiceId}/items", { params: { path: { invoiceId } } }));
+      },
+      /**
+       * Retrieve the upcoming invoice
+       *
+       * Retrieve the upcoming invoice preview for a membership or subscription.
+       */
+      async getUpcoming(query) {
+        return unwrap(await client.GET("/billing/invoices/v1/upcoming", { params: { query } }));
+      },
+      /**
+       * Issue an invoice
+       *
+       * Issue (finalize) a draft invoice, making it ready for payment.
+       */
+      async issue(invoiceId, body) {
+        return unwrap(await client.POST("/billing/invoices/v1/{invoiceId}/issue", { params: { path: { invoiceId } }, body }));
+      },
+      /**
+       * Pay an invoice
+       *
+       * Mark an invoice as paid by `External Payment`.
+       */
+      async pay(invoiceId, body) {
+        return unwrap(await client.POST("/billing/invoices/v1/{invoiceId}/pay", { params: { path: { invoiceId } }, body }));
+      },
+      /**
+       * Resend an invoice
+       *
+       * Resend an issued invoice notification to the customer.
+       */
+      async resend(invoiceId) {
+        return unwrap(await client.POST("/billing/invoices/v1/{invoiceId}/resend", { params: { path: { invoiceId } } }));
+      },
+      /**
+       * Void an invoice
+       *
+       * Void an issued invoice.
+       */
+      async void(invoiceId) {
+        return unwrap(await client.PATCH("/billing/invoices/v1/{invoiceId}/void", { params: { path: { invoiceId } } }));
+      },
+      items: {
+        /**
+         * Retrieve an invoice item
+         *
+         * Retrieve a specific invoice item.
+         */
+        async get(id) {
+          return unwrapProp(await client.GET("/billing/invoices/v1/items/{id}", { params: { path: { id } } }), "invoiceItem");
+        },
+        /**
+         * Create an invoice item
+         *
+         * Create an item in an invoice.
+         */
+        async create(body) {
+          return unwrapProp(await client.POST("/billing/invoices/v1/items", { body }), "invoiceItem");
+        },
+        /**
+         * Update an invoice item
+         *
+         * Update an invoice item on a draft invoice.
+         */
+        async update(id, body) {
+          return unwrap(await client.PATCH("/billing/invoices/v1/items/{id}", { params: { path: { id } }, body }));
+        },
+        /**
+         * Delete an invoice item
+         *
+         * Delete an invoice item from a draft invoice.
+         */
+        async delete(id) {
+          return unwrap(await client.DELETE("/billing/invoices/v1/items/{id}", { params: { path: { id } } }));
+        },
+        /** List upcoming invoice items */
+        async getUpcoming(query) {
+          return unwrapProp(await client.GET("/billing/invoices/v1/items/upcoming", { params: { query } }), "invoiceItems");
+        }
+      }
+    }
+  };
+}
+
+// src/generated/resources/community.ts
+function createCommunity(client, defaults) {
+  return {
+    companies: {
+      /**
+       * Retrieve companies
+       *
+       * Retrieve all companies.
+       */
+      async list(query) {
+        return unwrap(await client.GET("/community/companies/v1", { params: { query } }));
+      },
+      /**
+       * Retrieve companies — iterates every item across all pages.
+       *
+       * Retrieve all companies.
+       */
+      iterate(query) {
+        return paginate(
+          async (nextPageToken) => unwrap(await client.GET("/community/companies/v1", { params: { query: { ...query, nextPageToken } } })),
+          "companies"
+        );
+      },
+      /**
+       * Retrieve a company
+       *
+       * Retrieve a certain company.
+       */
+      async get(id) {
+        return unwrapProp(await client.GET("/community/companies/v1/{id}", { params: { path: { id } } }), "company");
+      },
+      /** Create a company */
+      async create(body) {
+        return unwrapProp(await client.POST("/community/companies/v1", { body }), "company");
+      },
+      /**
+       * Update a company
+       *
+       * Update a certain company.
+       */
+      async update(id, body) {
+        return unwrapProp(await client.PUT("/community/companies/v1/{id}", { params: { path: { id } }, body }), "company");
+      }
+    },
+    memberships: {
+      /**
+       * Retrieve memberships
+       *
+       * Retrieve all memberships.
+       */
+      async list(query) {
+        return unwrap(await client.GET("/community/memberships/v1", { params: { query } }));
+      },
+      /**
+       * Retrieve memberships — iterates every item across all pages.
+       *
+       * Retrieve all memberships.
+       */
+      iterate(query) {
+        return paginate(
+          async (nextPageToken) => unwrap(await client.GET("/community/memberships/v1", { params: { query: { ...query, nextPageToken } } })),
+          "memberships"
+        );
+      },
+      /**
+       * Retrieve a membership
+       *
+       * Retrieve a certain membership.
+       */
+      async get(id) {
+        return unwrapProp(await client.GET("/community/memberships/v1/{id}", { params: { path: { id } } }), "membership");
+      },
+      /**
+       * Create a membership
+       *
+       * Create a membership and send an email invitation to join if type is member.
+       */
+      async create(body) {
+        return unwrapProp(await client.POST("/community/memberships/v1", { body }), "membership");
+      },
+      /**
+       * Update a membership
+       *
+       * Update a certain membership.
+       */
+      async update(id, body) {
+        return unwrapProp(await client.PUT("/community/memberships/v1/{id}", { params: { path: { id } }, body }), "membership");
+      },
+      /**
+       * Delete a membership
+       *
+       * Delete a certain membership.
+       */
+      async delete(id) {
+        return unwrap(await client.DELETE("/community/memberships/v1/{id}", { params: { path: { id } } }));
+      },
+      /**
+       * Retrieve deleted memberships — iterates every item across all pages.
+       *
+       * Retrieve all deleted memberships.
+       */
+      iterateDeleted(query) {
+        return paginate(
+          async (nextPageToken) => unwrap(await client.GET("/community/memberships/v1/deleted", { params: { query: { ...query, nextPageToken } } })),
+          "memberships"
+        );
+      },
+      /**
+       * Retrieve deleted memberships
+       *
+       * Retrieve all deleted memberships.
+       */
+      async listDeleted(query) {
+        return unwrap(await client.GET("/community/memberships/v1/deleted", { params: { query } }));
+      }
+    }
+  };
+}
+
+// src/generated/resources/contracts.ts
+function createContracts(client, defaults) {
+  return {
+    /**
+     * Retrieve contracts
+     *
+     * Retrieve all contracts in the location.
+     */
+    async list(query) {
+      return unwrap(await client.GET("/contracts/v1", { params: { query } }));
+    },
+    /**
+     * Retrieve contracts — iterates every item across all pages.
+     *
+     * Retrieve all contracts in the location.
+     */
+    iterate(query) {
+      return paginate(
+        async (nextPageToken) => unwrap(await client.GET("/contracts/v1", { params: { query: { ...query, nextPageToken } } })),
+        "contracts"
+      );
+    },
+    /** Get a contract */
+    async get(contractId) {
+      return unwrapProp(await client.GET("/contracts/v1/{contractId}", { params: { path: { contractId } } }), "contract");
+    },
+    /** Create a contract */
+    async create(body) {
+      return unwrapProp(await client.POST("/contracts/v1", { body }), "contract");
+    },
+    /** Delete a contract */
+    async delete(contractId) {
+      return unwrap(await client.DELETE("/contracts/v1/{contractId}", { params: { path: { contractId } } }));
+    },
+    /** Issue a contract */
+    async issue(contractId, body) {
+      return unwrapProp(await client.POST("/contracts/v1/{contractId}/issue", { params: { path: { contractId } }, body }), "contract");
+    },
+    /** Terminate a contract */
+    async terminate(contractId, body) {
+      return unwrap(await client.PATCH("/contracts/v1/{contractId}/terminate", { params: { path: { contractId } }, body }));
+    }
+  };
+}
+
+// src/generated/resources/discounts.ts
+function createDiscounts(client, defaults) {
+  return {
+    coupons: {
+      /**
+       * Retrieve coupons
+       *
+       * Retrieve all coupons in the location.
+       */
+      async list(query) {
+        return unwrap(await client.GET("/discounts/coupons/v1", { params: { query } }));
+      },
+      /**
+       * Retrieve coupons — iterates every item across all pages.
+       *
+       * Retrieve all coupons in the location.
+       */
+      iterate(query) {
+        return paginate(
+          async (nextPageToken) => unwrap(await client.GET("/discounts/coupons/v1", { params: { query: { ...query, nextPageToken } } })),
+          "coupons"
+        );
+      },
+      /** Get a coupon */
+      async get(id) {
+        return unwrapProp(await client.GET("/discounts/coupons/v1/{id}", { params: { path: { id } } }), "coupon");
+      },
+      /** Create a coupon */
+      async create(body) {
+        return unwrapProp(await client.POST("/discounts/coupons/v1", { body }), "coupon");
+      },
+      /** Update a coupon */
+      async update(id, body) {
+        return unwrap(await client.PATCH("/discounts/coupons/v1/{id}", { params: { path: { id } }, body }));
+      },
+      /** Delete a coupon */
+      async delete(id) {
+        return unwrap(await client.DELETE("/discounts/coupons/v1/{id}", { params: { path: { id } } }));
+      }
+    },
+    promocodes: {
+      /**
+       * Retrieve promocodes
+       *
+       * Retrieve all promocodes.
+       */
+      async list(query) {
+        return unwrapProp(await client.GET("/discounts/promocodes/v1", { params: { query } }), "promocodes");
+      },
+      /** Get a promocode */
+      async get(id) {
+        return unwrapProp(await client.GET("/discounts/promocodes/v1/{id}", { params: { path: { id } } }), "promocode");
+      },
+      /** Create a promocode */
+      async create(body) {
+        return unwrapProp(await client.POST("/discounts/promocodes/v1", { body }), "promocode");
+      },
+      /** Archive a promocode */
+      async archive(id) {
+        return unwrapProp(await client.PUT("/discounts/promocodes/v1/{id}/archive", { params: { path: { id } } }), "promocode");
+      }
+    },
+    redemptions: {
+      /**
+       * Retrieve redemptions
+       *
+       * Retrieve all discount redemptions. Either couponRef or promocodeRef is required.
+       */
+      async list(query) {
+        return unwrap(await client.GET("/discounts/redemptions/v1", { params: { query } }));
+      },
+      /**
+       * Retrieve redemptions — iterates every item across all pages.
+       *
+       * Retrieve all discount redemptions. Either couponRef or promocodeRef is required.
+       */
+      iterate(query) {
+        return paginate(
+          async (nextPageToken) => unwrap(await client.GET("/discounts/redemptions/v1", { params: { query: { ...query, nextPageToken } } })),
+          "redemptions"
+        );
+      }
+    }
+  };
+}
+
+// src/generated/resources/events.ts
+function createEvents(client, defaults) {
+  return {
+    /** Retrieve events */
+    async list(query) {
+      return unwrap(await client.GET("/events/v1", { params: { query } }));
+    },
+    /** Retrieve an event */
+    async get(id) {
+      return unwrapProp(await client.GET("/events/v1/{id}", { params: { header: { "spacebring-network-id": defaults.networkId }, path: { id } } }), "event");
+    },
+    /** Create an event */
+    async create(body) {
+      return unwrapProp(await client.POST("/events/v1", { body }), "event");
+    },
+    /** Delete an event */
+    async delete(id) {
+      return unwrap(await client.DELETE("/events/v1/{id}", { params: { path: { id } } }));
+    },
+    /** Cancel an event */
+    async cancel(id) {
+      return unwrapProp(await client.PUT("/events/v1/{id}/cancel", { params: { path: { id } } }), "event");
+    },
+    /** Copy an event */
+    async copy(id) {
+      return unwrapProp(await client.POST("/events/v1/{id}/copy", { params: { path: { id } } }), "event");
+    },
+    tickets: {
+      /**
+       * Retrieve tickets
+       *
+       * Retrieve all event tickets.
+       */
+      async list(query) {
+        return unwrap(await client.GET("/events/tickets/v1", { params: { query } }));
+      },
+      /**
+       * Retrieve tickets — iterates every item across all pages.
+       *
+       * Retrieve all event tickets.
+       */
+      iterate(query) {
+        return paginate(
+          async (nextPageToken) => unwrap(await client.GET("/events/tickets/v1", { params: { query: { ...query, nextPageToken } } })),
+          "tickets"
+        );
+      },
+      /**
+       * Retrieve a ticket
+       *
+       * Retrieve an event ticket.
+       */
+      async get(id) {
+        return unwrapProp(await client.GET("/events/tickets/v1/{id}", { params: { path: { id } } }), "ticket");
+      }
+    }
+  };
+}
+
+// src/generated/resources/feed.ts
+function createFeed(client, defaults) {
+  return {
+    comments: {
+      /**
+       * Create a post comment
+       *
+       * Create a feed post comment.
+       */
+      async create(body) {
+        return unwrapProp(await client.POST("/feed/comments/v1", { body }), "comment");
+      },
+      /** Delete a post comment */
+      async delete(id) {
+        return unwrap(await client.DELETE("/feed/comments/v1/{id}", { params: { path: { id } } }));
+      },
+      /** Create a like for a post comment */
+      async createLike(id) {
+        return unwrapProp(await client.POST("/feed/comments/v1/{id}/likes", { params: { path: { id } } }), "like");
+      },
+      /** Delete a like for a post comment */
+      async deleteLike(id) {
+        return unwrap(await client.DELETE("/feed/comments/v1/{id}/likes", { params: { path: { id } } }));
+      }
+    },
+    posts: {
+      /**
+       * Get posts
+       *
+       * Get feed posts.
+       */
+      async list(query) {
+        return unwrap(await client.GET("/feed/posts/v1", { params: { query } }));
+      },
+      /**
+       * Get posts — iterates every item across all pages.
+       *
+       * Get feed posts.
+       */
+      iterate(query) {
+        return paginate(
+          async (nextPageToken) => unwrap(await client.GET("/feed/posts/v1", { params: { query: { ...query, nextPageToken } } })),
+          "posts"
+        );
+      },
+      /**
+       * Get a post
+       *
+       * Get a feed post.
+       */
+      async get(id) {
+        return unwrapProp(await client.GET("/feed/posts/v1/{id}", { params: { path: { id } } }), "post");
+      },
+      /**
+       * Create a post
+       *
+       * Create a feed post.
+       */
+      async create(body) {
+        return unwrapProp(await client.POST("/feed/posts/v1", { body }), "post");
+      },
+      /**
+       * Update a post
+       *
+       * Update a feed post.
+       */
+      async update(id, body) {
+        return unwrapProp(await client.PUT("/feed/posts/v1/{id}", { params: { path: { id } }, body }), "post");
+      },
+      /**
+       * Delete a post
+       *
+       * Delete a feed post.
+       */
+      async delete(id) {
+        return unwrap(await client.DELETE("/feed/posts/v1/{id}", { params: { path: { id } } }));
+      },
+      /** Create a like for a post */
+      async createLike(id) {
+        return unwrapProp(await client.POST("/feed/posts/v1/{id}/likes", { params: { path: { id } } }), "like");
+      },
+      /** Delete a like for a post */
+      async deleteLike(id) {
+        return unwrap(await client.DELETE("/feed/posts/v1/{id}/likes", { params: { path: { id } } }));
+      },
+      /** Get comments for a post */
+      async getComments(id) {
+        return unwrapProp(await client.GET("/feed/posts/v1/{id}/comments", { params: { path: { id } } }), "comments");
+      },
+      /** Get likes for a post */
+      async getLikes(id) {
+        return unwrapProp(await client.GET("/feed/posts/v1/{id}/likes", { params: { path: { id } } }), "likes");
+      }
+    }
+  };
+}
+
+// src/generated/resources/floors.ts
+function createFloors(client, defaults) {
+  return {
+    /** Get floors */
+    async list(query) {
+      return unwrap(await client.GET("/floors/v1", { params: { query } }));
+    },
+    /** Delete a floor */
+    async delete(id) {
+      return unwrap(await client.DELETE("/floors/v1/{id}", { params: { path: { id } } }));
+    }
+  };
+}
+
+// src/generated/resources/guides.ts
+function createGuides(client, defaults) {
+  return {
+    /**
+     * Retrieve guides
+     *
+     * Retrieve all guides for an organization. Requires locationRef. When using bearer token (non-basic auth), results are filtered by the user's access.
+     */
+    async list(query) {
+      return unwrap(await client.GET("/guides/v1", { params: { query } }));
+    },
+    /**
+     * Retrieve guides — iterates every item across all pages.
+     *
+     * Retrieve all guides for an organization. Requires locationRef. When using bearer token (non-basic auth), results are filtered by the user's access.
+     */
+    iterate(query) {
+      return paginate(
+        async (nextPageToken) => unwrap(await client.GET("/guides/v1", { params: { query: { ...query, nextPageToken } } })),
+        "guides"
+      );
+    },
+    /**
+     * Retrieve a guide
+     *
+     * Retrieve a guide by id.
+     */
+    async get(guideId) {
+      return unwrapProp(await client.GET("/guides/v1/{guideId}", { params: { path: { guideId } } }), "guide");
+    },
+    /**
+     * Create a guide
+     *
+     * Create a guide in an organization.
+     */
+    async create(body) {
+      return unwrapProp(await client.POST("/guides/v1", { body }), "guide");
+    },
+    /**
+     * Update a guide
+     *
+     * Update a guide. At least one guide property must be provided.
+     */
+    async update(guideId, body) {
+      return unwrapProp(await client.PATCH("/guides/v1/{guideId}", { params: { path: { guideId } }, body }), "guide");
+    },
+    /** Delete a guide */
+    async delete(guideId) {
+      return unwrap(await client.DELETE("/guides/v1/{guideId}", { params: { path: { guideId } } }));
+    }
+  };
+}
+
+// src/generated/resources/locations.ts
+function createLocations(client, defaults) {
+  return {
+    /** Retrieve all locations */
+    async list() {
+      return unwrapProp(await client.GET("/locations/v1", {}), "locations");
+    },
+    /** Get a location */
+    async get(locationId) {
+      return unwrapProp(await client.GET("/locations/v1/{locationId}", { params: { path: { locationId } } }), "location");
+    }
+  };
+}
+
+// src/generated/resources/networks.ts
+function createNetworks(client, defaults) {
+  return {
+    /**
+     * Retrieve networks
+     *
+     * Retrieve all networks you are in.
+     */
+    async list() {
+      return unwrapProp(await client.GET("/networks/v1", {}), "networks");
+    }
+  };
+}
+
+// src/generated/resources/plans.ts
+function createPlans(client, defaults) {
+  return {
+    /**
+     * Retrieve plans
+     *
+     * Retrieve all plans.
+     */
+    async list(query) {
+      return unwrap(await client.GET("/plans/v1", { params: { query } }));
+    },
+    /**
+     * Retrieve plans — iterates every item across all pages.
+     *
+     * Retrieve all plans.
+     */
+    iterate(query) {
+      return paginate(
+        async (nextPageToken) => unwrap(await client.GET("/plans/v1", { params: { query: { ...query, nextPageToken } } })),
+        "plans"
+      );
+    },
+    /**
+     * Retrieve a plan
+     *
+     * Retrieve a certain plan.
+     */
+    async get(planId) {
+      return unwrapProp(await client.GET("/plans/v1/{planId}", { params: { path: { planId } } }), "plan");
+    },
+    /** Create a plan */
+    async create(body) {
+      return unwrapProp(await client.POST("/plans/v1", { body }), "plan");
+    },
+    /**
+     * Update a plan
+     *
+     * Update a certain plan.
+     */
+    async update(planId, body) {
+      return unwrap(await client.PATCH("/plans/v1/{planId}", { params: { path: { planId } }, body }));
+    },
+    /**
+     * Delete a plan
+     *
+     * Delete a certain plan.
+     */
+    async delete(planId) {
+      return unwrap(await client.DELETE("/plans/v1/{planId}", { params: { path: { planId } } }));
+    }
+  };
+}
+
+// src/generated/resources/registrations.ts
+function createRegistrations(client, defaults) {
+  return {
+    /**
+     * Retrieve registrations
+     *
+     * Retrieve all registrations in network.
+     */
+    async list(query) {
+      return unwrap(await client.GET("/registrations/v1", { params: { query } }));
+    },
+    /**
+     * Retrieve registrations — iterates every item across all pages.
+     *
+     * Retrieve all registrations in network.
+     */
+    iterate(query) {
+      return paginate(
+        async (nextPageToken) => unwrap(await client.GET("/registrations/v1", { params: { query: { ...query, nextPageToken } } })),
+        "registrations"
+      );
+    }
+  };
+}
+
+// src/generated/resources/resources.ts
+function createResources(client, defaults) {
+  return {
+    /**
+     * Retrieve resources
+     *
+     * Retrieve resources in the location. Resources represent all kind of bookable items like rooms, hot desks, dedicated desks, parking lots.
+     */
+    async list(query) {
+      return unwrap(await client.GET("/resources/v1", { params: { query } }));
+    },
+    /**
+     * Retrieve resources — iterates every item across all pages.
+     *
+     * Retrieve resources in the location. Resources represent all kind of bookable items like rooms, hot desks, dedicated desks, parking lots.
+     */
+    iterate(query) {
+      return paginate(
+        async (nextPageToken) => unwrap(await client.GET("/resources/v1", { params: { query: { ...query, nextPageToken } } })),
+        "resources"
+      );
+    },
+    /**
+     * Get a resource
+     *
+     * Get a certain resource.
+     */
+    async get(id) {
+      return unwrapProp(await client.GET("/resources/v1/{id}", { params: { path: { id } } }), "resource");
+    },
+    /**
+     * Create a resource
+     *
+     * Create a new resource in a location. The request body must match the schema exactly—unknown properties are rejected.
+     */
+    async create(body) {
+      return unwrapProp(await client.POST("/resources/v1", { body }), "resource");
+    },
+    /**
+     * Patch a resource
+     *
+     * Patch a certain resource.
+     */
+    async update(id, body) {
+      return unwrap(await client.PATCH("/resources/v1/{id}", { params: { path: { id } }, body }));
+    },
+    bookings: {
+      /**
+       * Retrieve bookings
+       *
+       * Retrieve all bookings of resources.
+       */
+      async list(query) {
+        return unwrap(await client.GET("/resources/bookings/v1", { params: { query } }));
+      },
+      /**
+       * Retrieve bookings — iterates every item across all pages.
+       *
+       * Retrieve all bookings of resources.
+       */
+      iterate(query) {
+        return paginate(
+          async (nextPageToken) => unwrap(await client.GET("/resources/bookings/v1", { params: { query: { ...query, nextPageToken } } })),
+          "bookings"
+        );
+      },
+      /** Get a booking */
+      async get(id) {
+        return unwrapProp(await client.GET("/resources/bookings/v1/{id}", { params: { path: { id } } }), "booking");
+      },
+      /** Create a booking */
+      async create(body) {
+        return unwrapProp(await client.POST("/resources/bookings/v1", { body }), "booking");
+      },
+      /** Delete a booking */
+      async delete(id) {
+        return unwrap(await client.DELETE("/resources/bookings/v1/{id}", { params: { path: { id } } }));
+      }
+    }
+  };
+}
+
+// src/generated/resources/shop.ts
+function createShop(client, defaults) {
+  return {
+    categories: {
+      /**
+       * Retrieve categories
+       *
+       * Retrieve all shop categories in the location.
+       */
+      async list(query) {
+        return unwrapProp(await client.GET("/shop/categories/v1", { params: { query } }), "categories");
+      },
+      /**
+       * Get a category
+       *
+       * Get a shop category.
+       */
+      async get(categoryId) {
+        return unwrapProp(await client.GET("/shop/categories/v1/{categoryId}", { params: { path: { categoryId } } }), "category");
+      },
+      /**
+       * Create a category
+       *
+       * Create a shop category.
+       */
+      async create(body) {
+        return unwrapProp(await client.POST("/shop/categories/v1", { body }), "category");
+      },
+      /**
+       * Update a category
+       *
+       * Update a shop category.
+       */
+      async update(categoryId, body) {
+        return unwrapProp(await client.PUT("/shop/categories/v1/{categoryId}", { params: { path: { categoryId } }, body }), "category");
+      },
+      /**
+       * Delete a category
+       *
+       * Delete a shop category.
+       */
+      async delete(categoryId) {
+        return unwrap(await client.DELETE("/shop/categories/v1/{categoryId}", { params: { path: { categoryId } } }));
+      }
+    },
+    orders: {
+      /**
+       * Retrieve orders
+       *
+       * Retrieve all orders of products from shop.
+       */
+      async list(query) {
+        return unwrap(await client.GET("/shop/orders/v1", { params: { query } }));
+      },
+      /**
+       * Retrieve orders — iterates every item across all pages.
+       *
+       * Retrieve all orders of products from shop.
+       */
+      iterate(query) {
+        return paginate(
+          async (nextPageToken) => unwrap(await client.GET("/shop/orders/v1", { params: { query: { ...query, nextPageToken } } })),
+          "orders"
+        );
+      },
+      /**
+       * Get an order
+       *
+       * Get a certain order.
+       */
+      async get(orderId) {
+        return unwrapProp(await client.GET("/shop/orders/v1/{orderId}", { params: { path: { orderId } } }), "order");
+      }
+    },
+    products: {
+      /**
+       * Retrieve products
+       *
+       * Retrieve products from shop.
+       */
+      async list(query) {
+        return unwrap(await client.GET("/shop/products/v1", { params: { query } }));
+      },
+      /**
+       * Retrieve products — iterates every item across all pages.
+       *
+       * Retrieve products from shop.
+       */
+      iterate(query) {
+        return paginate(
+          async (nextPageToken) => unwrap(await client.GET("/shop/products/v1", { params: { query: { ...query, nextPageToken } } })),
+          "products"
+        );
+      },
+      /**
+       * Get a product
+       *
+       * Get a certain product.
+       */
+      async get(productId) {
+        return unwrapProp(await client.GET("/shop/products/v1/{productId}", { params: { path: { productId } } }), "product");
+      },
+      /**
+       * Create a product
+       *
+       * Create a product in shop.
+       */
+      async create(body) {
+        return unwrapProp(await client.POST("/shop/products/v1", { body }), "product");
+      },
+      /**
+       * Update a product
+       *
+       * Update a certain product.
+       */
+      async update(productId, body) {
+        return unwrapProp(await client.PUT("/shop/products/v1/{productId}", { params: { path: { productId } }, body }), "product");
+      },
+      /**
+       * Delete a product
+       *
+       * Delete a certain product.
+       */
+      async delete(productId) {
+        return unwrap(await client.DELETE("/shop/products/v1/{productId}", { params: { path: { productId } } }));
+      }
+    }
+  };
+}
+
+// src/generated/resources/subscriptions.ts
+function createSubscriptions(client, defaults) {
+  return {
+    /** Retrieve subscriptions */
+    async list(query) {
+      return unwrap(await client.GET("/subscriptions/v1", { params: { query } }));
+    },
+    /** Retrieve subscriptions — iterates every item across all pages. */
+    iterate(query) {
+      return paginate(
+        async (nextPageToken) => unwrap(await client.GET("/subscriptions/v1", { params: { query: { ...query, nextPageToken } } })),
+        "subscriptions"
+      );
+    },
+    /**
+     * Retrieve a subscription
+     *
+     * Retrieve a certain subscription.
+     */
+    async get(id) {
+      return unwrapProp(await client.GET("/subscriptions/v1/{id}", { params: { path: { id } } }), "subscription");
+    },
+    /**
+     * Create a subscription
+     *
+     * Create a subscription for a membership or company.
+     */
+    async create(body) {
+      return unwrapProp(await client.POST("/subscriptions/v1", { body }), "subscription");
+    },
+    /**
+     * Update a subscription
+     *
+     * Update a certain subscription.
+     */
+    async update(id, body) {
+      return unwrap(await client.PATCH("/subscriptions/v1/{id}", { params: { path: { id } }, body }));
+    },
+    /**
+     * Delete a subscription
+     *
+     * Delete a certain subscription.
+     */
+    async delete(id) {
+      return unwrap(await client.DELETE("/subscriptions/v1/{id}", { params: { path: { id } } }));
+    },
+    /** Create a subscription item */
+    async createItem(id, body) {
+      return unwrapProp(await client.POST("/subscriptions/v1/{id}/items", { params: { path: { id } }, body }), "subscription");
+    },
+    /** Delete a subscription item */
+    async deleteItem(id, itemId) {
+      return unwrap(await client.DELETE("/subscriptions/v1/{id}/items/{itemId}", { params: { path: { id, itemId } } }));
+    },
+    /** Update a subscription item */
+    async updateItem(id, itemId, body) {
+      return unwrap(await client.PATCH("/subscriptions/v1/{id}/items/{itemId}", { params: { path: { id, itemId } }, body }));
+    }
+  };
+}
+
+// src/generated/resources/support.ts
+function createSupport(client, defaults) {
+  return {
+    tickets: {
+      /**
+       * Retrieve tickets
+       *
+       * Retrieve all support tickets.
+       */
+      async list(query) {
+        return unwrap(await client.GET("/support/tickets/v1", { params: { query } }));
+      },
+      /**
+       * Retrieve tickets — iterates every item across all pages.
+       *
+       * Retrieve all support tickets.
+       */
+      iterate(query) {
+        return paginate(
+          async (nextPageToken) => unwrap(await client.GET("/support/tickets/v1", { params: { query: { ...query, nextPageToken } } })),
+          "tickets"
+        );
+      },
+      /**
+       * Retrieve a ticket
+       *
+       * Retrieve a support ticket.
+       */
+      async get(id) {
+        return unwrap(await client.GET("/support/tickets/v1/{id}", { params: { path: { id } } }));
+      },
+      /**
+       * Create a ticket
+       *
+       * Create a support ticket.
+       */
+      async create(body) {
+        return unwrap(await client.POST("/support/tickets/v1", { body }));
+      },
+      /**
+       * Update a ticket's assignee
+       *
+       * Update support ticket assignee.
+       */
+      async updateAssignee(id, body) {
+        return unwrap(await client.PUT("/support/tickets/v1/{id}/assignee", { params: { path: { id } }, body }));
+      },
+      /**
+       * Update a ticket's status
+       *
+       * Update support ticket status.
+       */
+      async updateStatus(id, body) {
+        return unwrap(await client.PUT("/support/tickets/v1/{id}/status", { params: { path: { id } }, body }));
+      },
+      /**
+       * Update a ticket's type
+       *
+       * Update a support ticket type.
+       */
+      async updateType(id, body) {
+        return unwrap(await client.PATCH("/support/tickets/v1/{id}/type", { params: { path: { id } }, body }));
+      },
+      comment: {
+        /**
+         * Create a ticket comment
+         *
+         * Create a support ticket comment.
+         */
+        async create(body) {
+          return unwrapProp(await client.POST("/support/tickets/v1/comment", { body }), "activity");
+        },
+        /**
+         * Delete a ticket comment
+         *
+         * Delete a support ticket comment.
+         */
+        async delete(id) {
+          return unwrap(await client.DELETE("/support/tickets/v1/comment/{id}", { params: { path: { id } } }));
+        }
+      }
+    }
+  };
+}
+
+// src/generated/resources/transactions.ts
+function createTransactions(client, defaults) {
+  return {
+    balances: {
+      /**
+       * Retrieve credit balance
+       *
+       * Retrieve credits balance.
+       */
+      async getCredits(id) {
+        return unwrapProp(await client.GET("/transactions/v1/balances/{id}/credits", { params: { path: { id } } }), "balances");
+      },
+      /** Retrieve day passes balance */
+      async getDayPasses(id) {
+        return unwrapProp(await client.GET("/transactions/v1/balances/{id}/day_passes", { params: { path: { id } } }), "balances");
+      }
+    },
+    credits: {
+      /**
+       * Retrieve credit transactions
+       *
+       * Retrieve credits transactions.
+       */
+      async list(query) {
+        return unwrap(await client.GET("/transactions/credits/v1", { params: { query } }));
+      },
+      /**
+       * Retrieve credit transactions — iterates every item across all pages.
+       *
+       * Retrieve credits transactions.
+       */
+      iterate(query) {
+        return paginate(
+          async (nextPageToken) => unwrap(await client.GET("/transactions/credits/v1", { params: { query: { ...query, nextPageToken } } })),
+          "transactions"
+        );
+      },
+      /**
+       * Create a credit transaction
+       *
+       * Create a credits transaction.
+       */
+      async create(body) {
+        return unwrapProp(await client.POST("/transactions/credits/v1", { body }), "transaction");
+      }
+    },
+    dayPasses: {
+      /**
+       * Retrieve day pass transactions
+       *
+       * Retrieve day passes transactions.
+       */
+      async list(query) {
+        return unwrap(await client.GET("/transactions/day_passes/v1", { params: { query } }));
+      },
+      /**
+       * Retrieve day pass transactions — iterates every item across all pages.
+       *
+       * Retrieve day passes transactions.
+       */
+      iterate(query) {
+        return paginate(
+          async (nextPageToken) => unwrap(await client.GET("/transactions/day_passes/v1", { params: { query: { ...query, nextPageToken } } })),
+          "transactions"
+        );
+      },
+      /**
+       * Create a day pass transaction
+       *
+       * Create a day passes transaction.
+       */
+      async create(body) {
+        return unwrapProp(await client.POST("/transactions/day_passes/v1", { body }), "transaction");
+      }
+    },
+    money: {
+      /** Retrieve money transactions */
+      async list(query) {
+        return unwrap(await client.GET("/transactions/money/v1", { params: { query } }));
+      },
+      /** Retrieve money transactions — iterates every item across all pages. */
+      iterate(query) {
+        return paginate(
+          async (nextPageToken) => unwrap(await client.GET("/transactions/money/v1", { params: { query: { ...query, nextPageToken } } })),
+          "transactions"
+        );
+      },
+      /** Retrieve a money transaction */
+      async get(id) {
+        return unwrapProp(await client.GET("/transactions/money/v1/{id}", { params: { path: { id } } }), "transaction");
+      }
+    }
+  };
+}
+
+// src/generated/resources/visitors.ts
+function createVisitors(client, defaults) {
+  return {
+    contacts: {
+      /** Get contacts */
+      async list(query) {
+        return unwrap(await client.GET("/visitors/contacts/v1", { params: { query } }));
+      },
+      /** Get contacts — iterates every item across all pages. */
+      iterate(query) {
+        return paginate(
+          async (nextPageToken) => unwrap(await client.GET("/visitors/contacts/v1", { params: { query: { ...query, nextPageToken } } })),
+          "contacts"
+        );
+      },
+      /** Get a contact */
+      async get(contactId) {
+        return unwrapProp(await client.GET("/visitors/contacts/v1/{contactId}", { params: { path: { contactId } } }), "contact");
+      },
+      /** Create a contact */
+      async create(body) {
+        return unwrapProp(await client.POST("/visitors/contacts/v1", { body }), "contact");
+      }
+    },
+    requests: {
+      /** Get requests */
+      async list(query) {
+        return unwrap(await client.GET("/visitors/requests/v1", { params: { query } }));
+      },
+      /** Get requests — iterates every item across all pages. */
+      iterate(query) {
+        return paginate(
+          async (nextPageToken) => unwrap(await client.GET("/visitors/requests/v1", { params: { query: { ...query, nextPageToken } } })),
+          "requests"
+        );
+      },
+      /** Retrieve a request */
+      async get(id) {
+        return unwrapProp(await client.GET("/visitors/requests/v1/{id}", { params: { path: { id } } }), "request");
+      },
+      /** Create a request */
+      async create(body) {
+        return unwrapProp(await client.POST("/visitors/requests/v1", { body }), "request");
+      },
+      /** Approve a request */
+      async approve(id) {
+        return unwrapProp(await client.POST("/visitors/requests/v1/{id}/approve", { params: { path: { id } } }), "visit");
+      },
+      /** Reject a request */
+      async reject(id) {
+        return unwrap(await client.POST("/visitors/requests/v1/{id}/reject", { params: { path: { id } } }));
+      }
+    },
+    visits: {
+      /** Retrieve visits */
+      async list(query) {
+        return unwrap(await client.GET("/visitors/visits/v1", { params: { query } }));
+      },
+      /** Retrieve visits — iterates every item across all pages. */
+      iterate(query) {
+        return paginate(
+          async (nextPageToken) => unwrap(await client.GET("/visitors/visits/v1", { params: { query: { ...query, nextPageToken } } })),
+          "visits"
+        );
+      },
+      /**
+       * Retrieve a visit
+       *
+       * Retrieve a visit by id.
+       */
+      async get(id) {
+        return unwrapProp(await client.GET("/visitors/visits/v1/{id}", { params: { path: { id } } }), "visit");
+      },
+      /** Create a visit */
+      async create(body) {
+        return unwrapProp(await client.POST("/visitors/visits/v1", { body }), "visit");
+      },
+      /**
+       * Update a visit
+       *
+       * Update a visit by id.
+       */
+      async update(id, body) {
+        return unwrapProp(await client.PUT("/visitors/visits/v1/{id}", { params: { path: { id } }, body }), "visit");
+      },
+      /**
+       * Delete a visit
+       *
+       * Delete a visit by id.
+       */
+      async delete(id) {
+        return unwrap(await client.DELETE("/visitors/visits/v1/{id}", { params: { path: { id } } }));
+      },
+      /** Check in a visit */
+      async checkIn(body) {
+        return unwrapProp(await client.POST("/visitors/visits/v1/checkin", { body }), "visit");
+      },
+      /** Check out a visit */
+      async checkOut(body) {
+        return unwrapProp(await client.POST("/visitors/visits/v1/checkout", { body }), "visit");
+      }
+    }
+  };
+}
+
+// src/generated/resources/index.ts
+function createResources2(client, defaults) {
+  return {
+    altCurrencies: createAltcurrencies(client, defaults),
+    benefits: createBenefits(client, defaults),
+    billing: createBilling(client, defaults),
+    community: createCommunity(client, defaults),
+    contracts: createContracts(client, defaults),
+    discounts: createDiscounts(client, defaults),
+    events: createEvents(client, defaults),
+    feed: createFeed(client, defaults),
+    floors: createFloors(client, defaults),
+    guides: createGuides(client, defaults),
+    locations: createLocations(client, defaults),
+    networks: createNetworks(client, defaults),
+    plans: createPlans(client, defaults),
+    registrations: createRegistrations(client, defaults),
+    resources: createResources(client, defaults),
+    shop: createShop(client, defaults),
+    subscriptions: createSubscriptions(client, defaults),
+    support: createSupport(client, defaults),
+    transactions: createTransactions(client, defaults),
+    visitors: createVisitors(client, defaults)
+  };
+}
+
+// src/client.ts
+var Spacebring = class {
+  /** Typed openapi-fetch client — escape hatch for endpoints or options the facade does not cover. */
+  raw;
+  constructor(config) {
+    const headers = {
+      Authorization: `Basic ${toBase64(`${config.clientId}:${config.clientSecret}`)}`
+    };
+    if (config.networkId) {
+      headers["spacebring-network-id"] = config.networkId;
+    }
+    this.raw = createClient({
+      baseUrl: config.baseUrl ?? "https://api.spacebring.com",
+      headers,
+      fetch: config.fetch
+    });
+    Object.assign(this, createResources2(this.raw, { networkId: config.networkId }));
+  }
+};
+function toBase64(value) {
+  if (typeof Buffer !== "undefined") {
+    return Buffer.from(value, "utf8").toString("base64");
+  }
+  let binary = "";
+  for (const byte of new TextEncoder().encode(value)) {
+    binary += String.fromCharCode(byte);
+  }
+  return btoa(binary);
+}
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  Spacebring,
+  SpacebringError
+});
+//# sourceMappingURL=index.cjs.map