@leaflow/sdk 0.106.0 → 0.107.0

package/dist/gen/notification/v1/functions.d.ts

@@ -0,0 +1,852 @@
+/**
+ * Generated by orval 🍺
+ * Do not edit manually.
+ * Leaflow Notification API
+ * Read the notifications this platform has sent you, and choose where each kind of notification
+ * is delivered.
+ *
+ * Every service on the platform reports events here rather than contacting you directly. This
+ * API is the single place where those events are read, and the single place where delivery is
+ * configured.
+ *
+ * ## Authentication
+ *
+ * Every request carries a scoped token; see the `bearerAuth` security scheme.
+ *
+ * **Neither the path nor the headers carry a `project_id`**: the current project is determined by
+ * the token. Listing operations return everything addressed to you across every project by
+ * default, because a notification is addressed to a person rather than to a project; pass
+ * `scope=current_project` to narrow the result to the project in the token.
+ *
+ * ## Conventions
+ *
+ * - **Notifications are typed, and the type determines who receives it.** A type such as
+ *   `compute.instance.provisioned` is addressed to whoever created the instance, while
+ *   `monitoring.alert.raised` is addressed to every member of the project. The full catalogue is
+ *   available from `GET /api/v1/notification-types` and is stable: a type identifier is never
+ *   reused for a different event.
+ * - **Text is rendered at read time from the language on your preferences.** Changing the
+ *   language changes the text of everything already in the inbox. Messages already delivered by
+ *   email or to an outbound channel are not rewritten, because they have already been sent.
+ * - **Times inside rendered text are stated in UTC and say so.** There is no time zone setting.
+ *   Clients that can determine the reader's time zone should present `created_at`, `occurred_at`
+ *   and the timestamps in `params` — all of which are RFC 3339 — in local time instead. Email
+ *   cannot do this, which is why the text it carries is explicit about being UTC.
+ * - **Some types must reach you, and those cannot be muted or removed from email.** They are
+ *   marked `mandatory` in the catalogue: types you would only find out about by signing in, when
+ *   not finding out costs you something — a suspension, a deletion, a credential that expires.
+ *   Everything else about them is still configurable, including adding channels of your own.
+ * - **Deleting a preference restores the default; it does not turn the type off.** To stop
+ *   receiving a type, set `muted` on it.
+ * - **Outbound channels deliver nothing until they are verified.** Registering a channel does not
+ *   contact it. Verification is a separate operation that sends one message, and only a channel
+ *   that has acknowledged it receives anything afterwards.
+ * - **Channel endpoints are never returned.** No operation, including the one that registers
+ *   them, returns the address that was submitted. A channel entered incorrectly must be deleted
+ *   and registered again.
+ *
+ * ## Rate and volume
+ *
+ * Delivery to outbound channels is limited per channel, and bursts of alerts about one server are
+ * summarised rather than sent individually. Nothing is summarised in the inbox: it always holds
+ * every notification. A notification that was summarised or suppressed is still readable here.
+ *
+ * ## One-time credentials
+ *
+ * Some notifications carry a reference to a credential rather than the credential itself — the
+ * initial password of a newly created instance, for example. That credential is readable exactly
+ * once, expires on its own, and is destroyed as soon as it has been read. Requesting it a second
+ * time returns `CREDENTIAL_TICKET_CONSUMED`.
+ * OpenAPI spec version: 1.0.0
+ */
+import type { AnnouncementListResource } from "./models/announcementListResource.js";
+import type { AnnouncementReadResultResource } from "./models/announcementReadResultResource.js";
+import type { AuthorizeRealtimeChannelRequestBody } from "./models/authorizeRealtimeChannelRequestBody.js";
+import type { ChannelListResponseBody } from "./models/channelListResponseBody.js";
+import type { ChannelResource } from "./models/channelResource.js";
+import type { ConfirmEmailOverrideRequestBody } from "./models/confirmEmailOverrideRequestBody.js";
+import type { CountUnreadNotificationsParams } from "./models/countUnreadNotificationsParams.js";
+import type { CreateChannelRequestBody } from "./models/createChannelRequestBody.js";
+import type { CredentialTicketResource } from "./models/credentialTicketResource.js";
+import type { DeleteTypePreferenceParams } from "./models/deleteTypePreferenceParams.js";
+import type { EmailOverrideCodeResource } from "./models/emailOverrideCodeResource.js";
+import type { Error } from "./models/error.js";
+import type { LengthAwarePageNotificationResource } from "./models/lengthAwarePageNotificationResource.js";
+import type { ListNotificationsParams } from "./models/listNotificationsParams.js";
+import type { ListTypePreferencesParams } from "./models/listTypePreferencesParams.js";
+import type { ListUserChannelsParams } from "./models/listUserChannelsParams.js";
+import type { MarkNotificationsReadRequestBody } from "./models/markNotificationsReadRequestBody.js";
+import type { NotificationResource } from "./models/notificationResource.js";
+import type { NotificationTypeListResponseBody } from "./models/notificationTypeListResponseBody.js";
+import type { PreferencesResource } from "./models/preferencesResource.js";
+import type { RealtimeAuthResource } from "./models/realtimeAuthResource.js";
+import type { RealtimeConnectionResource } from "./models/realtimeConnectionResource.js";
+import type { RevealedCredentialResource } from "./models/revealedCredentialResource.js";
+import type { TypePreferenceListResponseBody } from "./models/typePreferenceListResponseBody.js";
+import type { TypePreferenceResource } from "./models/typePreferenceResource.js";
+import type { UnreadCountResource } from "./models/unreadCountResource.js";
+import type { UpdateChannelRequestBody } from "./models/updateChannelRequestBody.js";
+import type { UpdatePreferencesRequestBody } from "./models/updatePreferencesRequestBody.js";
+import type { UpdateTypePreferenceParams } from "./models/updateTypePreferenceParams.js";
+import type { UpdateTypePreferenceRequestBody } from "./models/updateTypePreferenceRequestBody.js";
+export type HTTPStatusCode1xx = 100 | 101 | 102 | 103;
+export type HTTPStatusCode2xx = 200 | 201 | 202 | 203 | 204 | 205 | 206 | 207;
+export type HTTPStatusCode3xx = 300 | 301 | 302 | 303 | 304 | 305 | 307 | 308;
+export type HTTPStatusCode4xx = 400 | 401 | 402 | 403 | 404 | 405 | 406 | 407 | 408 | 409 | 410 | 411 | 412 | 413 | 414 | 415 | 416 | 417 | 418 | 419 | 420 | 421 | 422 | 423 | 424 | 426 | 428 | 429 | 431 | 451;
+export type HTTPStatusCode5xx = 500 | 501 | 502 | 503 | 504 | 505 | 507 | 511;
+export type HTTPStatusCodes = HTTPStatusCode1xx | HTTPStatusCode2xx | HTTPStatusCode3xx | HTTPStatusCode4xx | HTTPStatusCode5xx;
+export type listNotificationsResponse200 = {
+    data: LengthAwarePageNotificationResource;
+    status: 200;
+};
+export type listNotificationsResponseDefault = {
+    data: Error;
+    status: Exclude<HTTPStatusCodes, 200>;
+};
+export type listNotificationsResponseSuccess = listNotificationsResponse200 & {
+    headers: Headers;
+};
+export type listNotificationsResponseError = listNotificationsResponseDefault & {
+    headers: Headers;
+};
+export type listNotificationsResponse = listNotificationsResponseSuccess | listNotificationsResponseError;
+export declare const getListNotificationsUrl: (params?: ListNotificationsParams) => string;
+/**
+ * Returns notifications in reverse chronological order, newest first.
+ *
+ * Announcements are not in this list. They are one row for the whole platform rather than
+ * one per reader, so they are listed, read and counted by their own operations under
+ * `/api/v1/announcements`. `kind` is on every item here for clients that merge the two lists
+ * themselves, and it is `notification` for everything this operation returns.
+ * @summary List notifications addressed to you
+ */
+export declare const listNotifications: (params?: ListNotificationsParams, options?: RequestInit, fetchFn?: typeof globalThis.fetch) => Promise<listNotificationsResponse>;
+export type markNotificationsReadResponse200 = {
+    data: UnreadCountResource;
+    status: 200;
+};
+export type markNotificationsReadResponseDefault = {
+    data: Error;
+    status: Exclude<HTTPStatusCodes, 200>;
+};
+export type markNotificationsReadResponseSuccess = markNotificationsReadResponse200 & {
+    headers: Headers;
+};
+export type markNotificationsReadResponseError = markNotificationsReadResponseDefault & {
+    headers: Headers;
+};
+export type markNotificationsReadResponse = markNotificationsReadResponseSuccess | markNotificationsReadResponseError;
+export declare const getMarkNotificationsReadUrl: () => string;
+/**
+ * Marks every listed notification as read. Notifications already read are left alone, and the
+ * operation succeeds whether or not any of them changed.
+ *
+ * Passing an empty list marks everything currently unread as read.
+ * @summary Mark several notifications as read
+ */
+export declare const markNotificationsRead: (markNotificationsReadRequestBody: MarkNotificationsReadRequestBody, options?: RequestInit, fetchFn?: typeof globalThis.fetch) => Promise<markNotificationsReadResponse>;
+export type countUnreadNotificationsResponse200 = {
+    data: UnreadCountResource;
+    status: 200;
+};
+export type countUnreadNotificationsResponseDefault = {
+    data: Error;
+    status: Exclude<HTTPStatusCodes, 200>;
+};
+export type countUnreadNotificationsResponseSuccess = countUnreadNotificationsResponse200 & {
+    headers: Headers;
+};
+export type countUnreadNotificationsResponseError = countUnreadNotificationsResponseDefault & {
+    headers: Headers;
+};
+export type countUnreadNotificationsResponse = countUnreadNotificationsResponseSuccess | countUnreadNotificationsResponseError;
+export declare const getCountUnreadNotificationsUrl: (params?: CountUnreadNotificationsParams) => string;
+/**
+ * Returns the number of unread notifications. This is the value behind the badge in the
+ * console, and it is also carried on every realtime event, so it does not normally need to be
+ * requested on its own.
+ * @summary Count unread notifications
+ */
+export declare const countUnreadNotifications: (params?: CountUnreadNotificationsParams, options?: RequestInit, fetchFn?: typeof globalThis.fetch) => Promise<countUnreadNotificationsResponse>;
+export type getNotificationResponse200 = {
+    data: NotificationResource;
+    status: 200;
+};
+export type getNotificationResponseDefault = {
+    data: Error;
+    status: Exclude<HTTPStatusCodes, 200>;
+};
+export type getNotificationResponseSuccess = getNotificationResponse200 & {
+    headers: Headers;
+};
+export type getNotificationResponseError = getNotificationResponseDefault & {
+    headers: Headers;
+};
+export type getNotificationResponse = getNotificationResponseSuccess | getNotificationResponseError;
+export declare const getGetNotificationUrl: (notificationId: string) => string;
+/**
+ * A notification addressed to someone else returns `NOTIFICATION_NOT_FOUND`, the same answer
+ * as one that does not exist.
+ * @summary Get one notification
+ */
+export declare const getNotification: (notificationId: string, options?: RequestInit, fetchFn?: typeof globalThis.fetch) => Promise<getNotificationResponse>;
+export type markNotificationReadResponse200 = {
+    data: NotificationResource;
+    status: 200;
+};
+export type markNotificationReadResponseDefault = {
+    data: Error;
+    status: Exclude<HTTPStatusCodes, 200>;
+};
+export type markNotificationReadResponseSuccess = markNotificationReadResponse200 & {
+    headers: Headers;
+};
+export type markNotificationReadResponseError = markNotificationReadResponseDefault & {
+    headers: Headers;
+};
+export type markNotificationReadResponse = markNotificationReadResponseSuccess | markNotificationReadResponseError;
+export declare const getMarkNotificationReadUrl: (notificationId: string) => string;
+/**
+ * Marking a notification that is already read succeeds and changes nothing.
+ * @summary Mark one notification as read
+ */
+export declare const markNotificationRead: (notificationId: string, options?: RequestInit, fetchFn?: typeof globalThis.fetch) => Promise<markNotificationReadResponse>;
+export type markNotificationUnreadResponse200 = {
+    data: NotificationResource;
+    status: 200;
+};
+export type markNotificationUnreadResponseDefault = {
+    data: Error;
+    status: Exclude<HTTPStatusCodes, 200>;
+};
+export type markNotificationUnreadResponseSuccess = markNotificationUnreadResponse200 & {
+    headers: Headers;
+};
+export type markNotificationUnreadResponseError = markNotificationUnreadResponseDefault & {
+    headers: Headers;
+};
+export type markNotificationUnreadResponse = markNotificationUnreadResponseSuccess | markNotificationUnreadResponseError;
+export declare const getMarkNotificationUnreadUrl: (notificationId: string) => string;
+/**
+ * Puts it back in the unread count, which is what somebody wants after opening a thing by
+ * accident and needing it to stay in front of them.
+ *
+ * Marking one that is already unread succeeds and changes nothing.
+ * @summary Mark one notification as unread
+ */
+export declare const markNotificationUnread: (notificationId: string, options?: RequestInit, fetchFn?: typeof globalThis.fetch) => Promise<markNotificationUnreadResponse>;
+export type archiveNotificationResponse200 = {
+    data: NotificationResource;
+    status: 200;
+};
+export type archiveNotificationResponseDefault = {
+    data: Error;
+    status: Exclude<HTTPStatusCodes, 200>;
+};
+export type archiveNotificationResponseSuccess = archiveNotificationResponse200 & {
+    headers: Headers;
+};
+export type archiveNotificationResponseError = archiveNotificationResponseDefault & {
+    headers: Headers;
+};
+export type archiveNotificationResponse = archiveNotificationResponseSuccess | archiveNotificationResponseError;
+export declare const getArchiveNotificationUrl: (notificationId: string) => string;
+/**
+ * Archiving removes a notification from the default listing without deleting it; pass
+ * `include_archived` to see it again. Archiving also marks it read.
+ * @summary Archive one notification
+ */
+export declare const archiveNotification: (notificationId: string, options?: RequestInit, fetchFn?: typeof globalThis.fetch) => Promise<archiveNotificationResponse>;
+export type unarchiveNotificationResponse200 = {
+    data: NotificationResource;
+    status: 200;
+};
+export type unarchiveNotificationResponseDefault = {
+    data: Error;
+    status: Exclude<HTTPStatusCodes, 200>;
+};
+export type unarchiveNotificationResponseSuccess = unarchiveNotificationResponse200 & {
+    headers: Headers;
+};
+export type unarchiveNotificationResponseError = unarchiveNotificationResponseDefault & {
+    headers: Headers;
+};
+export type unarchiveNotificationResponse = unarchiveNotificationResponseSuccess | unarchiveNotificationResponseError;
+export declare const getUnarchiveNotificationUrl: (notificationId: string) => string;
+/**
+ * Returns it to the default listing. Archiving is one click away from anything in the list,
+ * so undoing it has to be too; without this operation a mistaken archive is permanent, and
+ * the notification stays reachable only by asking for archived ones.
+ *
+ * It does not mark it unread again: archiving marked it read, and that it was read is still
+ * true. Use `mark-notification-unread` for that.
+ *
+ * Unarchiving one that is not archived succeeds and changes nothing.
+ * @summary Take one notification out of the archive
+ */
+export declare const unarchiveNotification: (notificationId: string, options?: RequestInit, fetchFn?: typeof globalThis.fetch) => Promise<unarchiveNotificationResponse>;
+export type listAnnouncementsResponse200 = {
+    data: AnnouncementListResource;
+    status: 200;
+};
+export type listAnnouncementsResponseDefault = {
+    data: Error;
+    status: Exclude<HTTPStatusCodes, 200>;
+};
+export type listAnnouncementsResponseSuccess = listAnnouncementsResponse200 & {
+    headers: Headers;
+};
+export type listAnnouncementsResponseError = listAnnouncementsResponseDefault & {
+    headers: Headers;
+};
+export type listAnnouncementsResponse = listAnnouncementsResponseSuccess | listAnnouncementsResponseError;
+export declare const getListAnnouncementsUrl: () => string;
+/**
+ * Announcements the platform published for everyone, filtered to the ones you can still see:
+ * published, not expired, and targeted at you.
+ *
+ * They are not part of `GET /api/v1/notifications`. A notification is addressed to you and has
+ * a row per recipient; an announcement is one row for the whole platform and never fans out —
+ * a hundred thousand users would be a hundred thousand rows, and almost none of them would
+ * ever be read. Whether you have read one is recorded separately, so unread means "no such
+ * record" rather than "a record with a null timestamp".
+ *
+ * The list is short by design: expired announcements drop out of it. There is no paging.
+ *
+ * Text comes back in the language on your preferences. An announcement that has no text in
+ * that language falls back to the platform default — a readable announcement in the wrong
+ * language beats a blank title.
+ * @summary List platform announcements
+ */
+export declare const listAnnouncements: (options?: RequestInit, fetchFn?: typeof globalThis.fetch) => Promise<listAnnouncementsResponse>;
+export type readAllAnnouncementsResponse200 = {
+    data: AnnouncementReadResultResource;
+    status: 200;
+};
+export type readAllAnnouncementsResponseDefault = {
+    data: Error;
+    status: Exclude<HTTPStatusCodes, 200>;
+};
+export type readAllAnnouncementsResponseSuccess = readAllAnnouncementsResponse200 & {
+    headers: Headers;
+};
+export type readAllAnnouncementsResponseError = readAllAnnouncementsResponseDefault & {
+    headers: Headers;
+};
+export type readAllAnnouncementsResponse = readAllAnnouncementsResponseSuccess | readAllAnnouncementsResponseError;
+export declare const getReadAllAnnouncementsUrl: () => string;
+/**
+ * Idempotent. Announcements you had already read stay read, and the count only covers the ones this call changed.
+ * @summary Mark every visible announcement as read
+ */
+export declare const readAllAnnouncements: (options?: RequestInit, fetchFn?: typeof globalThis.fetch) => Promise<readAllAnnouncementsResponse>;
+export type readAnnouncementResponse204 = {
+    data: void;
+    status: 204;
+};
+export type readAnnouncementResponseDefault = {
+    data: Error;
+    status: Exclude<HTTPStatusCodes, 204>;
+};
+export type readAnnouncementResponseSuccess = readAnnouncementResponse204 & {
+    headers: Headers;
+};
+export type readAnnouncementResponseError = readAnnouncementResponseDefault & {
+    headers: Headers;
+};
+export type readAnnouncementResponse = readAnnouncementResponseSuccess | readAnnouncementResponseError;
+export declare const getReadAnnouncementUrl: (announcementId: string) => string;
+/**
+ * Idempotent: marking one twice is the same as marking it once. There is no way to mark it
+ * unread — having read something is a fact, not a state.
+ * @summary Mark one announcement as read
+ */
+export declare const readAnnouncement: (announcementId: string, options?: RequestInit, fetchFn?: typeof globalThis.fetch) => Promise<readAnnouncementResponse>;
+export type listNotificationTypesResponse200 = {
+    data: NotificationTypeListResponseBody;
+    status: 200;
+};
+export type listNotificationTypesResponseDefault = {
+    data: Error;
+    status: Exclude<HTTPStatusCodes, 200>;
+};
+export type listNotificationTypesResponseSuccess = listNotificationTypesResponse200 & {
+    headers: Headers;
+};
+export type listNotificationTypesResponseError = listNotificationTypesResponseDefault & {
+    headers: Headers;
+};
+export type listNotificationTypesResponse = listNotificationTypesResponseSuccess | listNotificationTypesResponseError;
+export declare const getListNotificationTypesUrl: () => string;
+/**
+ * The catalogue of everything this platform can notify about, with the default delivery for
+ * each type and whether it can be configured. It is the source for a settings interface.
+ *
+ * This operation does not require authentication: the catalogue is the same for everyone and
+ * describes the product rather than any account.
+ * @summary List every notification type
+ */
+export declare const listNotificationTypes: (options?: RequestInit, fetchFn?: typeof globalThis.fetch) => Promise<listNotificationTypesResponse>;
+export type getNotificationPreferencesResponse200 = {
+    data: PreferencesResource;
+    status: 200;
+};
+export type getNotificationPreferencesResponseDefault = {
+    data: Error;
+    status: Exclude<HTTPStatusCodes, 200>;
+};
+export type getNotificationPreferencesResponseSuccess = getNotificationPreferencesResponse200 & {
+    headers: Headers;
+};
+export type getNotificationPreferencesResponseError = getNotificationPreferencesResponseDefault & {
+    headers: Headers;
+};
+export type getNotificationPreferencesResponse = getNotificationPreferencesResponseSuccess | getNotificationPreferencesResponseError;
+export declare const getGetNotificationPreferencesUrl: () => string;
+/**
+ * Returns the account-wide settings: the language notifications are written in, the time zone
+ * times are stated in, and the address email is delivered to.
+ *
+ * A person who has never configured anything receives the defaults rather than an error.
+ * @summary Get your delivery preferences
+ */
+export declare const getNotificationPreferences: (options?: RequestInit, fetchFn?: typeof globalThis.fetch) => Promise<getNotificationPreferencesResponse>;
+export type updateNotificationPreferencesResponse200 = {
+    data: PreferencesResource;
+    status: 200;
+};
+export type updateNotificationPreferencesResponseDefault = {
+    data: Error;
+    status: Exclude<HTTPStatusCodes, 200>;
+};
+export type updateNotificationPreferencesResponseSuccess = updateNotificationPreferencesResponse200 & {
+    headers: Headers;
+};
+export type updateNotificationPreferencesResponseError = updateNotificationPreferencesResponseDefault & {
+    headers: Headers;
+};
+export type updateNotificationPreferencesResponse = updateNotificationPreferencesResponseSuccess | updateNotificationPreferencesResponseError;
+export declare const getUpdateNotificationPreferencesUrl: () => string;
+/**
+ * Fields that are omitted are left alone.
+ *
+ * Setting `email_override` records it as the pending address; nothing is sent to it until
+ * `send-email-override-code` is called, and email keeps going where it went before. Setting
+ * it to null clears the pending address and any address in use, returning delivery to the
+ * account address.
+ *
+ * An address is never used until somebody proves they can read it. Without that, anybody
+ * could point their own notifications at a stranger's mailbox, and the stranger would get
+ * mail about an account they have never heard of.
+ * @summary Update your delivery preferences
+ */
+export declare const updateNotificationPreferences: (updatePreferencesRequestBody: UpdatePreferencesRequestBody, options?: RequestInit, fetchFn?: typeof globalThis.fetch) => Promise<updateNotificationPreferencesResponse>;
+export type sendEmailOverrideCodeResponse200 = {
+    data: EmailOverrideCodeResource;
+    status: 200;
+};
+export type sendEmailOverrideCodeResponseDefault = {
+    data: Error;
+    status: Exclude<HTTPStatusCodes, 200>;
+};
+export type sendEmailOverrideCodeResponseSuccess = sendEmailOverrideCodeResponse200 & {
+    headers: Headers;
+};
+export type sendEmailOverrideCodeResponseError = sendEmailOverrideCodeResponseDefault & {
+    headers: Headers;
+};
+export type sendEmailOverrideCodeResponse = sendEmailOverrideCodeResponseSuccess | sendEmailOverrideCodeResponseError;
+export declare const getSendEmailOverrideCodeUrl: () => string;
+/**
+ * Emails a short code to the address waiting to be confirmed. That address receives this and
+ * nothing else; every other notification keeps going where it went before.
+ *
+ * The code stops working after a few minutes, and a wrong one can only be tried a handful of
+ * times before it is thrown away and a new one has to be sent. Both limits exist for the same
+ * reason: a six digit code is guessable if it lives forever and can be tried forever.
+ *
+ * Sending is rate limited per account and per destination address. The second limit is the one
+ * that matters to somebody who never asked to be involved: without it, this operation is a way
+ * to make the platform mail a stranger repeatedly.
+ * @summary Send a code to the pending address
+ */
+export declare const sendEmailOverrideCode: (options?: RequestInit, fetchFn?: typeof globalThis.fetch) => Promise<sendEmailOverrideCodeResponse>;
+export type cancelEmailOverrideResponse200 = {
+    data: PreferencesResource;
+    status: 200;
+};
+export type cancelEmailOverrideResponseDefault = {
+    data: Error;
+    status: Exclude<HTTPStatusCodes, 200>;
+};
+export type cancelEmailOverrideResponseSuccess = cancelEmailOverrideResponse200 & {
+    headers: Headers;
+};
+export type cancelEmailOverrideResponseError = cancelEmailOverrideResponseDefault & {
+    headers: Headers;
+};
+export type cancelEmailOverrideResponse = cancelEmailOverrideResponseSuccess | cancelEmailOverrideResponseError;
+export declare const getCancelEmailOverrideUrl: () => string;
+/**
+ * Drops the pending address and the code that was sent to it. Nothing else changes: an address
+ * that was already confirmed keeps receiving email.
+ *
+ * It exists because starting this and then changing your mind is ordinary, and the alternative
+ * is a settings page that shows an address waiting to be confirmed forever.
+ * @summary Give up on the pending address
+ */
+export declare const cancelEmailOverride: (options?: RequestInit, fetchFn?: typeof globalThis.fetch) => Promise<cancelEmailOverrideResponse>;
+export type confirmEmailOverrideResponse200 = {
+    data: PreferencesResource;
+    status: 200;
+};
+export type confirmEmailOverrideResponseDefault = {
+    data: Error;
+    status: Exclude<HTTPStatusCodes, 200>;
+};
+export type confirmEmailOverrideResponseSuccess = confirmEmailOverrideResponse200 & {
+    headers: Headers;
+};
+export type confirmEmailOverrideResponseError = confirmEmailOverrideResponseDefault & {
+    headers: Headers;
+};
+export type confirmEmailOverrideResponse = confirmEmailOverrideResponseSuccess | confirmEmailOverrideResponseError;
+export declare const getConfirmEmailOverrideUrl: () => string;
+/**
+ * A correct code moves the pending address into use: email starts going there instead of the
+ * account address, and the pending slot is emptied.
+ *
+ * A wrong code counts against the attempts on that code. Running out of attempts throws the
+ * code away, and a new one has to be sent; the pending address itself is kept, so nobody
+ * loses their place by mistyping.
+ * @summary Confirm the pending address with its code
+ */
+export declare const confirmEmailOverride: (confirmEmailOverrideRequestBody: ConfirmEmailOverrideRequestBody, options?: RequestInit, fetchFn?: typeof globalThis.fetch) => Promise<confirmEmailOverrideResponse>;
+export type listTypePreferencesResponse200 = {
+    data: TypePreferenceListResponseBody;
+    status: 200;
+};
+export type listTypePreferencesResponseDefault = {
+    data: Error;
+    status: Exclude<HTTPStatusCodes, 200>;
+};
+export type listTypePreferencesResponseSuccess = listTypePreferencesResponse200 & {
+    headers: Headers;
+};
+export type listTypePreferencesResponseError = listTypePreferencesResponseDefault & {
+    headers: Headers;
+};
+export type listTypePreferencesResponse = listTypePreferencesResponseSuccess | listTypePreferencesResponseError;
+export declare const getListTypePreferencesUrl: (params?: ListTypePreferencesParams) => string;
+/**
+ * Returns one entry per notification type, whether or not it has been configured. Entries
+ * that have never been configured are reported with `inherited: true` and carry the defaults
+ * from the catalogue.
+ *
+ * A preference applies either to one project or to every project. Both are returned; the one
+ * naming a project takes precedence for that project.
+ * @summary List your per-type preferences
+ */
+export declare const listTypePreferences: (params?: ListTypePreferencesParams, options?: RequestInit, fetchFn?: typeof globalThis.fetch) => Promise<listTypePreferencesResponse>;
+export type updateTypePreferenceResponse200 = {
+    data: TypePreferenceResource;
+    status: 200;
+};
+export type updateTypePreferenceResponseDefault = {
+    data: Error;
+    status: Exclude<HTTPStatusCodes, 200>;
+};
+export type updateTypePreferenceResponseSuccess = updateTypePreferenceResponse200 & {
+    headers: Headers;
+};
+export type updateTypePreferenceResponseError = updateTypePreferenceResponseDefault & {
+    headers: Headers;
+};
+export type updateTypePreferenceResponse = updateTypePreferenceResponseSuccess | updateTypePreferenceResponseError;
+export declare const getUpdateTypePreferenceUrl: (type: string, params?: UpdateTypePreferenceParams) => string;
+/**
+ * States how this type should be delivered, replacing whatever was configured before.
+ *
+ * Omitting `project_id` configures every project. Naming one configures that project alone
+ * and takes precedence there.
+ *
+ * On a type marked `mandatory`, setting `muted` or omitting `email` from `channels` returns
+ * `NOTIFICATION_TYPE_MANDATORY`. Everything else about such a type is configurable, including
+ * adding channels and raising `min_severity`.
+ *
+ * Naming a channel the type does not support returns `NOTIFICATION_CHANNEL_UNSUPPORTED`.
+ * `inbox` is accepted but has no effect: every notification is in the inbox regardless.
+ * @summary Set the preference for one type
+ */
+export declare const updateTypePreference: (type: string, updateTypePreferenceRequestBody: UpdateTypePreferenceRequestBody, params?: UpdateTypePreferenceParams, options?: RequestInit, fetchFn?: typeof globalThis.fetch) => Promise<updateTypePreferenceResponse>;
+export type deleteTypePreferenceResponse204 = {
+    data: void;
+    status: 204;
+};
+export type deleteTypePreferenceResponseDefault = {
+    data: Error;
+    status: Exclude<HTTPStatusCodes, 204>;
+};
+export type deleteTypePreferenceResponseSuccess = deleteTypePreferenceResponse204 & {
+    headers: Headers;
+};
+export type deleteTypePreferenceResponseError = deleteTypePreferenceResponseDefault & {
+    headers: Headers;
+};
+export type deleteTypePreferenceResponse = deleteTypePreferenceResponseSuccess | deleteTypePreferenceResponseError;
+export declare const getDeleteTypePreferenceUrl: (type: string, params?: DeleteTypePreferenceParams) => string;
+/**
+ * Removes the configured preference so the type follows the default in the catalogue again.
+ *
+ * **This does not stop the type from being delivered.** To stop receiving it, set `muted`
+ * instead. Deleting a preference that was never configured succeeds and changes nothing.
+ * @summary Restore the default for one type
+ */
+export declare const deleteTypePreference: (type: string, params?: DeleteTypePreferenceParams, options?: RequestInit, fetchFn?: typeof globalThis.fetch) => Promise<deleteTypePreferenceResponse>;
+export type listUserChannelsResponse200 = {
+    data: ChannelListResponseBody;
+    status: 200;
+};
+export type listUserChannelsResponseDefault = {
+    data: Error;
+    status: Exclude<HTTPStatusCodes, 200>;
+};
+export type listUserChannelsResponseSuccess = listUserChannelsResponse200 & {
+    headers: Headers;
+};
+export type listUserChannelsResponseError = listUserChannelsResponseDefault & {
+    headers: Headers;
+};
+export type listUserChannelsResponse = listUserChannelsResponseSuccess | listUserChannelsResponseError;
+export declare const getListUserChannelsUrl: (params?: ListUserChannelsParams) => string;
+/**
+ * Returns the channels you have registered, and the channels registered for the project in
+ * the token. The address of each is not included.
+ * @summary List outbound channels
+ */
+export declare const listUserChannels: (params?: ListUserChannelsParams, options?: RequestInit, fetchFn?: typeof globalThis.fetch) => Promise<listUserChannelsResponse>;
+export type createUserChannelResponse201 = {
+    data: ChannelResource;
+    status: 201;
+};
+export type createUserChannelResponseDefault = {
+    data: Error;
+    status: Exclude<HTTPStatusCodes, 201>;
+};
+export type createUserChannelResponseSuccess = createUserChannelResponse201 & {
+    headers: Headers;
+};
+export type createUserChannelResponseError = createUserChannelResponseDefault & {
+    headers: Headers;
+};
+export type createUserChannelResponse = createUserChannelResponseSuccess | createUserChannelResponseError;
+export declare const getCreateUserChannelUrl: () => string;
+/**
+ * Registering a channel does not contact it and does not make it deliver anything: a new
+ * channel is unverified, and unverified channels are skipped. Call verify to send it one
+ * message and make it usable.
+ *
+ * A `project` channel is shared with everyone in the project and requires
+ * `notification:channels.manage`. A `user` channel is yours alone.
+ *
+ * The endpoint must be reachable over the public internet. Addresses that resolve to private
+ * or link-local ranges are rejected with `CHANNEL_ENDPOINT_NOT_PUBLIC`, both here and again
+ * at delivery time. Registering an endpoint already registered in the same scope returns
+ * `CHANNEL_DUPLICATE`.
+ *
+ * The submitted endpoint is not returned by this or any other operation.
+ * @summary Register an outbound channel
+ */
+export declare const createUserChannel: (createChannelRequestBody: CreateChannelRequestBody, options?: RequestInit, fetchFn?: typeof globalThis.fetch) => Promise<createUserChannelResponse>;
+export type updateUserChannelResponse200 = {
+    data: ChannelResource;
+    status: 200;
+};
+export type updateUserChannelResponseDefault = {
+    data: Error;
+    status: Exclude<HTTPStatusCodes, 200>;
+};
+export type updateUserChannelResponseSuccess = updateUserChannelResponse200 & {
+    headers: Headers;
+};
+export type updateUserChannelResponseError = updateUserChannelResponseDefault & {
+    headers: Headers;
+};
+export type updateUserChannelResponse = updateUserChannelResponseSuccess | updateUserChannelResponseError;
+export declare const getUpdateUserChannelUrl: (channelId: string) => string;
+/**
+ * Fields that are omitted are left alone.
+ *
+ * A channel disabled after repeated failures is re-enabled by setting `enabled` to true,
+ * which also clears the failure count. It remains verified, so it starts delivering again
+ * immediately — verify it first if the cause of the failures is not known to be resolved.
+ *
+ * Changing the endpoint is not possible; register a new channel and delete this one.
+ * @summary Rename or re-enable an outbound channel
+ */
+export declare const updateUserChannel: (channelId: string, updateChannelRequestBody: UpdateChannelRequestBody, options?: RequestInit, fetchFn?: typeof globalThis.fetch) => Promise<updateUserChannelResponse>;
+export type deleteUserChannelResponse204 = {
+    data: void;
+    status: 204;
+};
+export type deleteUserChannelResponseDefault = {
+    data: Error;
+    status: Exclude<HTTPStatusCodes, 204>;
+};
+export type deleteUserChannelResponseSuccess = deleteUserChannelResponse204 & {
+    headers: Headers;
+};
+export type deleteUserChannelResponseError = deleteUserChannelResponseDefault & {
+    headers: Headers;
+};
+export type deleteUserChannelResponse = deleteUserChannelResponseSuccess | deleteUserChannelResponseError;
+export declare const getDeleteUserChannelUrl: (channelId: string) => string;
+/**
+ * Deleting a channel stops delivery to it and destroys the stored endpoint. Deliveries
+ * already queued for it are abandoned.
+ * @summary Delete an outbound channel
+ */
+export declare const deleteUserChannel: (channelId: string, options?: RequestInit, fetchFn?: typeof globalThis.fetch) => Promise<deleteUserChannelResponse>;
+export type verifyUserChannelResponse200 = {
+    data: ChannelResource;
+    status: 200;
+};
+export type verifyUserChannelResponseDefault = {
+    data: Error;
+    status: Exclude<HTTPStatusCodes, 200>;
+};
+export type verifyUserChannelResponseSuccess = verifyUserChannelResponse200 & {
+    headers: Headers;
+};
+export type verifyUserChannelResponseError = verifyUserChannelResponseDefault & {
+    headers: Headers;
+};
+export type verifyUserChannelResponse = verifyUserChannelResponseSuccess | verifyUserChannelResponseError;
+export declare const getVerifyUserChannelUrl: (channelId: string) => string;
+/**
+ * Sends one message to the channel and marks it verified if the endpoint accepted it.
+ *
+ * **The endpoint accepting the message is not proof that it arrived where it was meant to.**
+ * A webhook URL belonging to the wrong group answers exactly the same way. Confirm the
+ * message appeared before relying on the channel.
+ *
+ * A channel that fails verification is not marked verified and continues to be skipped. The
+ * reason is reported in `last_error`; it is the provider's own wording and is not translated.
+ * @summary Verify an outbound channel
+ */
+export declare const verifyUserChannel: (channelId: string, options?: RequestInit, fetchFn?: typeof globalThis.fetch) => Promise<verifyUserChannelResponse>;
+export type describeCredentialTicketResponse200 = {
+    data: CredentialTicketResource;
+    status: 200;
+};
+export type describeCredentialTicketResponseDefault = {
+    data: Error;
+    status: Exclude<HTTPStatusCodes, 200>;
+};
+export type describeCredentialTicketResponseSuccess = describeCredentialTicketResponse200 & {
+    headers: Headers;
+};
+export type describeCredentialTicketResponseError = describeCredentialTicketResponseDefault & {
+    headers: Headers;
+};
+export type describeCredentialTicketResponse = describeCredentialTicketResponseSuccess | describeCredentialTicketResponseError;
+export declare const getDescribeCredentialTicketUrl: (ticketId: string) => string;
+/**
+ * Reports whether the credential is still available without consuming it. It never contains
+ * the credential itself.
+ *
+ * A ticket addressed to someone else returns `CREDENTIAL_TICKET_NOT_FOUND`, the same answer
+ * as one that does not exist.
+ * @summary Describe a one-time credential
+ */
+export declare const describeCredentialTicket: (ticketId: string, options?: RequestInit, fetchFn?: typeof globalThis.fetch) => Promise<describeCredentialTicketResponse>;
+export type revealCredentialResponse200 = {
+    data: RevealedCredentialResource;
+    status: 200;
+};
+export type revealCredentialResponseDefault = {
+    data: Error;
+    status: Exclude<HTTPStatusCodes, 200>;
+};
+export type revealCredentialResponseSuccess = revealCredentialResponse200 & {
+    headers: Headers;
+};
+export type revealCredentialResponseError = revealCredentialResponseDefault & {
+    headers: Headers;
+};
+export type revealCredentialResponse = revealCredentialResponseSuccess | revealCredentialResponseError;
+export declare const getRevealCredentialUrl: (ticketId: string) => string;
+/**
+ * Returns the credential and destroys it in the same step. **This is the only operation that
+ * ever returns it, and it succeeds only once.**
+ *
+ * Every subsequent request returns `CREDENTIAL_TICKET_CONSUMED`, including one issued
+ * concurrently with the first: exactly one caller receives the credential.
+ *
+ * A ticket that has expired returns `CREDENTIAL_TICKET_EXPIRED`, and one withdrawn by the
+ * service that created it returns `CREDENTIAL_TICKET_REVOKED`. In all three cases the
+ * credential is already gone and cannot be recovered; obtain a new one from the service that
+ * owns the resource.
+ *
+ * This operation is a POST rather than a GET because a GET would be followed by link
+ * scanners in mail clients and by browser prefetching, either of which would consume the
+ * credential before the recipient opened it.
+ * @summary Reveal a one-time credential
+ */
+export declare const revealCredential: (ticketId: string, options?: RequestInit, fetchFn?: typeof globalThis.fetch) => Promise<revealCredentialResponse>;
+export type describeRealtimeConnectionResponse200 = {
+    data: RealtimeConnectionResource;
+    status: 200;
+};
+export type describeRealtimeConnectionResponseDefault = {
+    data: Error;
+    status: Exclude<HTTPStatusCodes, 200>;
+};
+export type describeRealtimeConnectionResponseSuccess = describeRealtimeConnectionResponse200 & {
+    headers: Headers;
+};
+export type describeRealtimeConnectionResponseError = describeRealtimeConnectionResponseDefault & {
+    headers: Headers;
+};
+export type describeRealtimeConnectionResponse = describeRealtimeConnectionResponseSuccess | describeRealtimeConnectionResponseError;
+export declare const getDescribeRealtimeConnectionUrl: () => string;
+/**
+ * Returns everything needed to open a realtime connection, and the names of the channels to
+ * subscribe to. The parameters are not constants: they differ between environments, so they
+ * must be requested rather than compiled in.
+ *
+ * Realtime delivery is an optimisation. Everything it announces is also readable through the
+ * listing operations, so a client that cannot connect stays correct by polling or by
+ * refreshing.
+ * @summary Describe the realtime connection
+ */
+export declare const describeRealtimeConnection: (options?: RequestInit, fetchFn?: typeof globalThis.fetch) => Promise<describeRealtimeConnectionResponse>;
+export type authorizeRealtimeChannelResponse200 = {
+    data: RealtimeAuthResource;
+    status: 200;
+};
+export type authorizeRealtimeChannelResponseDefault = {
+    data: Error;
+    status: Exclude<HTTPStatusCodes, 200>;
+};
+export type authorizeRealtimeChannelResponseSuccess = authorizeRealtimeChannelResponse200 & {
+    headers: Headers;
+};
+export type authorizeRealtimeChannelResponseError = authorizeRealtimeChannelResponseDefault & {
+    headers: Headers;
+};
+export type authorizeRealtimeChannelResponse = authorizeRealtimeChannelResponseSuccess | authorizeRealtimeChannelResponseError;
+export declare const getAuthorizeRealtimeChannelUrl: () => string;
+/**
+ * Authorizes one subscription. Realtime clients call this on their own while subscribing; it
+ * is not normally called directly.
+ *
+ * Only two channels are authorized: the one naming you, and the one naming the project in
+ * the token. Any other channel returns `REALTIME_CHANNEL_FORBIDDEN`.
+ *
+ * **Authorization is evaluated once, when the subscription is established.** A subscription
+ * already open is not revoked when project membership changes, so realtime events carry
+ * identifiers and counts only, never the contents of a notification.
+ * @summary Authorize a realtime channel subscription
+ */
+export declare const authorizeRealtimeChannel: (authorizeRealtimeChannelRequestBody: AuthorizeRealtimeChannelRequestBody, options?: RequestInit, fetchFn?: typeof globalThis.fetch) => Promise<authorizeRealtimeChannelResponse>;