@jumoo/processing 17.4.3-prerelease.2 → 18.2.0

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: 'https://localhost:44348/' }));

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/index.d.ts

@@ -1,3 +1,2 @@
-export { client, type CreateClientConfig } from './client.gen';
-export { type Options, PipelinesService, QueuesService } from './sdk.gen';
-export { type ClearPipelineData, type ClearPipelineError, type ClearPipelineErrors, type ClearPipelineResponses, type ClientOptions, type CreatePipelineData, type CreatePipelineError, type CreatePipelineErrors, type CreatePipelineResponse, type CreatePipelineResponses, type DeleteData, type DeleteError, type DeleteErrors, type DeleteResponses, type GetPipelineData, type GetPipelineError, type GetPipelineErrors, type GetPipelineResponse, type GetPipelineResponses, type GetProcessorsData, type GetProcessorsError, type GetProcessorsErrors, type GetProcessorsResponse, type GetProcessorsResponses, type GetResultsData, type GetResultsError, type GetResultsErrors, type GetResultsResponse, type GetResultsResponses, type ListPipelinesByStrategyData, type ListPipelinesByStrategyError, type ListPipelinesByStrategyErrors, type ListPipelinesByStrategyResponse, type ListPipelinesByStrategyResponses, type ListPipelinesData, type ListPipelinesError, type ListPipelinesErrors, type ListPipelinesResponse, type ListPipelinesResponses, type ListQueueData, type ListQueueError, type ListQueueErrors, type ListQueueResponse, type ListQueueResponses, type PagedModelQueuedItemModel, type PeekItemData, type PeekItemError, type PeekItemErrors, type PeekItemResponse, type PeekItemResponses, type Pipeline, type PipelineBackgroundState, type PipelineCreateRequest, type PipelineState, PipelineStatus, type ProblemDetails, type ProcessData, type ProcessError, type ProcessErrors, type ProcessingChildRequestAction, type ProcessingErrorDetails, type ProcessingOptions, type ProcessingOptionsResults, type ProcessingRequest, type ProcessingRequestAction, type ProcessingResults, type ProcessPipelineData, type ProcessPipelineError, type ProcessPipelineErrors, type ProcessPipelineResponse, type ProcessPipelineResponses, type ProcessResponse, type ProcessResponses, type ProgressInformation, type QueuedItem, type ReattachPipelineData, type ReattachPipelineError, type ReattachPipelineErrors, type ReattachPipelineResponse, type ReattachPipelineResponses, type StepInfo, StepStatus, type UpdatePipelineData, type UpdatePipelineError, type UpdatePipelineErrors, type UpdatePipelineResponse, type UpdatePipelineResponses } from './types.gen';
+export { deleteProcessingDeleteQueueByKey, getProcessingGetPipelineById, getProcessingGetProcessors, getProcessingGetResultsById, getProcessingListPipelinesByStatus, getProcessingListPipelinesByStrategyByStrategyByStatus, getProcessingListQueue, getProcessingPeekItem, type Options, postProcessingClearPipelineById, postProcessingCreatePipeline, postProcessingProcessPipelineById, postProcessingProcessQueueByKey, postProcessingReattachPipelineById, postProcessingUpdatePipelineById } from './sdk.gen';
+export { type ClientOptions, type DeleteProcessingDeleteQueueByKeyData, type DeleteProcessingDeleteQueueByKeyError, type DeleteProcessingDeleteQueueByKeyErrors, type DeleteProcessingDeleteQueueByKeyResponses, type GetProcessingGetPipelineByIdData, type GetProcessingGetPipelineByIdError, type GetProcessingGetPipelineByIdErrors, type GetProcessingGetPipelineByIdResponse, type GetProcessingGetPipelineByIdResponses, type GetProcessingGetProcessorsData, type GetProcessingGetProcessorsError, type GetProcessingGetProcessorsErrors, type GetProcessingGetProcessorsResponse, type GetProcessingGetProcessorsResponses, type GetProcessingGetResultsByIdData, type GetProcessingGetResultsByIdError, type GetProcessingGetResultsByIdErrors, type GetProcessingGetResultsByIdResponse, type GetProcessingGetResultsByIdResponses, type GetProcessingListPipelinesByStatusData, type GetProcessingListPipelinesByStatusError, type GetProcessingListPipelinesByStatusErrors, type GetProcessingListPipelinesByStatusResponse, type GetProcessingListPipelinesByStatusResponses, type GetProcessingListPipelinesByStrategyByStrategyByStatusData, type GetProcessingListPipelinesByStrategyByStrategyByStatusError, type GetProcessingListPipelinesByStrategyByStrategyByStatusErrors, type GetProcessingListPipelinesByStrategyByStrategyByStatusResponse, type GetProcessingListPipelinesByStrategyByStrategyByStatusResponses, type GetProcessingListQueueData, type GetProcessingListQueueError, type GetProcessingListQueueErrors, type GetProcessingListQueueResponse, type GetProcessingListQueueResponses, type GetProcessingPeekItemData, type GetProcessingPeekItemError, type GetProcessingPeekItemErrors, type GetProcessingPeekItemResponse, type GetProcessingPeekItemResponses, type PagedModelQueuedItemModel, type Pipeline, type PipelineBackgroundState, type PipelineCreateRequest, type PipelineState, PipelineStatus, type PostProcessingClearPipelineByIdData, type PostProcessingClearPipelineByIdError, type PostProcessingClearPipelineByIdErrors, type PostProcessingClearPipelineByIdResponses, type PostProcessingCreatePipelineData, type PostProcessingCreatePipelineError, type PostProcessingCreatePipelineErrors, type PostProcessingCreatePipelineResponse, type PostProcessingCreatePipelineResponses, type PostProcessingProcessPipelineByIdData, type PostProcessingProcessPipelineByIdError, type PostProcessingProcessPipelineByIdErrors, type PostProcessingProcessPipelineByIdResponse, type PostProcessingProcessPipelineByIdResponses, type PostProcessingProcessQueueByKeyData, type PostProcessingProcessQueueByKeyError, type PostProcessingProcessQueueByKeyErrors, type PostProcessingProcessQueueByKeyResponse, type PostProcessingProcessQueueByKeyResponses, type PostProcessingReattachPipelineByIdData, type PostProcessingReattachPipelineByIdError, type PostProcessingReattachPipelineByIdErrors, type PostProcessingReattachPipelineByIdResponse, type PostProcessingReattachPipelineByIdResponses, type PostProcessingUpdatePipelineByIdData, type PostProcessingUpdatePipelineByIdError, type PostProcessingUpdatePipelineByIdErrors, type PostProcessingUpdatePipelineByIdResponse, type PostProcessingUpdatePipelineByIdResponses, type ProblemDetails, type ProcessingErrorDetails, type ProcessingOptions, type ProcessingOptionsResults, type ProcessingRequest, type ProcessingRequestAction, type ProcessingResults, type ProgressInformation, type QueuedItem, type StepInfo, StepStatus } from './types.gen';

package/dist/api/index.js

@@ -1,4 +1,3 @@
 // This file is auto-generated by @hey-api/openapi-ts
-export { client } from './client.gen';
-export { PipelinesService, QueuesService } from './sdk.gen';
+export { deleteProcessingDeleteQueueByKey, getProcessingGetPipelineById, getProcessingGetProcessors, getProcessingGetResultsById, getProcessingListPipelinesByStatus, getProcessingListPipelinesByStrategyByStrategyByStatus, getProcessingListQueue, getProcessingPeekItem, postProcessingClearPipelineById, postProcessingCreatePipeline, postProcessingProcessPipelineById, postProcessingProcessQueueByKey, postProcessingReattachPipelineById, postProcessingUpdatePipelineById } from './sdk.gen';
 export { PipelineStatus, StepStatus } from './types.gen';