@explorins/pers-sdk 2.1.40 → 2.2.0-alpha.1

package/dist/index.cjs

@@ -1,6 +1,6 @@
 'use strict';
 
-var persSdk = require('./chunks/pers-sdk-CBvzmlL_.cjs');
+var persSdk = require('./chunks/pers-sdk-DcNDMx1Y.cjs');
 var persShared = require('@explorins/pers-shared');
 var environment = require('./chunks/environment-C_hPDl8L.cjs');
 var index = require('./chunks/index-C4K-jkRO.cjs');
@@ -22,7 +22,82 @@ var triggerSource = require('./trigger-source.cjs');
 var platformAdapters = require('./platform-adapters.cjs');
 var nodeHttpClient = require('./chunks/node-http-client-D_avaa5F.cjs');
 
-
+/**
+ * Build optimized image URL with automatic IPFS resolution and CDN options
+ *
+ * Single entry point for all image URL building:
+ * - IPFS URIs → resolved via gateway + CDN options applied
+ * - HTTP URLs → CDN options applied directly
+ *
+ * @param url - Image URL (ipfs://, https://, or any URL)
+ * @param options - CDN optimization options (preset, quality, format, fit)
+ * @param gateway - IPFS gateway domain (required for ipfs:// URLs)
+ * @returns Optimized URL with query parameters
+ *
+ * @example
+ * ```typescript
+ * // IPFS thumbnail
+ * buildImageUrl('ipfs://QmHash', { preset: 'thumb' }, 'cdn.example.com')
+ * // => 'https://cdn.example.com/ipfs/QmHash?preset=thumb'
+ *
+ * // IPFS hero with high quality
+ * buildImageUrl('ipfs://QmHash', { preset: 'hero', q: 95, fit: 'cover' }, 'cdn.example.com')
+ * // => 'https://cdn.example.com/ipfs/QmHash?preset=hero&q=95&fit=cover'
+ *
+ * // HTTP URL (gateway ignored)
+ * buildImageUrl('https://example.com/photo.jpg', { preset: 'card' })
+ * // => 'https://example.com/photo.jpg?preset=card'
+ *
+ * // No options - just IPFS resolution
+ * buildImageUrl('ipfs://QmHash', undefined, 'cdn.example.com')
+ * // => 'https://cdn.example.com/ipfs/QmHash'
+ * ```
+ */
+function buildImageUrl(url, options, gateway) {
+    if (!url)
+        return '';
+    let resolvedUrl = url;
+    // Resolve IPFS to HTTP via gateway
+    if (url.startsWith('ipfs://')) {
+        if (!gateway) {
+            console.warn('[buildImageUrl] IPFS URL requires gateway parameter');
+            return url;
+        }
+        const cid = url.replace('ipfs://', '');
+        resolvedUrl = `https://${gateway}/ipfs/${cid}`;
+    }
+    // Apply CDN options
+    return persShared.buildImageCdnUrl(resolvedUrl, options);
+}
+/**
+ * Check if a URL is an IPFS URI
+ *
+ * @param url - URL to check
+ * @returns True if URL starts with ipfs://
+ */
+function isIpfsUrl(url) {
+    return !!url && url.startsWith('ipfs://');
+}
+/**
+ * Extract CID from IPFS URI
+ *
+ * @param ipfsUri - IPFS URI (ipfs://Qm... or ipfs://baf...)
+ * @returns CID string, or null if not a valid IPFS URI
+ *
+ * @example
+ * ```typescript
+ * extractIpfsCid('ipfs://QmHash123')
+ * // => 'QmHash123'
+ *
+ * extractIpfsCid('https://example.com/image.jpg')
+ * // => null
+ * ```
+ */
+function extractIpfsCid(ipfsUri) {
+    if (!isIpfsUrl(ipfsUri))
+        return null;
+    return ipfsUri.replace('ipfs://', '');
+}
 
 exports.AUTH_STORAGE_KEYS = persSdk.AUTH_STORAGE_KEYS;
 exports.AnalyticsManager = persSdk.AnalyticsManager;
@@ -32,12 +107,13 @@ exports.AuthApi = persSdk.AuthApi;
 exports.AuthManager = persSdk.AuthManager;
 exports.AuthService = persSdk.AuthService;
 Object.defineProperty(exports, "AuthStatus", {
-	enumerable: true,
-	get: function () { return persSdk.AuthStatus; }
+    enumerable: true,
+    get: function () { return persSdk.AuthStatus; }
 });
 exports.AuthTokenManager = persSdk.AuthTokenManager;
 exports.BusinessManager = persSdk.BusinessManager;
 exports.CampaignManager = persSdk.CampaignManager;
+exports.CustomFieldDefinitionManager = persSdk.CustomFieldDefinitionManager;
 exports.DEFAULT_PERS_CONFIG = persSdk.DEFAULT_PERS_CONFIG;
 exports.DPOP_STORAGE_KEYS = persSdk.DPOP_STORAGE_KEYS;
 exports.DPoPManager = persSdk.DPoPManager;
@@ -77,40 +153,76 @@ exports.createPersSDK = persSdk.createPersSDK;
 exports.isFatalAuthErrorInMessage = persSdk.isFatalAuthErrorInMessage;
 exports.mergeWithDefaults = persSdk.mergeWithDefaults;
 Object.defineProperty(exports, "AccountOwnerType", {
-	enumerable: true,
-	get: function () { return persShared.AccountOwnerType; }
+    enumerable: true,
+    get: function () { return persShared.AccountOwnerType; }
+});
+Object.defineProperty(exports, "IMAGE_CDN_DEFAULT_FIT", {
+    enumerable: true,
+    get: function () { return persShared.IMAGE_CDN_DEFAULT_FIT; }
+});
+Object.defineProperty(exports, "IMAGE_CDN_DEFAULT_FORMAT", {
+    enumerable: true,
+    get: function () { return persShared.IMAGE_CDN_DEFAULT_FORMAT; }
+});
+Object.defineProperty(exports, "IMAGE_CDN_DEFAULT_QUALITY", {
+    enumerable: true,
+    get: function () { return persShared.IMAGE_CDN_DEFAULT_QUALITY; }
+});
+Object.defineProperty(exports, "IMAGE_CDN_MAX_DIMENSION", {
+    enumerable: true,
+    get: function () { return persShared.IMAGE_CDN_MAX_DIMENSION; }
+});
+Object.defineProperty(exports, "IMAGE_CDN_PRESETS", {
+    enumerable: true,
+    get: function () { return persShared.IMAGE_CDN_PRESETS; }
 });
 Object.defineProperty(exports, "SortOrder", {
-	enumerable: true,
-	get: function () { return persShared.SortOrder; }
+    enumerable: true,
+    get: function () { return persShared.SortOrder; }
 });
 Object.defineProperty(exports, "VALID_USER_RELATIONS", {
-	enumerable: true,
-	get: function () { return persShared.VALID_USER_RELATIONS; }
+    enumerable: true,
+    get: function () { return persShared.VALID_USER_RELATIONS; }
+});
+Object.defineProperty(exports, "buildImageCdnUrl", {
+    enumerable: true,
+    get: function () { return persShared.buildImageCdnUrl; }
+});
+Object.defineProperty(exports, "getPresetDimensions", {
+    enumerable: true,
+    get: function () { return persShared.getPresetDimensions; }
 });
 Object.defineProperty(exports, "isConnectedMessage", {
-	enumerable: true,
-	get: function () { return persShared.isConnectedMessage; }
+    enumerable: true,
+    get: function () { return persShared.isConnectedMessage; }
 });
 Object.defineProperty(exports, "isErrorMessage", {
-	enumerable: true,
-	get: function () { return persShared.isErrorMessage; }
+    enumerable: true,
+    get: function () { return persShared.isErrorMessage; }
 });
 Object.defineProperty(exports, "isEventMessage", {
-	enumerable: true,
-	get: function () { return persShared.isEventMessage; }
+    enumerable: true,
+    get: function () { return persShared.isEventMessage; }
 });
 Object.defineProperty(exports, "isServerMessage", {
-	enumerable: true,
-	get: function () { return persShared.isServerMessage; }
+    enumerable: true,
+    get: function () { return persShared.isServerMessage; }
 });
 Object.defineProperty(exports, "isSubscribedMessage", {
-	enumerable: true,
-	get: function () { return persShared.isSubscribedMessage; }
+    enumerable: true,
+    get: function () { return persShared.isSubscribedMessage; }
+});
+Object.defineProperty(exports, "isSupportedImageFormat", {
+    enumerable: true,
+    get: function () { return persShared.isSupportedImageFormat; }
+});
+Object.defineProperty(exports, "isValidPreset", {
+    enumerable: true,
+    get: function () { return persShared.isValidPreset; }
 });
 Object.defineProperty(exports, "isValidUserRelation", {
-	enumerable: true,
-	get: function () { return persShared.isValidUserRelation; }
+    enumerable: true,
+    get: function () { return persShared.isValidUserRelation; }
 });
 exports.detectEnvironment = environment.detectEnvironment;
 exports.environment = environment.environment;
@@ -179,10 +291,13 @@ exports.TriggerSourceService = triggerSource.TriggerSourceService;
 exports.AngularHttpClientAdapter = platformAdapters.AngularHttpClientAdapter;
 exports.BrowserFetchClientAdapter = platformAdapters.BrowserFetchClientAdapter;
 exports.NodeHttpClientAdapter = nodeHttpClient.NodeHttpClientAdapter;
+exports.buildImageUrl = buildImageUrl;
+exports.extractIpfsCid = extractIpfsCid;
+exports.isIpfsUrl = isIpfsUrl;
 Object.keys(persShared).forEach(function (k) {
-	if (k !== 'default' && !Object.prototype.hasOwnProperty.call(exports, k)) Object.defineProperty(exports, k, {
-		enumerable: true,
-		get: function () { return persShared[k]; }
-	});
+    if (k !== 'default' && !Object.prototype.hasOwnProperty.call(exports, k)) Object.defineProperty(exports, k, {
+        enumerable: true,
+        get: function () { return persShared[k]; }
+    });
 });
 //# sourceMappingURL=index.cjs.map

package/dist/index.cjs.map

@@ -1 +1 @@
-{"version":3,"file":"index.cjs","sources":[],"sourcesContent":[],"names":[],"mappings":";;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;"}
+{"version":3,"file":"index.cjs","sources":["../src/shared/utils/image-url-utils.ts"],"sourcesContent":[null],"names":["buildImageCdnUrl"],"mappings":";;;;;;;;;;;;;;;;;;;;;;;;AAyCA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;AA8BG;SACa,aAAa,CAC3B,GAAW,EACX,OAAyB,EACzB,OAAgB,EAAA;AAEhB,IAAA,IAAI,CAAC,GAAG;AAAE,QAAA,OAAO,EAAE;IAEnB,IAAI,WAAW,GAAG,GAAG;;AAGrB,IAAA,IAAI,GAAG,CAAC,UAAU,CAAC,SAAS,CAAC,EAAE;QAC7B,IAAI,CAAC,OAAO,EAAE;AACZ,YAAA,OAAO,CAAC,IAAI,CAAC,qDAAqD,CAAC;AACnE,YAAA,OAAO,GAAG;QACZ;QACA,MAAM,GAAG,GAAG,GAAG,CAAC,OAAO,CAAC,SAAS,EAAE,EAAE,CAAC;AACtC,QAAA,WAAW,GAAG,CAAA,QAAA,EAAW,OAAO,CAAA,MAAA,EAAS,GAAG,EAAE;IAChD;;AAGA,IAAA,OAAOA,2BAAgB,CAAC,WAAW,EAAE,OAAO,CAAC;AAC/C;AAEA;;;;;AAKG;AACG,SAAU,SAAS,CAAC,GAAW,EAAA;IACnC,OAAO,CAAC,CAAC,GAAG,IAAI,GAAG,CAAC,UAAU,CAAC,SAAS,CAAC;AAC3C;AAEA;;;;;;;;;;;;;;AAcG;AACG,SAAU,cAAc,CAAC,OAAe,EAAA;AAC5C,IAAA,IAAI,CAAC,SAAS,CAAC,OAAO,CAAC;AAAE,QAAA,OAAO,IAAI;IACpC,OAAO,OAAO,CAAC,OAAO,CAAC,SAAS,EAAE,EAAE,CAAC;AACvC;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;"}

package/dist/index.js

@@ -1,6 +1,7 @@
-export { b as AUTH_STORAGE_KEYS, x as AnalyticsManager, K as ApiKeyApi, w as ApiKeyManager, l as AuthApi, r as AuthManager, o as AuthService, A as AuthStatus, a as AuthTokenManager, B as BusinessManager, C as CampaignManager, h as DEFAULT_PERS_CONFIG, d as DPOP_STORAGE_KEYS, p as DPoPManager, D as DefaultAuthProvider, y as DonationManager, F as FATAL_AUTH_CODES, H as FileApi, v as FileManager, J as FileService, I as IndexedDBTokenStorage, L as LocalStorageTokenStorage, M as MemoryTokenStorage, g as PersApiClient, q as PersEventEmitter, Q as PersEventsClient, P as PersSDK, u as PurchaseManager, R as RedemptionManager, S as SDK_NAME, f as SDK_USER_AGENT, e as SDK_VERSION, k as StaticJwtAuthProvider, T as TokenManager, t as TransactionManager, z as TriggerSourceManager, U as UserManager, s as UserStatusManager, G as WalletEventsManager, W as WebDPoPCryptoProvider, N as WebhookApi, E as WebhookManager, O as WebhookService, i as buildApiRoot, j as buildWalletEventsWsUrl, V as createPersEventsClient, c as createPersSDK, n as isFatalAuthErrorInMessage, m as mergeWithDefaults } from './chunks/pers-sdk-DuDWwRWC.js';
+export { a as AUTH_STORAGE_KEYS, w as AnalyticsManager, N as ApiKeyApi, v as ApiKeyManager, k as AuthApi, q as AuthManager, n as AuthService, H as AuthStatus, A as AuthTokenManager, B as BusinessManager, C as CampaignManager, G as CustomFieldDefinitionManager, g as DEFAULT_PERS_CONFIG, b as DPOP_STORAGE_KEYS, o as DPoPManager, D as DefaultAuthProvider, x as DonationManager, F as FATAL_AUTH_CODES, J as FileApi, u as FileManager, K as FileService, I as IndexedDBTokenStorage, L as LocalStorageTokenStorage, M as MemoryTokenStorage, f as PersApiClient, p as PersEventEmitter, V as PersEventsClient, P as PersSDK, t as PurchaseManager, R as RedemptionManager, S as SDK_NAME, d as SDK_USER_AGENT, c as SDK_VERSION, j as StaticJwtAuthProvider, T as TokenManager, s as TransactionManager, y as TriggerSourceManager, U as UserManager, r as UserStatusManager, E as WalletEventsManager, W as WebDPoPCryptoProvider, O as WebhookApi, z as WebhookManager, Q as WebhookService, h as buildApiRoot, i as buildWalletEventsWsUrl, X as createPersEventsClient, e as createPersSDK, l as isFatalAuthErrorInMessage, m as mergeWithDefaults } from './chunks/pers-sdk-CBRtrG03.js';
+import { buildImageCdnUrl } from '@explorins/pers-shared';
 export * from '@explorins/pers-shared';
-export { AccountOwnerType, SortOrder, VALID_USER_RELATIONS, isConnectedMessage, isErrorMessage, isEventMessage, isServerMessage, isSubscribedMessage, isValidUserRelation } from '@explorins/pers-shared';
+export { AccountOwnerType, IMAGE_CDN_DEFAULT_FIT, IMAGE_CDN_DEFAULT_FORMAT, IMAGE_CDN_DEFAULT_QUALITY, IMAGE_CDN_MAX_DIMENSION, IMAGE_CDN_PRESETS, SortOrder, VALID_USER_RELATIONS, buildImageCdnUrl, getPresetDimensions, isConnectedMessage, isErrorMessage, isEventMessage, isServerMessage, isSubscribedMessage, isSupportedImageFormat, isValidPreset, isValidUserRelation } from '@explorins/pers-shared';
 export { d as detectEnvironment, e as environment, w as warnIfProblematicEnvironment } from './chunks/environment-DEI_L882.js';
 export { c as ApiErrorDetector, A as AuthenticationError, a as CacheService, C as CacheTTL, E as ErrorUtils, L as LogoutRequired, N as NetworkError, b as PersApiError, P as ProviderTokenRefreshNeeded, S as SdkErrorCodes, T as TokenRefreshNeeded, g as globalCacheService } from './chunks/index--OssIds0.js';
 export { T as TenantManager } from './chunks/tenant-manager-xmYKBFGu.js';
@@ -20,4 +21,83 @@ export { UserStatusApi, UserStatusService, createUserStatusSDK } from './user-st
 export { TriggerSourceApi, TriggerSourceService } from './trigger-source.js';
 export { AngularHttpClientAdapter, BrowserFetchClientAdapter } from './platform-adapters.js';
 export { N as NodeHttpClientAdapter } from './chunks/node-http-client-DloDLfm9.js';
+
+/**
+ * Build optimized image URL with automatic IPFS resolution and CDN options
+ *
+ * Single entry point for all image URL building:
+ * - IPFS URIs → resolved via gateway + CDN options applied
+ * - HTTP URLs → CDN options applied directly
+ *
+ * @param url - Image URL (ipfs://, https://, or any URL)
+ * @param options - CDN optimization options (preset, quality, format, fit)
+ * @param gateway - IPFS gateway domain (required for ipfs:// URLs)
+ * @returns Optimized URL with query parameters
+ *
+ * @example
+ * ```typescript
+ * // IPFS thumbnail
+ * buildImageUrl('ipfs://QmHash', { preset: 'thumb' }, 'cdn.example.com')
+ * // => 'https://cdn.example.com/ipfs/QmHash?preset=thumb'
+ *
+ * // IPFS hero with high quality
+ * buildImageUrl('ipfs://QmHash', { preset: 'hero', q: 95, fit: 'cover' }, 'cdn.example.com')
+ * // => 'https://cdn.example.com/ipfs/QmHash?preset=hero&q=95&fit=cover'
+ *
+ * // HTTP URL (gateway ignored)
+ * buildImageUrl('https://example.com/photo.jpg', { preset: 'card' })
+ * // => 'https://example.com/photo.jpg?preset=card'
+ *
+ * // No options - just IPFS resolution
+ * buildImageUrl('ipfs://QmHash', undefined, 'cdn.example.com')
+ * // => 'https://cdn.example.com/ipfs/QmHash'
+ * ```
+ */
+function buildImageUrl(url, options, gateway) {
+    if (!url)
+        return '';
+    let resolvedUrl = url;
+    // Resolve IPFS to HTTP via gateway
+    if (url.startsWith('ipfs://')) {
+        if (!gateway) {
+            console.warn('[buildImageUrl] IPFS URL requires gateway parameter');
+            return url;
+        }
+        const cid = url.replace('ipfs://', '');
+        resolvedUrl = `https://${gateway}/ipfs/${cid}`;
+    }
+    // Apply CDN options
+    return buildImageCdnUrl(resolvedUrl, options);
+}
+/**
+ * Check if a URL is an IPFS URI
+ *
+ * @param url - URL to check
+ * @returns True if URL starts with ipfs://
+ */
+function isIpfsUrl(url) {
+    return !!url && url.startsWith('ipfs://');
+}
+/**
+ * Extract CID from IPFS URI
+ *
+ * @param ipfsUri - IPFS URI (ipfs://Qm... or ipfs://baf...)
+ * @returns CID string, or null if not a valid IPFS URI
+ *
+ * @example
+ * ```typescript
+ * extractIpfsCid('ipfs://QmHash123')
+ * // => 'QmHash123'
+ *
+ * extractIpfsCid('https://example.com/image.jpg')
+ * // => null
+ * ```
+ */
+function extractIpfsCid(ipfsUri) {
+    if (!isIpfsUrl(ipfsUri))
+        return null;
+    return ipfsUri.replace('ipfs://', '');
+}
+
+export { buildImageUrl, extractIpfsCid, isIpfsUrl };
 //# sourceMappingURL=index.js.map

package/dist/index.js.map

@@ -1 +1 @@
-{"version":3,"file":"index.js","sources":[],"sourcesContent":[],"names":[],"mappings":";;;;;;;;;;;;;;;;;;;;;"}
+{"version":3,"file":"index.js","sources":["../src/shared/utils/image-url-utils.ts"],"sourcesContent":[null],"names":[],"mappings":";;;;;;;;;;;;;;;;;;;;;;;;AAyCA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;AA8BG;SACa,aAAa,CAC3B,GAAW,EACX,OAAyB,EACzB,OAAgB,EAAA;AAEhB,IAAA,IAAI,CAAC,GAAG;AAAE,QAAA,OAAO,EAAE;IAEnB,IAAI,WAAW,GAAG,GAAG;;AAGrB,IAAA,IAAI,GAAG,CAAC,UAAU,CAAC,SAAS,CAAC,EAAE;QAC7B,IAAI,CAAC,OAAO,EAAE;AACZ,YAAA,OAAO,CAAC,IAAI,CAAC,qDAAqD,CAAC;AACnE,YAAA,OAAO,GAAG;QACZ;QACA,MAAM,GAAG,GAAG,GAAG,CAAC,OAAO,CAAC,SAAS,EAAE,EAAE,CAAC;AACtC,QAAA,WAAW,GAAG,CAAA,QAAA,EAAW,OAAO,CAAA,MAAA,EAAS,GAAG,EAAE;IAChD;;AAGA,IAAA,OAAO,gBAAgB,CAAC,WAAW,EAAE,OAAO,CAAC;AAC/C;AAEA;;;;;AAKG;AACG,SAAU,SAAS,CAAC,GAAW,EAAA;IACnC,OAAO,CAAC,CAAC,GAAG,IAAI,GAAG,CAAC,UAAU,CAAC,SAAS,CAAC;AAC3C;AAEA;;;;;;;;;;;;;;AAcG;AACG,SAAU,cAAc,CAAC,OAAe,EAAA;AAC5C,IAAA,IAAI,CAAC,SAAS,CAAC,OAAO,CAAC;AAAE,QAAA,OAAO,IAAI;IACpC,OAAO,OAAO,CAAC,OAAO,CAAC,SAAS,EAAE,EAAE,CAAC;AACvC;;;;"}

package/dist/managers/custom-field-definition-manager.d.ts

@@ -0,0 +1,317 @@
+import { PersApiClient } from '../core/pers-api-client';
+import { PersEventEmitter } from '../core/events';
+import { CustomFieldDefinitionDTO, CreateCustomFieldDefinitionDTO, UpdateCustomFieldDefinitionDTO, CustomFieldEntityType, CustomFieldSelectOption, type FieldDefinition, type ValidationErrorDetail } from '@explorins/pers-shared';
+export type { CustomFieldDefinitionDTO, CreateCustomFieldDefinitionDTO, UpdateCustomFieldDefinitionDTO, CustomFieldEntityType, CustomFieldSelectOption, FieldDefinition, ValidationErrorDetail, };
+/**
+ * Options for querying custom field definitions
+ */
+export interface CustomFieldQueryOptions {
+    /** Filter by entity type (default: 'user') */
+    entityType?: CustomFieldEntityType;
+}
+/**
+ * Custom Field Definition Manager - Manage tenant-specific custom fields
+ *
+ * Provides CRUD operations for custom field definitions that extend the built-in
+ * user profile fields. Custom fields are defined per-tenant and can be used for
+ * additional user data collection, redemption requirements, and form validation.
+ *
+ * @group Managers
+ * @category Custom Fields
+ *
+ * @example Basic Operations
+ * ```typescript
+ * // List all user custom fields
+ * const fields = await sdk.customFields.getDefinitions();
+ *
+ * // Create a new custom field
+ * const field = await sdk.customFields.createDefinition({
+ *   key: 'employee_id',
+ *   label: 'Employee ID',
+ *   fieldType: 'text',
+ *   validation: { required: true, pattern: '^E[0-9]{5}$' }
+ * });
+ *
+ * // Update a field
+ * await sdk.customFields.updateDefinition(field.id, {
+ *   label: 'Company Employee ID'
+ * });
+ *
+ * // Delete a field
+ * await sdk.customFields.deleteDefinition(field.id);
+ * ```
+ *
+ * @example Validation
+ * ```typescript
+ * // Validate user custom data against definitions
+ * const definitions = await sdk.customFields.getDefinitions();
+ * const errors = sdk.customFields.validateUserData(
+ *   { employee_id: 'INVALID' },
+ *   definitions
+ * );
+ * if (errors.length > 0) {
+ *   console.log('Validation errors:', errors);
+ * }
+ * ```
+ */
+export declare class CustomFieldDefinitionManager {
+    private events?;
+    private readonly api;
+    constructor(apiClient: PersApiClient, events?: PersEventEmitter | undefined);
+    /**
+     * List all custom field definitions for the tenant
+     *
+     * Retrieves all custom field definitions, optionally filtered by entity type.
+     * Results are sorted by sortOrder (ascending).
+     *
+     * @param options - Query options including entity type filter
+     * @returns Array of custom field definitions
+     *
+     * @example List All User Fields
+     * ```typescript
+     * const fields = await sdk.customFields.getDefinitions();
+     * console.log(`Found ${fields.length} custom fields`);
+     *
+     * fields.forEach(field => {
+     *   console.log(`${field.key}: ${field.label} (${field.fieldType})`);
+     * });
+     * ```
+     *
+     * @example Filter by Entity Type
+     * ```typescript
+     * // Get only business custom fields
+     * const businessFields = await sdk.customFields.getDefinitions({
+     *   entityType: 'business'
+     * });
+     * ```
+     */
+    getDefinitions(options?: CustomFieldQueryOptions): Promise<CustomFieldDefinitionDTO[]>;
+    /**
+     * Get a single custom field definition by ID
+     *
+     * @param id - The UUID of the custom field definition
+     * @returns The custom field definition
+     * @throws {PersApiError} When definition not found (404)
+     *
+     * @example
+     * ```typescript
+     * try {
+     *   const field = await sdk.customFields.getDefinition('uuid-here');
+     *   console.log('Field:', field.label);
+     * } catch (error) {
+     *   if (error.statusCode === 404) {
+     *     console.log('Field not found');
+     *   }
+     * }
+     * ```
+     */
+    getDefinition(id: string): Promise<CustomFieldDefinitionDTO>;
+    /**
+     * Create a new custom field definition
+     *
+     * Creates a new custom field for the tenant. The field key must be unique
+     * within the tenant and entity type combination.
+     *
+     * @param data - The field definition data
+     * @returns The created custom field definition
+     * @throws {PersApiError} When key already exists (409) or validation fails (400)
+     *
+     * @example Text Field with Pattern
+     * ```typescript
+     * const employeeIdField = await sdk.customFields.createDefinition({
+     *   key: 'employee_id',
+     *   label: 'Employee ID',
+     *   description: 'Your company employee ID (E + 5 digits)',
+     *   fieldType: 'text',
+     *   validation: {
+     *     required: true,
+     *     pattern: '^E[0-9]{5}$',
+     *     patternMessage: 'Must be E followed by 5 digits'
+     *   },
+     *   sortOrder: 1
+     * });
+     * ```
+     *
+     * @example Date Field with Comparison
+     * ```typescript
+     * const checkOutField = await sdk.customFields.createDefinition({
+     *   key: 'check_out',
+     *   label: 'Check-out Date',
+     *   fieldType: 'date',
+     *   validation: {
+     *     required: true,
+     *     comparisons: [
+     *       { field: 'check_in', operator: '>', message: 'Must be after check-in' }
+     *     ]
+     *   },
+     *   sortOrder: 2
+     * });
+     * ```
+     *
+     * @example Select Field with Static Options
+     * ```typescript
+     * const departmentField = await sdk.customFields.createDefinition({
+     *   key: 'department',
+     *   label: 'Department',
+     *   fieldType: 'select',
+     *   selectOptions: [
+     *     { value: 'engineering', label: 'Engineering' },
+     *     { value: 'sales', label: 'Sales' },
+     *     { value: 'hr', label: 'Human Resources' }
+     *   ],
+     *   validation: { required: true }
+     * });
+     * ```
+     *
+     * @example Select Field with Dynamic Options
+     * ```typescript
+     * const hotelField = await sdk.customFields.createDefinition({
+     *   key: 'preferred_hotel',
+     *   label: 'Preferred Hotel',
+     *   fieldType: 'select',
+     *   selectOptionsSource: {
+     *     entity: 'business',
+     *     valueField: 'id',
+     *     labelField: 'name',
+     *     filter: { tags: ['hotel'], isActive: true }
+     *   },
+     *   validation: { required: true }
+     * });
+     * ```
+     */
+    createDefinition(data: CreateCustomFieldDefinitionDTO): Promise<CustomFieldDefinitionDTO>;
+    /**
+     * Update an existing custom field definition
+     *
+     * Updates a custom field definition. Note that key and entityType cannot
+     * be changed after creation.
+     *
+     * @param id - The UUID of the custom field definition to update
+     * @param data - The fields to update (partial update supported)
+     * @returns The updated custom field definition
+     * @throws {PersApiError} When definition not found (404) or validation fails (400)
+     *
+     * @example Update Label and Validation
+     * ```typescript
+     * const updated = await sdk.customFields.updateDefinition('uuid-here', {
+     *   label: 'Employee ID (Required)',
+     *   validation: {
+     *     required: true,
+     *     minLength: 6,
+     *     maxLength: 6
+     *   }
+     * });
+     * ```
+     *
+     * @example Update Sort Order
+     * ```typescript
+     * await sdk.customFields.updateDefinition('uuid-here', {
+     *   sortOrder: 5
+     * });
+     * ```
+     */
+    updateDefinition(id: string, data: UpdateCustomFieldDefinitionDTO): Promise<CustomFieldDefinitionDTO>;
+    /**
+     * Delete a custom field definition (soft delete)
+     *
+     * Soft deletes a custom field definition. Existing user data in customData
+     * is preserved, but the field will no longer appear in forms or validation.
+     *
+     * ⚠️ Consider the impact on existing user data before deleting.
+     *
+     * @param id - The UUID of the custom field definition to delete
+     * @throws {PersApiError} When definition not found (404)
+     *
+     * @example
+     * ```typescript
+     * try {
+     *   await sdk.customFields.deleteDefinition('uuid-here');
+     *   console.log('Field deleted');
+     * } catch (error) {
+     *   console.log('Failed to delete:', error.message);
+     * }
+     * ```
+     */
+    deleteDefinition(id: string): Promise<void>;
+    /**
+     * Resolve dynamic select options for a field
+     *
+     * For fields with selectOptionsSource (dynamic options from entities),
+     * this resolves the actual options by querying the source entity.
+     *
+     * @param id - The UUID of the custom field definition
+     * @returns Array of select options
+     *
+     * @example
+     * ```typescript
+     * const field = await sdk.customFields.getDefinition('hotel-field-id');
+     *
+     * if (field.selectOptionsSource) {
+     *   // Options come from entity - need to resolve
+     *   const options = await sdk.customFields.resolveSelectOptions(field.id);
+     *   console.log('Available hotels:', options);
+     * } else {
+     *   // Static options
+     *   console.log('Options:', field.selectOptions);
+     * }
+     * ```
+     */
+    resolveSelectOptions(id: string): Promise<CustomFieldSelectOption[]>;
+    /**
+     * Validate user custom data against field definitions
+     *
+     * Client-side validation using the same rules as the backend. Use this
+     * to validate form data before submission.
+     *
+     * @param data - User's custom data (key-value pairs)
+     * @param definitions - Custom field definitions to validate against
+     * @returns Array of validation errors (empty if valid)
+     *
+     * @example Form Validation
+     * ```typescript
+     * const definitions = await sdk.customFields.getDefinitions();
+     * const formData = {
+     *   employee_id: 'E123', // Missing a digit
+     *   department: 'engineering'
+     * };
+     *
+     * const errors = sdk.customFields.validateUserData(formData, definitions);
+     * if (errors.length > 0) {
+     *   errors.forEach(err => {
+     *     console.log(`${err.field}: ${err.message}`);
+     *   });
+     *   return; // Don't submit
+     * }
+     *
+     * // No errors, safe to submit
+     * await sdk.users.updateCurrentUser({ customData: formData });
+     * ```
+     */
+    validateUserData(data: Record<string, unknown>, definitions: CustomFieldDefinitionDTO[]): ValidationErrorDetail[];
+    /**
+     * Validate a single field value
+     *
+     * Validates a single value against a field's rules. Useful for
+     * real-time validation as the user types.
+     *
+     * @param value - The value to validate
+     * @param definition - The field definition
+     * @returns Validation error or null if valid
+     *
+     * @example Real-time Validation
+     * ```typescript
+     * const employeeIdField = definitions.find(d => d.key === 'employee_id');
+     *
+     * const handleBlur = (value: string) => {
+     *   const error = sdk.customFields.validateFieldValue(value, employeeIdField);
+     *   if (error) {
+     *     setFieldError('employee_id', error.message);
+     *   } else {
+     *     clearFieldError('employee_id');
+     *   }
+     * };
+     * ```
+     */
+    validateFieldValue(value: unknown, definition: CustomFieldDefinitionDTO): ValidationErrorDetail | null;
+}
+//# sourceMappingURL=custom-field-definition-manager.d.ts.map

package/dist/managers/custom-field-definition-manager.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"custom-field-definition-manager.d.ts","sourceRoot":"","sources":["../../src/managers/custom-field-definition-manager.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,aAAa,EAAE,MAAM,yBAAyB,CAAC;AACxD,OAAO,EAAE,gBAAgB,EAAE,MAAM,gBAAgB,CAAC;AAElD,OAAO,EACL,wBAAwB,EACxB,8BAA8B,EAC9B,8BAA8B,EAC9B,qBAAqB,EACrB,uBAAuB,EAGvB,KAAK,eAAe,EACpB,KAAK,qBAAqB,EAC3B,MAAM,wBAAwB,CAAC;AAGhC,YAAY,EACV,wBAAwB,EACxB,8BAA8B,EAC9B,8BAA8B,EAC9B,qBAAqB,EACrB,uBAAuB,EACvB,eAAe,EACf,qBAAqB,GACtB,CAAC;AAEF;;GAEG;AACH,MAAM,WAAW,uBAAuB;IACtC,8CAA8C;IAC9C,UAAU,CAAC,EAAE,qBAAqB,CAAC;CACpC;AAED;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GA4CG;AACH,qBAAa,4BAA4B;IAKrC,OAAO,CAAC,MAAM,CAAC;IAJjB,OAAO,CAAC,QAAQ,CAAC,GAAG,CAAiB;gBAGnC,SAAS,EAAE,aAAa,EAChB,MAAM,CAAC,8BAAkB;IAKnC;;;;;;;;;;;;;;;;;;;;;;;;;;OA0BG;IACG,cAAc,CAClB,OAAO,CAAC,EAAE,uBAAuB,GAChC,OAAO,CAAC,wBAAwB,EAAE,CAAC;IAItC;;;;;;;;;;;;;;;;;;OAkBG;IACG,aAAa,CAAC,EAAE,EAAE,MAAM,GAAG,OAAO,CAAC,wBAAwB,CAAC;IAIlE;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;OAwEG;IACG,gBAAgB,CACpB,IAAI,EAAE,8BAA8B,GACnC,OAAO,CAAC,wBAAwB,CAAC;IAcpC;;;;;;;;;;;;;;;;;;;;;;;;;;;;;OA6BG;IACG,gBAAgB,CACpB,EAAE,EAAE,MAAM,EACV,IAAI,EAAE,8BAA8B,GACnC,OAAO,CAAC,wBAAwB,CAAC;IAcpC;;;;;;;;;;;;;;;;;;;;OAoBG;IACG,gBAAgB,CAAC,EAAE,EAAE,MAAM,GAAG,OAAO,CAAC,IAAI,CAAC;IAYjD;;;;;;;;;;;;;;;;;;;;;;OAsBG;IACG,oBAAoB,CAAC,EAAE,EAAE,MAAM,GAAG,OAAO,CAAC,uBAAuB,EAAE,CAAC;IAK1E;;;;;;;;;;;;;;;;;;;;;;;;;;;;;OA6BG;IACH,gBAAgB,CACd,IAAI,EAAE,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,EAC7B,WAAW,EAAE,wBAAwB,EAAE,GACtC,qBAAqB,EAAE;IAY1B;;;;;;;;;;;;;;;;;;;;;;;OAuBG;IACH,kBAAkB,CAChB,KAAK,EAAE,OAAO,EACd,UAAU,EAAE,wBAAwB,GACnC,qBAAqB,GAAG,IAAI;CAchC"}

package/dist/managers/index.d.ts

@@ -22,4 +22,5 @@ export { DonationManager } from './donation-manager';
 export { TriggerSourceManager } from './trigger-source-manager';
 export { WebhookManager } from './webhook-manager';
 export { WalletEventsManager, type WalletEventsConfig } from './events-manager';
+export { CustomFieldDefinitionManager, type CustomFieldQueryOptions } from './custom-field-definition-manager';
 //# sourceMappingURL=index.d.ts.map

package/dist/managers/index.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../src/managers/index.ts"],"names":[],"mappings":"AAAA;;;;;GAKG;AAEH,OAAO,EAAE,WAAW,EAAE,MAAM,gBAAgB,CAAC;AAC7C,YAAY,EAAE,mBAAmB,EAAE,iBAAiB,EAAE,MAAM,gBAAgB,CAAC;AAC7E,OAAO,EAAE,WAAW,EAAE,MAAM,gBAAgB,CAAC;AAC7C,OAAO,EAAE,iBAAiB,EAAE,MAAM,uBAAuB,CAAC;AAC1D,OAAO,EAAE,YAAY,EAAE,MAAM,iBAAiB,CAAC;AAC/C,OAAO,EAAE,eAAe,EAAE,MAAM,oBAAoB,CAAC;AACrD,OAAO,EAAE,eAAe,EAAE,MAAM,oBAAoB,CAAC;AACrD,OAAO,EAAE,iBAAiB,EAAE,MAAM,sBAAsB,CAAC;AACzD,OAAO,EAAE,kBAAkB,EAAE,MAAM,uBAAuB,CAAC;AAC3D,OAAO,EAAE,eAAe,EAAE,MAAM,oBAAoB,CAAC;AACrD,OAAO,EAAE,WAAW,EAAE,MAAM,gBAAgB,CAAC;AAC7C,OAAO,EAAE,aAAa,EAAE,KAAK,aAAa,EAAE,MAAM,kBAAkB,CAAC;AACrE,OAAO,EAAE,aAAa,EAAE,MAAM,mBAAmB,CAAC;AAClD,OAAO,EAAE,gBAAgB,EAAE,MAAM,qBAAqB,CAAC;AACvD,OAAO,EAAE,eAAe,EAAE,MAAM,oBAAoB,CAAC;AACrD,OAAO,EAAE,oBAAoB,EAAE,MAAM,0BAA0B,CAAC;AAChE,OAAO,EAAE,cAAc,EAAE,MAAM,mBAAmB,CAAC;AACnD,OAAO,EAAE,mBAAmB,EAAE,KAAK,kBAAkB,EAAE,MAAM,kBAAkB,CAAC"}
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../src/managers/index.ts"],"names":[],"mappings":"AAAA;;;;;GAKG;AAEH,OAAO,EAAE,WAAW,EAAE,MAAM,gBAAgB,CAAC;AAC7C,YAAY,EAAE,mBAAmB,EAAE,iBAAiB,EAAE,MAAM,gBAAgB,CAAC;AAC7E,OAAO,EAAE,WAAW,EAAE,MAAM,gBAAgB,CAAC;AAC7C,OAAO,EAAE,iBAAiB,EAAE,MAAM,uBAAuB,CAAC;AAC1D,OAAO,EAAE,YAAY,EAAE,MAAM,iBAAiB,CAAC;AAC/C,OAAO,EAAE,eAAe,EAAE,MAAM,oBAAoB,CAAC;AACrD,OAAO,EAAE,eAAe,EAAE,MAAM,oBAAoB,CAAC;AACrD,OAAO,EAAE,iBAAiB,EAAE,MAAM,sBAAsB,CAAC;AACzD,OAAO,EAAE,kBAAkB,EAAE,MAAM,uBAAuB,CAAC;AAC3D,OAAO,EAAE,eAAe,EAAE,MAAM,oBAAoB,CAAC;AACrD,OAAO,EAAE,WAAW,EAAE,MAAM,gBAAgB,CAAC;AAC7C,OAAO,EAAE,aAAa,EAAE,KAAK,aAAa,EAAE,MAAM,kBAAkB,CAAC;AACrE,OAAO,EAAE,aAAa,EAAE,MAAM,mBAAmB,CAAC;AAClD,OAAO,EAAE,gBAAgB,EAAE,MAAM,qBAAqB,CAAC;AACvD,OAAO,EAAE,eAAe,EAAE,MAAM,oBAAoB,CAAC;AACrD,OAAO,EAAE,oBAAoB,EAAE,MAAM,0BAA0B,CAAC;AAChE,OAAO,EAAE,cAAc,EAAE,MAAM,mBAAmB,CAAC;AACnD,OAAO,EAAE,mBAAmB,EAAE,KAAK,kBAAkB,EAAE,MAAM,kBAAkB,CAAC;AAChF,OAAO,EAAE,4BAA4B,EAAE,KAAK,uBAAuB,EAAE,MAAM,mCAAmC,CAAC"}

package/dist/node.cjs

@@ -1,6 +1,6 @@
 'use strict';
 
-var persSdk = require('./chunks/pers-sdk-CBvzmlL_.cjs');
+var persSdk = require('./chunks/pers-sdk-DcNDMx1Y.cjs');
 var persShared = require('@explorins/pers-shared');
 var nodeHttpClient = require('./chunks/node-http-client-D_avaa5F.cjs');
 require('./chunks/index-C4K-jkRO.cjs');