@omerlo/omerlo-webkit 0.0.42 → 0.0.43

package/dist/omerlo/index.d.ts

@@ -6,36 +6,37 @@ export declare const useReader: (f: typeof fetch) => {
     };
     magazines: {
         listReleases: (distributionId: string, params?: Partial<import("./reader/utils/api").PagingParams>) => Promise<import("./reader/utils/api").ApiResponse<import("./reader").Release[]>>;
-        getIssue: (id: string) => Promise<import("./reader/utils/api").ApiResponse<import("./reader").Issue>>;
-        getBlocks: (sectionId: string) => Promise<import("./reader/utils/api").ApiResponse<import("./reader").IssueBlock[]>>;
-        searchContents: (issueId: string, q: string) => Promise<import("./reader/utils/api").ApiResponse<import("./reader").SectionContent[]>>;
-        getSectionContents: (sectionId: string) => Promise<import("./reader/utils/api").ApiResponse<import("./reader").ContentSummary[]>>;
+        getIssue: (id: string, params?: Partial<import("./reader/utils/api").ApiParams>) => Promise<import("./reader/utils/api").ApiResponse<import("./reader").Issue>>;
+        getBlocks: (sectionId: string, params?: Partial<import("./reader/utils/api").ApiParams>) => Promise<import("./reader/utils/api").ApiResponse<import("./reader").IssueBlock[]>>;
+        searchContents: (issueId: string, q: string, params?: Partial<import("./reader/utils/api").ApiParams>) => Promise<import("./reader/utils/api").ApiResponse<import("./reader").SectionContent[]>>;
+        getSectionContents: (sectionId: string, params?: Partial<import("./reader/utils/api").ApiParams>) => Promise<import("./reader/utils/api").ApiResponse<import("./reader").ContentSummary[]>>;
     };
-    getReference: (key: string) => Promise<import("./reader/utils/api").ApiResponse<import("./reader/endpoints/integration").Reference>>;
+    getReference: (key: string, params?: Partial<import("./reader/utils/api").ApiParams>) => Promise<import("./reader/utils/api").ApiResponse<import("./reader/endpoints/integration").Reference>>;
     listProjects: (params?: Partial<import("./reader/utils/api").PagingParams>) => Promise<import("./reader/utils/api").ApiResponse<import("./reader").ProjectSummary[]>>;
-    getProject: (id: string) => Promise<import("./reader/utils/api").ApiResponse<import("./reader").Project>>;
+    getProject: (id: string, params?: Partial<import("./reader/utils/api").ApiParams>) => Promise<import("./reader/utils/api").ApiResponse<import("./reader").Project>>;
     listPeople: (params?: Partial<import("./reader/utils/api").PagingParams>) => Promise<import("./reader/utils/api").ApiResponse<import("./reader").PersonSummary[]>>;
-    getPerson: (id: string) => Promise<import("./reader/utils/api").ApiResponse<import("./reader").Person>>;
+    getPerson: (id: string, params?: Partial<import("./reader/utils/api").ApiParams>) => Promise<import("./reader/utils/api").ApiResponse<import("./reader").Person>>;
     listEvents: (params?: Partial<import("./reader/utils/api").PagingParams>) => Promise<import("./reader/utils/api").ApiResponse<import("./reader").EventSummary[]>>;
-    getEvent: (id: string) => Promise<import("./reader/utils/api").ApiResponse<import("./reader").Event>>;
+    getEvent: (id: string, params?: Partial<import("./reader/utils/api").ApiParams>) => Promise<import("./reader/utils/api").ApiResponse<import("./reader").Event>>;
     allEventBlocks: (id: string, params?: Partial<import("./reader/utils/api").PagingParams>) => Promise<import("./reader/utils/api").ApiResponse<import("./reader").ProfileBlockKind[]>>;
     listOrganizations: (params?: Partial<import("./reader/utils/api").PagingParams>) => Promise<import("./reader/utils/api").ApiResponse<import("./reader").OrganizationSummary[]>>;
-    getOrganization: (id: string) => Promise<import("./reader/utils/api").ApiResponse<import("./reader").Organization>>;
+    getOrganization: (id: string, params?: Partial<import("./reader/utils/api").ApiParams>) => Promise<import("./reader/utils/api").ApiResponse<import("./reader").Organization>>;
+    listProfileTypes: (params?: Partial<import("./reader/utils/api").PagingParams>) => Promise<import("./reader/utils/api").ApiResponse<import("./reader").ProfileTypeSummary[]>>;
+    getProfileType: (id: string, params?: Partial<import("./reader/utils/api").ApiParams>) => Promise<import("./reader/utils/api").ApiResponse<import("./reader").ProfileType>>;
     listWebpages: (params?: Partial<import("./reader/utils/api").PagingParams>) => Promise<import("./reader/utils/api").ApiResponse<import("./reader").WebpageSummary[]>>;
-    getWebpage: (slug: string) => Promise<import("./reader/utils/api").ApiResponse<import("./reader").OrgWebpage>>;
-    getMenu: (key: string) => Promise<import("./reader/utils/api").ApiResponse<import("./reader").Menu>>;
-    listMenus: (params?: Partial<import("./reader/utils/api").PagingParams>) => Promise<import("./reader/utils/api").ApiResponse<import("./reader").MenuSummary[]>>;
-    getMedia: () => Promise<import("./reader/utils/api").ApiResponse<import("./reader").Media>>;
-    getMediaSection: (id: string) => Promise<import("./reader/utils/api").ApiResponse<import("./reader").MediaSection>>;
-    getMediaBlock: (id: string) => Promise<import("./reader/utils/api").ApiResponse<import("./reader").MediaBlock>>;
+    getWebpage: (slug: string, params?: Partial<import("./reader/utils/api").ApiParams>) => Promise<import("./reader/utils/api").ApiResponse<import("./reader").OrgWebpage>>;
+    getMenu: (key: string, params?: Partial<import("./reader/utils/api").ApiParams>) => Promise<import("./reader/utils/api").ApiResponse<import("./reader").Menu>>;
+    getMedia: (params?: Partial<import("./reader/utils/api").ApiParams>) => Promise<import("./reader/utils/api").ApiResponse<import("./reader").Media>>;
+    getMediaSection: (id: string, params?: Partial<import("./reader/utils/api").ApiParams>) => Promise<import("./reader/utils/api").ApiResponse<import("./reader").MediaSection>>;
+    getMediaBlock: (id: string, params?: Partial<import("./reader/utils/api").ApiParams>) => Promise<import("./reader/utils/api").ApiResponse<import("./reader").MediaBlock>>;
     listMediaSectionContents: (sectionId: string, params?: Partial<import("./reader/utils/api").PagingParams>) => Promise<import("./reader/utils/api").ApiResponse<import("./reader").ContentSummary[]>>;
     getContent: (id: string, params?: Partial<import("./reader/utils/api").ApiParams>) => Promise<import("./reader/utils/api").ApiResponse<import("./reader").Content>>;
     listContents: (params?: Partial<import("./reader").ListContentParams>) => Promise<import("./reader/utils/api").ApiResponse<import("./reader").ContentSummary[]>>;
     listCategories: (params?: Partial<import("./reader/utils/api").PagingParams>) => Promise<import("./reader/utils/api").ApiResponse<import("./reader").Category[]>>;
-    getCategory: (id: string) => Promise<import("./reader/utils/api").ApiResponse<import("./reader").Category>>;
+    getCategory: (id: string, params?: Partial<import("./reader/utils/api").ApiParams>) => Promise<import("./reader/utils/api").ApiResponse<import("./reader").Category>>;
     listOauthProviders: (params?: Partial<import("./reader/utils/api").PagingParams>) => Promise<import("./reader/utils/api").ApiResponse<import("./reader").OauthProviderSummary[]>>;
-    getOauthUser: () => Promise<import("./reader/utils/api").ApiResponse<import("./reader").OauthUser>>;
+    getOauthUser: (params?: Partial<import("./reader/utils/api").ApiParams>) => Promise<import("./reader/utils/api").ApiResponse<import("./reader").OauthUser>>;
     registerDevice: (params: import("./reader").DeviceParams) => Promise<import("./reader/utils/api").ApiResponse<unknown>>;
-    userInfo: () => Promise<import("./reader/utils/api").ApiResponse<import("./reader").UserInfo>>;
-    userEntitlements: () => Promise<import("./reader/utils/api").ApiResponse<import("./reader").UserEntitlement[]>>;
+    userInfo: (params?: Partial<import("./reader/utils/api").ApiParams>) => Promise<import("./reader/utils/api").ApiResponse<import("./reader").UserInfo>>;
+    userEntitlements: (params?: Partial<import("./reader/utils/api").ApiParams>) => Promise<import("./reader/utils/api").ApiResponse<import("./reader").UserEntitlement[]>>;
 };

package/dist/omerlo/reader/endpoints/accounts.d.ts

@@ -1,13 +1,14 @@
+import { type ApiParams } from '../utils/api';
 export declare const accountsFetchers: (f: typeof fetch) => {
-    userInfo: () => Promise<import("../utils/api").ApiResponse<UserInfo>>;
-    userEntitlements: () => Promise<import("../utils/api").ApiResponse<UserEntitlement[]>>;
+    userInfo: (params?: Partial<ApiParams>) => Promise<import("../utils/api").ApiResponse<UserInfo>>;
+    userEntitlements: (params?: Partial<ApiParams>) => Promise<import("../utils/api").ApiResponse<UserEntitlement[]>>;
 };
-export declare function getUserInfo(f: typeof fetch): () => Promise<import("../utils/api").ApiResponse<UserInfo>>;
+export declare function getUserInfo(f: typeof fetch): (params?: Partial<ApiParams>) => Promise<import("../utils/api").ApiResponse<UserInfo>>;
 export interface UserInfo {
     name: string;
     email: string;
 }
-export declare function getUserEntitlements(f: typeof fetch): () => Promise<import("../utils/api").ApiResponse<UserEntitlement[]>>;
+export declare function getUserEntitlements(f: typeof fetch): (params?: Partial<ApiParams>) => Promise<import("../utils/api").ApiResponse<UserEntitlement[]>>;
 export interface UserEntitlement {
     id: string;
     feature_key: string;

package/dist/omerlo/reader/endpoints/accounts.js

@@ -10,8 +10,8 @@ export const accountsFetchers = (f) => {
 // Get user's informations associated to the bearer token.
 //
 export function getUserInfo(f) {
-    return async () => {
-        const opts = { parser: parseUserInfo };
+    return async (params) => {
+        const opts = { parser: parseUserInfo, queryParams: params };
         return request(f, '/account/me', opts);
     };
 }
@@ -25,8 +25,8 @@ function parseUserInfo(data, _assoc) {
 // Get user's entitlements associated to the bearer token (Platform).
 //
 export function getUserEntitlements(f) {
-    return async () => {
-        const opts = { parser: parseMany(parseUserEntitlement) };
+    return async (params) => {
+        const opts = { parser: parseMany(parseUserEntitlement), queryParams: params };
         return request(f, '/account/me/entitlements', opts);
     };
 }

package/dist/omerlo/reader/endpoints/categories.d.ts

@@ -1,8 +1,8 @@
 import { type LocalesMetadata } from '../utils/response';
-import { type ApiAssocs, type ApiData, type PagingParams } from '../utils/api';
+import { type ApiAssocs, type ApiData, type ApiParams, type PagingParams } from '../utils/api';
 export declare const categoriesFetchers: (f: typeof fetch) => {
     listCategories: (params?: Partial<PagingParams>) => Promise<import("../utils/api").ApiResponse<Category[]>>;
-    getCategory: (id: string) => Promise<import("../utils/api").ApiResponse<Category>>;
+    getCategory: (id: string, params?: Partial<ApiParams>) => Promise<import("../utils/api").ApiResponse<Category>>;
 };
 export interface Category {
     id: string;
@@ -13,6 +13,6 @@ export interface Category {
     };
     updatedAt: Date;
 }
-export declare function getCategory(f: typeof fetch): (id: string) => Promise<import("../utils/api").ApiResponse<Category>>;
+export declare function getCategory(f: typeof fetch): (id: string, params?: Partial<ApiParams>) => Promise<import("../utils/api").ApiResponse<Category>>;
 export declare function listCategories(f: typeof fetch): (params?: Partial<PagingParams>) => Promise<import("../utils/api").ApiResponse<Category[]>>;
 export declare function parseCategory(data: ApiData, _assoc: ApiAssocs): Category;

package/dist/omerlo/reader/endpoints/categories.js

@@ -9,8 +9,8 @@ export const categoriesFetchers = (f) => {
     };
 };
 export function getCategory(f) {
-    return async (id) => {
-        const opts = { parser: parseCategory };
+    return async (id, params) => {
+        const opts = { parser: parseCategory, queryParams: params };
         return requestPublisher(f, `media/categories/${id}`, opts);
     };
 }

package/dist/omerlo/reader/endpoints/events.d.ts

@@ -1,15 +1,15 @@
 import type { Category } from './categories';
-import { type ApiAssocs, type ApiData, type PagingParams } from '../utils/api';
+import { type ApiAssocs, type ApiData, type ApiParams, type PagingParams } from '../utils/api';
 import type { LocalesMetadata } from '../utils/response';
 import type { ProfileType } from './profileType';
 import type { ProfileAddress, ProfileContact, ProfileDescription } from './profiles';
 export declare const eventFetchers: (f: typeof fetch) => {
     listEvents: (params?: Partial<PagingParams>) => Promise<import("../utils/api").ApiResponse<EventSummary[]>>;
-    getEvent: (id: string) => Promise<import("../utils/api").ApiResponse<Event>>;
+    getEvent: (id: string, params?: Partial<ApiParams>) => Promise<import("../utils/api").ApiResponse<Event>>;
     allEventBlocks: (id: string, params?: Partial<PagingParams>) => Promise<import("../utils/api").ApiResponse<import("./profiles").ProfileBlockKind[]>>;
 };
 export declare function listEvents(f: typeof fetch): (params?: Partial<PagingParams>) => Promise<import("../utils/api").ApiResponse<EventSummary[]>>;
-export declare function getEvent(f: typeof fetch): (id: string) => Promise<import("../utils/api").ApiResponse<Event>>;
+export declare function getEvent(f: typeof fetch): (id: string, params?: Partial<ApiParams>) => Promise<import("../utils/api").ApiResponse<Event>>;
 export declare function allEventBlocks(f: typeof fetch): (id: string, params?: Partial<PagingParams>) => Promise<import("../utils/api").ApiResponse<import("./profiles").ProfileBlockKind[]>>;
 export interface EventSummary {
     id: string;

package/dist/omerlo/reader/endpoints/events.js

@@ -18,8 +18,8 @@ export function listEvents(f) {
     };
 }
 export function getEvent(f) {
-    return async (id) => {
-        const opts = { parser: parseEvent };
+    return async (id, params) => {
+        const opts = { parser: parseEvent, queryParams: params };
         return requestPublisher(f, `media/events/${id}`, opts);
     };
 }

package/dist/omerlo/reader/endpoints/integration.d.ts

@@ -1,8 +1,8 @@
-import type { ApiAssocs, ApiData } from '../utils/api';
+import type { ApiAssocs, ApiData, ApiParams } from '../utils/api';
 export declare const integrationFetchers: (f: typeof fetch) => {
-    getReference: (key: string) => Promise<import("../utils/api").ApiResponse<Reference>>;
+    getReference: (key: string, params?: Partial<ApiParams>) => Promise<import("../utils/api").ApiResponse<Reference>>;
 };
-export declare function getReference(f: typeof fetch): (key: string) => Promise<import("../utils/api").ApiResponse<Reference>>;
+export declare function getReference(f: typeof fetch): (key: string, params?: Partial<ApiParams>) => Promise<import("../utils/api").ApiResponse<Reference>>;
 export interface Reference {
     id: string;
     provider: string;

package/dist/omerlo/reader/endpoints/integration.js

@@ -5,8 +5,8 @@ export const integrationFetchers = (f) => {
     };
 };
 export function getReference(f) {
-    return async (key) => {
-        const opts = { parser: parseReference };
+    return async (key, params) => {
+        const opts = { parser: parseReference, queryParams: params };
         return requestOmerlo(f, `/core/v2/references/${key}`, opts);
     };
 }

package/dist/omerlo/reader/endpoints/magazines.d.ts

@@ -1,17 +1,17 @@
 import { type LocalesMetadata } from '../utils/response';
 import { type Visual } from './visuals';
-import { type ApiAssocs, type ApiData } from '../utils/api';
+import { type ApiAssocs, type ApiData, type ApiParams } from '../utils/api';
 import { type ContentSummary } from './contents';
 export declare const magazineFetchers: (f: typeof fetch) => {
-    getIssue: (id: string) => Promise<import("../utils/api").ApiResponse<Issue>>;
-    getBlocks: (sectionId: string) => Promise<import("../utils/api").ApiResponse<IssueBlock[]>>;
-    searchContents: (issueId: string, q: string) => Promise<import("../utils/api").ApiResponse<SectionContent[]>>;
-    getSectionContents: (sectionId: string) => Promise<import("../utils/api").ApiResponse<ContentSummary[]>>;
+    getIssue: (id: string, params?: Partial<ApiParams>) => Promise<import("../utils/api").ApiResponse<Issue>>;
+    getBlocks: (sectionId: string, params?: Partial<ApiParams>) => Promise<import("../utils/api").ApiResponse<IssueBlock[]>>;
+    searchContents: (issueId: string, q: string, params?: Partial<ApiParams>) => Promise<import("../utils/api").ApiResponse<SectionContent[]>>;
+    getSectionContents: (sectionId: string, params?: Partial<ApiParams>) => Promise<import("../utils/api").ApiResponse<ContentSummary[]>>;
 };
-export declare function issueFetcher(f: typeof fetch): (id: string) => Promise<import("../utils/api").ApiResponse<Issue>>;
-export declare function issueBlocksFetcher(f: typeof fetch): (sectionId: string) => Promise<import("../utils/api").ApiResponse<IssueBlock[]>>;
-export declare function contentsSearch(f: typeof fetch): (issueId: string, q: string) => Promise<import("../utils/api").ApiResponse<SectionContent[]>>;
-export declare function sectionContentsFetcher(f: typeof fetch): (sectionId: string) => Promise<import("../utils/api").ApiResponse<ContentSummary[]>>;
+export declare function issueFetcher(f: typeof fetch): (id: string, params?: Partial<ApiParams>) => Promise<import("../utils/api").ApiResponse<Issue>>;
+export declare function issueBlocksFetcher(f: typeof fetch): (sectionId: string, params?: Partial<ApiParams>) => Promise<import("../utils/api").ApiResponse<IssueBlock[]>>;
+export declare function contentsSearch(f: typeof fetch): (issueId: string, q: string, params?: Partial<ApiParams>) => Promise<import("../utils/api").ApiResponse<SectionContent[]>>;
+export declare function sectionContentsFetcher(f: typeof fetch): (sectionId: string, params?: Partial<ApiParams>) => Promise<import("../utils/api").ApiResponse<ContentSummary[]>>;
 /******************************************************************************
  * Parsers
  ******************************************************************************/

package/dist/omerlo/reader/endpoints/magazines.js

@@ -14,26 +14,26 @@ export const magazineFetchers = (f) => {
     };
 };
 export function issueFetcher(f) {
-    return async (id) => {
-        const opts = { parser: parseIssue };
+    return async (id, params) => {
+        const opts = { parser: parseIssue, queryParams: params };
         return request(f, `/issues/${id}`, opts);
     };
 }
 export function issueBlocksFetcher(f) {
-    return async (sectionId) => {
-        const opts = { parser: parseMany(parseIssueBlock) };
+    return async (sectionId, params) => {
+        const opts = { parser: parseMany(parseIssueBlock), queryParams: params };
         return request(f, `/issues/sections/${sectionId}/blocks`, opts);
     };
 }
 export function contentsSearch(f) {
-    return async (issueId, q) => {
-        const opts = { parser: parseMany(parseIssueSectionContent), queryParams: { q } };
+    return async (issueId, q, params) => {
+        const opts = { parser: parseMany(parseIssueSectionContent), queryParams: { ...params, q } };
         return request(f, `/issues/${issueId}/contents/search`, opts);
     };
 }
 export function sectionContentsFetcher(f) {
-    return async (sectionId) => {
-        const opts = { parser: parseMany(parseContentSummary) };
+    return async (sectionId, params) => {
+        const opts = { parser: parseMany(parseContentSummary), queryParams: params };
         return request(f, `/issues/sections/${sectionId}/contents`, opts);
     };
 }

package/dist/omerlo/reader/endpoints/media.d.ts

@@ -1,19 +1,19 @@
 import { type ApiAssocs, type PagingParams } from '../utils/api';
-import type { ApiData } from '../utils/api';
+import type { ApiData, ApiParams } from '../utils/api';
 import type { LocalesMetadata } from '../utils/response';
 import { type Visual } from './visuals';
 import { type ContentSummary } from './contents';
 import { type Distribution, type Release } from './distributions';
 export declare const mediaFetchers: (f: typeof fetch) => {
-    getMedia: () => Promise<import("../utils/api").ApiResponse<Media>>;
-    getMediaSection: (id: string) => Promise<import("../utils/api").ApiResponse<MediaSection>>;
-    getMediaBlock: (id: string) => Promise<import("../utils/api").ApiResponse<MediaBlock>>;
+    getMedia: (params?: Partial<ApiParams>) => Promise<import("../utils/api").ApiResponse<Media>>;
+    getMediaSection: (id: string, params?: Partial<ApiParams>) => Promise<import("../utils/api").ApiResponse<MediaSection>>;
+    getMediaBlock: (id: string, params?: Partial<ApiParams>) => Promise<import("../utils/api").ApiResponse<MediaBlock>>;
     listMediaSectionContents: (sectionId: string, params?: Partial<PagingParams>) => Promise<import("../utils/api").ApiResponse<ContentSummary[]>>;
 };
-export declare function getMedia(f: typeof fetch): () => Promise<import("../utils/api").ApiResponse<Media>>;
-export declare function getMediaSection(f: typeof fetch): (id: string) => Promise<import("../utils/api").ApiResponse<MediaSection>>;
+export declare function getMedia(f: typeof fetch): (params?: Partial<ApiParams>) => Promise<import("../utils/api").ApiResponse<Media>>;
+export declare function getMediaSection(f: typeof fetch): (id: string, params?: Partial<ApiParams>) => Promise<import("../utils/api").ApiResponse<MediaSection>>;
 export declare function listMediaSectionContents(f: typeof fetch): (sectionId: string, params?: Partial<PagingParams>) => Promise<import("../utils/api").ApiResponse<ContentSummary[]>>;
-export declare function getMediaBlock(f: typeof fetch): (id: string) => Promise<import("../utils/api").ApiResponse<MediaBlock>>;
+export declare function getMediaBlock(f: typeof fetch): (id: string, params?: Partial<ApiParams>) => Promise<import("../utils/api").ApiResponse<MediaBlock>>;
 export interface Media {
     id: string;
     displayName: string | null;

package/dist/omerlo/reader/endpoints/media.js

@@ -14,15 +14,15 @@ export const mediaFetchers = (f) => {
     };
 };
 export function getMedia(f) {
-    return async () => {
-        const opts = { parser: parseMedia };
+    return async (params) => {
+        const opts = { parser: parseMedia, queryParams: params };
         // NOTE the `/` is REALLY important
         return requestPublisher(f, 'media/', opts);
     };
 }
 export function getMediaSection(f) {
-    return async (id) => {
-        const opts = { parser: parseSection };
+    return async (id, params) => {
+        const opts = { parser: parseSection, queryParams: params };
         return requestPublisher(f, `/sections/${id}`, opts);
     };
 }
@@ -33,8 +33,8 @@ export function listMediaSectionContents(f) {
     };
 }
 export function getMediaBlock(f) {
-    return async (id) => {
-        const opts = { parser: parseBlock };
+    return async (id, params) => {
+        const opts = { parser: parseBlock, queryParams: params };
         return requestPublisher(f, `/blocks/${id}`, opts);
     };
 }

package/dist/omerlo/reader/endpoints/menu.d.ts

@@ -1,4 +1,4 @@
-import { type ApiAssocs, type ApiData, type PagingParams } from '../utils/api';
+import { type ApiAssocs, type ApiData, type ApiParams } from '../utils/api';
 import type { LocalesMetadata } from '../utils/response';
 export interface MenuSummary {
     id: string;
@@ -8,11 +8,9 @@ export interface MenuSummary {
     updatedAt: Date;
 }
 export declare const menuFetchers: (f: typeof fetch) => {
-    getMenu: (key: string) => Promise<import("../utils/api").ApiResponse<Menu>>;
-    listMenus: (params?: Partial<PagingParams>) => Promise<import("../utils/api").ApiResponse<MenuSummary[]>>;
+    getMenu: (key: string, params?: Partial<ApiParams>) => Promise<import("../utils/api").ApiResponse<Menu>>;
 };
-export declare function listMenus(f: typeof fetch): (params?: Partial<PagingParams>) => Promise<import("../utils/api").ApiResponse<MenuSummary[]>>;
-export declare function getMenu(f: typeof fetch): (key: string) => Promise<import("../utils/api").ApiResponse<Menu>>;
+export declare function getMenu(f: typeof fetch): (key: string, params?: Partial<ApiParams>) => Promise<import("../utils/api").ApiResponse<Menu>>;
 export interface Menu extends MenuSummary {
     meta: {
         locales: LocalesMetadata;

package/dist/omerlo/reader/endpoints/menu.js

@@ -1,21 +1,14 @@
-import { parseMany } from '../utils/api';
+import {} from '../utils/api';
 import { buildMeta } from '../utils/parseHelpers';
 import { requestPublisher } from '../utils/request';
 export const menuFetchers = (f) => {
     return {
-        getMenu: getMenu(f),
-        listMenus: listMenus(f)
+        getMenu: getMenu(f)
     };
 };
-export function listMenus(f) {
-    return async (params) => {
-        const opts = { parser: parseMany(parseMenuSummary), queryParams: params };
-        return requestPublisher(f, `media/menus`, opts);
-    };
-}
 export function getMenu(f) {
-    return async (key) => {
-        const opts = { parser: parseMenu };
+    return async (key, params) => {
+        const opts = { parser: parseMenu, queryParams: params };
         return requestPublisher(f, `media/menus/${key}`, opts);
     };
 }

package/dist/omerlo/reader/endpoints/oauth.d.ts

@@ -1,7 +1,7 @@
-import { type ApiAssocs, type ApiData, type PagingParams } from '../utils/api';
+import { type ApiAssocs, type ApiData, type ApiParams, type PagingParams } from '../utils/api';
 export declare const oauthFetchers: (f: typeof fetch) => {
     listOauthProviders: (params?: Partial<PagingParams>) => Promise<import("../utils/api").ApiResponse<OauthProviderSummary[]>>;
-    getOauthUser: () => Promise<import("../utils/api").ApiResponse<OauthUser>>;
+    getOauthUser: (params?: Partial<ApiParams>) => Promise<import("../utils/api").ApiResponse<OauthUser>>;
 };
 export declare function listOauthProviders(f: typeof fetch): (params?: Partial<PagingParams>) => Promise<import("../utils/api").ApiResponse<OauthProviderSummary[]>>;
 export declare function parseOauthProviderSummary(data: ApiData, _assocs: ApiAssocs): OauthProviderSummary;
@@ -13,7 +13,7 @@ export interface OauthProviderSummary {
     insertedAt: Date;
     updatedAt: Date;
 }
-export declare function getOauthUser(f: typeof fetch): () => Promise<import("../utils/api").ApiResponse<OauthUser>>;
+export declare function getOauthUser(f: typeof fetch): (params?: Partial<ApiParams>) => Promise<import("../utils/api").ApiResponse<OauthUser>>;
 export declare function parseOauthUser(data: ApiData, _assoc: ApiAssocs): OauthUser;
 export interface OauthUser {
     id: string;

package/dist/omerlo/reader/endpoints/oauth.js

@@ -23,8 +23,8 @@ export function parseOauthProviderSummary(data, _assocs) {
     };
 }
 export function getOauthUser(f) {
-    return () => {
-        const opts = { parser: parseOauthUser };
+    return (params) => {
+        const opts = { parser: parseOauthUser, queryParams: params };
         return request(f, '/oauth/user', opts);
     };
 }

package/dist/omerlo/reader/endpoints/organizations.d.ts

@@ -1,4 +1,4 @@
-import type { ApiAssocs, PagingParams } from '../utils/api';
+import type { ApiAssocs, ApiParams, PagingParams } from '../utils/api';
 import { type ApiData } from '../utils/api';
 import { type LocalesMetadata } from '../utils/response';
 import type { Category } from './categories';
@@ -8,10 +8,10 @@ import { type ProfileDescription } from './profiles';
 import type { ProfileType } from './profileType';
 export declare const organizationFetchers: (f: typeof fetch) => {
     listOrganizations: (params?: Partial<PagingParams>) => Promise<import("../utils/api").ApiResponse<OrganizationSummary[]>>;
-    getOrganization: (id: string) => Promise<import("../utils/api").ApiResponse<Organization>>;
+    getOrganization: (id: string, params?: Partial<ApiParams>) => Promise<import("../utils/api").ApiResponse<Organization>>;
 };
 export declare function listOrganizations(f: typeof fetch): (params?: Partial<PagingParams>) => Promise<import("../utils/api").ApiResponse<OrganizationSummary[]>>;
-export declare function getOrganization(f: typeof fetch): (id: string) => Promise<import("../utils/api").ApiResponse<Organization>>;
+export declare function getOrganization(f: typeof fetch): (id: string, params?: Partial<ApiParams>) => Promise<import("../utils/api").ApiResponse<Organization>>;
 export interface OrganizationSummary {
     id: string;
     profileType: ProfileType;

package/dist/omerlo/reader/endpoints/organizations.js

@@ -21,8 +21,8 @@ export function listOrganizations(f) {
     };
 }
 export function getOrganization(f) {
-    return async (id) => {
-        const opts = { parser: parseOrganization };
+    return async (id, params) => {
+        const opts = { parser: parseOrganization, queryParams: params };
         return requestPublisher(f, `media/organizations/${id}`, opts);
     };
 }

package/dist/omerlo/reader/endpoints/person.d.ts

@@ -1,5 +1,5 @@
 import type { Category } from './categories';
-import { type ApiAssocs, type ApiData, type PagingParams } from '../utils/api';
+import { type ApiAssocs, type ApiData, type ApiParams, type PagingParams } from '../utils/api';
 import { type LocalesMetadata } from '../utils/response';
 import { type ProfileAddress } from './profiles';
 import { type ProfileContact } from './profiles';
@@ -7,10 +7,10 @@ import { type ProfileDescription } from './profiles';
 import type { ProfileType } from './profileType';
 export declare const personFetchers: (f: typeof fetch) => {
     listPeople: (params?: Partial<PagingParams>) => Promise<import("../utils/api").ApiResponse<PersonSummary[]>>;
-    getPerson: (id: string) => Promise<import("../utils/api").ApiResponse<Person>>;
+    getPerson: (id: string, params?: Partial<ApiParams>) => Promise<import("../utils/api").ApiResponse<Person>>;
 };
 export declare function listPeople(f: typeof fetch): (params?: Partial<PagingParams>) => Promise<import("../utils/api").ApiResponse<PersonSummary[]>>;
-export declare function getPerson(f: typeof fetch): (id: string) => Promise<import("../utils/api").ApiResponse<Person>>;
+export declare function getPerson(f: typeof fetch): (id: string, params?: Partial<ApiParams>) => Promise<import("../utils/api").ApiResponse<Person>>;
 export interface PersonSummary {
     id: string;
     profileType: ProfileType;

package/dist/omerlo/reader/endpoints/person.js

@@ -21,8 +21,8 @@ export function listPeople(f) {
     };
 }
 export function getPerson(f) {
-    return async (id) => {
-        const opts = { parser: parsePerson };
+    return async (id, params) => {
+        const opts = { parser: parsePerson, queryParams: params };
         return requestPublisher(f, `media/people/${id}`, opts);
     };
 }

package/dist/omerlo/reader/endpoints/profileType.d.ts

@@ -1,11 +1,11 @@
-import { type ApiAssocs, type ApiData, type PagingParams } from '../utils/api';
+import { type ApiAssocs, type ApiData, type ApiParams, type PagingParams } from '../utils/api';
 import { type LocalesMetadata } from '../utils/response';
 export declare const profileTypeFetchers: (f: typeof fetch) => {
     listProfileTypes: (params?: Partial<PagingParams>) => Promise<import("../utils/api").ApiResponse<ProfileTypeSummary[]>>;
-    getProfileType: (id: string) => Promise<import("../utils/api").ApiResponse<ProfileType>>;
+    getProfileType: (id: string, params?: Partial<ApiParams>) => Promise<import("../utils/api").ApiResponse<ProfileType>>;
 };
 export declare function listProfileTypes(f: typeof fetch): (params?: Partial<PagingParams>) => Promise<import("../utils/api").ApiResponse<ProfileTypeSummary[]>>;
-export declare function getProfileType(f: typeof fetch): (id: string) => Promise<import("../utils/api").ApiResponse<ProfileType>>;
+export declare function getProfileType(f: typeof fetch): (id: string, params?: Partial<ApiParams>) => Promise<import("../utils/api").ApiResponse<ProfileType>>;
 export interface ProfileTypeSummary {
     id: string;
     kind: 'person' | 'project' | 'organization' | 'event';

package/dist/omerlo/reader/endpoints/profileType.js

@@ -15,8 +15,8 @@ export function listProfileTypes(f) {
     };
 }
 export function getProfileType(f) {
-    return async (id) => {
-        const opts = { parser: parseProfileType };
+    return async (id, params) => {
+        const opts = { parser: parseProfileType, queryParams: params };
         return requestPublisher(f, `media/profile-types/${id}`, opts);
     };
 }

package/dist/omerlo/reader/endpoints/projects.d.ts

@@ -1,14 +1,14 @@
 import type { LocalesMetadata } from '../utils/response';
 import type { Category } from './categories';
 import { type ProfileAddress, type ProfileContact, type ProfileDescription } from './profiles';
-import { type ApiData, type ApiAssocs, type PagingParams } from '../utils/api';
+import { type ApiData, type ApiAssocs, type PagingParams, type ApiParams } from '../utils/api';
 import type { ProfileType } from './profileType';
 export declare const projectFetchers: (f: typeof fetch) => {
     listProjects: (params?: Partial<PagingParams>) => Promise<import("../utils/api").ApiResponse<ProjectSummary[]>>;
-    getProject: (id: string) => Promise<import("../utils/api").ApiResponse<Project>>;
+    getProject: (id: string, params?: Partial<ApiParams>) => Promise<import("../utils/api").ApiResponse<Project>>;
 };
 export declare function listProjects(f: typeof fetch): (params?: Partial<PagingParams>) => Promise<import("../utils/api").ApiResponse<ProjectSummary[]>>;
-export declare function getProject(f: typeof fetch): (id: string) => Promise<import("../utils/api").ApiResponse<Project>>;
+export declare function getProject(f: typeof fetch): (id: string, params?: Partial<ApiParams>) => Promise<import("../utils/api").ApiResponse<Project>>;
 export interface ProjectSummary {
     id: string;
     profileType: ProfileType;

package/dist/omerlo/reader/endpoints/projects.js

@@ -18,8 +18,8 @@ export function listProjects(f) {
     };
 }
 export function getProject(f) {
-    return async (id) => {
-        const opts = { parser: parseProject };
+    return async (id, params) => {
+        const opts = { parser: parseProject, queryParams: params };
         return requestPublisher(f, `media/projects/${id}`, opts);
     };
 }

package/dist/omerlo/reader/endpoints/webpage.d.ts

@@ -1,11 +1,11 @@
-import { type ApiAssocs, type ApiData, type PagingParams } from '../utils/api';
+import { type ApiAssocs, type ApiData, type ApiParams, type PagingParams } from '../utils/api';
 import type { LocalesMetadata } from '../utils/response';
 export declare const webpageFetchers: (f: typeof fetch) => {
     listWebpages: (params?: Partial<PagingParams>) => Promise<import("../utils/api").ApiResponse<WebpageSummary[]>>;
-    getWebpage: (slug: string) => Promise<import("../utils/api").ApiResponse<OrgWebpage>>;
+    getWebpage: (slug: string, params?: Partial<ApiParams>) => Promise<import("../utils/api").ApiResponse<OrgWebpage>>;
 };
 export declare function listWebpages(f: typeof fetch): (params?: Partial<PagingParams>) => Promise<import("../utils/api").ApiResponse<WebpageSummary[]>>;
-export declare function getWebpage(f: typeof fetch): (slug: string) => Promise<import("../utils/api").ApiResponse<OrgWebpage>>;
+export declare function getWebpage(f: typeof fetch): (slug: string, params?: Partial<ApiParams>) => Promise<import("../utils/api").ApiResponse<OrgWebpage>>;
 export interface WebpageSummary {
     id: string;
     name: string;

package/dist/omerlo/reader/endpoints/webpage.js

@@ -14,8 +14,8 @@ export function listWebpages(f) {
     };
 }
 export function getWebpage(f) {
-    return async (slug) => {
-        const opts = { parser: parseWebpage };
+    return async (slug, params) => {
+        const opts = { parser: parseWebpage, queryParams: params };
         return requestPublisher(f, `organization/pages/${slug}`, opts);
     };
 }

package/dist/omerlo/reader/fetchers.d.ts

@@ -6,36 +6,37 @@ export declare const fetchers: (f: typeof fetch) => {
     };
     magazines: {
         listReleases: (distributionId: string, params?: Partial<import("./utils/api").PagingParams>) => Promise<import("./utils/api").ApiResponse<import("./endpoints/distributions").Release[]>>;
-        getIssue: (id: string) => Promise<import("./utils/api").ApiResponse<import("./endpoints/magazines").Issue>>;
-        getBlocks: (sectionId: string) => Promise<import("./utils/api").ApiResponse<import("./endpoints/magazines").IssueBlock[]>>;
-        searchContents: (issueId: string, q: string) => Promise<import("./utils/api").ApiResponse<import("./endpoints/magazines").SectionContent[]>>;
-        getSectionContents: (sectionId: string) => Promise<import("./utils/api").ApiResponse<import("./endpoints/contents").ContentSummary[]>>;
+        getIssue: (id: string, params?: Partial<import("./utils/api").ApiParams>) => Promise<import("./utils/api").ApiResponse<import("./endpoints/magazines").Issue>>;
+        getBlocks: (sectionId: string, params?: Partial<import("./utils/api").ApiParams>) => Promise<import("./utils/api").ApiResponse<import("./endpoints/magazines").IssueBlock[]>>;
+        searchContents: (issueId: string, q: string, params?: Partial<import("./utils/api").ApiParams>) => Promise<import("./utils/api").ApiResponse<import("./endpoints/magazines").SectionContent[]>>;
+        getSectionContents: (sectionId: string, params?: Partial<import("./utils/api").ApiParams>) => Promise<import("./utils/api").ApiResponse<import("./endpoints/contents").ContentSummary[]>>;
     };
-    getReference: (key: string) => Promise<import("./utils/api").ApiResponse<import("./endpoints/integration").Reference>>;
+    getReference: (key: string, params?: Partial<import("./utils/api").ApiParams>) => Promise<import("./utils/api").ApiResponse<import("./endpoints/integration").Reference>>;
     listProjects: (params?: Partial<import("./utils/api").PagingParams>) => Promise<import("./utils/api").ApiResponse<import("./endpoints/projects").ProjectSummary[]>>;
-    getProject: (id: string) => Promise<import("./utils/api").ApiResponse<import("./endpoints/projects").Project>>;
+    getProject: (id: string, params?: Partial<import("./utils/api").ApiParams>) => Promise<import("./utils/api").ApiResponse<import("./endpoints/projects").Project>>;
     listPeople: (params?: Partial<import("./utils/api").PagingParams>) => Promise<import("./utils/api").ApiResponse<import("./endpoints/person").PersonSummary[]>>;
-    getPerson: (id: string) => Promise<import("./utils/api").ApiResponse<import("./endpoints/person").Person>>;
+    getPerson: (id: string, params?: Partial<import("./utils/api").ApiParams>) => Promise<import("./utils/api").ApiResponse<import("./endpoints/person").Person>>;
     listEvents: (params?: Partial<import("./utils/api").PagingParams>) => Promise<import("./utils/api").ApiResponse<import("./endpoints/events").EventSummary[]>>;
-    getEvent: (id: string) => Promise<import("./utils/api").ApiResponse<import("./endpoints/events").Event>>;
+    getEvent: (id: string, params?: Partial<import("./utils/api").ApiParams>) => Promise<import("./utils/api").ApiResponse<import("./endpoints/events").Event>>;
     allEventBlocks: (id: string, params?: Partial<import("./utils/api").PagingParams>) => Promise<import("./utils/api").ApiResponse<import(".").ProfileBlockKind[]>>;
     listOrganizations: (params?: Partial<import("./utils/api").PagingParams>) => Promise<import("./utils/api").ApiResponse<import("./endpoints/organizations").OrganizationSummary[]>>;
-    getOrganization: (id: string) => Promise<import("./utils/api").ApiResponse<import("./endpoints/organizations").Organization>>;
+    getOrganization: (id: string, params?: Partial<import("./utils/api").ApiParams>) => Promise<import("./utils/api").ApiResponse<import("./endpoints/organizations").Organization>>;
+    listProfileTypes: (params?: Partial<import("./utils/api").PagingParams>) => Promise<import("./utils/api").ApiResponse<import("./endpoints/profileType").ProfileTypeSummary[]>>;
+    getProfileType: (id: string, params?: Partial<import("./utils/api").ApiParams>) => Promise<import("./utils/api").ApiResponse<import("./endpoints/profileType").ProfileType>>;
     listWebpages: (params?: Partial<import("./utils/api").PagingParams>) => Promise<import("./utils/api").ApiResponse<import("./endpoints/webpage").WebpageSummary[]>>;
-    getWebpage: (slug: string) => Promise<import("./utils/api").ApiResponse<import("./endpoints/webpage").OrgWebpage>>;
-    getMenu: (key: string) => Promise<import("./utils/api").ApiResponse<import("./endpoints/menu").Menu>>;
-    listMenus: (params?: Partial<import("./utils/api").PagingParams>) => Promise<import("./utils/api").ApiResponse<import("./endpoints/menu").MenuSummary[]>>;
-    getMedia: () => Promise<import("./utils/api").ApiResponse<import("./endpoints/media").Media>>;
-    getMediaSection: (id: string) => Promise<import("./utils/api").ApiResponse<import("./endpoints/media").MediaSection>>;
-    getMediaBlock: (id: string) => Promise<import("./utils/api").ApiResponse<import("./endpoints/media").MediaBlock>>;
+    getWebpage: (slug: string, params?: Partial<import("./utils/api").ApiParams>) => Promise<import("./utils/api").ApiResponse<import("./endpoints/webpage").OrgWebpage>>;
+    getMenu: (key: string, params?: Partial<import("./utils/api").ApiParams>) => Promise<import("./utils/api").ApiResponse<import("./endpoints/menu").Menu>>;
+    getMedia: (params?: Partial<import("./utils/api").ApiParams>) => Promise<import("./utils/api").ApiResponse<import("./endpoints/media").Media>>;
+    getMediaSection: (id: string, params?: Partial<import("./utils/api").ApiParams>) => Promise<import("./utils/api").ApiResponse<import("./endpoints/media").MediaSection>>;
+    getMediaBlock: (id: string, params?: Partial<import("./utils/api").ApiParams>) => Promise<import("./utils/api").ApiResponse<import("./endpoints/media").MediaBlock>>;
     listMediaSectionContents: (sectionId: string, params?: Partial<import("./utils/api").PagingParams>) => Promise<import("./utils/api").ApiResponse<import("./endpoints/contents").ContentSummary[]>>;
     getContent: (id: string, params?: Partial<import("./utils/api").ApiParams>) => Promise<import("./utils/api").ApiResponse<import("./endpoints/contents").Content>>;
     listContents: (params?: Partial<import("./endpoints/contents").ListContentParams>) => Promise<import("./utils/api").ApiResponse<import("./endpoints/contents").ContentSummary[]>>;
     listCategories: (params?: Partial<import("./utils/api").PagingParams>) => Promise<import("./utils/api").ApiResponse<import("./endpoints/categories").Category[]>>;
-    getCategory: (id: string) => Promise<import("./utils/api").ApiResponse<import("./endpoints/categories").Category>>;
+    getCategory: (id: string, params?: Partial<import("./utils/api").ApiParams>) => Promise<import("./utils/api").ApiResponse<import("./endpoints/categories").Category>>;
     listOauthProviders: (params?: Partial<import("./utils/api").PagingParams>) => Promise<import("./utils/api").ApiResponse<import("./endpoints/oauth").OauthProviderSummary[]>>;
-    getOauthUser: () => Promise<import("./utils/api").ApiResponse<import("./endpoints/oauth").OauthUser>>;
+    getOauthUser: (params?: Partial<import("./utils/api").ApiParams>) => Promise<import("./utils/api").ApiResponse<import("./endpoints/oauth").OauthUser>>;
     registerDevice: (params: import("./endpoints/device").DeviceParams) => Promise<import("./utils/api").ApiResponse<unknown>>;
-    userInfo: () => Promise<import("./utils/api").ApiResponse<import("./endpoints/accounts").UserInfo>>;
-    userEntitlements: () => Promise<import("./utils/api").ApiResponse<import("./endpoints/accounts").UserEntitlement[]>>;
+    userInfo: (params?: Partial<import("./utils/api").ApiParams>) => Promise<import("./utils/api").ApiResponse<import("./endpoints/accounts").UserInfo>>;
+    userEntitlements: (params?: Partial<import("./utils/api").ApiParams>) => Promise<import("./utils/api").ApiResponse<import("./endpoints/accounts").UserEntitlement[]>>;
 };

package/dist/omerlo/reader/fetchers.js

@@ -14,6 +14,7 @@ import { eventFetchers } from './endpoints/events';
 import { personFetchers } from './endpoints/person';
 import { projectFetchers } from './endpoints/projects';
 import { webpageFetchers } from './endpoints/webpage';
+import { profileTypeFetchers } from './endpoints/profileType';
 export const fetchers = (f) => {
     return {
         ...accountsFetchers(f),
@@ -24,6 +25,7 @@ export const fetchers = (f) => {
         ...mediaFetchers(f),
         ...menuFetchers(f),
         ...webpageFetchers(f),
+        ...profileTypeFetchers(f),
         ...organizationFetchers(f),
         ...eventFetchers(f),
         ...personFetchers(f),

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@omerlo/omerlo-webkit",
-  "version": "0.0.42",
+  "version": "0.0.43",
   "scripts": {
     "dev": "vite dev",
     "build": "vite build && npm run package",