@jumoo/usync-expansions 17.6.0 → 18.3.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: 'https://localhost:44317', throwOnError: true })));
+export const client = createClient(createConfig({ baseUrl: 'https://localhost:44385/' }));

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 { FilesService, ItemsService, LicenceService, type Options, RestoreService } from './sdk.gen';
-export { type Assembly, type AssemblyWritable, CallingConventions, ChangeDetailType, ChangeType, type CheckLegacyData, type CheckLegacyErrors, type CheckLegacyResponse, type CheckLegacyResponses, type CleanData, type CleanErrors, type CleanResponses, type ClientOptions, type ConstructorInfo, type ConstructorInfoWritable, type CustomAttributeData, type CustomAttributeDataWritable, type CustomAttributeNamedArgument, type CustomAttributeNamedArgumentWritable, type CustomAttributeTypedArgument, type CustomAttributeTypedArgumentWritable, DependencyFlags, EventAttributes, type EventInfo, type EventInfoWritable, type Exception, type ExceptionWritable, FieldAttributes, type FieldInfo, type FieldInfoWritable, GenericParameterAttributes, type GetActionViewData, type GetActionViewErrors, type GetActionViewResponse, type GetActionViewResponses, type GetAllData, type GetAllErrors, type GetAllResponse, type GetAllResponses, type GetLicenceData, type GetLicenceErrors, type GetLicenceResponse, type GetLicenceResponses, type GetLicenceStatusData, type GetLicenceStatusErrors, type GetLicenceStatusResponse, type GetLicenceStatusResponses, type GetReportData, type GetReportErrors, type GetReportResponse, type GetReportResponses, type GetRestorePointData, type GetRestorePointErrors, type GetRestorePointResponse, type GetRestorePointResponses, type GetSyncItemData, type GetSyncItemErrors, type GetSyncItemResponse, type GetSyncItemResponses, type HasRootFilesData, type HasRootFilesErrors, type HasRootFilesResponse, type HasRootFilesResponses, type ICustomAttributeProvider, type IntPtr, type IsLicencedData, type IsLicencedErrors, type IsLicencedResponse, type IsLicencedResponses, LayoutKind, type Licence, type LicencedProduct, type LicenceInfo, LicenceStatus, type LicenceStatusView, LicenceType, type LicenceWritable, type MemberInfo, type MemberInfoWritable, MemberTypes, MethodAttributes, type MethodBase, type MethodBaseWritable, MethodImplAttributes, type MethodInfo, type MethodInfoWritable, type Module, type ModuleHandle, type ModuleWritable, ParameterAttributes, type ParameterInfo, type ParameterInfoWritable, PropertyAttributes, type PropertyInfo, type PropertyInfoWritable, type RemoveData, type RemoveErrors, type RemoveResponses, type RestorePoint, type RestorePointProcessingOptions, type RestorePointProcessingOptionsWritable, RestorePointStatus, type RuntimeFieldHandle, type RuntimeMethodHandle, type RuntimeTypeHandle, type SaveLicenceData, type SaveLicenceErrors, type SaveLicenceResponse, type SaveLicenceResponses, type ScanData, type ScanErrors, type ScanResponse, type ScanResponses, SecurityRuleSet, type StructLayoutAttribute, type StructLayoutAttributeWritable, type SyncEntity, type SyncEntityWritable, type SyncItem, type SyncItemWritable, type SyncPackAttributes, type SyncPackOptions, type Type, TypeAttributes, type TypeInfo, type TypeInfoWritable, type TypeWritable, type UdiModel, type USyncAction, type USyncActionView, type USyncActionWritable, type USyncChange } from './types.gen';
+export { ChangeDetailType, ChangeType, type CheckLegacyData, type CheckLegacyErrors, type CheckLegacyResponse, type CheckLegacyResponses, type CleanData, type CleanErrors, type CleanResponses, type ClientOptions, type Exception, type GetActionViewData, type GetActionViewErrors, type GetActionViewResponse, type GetActionViewResponses, type GetAllData, type GetAllErrors, type GetAllResponse, type GetAllResponses, type GetLicenceData, type GetLicenceErrors, type GetLicenceResponse, type GetLicenceResponses, type GetLicenceStatusData, type GetLicenceStatusErrors, type GetLicenceStatusResponse, type GetLicenceStatusResponses, type GetReportData, type GetReportErrors, type GetReportResponse, type GetReportResponses, type GetRestorePointData, type GetRestorePointErrors, type GetRestorePointResponse, type GetRestorePointResponses, type GetSyncItemData, type GetSyncItemErrors, type GetSyncItemResponse, type GetSyncItemResponses, type HasRootFilesData, type HasRootFilesErrors, type HasRootFilesResponse, type HasRootFilesResponses, type IsLicencedData, type IsLicencedErrors, type IsLicencedResponse, type IsLicencedResponses, type Licence, type LicencedProduct, type LicenceInfo, LicenceStatus, type LicenceStatusView, LicenceType, type MethodBase, type RemoveData, type RemoveErrors, type RemoveResponses, type RestorePoint, type RestorePointProcessingOptions, RestorePointStatus, type SaveLicenceData, type SaveLicenceErrors, type SaveLicenceResponse, type SaveLicenceResponses, type ScanData, type ScanErrors, type ScanResponse, type ScanResponses, SyncDependencyFlags, type SyncEntity, type UdiModel, type USyncAction, type USyncActionView, type USyncChange } 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 { FilesService, ItemsService, LicenceService, RestoreService } from './sdk.gen';
-export { CallingConventions, ChangeDetailType, ChangeType, DependencyFlags, EventAttributes, FieldAttributes, GenericParameterAttributes, LayoutKind, LicenceStatus, LicenceType, MemberTypes, MethodAttributes, MethodImplAttributes, ParameterAttributes, PropertyAttributes, RestorePointStatus, SecurityRuleSet, TypeAttributes } from './types.gen';
+export { ChangeDetailType, ChangeType, LicenceStatus, LicenceType, RestorePointStatus, SyncDependencyFlags } from './types.gen';

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 { CheckLegacyData, CheckLegacyErrors, CheckLegacyResponses, CleanData, CleanErrors, CleanResponses, GetActionViewData, GetActionViewErrors, GetActionViewResponses, GetAllData, GetAllErrors, GetAllResponses, GetLicenceData, GetLicenceErrors, GetLicenceResponses, GetLicenceStatusData, GetLicenceStatusErrors, GetLicenceStatusResponses, GetReportData, GetReportErrors, GetReportResponses, GetRestorePointData, GetRestorePointErrors, GetRestorePointResponses, GetSyncItemData, GetSyncItemErrors, GetSyncItemResponses, HasRootFilesData, HasRootFilesErrors, HasRootFilesResponses, IsLicencedData, IsLicencedErrors, IsLicencedResponses, RemoveData, RemoveErrors, RemoveResponses, SaveLicenceData, SaveLicenceErrors, SaveLicenceResponses, ScanData, ScanErrors, ScanResponses } from './types.gen';
 export type Options<TData extends TDataShape = TDataShape, ThrowOnError extends boolean = boolean, TResponse = unknown> = Options2<TData, ThrowOnError, TResponse> & {
     /**
@@ -11,27 +11,27 @@ 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 FilesService {
-    static hasRootFiles<ThrowOnError extends boolean = true>(options?: Options<HasRootFilesData, ThrowOnError>): import("./client").RequestResult<HasRootFilesResponses, HasRootFilesErrors, ThrowOnError, "fields">;
+    static hasRootFiles<ThrowOnError extends boolean = false>(options?: Options<HasRootFilesData, ThrowOnError>): RequestResult<HasRootFilesResponses, HasRootFilesErrors, ThrowOnError>;
 }
 export declare class ItemsService {
-    static getActionView<ThrowOnError extends boolean = true>(options?: Options<GetActionViewData, ThrowOnError>): import("./client").RequestResult<GetActionViewResponses, GetActionViewErrors, ThrowOnError, "fields">;
-    static getSyncItem<ThrowOnError extends boolean = true>(options?: Options<GetSyncItemData, ThrowOnError>): import("./client").RequestResult<GetSyncItemResponses, GetSyncItemErrors, ThrowOnError, "fields">;
+    static getActionView<ThrowOnError extends boolean = false>(options?: Options<GetActionViewData, ThrowOnError>): RequestResult<GetActionViewResponses, GetActionViewErrors, ThrowOnError>;
+    static getSyncItem<ThrowOnError extends boolean = false>(options?: Options<GetSyncItemData, ThrowOnError>): RequestResult<GetSyncItemResponses, GetSyncItemErrors, ThrowOnError>;
 }
 export declare class LicenceService {
-    static checkLegacy<ThrowOnError extends boolean = true>(options?: Options<CheckLegacyData, ThrowOnError>): import("./client").RequestResult<CheckLegacyResponses, CheckLegacyErrors, ThrowOnError, "fields">;
-    static getLicence<ThrowOnError extends boolean = true>(options?: Options<GetLicenceData, ThrowOnError>): import("./client").RequestResult<GetLicenceResponses, GetLicenceErrors, ThrowOnError, "fields">;
-    static getLicenceStatus<ThrowOnError extends boolean = true>(options?: Options<GetLicenceStatusData, ThrowOnError>): import("./client").RequestResult<GetLicenceStatusResponses, GetLicenceStatusErrors, ThrowOnError, "fields">;
-    static isLicenced<ThrowOnError extends boolean = true>(options?: Options<IsLicencedData, ThrowOnError>): import("./client").RequestResult<IsLicencedResponses, IsLicencedErrors, ThrowOnError, "fields">;
-    static saveLicence<ThrowOnError extends boolean = true>(options?: Options<SaveLicenceData, ThrowOnError>): import("./client").RequestResult<SaveLicenceResponses, SaveLicenceErrors, ThrowOnError, "fields">;
+    static checkLegacy<ThrowOnError extends boolean = false>(options?: Options<CheckLegacyData, ThrowOnError>): RequestResult<CheckLegacyResponses, CheckLegacyErrors, ThrowOnError>;
+    static getLicence<ThrowOnError extends boolean = false>(options?: Options<GetLicenceData, ThrowOnError>): RequestResult<GetLicenceResponses, GetLicenceErrors, ThrowOnError>;
+    static getLicenceStatus<ThrowOnError extends boolean = false>(options?: Options<GetLicenceStatusData, ThrowOnError>): RequestResult<GetLicenceStatusResponses, GetLicenceStatusErrors, ThrowOnError>;
+    static isLicenced<ThrowOnError extends boolean = false>(options?: Options<IsLicencedData, ThrowOnError>): RequestResult<IsLicencedResponses, IsLicencedErrors, ThrowOnError>;
+    static saveLicence<ThrowOnError extends boolean = false>(options: Options<SaveLicenceData, ThrowOnError>): RequestResult<SaveLicenceResponses, SaveLicenceErrors, ThrowOnError>;
 }
 export declare class RestoreService {
-    static clean<ThrowOnError extends boolean = true>(options?: Options<CleanData, ThrowOnError>): import("./client").RequestResult<CleanResponses, CleanErrors, ThrowOnError, "fields">;
-    static getRestorePoint<ThrowOnError extends boolean = true>(options?: Options<GetRestorePointData, ThrowOnError>): import("./client").RequestResult<GetRestorePointResponses, GetRestorePointErrors, ThrowOnError, "fields">;
-    static getAll<ThrowOnError extends boolean = true>(options?: Options<GetAllData, ThrowOnError>): import("./client").RequestResult<GetAllResponses, GetAllErrors, ThrowOnError, "fields">;
-    static getReport<ThrowOnError extends boolean = true>(options?: Options<GetReportData, ThrowOnError>): import("./client").RequestResult<GetReportResponses, GetReportErrors, ThrowOnError, "fields">;
-    static remove<ThrowOnError extends boolean = true>(options?: Options<RemoveData, ThrowOnError>): import("./client").RequestResult<RemoveResponses, RemoveErrors, ThrowOnError, "fields">;
-    static scan<ThrowOnError extends boolean = true>(options?: Options<ScanData, ThrowOnError>): import("./client").RequestResult<ScanResponses, ScanErrors, ThrowOnError, "fields">;
+    static clean<ThrowOnError extends boolean = false>(options?: Options<CleanData, ThrowOnError>): RequestResult<CleanResponses, CleanErrors, ThrowOnError>;
+    static getRestorePoint<ThrowOnError extends boolean = false>(options?: Options<GetRestorePointData, ThrowOnError>): RequestResult<GetRestorePointResponses, GetRestorePointErrors, ThrowOnError>;
+    static getAll<ThrowOnError extends boolean = false>(options?: Options<GetAllData, ThrowOnError>): RequestResult<GetAllResponses, GetAllErrors, ThrowOnError>;
+    static getReport<ThrowOnError extends boolean = false>(options?: Options<GetReportData, ThrowOnError>): RequestResult<GetReportResponses, GetReportErrors, ThrowOnError>;
+    static remove<ThrowOnError extends boolean = false>(options?: Options<RemoveData, ThrowOnError>): RequestResult<RemoveResponses, RemoveErrors, ThrowOnError>;
+    static scan<ThrowOnError extends boolean = false>(options?: Options<ScanData, ThrowOnError>): RequestResult<ScanResponses, ScanErrors, ThrowOnError>;
 }