@leaflow/sdk 0.176.0 → 0.177.1

package/dist/eventbus/v1/generated/functions.d.ts

@@ -0,0 +1,336 @@
+/**
+ * Generated by orval 🍺
+ * Do not edit manually.
+ * Leaflow Event Bus API
+ * Event definitions, versions, publishing, and realtime access.
+ *
+ * ## 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.
+ *
+ * ## Definitions and messages
+ *
+ * An event is a definition: a name, a description, and one or more versions. A version carries a
+ * JSON Schema that every published payload must satisfy. Messages are not stored here and are
+ * not part of the event definition.
+ *
+ * A project event belongs to the current project. A global event has no `project_id`; it is
+ * defined by a platform service and is read-only in this API. Global events are listed alongside
+ * the project's own events.
+ *
+ * A version number never changes meaning. Adding optional properties is allowed within a version;
+ * a breaking change creates a new version. Publishing without a version uses the highest active
+ * version.
+ *
+ * ## Publishing
+ *
+ * Publishing returns the identity of the message and does not wait for consumers. Messages are
+ * not stored and are not replayed: a consumer that connects later does not receive earlier
+ * messages. Consumers receive messages through the realtime API or the platform's service API.
+ *
+ * ## Realtime
+ *
+ * Create a ticket, connect to the returned URL with the ticket, and authenticate the connection
+ * with a scoped token. A ticket is single-use and short-lived. The connection ends when the
+ * token expires unless it is refreshed with a new scoped token for the same user and project.
+ * OpenAPI spec version: 1.0.0
+ */
+import type { CreateEventRequest, CreateVersionRequest, Error, EventDetail, EventList, EventResource, EventVersion, ListEventsParams, PublishRequest, PublishResponse, RealtimeTicket, UpdateEventRequest } from "./models.js";
+export type listEventsResponse200 = {
+    data: EventList;
+    status: 200;
+};
+export type listEventsResponse400 = {
+    data: Error;
+    status: 400;
+};
+export type listEventsResponse401 = {
+    data: Error;
+    status: 401;
+};
+export type listEventsResponse403 = {
+    data: Error;
+    status: 403;
+};
+export type listEventsResponse503 = {
+    data: Error;
+    status: 503;
+};
+export type listEventsResponseSuccess = listEventsResponse200 & {
+    headers: Headers;
+};
+export type listEventsResponseError = (listEventsResponse400 | listEventsResponse401 | listEventsResponse403 | listEventsResponse503) & {
+    headers: Headers;
+};
+export type listEventsResponse = listEventsResponseSuccess | listEventsResponseError;
+export declare const getListEventsUrl: (params?: ListEventsParams) => string;
+/**
+ * Returns the global events visible to the project and the project's own events. Ordered by
+ * name.
+ * @summary List event definitions
+ */
+export declare const listEvents: (params?: ListEventsParams, options?: RequestInit, fetchFn?: typeof globalThis.fetch) => Promise<listEventsResponse>;
+export type createEventResponse201 = {
+    data: EventResource;
+    status: 201;
+};
+export type createEventResponse400 = {
+    data: Error;
+    status: 400;
+};
+export type createEventResponse401 = {
+    data: Error;
+    status: 401;
+};
+export type createEventResponse403 = {
+    data: Error;
+    status: 403;
+};
+export type createEventResponse409 = {
+    data: Error;
+    status: 409;
+};
+export type createEventResponse503 = {
+    data: Error;
+    status: 503;
+};
+export type createEventResponseSuccess = createEventResponse201 & {
+    headers: Headers;
+};
+export type createEventResponseError = (createEventResponse400 | createEventResponse401 | createEventResponse403 | createEventResponse409 | createEventResponse503) & {
+    headers: Headers;
+};
+export type createEventResponse = createEventResponseSuccess | createEventResponseError;
+export declare const getCreateEventUrl: () => string;
+/**
+ * Creates a project event with its first version. The name is unique within the project. The
+ * first segment of the name is the event's namespace and must not be a platform namespace.
+ * @summary Create an event definition
+ */
+export declare const createEvent: (createEventRequest: CreateEventRequest, options?: RequestInit, fetchFn?: typeof globalThis.fetch) => Promise<createEventResponse>;
+export type getEventResponse200 = {
+    data: EventDetail;
+    status: 200;
+};
+export type getEventResponse401 = {
+    data: Error;
+    status: 401;
+};
+export type getEventResponse403 = {
+    data: Error;
+    status: 403;
+};
+export type getEventResponse404 = {
+    data: Error;
+    status: 404;
+};
+export type getEventResponse503 = {
+    data: Error;
+    status: 503;
+};
+export type getEventResponseSuccess = getEventResponse200 & {
+    headers: Headers;
+};
+export type getEventResponseError = (getEventResponse401 | getEventResponse403 | getEventResponse404 | getEventResponse503) & {
+    headers: Headers;
+};
+export type getEventResponse = getEventResponseSuccess | getEventResponseError;
+export declare const getGetEventUrl: (eventName: string) => string;
+/**
+ * Returns the event and every version, newest first.
+ * @summary Get an event definition
+ */
+export declare const getEvent: (eventName: string, options?: RequestInit, fetchFn?: typeof globalThis.fetch) => Promise<getEventResponse>;
+export type updateEventResponse200 = {
+    data: EventResource;
+    status: 200;
+};
+export type updateEventResponse400 = {
+    data: Error;
+    status: 400;
+};
+export type updateEventResponse401 = {
+    data: Error;
+    status: 401;
+};
+export type updateEventResponse403 = {
+    data: Error;
+    status: 403;
+};
+export type updateEventResponse404 = {
+    data: Error;
+    status: 404;
+};
+export type updateEventResponse409 = {
+    data: Error;
+    status: 409;
+};
+export type updateEventResponse503 = {
+    data: Error;
+    status: 503;
+};
+export type updateEventResponseSuccess = updateEventResponse200 & {
+    headers: Headers;
+};
+export type updateEventResponseError = (updateEventResponse400 | updateEventResponse401 | updateEventResponse403 | updateEventResponse404 | updateEventResponse409 | updateEventResponse503) & {
+    headers: Headers;
+};
+export type updateEventResponse = updateEventResponseSuccess | updateEventResponseError;
+export declare const getUpdateEventUrl: (eventName: string) => string;
+/**
+ * Changes the description, tags, or status. Only the fields present in the request are
+ * changed. An archived event stops accepting new messages; existing versions remain readable.
+ * @summary Update an event definition
+ */
+export declare const updateEvent: (eventName: string, updateEventRequest: UpdateEventRequest, options?: RequestInit, fetchFn?: typeof globalThis.fetch) => Promise<updateEventResponse>;
+export type createEventVersionResponse201 = {
+    data: EventVersion;
+    status: 201;
+};
+export type createEventVersionResponse400 = {
+    data: Error;
+    status: 400;
+};
+export type createEventVersionResponse401 = {
+    data: Error;
+    status: 401;
+};
+export type createEventVersionResponse403 = {
+    data: Error;
+    status: 403;
+};
+export type createEventVersionResponse404 = {
+    data: Error;
+    status: 404;
+};
+export type createEventVersionResponse409 = {
+    data: Error;
+    status: 409;
+};
+export type createEventVersionResponse503 = {
+    data: Error;
+    status: 503;
+};
+export type createEventVersionResponseSuccess = createEventVersionResponse201 & {
+    headers: Headers;
+};
+export type createEventVersionResponseError = (createEventVersionResponse400 | createEventVersionResponse401 | createEventVersionResponse403 | createEventVersionResponse404 | createEventVersionResponse409 | createEventVersionResponse503) & {
+    headers: Headers;
+};
+export type createEventVersionResponse = createEventVersionResponseSuccess | createEventVersionResponseError;
+export declare const getCreateEventVersionUrl: (eventName: string) => string;
+/**
+ * Adds a version to an existing event. The version number must be greater than every existing
+ * version. A version number's schema may gain optional properties, but it may not remove or
+ * change existing ones; use a new version for a breaking change.
+ * @summary Add an event version
+ */
+export declare const createEventVersion: (eventName: string, createVersionRequest: CreateVersionRequest, options?: RequestInit, fetchFn?: typeof globalThis.fetch) => Promise<createEventVersionResponse>;
+export type getEventVersionResponse200 = {
+    data: EventVersion;
+    status: 200;
+};
+export type getEventVersionResponse401 = {
+    data: Error;
+    status: 401;
+};
+export type getEventVersionResponse403 = {
+    data: Error;
+    status: 403;
+};
+export type getEventVersionResponse404 = {
+    data: Error;
+    status: 404;
+};
+export type getEventVersionResponse503 = {
+    data: Error;
+    status: 503;
+};
+export type getEventVersionResponseSuccess = getEventVersionResponse200 & {
+    headers: Headers;
+};
+export type getEventVersionResponseError = (getEventVersionResponse401 | getEventVersionResponse403 | getEventVersionResponse404 | getEventVersionResponse503) & {
+    headers: Headers;
+};
+export type getEventVersionResponse = getEventVersionResponseSuccess | getEventVersionResponseError;
+export declare const getGetEventVersionUrl: (eventName: string, version: number) => string;
+/**
+ * Returns one version of an event.
+ * @summary Get an event version
+ */
+export declare const getEventVersion: (eventName: string, version: number, options?: RequestInit, fetchFn?: typeof globalThis.fetch) => Promise<getEventVersionResponse>;
+export type publishEventResponse202 = {
+    data: PublishResponse;
+    status: 202;
+};
+export type publishEventResponse400 = {
+    data: Error;
+    status: 400;
+};
+export type publishEventResponse401 = {
+    data: Error;
+    status: 401;
+};
+export type publishEventResponse403 = {
+    data: Error;
+    status: 403;
+};
+export type publishEventResponse404 = {
+    data: Error;
+    status: 404;
+};
+export type publishEventResponse409 = {
+    data: Error;
+    status: 409;
+};
+export type publishEventResponse503 = {
+    data: Error;
+    status: 503;
+};
+export type publishEventResponseSuccess = publishEventResponse202 & {
+    headers: Headers;
+};
+export type publishEventResponseError = (publishEventResponse400 | publishEventResponse401 | publishEventResponse403 | publishEventResponse404 | publishEventResponse409 | publishEventResponse503) & {
+    headers: Headers;
+};
+export type publishEventResponse = publishEventResponseSuccess | publishEventResponseError;
+export declare const getPublishEventUrl: (eventName: string) => string;
+/**
+ * Validates the payload against the selected version and publishes the message. The response
+ * carries the message identity; it does not mean a consumer received it. A version of zero
+ * selects the highest active version.
+ * @summary Publish an event message
+ */
+export declare const publishEvent: (eventName: string, publishRequest: PublishRequest, options?: RequestInit, fetchFn?: typeof globalThis.fetch) => Promise<publishEventResponse>;
+export type createRealtimeTicketResponse201 = {
+    data: RealtimeTicket;
+    status: 201;
+};
+export type createRealtimeTicketResponse401 = {
+    data: Error;
+    status: 401;
+};
+export type createRealtimeTicketResponse403 = {
+    data: Error;
+    status: 403;
+};
+export type createRealtimeTicketResponse503 = {
+    data: Error;
+    status: 503;
+};
+export type createRealtimeTicketResponseSuccess = createRealtimeTicketResponse201 & {
+    headers: Headers;
+};
+export type createRealtimeTicketResponseError = (createRealtimeTicketResponse401 | createRealtimeTicketResponse403 | createRealtimeTicketResponse503) & {
+    headers: Headers;
+};
+export type createRealtimeTicketResponse = createRealtimeTicketResponseSuccess | createRealtimeTicketResponseError;
+export declare const getCreateRealtimeTicketUrl: () => string;
+/**
+ * Issues a short-lived ticket for a realtime connection. Connect to `url`, pass the ticket,
+ * then authenticate the connection with a scoped token. A ticket is not a bearer token for
+ * other APIs.
+ * @summary Create a realtime ticket
+ */
+export declare const createRealtimeTicket: (options?: RequestInit, fetchFn?: typeof globalThis.fetch) => Promise<createRealtimeTicketResponse>;

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

@@ -0,0 +1,214 @@
+export const getListEventsUrl = (params) => {
+    const normalizedParams = new URLSearchParams();
+    Object.entries(params || {}).forEach(([key, value]) => {
+        if (value !== undefined) {
+            normalizedParams.append(key, value === null ? "null" : String(value));
+        }
+    });
+    const stringifiedParams = normalizedParams.toString();
+    return stringifiedParams.length > 0
+        ? `https://eventbus.leaflow.cloud/api/v1/events?${stringifiedParams}`
+        : `https://eventbus.leaflow.cloud/api/v1/events`;
+};
+/**
+ * Returns the global events visible to the project and the project's own events. Ordered by
+ * name.
+ * @summary List event definitions
+ */
+export const listEvents = async (params, options, fetchFn) => {
+    const res = await (fetchFn ?? fetch)(getListEventsUrl(params), {
+        ...options,
+        method: "GET",
+    });
+    const body = [204, 205, 304].includes(res.status) ? null : await res.text();
+    const data = body ? JSON.parse(body) : {};
+    return { data, status: res.status, headers: res.headers };
+};
+export const getCreateEventUrl = () => {
+    return `https://eventbus.leaflow.cloud/api/v1/events`;
+};
+/**
+ * Creates a project event with its first version. The name is unique within the project. The
+ * first segment of the name is the event's namespace and must not be a platform namespace.
+ * @summary Create an event definition
+ */
+export const createEvent = async (createEventRequest, options, fetchFn) => {
+    const getHeaders = (h) => {
+        if (!h)
+            return {};
+        if (h instanceof Headers)
+            return Object.fromEntries(h.entries());
+        if (Symbol.iterator in h) {
+            return Object.fromEntries(Array.from(h, (entry) => Array.from(entry)));
+        }
+        const headers = {};
+        for (const [name, value] of Object.entries(h)) {
+            if (value !== undefined)
+                headers[name] = value;
+        }
+        return headers;
+    };
+    const res = await (fetchFn ?? fetch)(getCreateEventUrl(), {
+        ...options,
+        method: "POST",
+        headers: { "Content-Type": "application/json", ...getHeaders(options?.headers) },
+        body: JSON.stringify(createEventRequest),
+    });
+    const body = [204, 205, 304].includes(res.status) ? null : await res.text();
+    const data = body ? JSON.parse(body) : {};
+    return { data, status: res.status, headers: res.headers };
+};
+export const getGetEventUrl = (eventName) => {
+    return `https://eventbus.leaflow.cloud/api/v1/events/${encodeURIComponent(String(eventName))}`;
+};
+/**
+ * Returns the event and every version, newest first.
+ * @summary Get an event definition
+ */
+export const getEvent = async (eventName, options, fetchFn) => {
+    const res = await (fetchFn ?? fetch)(getGetEventUrl(eventName), {
+        ...options,
+        method: "GET",
+    });
+    const body = [204, 205, 304].includes(res.status) ? null : await res.text();
+    const data = body ? JSON.parse(body) : {};
+    return { data, status: res.status, headers: res.headers };
+};
+export const getUpdateEventUrl = (eventName) => {
+    return `https://eventbus.leaflow.cloud/api/v1/events/${encodeURIComponent(String(eventName))}`;
+};
+/**
+ * Changes the description, tags, or status. Only the fields present in the request are
+ * changed. An archived event stops accepting new messages; existing versions remain readable.
+ * @summary Update an event definition
+ */
+export const updateEvent = async (eventName, updateEventRequest, options, fetchFn) => {
+    const getHeaders = (h) => {
+        if (!h)
+            return {};
+        if (h instanceof Headers)
+            return Object.fromEntries(h.entries());
+        if (Symbol.iterator in h) {
+            return Object.fromEntries(Array.from(h, (entry) => Array.from(entry)));
+        }
+        const headers = {};
+        for (const [name, value] of Object.entries(h)) {
+            if (value !== undefined)
+                headers[name] = value;
+        }
+        return headers;
+    };
+    const res = await (fetchFn ?? fetch)(getUpdateEventUrl(eventName), {
+        ...options,
+        method: "PATCH",
+        headers: { "Content-Type": "application/json", ...getHeaders(options?.headers) },
+        body: JSON.stringify(updateEventRequest),
+    });
+    const body = [204, 205, 304].includes(res.status) ? null : await res.text();
+    const data = body ? JSON.parse(body) : {};
+    return { data, status: res.status, headers: res.headers };
+};
+export const getCreateEventVersionUrl = (eventName) => {
+    return `https://eventbus.leaflow.cloud/api/v1/events/${encodeURIComponent(String(eventName))}/versions`;
+};
+/**
+ * Adds a version to an existing event. The version number must be greater than every existing
+ * version. A version number's schema may gain optional properties, but it may not remove or
+ * change existing ones; use a new version for a breaking change.
+ * @summary Add an event version
+ */
+export const createEventVersion = async (eventName, createVersionRequest, options, fetchFn) => {
+    const getHeaders = (h) => {
+        if (!h)
+            return {};
+        if (h instanceof Headers)
+            return Object.fromEntries(h.entries());
+        if (Symbol.iterator in h) {
+            return Object.fromEntries(Array.from(h, (entry) => Array.from(entry)));
+        }
+        const headers = {};
+        for (const [name, value] of Object.entries(h)) {
+            if (value !== undefined)
+                headers[name] = value;
+        }
+        return headers;
+    };
+    const res = await (fetchFn ?? fetch)(getCreateEventVersionUrl(eventName), {
+        ...options,
+        method: "POST",
+        headers: { "Content-Type": "application/json", ...getHeaders(options?.headers) },
+        body: JSON.stringify(createVersionRequest),
+    });
+    const body = [204, 205, 304].includes(res.status) ? null : await res.text();
+    const data = body ? JSON.parse(body) : {};
+    return { data, status: res.status, headers: res.headers };
+};
+export const getGetEventVersionUrl = (eventName, version) => {
+    return `https://eventbus.leaflow.cloud/api/v1/events/${encodeURIComponent(String(eventName))}/versions/${encodeURIComponent(String(version))}`;
+};
+/**
+ * Returns one version of an event.
+ * @summary Get an event version
+ */
+export const getEventVersion = async (eventName, version, options, fetchFn) => {
+    const res = await (fetchFn ?? fetch)(getGetEventVersionUrl(eventName, version), {
+        ...options,
+        method: "GET",
+    });
+    const body = [204, 205, 304].includes(res.status) ? null : await res.text();
+    const data = body ? JSON.parse(body) : {};
+    return { data, status: res.status, headers: res.headers };
+};
+export const getPublishEventUrl = (eventName) => {
+    return `https://eventbus.leaflow.cloud/api/v1/events/${encodeURIComponent(String(eventName))}:publish`;
+};
+/**
+ * Validates the payload against the selected version and publishes the message. The response
+ * carries the message identity; it does not mean a consumer received it. A version of zero
+ * selects the highest active version.
+ * @summary Publish an event message
+ */
+export const publishEvent = async (eventName, publishRequest, options, fetchFn) => {
+    const getHeaders = (h) => {
+        if (!h)
+            return {};
+        if (h instanceof Headers)
+            return Object.fromEntries(h.entries());
+        if (Symbol.iterator in h) {
+            return Object.fromEntries(Array.from(h, (entry) => Array.from(entry)));
+        }
+        const headers = {};
+        for (const [name, value] of Object.entries(h)) {
+            if (value !== undefined)
+                headers[name] = value;
+        }
+        return headers;
+    };
+    const res = await (fetchFn ?? fetch)(getPublishEventUrl(eventName), {
+        ...options,
+        method: "POST",
+        headers: { "Content-Type": "application/json", ...getHeaders(options?.headers) },
+        body: JSON.stringify(publishRequest),
+    });
+    const body = [204, 205, 304].includes(res.status) ? null : await res.text();
+    const data = body ? JSON.parse(body) : {};
+    return { data, status: res.status, headers: res.headers };
+};
+export const getCreateRealtimeTicketUrl = () => {
+    return `https://eventbus.leaflow.cloud/api/v1/realtime/tickets`;
+};
+/**
+ * Issues a short-lived ticket for a realtime connection. Connect to `url`, pass the ticket,
+ * then authenticate the connection with a scoped token. A ticket is not a bearer token for
+ * other APIs.
+ * @summary Create a realtime ticket
+ */
+export const createRealtimeTicket = async (options, fetchFn) => {
+    const res = await (fetchFn ?? fetch)(getCreateRealtimeTicketUrl(), {
+        ...options,
+        method: "POST",
+    });
+    const body = [204, 205, 304].includes(res.status) ? null : await res.text();
+    const data = body ? JSON.parse(body) : {};
+    return { data, status: res.status, headers: res.headers };
+};