jamespot-user-api 1.0.168 → 1.0.169

package/lib/src/apis/admin/license.d.ts

@@ -1,28 +1,55 @@
 import { JBaseApi } from '../base';
-import { AdminLicensesAssigned, AdminLicensesNotAssigned, AdminLicenseUserStats, ObjectWithoutLicenseFilter } from '../../types';
+import { AdminLicensesAssigned, AdminLicensesNotAssigned, FormatList, GetLicenseKindUsersParams, jUserLittle, ObjectWithoutLicenseFilter, PagingResults } from '../../types';
 export declare class AdminLicenseApi extends JBaseApi {
     /**
      * Retrieve the user licenses stats
      */
-    getLicenseUserStatistics(): Promise<import("../../types").ApiWrapper<AdminLicenseUserStats, import("../../types").BaseMessages>>;
+    getLicenseUserStatistics(signal?: AbortSignal): Promise<import("../../types").ApiWrapper<{
+        countLicensesAssigned: number;
+        countLicensesNotAssigned: number;
+        countActiveUsersWithoutLicense?: number | undefined;
+    }, import("../../types").BaseMessages>>;
+    /**
+     * Retrieve the licenses stats for a given kind
+     */
+    getLicenseStatistics(kind: string, signal?: AbortSignal): Promise<import("../../types").ApiWrapper<{
+        countLicensesAssigned: number;
+        countLicensesNotAssigned: number;
+        countActiveUsersWithoutLicense?: number | undefined;
+    }, import("../../types").BaseMessages>>;
     /**
      * Assigns a license to the content with the provided uri (if any is available)
      * @param uri URI of the object to which a license must be assigned
      * @returns boolean
      */
     assignLicense(uri: string): Promise<import("../../types").ApiWrapper<boolean, import("../../types").BaseMessages>>;
+    /**
+     * Assigns a license to a given kind with the provided uri (if any is available)
+     * @param uri URI of the object to which a license must be assigned
+     * @param kind the kind of license which must be assigned
+     * @returns boolean
+     */
+    assignKindLicense(uri: string, kind: string): Promise<import("../../types").ApiWrapper<boolean, import("../../types").BaseMessages>>;
     /**
      * Unassigns the license linked to the content with the provided uri
      * @param uri URI of the object to which a license must be unassigned
      * @returns boolean
      */
     unAssignLicense(uri: string): Promise<import("../../types").ApiWrapper<boolean, import("../../types").BaseMessages>>;
+    /**
+     * Unassigns the license linked to the given kind with the provided uri
+     * @param uri URI of the object to which a license must be unassigned
+     * @param kind the kind of license which must be unassigned
+     * @returns boolean
+     */
+    unAssignKindLicense(uri: string, kind: string): Promise<import("../../types").ApiWrapper<boolean, import("../../types").BaseMessages>>;
     /**
      * Retrieve the assignment license user mode between automatic | manual
      * @param type retrieve the automatic license assignation
+     * @param signal the signal to cancel the request
      * @returns a string who's the current assignment selected
      */
-    getAssignmentMode(type: string): Promise<import("../../types").ApiWrapper<string, import("../../types").BaseMessages>>;
+    getAssignmentMode(type: string, signal?: AbortSignal): Promise<import("../../types").ApiWrapper<string, import("../../types").BaseMessages>>;
     /**
      * Change the mode which the license are affected to the users
      * @param type the type of license that would automatically be assigned
@@ -39,9 +66,10 @@ export declare class AdminLicenseApi extends JBaseApi {
     /**
      * Unassign licenses for inactive users
      * @param type the type of licenses for which we will unassign upon inactive user
+     * @param kind particular license kind to unassign
      * @returns boolean
      */
-    unAssignUnusedLicenses(type: string): Promise<import("../../types").ApiWrapper<boolean, import("../../types").BaseMessages>>;
+    unAssignUnusedLicenses(type: string, kind?: string): Promise<import("../../types").ApiWrapper<boolean, import("../../types").BaseMessages>>;
     /**
      * Assign available licenses and unassign license for inactive users
      * @param type the type of licenses for which we will unassign and assign the possible licenses
@@ -71,4 +99,11 @@ export declare class AdminLicenseApi extends JBaseApi {
      * @returns The list of licenses assigned to content of the provided type
      */
     getLicensesAssigned(type: string): Promise<import("../../types").ApiWrapper<AdminLicensesAssigned[], import("../../types").BaseMessages>>;
+    getLicenceUsersByKind<T extends jUserLittle = jUserLittle>({ ...params }: GetLicenseKindUsersParams, format: FormatList, signal?: AbortSignal): Promise<import("../../types").ApiWrapper<PagingResults<import("zod").objectUtil.addQuestionMarks<import("zod").baseObjectOutputType<{
+        license: import("zod").ZodUnion<[import("zod").ZodLiteral<"1">, import("zod").ZodLiteral<"0">]>;
+        user: import("zod").ZodType<T, import("zod").ZodTypeDef, T>;
+    }>, "license" | (undefined extends T ? never : "user")> extends infer T_1 ? { [k_1 in keyof T_1]: import("zod").objectUtil.addQuestionMarks<import("zod").baseObjectOutputType<{
+        license: import("zod").ZodUnion<[import("zod").ZodLiteral<"1">, import("zod").ZodLiteral<"0">]>;
+        user: import("zod").ZodType<T, import("zod").ZodTypeDef, T>;
+    }>, "license" | (undefined extends T ? never : "user")>[k_1]; } : never>, import("../../types").BaseMessages>>;
 }

package/lib/src/apis/admin/licenses.mock.d.ts

@@ -1,7 +1,12 @@
-import { AdminLicensesNotAssigned, ApiWrapper, License } from '../../types';
+import { AdminLicensesNotAssigned, AdminLicenseStats, ApiWrapper, jUserList, License, PagingResults, UserLicense } from '../../types';
 export declare const licenseManagerAssignLicenseDefault: ApiWrapper<boolean>;
 export declare const licenseManagerAssignLicenseIsAssign: ApiWrapper<boolean>;
 export declare const licenseManagerCountLicensesNotAssignedCount: ApiWrapper<AdminLicensesNotAssigned>;
 export declare const licenseManagerGetLicensesAssignedDefault: ApiWrapper<Array<License>>;
 export declare const licenseManagerUnassignLicenseDefault: ApiWrapper<boolean>;
 export declare const licenseManagerUnassignLicenseIsUnassign: ApiWrapper<boolean>;
+export declare const licenseManagerGetLicenseStatistics: ApiWrapper<AdminLicenseStats>;
+export declare const licenseManagerAssignHookLicense: ApiWrapper<boolean>;
+export declare const licenseManagerUnAssignHookLicense: ApiWrapper<boolean>;
+export declare const licenseManagerUnAssignUnusedLicenses: ApiWrapper<boolean>;
+export declare const licenseManagerGetHookUsers: ApiWrapper<PagingResults<UserLicense<jUserList>>>;

package/lib/src/apis/admin/utils.d.ts

@@ -4,5 +4,5 @@ export declare class AdminUtilsApi extends JBaseApi {
     /**
      * Request the admin applications and sub applications for the admin panel
      */
-    getApps(): Promise<import("../../types").ApiWrapper<AdminApps, import("../../types").BaseMessages>>;
+    getApps(signal?: AbortSignal): Promise<import("../../types").ApiWrapper<AdminApps, import("../../types").BaseMessages>>;
 }

package/lib/src/apis/jamespotUserApi.d.ts

@@ -32,6 +32,7 @@ import { JSocialActionApi } from './socialAction/socialAction';
 import { JBusinessNetworkingApi } from './businessNetworking/businessNetworking';
 import { JIAApi } from './jia/jia';
 import { JWidgetApi } from './widget/widget';
+import { JMagicPadApi } from './magicPad/magicPad';
 import { JBbbApi } from './bbb/bbb';
 /**
  * In browser usage, 'window' should be the window object.
@@ -69,6 +70,7 @@ export declare class JamespotUserApi {
     group: JGroupApi;
     jia: JIAApi;
     jland: JLandApi;
+    magicPad: JMagicPadApi;
     mediaLibrary: JMediaLibraryApi;
     messenger: JMessengerApi;
     object: JObjectApi;

package/lib/src/apis/magicPad/magicPad.d.ts

@@ -0,0 +1,6 @@
+import { JBaseApi } from '../base';
+import { ApiWrapper } from '../../types';
+import { MagicPadThumbnail } from '../../types/magicPad';
+export declare class JMagicPadApi extends JBaseApi {
+    getThumbnailUrl(uri: string): Promise<ApiWrapper<MagicPadThumbnail>>;
+}

package/lib/src/apis/magicPad/magicPad.mock.d.ts

@@ -0,0 +1,3 @@
+import { ApiWrapper } from '../../types';
+import { MagicPadThumbnail } from '../../types/magicPad';
+export declare const magicPadGetThumbnailUrl: ApiWrapper<MagicPadThumbnail>;

package/lib/src/apis/magicPad/magicPad.test.d.ts

@@ -0,0 +1 @@
+export {};

package/lib/src/types/adminLicence.d.ts

@@ -1,10 +1,20 @@
 import { jUserList } from './user';
 import { ObjectListProps } from './utils';
-export type AdminLicenseUserStats = {
-    countActiveUsersWithoutLicense: number;
+import { z } from 'zod';
+export declare const adminLicenseStatsSchema: z.ZodObject<{
+    countActiveUsersWithoutLicense: z.ZodOptional<z.ZodNumber>;
+    countLicensesAssigned: z.ZodNumber;
+    countLicensesNotAssigned: z.ZodNumber;
+}, "strip", z.ZodTypeAny, {
     countLicensesAssigned: number;
     countLicensesNotAssigned: number;
-};
+    countActiveUsersWithoutLicense?: number | undefined;
+}, {
+    countLicensesAssigned: number;
+    countLicensesNotAssigned: number;
+    countActiveUsersWithoutLicense?: number | undefined;
+}>;
+export type AdminLicenseStats = z.infer<typeof adminLicenseStatsSchema>;
 export type ObjectWithoutLicenseFilter = {
     name: string;
     operator: string;

package/lib/src/types/adminUtils.d.ts

@@ -4,6 +4,8 @@ export type AdminAppTab = {
     idDiv: string;
     label: string;
     icon: string;
+    licenseMode?: 'classic';
+    hook?: string;
 };
 export type AdminApp = {
     name: string;

package/lib/src/types/hook.d.ts

@@ -7,6 +7,14 @@ declare const buildHookSchema: <T extends z.ZodTypeAny>(hookType: T) => z.ZodInt
     isActive: boolean;
 }>, T>;
 export type HookType<T extends object = {}> = z.infer<ReturnType<typeof buildHookSchema<ZodType<T>>>>;
+declare const buildLicenceHookSchema: <T extends z.ZodTypeAny>(hookType: T) => z.ZodIntersection<z.ZodObject<{
+    isActive: z.ZodBoolean;
+}, "strip", z.ZodTypeAny, {
+    isActive: boolean;
+}, {
+    isActive: boolean;
+}>, z.ZodTypeAny>;
+export type LicenceHookType<T extends object = {}> = z.infer<ReturnType<typeof buildLicenceHookSchema<ZodType<T>>>>;
 /**
  * Hook types
  */
@@ -96,10 +104,60 @@ declare const widgetHookSchema: z.ZodIntersection<z.ZodObject<{
     autorize: ("comment" | "message" | "board" | "article" | undefined)[];
 }>>;
 export type WidgetHook = z.infer<typeof widgetHookSchema>;
+declare const magicPadHookSchema: z.ZodIntersection<z.ZodObject<{
+    isActive: z.ZodBoolean;
+}, "strip", z.ZodTypeAny, {
+    isActive: boolean;
+}, {
+    isActive: boolean;
+}>, z.ZodObject<{
+    label: z.ZodString;
+    hasLicense: z.ZodBoolean;
+}, "strip", z.ZodTypeAny, {
+    label: string;
+    hasLicense: boolean;
+}, {
+    label: string;
+    hasLicense: boolean;
+}>>;
+export type MagicPadHook = z.infer<typeof magicPadHookSchema>;
 /**
  * HookListType
  */
-declare const hookListTypeSchema: z.ZodObject<{
+declare const licenseHookListTypeSchema: z.ZodObject<{
+    MagicPadHook: z.ZodOptional<z.ZodIntersection<z.ZodObject<{
+        isActive: z.ZodBoolean;
+    }, "strip", z.ZodTypeAny, {
+        isActive: boolean;
+    }, {
+        isActive: boolean;
+    }>, z.ZodObject<{
+        label: z.ZodString;
+        hasLicense: z.ZodBoolean;
+    }, "strip", z.ZodTypeAny, {
+        label: string;
+        hasLicense: boolean;
+    }, {
+        label: string;
+        hasLicense: boolean;
+    }>>>;
+}, "strip", z.ZodTypeAny, {
+    MagicPadHook?: ({
+        isActive: boolean;
+    } & {
+        label: string;
+        hasLicense: boolean;
+    }) | undefined;
+}, {
+    MagicPadHook?: ({
+        isActive: boolean;
+    } & {
+        label: string;
+        hasLicense: boolean;
+    }) | undefined;
+}>;
+export type LicenseHookListType = z.infer<typeof licenseHookListTypeSchema>;
+declare const hookListTypeSchema: z.ZodIntersection<z.ZodObject<{
     DriveHook: z.ZodOptional<z.ZodIntersection<z.ZodObject<{
         isActive: z.ZodBoolean;
     }, "strip", z.ZodTypeAny, {
@@ -240,7 +298,38 @@ declare const hookListTypeSchema: z.ZodObject<{
     } & {
         sendAlert: boolean;
     }) | undefined;
-}>;
+}>, z.ZodObject<{
+    MagicPadHook: z.ZodOptional<z.ZodIntersection<z.ZodObject<{
+        isActive: z.ZodBoolean;
+    }, "strip", z.ZodTypeAny, {
+        isActive: boolean;
+    }, {
+        isActive: boolean;
+    }>, z.ZodObject<{
+        label: z.ZodString;
+        hasLicense: z.ZodBoolean;
+    }, "strip", z.ZodTypeAny, {
+        label: string;
+        hasLicense: boolean;
+    }, {
+        label: string;
+        hasLicense: boolean;
+    }>>>;
+}, "strip", z.ZodTypeAny, {
+    MagicPadHook?: ({
+        isActive: boolean;
+    } & {
+        label: string;
+        hasLicense: boolean;
+    }) | undefined;
+}, {
+    MagicPadHook?: ({
+        isActive: boolean;
+    } & {
+        label: string;
+        hasLicense: boolean;
+    }) | undefined;
+}>>;
 export type HookListType = z.infer<typeof hookListTypeSchema>;
 export declare const validateIsFormatHookListType: (object: object) => HookListType;
 export {};

package/lib/src/types/index.d.ts

@@ -19,6 +19,7 @@ export * from './global';
 export * from './group';
 export * from './hook';
 export * from './jia';
+export * from './license';
 export * from './mediaLibrary';
 export * from './meeting';
 export * from './model';

package/lib/src/types/license.d.ts

@@ -0,0 +1,223 @@
+import { z, ZodType } from 'zod';
+import { jUserLittle } from './user';
+export declare const getLicenseKindUsersParamsSchema: z.ZodObject<{
+    kind: z.ZodString;
+    page: z.ZodNumber;
+    limit: z.ZodNumber;
+    filters: z.ZodOptional<z.ZodArray<z.ZodObject<{
+        name: z.ZodString;
+        value: z.ZodUnion<[z.ZodBoolean, z.ZodString, z.ZodNumber, z.ZodArray<z.ZodString, "many">, z.ZodObject<{
+            srcId: z.ZodUnion<[z.ZodNumber, z.ZodString]>;
+            srcType: z.ZodString;
+        }, "strip", z.ZodTypeAny, {
+            srcId: string | number;
+            srcType: string;
+        }, {
+            srcId: string | number;
+            srcType: string;
+        }>, z.ZodObject<{
+            targetId: z.ZodUnion<[z.ZodNumber, z.ZodString]>;
+            targetType: z.ZodString;
+        }, "strip", z.ZodTypeAny, {
+            targetId: string | number;
+            targetType: string;
+        }, {
+            targetId: string | number;
+            targetType: string;
+        }>, z.ZodObject<{
+            start: z.ZodString;
+            end: z.ZodString;
+        }, "strip", z.ZodTypeAny, {
+            start: string;
+            end: string;
+        }, {
+            start: string;
+            end: string;
+        }>]>;
+        operator: z.ZodOptional<z.ZodUnion<[z.ZodLiteral<"<">, z.ZodLiteral<">">, z.ZodLiteral<"<=">, z.ZodLiteral<">=">, z.ZodLiteral<"!=">, z.ZodLiteral<"<>">, z.ZodLiteral<"like">, z.ZodLiteral<"between">, z.ZodLiteral<"is">, z.ZodLiteral<"is not">, z.ZodLiteral<"in">, z.ZodLiteral<"link">, z.ZodLiteral<"match">, z.ZodLiteral<"equal">]>>;
+        method: z.ZodOptional<z.ZodUnion<[z.ZodLiteral<"<">, z.ZodLiteral<">">, z.ZodLiteral<"<=">, z.ZodLiteral<">=">, z.ZodLiteral<"!=">, z.ZodLiteral<"<>">, z.ZodLiteral<"+">, z.ZodLiteral<"-">, z.ZodLiteral<"like">, z.ZodLiteral<"between">, z.ZodLiteral<"is">, z.ZodLiteral<"is not">, z.ZodLiteral<"in">, z.ZodLiteral<"link">, z.ZodLiteral<"match">, z.ZodLiteral<"equal">]>>;
+        or: z.ZodOptional<z.ZodBoolean>;
+        isNull: z.ZodOptional<z.ZodBoolean>;
+        isNotNull: z.ZodOptional<z.ZodBoolean>;
+    }, "strip", z.ZodTypeAny, {
+        value: (string | number | boolean | string[] | {
+            srcId: string | number;
+            srcType: string;
+        } | {
+            targetId: string | number;
+            targetType: string;
+        } | {
+            start: string;
+            end: string;
+        }) & (string | number | boolean | string[] | {
+            srcId: string | number;
+            srcType: string;
+        } | {
+            targetId: string | number;
+            targetType: string;
+        } | {
+            start: string;
+            end: string;
+        } | undefined);
+        name: string;
+        operator?: "link" | "<" | ">" | "<=" | ">=" | "!=" | "<>" | "like" | "between" | "is" | "is not" | "in" | "match" | "equal" | undefined;
+        method?: "link" | "<" | ">" | "<=" | ">=" | "!=" | "<>" | "like" | "between" | "is" | "is not" | "in" | "match" | "equal" | "+" | "-" | undefined;
+        or?: boolean | undefined;
+        isNull?: boolean | undefined;
+        isNotNull?: boolean | undefined;
+    }, {
+        value: (string | number | boolean | string[] | {
+            srcId: string | number;
+            srcType: string;
+        } | {
+            targetId: string | number;
+            targetType: string;
+        } | {
+            start: string;
+            end: string;
+        }) & (string | number | boolean | string[] | {
+            srcId: string | number;
+            srcType: string;
+        } | {
+            targetId: string | number;
+            targetType: string;
+        } | {
+            start: string;
+            end: string;
+        } | undefined);
+        name: string;
+        operator?: "link" | "<" | ">" | "<=" | ">=" | "!=" | "<>" | "like" | "between" | "is" | "is not" | "in" | "match" | "equal" | undefined;
+        method?: "link" | "<" | ">" | "<=" | ">=" | "!=" | "<>" | "like" | "between" | "is" | "is not" | "in" | "match" | "equal" | "+" | "-" | undefined;
+        or?: boolean | undefined;
+        isNull?: boolean | undefined;
+        isNotNull?: boolean | undefined;
+    }>, "many">>;
+    orders: z.ZodOptional<z.ZodArray<z.ZodObject<{
+        name: z.ZodString;
+        sort: z.ZodUnion<[z.ZodLiteral<"ASC">, z.ZodLiteral<"DESC">]>;
+    }, "strip", z.ZodTypeAny, {
+        sort: "ASC" | "DESC";
+        name: string;
+    }, {
+        sort: "ASC" | "DESC";
+        name: string;
+    }>, "many">>;
+}, "strip", z.ZodTypeAny, {
+    limit: number;
+    page: number;
+    kind: string;
+    filters?: {
+        value: (string | number | boolean | string[] | {
+            srcId: string | number;
+            srcType: string;
+        } | {
+            targetId: string | number;
+            targetType: string;
+        } | {
+            start: string;
+            end: string;
+        }) & (string | number | boolean | string[] | {
+            srcId: string | number;
+            srcType: string;
+        } | {
+            targetId: string | number;
+            targetType: string;
+        } | {
+            start: string;
+            end: string;
+        } | undefined);
+        name: string;
+        operator?: "link" | "<" | ">" | "<=" | ">=" | "!=" | "<>" | "like" | "between" | "is" | "is not" | "in" | "match" | "equal" | undefined;
+        method?: "link" | "<" | ">" | "<=" | ">=" | "!=" | "<>" | "like" | "between" | "is" | "is not" | "in" | "match" | "equal" | "+" | "-" | undefined;
+        or?: boolean | undefined;
+        isNull?: boolean | undefined;
+        isNotNull?: boolean | undefined;
+    }[] | undefined;
+    orders?: {
+        sort: "ASC" | "DESC";
+        name: string;
+    }[] | undefined;
+}, {
+    limit: number;
+    page: number;
+    kind: string;
+    filters?: {
+        value: (string | number | boolean | string[] | {
+            srcId: string | number;
+            srcType: string;
+        } | {
+            targetId: string | number;
+            targetType: string;
+        } | {
+            start: string;
+            end: string;
+        }) & (string | number | boolean | string[] | {
+            srcId: string | number;
+            srcType: string;
+        } | {
+            targetId: string | number;
+            targetType: string;
+        } | {
+            start: string;
+            end: string;
+        } | undefined);
+        name: string;
+        operator?: "link" | "<" | ">" | "<=" | ">=" | "!=" | "<>" | "like" | "between" | "is" | "is not" | "in" | "match" | "equal" | undefined;
+        method?: "link" | "<" | ">" | "<=" | ">=" | "!=" | "<>" | "like" | "between" | "is" | "is not" | "in" | "match" | "equal" | "+" | "-" | undefined;
+        or?: boolean | undefined;
+        isNull?: boolean | undefined;
+        isNotNull?: boolean | undefined;
+    }[] | undefined;
+    orders?: {
+        sort: "ASC" | "DESC";
+        name: string;
+    }[] | undefined;
+}>;
+export type GetLicenseKindUsersParams = z.infer<typeof getLicenseKindUsersParamsSchema>;
+export declare const inferUserLicenseSchema: <T extends z.ZodType<z.objectOutputType<{
+    type: z.ZodString;
+    id: z.ZodNumber;
+    mainType: z.ZodString;
+    uri: z.ZodString;
+    title: z.ZodString;
+    _url: z.ZodString;
+    level: z.ZodNativeEnum<{
+        readonly ADMIN: 9;
+        readonly USER: 5;
+        readonly EXTERNAL: 3;
+        readonly GUEST: 0;
+    }>;
+    dateCreation: z.ZodString;
+    dateModified: z.ZodString;
+}, z.ZodUnion<[z.ZodNumber, z.ZodNullable<z.ZodString>, z.ZodNullable<z.ZodString>, z.ZodNullable<z.ZodString>, z.ZodString, z.ZodNumber, z.ZodNullable<z.ZodString>, z.ZodString, z.ZodString]>, "strip">, z.ZodTypeDef, z.objectOutputType<{
+    type: z.ZodString;
+    id: z.ZodNumber;
+    mainType: z.ZodString;
+    uri: z.ZodString;
+    title: z.ZodString;
+    _url: z.ZodString;
+    level: z.ZodNativeEnum<{
+        readonly ADMIN: 9;
+        readonly USER: 5;
+        readonly EXTERNAL: 3;
+        readonly GUEST: 0;
+    }>;
+    dateCreation: z.ZodString;
+    dateModified: z.ZodString;
+}, z.ZodUnion<[z.ZodNumber, z.ZodNullable<z.ZodString>, z.ZodNullable<z.ZodString>, z.ZodNullable<z.ZodString>, z.ZodString, z.ZodNumber, z.ZodNullable<z.ZodString>, z.ZodString, z.ZodString]>, "strip">>>(type: T) => z.ZodObject<{
+    license: z.ZodUnion<[z.ZodLiteral<"1">, z.ZodLiteral<"0">]>;
+    user: T;
+}, "strip", z.ZodTypeAny, z.objectUtil.addQuestionMarks<z.baseObjectOutputType<{
+    license: z.ZodUnion<[z.ZodLiteral<"1">, z.ZodLiteral<"0">]>;
+    user: T;
+}>, "license" | (undefined extends T["_output"] ? never : "user")> extends infer T_1 ? { [k_1 in keyof T_1]: z.objectUtil.addQuestionMarks<z.baseObjectOutputType<{
+    license: z.ZodUnion<[z.ZodLiteral<"1">, z.ZodLiteral<"0">]>;
+    user: T;
+}>, "license" | (undefined extends T["_output"] ? never : "user")>[k_1]; } : never, z.baseObjectInputType<{
+    license: z.ZodUnion<[z.ZodLiteral<"1">, z.ZodLiteral<"0">]>;
+    user: T;
+}> extends infer T_2 ? { [k_2 in keyof T_2]: z.baseObjectInputType<{
+    license: z.ZodUnion<[z.ZodLiteral<"1">, z.ZodLiteral<"0">]>;
+    user: T;
+}>[k_2]; } : never>;
+export type UserLicense<T extends jUserLittle> = z.infer<ReturnType<typeof inferUserLicenseSchema<ZodType<T>>>>;

package/lib/src/types/magicPad.d.ts

@@ -0,0 +1,9 @@
+import { z } from 'zod';
+export declare const magicPadGetThumbnailSchema: z.ZodObject<{
+    thumbnailUrl: z.ZodString;
+}, "strip", z.ZodTypeAny, {
+    thumbnailUrl: string;
+}, {
+    thumbnailUrl: string;
+}>;
+export type MagicPadThumbnail = z.infer<typeof magicPadGetThumbnailSchema>;

package/lib/src/types/search.d.ts

@@ -18,9 +18,7 @@ export interface SearchCategoryValue {
 export type FacetMode = 'AND' | 'OR';
 export interface SearchFacetModel {
     facetType: string;
-    facetOptions: any | {
-        uriTaxonomy: string;
-    };
+    facetOptions: Record<string, object | number | string> | Array<never>;
     facetMode?: FacetMode;
     field: string;
     title: string;

package/lib/src/types/utils.d.ts

@@ -170,17 +170,6 @@ export declare const audienceSchema: z.ZodUnion<[z.ZodLazy<z.ZodObject<{
     privacy: number;
 }>]>;
 export type Audience = z.infer<typeof audienceSchema>;
-export declare const ordersSchema: z.ZodArray<z.ZodObject<{
-    name: z.ZodString;
-    sort: z.ZodUnion<[z.ZodLiteral<"ASC">, z.ZodLiteral<"DESC">]>;
-}, "strip", z.ZodTypeAny, {
-    sort: "ASC" | "DESC";
-    name: string;
-}, {
-    sort: "ASC" | "DESC";
-    name: string;
-}>, "many">;
-export type Orders = z.infer<typeof ordersSchema>;
 export declare const filterValueSchema: z.ZodUnion<[z.ZodBoolean, z.ZodString, z.ZodNumber, z.ZodArray<z.ZodString, "many">, z.ZodObject<{
     srcId: z.ZodUnion<[z.ZodNumber, z.ZodString]>;
     srcType: z.ZodString;
@@ -299,6 +288,17 @@ export declare const filterSchema: z.ZodObject<{
     isNotNull?: boolean | undefined;
 }>;
 export type Filter = z.infer<typeof filterSchema>;
+export declare const ordersSchema: z.ZodArray<z.ZodObject<{
+    name: z.ZodString;
+    sort: z.ZodUnion<[z.ZodLiteral<"ASC">, z.ZodLiteral<"DESC">]>;
+}, "strip", z.ZodTypeAny, {
+    sort: "ASC" | "DESC";
+    name: string;
+}, {
+    sort: "ASC" | "DESC";
+    name: string;
+}>, "many">;
+export type Orders = z.infer<typeof ordersSchema>;
 export declare const filtersSchema: z.ZodArray<z.ZodObject<{
     name: z.ZodString;
     value: z.ZodUnion<[z.ZodBoolean, z.ZodString, z.ZodNumber, z.ZodArray<z.ZodString, "many">, z.ZodObject<{

package/lib/src/util/taxonomy.d.ts

@@ -1,5 +1,5 @@
 export declare function extractTaxonomiesFromObject(objet: Record<string, unknown>): Record<string, unknown>;
-export declare function extractTaxonomiesFromObjectAndMapProperty(objet: Record<string, unknown>, property: string, format?: (o: any) => any): {
-    [k: string]: any;
+export declare function extractTaxonomiesFromObjectAndMapProperty(objet: Record<string, unknown>, property: string, format?: (o: string[]) => string): {
+    [k: string]: unknown;
 };
 export declare function extractTaxonomiesFromObjectAndMapUri(objet: Record<string, unknown>): Record<string, unknown>;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "jamespot-user-api",
-  "version": "1.0.168",
+  "version": "1.0.169",
   "main": "lib/jamespot-user-api.js",
   "types": "lib/src/index.d.ts",
   "directories": {

package/phpunitMock/licenseManagerAssignLicenseKind-default.json

@@ -0,0 +1,7 @@
+{
+    "o": "licenseManager",
+    "f": "assignLicenseKind",
+    "error": 0,
+    "messages": [],
+    "result": true
+}