@leaflow/sdk 0.0.0-dev.43.g1ad4bd0 → 0.0.0-dev.433.g7e48b8f

package/dist/account/v1/generated/functions.js

@@ -0,0 +1,599 @@
+export const getGetSettingsUrl = () => {
+    return `https://account.leaflow.cloud/account/v1/settings`;
+};
+/**
+ * No token required.
+ *
+ * While `registration_mode` is not `OPEN`, `POST /account/v1/me:register` answers 403: `CLOSED` refuses everyone, and `INVITE_ONLY` accepts only an email address holding a project invitation. `project_creation_mode` behaves the same way, and `VERIFIED_ONLY` requires identity verification to have completed.
+ *
+ * Both quotas are `0` when unlimited. The decision itself is made at the moment of writing.
+ * @summary Get registration and project creation settings
+ */
+export const getSettings = async (options, fetchFn) => {
+    const res = await (fetchFn ?? fetch)(getGetSettingsUrl(), {
+        ...options,
+        method: "GET",
+    });
+    const body = [204, 205, 304].includes(res.status) ? null : await res.text();
+    const data = body ? JSON.parse(body) : {};
+    return { data, status: res.status, headers: res.headers };
+};
+export const getListLocalesUrl = () => {
+    return `https://account.leaflow.cloud/account/v1/locales`;
+};
+/**
+ * No token required: the registration page renders both lists before an account exists.
+ *
+ * Country names and their order follow `Accept-Language`. A name is rendered in the requested language and the list is ordered by the rules of that language rather than by code point. Simplified Chinese applies when the header is absent.
+ *
+ * Retired codes such as the Soviet Union and Yugoslavia, and codes that denote no country such as the European Union, are not listed.
+ * @summary List countries and languages for registration
+ */
+export const listLocales = async (options, fetchFn) => {
+    const res = await (fetchFn ?? fetch)(getListLocalesUrl(), {
+        ...options,
+        method: "GET",
+    });
+    const body = [204, 205, 304].includes(res.status) ? null : await res.text();
+    const data = body ? JSON.parse(body) : {};
+    return { data, status: res.status, headers: res.headers };
+};
+export const getListAgreementsUrl = () => {
+    return `https://account.leaflow.cloud/account/v1/agreements`;
+};
+/**
+ * No token required. Send the `type` and `version` of each one back unchanged to `POST /account/v1/me:register`.
+ *
+ * The array is empty while no agreement is in force, and registration then takes no `consents`.
+ * @summary List the agreements registration requires
+ */
+export const listAgreements = async (options, fetchFn) => {
+    const res = await (fetchFn ?? fetch)(getListAgreementsUrl(), {
+        ...options,
+        method: "GET",
+    });
+    const body = [204, 205, 304].includes(res.status) ? null : await res.text();
+    const data = body ? JSON.parse(body) : {};
+    return { data, status: res.status, headers: res.headers };
+};
+export const getListConsentsUrl = () => {
+    return `https://account.leaflow.cloud/account/v1/me/consents`;
+};
+/**
+ * Every record, most recent first, including versions that are no longer current.
+ * @summary List the agreements the caller has consented to
+ */
+export const listConsents = async (options, fetchFn) => {
+    const res = await (fetchFn ?? fetch)(getListConsentsUrl(), {
+        ...options,
+        method: "GET",
+    });
+    const body = [204, 205, 304].includes(res.status) ? null : await res.text();
+    const data = body ? JSON.parse(body) : {};
+    return { data, status: res.status, headers: res.headers };
+};
+export const getAcceptAgreementsUrl = () => {
+    return `https://account.leaflow.cloud/account/v1/me/consents`;
+};
+/**
+ * Call this once a new version is published, which is whenever `pending_agreements` on `GET /account/v1/me` is not empty.
+ *
+ * Only the version currently in force is accepted; consenting to an earlier one answers 409. Submitting the same version twice is not an error and leaves the first record in place.
+ * @summary Consent to the current agreements
+ */
+export const acceptAgreements = async (acceptConsentsRequestBody, options, fetchFn) => {
+    const getHeaders = (h) => {
+        if (!h)
+            return {};
+        if (h instanceof Headers)
+            return Object.fromEntries(h.entries());
+        if (Symbol.iterator in h) {
+            return Object.fromEntries(Array.from(h, (entry) => Array.from(entry)));
+        }
+        const headers = {};
+        for (const [name, value] of Object.entries(h)) {
+            if (value !== undefined)
+                headers[name] = value;
+        }
+        return headers;
+    };
+    const res = await (fetchFn ?? fetch)(getAcceptAgreementsUrl(), {
+        ...options,
+        method: "POST",
+        headers: { "Content-Type": "application/json", ...getHeaders(options?.headers) },
+        body: JSON.stringify(acceptConsentsRequestBody),
+    });
+    const body = [204, 205, 304].includes(res.status) ? null : await res.text();
+    const data = body ? JSON.parse(body) : {};
+    return { data, status: res.status, headers: res.headers };
+};
+export const getRegisterUrl = () => {
+    return `https://account.leaflow.cloud/account/v1/me:register`;
+};
+/**
+ * Call this after signing in at auth.leaflow.net, carrying the access token. The name and email address are taken from the sign-in claims and are not read from the request body.
+ *
+ * `consents` must cover every agreement returned by `GET /account/v1/agreements`, at the same versions. A missing agreement answers 400 and a stale version answers 409, in which case fetch the list again. An account that already exists answers 409, and one that has been deleted answers 410 `USER_DELETED`: the same sign-in cannot register again.
+ * @summary Register an account
+ */
+export const register = async (registerRequestBody, options, fetchFn) => {
+    const getHeaders = (h) => {
+        if (!h)
+            return {};
+        if (h instanceof Headers)
+            return Object.fromEntries(h.entries());
+        if (Symbol.iterator in h) {
+            return Object.fromEntries(Array.from(h, (entry) => Array.from(entry)));
+        }
+        const headers = {};
+        for (const [name, value] of Object.entries(h)) {
+            if (value !== undefined)
+                headers[name] = value;
+        }
+        return headers;
+    };
+    const res = await (fetchFn ?? fetch)(getRegisterUrl(), {
+        ...options,
+        method: "POST",
+        headers: { "Content-Type": "application/json", ...getHeaders(options?.headers) },
+        body: JSON.stringify(registerRequestBody),
+    });
+    const body = [204, 205, 304].includes(res.status) ? null : await res.text();
+    const data = body ? JSON.parse(body) : {};
+    return { data, status: res.status, headers: res.headers };
+};
+export const getGetAccountUrl = () => {
+    return `https://account.leaflow.cloud/account/v1/me`;
+};
+/**
+ * `pending_agreements` holds the agreements not yet consented to. While it is not empty, obtain consent and call `POST /account/v1/me/consents`.
+ *
+ * `status` is `DELETING` while a deletion is open; see `GET /account/v1/me/deletion`. A deleted account answers 410 `USER_DELETED`.
+ * @summary Get the current account
+ */
+export const getAccount = async (options, fetchFn) => {
+    const res = await (fetchFn ?? fetch)(getGetAccountUrl(), {
+        ...options,
+        method: "GET",
+    });
+    const body = [204, 205, 304].includes(res.status) ? null : await res.text();
+    const data = body ? JSON.parse(body) : {};
+    return { data, status: res.status, headers: res.headers };
+};
+export const getUpdateAccountUrl = () => {
+    return `https://account.leaflow.cloud/account/v1/me`;
+};
+/**
+ * The name and email address cannot be changed here. They come from the identity provider, and a change would be overwritten at the next sign-in.
+ * @summary Update the country and language of the current account
+ */
+export const updateAccount = async (updateAccountRequestBody, options, fetchFn) => {
+    const getHeaders = (h) => {
+        if (!h)
+            return {};
+        if (h instanceof Headers)
+            return Object.fromEntries(h.entries());
+        if (Symbol.iterator in h) {
+            return Object.fromEntries(Array.from(h, (entry) => Array.from(entry)));
+        }
+        const headers = {};
+        for (const [name, value] of Object.entries(h)) {
+            if (value !== undefined)
+                headers[name] = value;
+        }
+        return headers;
+    };
+    const res = await (fetchFn ?? fetch)(getUpdateAccountUrl(), {
+        ...options,
+        method: "PATCH",
+        headers: { "Content-Type": "application/json", ...getHeaders(options?.headers) },
+        body: JSON.stringify(updateAccountRequestBody),
+    });
+    const body = [204, 205, 304].includes(res.status) ? null : await res.text();
+    const data = body ? JSON.parse(body) : {};
+    return { data, status: res.status, headers: res.headers };
+};
+export const getRequestAccountDeletionUrl = (params) => {
+    const normalizedParams = new URLSearchParams();
+    Object.entries(params || {}).forEach(([key, value]) => {
+        if (value !== undefined) {
+            normalizedParams.append(key, value === null ? "null" : String(value));
+        }
+    });
+    const stringifiedParams = normalizedParams.toString();
+    return stringifiedParams.length > 0
+        ? `https://account.leaflow.cloud/account/v1/me?${stringifiedParams}`
+        : `https://account.leaflow.cloud/account/v1/me`;
+};
+/**
+ * The account is frozen at once: it can no longer enter a project or change anything in one. The answer is 202 with `state` `checking` while the services holding data for the account are asked whether it can be closed. Poll `GET /account/v1/me/deletion` until `state` leaves `checking`, which normally takes a few seconds.
+ *
+ * - If any service refuses, the account returns to use, `state` becomes `none`, and `rejected_at` and `objections` say why.
+ * - Otherwise `state` becomes `scheduled`, and the account is deleted at `scheduled_at`, fifteen days after the request. The conditions are checked once more at that time.
+ *
+ * The deletion can be cancelled with `POST /account/v1/me:undelete` until `scheduled_at`, and not after. Once carried out it cannot be undone, and the same sign-in cannot register again. Any remaining balance and prepaid benefits are forfeited, which `acknowledge_forfeiture` confirms.
+ *
+ * Requesting again while a deletion is open returns it unchanged. Fails with 412 `USER_OWNS_PROJECTS` while `blocking_projects` is not empty, and with 401 `INSUFFICIENT_USER_AUTHENTICATION` unless the caller signed in within the last `meta.max_age` seconds; sign in again with that `max_age` and retry.
+ * @summary Request deletion of the current account
+ */
+export const requestAccountDeletion = async (params, options, fetchFn) => {
+    const res = await (fetchFn ?? fetch)(getRequestAccountDeletionUrl(params), {
+        ...options,
+        method: "DELETE",
+    });
+    const body = [204, 205, 304].includes(res.status) ? null : await res.text();
+    const data = body ? JSON.parse(body) : {};
+    return { data, status: res.status, headers: res.headers };
+};
+export const getGetAccountDeletionUrl = () => {
+    return `https://account.leaflow.cloud/account/v1/me/deletion`;
+};
+/**
+ * `state` is `none` while no deletion is open. `blocking_projects` lists the projects the caller still owns; a deletion cannot be requested while it is not empty, so each of them must be transferred or deleted first.
+ *
+ * Conditions held by other services, such as an unpaid balance or a billing account still paying for a project, are not listed here. Read them from those services before requesting; they are checked again after the request, and a refusal shows up in `rejected_at` and `objections`.
+ * @summary Get the deletion of the current account
+ */
+export const getAccountDeletion = async (options, fetchFn) => {
+    const res = await (fetchFn ?? fetch)(getGetAccountDeletionUrl(), {
+        ...options,
+        method: "GET",
+    });
+    const body = [204, 205, 304].includes(res.status) ? null : await res.text();
+    const data = body ? JSON.parse(body) : {};
+    return { data, status: res.status, headers: res.headers };
+};
+export const getCancelAccountDeletionUrl = () => {
+    return `https://account.leaflow.cloud/account/v1/me:undelete`;
+};
+/**
+ * Returns the account to use. Cancelling when no deletion is open returns `state` `none`. Fails with 409 `ACCOUNT_DELETION_NOT_CANCELLABLE` once `scheduled_at` has passed.
+ * @summary Cancel the deletion of the current account
+ */
+export const cancelAccountDeletion = async (options, fetchFn) => {
+    const res = await (fetchFn ?? fetch)(getCancelAccountDeletionUrl(), {
+        ...options,
+        method: "POST",
+    });
+    const body = [204, 205, 304].includes(res.status) ? null : await res.text();
+    const data = body ? JSON.parse(body) : {};
+    return { data, status: res.status, headers: res.headers };
+};
+export const getGetIdentityVerificationUrl = () => {
+    return `https://account.leaflow.cloud/account/v1/me/identity-verification`;
+};
+/**
+ * The status is `UNVERIFIED` rather than 404 when nothing has been submitted. The legal name and the document number appear in no response.
+ * @summary Get identity verification status
+ */
+export const getIdentityVerification = async (options, fetchFn) => {
+    const res = await (fetchFn ?? fetch)(getGetIdentityVerificationUrl(), {
+        ...options,
+        method: "GET",
+    });
+    const body = [204, 205, 304].includes(res.status) ? null : await res.text();
+    const data = body ? JSON.parse(body) : {};
+    return { data, status: res.status, headers: res.headers };
+};
+export const getSubmitIdentityVerificationUrl = () => {
+    return `https://account.leaflow.cloud/account/v1/me/identity-verification`;
+};
+/**
+ * A submission awaiting review, and an account already verified, are both refused. A rejected submission may be corrected and sent again.
+ * @summary Submit identity verification
+ */
+export const submitIdentityVerification = async (submitIdentityVerificationRequestBody, options, fetchFn) => {
+    const getHeaders = (h) => {
+        if (!h)
+            return {};
+        if (h instanceof Headers)
+            return Object.fromEntries(h.entries());
+        if (Symbol.iterator in h) {
+            return Object.fromEntries(Array.from(h, (entry) => Array.from(entry)));
+        }
+        const headers = {};
+        for (const [name, value] of Object.entries(h)) {
+            if (value !== undefined)
+                headers[name] = value;
+        }
+        return headers;
+    };
+    const res = await (fetchFn ?? fetch)(getSubmitIdentityVerificationUrl(), {
+        ...options,
+        method: "POST",
+        headers: { "Content-Type": "application/json", ...getHeaders(options?.headers) },
+        body: JSON.stringify(submitIdentityVerificationRequestBody),
+    });
+    const body = [204, 205, 304].includes(res.status) ? null : await res.text();
+    const data = body ? JSON.parse(body) : {};
+    return { data, status: res.status, headers: res.headers };
+};
+export const getListMyInvitationsUrl = (params) => {
+    const normalizedParams = new URLSearchParams();
+    Object.entries(params || {}).forEach(([key, value]) => {
+        if (value !== undefined) {
+            normalizedParams.append(key, value === null ? "null" : String(value));
+        }
+    });
+    const stringifiedParams = normalizedParams.toString();
+    return stringifiedParams.length > 0
+        ? `https://account.leaflow.cloud/account/v1/me/invitations?${stringifiedParams}`
+        : `https://account.leaflow.cloud/account/v1/me/invitations`;
+};
+/**
+ * Matched against the email address of the current account.
+ * @summary List invitations addressed to the caller
+ */
+export const listMyInvitations = async (params, options, fetchFn) => {
+    const res = await (fetchFn ?? fetch)(getListMyInvitationsUrl(params), {
+        ...options,
+        method: "GET",
+    });
+    const body = [204, 205, 304].includes(res.status) ? null : await res.text();
+    const data = body ? JSON.parse(body) : {};
+    return { data, status: res.status, headers: res.headers };
+};
+export const getPreviewInvitationByTokenUrl = (params) => {
+    const normalizedParams = new URLSearchParams();
+    Object.entries(params || {}).forEach(([key, value]) => {
+        if (value !== undefined) {
+            normalizedParams.append(key, value === null ? "null" : String(value));
+        }
+    });
+    const stringifiedParams = normalizedParams.toString();
+    return stringifiedParams.length > 0
+        ? `https://account.leaflow.cloud/account/v1/invitations/by-token?${stringifiedParams}`
+        : `https://account.leaflow.cloud/account/v1/invitations/by-token`;
+};
+/**
+ * No token required: whoever follows the link in an invitation email has usually not signed in, and may hold no account at all.
+ *
+ * The recipient address is masked (`t***@example.com`).
+ *
+ * A token that does not exist, one already redeemed, one revoked and one expired all answer the same 404.
+ * @summary Preview an invitation by its token
+ */
+export const previewInvitationByToken = async (params, options, fetchFn) => {
+    const res = await (fetchFn ?? fetch)(getPreviewInvitationByTokenUrl(params), {
+        ...options,
+        method: "GET",
+    });
+    const body = [204, 205, 304].includes(res.status) ? null : await res.text();
+    const data = body ? JSON.parse(body) : {};
+    return { data, status: res.status, headers: res.headers };
+};
+export const getAcceptInvitationByTokenUrl = () => {
+    return `https://account.leaflow.cloud/account/v1/me/invitations:accept`;
+};
+/**
+ * A token that does not match, and an invitation that no longer stands, answer the same way.
+ * @summary Accept an invitation by its token
+ */
+export const acceptInvitationByToken = async (acceptInvitationByTokenRequestBody, options, fetchFn) => {
+    const getHeaders = (h) => {
+        if (!h)
+            return {};
+        if (h instanceof Headers)
+            return Object.fromEntries(h.entries());
+        if (Symbol.iterator in h) {
+            return Object.fromEntries(Array.from(h, (entry) => Array.from(entry)));
+        }
+        const headers = {};
+        for (const [name, value] of Object.entries(h)) {
+            if (value !== undefined)
+                headers[name] = value;
+        }
+        return headers;
+    };
+    const res = await (fetchFn ?? fetch)(getAcceptInvitationByTokenUrl(), {
+        ...options,
+        method: "POST",
+        headers: { "Content-Type": "application/json", ...getHeaders(options?.headers) },
+        body: JSON.stringify(acceptInvitationByTokenRequestBody),
+    });
+    const body = [204, 205, 304].includes(res.status) ? null : await res.text();
+    const data = body ? JSON.parse(body) : {};
+    return { data, status: res.status, headers: res.headers };
+};
+export const getAcceptInvitationUrl = (invitationId) => {
+    return `https://account.leaflow.cloud/account/v1/me/invitations/${encodeURIComponent(String(invitationId))}:accept`;
+};
+/**
+ * No token is required; the invitation is addressed to the email address of the current account.
+ * @summary Accept an invitation listed against the caller
+ */
+export const acceptInvitation = async (invitationId, options, fetchFn) => {
+    const res = await (fetchFn ?? fetch)(getAcceptInvitationUrl(invitationId), {
+        ...options,
+        method: "POST",
+    });
+    const body = [204, 205, 304].includes(res.status) ? null : await res.text();
+    const data = body ? JSON.parse(body) : {};
+    return { data, status: res.status, headers: res.headers };
+};
+export const getListProjectsUrl = (params) => {
+    const normalizedParams = new URLSearchParams();
+    Object.entries(params || {}).forEach(([key, value]) => {
+        if (value !== undefined) {
+            normalizedParams.append(key, value === null ? "null" : String(value));
+        }
+    });
+    const stringifiedParams = normalizedParams.toString();
+    return stringifiedParams.length > 0
+        ? `https://account.leaflow.cloud/account/v1/projects?${stringifiedParams}`
+        : `https://account.leaflow.cloud/account/v1/projects`;
+};
+/**
+ * Superseded by `QUERY /account/v1/projects`, which filters by status and pages by page number. Projects whose deletion has finished are excluded unless `include_deleted` is true; projects being deleted are included.
+ * @deprecated
+ * @summary List the projects the caller belongs to
+ */
+export const listProjects = async (params, options, fetchFn) => {
+    const res = await (fetchFn ?? fetch)(getListProjectsUrl(params), {
+        ...options,
+        method: "GET",
+    });
+    const body = [204, 205, 304].includes(res.status) ? null : await res.text();
+    const data = body ? JSON.parse(body) : {};
+    return { data, status: res.status, headers: res.headers };
+};
+export const getSearchProjectsUrl = () => {
+    return `https://account.leaflow.cloud/account/v1/projects`;
+};
+/**
+ * Projects the caller belongs to, most recently created first. The conditions in the body are combined with AND. Without `statuses`, only active projects are returned; projects being deleted and deleted projects are returned only when asked for by status.
+ * @summary Search the projects the caller belongs to
+ */
+export const searchProjects = async (searchProjectsRequestBody, options, fetchFn) => {
+    const getHeaders = (h) => {
+        if (!h)
+            return {};
+        if (h instanceof Headers)
+            return Object.fromEntries(h.entries());
+        if (Symbol.iterator in h) {
+            return Object.fromEntries(Array.from(h, (entry) => Array.from(entry)));
+        }
+        const headers = {};
+        for (const [name, value] of Object.entries(h)) {
+            if (value !== undefined)
+                headers[name] = value;
+        }
+        return headers;
+    };
+    const res = await (fetchFn ?? fetch)(getSearchProjectsUrl(), {
+        ...options,
+        method: "QUERY",
+        headers: { "Content-Type": "application/json", ...getHeaders(options?.headers) },
+        body: JSON.stringify(searchProjectsRequestBody),
+    });
+    const body = [204, 205, 304].includes(res.status) ? null : await res.text();
+    const data = body ? JSON.parse(body) : {};
+    return { data, status: res.status, headers: res.headers };
+};
+export const getCreateProjectUrl = () => {
+    return `https://account.leaflow.cloud/account/v1/projects`;
+};
+/**
+ * The caller becomes its owner. The project is created with the built-in `OWNER` and `ADMIN` roles and a `member` role carrying no permissions.
+ *
+ * A custom `slug` may be chosen here; without one the slug is the new project's `id`. A custom slug is refused with:
+ *
+ * - 400 `PROJECT_SLUG_INVALID` when it does not follow the format described on `slug`;
+ * - 422 `PROJECT_SLUG_RESERVED` when the name is reserved;
+ * - 409 `PROJECT_SLUG_TAKEN` when another project, including a deleted one, holds it;
+ * - 429 `PROJECT_SLUG_CLAIM_RATE_LIMITED` when the account has attempted to claim custom slugs too often. Attempts count whether or not they succeed; creating a project without a custom slug does not count.
+ * @summary Create a project
+ */
+export const createProject = async (createProjectRequestBody, options, fetchFn) => {
+    const getHeaders = (h) => {
+        if (!h)
+            return {};
+        if (h instanceof Headers)
+            return Object.fromEntries(h.entries());
+        if (Symbol.iterator in h) {
+            return Object.fromEntries(Array.from(h, (entry) => Array.from(entry)));
+        }
+        const headers = {};
+        for (const [name, value] of Object.entries(h)) {
+            if (value !== undefined)
+                headers[name] = value;
+        }
+        return headers;
+    };
+    const res = await (fetchFn ?? fetch)(getCreateProjectUrl(), {
+        ...options,
+        method: "POST",
+        headers: { "Content-Type": "application/json", ...getHeaders(options?.headers) },
+        body: JSON.stringify(createProjectRequestBody),
+    });
+    const body = [204, 205, 304].includes(res.status) ? null : await res.text();
+    const data = body ? JSON.parse(body) : {};
+    return { data, status: res.status, headers: res.headers };
+};
+export const getGetProjectBySlugUrl = (slug) => {
+    return `https://account.leaflow.cloud/account/v1/projects/by-slug/${encodeURIComponent(String(slug))}`;
+};
+/**
+ * Returns a project the caller belongs to, found by an address label: a custom slug is compared exactly, and a label in the form of a project id finds the project with that id, whether or not it has since chosen a custom slug.
+ *
+ * A deleted project is returned, answering that it is gone. Fails with:
+ *
+ * - 400 `PROJECT_SLUG_INVALID` when the value cannot be a slug;
+ * - 404 `PROJECT_NOT_FOUND` when no project holds the slug;
+ * - 403 `PROJECT_MEMBERSHIP_REQUIRED` when the caller is not a member of the project;
+ * - 429 `PROJECT_SLUG_LOOKUP_RATE_LIMITED` when the account has looked up slugs too often. This operation shares its limit with `GET /account/v1/project-slugs/{slug}/availability`.
+ * @summary Get a project by its slug
+ */
+export const getProjectBySlug = async (slug, options, fetchFn) => {
+    const res = await (fetchFn ?? fetch)(getGetProjectBySlugUrl(slug), {
+        ...options,
+        method: "GET",
+    });
+    const body = [204, 205, 304].includes(res.status) ? null : await res.text();
+    const data = body ? JSON.parse(body) : {};
+    return { data, status: res.status, headers: res.headers };
+};
+export const getGetProjectUrl = (projectId) => {
+    return `https://account.leaflow.cloud/account/v1/projects/${encodeURIComponent(String(projectId))}`;
+};
+/**
+ * Returns a project the caller belongs to. A deleted project is returned, answering that it is gone. Fails with:
+ *
+ * - 404 `PROJECT_NOT_FOUND` when no project has the id;
+ * - 403 `PROJECT_MEMBERSHIP_REQUIRED` when the caller is not a member of the project.
+ * @summary Get a project
+ */
+export const getProject = async (projectId, options, fetchFn) => {
+    const res = await (fetchFn ?? fetch)(getGetProjectUrl(projectId), {
+        ...options,
+        method: "GET",
+    });
+    const body = [204, 205, 304].includes(res.status) ? null : await res.text();
+    const data = body ? JSON.parse(body) : {};
+    return { data, status: res.status, headers: res.headers };
+};
+export const getGetProjectSlugAvailabilityUrl = (slug) => {
+    return `https://account.leaflow.cloud/account/v1/project-slugs/${encodeURIComponent(String(slug))}/availability`;
+};
+/**
+ * Reports whether a custom slug can be chosen now. Nothing is reserved by asking: the slug is claimed only by creating a project with it or by setting it, either of which may still fail with 409 `PROJECT_SLUG_TAKEN`.
+ *
+ * Fails with:
+ *
+ * - 400 `PROJECT_SLUG_INVALID` when the value does not follow the format of a custom slug;
+ * - 429 `PROJECT_SLUG_LOOKUP_RATE_LIMITED` when the account has looked up slugs too often. This operation shares its limit with `GET /account/v1/projects/by-slug/{slug}`.
+ * @summary Check whether a custom slug can be chosen
+ */
+export const getProjectSlugAvailability = async (slug, options, fetchFn) => {
+    const res = await (fetchFn ?? fetch)(getGetProjectSlugAvailabilityUrl(slug), {
+        ...options,
+        method: "GET",
+    });
+    const body = [204, 205, 304].includes(res.status) ? null : await res.text();
+    const data = body ? JSON.parse(body) : {};
+    return { data, status: res.status, headers: res.headers };
+};
+export const getCreateScopedTokenUrl = (projectId) => {
+    return `https://account.leaflow.cloud/account/v1/projects/${encodeURIComponent(String(projectId))}/scoped-tokens`;
+};
+/**
+ * Once a project has been chosen, exchange the access token for a scoped token for that project.
+ *
+ * **Only an access token issued by auth.leaflow.net is accepted; a scoped token is not.** Once a scoped token has expired, obtain a fresh access token at auth.leaflow.net and call this endpoint again.
+ *
+ * The exchange confirms that the account is usable, that the project exists, and that the caller is a member of it. A caller who is not a member obtains no token.
+ *
+ * A scoped token states identity only — the user and the project — and **carries no permissions**. Permissions are evaluated on every request, so a change of role takes effect immediately rather than at the next expiry.
+ *
+ * A project that is suspended, banned or being deleted still issues tokens; those states restrict writes, and the project remains readable.
+ * @summary Exchange the access token for a scoped token
+ */
+export const createScopedToken = async (projectId, options, fetchFn) => {
+    const res = await (fetchFn ?? fetch)(getCreateScopedTokenUrl(projectId), {
+        ...options,
+        method: "POST",
+    });
+    const body = [204, 205, 304].includes(res.status) ? null : await res.text();
+    const data = body ? JSON.parse(body) : {};
+    return { data, status: res.status, headers: res.headers };
+};