@flusys/nestjs-entity-builder 9.0.0

package/flow-engine/flow-api-key.d.ts

@@ -0,0 +1,6 @@
+import { type IFlowNode, type IStoredApiKey } from './flow.types.js';
+export declare const hashApiKey: (key: string) => string;
+export declare const apiKeyPrefix: (key: string) => string;
+export declare function looksLikeApiKey(key: unknown): key is string;
+export declare const apiKeyOpens: (stored: IStoredApiKey | null, presented: unknown) => boolean;
+export declare function sealApiKeys(nodes: IFlowNode[]): IFlowNode[];

package/flow-engine/flow-code-sandbox.d.ts

@@ -0,0 +1,5 @@
+export interface ICodeRunResult {
+    output: unknown;
+    logs: string[];
+}
+export declare function runSandboxedCode(code: string, ctx: Record<string, unknown>, timeoutMs: number, node: string): Promise<ICodeRunResult>;

package/flow-engine/flow-engine.d.ts

@@ -0,0 +1,22 @@
+import { type IFlowGraph } from './flow.types.js';
+import { type IFlowEnv, type IFlowRunState, type IFlowRunResult, type IFlowSavePoint, type IFlowTraceEntry } from './flow-run.types.js';
+export declare class FlowEngine {
+    private readonly env;
+    private readonly nodes;
+    private readonly edgesFrom;
+    constructor(graph: IFlowGraph, env: IFlowEnv);
+    walk(state: IFlowRunState): Promise<void>;
+    private targets;
+    private run;
+    private follow;
+    private loop;
+}
+export interface IFailureMapping {
+    status: 'failed' | 'rejected';
+    statusCode: number;
+    body: Record<string, unknown>;
+    error: string;
+}
+export declare function mapFlowFailure(error: unknown, exposeDetails: boolean): IFailureMapping;
+export declare function lastSavePoint(trace: IFlowTraceEntry[]): IFlowSavePoint | null;
+export declare function successResult(state: IFlowRunState, startedAt: number): IFlowRunResult;

package/flow-engine/flow-graph.validator.d.ts

@@ -0,0 +1,20 @@
+import { type IMessageRef } from '@flusys/nestjs-shared/interfaces';
+import { type FlowMessageService, type IFlowEndpoint, type IFlowSettings } from './flow.types.js';
+export interface IFlowValidationResult {
+    errors: IMessageRef[];
+    warnings: IMessageRef[];
+}
+export interface ICallableFlow {
+    isActive: boolean;
+    endpoints: Array<Omit<IFlowEndpoint, 'nodeId'>>;
+    calls: string[];
+}
+export interface IFlowValidationContext {
+    knownEntityCodes?: Set<string>;
+    knownFlows?: Map<string, ICallableFlow>;
+    messageServices?: Partial<Record<FlowMessageService, boolean>>;
+    companyMembers?: boolean;
+}
+export declare function usesPermissionFunction(value: unknown, depth?: number): boolean;
+export declare function validateFlow(flow: IFlowSettings, context?: IFlowValidationContext): IFlowValidationResult;
+export declare function callProblems(caller: IFlowSettings, slug: string, known: Map<string, ICallableFlow>): IMessageRef[];

package/flow-engine/flow-http.client.d.ts

@@ -0,0 +1,15 @@
+export interface IFlowHttpRequest {
+    method: string;
+    url: string;
+    headers?: Record<string, string>;
+    body?: unknown;
+    timeoutMs: number;
+    allowPrivate?: boolean;
+}
+export interface IFlowHttpResponse {
+    status: number;
+    ok: boolean;
+    headers: Record<string, string>;
+    body: unknown;
+}
+export declare function flowHttpRequest(request: IFlowHttpRequest): Promise<IFlowHttpResponse>;

package/flow-engine/flow-input.validator.d.ts

@@ -0,0 +1,7 @@
+import { type IFieldError } from '../services/field-value-validator.js';
+import { type FlowBodyType, type FlowInput, type IFlowInputField } from './flow.types.js';
+export interface IFlowInputResult {
+    values: FlowInput;
+    errors: IFieldError[];
+}
+export declare function validateFlowInput(schema: IFlowInputField[], body: unknown, bodyType?: FlowBodyType): IFlowInputResult;

package/flow-engine/flow-node-handlers.d.ts

@@ -0,0 +1,5 @@
+import { type RuleEvaluationContext } from '../rule-engine/index.js';
+import { type IFlowNode } from './flow.types.js';
+import { type IFlowEnv, type IFlowRunState, type INodeResult } from './flow-run.types.js';
+export declare function evaluationContext(state: IFlowRunState, env?: IFlowEnv): RuleEvaluationContext;
+export declare function runNode(node: IFlowNode, env: IFlowEnv, state: IFlowRunState): Promise<INodeResult>;

package/flow-engine/flow-rate-limiter.d.ts

@@ -0,0 +1,8 @@
+export declare class FlowRateLimiter {
+    private readonly maxKeys;
+    private readonly windows;
+    constructor(maxKeys?: number);
+    hit(key: string, limitPerMinute: number, now?: number): boolean;
+    get size(): number;
+    private dropExpired;
+}

package/flow-engine/flow-reference.d.ts

@@ -0,0 +1,7 @@
+import { type IFlowNode } from './flow.types.js';
+export declare function flowUsesEntity(nodes: IFlowNode[], entityCode: string): boolean;
+export declare function flowRefersToField(nodes: IFlowNode[], entityCode: string, field: string): boolean;
+export declare function rewriteFlowField(nodes: IFlowNode[], entityCode: string, from: string, to: string): {
+    nodes: IFlowNode[];
+    changed: boolean;
+};

package/flow-engine/flow-run.types.d.ts

@@ -0,0 +1,131 @@
+import { type IEmailAdapter, type ILoggedUserInfo, type IMessageRef, type INotificationAdapter, type IUserCompanyAccess } from '@flusys/nestjs-shared/interfaces';
+import { type QueryRunner } from 'typeorm';
+import { type IGenericRecord } from '../interfaces/generic-record.interface.js';
+import { type IRulePermissionResolver, type RuleEngineService, type RuleExpression } from '../rule-engine/index.js';
+import { type IFlowHttpRequest, type IFlowHttpResponse } from './flow-http.client.js';
+import { type FlowInput, type FlowRunAs, type FlowRunMode } from './flow.types.js';
+export interface IFlowTraceEntry {
+    nodeId: string;
+    name: string;
+    type: string;
+    status: 'ok' | 'error' | 'skipped';
+    durationMs: number;
+    iteration?: number;
+    output?: string;
+    error?: IMessageRef;
+    logs?: string[];
+}
+export interface IPendingRecordEvent {
+    entityCode: string;
+    action: 'created' | 'updated' | 'deleted' | 'purged';
+    row: IGenericRecord;
+}
+export interface IPendingFlowEvent {
+    eventName: string;
+    payload: Record<string, unknown>;
+}
+export interface IPendingDelivery {
+    delivery: string;
+    send: () => Promise<void>;
+}
+export type IPendingEvent = IPendingRecordEvent | IPendingFlowEvent | IPendingDelivery;
+export interface IFlowLoopScope {
+    item: unknown;
+    index: number;
+    parent?: IFlowLoopScope;
+}
+export interface IFlowSavePoint {
+    nodeId: string;
+    name: string;
+    at: string;
+}
+export interface IFlowRunState {
+    startAt?: string;
+    input: FlowInput;
+    vars: Record<string, unknown>;
+    context: Record<string, unknown>;
+    loop?: IFlowLoopScope;
+    request: Record<string, unknown>;
+    user: ILoggedUserInfo | null;
+    authorization?: string;
+    permissions?: IRulePermissionResolver;
+    mode: FlowRunMode;
+    runAs: FlowRunAs;
+    systemAuthorized?: boolean;
+    steps: number;
+    httpCalls: number;
+    messages: number;
+    writes: number;
+    deadline: number;
+    qr?: QueryRunner;
+    ownsTransaction?: boolean;
+    savedUpTo?: IFlowSavePoint;
+    callStack: string[];
+    pendingEvents: IPendingEvent[];
+    trace: IFlowTraceEntry[];
+    response?: {
+        status: number;
+        body: unknown;
+    };
+}
+export interface IFlowEnv {
+    ruleEngine: RuleEngineService;
+    entityService(entityCode: string, queryRunner?: QueryRunner): Promise<IFlowEntityAccess>;
+    callFlow(slug: string, input: unknown, state: IFlowRunState, endpoint?: string): Promise<unknown>;
+    http(request: IFlowHttpRequest): Promise<IFlowHttpResponse>;
+    publish(eventName: string, payload: Record<string, unknown>, user: ILoggedUserInfo | null): Promise<void>;
+    atomic<T>(state: IFlowRunState, work: () => Promise<T>): Promise<T>;
+    commit(state: IFlowRunState): Promise<void>;
+    companyAccess(userId: string): Promise<IUserCompanyAccess>;
+    companyMembers?(companyId: string, branchIds?: string[]): Promise<string[]>;
+    assertPermission(code: string, user: ILoggedUserInfo | null): Promise<void>;
+    allowPrivateHttp: boolean;
+    notifications?: INotificationAdapter;
+    email?: IEmailAdapter;
+}
+export interface IFlowEntityAccess {
+    insert(dto: Record<string, unknown>, user: ILoggedUserInfo | null, options?: IFlowWriteOptions): Promise<IGenericRecord>;
+    update(dto: Record<string, unknown> & {
+        id: string;
+    }, user: ILoggedUserInfo | null, options?: IFlowWriteOptions): Promise<IGenericRecord>;
+    delete(id: string, user: ILoggedUserInfo | null, options?: IFlowWriteOptions): Promise<'deleted' | 'purged'>;
+    findById(id: string, options?: IFlowReadOptions): Promise<IGenericRecord>;
+    getAll(search: string | undefined, dto: {
+        filter?: Record<string, unknown>;
+        sort?: Record<string, 'ASC' | 'DESC'>;
+        pagination?: {
+            currentPage: number;
+            pageSize: number;
+        };
+    }, options?: IFlowReadOptions): Promise<{
+        data: IGenericRecord[];
+        total: number;
+    }>;
+}
+export interface IFlowReadOptions {
+    queryRunner?: QueryRunner;
+}
+export interface IFlowWriteOptions extends IFlowReadOptions {
+    publishEvents?: boolean;
+}
+export interface INodeResult {
+    output?: unknown;
+    port?: string;
+    items?: unknown[];
+    collect?: RuleExpression;
+    respond?: {
+        status: number;
+        body: unknown;
+    };
+    skipped?: boolean;
+    logs?: string[];
+}
+export interface IFlowRunResult {
+    status: 'success' | 'failed' | 'rejected';
+    statusCode: number;
+    body: unknown;
+    error?: string;
+    trace: IFlowTraceEntry[];
+    durationMs: number;
+    savedUpTo?: IFlowSavePoint;
+}

package/flow-engine/flow.errors.d.ts

@@ -0,0 +1,27 @@
+import { type IValidationError } from '@flusys/nestjs-shared/exceptions';
+import { type IMessageRef } from '@flusys/nestjs-shared/interfaces';
+export declare class FlowKeyedError extends Error implements IMessageRef {
+    readonly messageKey: string;
+    readonly messageVariables?: Record<string, unknown> | undefined;
+    constructor(messageKey: string, messageVariables?: Record<string, unknown> | undefined, detail?: string);
+}
+export declare class FlowHttpError extends Error {
+    readonly status: number;
+    readonly errors?: IValidationError[] | undefined;
+    readonly messageKey: string;
+    readonly messageVariables: Record<string, unknown>;
+    constructor(status: number, message: string, errors?: IValidationError[] | undefined, reason?: IMessageRef);
+}
+export declare class FlowLimitError extends FlowKeyedError {
+}
+export declare class FlowCodeError extends FlowKeyedError {
+    readonly logs: string[];
+    constructor(messageKey: string, messageVariables: Record<string, unknown>, detail: string, logs?: string[]);
+}
+export declare class FlowNodeError extends Error {
+    readonly nodeId: string;
+    readonly nodeName: string;
+    readonly cause: unknown;
+    constructor(nodeId: string, nodeName: string, cause: unknown);
+}
+export declare function errorRef(error: unknown): IMessageRef;

package/flow-engine/flow.types.d.ts

@@ -0,0 +1,315 @@
+import { type RecordFilterOp } from '../interfaces/generic-record.interface.js';
+import { type RuleExpression, type RuleGroup } from '../rule-engine/index.js';
+export declare const FLOW_NODE_TYPES: readonly ["trigger", "validate", "permission_check", "company_branch_check", "set", "condition", "switch", "foreach", "entity_insert", "entity_update", "entity_delete", "entity_get", "entity_query", "commit", "call_flow", "http_request", "publish_event", "send_notification", "send_email", "respond", "code"];
+export type FlowNodeType = (typeof FLOW_NODE_TYPES)[number];
+export declare const NON_CONTINUABLE_NODE_TYPES: ReadonlySet<FlowNodeType>;
+export declare const FLOW_AUTH_MODES: readonly ["public", "api_key", "jwt", "permission", "internal"];
+export type FlowAuthMode = (typeof FLOW_AUTH_MODES)[number];
+export declare const DEFAULT_AUTH_MODE: FlowAuthMode;
+export declare const KEYLESS_AUTH_MODES: ReadonlySet<FlowAuthMode>;
+export declare const FLOW_RUN_AS: readonly ["caller", "system"];
+export type FlowRunAs = (typeof FLOW_RUN_AS)[number];
+export type FlowRunMode = 'live' | 'dry_run';
+export declare const FLOW_BODY_TYPES: readonly ["object", "list"];
+export type FlowBodyType = (typeof FLOW_BODY_TYPES)[number];
+export type FlowInput = Record<string, unknown> | unknown[];
+export declare const FLOW_INPUT_TYPES: readonly ["string", "text", "number", "integer", "boolean", "date", "datetime", "email", "uuid", "object", "array", "choice"];
+export type FlowInputType = (typeof FLOW_INPUT_TYPES)[number];
+export type FlowInputItemType = Exclude<FlowInputType, 'array'>;
+export interface IFlowInputField {
+    name: string;
+    label?: string;
+    type: FlowInputType;
+    required?: boolean;
+    default?: unknown;
+    min?: number;
+    max?: number;
+    minLength?: number;
+    maxLength?: number;
+    options?: string[];
+    itemType?: FlowInputItemType;
+    fields?: IFlowInputField[];
+}
+export declare const nodeLabel: (node: Pick<IFlowNode, "id" | "name">) => string;
+export interface IFlowNode {
+    id: string;
+    type: FlowNodeType;
+    name: string;
+    position: {
+        x: number;
+        y: number;
+    };
+    config: Record<string, unknown>;
+    onError?: 'stop' | 'continue';
+}
+export interface IFlowEdge {
+    id: string;
+    from: string;
+    port: string;
+    to: string;
+}
+export interface IFlowGraph {
+    nodes: IFlowNode[];
+    edges: IFlowEdge[];
+}
+export interface IFlowSettings extends IFlowGraph {
+    slug: string;
+}
+export type ExpressionMap = Record<string, RuleExpression>;
+export interface IValidateCheck {
+    id: string;
+    rule: RuleGroup;
+    message: string;
+    field?: string;
+}
+export type ValidateMode = 'all' | 'first';
+export interface IValidateConfig {
+    checks: IValidateCheck[];
+    mode?: ValidateMode;
+    statusCode?: number;
+}
+export type PermissionDeniedMode = 'reject' | 'branch';
+export interface IPermissionCheckConfig {
+    codes: string[] | string;
+    match?: 'any' | 'all';
+    onDenied?: PermissionDeniedMode;
+    statusCode?: number;
+    message?: string;
+}
+export interface ICompanyBranchCheckConfig {
+    companyIds?: RuleExpression;
+    branchIds?: RuleExpression;
+    onDenied?: PermissionDeniedMode;
+    statusCode?: number;
+    message?: string;
+}
+export interface ISetConfig {
+    values: ExpressionMap;
+}
+export interface IConditionConfig {
+    rule: RuleGroup;
+}
+export interface ISwitchConfig {
+    value: RuleExpression;
+    cases: Array<{
+        id: string;
+        equals: string | number | boolean | null;
+    }>;
+}
+export interface IForeachConfig {
+    items: RuleExpression;
+    maxItems?: number;
+    collect?: RuleExpression;
+}
+export declare const RECORD_WRITE_TARGETS: readonly ["one", "many", "filter"];
+export type RecordWriteTarget = (typeof RECORD_WRITE_TARGETS)[number];
+export type RecordNotFoundMode = 'error' | 'skip' | 'insert';
+export interface IChildInsert {
+    as: string;
+    entityCode: string;
+    parentField: string;
+    items: RuleExpression;
+    fields: ExpressionMap;
+}
+export interface IEntityInsertConfig {
+    entityCode: string;
+    target?: Extract<RecordWriteTarget, 'one' | 'many'>;
+    fields: ExpressionMap;
+    items?: RuleExpression;
+    children?: IChildInsert[];
+}
+export interface IEntityUpdateConfig {
+    entityCode: string;
+    target?: RecordWriteTarget;
+    id?: RuleExpression;
+    items?: RuleExpression;
+    filter?: FlowFilterMap;
+    limit?: number;
+    fields: ExpressionMap;
+    onNotFound?: RecordNotFoundMode;
+}
+export interface IEntityDeleteConfig {
+    entityCode: string;
+    target?: RecordWriteTarget;
+    id?: RuleExpression;
+    items?: RuleExpression;
+    filter?: FlowFilterMap;
+    limit?: number;
+    onNotFound?: Exclude<RecordNotFoundMode, 'insert'>;
+}
+export interface IEntityGetConfig {
+    entityCode: string;
+    id: RuleExpression;
+    onNotFound?: 'error' | 'null';
+}
+export interface IFlowFilterCondition {
+    op: RecordFilterOp;
+    value?: RuleExpression;
+}
+export type FlowFilterMap = Record<string, RuleExpression | IFlowFilterCondition>;
+export interface IEntityQueryConfig {
+    entityCode: string;
+    filter?: FlowFilterMap;
+    search?: RuleExpression;
+    sort?: {
+        field: string;
+        direction: 'ASC' | 'DESC';
+    };
+    limit?: number;
+}
+export interface ITriggerConfig {
+    path?: string;
+    bodyType?: FlowBodyType;
+    inputSchema?: IFlowInputField[];
+    authMode?: FlowAuthMode;
+    permissionCode?: string;
+    runAs?: FlowRunAs;
+    isTransactional?: boolean;
+    timeoutMs?: number;
+    rateLimitPerMinute?: number;
+    apiKey?: string | IStoredApiKey;
+}
+export interface IStoredApiKey {
+    prefix: string;
+    hash: string;
+}
+export declare function isStoredApiKey(value: unknown): value is IStoredApiKey;
+export interface ICallFlowConfig {
+    flowSlug: string;
+    endpoint?: string;
+    input?: ExpressionMap;
+    inputList?: RuleExpression;
+}
+export interface IHttpRequestConfig {
+    method: 'GET' | 'POST' | 'PUT' | 'PATCH' | 'DELETE';
+    url: RuleExpression;
+    headers?: ExpressionMap;
+    body?: ExpressionMap;
+    timeoutMs?: number;
+    forwardAuth?: boolean;
+}
+export interface IPublishEventConfig {
+    eventName: string;
+    payload: ExpressionMap;
+}
+export declare const FLOW_MESSAGE_SERVICES: {
+    readonly send_notification: "notification";
+    readonly send_email: "email";
+};
+export type FlowMessageNodeType = keyof typeof FLOW_MESSAGE_SERVICES;
+export type FlowMessageService = (typeof FLOW_MESSAGE_SERVICES)[FlowMessageNodeType];
+export declare const isMessageNode: (type: string) => type is FlowMessageNodeType;
+export declare const FLOW_NOTIFICATION_TYPES: readonly ["info", "success", "warning", "error"];
+export type FlowNotificationType = (typeof FLOW_NOTIFICATION_TYPES)[number];
+export declare const FLOW_NOTIFICATION_TARGETS: readonly ["one", "many", "company"];
+export type FlowNotificationTarget = (typeof FLOW_NOTIFICATION_TARGETS)[number];
+export declare const FLOW_EMAIL_TARGETS: readonly ["one", "many"];
+export type FlowEmailTarget = (typeof FLOW_EMAIL_TARGETS)[number];
+export interface ISendNotificationConfig {
+    target?: FlowNotificationTarget;
+    items?: RuleExpression;
+    userIds?: RuleExpression;
+    companyIds?: RuleExpression;
+    branchIds?: RuleExpression;
+    title: RuleExpression;
+    message?: RuleExpression;
+    type?: FlowNotificationType;
+    data?: ExpressionMap;
+    companyId?: RuleExpression;
+    realtime?: boolean;
+}
+export declare const FLOW_EMAIL_MODES: readonly ["content", "template"];
+export type FlowEmailMode = (typeof FLOW_EMAIL_MODES)[number];
+export declare const FLOW_EMAIL_FORMATS: readonly ["text", "html"];
+export type FlowEmailFormat = (typeof FLOW_EMAIL_FORMATS)[number];
+export interface ISendEmailConfig {
+    target?: FlowEmailTarget;
+    items?: RuleExpression;
+    to: RuleExpression;
+    cc?: RuleExpression;
+    bcc?: RuleExpression;
+    replyTo?: RuleExpression;
+    mode?: FlowEmailMode;
+    subject?: RuleExpression;
+    body?: RuleExpression;
+    format?: FlowEmailFormat;
+    templateSlug?: string;
+    variables?: ExpressionMap;
+    emailConfigId?: string;
+}
+export interface IRespondConfig {
+    statusCode: number;
+    body?: ExpressionMap;
+    bodyExpression?: RuleExpression;
+}
+export interface ICodeConfig {
+    code: string;
+    timeoutMs?: number;
+}
+export declare const FLOW_LIMITS: {
+    readonly MAX_NODES: 100;
+    readonly MAX_EDGES: 300;
+    readonly MAX_STEPS_PER_RUN: 5000;
+    readonly MAX_FOREACH_ITEMS: 1000;
+    readonly MAX_LOOP_DEPTH: 3;
+    readonly MAX_CALL_DEPTH: 5;
+    readonly MAX_HTTP_CALLS: 10;
+    readonly MAX_MESSAGES_PER_RUN: 100;
+    readonly MAX_NOTIFICATION_RECIPIENTS: 500;
+    readonly MAX_COMPANY_NOTIFICATION_RECIPIENTS: 5000;
+    readonly MAX_EMAIL_RECIPIENTS: 50;
+    readonly MAX_NOTIFICATION_TITLE_LENGTH: 255;
+    readonly MAX_EMAIL_SUBJECT_LENGTH: 255;
+    readonly MAX_EMAIL_TEMPLATE_SLUG_LENGTH: 255;
+    readonly MAX_HTTP_TIMEOUT_MS: 15000;
+    readonly MAX_HTTP_RESPONSE_BYTES: 1000000;
+    readonly MAX_QUERY_LIMIT: 200;
+    readonly MAX_WRITE_ITEMS: 1000;
+    readonly DEFAULT_WRITE_FILTER_LIMIT: 100;
+    readonly MAX_CHILD_INSERTS: 10;
+    readonly MAX_WRITES_PER_RUN: 5000;
+    readonly DEFAULT_TIMEOUT_MS: 30000;
+    readonly MIN_TIMEOUT_MS: 1000;
+    readonly MAX_TIMEOUT_MS: 120000;
+    readonly DEFAULT_RATE_LIMIT_PER_MINUTE: 60;
+    readonly MAX_RATE_LIMIT_PER_MINUTE: 100000;
+    readonly TRACE_PREVIEW_CHARS: 2000;
+    readonly MAX_INPUT_FIELDS: 50;
+    readonly MAX_INPUT_DEPTH: 4;
+    readonly MAX_VALIDATE_CHECKS: 50;
+    readonly MAX_CODE_LENGTH: 20000;
+    readonly DEFAULT_CODE_TIMEOUT_MS: 1000;
+    readonly MIN_CODE_TIMEOUT_MS: 10;
+    readonly MAX_CODE_TIMEOUT_MS: 5000;
+    readonly CODE_MEMORY_LIMIT_BYTES: number;
+    readonly CODE_STACK_SIZE_BYTES: number;
+    readonly MAX_CODE_OUTPUT_BYTES: 1000000;
+    readonly MAX_CODE_LOG_LINES: 50;
+    readonly MAX_CODE_LOG_LINE_CHARS: 500;
+};
+export declare const FLOW_NODE_ID_PATTERN: RegExp;
+export declare const FLOW_SLUG_PATTERN: RegExp;
+export declare const FLOW_INPUT_NAME_PATTERN: RegExp;
+export declare const FLOW_ENDPOINT_PATH_PATTERN: RegExp;
+export declare const FLOW_ID_PATTERN: RegExp;
+export interface IFlowEndpoint {
+    nodeId: string;
+    path: string | null;
+    bodyType: FlowBodyType;
+    inputSchema: IFlowInputField[];
+    authMode: FlowAuthMode;
+    permissionCode: string | null;
+    runAs: FlowRunAs;
+    isTransactional: boolean;
+    timeoutMs: number;
+    rateLimitPerMinute: number;
+    apiKey: IStoredApiKey | null;
+}
+type EndpointSource = Pick<IFlowSettings, 'nodes'>;
+export declare const isFunctionFlow: (flow: EndpointSource) => boolean;
+export declare function triggerPath(node: Pick<IFlowNode, 'config'>): string | null;
+export declare function flowEndpoints(flow: EndpointSource): IFlowEndpoint[];
+export declare function findEndpoint(flow: EndpointSource, path?: string | null): IFlowEndpoint | undefined;
+export declare function startEndpoint(flow: EndpointSource, nodeId?: string): IFlowEndpoint | undefined;
+export declare function portsOf(node: Pick<IFlowNode, 'type' | 'config'>): string[];
+export {};

package/flow-engine/index.d.ts

@@ -0,0 +1,4 @@
+export * from './flow.types.js';
+export * from './flow-run.types.js';
+export * from './flow.errors.js';
+export * from './flow-graph.validator.js';

package/flow-engine/redact.d.ts

@@ -0,0 +1,3 @@
+export declare const SENSITIVE_KEY: RegExp;
+export declare function redactSensitive(value: unknown, depth?: number): unknown;
+export declare function preview(value: unknown, maxChars: number): string;

package/flow-engine/ssrf-guard.d.ts

@@ -0,0 +1,6 @@
+import { FlowKeyedError } from './flow.errors.js';
+export declare function isPrivateAddress(address: string): boolean;
+export declare class FlowUrlError extends FlowKeyedError {
+}
+export declare function assertUrlAllowed(rawUrl: string, allowPrivate: boolean): URL;
+export declare function safeLookup(allowPrivate: boolean): (hostname: string, options: unknown, callback: (...args: unknown[]) => void) => void;

package/guards/flow-access.guard.d.ts

@@ -0,0 +1,11 @@
+import { SharedPermissionCacheService } from '@flusys/nestjs-shared/modules';
+import { type CanActivate, type ExecutionContext } from '@nestjs/common';
+import { ModuleRef } from '@nestjs/core';
+export declare class FlowAccessGuard implements CanActivate {
+    private readonly moduleRef;
+    private readonly permissionCache;
+    private jwtGuard?;
+    constructor(moduleRef: ModuleRef, permissionCache: SharedPermissionCacheService);
+    canActivate(context: ExecutionContext): Promise<boolean>;
+    private authenticate;
+}

package/guards/index.d.ts

@@ -0,0 +1 @@
+export * from './flow-access.guard.js';

package/index.d.ts

@@ -0,0 +1,11 @@
+export * from './config/index.js';
+export * from './controllers/index.js';
+export * from './dtos/index.js';
+export * from './entities/index.js';
+export * from './flow-engine/index.js';
+export * from './enums/index.js';
+export * from './guards/index.js';
+export * from './interfaces/index.js';
+export * from './modules/index.js';
+export * from './rule-engine/index.js';
+export * from './services/index.js';

package/interfaces/entity-builder-module.interface.d.ts

@@ -0,0 +1,28 @@
+import { type ModuleMetadata, type Provider, type Type } from '@nestjs/common';
+import { type IBootstrapAppConfig, type IDataSourceServiceOptions, type IDynamicModuleConfig } from '@flusys/nestjs-core';
+import { type IModuleEventsConfig } from '@flusys/nestjs-shared/interfaces';
+export interface IEntityBuilderConfig extends IDataSourceServiceOptions {
+    events?: IModuleEventsConfig;
+    flows?: {
+        allowPrivateHttp?: boolean;
+    };
+}
+export interface EntityBuilderModuleOptions extends IDynamicModuleConfig {
+    bootstrapAppConfig?: IBootstrapAppConfig;
+    config?: IEntityBuilderConfig;
+    providers?: Provider[];
+}
+export interface EntityBuilderOptionsFactory {
+    createEntityBuilderOptions(): Promise<IEntityBuilderConfig> | IEntityBuilderConfig;
+}
+export interface EntityBuilderModuleAsyncOptions extends Pick<ModuleMetadata, 'imports'> {
+    global?: boolean;
+    includeController?: boolean;
+    bootstrapAppConfig?: IBootstrapAppConfig;
+    useFactory?: (...args: any[]) => Promise<IEntityBuilderConfig> | IEntityBuilderConfig;
+    inject?: any[];
+    useExisting?: Type<EntityBuilderOptionsFactory>;
+    useClass?: Type<EntityBuilderOptionsFactory>;
+    config?: IEntityBuilderConfig;
+    providers?: Provider[];
+}