@leaflow/sdk 0.0.0-dev.101.g01ce843

package/dist/notification/v1/schema.d.ts

@@ -0,0 +1,2038 @@
+/**
+ * This file was auto-generated by openapi-typescript.
+ * Do not make direct changes to the file.
+ */
+export interface paths {
+    "/api/v1/notifications": {
+        parameters: {
+            query?: never;
+            header?: never;
+            path?: never;
+            cookie?: never;
+        };
+        /**
+         * List notifications addressed to you
+         * @description 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.
+         */
+        get: operations["list-notifications"];
+        put?: never;
+        post?: never;
+        delete?: never;
+        options?: never;
+        head?: never;
+        patch?: never;
+        trace?: never;
+    };
+    "/api/v1/notifications/read": {
+        parameters: {
+            query?: never;
+            header?: never;
+            path?: never;
+            cookie?: never;
+        };
+        get?: never;
+        put?: never;
+        /**
+         * Mark several notifications as read
+         * @description 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.
+         */
+        post: operations["mark-notifications-read"];
+        delete?: never;
+        options?: never;
+        head?: never;
+        patch?: never;
+        trace?: never;
+    };
+    "/api/v1/notifications/unread-count": {
+        parameters: {
+            query?: never;
+            header?: never;
+            path?: never;
+            cookie?: never;
+        };
+        /**
+         * Count unread notifications
+         * @description 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.
+         */
+        get: operations["count-unread-notifications"];
+        put?: never;
+        post?: never;
+        delete?: never;
+        options?: never;
+        head?: never;
+        patch?: never;
+        trace?: never;
+    };
+    "/api/v1/notifications/{notificationId}": {
+        parameters: {
+            query?: never;
+            header?: never;
+            path?: never;
+            cookie?: never;
+        };
+        /**
+         * Get one notification
+         * @description A notification addressed to someone else returns `NOTIFICATION_NOT_FOUND`, the same answer
+         *     as one that does not exist.
+         */
+        get: operations["get-notification"];
+        put?: never;
+        post?: never;
+        delete?: never;
+        options?: never;
+        head?: never;
+        patch?: never;
+        trace?: never;
+    };
+    "/api/v1/notifications/{notificationId}/read": {
+        parameters: {
+            query?: never;
+            header?: never;
+            path?: never;
+            cookie?: never;
+        };
+        get?: never;
+        put?: never;
+        /**
+         * Mark one notification as read
+         * @description Marking a notification that is already read succeeds and changes nothing.
+         */
+        post: operations["mark-notification-read"];
+        /**
+         * Mark one notification as unread
+         * @description 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.
+         */
+        delete: operations["mark-notification-unread"];
+        options?: never;
+        head?: never;
+        patch?: never;
+        trace?: never;
+    };
+    "/api/v1/notifications/{notificationId}/archive": {
+        parameters: {
+            query?: never;
+            header?: never;
+            path?: never;
+            cookie?: never;
+        };
+        get?: never;
+        put?: never;
+        /**
+         * Archive one notification
+         * @description Archiving removes a notification from the default listing without deleting it; pass
+         *     `include_archived` to see it again. Archiving also marks it read.
+         */
+        post: operations["archive-notification"];
+        /**
+         * Take one notification out of the archive
+         * @description 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.
+         */
+        delete: operations["unarchive-notification"];
+        options?: never;
+        head?: never;
+        patch?: never;
+        trace?: never;
+    };
+    "/api/v1/announcements": {
+        parameters: {
+            query?: never;
+            header?: never;
+            path?: never;
+            cookie?: never;
+        };
+        /**
+         * List platform announcements
+         * @description 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.
+         */
+        get: operations["list-announcements"];
+        put?: never;
+        post?: never;
+        delete?: never;
+        options?: never;
+        head?: never;
+        patch?: never;
+        trace?: never;
+    };
+    "/api/v1/announcements/read": {
+        parameters: {
+            query?: never;
+            header?: never;
+            path?: never;
+            cookie?: never;
+        };
+        get?: never;
+        put?: never;
+        /**
+         * Mark every visible announcement as read
+         * @description Idempotent. Announcements you had already read stay read, and the count only covers the ones this call changed.
+         */
+        post: operations["read-all-announcements"];
+        delete?: never;
+        options?: never;
+        head?: never;
+        patch?: never;
+        trace?: never;
+    };
+    "/api/v1/announcements/{announcementId}/read": {
+        parameters: {
+            query?: never;
+            header?: never;
+            path?: never;
+            cookie?: never;
+        };
+        get?: never;
+        put?: never;
+        /**
+         * Mark one announcement as read
+         * @description 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.
+         */
+        post: operations["read-announcement"];
+        delete?: never;
+        options?: never;
+        head?: never;
+        patch?: never;
+        trace?: never;
+    };
+    "/api/v1/notification-types": {
+        parameters: {
+            query?: never;
+            header?: never;
+            path?: never;
+            cookie?: never;
+        };
+        /**
+         * List every notification type
+         * @description 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.
+         */
+        get: operations["list-notification-types"];
+        put?: never;
+        post?: never;
+        delete?: never;
+        options?: never;
+        head?: never;
+        patch?: never;
+        trace?: never;
+    };
+    "/api/v1/preferences": {
+        parameters: {
+            query?: never;
+            header?: never;
+            path?: never;
+            cookie?: never;
+        };
+        /**
+         * Get your delivery preferences
+         * @description 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.
+         */
+        get: operations["get-notification-preferences"];
+        put?: never;
+        post?: never;
+        delete?: never;
+        options?: never;
+        head?: never;
+        /**
+         * Update your delivery preferences
+         * @description 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.
+         */
+        patch: operations["update-notification-preferences"];
+        trace?: never;
+    };
+    "/api/v1/preferences/email-override/code": {
+        parameters: {
+            query?: never;
+            header?: never;
+            path?: never;
+            cookie?: never;
+        };
+        get?: never;
+        put?: never;
+        /**
+         * Send a code to the pending address
+         * @description 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.
+         */
+        post: operations["send-email-override-code"];
+        /**
+         * Give up on the pending address
+         * @description 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.
+         */
+        delete: operations["cancel-email-override"];
+        options?: never;
+        head?: never;
+        patch?: never;
+        trace?: never;
+    };
+    "/api/v1/preferences/email-override/code/confirm": {
+        parameters: {
+            query?: never;
+            header?: never;
+            path?: never;
+            cookie?: never;
+        };
+        get?: never;
+        put?: never;
+        /**
+         * Confirm the pending address with its code
+         * @description 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.
+         */
+        post: operations["confirm-email-override"];
+        delete?: never;
+        options?: never;
+        head?: never;
+        patch?: never;
+        trace?: never;
+    };
+    "/api/v1/preferences/types": {
+        parameters: {
+            query?: never;
+            header?: never;
+            path?: never;
+            cookie?: never;
+        };
+        /**
+         * List your per-type preferences
+         * @description 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.
+         */
+        get: operations["list-type-preferences"];
+        put?: never;
+        post?: never;
+        delete?: never;
+        options?: never;
+        head?: never;
+        patch?: never;
+        trace?: never;
+    };
+    "/api/v1/preferences/types/{type}": {
+        parameters: {
+            query?: never;
+            header?: never;
+            path?: never;
+            cookie?: never;
+        };
+        get?: never;
+        /**
+         * Set the preference for one type
+         * @description 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.
+         */
+        put: operations["update-type-preference"];
+        post?: never;
+        /**
+         * Restore the default for one type
+         * @description 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.
+         */
+        delete: operations["delete-type-preference"];
+        options?: never;
+        head?: never;
+        patch?: never;
+        trace?: never;
+    };
+    "/api/v1/channels": {
+        parameters: {
+            query?: never;
+            header?: never;
+            path?: never;
+            cookie?: never;
+        };
+        /**
+         * List outbound channels
+         * @description Returns the channels you have registered, and the channels registered for the project in
+         *     the token. The address of each is not included.
+         */
+        get: operations["list-user-channels"];
+        put?: never;
+        /**
+         * Register an outbound channel
+         * @description 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.
+         */
+        post: operations["create-user-channel"];
+        delete?: never;
+        options?: never;
+        head?: never;
+        patch?: never;
+        trace?: never;
+    };
+    "/api/v1/channels/{channelId}": {
+        parameters: {
+            query?: never;
+            header?: never;
+            path?: never;
+            cookie?: never;
+        };
+        get?: never;
+        put?: never;
+        post?: never;
+        /**
+         * Delete an outbound channel
+         * @description Deleting a channel stops delivery to it and destroys the stored endpoint. Deliveries
+         *     already queued for it are abandoned.
+         */
+        delete: operations["delete-user-channel"];
+        options?: never;
+        head?: never;
+        /**
+         * Rename or re-enable an outbound channel
+         * @description 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.
+         */
+        patch: operations["update-user-channel"];
+        trace?: never;
+    };
+    "/api/v1/channels/{channelId}/verify": {
+        parameters: {
+            query?: never;
+            header?: never;
+            path?: never;
+            cookie?: never;
+        };
+        get?: never;
+        put?: never;
+        /**
+         * Verify an outbound channel
+         * @description 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.
+         */
+        post: operations["verify-user-channel"];
+        delete?: never;
+        options?: never;
+        head?: never;
+        patch?: never;
+        trace?: never;
+    };
+    "/api/v1/credentials/{ticketId}": {
+        parameters: {
+            query?: never;
+            header?: never;
+            path?: never;
+            cookie?: never;
+        };
+        /**
+         * Describe a one-time credential
+         * @description 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.
+         */
+        get: operations["describe-credential-ticket"];
+        put?: never;
+        post?: never;
+        delete?: never;
+        options?: never;
+        head?: never;
+        patch?: never;
+        trace?: never;
+    };
+    "/api/v1/credentials/{ticketId}/reveal": {
+        parameters: {
+            query?: never;
+            header?: never;
+            path?: never;
+            cookie?: never;
+        };
+        get?: never;
+        put?: never;
+        /**
+         * Reveal a one-time credential
+         * @description 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.
+         */
+        post: operations["reveal-credential"];
+        delete?: never;
+        options?: never;
+        head?: never;
+        patch?: never;
+        trace?: never;
+    };
+    "/api/v1/realtime": {
+        parameters: {
+            query?: never;
+            header?: never;
+            path?: never;
+            cookie?: never;
+        };
+        /**
+         * Describe the realtime connection
+         * @description 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.
+         */
+        get: operations["describe-realtime-connection"];
+        put?: never;
+        post?: never;
+        delete?: never;
+        options?: never;
+        head?: never;
+        patch?: never;
+        trace?: never;
+    };
+    "/api/v1/realtime/auth": {
+        parameters: {
+            query?: never;
+            header?: never;
+            path?: never;
+            cookie?: never;
+        };
+        get?: never;
+        put?: never;
+        /**
+         * Authorize a realtime channel subscription
+         * @description 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.
+         */
+        post: operations["authorize-realtime-channel"];
+        delete?: never;
+        options?: never;
+        head?: never;
+        patch?: never;
+        trace?: never;
+    };
+}
+export type webhooks = Record<string, never>;
+export interface components {
+    schemas: {
+        Error: {
+            code?: string;
+            message: string;
+            meta?: {
+                [key: string]: unknown;
+            };
+            /** Format: int64 */
+            status: number;
+        };
+        /**
+         * @description `all` covers every project you belong to as well as notifications that belong to no
+         *     project. `current_project` covers only the project in the token.
+         * @enum {string}
+         */
+        NotificationScope: "all" | "current_project";
+        /**
+         * @description How much attention a notification asks for. It is assigned by the type and by the event,
+         *     not by the recipient.
+         *
+         *     `critical` announces something that is either irreversible or actively costing the
+         *     recipient something.
+         * @enum {string}
+         */
+        NotificationSeverity: "info" | "warning" | "error" | "critical";
+        /**
+         * @description `notification` is addressed to you. `announcement` was published to the whole platform and
+         *     appears in everyone's inbox.
+         * @enum {string}
+         */
+        NotificationKind: "notification" | "announcement";
+        /**
+         * @description Where a notification is delivered.
+         *
+         *     `inbox` is this API. `email` is the address on your preferences. `webhook` covers every
+         *     outbound channel you have registered — the message is shaped for each one.
+         * @enum {string}
+         */
+        NotificationChannel: "inbox" | "email" | "webhook";
+        /**
+         * @description `user` is yours alone. `project` is shared with everyone in the project and requires
+         *     `notification:channels.manage` to register or delete.
+         * @enum {string}
+         */
+        ChannelScope: "user" | "project";
+        /**
+         * @description The kind of endpoint, which determines both how the message is shaped and what the
+         *     endpoint is.
+         *
+         *     `lark_webhook` and `wecom_webhook` are group robot webhook URLs and receive a card.
+         *     `bark` is a Bark server URL including the device key and receives a short line of text.
+         *     `generic_webhook` receives a JSON document and is the option for anything else.
+         * @enum {string}
+         */
+        ChannelKind: "lark_webhook" | "wecom_webhook" | "bark" | "generic_webhook";
+        /**
+         * @description Who a type is addressed to. It is a property of the type, so it is the same for every
+         *     occurrence.
+         *
+         *     `explicit` is whoever the reporting service names, usually the person who asked for the
+         *     action. `account` is one person, independently of any project. `address` is an email
+         *     address belonging to someone who may not have an account yet. `broadcast` is everyone.
+         * @enum {string}
+         */
+        NotificationAudience: "explicit" | "account" | "address" | "project_members" | "project_owner" | "project_admins" | "broadcast";
+        /** @description One announcement, with its text in the language on your preferences. */
+        AnnouncementResource: {
+            /** Format: uuid */
+            id: string;
+            title: string;
+            /** @description The text as a fragment of HTML, same rules as a notification body */
+            body: string;
+            severity: components["schemas"]["NotificationSeverity"];
+            /** @description You cannot dismiss this one. It is a property of the announcement rather than a second type, because what the operator judges when writing it is "is this important enough to push", and that is the question this asks. */
+            critical: boolean;
+            /** Format: date-time */
+            published_at: string;
+            /**
+             * Format: date-time
+             * @description When it drops out of this list; null means it stays
+             */
+            expires_at?: string | null;
+            /**
+             * Format: date-time
+             * @description When you read it; null means you have not
+             */
+            read_at?: string | null;
+        };
+        AnnouncementListResource: {
+            items: components["schemas"]["AnnouncementResource"][];
+            /** @description How many of them you have not read */
+            unread: number;
+        };
+        AnnouncementReadResultResource: {
+            /** @description How many this call changed; already-read ones are not counted */
+            marked: number;
+        };
+        /**
+         * @description One notification, with its text rendered in the language on your preferences at the moment
+         *     it was read.
+         */
+        NotificationResource: {
+            /**
+             * Format: date-time
+             * @description When you archived it; null if you did not
+             */
+            archived_at: string | null;
+            /** @description The text, as a fragment of HTML. Contains formatting and links, no scripts and no styles */
+            body: string;
+            /** @description The same text without markup, for clients that cannot render HTML */
+            body_text: string;
+            /** Format: date-time */
+            created_at: string;
+            /** Format: uuid */
+            id: string;
+            kind: components["schemas"]["NotificationKind"];
+            /** @description The language this text was rendered in */
+            locale: string;
+            /**
+             * Format: date-time
+             * @description When the event itself happened, which precedes created_at
+             */
+            occurred_at: string;
+            /**
+             * @description The facts the text was rendered from, for clients that want to link to the resource the
+             *     notification is about. The names are documented per type in the catalogue.
+             */
+            params: {
+                [key: string]: unknown;
+            };
+            /**
+             * Format: uuid
+             * @description The project the event belongs to; null for events that belong to no project
+             */
+            project_id: string | null;
+            /**
+             * Format: date-time
+             * @description When you read it; null if you have not
+             */
+            read_at: string | null;
+            severity: components["schemas"]["NotificationSeverity"];
+            /** @description A single line, without markup */
+            title: string;
+            /** @description The type identifier; empty for announcements, which have no type */
+            type: string;
+        };
+        LengthAwarePageNotificationResource: {
+            /** @description The contents of this page */
+            items: components["schemas"]["NotificationResource"][];
+            /**
+             * Format: int64
+             * @description Maximum items per page, echoing the value in the request
+             */
+            limit: number;
+            /**
+             * Format: int64
+             * @description Items skipped, echoing the value in the request
+             */
+            offset: number;
+            /**
+             * Format: int64
+             * @description Total number of matching items, not only those in this page
+             */
+            total: number;
+            /**
+             * Format: int64
+             * @description Unread notifications in the same scope, not only in this page
+             */
+            unread_count: number;
+        };
+        UnreadCountResource: {
+            /** Format: int64 */
+            unread_count: number;
+        };
+        /** @description An empty list marks everything currently unread as read. */
+        MarkNotificationsReadRequestBody: {
+            notification_ids: string[];
+        };
+        /** @description One entry in the catalogue of everything the platform can notify about. */
+        NotificationTypeDescriptor: {
+            audience: components["schemas"]["NotificationAudience"];
+            /** @description The channels this type may be delivered on. Configuring any other channel is rejected */
+            available_channels: components["schemas"]["NotificationChannel"][];
+            /** @description The channels this type is delivered on when nothing has been configured */
+            default_channels: components["schemas"]["NotificationChannel"][];
+            /**
+             * @description True when this type must reach you: it cannot be muted, and email cannot be removed
+             *     from its channels. Everything else about it is still configurable
+             */
+            mandatory: boolean;
+            /** @description The names of the facts this type carries, as they appear on NotificationResource.params */
+            params: string[];
+            /** @description The service that reports this type */
+            service: string;
+            severity: components["schemas"]["NotificationSeverity"];
+            type: string;
+        };
+        NotificationTypeListResponseBody: {
+            items: components["schemas"]["NotificationTypeDescriptor"][];
+        };
+        PreferencesResource: {
+            /** @description Where email is delivered right now, which is the account address unless a verified override replaces it */
+            email_address: string;
+            /**
+             * @description The address email goes to instead of the account address; null when the account address
+             *     is used. Only ever an address that was confirmed by code
+             */
+            email_override: string | null;
+            /**
+             * @description An address waiting to be confirmed; null when nothing is waiting. It receives nothing but
+             *     the code, and the address in `email_override` keeps being used until this one is
+             *     confirmed
+             */
+            email_override_pending: string | null;
+            /**
+             * Format: date-time
+             * @description When the code last sent to the pending address stops working; null when no code is
+             *     outstanding, in which case a new one has to be sent before it can be confirmed
+             */
+            email_override_pending_expires_at: string | null;
+            /**
+             * Format: date-time
+             * @description When the address in `email_override` was confirmed; null when there is no override
+             */
+            email_override_verified_at: string | null;
+            /** @description The language notifications are written in, as an IETF language tag */
+            locale: string;
+        };
+        /** @description Fields that are omitted are left alone. */
+        UpdatePreferencesRequestBody: {
+            /**
+             * @description An address to receive email instead of the account address. It is stored as pending and
+             *     receives nothing until it is confirmed by code, so the address in use does not change
+             *     here. Null clears both the pending address and the one in use, returning delivery to
+             *     the account address
+             */
+            email_override?: string | null;
+            /** @description An IETF language tag. A language that is not supported is rejected rather than approximated */
+            locale?: string;
+        };
+        /** @description What was sent, and when the next one may be asked for. */
+        EmailOverrideCodeResource: {
+            /** @description Where the code went. It is the pending address, echoed so a client can show it */
+            address: string;
+            /**
+             * Format: date-time
+             * @description When this code stops working
+             */
+            expires_at: string;
+            /**
+             * Format: date-time
+             * @description The earliest another code may be asked for. Asking sooner is refused rather than
+             *     silently ignored, so a client can show the wait instead of a failure
+             */
+            resend_available_at: string;
+        };
+        ConfirmEmailOverrideRequestBody: {
+            /** @description The code from the email, exactly as it appears there */
+            code: string;
+        };
+        TypePreferenceResource: {
+            /** @description Where this type is delivered */
+            channels: components["schemas"]["NotificationChannel"][];
+            /** @description True when nothing has been configured and these are the defaults from the catalogue */
+            inherited: boolean;
+            /** @description True when this type cannot be muted and email cannot be removed from it */
+            mandatory: boolean;
+            /**
+             * @description Deliver only at or above this severity. Null delivers every severity. It applies to the
+             *     channels named here and not to the inbox, which always holds everything
+             */
+            min_severity: components["schemas"]["NotificationSeverity"] | null;
+            /** @description True when this type is not delivered anywhere except the inbox */
+            muted: boolean;
+            /**
+             * Format: uuid
+             * @description The project this preference applies to; null when it applies to every project
+             */
+            project_id: string | null;
+            type: string;
+        };
+        TypePreferenceListResponseBody: {
+            items: components["schemas"]["TypePreferenceResource"][];
+        };
+        /** @description States how this type should be delivered, replacing whatever was configured before. */
+        UpdateTypePreferenceRequestBody: {
+            /**
+             * @description Where to deliver this type, beyond the inbox. An empty list delivers to the inbox only.
+             *     `inbox` may be listed and is accepted, but has no effect: every notification is in the
+             *     inbox whatever this says
+             */
+            channels: components["schemas"]["NotificationChannel"][];
+            /** @description Deliver only at or above this severity. Null delivers every severity */
+            min_severity?: components["schemas"]["NotificationSeverity"] | null;
+            /**
+             * @description Stop delivering this type anywhere except the inbox
+             * @default false
+             */
+            muted?: boolean;
+        };
+        /** @description A registered outbound channel. The endpoint itself is never included. */
+        ChannelResource: {
+            channel_scope: components["schemas"]["ChannelScope"];
+            /**
+             * Format: int64
+             * @description Deliveries that have failed in a row. Reset by a success, and by re-enabling the channel
+             */
+            consecutive_failures: number;
+            /** Format: date-time */
+            created_at: string;
+            /**
+             * Format: date-time
+             * @description When the channel was disabled after repeated failures; null if it is enabled
+             */
+            disabled_at: string | null;
+            /** @description Why it was disabled; null if it is enabled */
+            disabled_reason: string | null;
+            /** Format: uuid */
+            id: string;
+            kind: components["schemas"]["ChannelKind"];
+            /** @description Why the most recent attempt failed, in the endpoint's own wording; null if the most recent attempt succeeded */
+            last_error: string | null;
+            /** Format: date-time */
+            last_failure_at: string | null;
+            /** Format: date-time */
+            last_success_at: string | null;
+            name: string;
+            /**
+             * Format: uuid
+             * @description The project this channel is shared with; null for a channel of scope user
+             */
+            project_id: string | null;
+            /** @description A partially masked fragment of the endpoint, for visual identification only */
+            redacted: string;
+            /** Format: date-time */
+            updated_at: string;
+            /**
+             * Format: date-time
+             * @description When the endpoint last acknowledged a verification message; null while it never has, during which the channel is skipped
+             */
+            verified_at: string | null;
+        };
+        ChannelListResponseBody: {
+            items: components["schemas"]["ChannelResource"][];
+        };
+        CreateChannelRequestBody: {
+            channel_scope: components["schemas"]["ChannelScope"];
+            /**
+             * @description The address messages are sent to. It must be an https URL reachable over the public
+             *     internet.
+             *
+             *     For `lark_webhook` and `wecom_webhook` this is the group robot webhook URL. For `bark`
+             *     it is the push URL including the device key, such as
+             *     `https://api.day.app/your-device-key`. For `generic_webhook` it is any endpoint
+             *     accepting a JSON POST.
+             */
+            endpoint: string;
+            kind: components["schemas"]["ChannelKind"];
+            /** @description A display name for this channel */
+            name: string;
+            /**
+             * @description The signing secret, where the endpoint has one. It is required for a Lark group robot
+             *     configured with signature verification, and optional for `generic_webhook`, where it
+             *     signs the request so the receiver can confirm the message came from this platform.
+             *
+             *     It is not returned by any operation.
+             */
+            secret?: string;
+        };
+        /** @description Fields that are omitted are left alone. */
+        UpdateChannelRequestBody: {
+            /** @description Set true to re-enable a channel that was disabled after repeated failures, clearing the failure count */
+            enabled?: boolean;
+            name?: string;
+        };
+        /**
+         * @description What the credential belongs to.
+         * @enum {string}
+         */
+        CredentialSubjectKind: "compute_instance";
+        /** @description A one-time credential, described without being consumed. */
+        CredentialTicketResource: {
+            /**
+             * @description True when the credential can still be revealed. False once it has been revealed, has
+             *     expired, or was withdrawn — in all three cases it is already destroyed
+             */
+            available: boolean;
+            /**
+             * Format: date-time
+             * @description After this moment the credential is destroyed whether or not it was read
+             */
+            expires_at: string;
+            /** Format: uuid */
+            id: string;
+            /**
+             * Format: date-time
+             * @description When it was revealed; null if it has not been
+             */
+            revealed_at: string | null;
+            /**
+             * Format: date-time
+             * @description When the service that issued it withdrew it; null if it did not
+             */
+            revoked_at: string | null;
+            /** @description The resource the credential belongs to */
+            subject_id: string;
+            subject_kind: components["schemas"]["CredentialSubjectKind"];
+        };
+        /**
+         * @description The credential itself. This shape is returned by exactly one operation, and that operation
+         *     succeeds at most once per ticket.
+         */
+        RevealedCredentialResource: {
+            /** Format: date-time */
+            revealed_at: string;
+            /** @description The credential. It is destroyed as this response is produced and cannot be obtained again */
+            secret: string;
+            subject_id: string;
+            subject_kind: components["schemas"]["CredentialSubjectKind"];
+            /** @description The account the credential belongs to, where the resource has one; null otherwise */
+            username: string | null;
+        };
+        /**
+         * @description Everything needed to open a realtime connection. The connection speaks the Pusher channels
+         *     protocol, so any client library for it works.
+         */
+        RealtimeConnectionResource: {
+            /** @description The path a client posts to while subscribing, relative to this API */
+            auth_path: string;
+            /** @description The cluster name some client libraries require; empty when the deployment does not use one */
+            cluster: string;
+            /** @description False when realtime delivery is not configured in this deployment. Every other field is empty and clients should not attempt to connect */
+            enabled: boolean;
+            host: string;
+            /** @description The application key, which is public and identifies the deployment rather than the caller */
+            key: string;
+            /** Format: int64 */
+            port: number;
+            /**
+             * @description The channel carrying announcements. It is public: subscribing to it needs no
+             *     authorization, because an announcement is addressed to everybody. The events on it
+             *     carry an identifier and nothing else, so a client fetches the list and sees the
+             *     announcements it is entitled to
+             */
+            announcements_channel: string;
+            /** @description The channel carrying events about the project in the token; empty when the token names no project */
+            project_channel: string;
+            /** @description Whether to connect over TLS */
+            secure: boolean;
+            /** @description The channel carrying events addressed to you */
+            user_channel: string;
+        };
+        AuthorizeRealtimeChannelRequestBody: {
+            /** @description The channel being subscribed to */
+            channel_name: string;
+            /** @description The connection identifier the realtime server assigned to this client */
+            socket_id: string;
+        };
+        RealtimeAuthResource: {
+            /** @description The authorization token for this subscription, passed back to the realtime server by the client library */
+            auth: string;
+        };
+    };
+    responses: never;
+    parameters: {
+        /** @description The notification, or the announcement when kind is announcement */
+        NotificationId: string;
+        /** @description A notification type identifier, as listed by list-notification-types */
+        NotificationType: string;
+        /** @description Apply to this project alone; omit to apply to every project */
+        PreferenceProjectId: string;
+        /** @description The outbound channel */
+        ChannelId: string;
+        /** @description The one-time credential */
+        TicketId: string;
+    };
+    requestBodies: never;
+    headers: never;
+    pathItems: never;
+}
+export type $defs = Record<string, never>;
+export interface operations {
+    "list-notifications": {
+        parameters: {
+            query?: {
+                /** @description Maximum number of items to return in this page */
+                limit?: number;
+                /** @description Number of items to skip */
+                offset?: number;
+                /** @description Which projects to include; defaults to every project */
+                scope?: components["schemas"]["NotificationScope"];
+                /** @description Return only notifications of this type; omit for all types */
+                type?: string;
+                /** @description Return only notifications at or above this severity; omit for all severities */
+                min_severity?: components["schemas"]["NotificationSeverity"];
+                /** @description Restrict to unread, to read, or to neither; omit for both */
+                read?: boolean;
+                /** @description Include archived notifications; they are excluded by default */
+                include_archived?: boolean;
+            };
+            header?: never;
+            path?: never;
+            cookie?: never;
+        };
+        requestBody?: never;
+        responses: {
+            /** @description OK */
+            200: {
+                headers: {
+                    [name: string]: unknown;
+                };
+                content: {
+                    "application/json": components["schemas"]["LengthAwarePageNotificationResource"];
+                };
+            };
+            /** @description Error */
+            default: {
+                headers: {
+                    [name: string]: unknown;
+                };
+                content: {
+                    "application/json": components["schemas"]["Error"];
+                };
+            };
+        };
+    };
+    "mark-notifications-read": {
+        parameters: {
+            query?: never;
+            header?: never;
+            path?: never;
+            cookie?: never;
+        };
+        requestBody: {
+            content: {
+                "application/json": components["schemas"]["MarkNotificationsReadRequestBody"];
+            };
+        };
+        responses: {
+            /** @description OK */
+            200: {
+                headers: {
+                    [name: string]: unknown;
+                };
+                content: {
+                    "application/json": components["schemas"]["UnreadCountResource"];
+                };
+            };
+            /** @description Error */
+            default: {
+                headers: {
+                    [name: string]: unknown;
+                };
+                content: {
+                    "application/json": components["schemas"]["Error"];
+                };
+            };
+        };
+    };
+    "count-unread-notifications": {
+        parameters: {
+            query?: {
+                /** @description Which projects to include; defaults to every project */
+                scope?: components["schemas"]["NotificationScope"];
+            };
+            header?: never;
+            path?: never;
+            cookie?: never;
+        };
+        requestBody?: never;
+        responses: {
+            /** @description OK */
+            200: {
+                headers: {
+                    [name: string]: unknown;
+                };
+                content: {
+                    "application/json": components["schemas"]["UnreadCountResource"];
+                };
+            };
+            /** @description Error */
+            default: {
+                headers: {
+                    [name: string]: unknown;
+                };
+                content: {
+                    "application/json": components["schemas"]["Error"];
+                };
+            };
+        };
+    };
+    "get-notification": {
+        parameters: {
+            query?: never;
+            header?: never;
+            path: {
+                /** @description The notification, or the announcement when kind is announcement */
+                notificationId: components["parameters"]["NotificationId"];
+            };
+            cookie?: never;
+        };
+        requestBody?: never;
+        responses: {
+            /** @description OK */
+            200: {
+                headers: {
+                    [name: string]: unknown;
+                };
+                content: {
+                    "application/json": components["schemas"]["NotificationResource"];
+                };
+            };
+            /** @description Error */
+            default: {
+                headers: {
+                    [name: string]: unknown;
+                };
+                content: {
+                    "application/json": components["schemas"]["Error"];
+                };
+            };
+        };
+    };
+    "mark-notification-read": {
+        parameters: {
+            query?: never;
+            header?: never;
+            path: {
+                /** @description The notification, or the announcement when kind is announcement */
+                notificationId: components["parameters"]["NotificationId"];
+            };
+            cookie?: never;
+        };
+        requestBody?: never;
+        responses: {
+            /** @description OK */
+            200: {
+                headers: {
+                    [name: string]: unknown;
+                };
+                content: {
+                    "application/json": components["schemas"]["NotificationResource"];
+                };
+            };
+            /** @description Error */
+            default: {
+                headers: {
+                    [name: string]: unknown;
+                };
+                content: {
+                    "application/json": components["schemas"]["Error"];
+                };
+            };
+        };
+    };
+    "mark-notification-unread": {
+        parameters: {
+            query?: never;
+            header?: never;
+            path: {
+                /** @description The notification, or the announcement when kind is announcement */
+                notificationId: components["parameters"]["NotificationId"];
+            };
+            cookie?: never;
+        };
+        requestBody?: never;
+        responses: {
+            /** @description OK */
+            200: {
+                headers: {
+                    [name: string]: unknown;
+                };
+                content: {
+                    "application/json": components["schemas"]["NotificationResource"];
+                };
+            };
+            /** @description Error */
+            default: {
+                headers: {
+                    [name: string]: unknown;
+                };
+                content: {
+                    "application/json": components["schemas"]["Error"];
+                };
+            };
+        };
+    };
+    "archive-notification": {
+        parameters: {
+            query?: never;
+            header?: never;
+            path: {
+                /** @description The notification, or the announcement when kind is announcement */
+                notificationId: components["parameters"]["NotificationId"];
+            };
+            cookie?: never;
+        };
+        requestBody?: never;
+        responses: {
+            /** @description OK */
+            200: {
+                headers: {
+                    [name: string]: unknown;
+                };
+                content: {
+                    "application/json": components["schemas"]["NotificationResource"];
+                };
+            };
+            /** @description Error */
+            default: {
+                headers: {
+                    [name: string]: unknown;
+                };
+                content: {
+                    "application/json": components["schemas"]["Error"];
+                };
+            };
+        };
+    };
+    "unarchive-notification": {
+        parameters: {
+            query?: never;
+            header?: never;
+            path: {
+                /** @description The notification, or the announcement when kind is announcement */
+                notificationId: components["parameters"]["NotificationId"];
+            };
+            cookie?: never;
+        };
+        requestBody?: never;
+        responses: {
+            /** @description OK */
+            200: {
+                headers: {
+                    [name: string]: unknown;
+                };
+                content: {
+                    "application/json": components["schemas"]["NotificationResource"];
+                };
+            };
+            /** @description Error */
+            default: {
+                headers: {
+                    [name: string]: unknown;
+                };
+                content: {
+                    "application/json": components["schemas"]["Error"];
+                };
+            };
+        };
+    };
+    "list-announcements": {
+        parameters: {
+            query?: never;
+            header?: never;
+            path?: never;
+            cookie?: never;
+        };
+        requestBody?: never;
+        responses: {
+            /** @description OK */
+            200: {
+                headers: {
+                    [name: string]: unknown;
+                };
+                content: {
+                    "application/json": components["schemas"]["AnnouncementListResource"];
+                };
+            };
+            /** @description Error */
+            default: {
+                headers: {
+                    [name: string]: unknown;
+                };
+                content: {
+                    "application/json": components["schemas"]["Error"];
+                };
+            };
+        };
+    };
+    "read-all-announcements": {
+        parameters: {
+            query?: never;
+            header?: never;
+            path?: never;
+            cookie?: never;
+        };
+        requestBody?: never;
+        responses: {
+            /** @description OK */
+            200: {
+                headers: {
+                    [name: string]: unknown;
+                };
+                content: {
+                    "application/json": components["schemas"]["AnnouncementReadResultResource"];
+                };
+            };
+            /** @description Error */
+            default: {
+                headers: {
+                    [name: string]: unknown;
+                };
+                content: {
+                    "application/json": components["schemas"]["Error"];
+                };
+            };
+        };
+    };
+    "read-announcement": {
+        parameters: {
+            query?: never;
+            header?: never;
+            path: {
+                announcementId: string;
+            };
+            cookie?: never;
+        };
+        requestBody?: never;
+        responses: {
+            /** @description No Content */
+            204: {
+                headers: {
+                    [name: string]: unknown;
+                };
+                content?: never;
+            };
+            /** @description Error */
+            default: {
+                headers: {
+                    [name: string]: unknown;
+                };
+                content: {
+                    "application/json": components["schemas"]["Error"];
+                };
+            };
+        };
+    };
+    "list-notification-types": {
+        parameters: {
+            query?: never;
+            header?: never;
+            path?: never;
+            cookie?: never;
+        };
+        requestBody?: never;
+        responses: {
+            /** @description OK */
+            200: {
+                headers: {
+                    [name: string]: unknown;
+                };
+                content: {
+                    "application/json": components["schemas"]["NotificationTypeListResponseBody"];
+                };
+            };
+            /** @description Error */
+            default: {
+                headers: {
+                    [name: string]: unknown;
+                };
+                content: {
+                    "application/json": components["schemas"]["Error"];
+                };
+            };
+        };
+    };
+    "get-notification-preferences": {
+        parameters: {
+            query?: never;
+            header?: never;
+            path?: never;
+            cookie?: never;
+        };
+        requestBody?: never;
+        responses: {
+            /** @description OK */
+            200: {
+                headers: {
+                    [name: string]: unknown;
+                };
+                content: {
+                    "application/json": components["schemas"]["PreferencesResource"];
+                };
+            };
+            /** @description Error */
+            default: {
+                headers: {
+                    [name: string]: unknown;
+                };
+                content: {
+                    "application/json": components["schemas"]["Error"];
+                };
+            };
+        };
+    };
+    "update-notification-preferences": {
+        parameters: {
+            query?: never;
+            header?: never;
+            path?: never;
+            cookie?: never;
+        };
+        requestBody: {
+            content: {
+                "application/json": components["schemas"]["UpdatePreferencesRequestBody"];
+            };
+        };
+        responses: {
+            /** @description OK */
+            200: {
+                headers: {
+                    [name: string]: unknown;
+                };
+                content: {
+                    "application/json": components["schemas"]["PreferencesResource"];
+                };
+            };
+            /** @description Error */
+            default: {
+                headers: {
+                    [name: string]: unknown;
+                };
+                content: {
+                    "application/json": components["schemas"]["Error"];
+                };
+            };
+        };
+    };
+    "send-email-override-code": {
+        parameters: {
+            query?: never;
+            header?: never;
+            path?: never;
+            cookie?: never;
+        };
+        requestBody?: never;
+        responses: {
+            /** @description OK */
+            200: {
+                headers: {
+                    [name: string]: unknown;
+                };
+                content: {
+                    "application/json": components["schemas"]["EmailOverrideCodeResource"];
+                };
+            };
+            /** @description Error */
+            default: {
+                headers: {
+                    [name: string]: unknown;
+                };
+                content: {
+                    "application/json": components["schemas"]["Error"];
+                };
+            };
+        };
+    };
+    "cancel-email-override": {
+        parameters: {
+            query?: never;
+            header?: never;
+            path?: never;
+            cookie?: never;
+        };
+        requestBody?: never;
+        responses: {
+            /** @description OK */
+            200: {
+                headers: {
+                    [name: string]: unknown;
+                };
+                content: {
+                    "application/json": components["schemas"]["PreferencesResource"];
+                };
+            };
+            /** @description Error */
+            default: {
+                headers: {
+                    [name: string]: unknown;
+                };
+                content: {
+                    "application/json": components["schemas"]["Error"];
+                };
+            };
+        };
+    };
+    "confirm-email-override": {
+        parameters: {
+            query?: never;
+            header?: never;
+            path?: never;
+            cookie?: never;
+        };
+        requestBody: {
+            content: {
+                "application/json": components["schemas"]["ConfirmEmailOverrideRequestBody"];
+            };
+        };
+        responses: {
+            /** @description OK */
+            200: {
+                headers: {
+                    [name: string]: unknown;
+                };
+                content: {
+                    "application/json": components["schemas"]["PreferencesResource"];
+                };
+            };
+            /** @description Error */
+            default: {
+                headers: {
+                    [name: string]: unknown;
+                };
+                content: {
+                    "application/json": components["schemas"]["Error"];
+                };
+            };
+        };
+    };
+    "list-type-preferences": {
+        parameters: {
+            query?: {
+                /** @description Return preferences for this project in addition to the account-wide ones; omit for the account-wide ones only */
+                project_id?: string;
+            };
+            header?: never;
+            path?: never;
+            cookie?: never;
+        };
+        requestBody?: never;
+        responses: {
+            /** @description OK */
+            200: {
+                headers: {
+                    [name: string]: unknown;
+                };
+                content: {
+                    "application/json": components["schemas"]["TypePreferenceListResponseBody"];
+                };
+            };
+            /** @description Error */
+            default: {
+                headers: {
+                    [name: string]: unknown;
+                };
+                content: {
+                    "application/json": components["schemas"]["Error"];
+                };
+            };
+        };
+    };
+    "update-type-preference": {
+        parameters: {
+            query?: {
+                /** @description Apply to this project alone; omit to apply to every project */
+                project_id?: components["parameters"]["PreferenceProjectId"];
+            };
+            header?: never;
+            path: {
+                /** @description A notification type identifier, as listed by list-notification-types */
+                type: components["parameters"]["NotificationType"];
+            };
+            cookie?: never;
+        };
+        requestBody: {
+            content: {
+                "application/json": components["schemas"]["UpdateTypePreferenceRequestBody"];
+            };
+        };
+        responses: {
+            /** @description OK */
+            200: {
+                headers: {
+                    [name: string]: unknown;
+                };
+                content: {
+                    "application/json": components["schemas"]["TypePreferenceResource"];
+                };
+            };
+            /** @description Error */
+            default: {
+                headers: {
+                    [name: string]: unknown;
+                };
+                content: {
+                    "application/json": components["schemas"]["Error"];
+                };
+            };
+        };
+    };
+    "delete-type-preference": {
+        parameters: {
+            query?: {
+                /** @description Apply to this project alone; omit to apply to every project */
+                project_id?: components["parameters"]["PreferenceProjectId"];
+            };
+            header?: never;
+            path: {
+                /** @description A notification type identifier, as listed by list-notification-types */
+                type: components["parameters"]["NotificationType"];
+            };
+            cookie?: never;
+        };
+        requestBody?: never;
+        responses: {
+            /** @description No Content */
+            204: {
+                headers: {
+                    [name: string]: unknown;
+                };
+                content?: never;
+            };
+            /** @description Error */
+            default: {
+                headers: {
+                    [name: string]: unknown;
+                };
+                content: {
+                    "application/json": components["schemas"]["Error"];
+                };
+            };
+        };
+    };
+    "list-user-channels": {
+        parameters: {
+            query?: {
+                /** @description Return only channels of this scope; omit for both */
+                channel_scope?: components["schemas"]["ChannelScope"];
+                /** @description Return only channels of this kind; omit for all kinds */
+                kind?: components["schemas"]["ChannelKind"];
+            };
+            header?: never;
+            path?: never;
+            cookie?: never;
+        };
+        requestBody?: never;
+        responses: {
+            /** @description OK */
+            200: {
+                headers: {
+                    [name: string]: unknown;
+                };
+                content: {
+                    "application/json": components["schemas"]["ChannelListResponseBody"];
+                };
+            };
+            /** @description Error */
+            default: {
+                headers: {
+                    [name: string]: unknown;
+                };
+                content: {
+                    "application/json": components["schemas"]["Error"];
+                };
+            };
+        };
+    };
+    "create-user-channel": {
+        parameters: {
+            query?: never;
+            header?: never;
+            path?: never;
+            cookie?: never;
+        };
+        requestBody: {
+            content: {
+                "application/json": components["schemas"]["CreateChannelRequestBody"];
+            };
+        };
+        responses: {
+            /** @description Created */
+            201: {
+                headers: {
+                    [name: string]: unknown;
+                };
+                content: {
+                    "application/json": components["schemas"]["ChannelResource"];
+                };
+            };
+            /** @description Error */
+            default: {
+                headers: {
+                    [name: string]: unknown;
+                };
+                content: {
+                    "application/json": components["schemas"]["Error"];
+                };
+            };
+        };
+    };
+    "delete-user-channel": {
+        parameters: {
+            query?: never;
+            header?: never;
+            path: {
+                /** @description The outbound channel */
+                channelId: components["parameters"]["ChannelId"];
+            };
+            cookie?: never;
+        };
+        requestBody?: never;
+        responses: {
+            /** @description No Content */
+            204: {
+                headers: {
+                    [name: string]: unknown;
+                };
+                content?: never;
+            };
+            /** @description Error */
+            default: {
+                headers: {
+                    [name: string]: unknown;
+                };
+                content: {
+                    "application/json": components["schemas"]["Error"];
+                };
+            };
+        };
+    };
+    "update-user-channel": {
+        parameters: {
+            query?: never;
+            header?: never;
+            path: {
+                /** @description The outbound channel */
+                channelId: components["parameters"]["ChannelId"];
+            };
+            cookie?: never;
+        };
+        requestBody: {
+            content: {
+                "application/json": components["schemas"]["UpdateChannelRequestBody"];
+            };
+        };
+        responses: {
+            /** @description OK */
+            200: {
+                headers: {
+                    [name: string]: unknown;
+                };
+                content: {
+                    "application/json": components["schemas"]["ChannelResource"];
+                };
+            };
+            /** @description Error */
+            default: {
+                headers: {
+                    [name: string]: unknown;
+                };
+                content: {
+                    "application/json": components["schemas"]["Error"];
+                };
+            };
+        };
+    };
+    "verify-user-channel": {
+        parameters: {
+            query?: never;
+            header?: never;
+            path: {
+                /** @description The outbound channel */
+                channelId: components["parameters"]["ChannelId"];
+            };
+            cookie?: never;
+        };
+        requestBody?: never;
+        responses: {
+            /** @description OK */
+            200: {
+                headers: {
+                    [name: string]: unknown;
+                };
+                content: {
+                    "application/json": components["schemas"]["ChannelResource"];
+                };
+            };
+            /** @description Error */
+            default: {
+                headers: {
+                    [name: string]: unknown;
+                };
+                content: {
+                    "application/json": components["schemas"]["Error"];
+                };
+            };
+        };
+    };
+    "describe-credential-ticket": {
+        parameters: {
+            query?: never;
+            header?: never;
+            path: {
+                /** @description The one-time credential */
+                ticketId: components["parameters"]["TicketId"];
+            };
+            cookie?: never;
+        };
+        requestBody?: never;
+        responses: {
+            /** @description OK */
+            200: {
+                headers: {
+                    [name: string]: unknown;
+                };
+                content: {
+                    "application/json": components["schemas"]["CredentialTicketResource"];
+                };
+            };
+            /** @description Error */
+            default: {
+                headers: {
+                    [name: string]: unknown;
+                };
+                content: {
+                    "application/json": components["schemas"]["Error"];
+                };
+            };
+        };
+    };
+    "reveal-credential": {
+        parameters: {
+            query?: never;
+            header?: never;
+            path: {
+                /** @description The one-time credential */
+                ticketId: components["parameters"]["TicketId"];
+            };
+            cookie?: never;
+        };
+        requestBody?: never;
+        responses: {
+            /** @description OK */
+            200: {
+                headers: {
+                    [name: string]: unknown;
+                };
+                content: {
+                    "application/json": components["schemas"]["RevealedCredentialResource"];
+                };
+            };
+            /** @description Error */
+            default: {
+                headers: {
+                    [name: string]: unknown;
+                };
+                content: {
+                    "application/json": components["schemas"]["Error"];
+                };
+            };
+        };
+    };
+    "describe-realtime-connection": {
+        parameters: {
+            query?: never;
+            header?: never;
+            path?: never;
+            cookie?: never;
+        };
+        requestBody?: never;
+        responses: {
+            /** @description OK */
+            200: {
+                headers: {
+                    [name: string]: unknown;
+                };
+                content: {
+                    "application/json": components["schemas"]["RealtimeConnectionResource"];
+                };
+            };
+            /** @description Error */
+            default: {
+                headers: {
+                    [name: string]: unknown;
+                };
+                content: {
+                    "application/json": components["schemas"]["Error"];
+                };
+            };
+        };
+    };
+    "authorize-realtime-channel": {
+        parameters: {
+            query?: never;
+            header?: never;
+            path?: never;
+            cookie?: never;
+        };
+        requestBody: {
+            content: {
+                "application/json": components["schemas"]["AuthorizeRealtimeChannelRequestBody"];
+            };
+        };
+        responses: {
+            /** @description OK */
+            200: {
+                headers: {
+                    [name: string]: unknown;
+                };
+                content: {
+                    "application/json": components["schemas"]["RealtimeAuthResource"];
+                };
+            };
+            /** @description Error */
+            default: {
+                headers: {
+                    [name: string]: unknown;
+                };
+                content: {
+                    "application/json": components["schemas"]["Error"];
+                };
+            };
+        };
+    };
+}