@halix/action-sdk 1.0.43 → 1.0.45

package/lib/esm/types/access.d.ts

@@ -0,0 +1,229 @@
+import { Observable } from 'rxjs';
+/**
+ * A data scope assigned to a user as part of a sandbox scope entry.
+ */
+export interface ScopeKeyItem {
+    /** Object key for the scoped record, such as an organization or user proxy object key. */
+    scopeKey: string;
+    /** Data element ID for the scoped object. */
+    dataElementId: string;
+    /** Optional display label for the scope entry. */
+    label?: string;
+    /** Optional custom data scope identifier when assigning a custom scope. */
+    customDataScopeId?: string;
+}
+/**
+ * Role metadata available in the current sandbox.
+ *
+ * Use `id` to identify the intended role in code. Use `objKey` when assigning the role to a user through `roleKeys`.
+ */
+export interface Role {
+    /** Persisted role object key. Required when assigning roles through `roleKeys`. */
+    objKey?: string;
+    /** Stable semantic role identifier. Do not submit this as a role key. */
+    id: string;
+    /** Human-readable role name. */
+    name: string;
+    /** Human-readable role description. */
+    description?: string;
+    /** Navigation object keys granted to this role. */
+    navigationKeys?: string[];
+    /** Data element object keys readable by this role. */
+    readDataElementKeys?: string[];
+    /** Data element object keys writable by this role. */
+    writeDataElementKeys?: string[];
+    /** Data element object keys deletable by this role. */
+    deleteDataElementKeys?: string[];
+    /** Platform system roles granted to this role. */
+    systemRoles?: string[];
+    /** Business privilege IDs granted to this role. */
+    businessPrivilegeIds?: string[];
+    /** Optional role grouping labels. */
+    categories?: string[];
+}
+/**
+ * Business privilege metadata available in the current sandbox.
+ */
+export interface BusinessPrivilege {
+    /** Persisted privilege object key, when included by the API. */
+    objKey?: string;
+    /** Stable business privilege identifier used for checks and role grants. */
+    id: string;
+    /** Human-readable privilege name. */
+    name: string;
+    /** Human-readable privilege description. */
+    description?: string;
+    /** Optional privilege grouping labels. */
+    categories?: string[];
+}
+/**
+ * User summary for a user with access to the current sandbox.
+ */
+export interface SandboxUser {
+    /** Persisted user object key. */
+    userKey: string;
+    /** Display name, when available. */
+    name?: string;
+    /** Email address, when available. */
+    email?: string;
+    /** Raw scope entries returned by the access service. */
+    scopeElements?: unknown[];
+}
+/**
+ * Full access wrapper for one user, including scope entries and role metadata when returned by the access service.
+ */
+export interface UserAccessWrapper {
+    /** Raw user payload returned by the access service. */
+    user: unknown;
+    /** Raw scope entries for the user. */
+    scopeElements: unknown[];
+    /** Role metadata associated with the user's access, when returned. */
+    roles?: Role[];
+}
+/**
+ * Request body for inviting a user and assigning initial sandbox access.
+ */
+export interface InviteUserRequest {
+    /** Email address for the invited user. */
+    email: string;
+    /** Optional first name for the invited user. */
+    firstName?: string;
+    /** Optional last name for the invited user. */
+    lastName?: string;
+    /** User proxy data element ID used to create or link the user proxy record. */
+    userProxyElementId: string;
+    /** Optional organization proxy object key for organization-scoped invitations. */
+    orgProxyKey?: string;
+    /** Persisted role object keys (`Role.objKey`). Never pass semantic `Role.id` values here. */
+    roleKeys: string[];
+    /** Optional data scopes granted to the invited user. */
+    scopeKeyItems?: ScopeKeyItem[];
+    /** Optional notification template identifier. */
+    notificationTemplate?: string;
+}
+/**
+ * Result returned from an invitation request.
+ */
+export interface InviteResult {
+    /** Invitation/user token key, when returned by the access service. */
+    userTokenKey?: string;
+    /** Persisted user object key, when a user was created or resolved. */
+    userKey?: string;
+    /** Invited email address. */
+    email?: string;
+    [key: string]: unknown;
+}
+/**
+ * Request body for adding or updating one user scope entry.
+ */
+export interface UpdateAccessRequest {
+    /** Existing scope element ID. When omitted, a new scope entry is added. */
+    scopeElementId?: string;
+    /** Persisted role object keys (`Role.objKey`). Never pass semantic `Role.id` values here. */
+    roleKeys: string[];
+    /** Data scopes to store on the scope entry. */
+    scopeKeyItems: ScopeKeyItem[];
+    /** Whether this scope entry should apply globally instead of being limited to the provided scopes. */
+    globalAccess?: boolean;
+}
+/**
+ * Lists roles available in the current sandbox.
+ *
+ * Use this before assigning roles so semantic role IDs can be resolved to persisted `objKey` values. Assignment
+ * requests must send `Role.objKey` values in `roleKeys`.
+ *
+ * @returns Promise resolving to role metadata for the current sandbox
+ */
+export declare function listRoles(): Promise<Role[]>;
+/**
+ * Observable version of `listRoles`. See `listRoles` for details.
+ */
+export declare function listRolesAsObservable(): Observable<Role[]>;
+/**
+ * Lists business privileges available in the current sandbox.
+ *
+ * Business privilege IDs are used by `hasBusinessPrivilege`, current-user privilege checks, and role
+ * `businessPrivilegeIds`.
+ *
+ * @returns Promise resolving to business privilege metadata
+ */
+export declare function listBusinessPrivileges(): Promise<BusinessPrivilege[]>;
+/**
+ * Observable version of `listBusinessPrivileges`. See `listBusinessPrivileges` for details.
+ */
+export declare function listBusinessPrivilegesAsObservable(): Observable<BusinessPrivilege[]>;
+/**
+ * Lists users with access to the current sandbox.
+ *
+ * Use `getUserAccess` when full scope-entry details are needed for a specific user.
+ *
+ * @returns Promise resolving to sandbox user summaries
+ */
+export declare function listSandboxUsers(): Promise<SandboxUser[]>;
+/**
+ * Observable version of `listSandboxUsers`. See `listSandboxUsers` for details.
+ */
+export declare function listSandboxUsersAsObservable(): Observable<SandboxUser[]>;
+/**
+ * Gets one user's current sandbox access, including scope entries and any role metadata returned by the access service.
+ *
+ * @param userKey - Persisted user object key
+ * @returns Promise resolving to the user's access wrapper
+ */
+export declare function getUserAccess(userKey: string): Promise<UserAccessWrapper>;
+/**
+ * Observable version of `getUserAccess`. See `getUserAccess` for details.
+ */
+export declare function getUserAccessAsObservable(userKey: string): Observable<UserAccessWrapper>;
+/**
+ * Invites a user by email and assigns initial sandbox access.
+ *
+ * `req.roleKeys` must contain persisted role object keys from `Role.objKey`, not semantic role IDs. Resolve desired
+ * semantic IDs with `listRoles` before calling this function.
+ *
+ * @param req - Invitation and initial access request
+ * @returns Promise resolving to invitation result metadata
+ */
+export declare function inviteUser(req: InviteUserRequest): Promise<InviteResult>;
+/**
+ * Observable version of `inviteUser`. See `inviteUser` for details.
+ */
+export declare function inviteUserAsObservable(req: InviteUserRequest): Observable<InviteResult>;
+/**
+ * Adds or updates one user's sandbox scope entry.
+ *
+ * If `req.scopeElementId` is present, the existing scope entry is updated. If it is omitted, a new scope entry is
+ * added. `req.roleKeys` must contain persisted role object keys from `Role.objKey`, not semantic role IDs.
+ *
+ * @param userKey - Persisted user object key
+ * @param req - Scope-entry access update request
+ */
+export declare function updateUserAccess(userKey: string, req: UpdateAccessRequest): Promise<void>;
+/**
+ * Observable version of `updateUserAccess`. See `updateUserAccess` for details.
+ */
+export declare function updateUserAccessAsObservable(userKey: string, req: UpdateAccessRequest): Observable<void>;
+/**
+ * Removes one sandbox scope entry from a user.
+ *
+ * @param userKey - Persisted user object key
+ * @param scopeElementId - Scope element ID to remove from the user
+ */
+export declare function removeUserAccess(userKey: string, scopeElementId: string): Promise<void>;
+/**
+ * Observable version of `removeUserAccess`. See `removeUserAccess` for details.
+ */
+export declare function removeUserAccessAsObservable(userKey: string, scopeElementId: string): Observable<void>;
+/**
+ * Checks whether the current user context contains a business privilege ID.
+ *
+ * @param privilegeId - Stable business privilege ID
+ * @returns True when the current user has the privilege
+ */
+export declare function hasBusinessPrivilege(privilegeId: string): boolean;
+/**
+ * Returns the current user's business privilege IDs from the SDK user context.
+ *
+ * @returns Business privilege IDs for the current user, or an empty array when none are available
+ */
+export declare function userPrivileges(): string[];

package/lib/esm/types/content.d.ts

@@ -58,3 +58,45 @@ export declare function createOrUpdateResource(resourceKey: string | null, fileT
  * Observable version of createOrUpdateResource. See createOrUpdateResource for details.
  */
 export declare function createOrUpdateResourceAsObservable(resourceKey: string | null, fileToUpload: File | Blob, publicFlag: boolean, resourceType: string, tags: string[]): Observable<ContentResource>;
+/**
+ * Fetches a file resource from the Halix content service and returns it as a `Blob` along with
+ * the filename derived from the `Content-Disposition` response header (falling back to
+ * `resourceKey` when the header is absent).
+ *
+ * This function is environment-agnostic: it performs only the authenticated HTTP fetch and leaves
+ * all presentation logic to the caller.
+ *
+ * **Browser download example** — trigger the native Save dialog from a click handler:
+ * ```js
+ * button.addEventListener('click', async () => {
+ *     const { blob, fileName } = await downloadResource(recipe.attachmentKey);
+ *     const url = URL.createObjectURL(blob);
+ *     const a = document.createElement('a');
+ *     a.href = url;
+ *     a.download = fileName;
+ *     a.click();
+ *     URL.revokeObjectURL(url);
+ * });
+ * ```
+ *
+ * **Node.js example** — write the blob to disk:
+ * ```js
+ * const { blob } = await downloadResource(recipe.attachmentKey);
+ * const buffer = Buffer.from(await blob.arrayBuffer());
+ * fs.writeFileSync('attachment.pdf', buffer);
+ * ```
+ *
+ * @param resourceKey - Key of the content resource to fetch
+ * @returns Promise resolving to `{ blob, fileName }`
+ */
+export declare function downloadResource(resourceKey: string): Promise<{
+    blob: Blob;
+    fileName: string;
+}>;
+/**
+ * Observable version of downloadResource. See downloadResource for details.
+ */
+export declare function downloadResourceAsObservable(resourceKey: string): Observable<{
+    blob: Blob;
+    fileName: string;
+}>;

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

@@ -5,7 +5,8 @@
  */
 export { getAuthToken, sandboxKey, serviceAddress, actionSubject, userContext, params, useBody, initialize, type UserContext, type IncomingEventBody, type BaseActionResponse, type ActionResponse, type NotificationConfig, type ListActionResponse, type FormTemplateActionResponse, type PageTemplateActionResponse, type ObjectSaveActionResponse, type CalculatedFieldActionResponse, type SingleValueActionResponse, type ErrorResponse, prepareSuccessResponse, prepareErrorResponse } from './sdk-general';
 export { type SaveOptions, getObject, getObjectAsObservable, getRelatedObjects, getRelatedObjectsAsObservable, getAccessibleObjects, getAccessibleObjectsAsObservable, getObjects, getObjectsAsObservable, saveObject, saveObjectAsObservable, saveRelatedObject, saveRelatedObjectAsObservable, deleteObject, deleteObjectAsObservable, deleteRelatedObject, deleteRelatedObjectAsObservable, deleteRelatedObjects, deleteRelatedObjectsAsObservable } from './data-crud';
-export { type ContentResource, getOrCreateResource, getOrCreateResourceAsObservable, saveResource, saveResourceAsObservable, sendFileContents, sendFileContentsAsObservable, createOrUpdateResource, createOrUpdateResourceAsObservable } from './content';
+export { type ScopeKeyItem, type Role, type BusinessPrivilege, type SandboxUser, type UserAccessWrapper, type InviteUserRequest, type InviteResult, type UpdateAccessRequest, listRoles, listRolesAsObservable, listBusinessPrivileges, listBusinessPrivilegesAsObservable, listSandboxUsers, listSandboxUsersAsObservable, getUserAccess, getUserAccessAsObservable, inviteUser, inviteUserAsObservable, updateUserAccess, updateUserAccessAsObservable, removeUserAccess, removeUserAccessAsObservable, hasBusinessPrivilege, userPrivileges, } from './access';
+export { type ContentResource, getOrCreateResource, getOrCreateResourceAsObservable, saveResource, saveResourceAsObservable, sendFileContents, sendFileContentsAsObservable, createOrUpdateResource, createOrUpdateResourceAsObservable, downloadResource, downloadResourceAsObservable } from './content';
 export { MessageMethod, type MessageRequest, sendMessage, sendMessageAsObservable } from './messaging';
 export { getUserPreference, getOrganizationPreference, getUserPreferenceAsObservable, getOrganizationPreferenceAsObservable } from './preferences';
 export { type SortField, type DataSortField, type BaseListDataRequest, type PagedListDataRequest, type ListDataResponse, type ListDataOptions, type ListDataSearchOptions, type MassEditValueType, type MassEditRequest, type MassDeleteRequest, type MassChangeResponse, getListData, getListDataAsObservable, massEdit, massEditAsObservable, massDelete, massDeleteAsObservable } from './lists';

package/lib/esm/types/sdk-general.d.ts

@@ -58,6 +58,7 @@ export interface UserContext {
     orgProxyKey: string;
     orgKey: string;
     userProxyKey: string;
+    businessPrivileges: string[];
     navigationContext: {
         navigationKey: string;
         navLevel: "organization" | "user";

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@halix/action-sdk",
-  "version": "1.0.43",
+  "version": "1.0.45",
   "description": "Halix Platform action SDK",
   "types": "./lib/cjs/types/index.d.ts",
   "main": "./lib/cjs/index.js",