@jumoo/processing 17.5.1 → 17.5.2

package/dist/api/client/client.gen.js

@@ -19,10 +19,7 @@ export const createClient = (config = {}) => {
             serializedBody: undefined,
         };
         if (opts.security) {
-            await setAuthParams({
-                ...opts,
-                security: opts.security,
-            });
+            await setAuthParams(opts);
         }
         if (opts.requestValidator) {
             await opts.requestValidator(opts);
@@ -39,149 +36,134 @@ export const createClient = (config = {}) => {
         return { opts: resolvedOpts, url };
     };
     const request = async (options) => {
-        const { opts, url } = await beforeRequest(options);
-        const requestInit = {
-            redirect: 'follow',
-            ...opts,
-            body: getValidRequestBody(opts),
-        };
-        let request = new Request(url, requestInit);
-        for (const fn of interceptors.request.fns) {
-            if (fn) {
-                request = await fn(request, opts);
-            }
-        }
-        // fetch must be assigned here, otherwise it would throw the error:
-        // TypeError: Failed to execute 'fetch' on 'Window': Illegal invocation
-        const _fetch = opts.fetch;
+        const throwOnError = options.throwOnError ?? _config.throwOnError;
+        const responseStyle = options.responseStyle ?? _config.responseStyle;
+        let request;
         let response;
         try {
-            response = await _fetch(request);
-        }
-        catch (error) {
-            // Handle fetch exceptions (AbortError, network errors, etc.)
-            let finalError = error;
-            for (const fn of interceptors.error.fns) {
+            const { opts, url } = await beforeRequest(options);
+            const requestInit = {
+                redirect: 'follow',
+                ...opts,
+                body: getValidRequestBody(opts),
+            };
+            request = new Request(url, requestInit);
+            for (const fn of interceptors.request.fns) {
                 if (fn) {
-                    finalError = (await fn(error, undefined, request, opts));
+                    request = await fn(request, opts);
                 }
             }
-            finalError = finalError || {};
-            if (opts.throwOnError) {
-                throw finalError;
-            }
-            // Return error response
-            return opts.responseStyle === 'data'
-                ? undefined
-                : {
-                    error: finalError,
-                    request,
-                    response: undefined,
-                };
-        }
-        for (const fn of interceptors.response.fns) {
-            if (fn) {
-                response = await fn(response, request, opts);
+            // fetch must be assigned here, otherwise it would throw the error:
+            // TypeError: Failed to execute 'fetch' on 'Window': Illegal invocation
+            const _fetch = opts.fetch;
+            response = await _fetch(request);
+            for (const fn of interceptors.response.fns) {
+                if (fn) {
+                    response = await fn(response, request, opts);
+                }
             }
-        }
-        const result = {
-            request,
-            response,
-        };
-        if (response.ok) {
-            const parseAs = (opts.parseAs === 'auto'
-                ? getParseAs(response.headers.get('Content-Type'))
-                : opts.parseAs) ?? 'json';
-            if (response.status === 204 || response.headers.get('Content-Length') === '0') {
-                let emptyData;
+            const result = {
+                request,
+                response,
+            };
+            if (response.ok) {
+                const parseAs = (opts.parseAs === 'auto'
+                    ? getParseAs(response.headers.get('Content-Type'))
+                    : opts.parseAs) ?? 'json';
+                if (response.status === 204 || response.headers.get('Content-Length') === '0') {
+                    let emptyData;
+                    switch (parseAs) {
+                        case 'arrayBuffer':
+                        case 'blob':
+                        case 'text':
+                            emptyData = await response[parseAs]();
+                            break;
+                        case 'formData':
+                            emptyData = new FormData();
+                            break;
+                        case 'stream':
+                            emptyData = response.body;
+                            break;
+                        case 'json':
+                        default:
+                            emptyData = {};
+                            break;
+                    }
+                    return opts.responseStyle === 'data'
+                        ? emptyData
+                        : {
+                            data: emptyData,
+                            ...result,
+                        };
+                }
+                let data;
                 switch (parseAs) {
                     case 'arrayBuffer':
                     case 'blob':
+                    case 'formData':
                     case 'text':
-                        emptyData = await response[parseAs]();
+                        data = await response[parseAs]();
                         break;
-                    case 'formData':
-                        emptyData = new FormData();
+                    case 'json': {
+                        // Some servers return 200 with no Content-Length and empty body.
+                        // response.json() would throw; read as text and parse if non-empty.
+                        const text = await response.text();
+                        data = text ? JSON.parse(text) : {};
                         break;
+                    }
                     case 'stream':
-                        emptyData = response.body;
-                        break;
-                    case 'json':
-                    default:
-                        emptyData = {};
-                        break;
+                        return opts.responseStyle === 'data'
+                            ? response.body
+                            : {
+                                data: response.body,
+                                ...result,
+                            };
+                }
+                if (parseAs === 'json') {
+                    if (opts.responseValidator) {
+                        await opts.responseValidator(data);
+                    }
+                    if (opts.responseTransformer) {
+                        data = await opts.responseTransformer(data);
+                    }
                 }
                 return opts.responseStyle === 'data'
-                    ? emptyData
+                    ? data
                     : {
-                        data: emptyData,
+                        data,
                         ...result,
                     };
             }
-            let data;
-            switch (parseAs) {
-                case 'arrayBuffer':
-                case 'blob':
-                case 'formData':
-                case 'text':
-                    data = await response[parseAs]();
-                    break;
-                case 'json': {
-                    // Some servers return 200 with no Content-Length and empty body.
-                    // response.json() would throw; read as text and parse if non-empty.
-                    const text = await response.text();
-                    data = text ? JSON.parse(text) : {};
-                    break;
-                }
-                case 'stream':
-                    return opts.responseStyle === 'data'
-                        ? response.body
-                        : {
-                            data: response.body,
-                            ...result,
-                        };
+            const textError = await response.text();
+            let jsonError;
+            try {
+                jsonError = JSON.parse(textError);
             }
-            if (parseAs === 'json') {
-                if (opts.responseValidator) {
-                    await opts.responseValidator(data);
-                }
-                if (opts.responseTransformer) {
-                    data = await opts.responseTransformer(data);
+            catch {
+                // noop
+            }
+            throw jsonError ?? textError;
+        }
+        catch (error) {
+            let finalError = error;
+            for (const fn of interceptors.error.fns) {
+                if (fn) {
+                    finalError = await fn(finalError, response, request, options);
                 }
             }
-            return opts.responseStyle === 'data'
-                ? data
+            finalError = finalError || {};
+            if (throwOnError) {
+                throw finalError;
+            }
+            // TODO: we probably want to return error and improve types
+            return responseStyle === 'data'
+                ? undefined
                 : {
-                    data,
-                    ...result,
+                    error: finalError,
+                    request,
+                    response,
                 };
         }
-        const textError = await response.text();
-        let jsonError;
-        try {
-            jsonError = JSON.parse(textError);
-        }
-        catch {
-            // noop
-        }
-        const error = jsonError ?? textError;
-        let finalError = error;
-        for (const fn of interceptors.error.fns) {
-            if (fn) {
-                finalError = (await fn(error, response, request, opts));
-            }
-        }
-        finalError = finalError || {};
-        if (opts.throwOnError) {
-            throw finalError;
-        }
-        // TODO: we probably want to return error and improve types
-        return opts.responseStyle === 'data'
-            ? undefined
-            : {
-                error: finalError,
-                ...result,
-            };
     };
     const makeMethodFn = (method) => (options) => request({ ...options, method });
     const makeSseFn = (method) => async (options) => {
@@ -189,7 +171,6 @@ export const createClient = (config = {}) => {
         return createSseClient({
             ...opts,
             body: opts.body,
-            headers: opts.headers,
             method,
             onRequest: async (url, init) => {
                 let request = new Request(url, init);

package/dist/api/client/index.d.ts

@@ -3,6 +3,8 @@ export type { QuerySerializerOptions } from '../core/bodySerializer.gen';
 export { formDataBodySerializer, jsonBodySerializer, urlSearchParamsBodySerializer, } from '../core/bodySerializer.gen';
 export { buildClientParams } from '../core/params.gen';
 export { serializeQueryKeyValue } from '../core/queryKeySerializer.gen';
+export type { ServerSentEventsResult } from '../core/serverSentEvents.gen';
+export type { ClientMeta } from '../core/types.gen';
 export { createClient } from './client.gen';
 export type { Client, ClientOptions, Config, CreateClientConfig, Options, RequestOptions, RequestResult, ResolvedRequestOptions, ResponseStyle, TDataShape, } from './types.gen';
 export { createConfig, mergeHeaders } from './utils.gen';

package/dist/api/client/types.gen.d.ts

@@ -63,6 +63,7 @@ export interface RequestOptions<TData = unknown, TResponseStyle extends Response
     url: Url;
 }
 export interface ResolvedRequestOptions<TResponseStyle extends ResponseStyle = 'fields', ThrowOnError extends boolean = boolean, Url extends string = string> extends RequestOptions<unknown, TResponseStyle, ThrowOnError, Url> {
+    headers: Headers;
     serializedBody?: string;
 }
 export type RequestResult<TData = unknown, TError = unknown, ThrowOnError extends boolean = boolean, TResponseStyle extends ResponseStyle = 'fields'> = ThrowOnError extends true ? Promise<TResponseStyle extends 'data' ? TData extends Record<string, unknown> ? TData[keyof TData] : TData : {
@@ -76,8 +77,10 @@ export type RequestResult<TData = unknown, TError = unknown, ThrowOnError extend
     data: undefined;
     error: TError extends Record<string, unknown> ? TError[keyof TError] : TError;
 }) & {
-    request: Request;
-    response: Response;
+    /** request may be undefined, because error may be from building the request object itself */
+    request?: Request;
+    /** response may be undefined, because error may be from building the request object itself or from a network error */
+    response?: Response;
 }>;
 export interface ClientOptions {
     baseUrl?: string;
@@ -85,7 +88,7 @@ export interface ClientOptions {
     throwOnError?: boolean;
 }
 type MethodFn = <TData = unknown, TError = unknown, ThrowOnError extends boolean = false, TResponseStyle extends ResponseStyle = 'fields'>(options: Omit<RequestOptions<TData, TResponseStyle, ThrowOnError>, 'method'>) => RequestResult<TData, TError, ThrowOnError, TResponseStyle>;
-type SseFn = <TData = unknown, TError = unknown, ThrowOnError extends boolean = false, TResponseStyle extends ResponseStyle = 'fields'>(options: Omit<RequestOptions<never, TResponseStyle, ThrowOnError>, 'method'>) => Promise<ServerSentEventsResult<TData, TError>>;
+type SseFn = <TData = unknown, _TError = unknown, ThrowOnError extends boolean = false, TResponseStyle extends ResponseStyle = 'fields'>(options: Omit<RequestOptions<never, TResponseStyle, ThrowOnError>, 'method'>) => Promise<ServerSentEventsResult<TData>>;
 type RequestFn = <TData = unknown, TError = unknown, ThrowOnError extends boolean = false, TResponseStyle extends ResponseStyle = 'fields'>(options: Omit<RequestOptions<TData, TResponseStyle, ThrowOnError>, 'method'> & Pick<Required<RequestOptions<TData, TResponseStyle, ThrowOnError>>, 'method'>) => RequestResult<TData, TError, ThrowOnError, TResponseStyle>;
 type BuildUrlFn = <TData extends {
     body?: unknown;

package/dist/api/client/utils.gen.d.ts

@@ -1,17 +1,21 @@
 import type { QuerySerializerOptions } from '../core/bodySerializer.gen';
 import type { Client, ClientOptions, Config, RequestOptions } from './types.gen';
-export declare const createQuerySerializer: <T = unknown>({ parameters, ...args }?: QuerySerializerOptions) => (queryParams: T) => string;
+export declare const createQuerySerializer: <T = unknown>({ parameters, ...args }?: QuerySerializerOptions) => ((queryParams: T) => string);
 /**
  * Infers parseAs value from provided Content-Type header.
  */
 export declare const getParseAs: (contentType: string | null) => Exclude<Config["parseAs"], "auto">;
-export declare const setAuthParams: ({ security, ...options }: Pick<Required<RequestOptions>, "security"> & Pick<RequestOptions, "auth" | "query"> & {
+export declare function setAuthParams(options: Pick<RequestOptions, 'auth' | 'query' | 'security'> & {
     headers: Headers;
-}) => Promise<void>;
+}): Promise<void>;
 export declare const buildUrl: Client['buildUrl'];
 export declare const mergeConfigs: (a: Config, b: Config) => Config;
 export declare const mergeHeaders: (...headers: Array<Required<Config>["headers"] | undefined>) => Headers;
-type ErrInterceptor<Err, Res, Req, Options> = (error: Err, response: Res, request: Req, options: Options) => Err | Promise<Err>;
+type ErrInterceptor<Err, Res, Req, Options> = (error: Err, 
+/** response may be undefined due to a network error where no response object is produced */
+response: Res | undefined, 
+/** request may be undefined, because error may be from building the request object itself */
+request: Req | undefined, options: Options) => Err | Promise<Err>;
 type ReqInterceptor<Req, Options> = (request: Req, options: Options) => Req | Promise<Req>;
 type ResInterceptor<Res, Req, Options> = (response: Res, request: Req, options: Options) => Res | Promise<Res>;
 declare class Interceptors<Interceptor> {

package/dist/api/client/utils.gen.js

@@ -90,8 +90,8 @@ const checkForExistence = (options, name) => {
     }
     return false;
 };
-export const setAuthParams = async ({ security, ...options }) => {
-    for (const auth of security) {
+export async function setAuthParams(options) {
+    for (const auth of options.security ?? []) {
         if (checkForExistence(options, auth.name)) {
             continue;
         }
@@ -116,7 +116,7 @@ export const setAuthParams = async ({ security, ...options }) => {
                 break;
         }
     }
-};
+}
 export const buildUrl = (options) => getUrl({
     baseUrl: options.baseUrl,
     path: options.path,

package/dist/api/client.gen.d.ts

@@ -1,4 +1,4 @@
-import { type ClientOptions, type Config } from './client';
+import { type Client, type ClientOptions, type Config } from './client';
 import type { ClientOptions as ClientOptions2 } from './types.gen';
 /**
  * The `createClientConfig()` function will be called on client initialization
@@ -9,4 +9,4 @@ import type { ClientOptions as ClientOptions2 } from './types.gen';
  * to ensure your client always has the correct values.
  */
 export type CreateClientConfig<T extends ClientOptions = ClientOptions2> = (override?: Config<ClientOptions & T>) => Config<Required<ClientOptions> & T>;
-export declare const client: import("./client").Client;
+export declare const client: Client;

package/dist/api/client.gen.js

@@ -1,4 +1,3 @@
 // This file is auto-generated by @hey-api/openapi-ts
-import { createClientConfig } from '../hey-api';
 import { createClient, createConfig } from './client';
-export const client = createClient(createClientConfig(createConfig({ baseUrl: 'http://localhost:41839', throwOnError: true })));
+export const client = createClient(createConfig({ baseUrl: 'http://localhost:41839', throwOnError: true }));

package/dist/api/core/auth.gen.d.ts

@@ -6,6 +6,13 @@ export interface Auth {
      * @default 'header'
      */
     in?: 'header' | 'query' | 'cookie';
+    /**
+     * A unique identifier for the security scheme.
+     *
+     * Defined only when there are multiple security schemes whose `Auth`
+     * shape would otherwise be identical.
+     */
+    key?: string;
     /**
      * Header or query parameter name.
      *

package/dist/api/core/params.gen.d.ts

@@ -34,10 +34,10 @@ export interface Fields {
 }
 export type FieldsConfig = ReadonlyArray<Field | Fields>;
 interface Params {
-    body: unknown;
+    body?: unknown;
     headers: Record<string, unknown>;
     path: Record<string, unknown>;
     query: Record<string, unknown>;
 }
-export declare const buildClientParams: (args: ReadonlyArray<unknown>, fields: FieldsConfig) => Params;
+export declare function buildClientParams(args: ReadonlyArray<unknown>, fields: FieldsConfig): Params;
 export {};

package/dist/api/core/params.gen.js

@@ -6,7 +6,7 @@ const extraPrefixesMap = {
     $query_: 'query',
 };
 const extraPrefixes = Object.entries(extraPrefixesMap);
-const buildKeyMap = (fields, map) => {
+function buildKeyMap(fields, map) {
     if (!map) {
         map = new Map();
     }
@@ -29,22 +29,31 @@ const buildKeyMap = (fields, map) => {
         }
     }
     return map;
-};
-const stripEmptySlots = (params) => {
+}
+function stripEmptySlots(params) {
     for (const [slot, value] of Object.entries(params)) {
+        if (slot === 'body')
+            continue;
         if (value && typeof value === 'object' && !Array.isArray(value) && !Object.keys(value).length) {
             delete params[slot];
         }
     }
-};
-export const buildClientParams = (args, fields) => {
+}
+export function buildClientParams(args, fields) {
     const params = {
-        body: {},
-        headers: {},
-        path: {},
-        query: {},
+        headers: Object.create(null),
+        path: Object.create(null),
+        query: Object.create(null),
     };
     const map = buildKeyMap(fields);
+    function writeSlot(slot, key, value) {
+        let record = params[slot];
+        if (record === undefined) {
+            record = Object.create(null);
+            params[slot] = record;
+        }
+        record[key] = value;
+    }
     let config;
     for (const [index, arg] of args.entries()) {
         if (fields[index]) {
@@ -58,7 +67,7 @@ export const buildClientParams = (args, fields) => {
                 const field = map.get(config.key);
                 const name = field.map || config.key;
                 if (field.in) {
-                    params[field.in][name] = arg;
+                    writeSlot(field.in, name, arg);
                 }
             }
             else {
@@ -71,7 +80,7 @@ export const buildClientParams = (args, fields) => {
                 if (field) {
                     if (field.in) {
                         const name = field.map || key;
-                        params[field.in][name] = value;
+                        writeSlot(field.in, name, value);
                     }
                     else {
                         params[field.map] = value;
@@ -81,12 +90,12 @@ export const buildClientParams = (args, fields) => {
                     const extra = extraPrefixes.find(([prefix]) => key.startsWith(prefix));
                     if (extra) {
                         const [prefix, slot] = extra;
-                        params[slot][key.slice(prefix.length)] = value;
+                        writeSlot(slot, key.slice(prefix.length), value);
                     }
                     else if ('allowExtra' in config && config.allowExtra) {
                         for (const [slot, allowed] of Object.entries(config.allowExtra)) {
                             if (allowed) {
-                                params[slot][key] = value;
+                                writeSlot(slot, key, value);
                                 break;
                             }
                         }
@@ -97,4 +106,4 @@ export const buildClientParams = (args, fields) => {
     }
     stripEmptySlots(params);
     return params;
-};
+}

package/dist/api/core/queryKeySerializer.gen.d.ts

@@ -7,7 +7,7 @@ export type JsonValue = null | string | number | boolean | JsonValue[] | {
 /**
  * Replacer that converts non-JSON values (bigint, Date, etc.) to safe substitutes.
  */
-export declare const queryKeyJsonReplacer: (_key: string, value: unknown) => {} | null | undefined;
+export declare const queryKeyJsonReplacer: (_key: string, value: unknown) => unknown | undefined;
 /**
  * Safely stringifies a value and parses it back into a JsonValue.
  */

package/dist/api/core/serverSentEvents.gen.d.ts

@@ -68,4 +68,4 @@ export interface StreamEvent<TData = unknown> {
 export type ServerSentEventsResult<TData = unknown, TReturn = void, TNext = unknown> = {
     stream: AsyncGenerator<TData extends Record<string, unknown> ? TData[keyof TData] : TData, TReturn, TNext>;
 };
-export declare const createSseClient: <TData = unknown>({ onRequest, onSseError, onSseEvent, responseTransformer, responseValidator, sseDefaultRetryDelay, sseMaxRetryAttempts, sseMaxRetryDelay, sseSleepFn, url, ...options }: ServerSentEventsOptions) => ServerSentEventsResult<TData>;
+export declare function createSseClient<TData = unknown>({ onRequest, onSseError, onSseEvent, responseTransformer, responseValidator, sseDefaultRetryDelay, sseMaxRetryAttempts, sseMaxRetryDelay, sseSleepFn, url, ...options }: ServerSentEventsOptions): ServerSentEventsResult<TData>;

package/dist/api/core/serverSentEvents.gen.js

@@ -1,5 +1,5 @@
 // This file is auto-generated by @hey-api/openapi-ts
-export const createSseClient = ({ onRequest, onSseError, onSseEvent, responseTransformer, responseValidator, sseDefaultRetryDelay, sseMaxRetryAttempts, sseMaxRetryDelay, sseSleepFn, url, ...options }) => {
+export function createSseClient({ onRequest, onSseError, onSseEvent, responseTransformer, responseValidator, sseDefaultRetryDelay, sseMaxRetryAttempts, sseMaxRetryDelay, sseSleepFn, url, ...options }) {
     let lastEventId;
     const sleep = sseSleepFn ?? ((ms) => new Promise((resolve) => setTimeout(resolve, ms)));
     const createStream = async function* () {
@@ -53,8 +53,7 @@ export const createSseClient = ({ onRequest, onSseError, onSseEvent, responseTra
                         if (done)
                             break;
                         buffer += value;
-                        // Normalize line endings: CRLF -> LF, then CR -> LF
-                        buffer = buffer.replace(/\r\n/g, '\n').replace(/\r/g, '\n');
+                        buffer = buffer.replace(/\r\n?/g, '\n'); // normalize line endings
                         const chunks = buffer.split('\n\n');
                         buffer = chunks.pop() ?? '';
                         for (const chunk of chunks) {
@@ -130,4 +129,4 @@ export const createSseClient = ({ onRequest, onSseError, onSseEvent, responseTra
     };
     const stream = createStream();
     return { stream };
-};
+}

package/dist/api/core/types.gen.d.ts

@@ -71,6 +71,11 @@ export interface Config {
      */
     responseValidator?: (data: unknown) => Promise<unknown>;
 }
+/**
+ * Arbitrary metadata passed through the `meta` request option.
+ */
+export interface ClientMeta {
+}
 type IsExactlyNeverOrNeverUndefined<T> = [T] extends [never] ? true : [T] extends [never | undefined] ? [undefined] extends [T] ? false : true : false;
 export type OmitNever<T extends Record<string, unknown>> = {
     [K in keyof T as IsExactlyNeverOrNeverUndefined<T[K]> extends true ? never : K]: T[K];

package/dist/api/sdk.gen.d.ts

@@ -1,4 +1,4 @@
-import type { Client, Options as Options2, TDataShape } from './client';
+import type { Client, ClientMeta, Options as Options2, RequestResult, TDataShape } from './client';
 import type { CancelPipelineData, CancelPipelineErrors, CancelPipelineResponses, ClearPipelineData, ClearPipelineErrors, ClearPipelineResponses, CreatePipelineData, CreatePipelineErrors, CreatePipelineResponses, DeleteData, DeleteErrors, DeleteResponses, GetPipelineData, GetPipelineErrors, GetPipelineResponses, GetProcessorsData, GetProcessorsErrors, GetProcessorsResponses, GetResultsData, GetResultsErrors, GetResultsResponses, ListPipelinesByStrategyData, ListPipelinesByStrategyErrors, ListPipelinesByStrategyResponses, ListPipelinesData, ListPipelinesErrors, ListPipelinesResponses, ListQueueData, ListQueueErrors, ListQueueResponses, PeekItemData, PeekItemErrors, PeekItemResponses, PipelineStatusData, PipelineStatusErrors, PipelineStatusResponses, ProcessData, ProcessErrors, ProcessPipelineData, ProcessPipelineErrors, ProcessPipelineResponses, ProcessResponses, ReattachPipelineData, ReattachPipelineErrors, ReattachPipelineResponses, StartPipelineData, StartPipelineErrors, StartPipelineResponses, UpdatePipelineData, UpdatePipelineErrors, UpdatePipelineResponses } from './types.gen';
 export type Options<TData extends TDataShape = TDataShape, ThrowOnError extends boolean = boolean, TResponse = unknown> = Options2<TData, ThrowOnError, TResponse> & {
     /**
@@ -11,32 +11,32 @@ export type Options<TData extends TDataShape = TDataShape, ThrowOnError extends
      * You can pass arbitrary values through the `meta` object. This can be
      * used to access values that aren't defined as part of the SDK function.
      */
-    meta?: Record<string, unknown>;
+    meta?: keyof ClientMeta extends never ? Record<string, unknown> : ClientMeta;
 };
 export declare class PipelinesService {
-    static cancelPipeline<ThrowOnError extends boolean = true>(options: Options<CancelPipelineData, ThrowOnError>): import("./client").RequestResult<CancelPipelineResponses, CancelPipelineErrors, ThrowOnError, "fields">;
-    static clearPipeline<ThrowOnError extends boolean = true>(options: Options<ClearPipelineData, ThrowOnError>): import("./client").RequestResult<ClearPipelineResponses, ClearPipelineErrors, ThrowOnError, "fields">;
-    static createPipeline<ThrowOnError extends boolean = true>(options?: Options<CreatePipelineData, ThrowOnError>): import("./client").RequestResult<CreatePipelineResponses, CreatePipelineErrors, ThrowOnError, "fields">;
-    static getPipeline<ThrowOnError extends boolean = true>(options: Options<GetPipelineData, ThrowOnError>): import("./client").RequestResult<GetPipelineResponses, GetPipelineErrors, ThrowOnError, "fields">;
-    static getProcessors<ThrowOnError extends boolean = true>(options?: Options<GetProcessorsData, ThrowOnError>): import("./client").RequestResult<GetProcessorsResponses, GetProcessorsErrors, ThrowOnError, "fields">;
-    static getResults<ThrowOnError extends boolean = true>(options: Options<GetResultsData, ThrowOnError>): import("./client").RequestResult<GetResultsResponses, GetResultsErrors, ThrowOnError, "fields">;
-    static listPipelines<ThrowOnError extends boolean = true>(options: Options<ListPipelinesData, ThrowOnError>): import("./client").RequestResult<ListPipelinesResponses, ListPipelinesErrors, ThrowOnError, "fields">;
-    static listPipelinesByStrategy<ThrowOnError extends boolean = true>(options: Options<ListPipelinesByStrategyData, ThrowOnError>): import("./client").RequestResult<ListPipelinesByStrategyResponses, ListPipelinesByStrategyErrors, ThrowOnError, "fields">;
-    static pipelineStatus<ThrowOnError extends boolean = true>(options: Options<PipelineStatusData, ThrowOnError>): import("./client").RequestResult<PipelineStatusResponses, PipelineStatusErrors, ThrowOnError, "fields">;
-    static processPipeline<ThrowOnError extends boolean = true>(options: Options<ProcessPipelineData, ThrowOnError>): import("./client").RequestResult<ProcessPipelineResponses, ProcessPipelineErrors, ThrowOnError, "fields">;
-    static reattachPipeline<ThrowOnError extends boolean = true>(options: Options<ReattachPipelineData, ThrowOnError>): import("./client").RequestResult<ReattachPipelineResponses, ReattachPipelineErrors, ThrowOnError, "fields">;
-    static startPipeline<ThrowOnError extends boolean = true>(options?: Options<StartPipelineData, ThrowOnError>): import("./client").RequestResult<StartPipelineResponses, StartPipelineErrors, ThrowOnError, "fields">;
-    static updatePipeline<ThrowOnError extends boolean = true>(options: Options<UpdatePipelineData, ThrowOnError>): import("./client").RequestResult<UpdatePipelineResponses, UpdatePipelineErrors, ThrowOnError, "fields">;
+    static cancelPipeline<ThrowOnError extends boolean = true>(options: Options<CancelPipelineData, ThrowOnError>): RequestResult<CancelPipelineResponses, CancelPipelineErrors, ThrowOnError>;
+    static clearPipeline<ThrowOnError extends boolean = true>(options: Options<ClearPipelineData, ThrowOnError>): RequestResult<ClearPipelineResponses, ClearPipelineErrors, ThrowOnError>;
+    static createPipeline<ThrowOnError extends boolean = true>(options?: Options<CreatePipelineData, ThrowOnError>): RequestResult<CreatePipelineResponses, CreatePipelineErrors, ThrowOnError>;
+    static getPipeline<ThrowOnError extends boolean = true>(options: Options<GetPipelineData, ThrowOnError>): RequestResult<GetPipelineResponses, GetPipelineErrors, ThrowOnError>;
+    static getProcessors<ThrowOnError extends boolean = true>(options?: Options<GetProcessorsData, ThrowOnError>): RequestResult<GetProcessorsResponses, GetProcessorsErrors, ThrowOnError>;
+    static getResults<ThrowOnError extends boolean = true>(options: Options<GetResultsData, ThrowOnError>): RequestResult<GetResultsResponses, GetResultsErrors, ThrowOnError>;
+    static listPipelines<ThrowOnError extends boolean = true>(options: Options<ListPipelinesData, ThrowOnError>): RequestResult<ListPipelinesResponses, ListPipelinesErrors, ThrowOnError>;
+    static listPipelinesByStrategy<ThrowOnError extends boolean = true>(options: Options<ListPipelinesByStrategyData, ThrowOnError>): RequestResult<ListPipelinesByStrategyResponses, ListPipelinesByStrategyErrors, ThrowOnError>;
+    static pipelineStatus<ThrowOnError extends boolean = true>(options: Options<PipelineStatusData, ThrowOnError>): RequestResult<PipelineStatusResponses, PipelineStatusErrors, ThrowOnError>;
+    static processPipeline<ThrowOnError extends boolean = true>(options: Options<ProcessPipelineData, ThrowOnError>): RequestResult<ProcessPipelineResponses, ProcessPipelineErrors, ThrowOnError>;
+    static reattachPipeline<ThrowOnError extends boolean = true>(options: Options<ReattachPipelineData, ThrowOnError>): RequestResult<ReattachPipelineResponses, ReattachPipelineErrors, ThrowOnError>;
+    static startPipeline<ThrowOnError extends boolean = true>(options?: Options<StartPipelineData, ThrowOnError>): RequestResult<StartPipelineResponses, StartPipelineErrors, ThrowOnError>;
+    static updatePipeline<ThrowOnError extends boolean = true>(options: Options<UpdatePipelineData, ThrowOnError>): RequestResult<UpdatePipelineResponses, UpdatePipelineErrors, ThrowOnError>;
 }
 export declare class QueuesService {
-    static delete<ThrowOnError extends boolean = true>(options: Options<DeleteData, ThrowOnError>): import("./client").RequestResult<DeleteResponses, DeleteErrors, ThrowOnError, "fields">;
-    static listQueue<ThrowOnError extends boolean = true>(options?: Options<ListQueueData, ThrowOnError>): import("./client").RequestResult<ListQueueResponses, ListQueueErrors, ThrowOnError, "fields">;
+    static delete<ThrowOnError extends boolean = true>(options: Options<DeleteData, ThrowOnError>): RequestResult<DeleteResponses, DeleteErrors, ThrowOnError>;
+    static listQueue<ThrowOnError extends boolean = true>(options?: Options<ListQueueData, ThrowOnError>): RequestResult<ListQueueResponses, ListQueueErrors, ThrowOnError>;
     /**
      * Peek an item from the queue
      */
-    static peekItem<ThrowOnError extends boolean = true>(options?: Options<PeekItemData, ThrowOnError>): import("./client").RequestResult<PeekItemResponses, PeekItemErrors, ThrowOnError, "fields">;
+    static peekItem<ThrowOnError extends boolean = true>(options?: Options<PeekItemData, ThrowOnError>): RequestResult<PeekItemResponses, PeekItemErrors, ThrowOnError>;
     /**
      * Takes an item off the queue, removes the schedule date and puts it back
      */
-    static process<ThrowOnError extends boolean = true>(options: Options<ProcessData, ThrowOnError>): import("./client").RequestResult<ProcessResponses, ProcessErrors, ThrowOnError, "fields">;
+    static process<ThrowOnError extends boolean = true>(options: Options<ProcessData, ThrowOnError>): RequestResult<ProcessResponses, ProcessErrors, ThrowOnError>;
 }

package/dist/api/types.gen.d.ts

@@ -56,7 +56,8 @@ export type PipelineRunRejected = {
 export declare enum PipelineRunRejectedReason {
     NOT_FOUND = "NotFound",
     ALREADY_RUNNING = "AlreadyRunning",
-    INVALID = "Invalid"
+    INVALID = "Invalid",
+    NOT_WAITING = "NotWaiting"
 }
 export type PipelineRunRequest = {
     processor: string;

package/dist/api/types.gen.js

@@ -4,6 +4,7 @@ export var PipelineRunRejectedReason;
     PipelineRunRejectedReason["NOT_FOUND"] = "NotFound";
     PipelineRunRejectedReason["ALREADY_RUNNING"] = "AlreadyRunning";
     PipelineRunRejectedReason["INVALID"] = "Invalid";
+    PipelineRunRejectedReason["NOT_WAITING"] = "NotWaiting";
 })(PipelineRunRejectedReason || (PipelineRunRejectedReason = {}));
 export var PipelineRunState;
 (function (PipelineRunState) {

package/dist/index.js

@@ -6,7 +6,15 @@ import './api/index.js';
 import { manifests as modals } from './pipeline/modal/manifest.js';
 import { manifests as pipelines } from './pipeline/workspace/manifest.js';
 import { manifests as localizations } from './lang/manifest.js';
+import { UMB_AUTH_CONTEXT } from '@umbraco-cms/backoffice/auth';
+import { client } from './api/client.gen.js';
 export * from './exports.js';
-export const onInit = (_host, extensions) => {
+export const onInit = async (host, extensions) => {
     extensions.registerMany([...modals, ...pipelines, ...localizations]);
+    const authContext = await host.getContext(UMB_AUTH_CONTEXT);
+    if (!authContext) {
+        console.warn('UMB_AUTH_CONTEXT not available — extension API client will not be authenticated');
+        return;
+    }
+    authContext.configureClient(client);
 };

package/dist/queue/queue.context.js

@@ -24,7 +24,9 @@ export class QueueContext extends UmbControllerBase {
     }
     async loadQueue() {
         const queue = await __classPrivateFieldGet(this, _QueueContext_repository, "f").list();
-        __classPrivateFieldGet(this, _QueueContext_queue, "f").setValue(queue);
+        // undefined means the request failed, so keep the last list rather than clearing it.
+        if (queue)
+            __classPrivateFieldGet(this, _QueueContext_queue, "f").setValue(queue);
         return queue;
     }
     async process(key) {

package/dist/queue/queue.repository.js

@@ -1,32 +1,33 @@
 import { UmbControllerBase } from '@umbraco-cms/backoffice/class-api';
+import { tryExecute } from '@umbraco-cms/backoffice/resources';
 import { QueuesService } from '../api';
 export class QueueRepository extends UmbControllerBase {
     constructor(host) {
         super(host);
     }
     async list() {
-        return (await QueuesService.listQueue()).data;
+        return (await tryExecute(this, QueuesService.listQueue())).data;
     }
     async peek(key) {
-        return (await QueuesService.peekItem({
+        return (await tryExecute(this, QueuesService.peekItem({
             query: {
                 key: key,
             },
-        })).data;
+        }))).data;
     }
     async delete(key) {
-        return (await QueuesService.delete({
+        return (await tryExecute(this, QueuesService.delete({
             path: {
                 key: key,
             },
-        })).data;
+        }))).data;
     }
     async process(key) {
-        return (await QueuesService.process({
+        return (await tryExecute(this, QueuesService.process({
             path: {
                 key: key,
             },
-        })).data;
+        }))).data;
     }
 }
 export default QueueRepository;

package/package.json

@@ -1,7 +1,7 @@
 {
 	"name": "@jumoo/processing",
 	"licence": "custom",
-	"version": "17.5.1",
+	"version": "17.5.2",
 	"type": "module",
 	"description": "Jumoo processing library",
 	"exports": {
@@ -38,7 +38,7 @@
 	},
 	"devDependencies": {
 		"@eslint/js": "^10.0.1",
-		"@hey-api/openapi-ts": "^0.95.0",
+		"@hey-api/openapi-ts": "^0.99.0",
 		"@microsoft/signalr": "^10.0.0",
 		"@umbraco-cms/backoffice": "^17.3.0",
 		"eslint": "^10.13.0",
@@ -46,7 +46,7 @@
 		"lit": "^3.3.2",
 		"prettier": "^3.9.10",
 		"typescript": "^6.0.3",
-		"typescript-eslint": "^8.72.0",
+		"typescript-eslint": "^8.72.1",
 		"vite": "^8.3.5",
 		"vite-plugin-dts": "^5.1.2"
 	},

package/dist/hey-api.d.ts

@@ -1,11 +0,0 @@
-import type { CreateClientConfig } from './api/client.gen';
-/**
- * Pre-configure the generated client by copying the Umbraco HTTP client's config.
- *
- * Called automatically by the generated client during initialization (via runtimeConfigPath).
- * Inherits baseUrl, credentials, auth, and headers from umbHttpClient — which is already
- * configured by the backoffice before extensions load.
- *
- * @see https://heyapi.dev/openapi-ts/clients/fetch#configuration
- */
-export declare const createClientConfig: CreateClientConfig;

package/dist/hey-api.js

@@ -1,14 +0,0 @@
-import { umbHttpClient } from '@umbraco-cms/backoffice/http-client';
-/**
- * Pre-configure the generated client by copying the Umbraco HTTP client's config.
- *
- * Called automatically by the generated client during initialization (via runtimeConfigPath).
- * Inherits baseUrl, credentials, auth, and headers from umbHttpClient — which is already
- * configured by the backoffice before extensions load.
- *
- * @see https://heyapi.dev/openapi-ts/clients/fetch#configuration
- */
-export const createClientConfig = (config) => ({
-    ...config,
-    ...umbHttpClient.getConfig(),
-});