@burdenoff/fluidgrids-fe-sdk 2026.1111.15 → 2026.1111.17

package/dist/index-BcdtKBM-.d.ts

@@ -0,0 +1,56 @@
+
+import { FeatureFlagContextValue } from "@burdenoff/fe-libs/shared/feature-flags";
+declare const DURABLE_FUNCTION_NODE_TYPES: ReadonlySet<string>;
+declare const RUN_CONTROL_NODE_TYPES: ReadonlySet<string>;
+declare const WORKFLOW_TEST_NODE_TYPES: ReadonlySet<string>;
+declare function isRunControlNodeType(nodeType: string | null | undefined): boolean;
+interface PaletteGates {
+  durableFunctions: boolean;
+  runControl: boolean;
+  searchAttributes: boolean;
+  workflowTests: boolean;
+}
+declare function isDurableFunctionNodeType(nodeType: string | null | undefined): boolean;
+declare function isNodeTypeHiddenFromPalette(nodeType: string | null | undefined, gates?: boolean | Partial<PaletteGates>): boolean;
+declare function filterPaletteNodes<T extends {
+  type: string;
+}>(nodes: readonly T[], gates?: boolean | Partial<PaletteGates>): readonly T[];
+declare const FLUIDGRIDS_FLAGS: {
+  readonly logStreams: "fluidgrids.log-streams";
+  readonly codeFirst: "fluidgrids.code-first";
+  readonly durableFunctions: "fluidgrids.durable-functions";
+  readonly durableParity: "fluidgrids.durable-parity";
+  readonly selfHostedWorkers: "fluidgrids.self-hosted-workers";
+  readonly runControl: "fluidgrids.run-control";
+  readonly searchAttributes: "fluidgrids.search-attributes";
+  readonly runArchival: "fluidgrids.run-archival";
+  readonly schedulePolicies: "fluidgrids.schedule-policies";
+  readonly pythonDurableFunctions: "fluidgrids.python-durable-functions";
+  readonly workflowTests: "fluidgrids.workflow-tests";
+  readonly continuousOptimisation: "fluidgrids.continuous-optimisation";
+};
+type FluidGridsFlagKey = (typeof FLUIDGRIDS_FLAGS)[keyof typeof FLUIDGRIDS_FLAGS];
+declare const FLUIDGRIDS_FLAG_DEFAULTS: Readonly<Record<FluidGridsFlagKey, boolean>>;
+type FluidGridsFlagContext = Pick<FeatureFlagContextValue, "getEvaluation" | "isLoading" | "error"> & Partial<Pick<FeatureFlagContextValue, "evaluations" | "workspaceId">>;
+declare function useFluidGridsFlag(flag: FluidGridsFlagKey): boolean;
+declare function useDurableFunctionNodesEnabled(): boolean;
+declare function useDurableParityEnabled(): boolean;
+interface PhaseCFlags {
+  runControl: boolean;
+  runControlDurable: boolean;
+  selfHostedWorkers: boolean;
+  searchAttributes: boolean;
+  runArchival: boolean;
+  schedulePolicies: boolean;
+  pythonDurableFunctions: boolean;
+}
+declare const PHASE_C_FLAGS_OFF: Readonly<PhaseCFlags>;
+declare function resolvePhaseCFlags(context: FluidGridsFlagContext | null): PhaseCFlags;
+declare function usePhaseCFlags(): PhaseCFlags;
+declare function resolveFluidGridsFlagsSettled(context: FluidGridsFlagContext | null): boolean;
+declare function useFluidGridsFlagsSettled(): boolean;
+declare function useSelfHostedWorkersEnabled(): boolean;
+declare function useWorkflowTestsEnabled(): boolean;
+declare function useContinuousOptimisationEnabled(): boolean;
+declare function usePaletteGates(): PaletteGates;
+export { isNodeTypeHiddenFromPalette as C, isDurableFunctionNodeType as S, DURABLE_FUNCTION_NODE_TYPES as _, PhaseCFlags as a, WORKFLOW_TEST_NODE_TYPES as b, useContinuousOptimisationEnabled as c, useFluidGridsFlag as d, useFluidGridsFlagsSettled as f, useWorkflowTestsEnabled as g, useSelfHostedWorkersEnabled as h, PHASE_C_FLAGS_OFF as i, useDurableFunctionNodesEnabled as l, usePhaseCFlags as m, FLUIDGRIDS_FLAG_DEFAULTS as n, resolveFluidGridsFlagsSettled as o, usePaletteGates as p, FluidGridsFlagKey as r, resolvePhaseCFlags as s, FLUIDGRIDS_FLAGS as t, useDurableParityEnabled as u, PaletteGates as v, isRunControlNodeType as w, filterPaletteNodes as x, RUN_CONTROL_NODE_TYPES as y };

package/dist/{index-B3BWqafN.d.ts → index-DjiFgEQl.d.ts}

@@ -1,137 +1,8 @@
 
+import { D as FluidGridsEventHandler, f as FluidGridsTheme, t as FluidGridsAuthConfig } from "./index-72XFgvbn.js";
 import { ReactNode } from "react";
 import { ApolloClient } from "@apollo/client/core";
 import { Connection, Edge, EdgeChange, Node, NodeChange } from "@xyflow/react";
-declare const FLUIDGRIDS_EVENTS_VERSION = "1.1.0";
-type FluidGridsErrorSource = "workflow:save" | "workflow:activate" | "run:start";
-interface FluidGridsEventMap {
-  "workflow:saved": {
-    workflowKey: string;
-    version?: string;
-    id?: string;
-  };
-  "workflow:activated": {
-    workflowKey: string;
-    version?: string;
-  };
-  "run:started": {
-    runId: string;
-    workflowKey?: string;
-    mode?: string;
-  };
-  "run:completed": {
-    runId: string;
-    status: string;
-    workflowKey?: string;
-  };
-  "node:selected": {
-    nodeId: string | null;
-    nodeType?: string;
-  };
-  error: {
-    source: FluidGridsErrorSource;
-    message: string;
-    code?: string;
-  };
-  "auth:failed": {
-    message: string;
-  };
-  "builder:fullscreen": {
-    active: boolean;
-  };
-}
-type FluidGridsEventName = keyof FluidGridsEventMap;
-type FluidGridsEventPayload<K extends FluidGridsEventName> = FluidGridsEventMap[K];
-declare const FLUIDGRIDS_EVENT_NAMES: readonly FluidGridsEventName[];
-type FluidGridsEventArgs = { [K in FluidGridsEventName]: [name: K, payload: FluidGridsEventMap[K]]; }[FluidGridsEventName];
-type FluidGridsEventHandler = (...args: FluidGridsEventArgs) => void;
-type FluidGridsThemeMode = "light" | "dark";
-interface FluidGridsThemeColors {
-  bgCanvas?: string;
-  bgSurface?: string;
-  bgElevated?: string;
-  bgSunken?: string;
-  textPrimary?: string;
-  textSecondary?: string;
-  textMuted?: string;
-  borderDefault?: string;
-  borderSubtle?: string;
-  borderStrong?: string;
-  primary?: string;
-  primaryHover?: string;
-  primaryActive?: string;
-  primaryText?: string;
-  success?: string;
-  warning?: string;
-  error?: string;
-  info?: string;
-}
-interface FluidGridsThemeRadius {
-  base?: string;
-  card?: string;
-  button?: string;
-  input?: string;
-}
-interface FluidGridsThemeFont {
-  body?: string;
-  heading?: string;
-  mono?: string;
-}
-interface FluidGridsThemeTokens {
-  mode?: FluidGridsThemeMode;
-  colors?: FluidGridsThemeColors;
-  radius?: FluidGridsThemeRadius;
-  font?: FluidGridsThemeFont;
-}
-type FluidGridsTheme = FluidGridsThemeMode | FluidGridsThemeTokens;
-type FluidGridsThemeValueKind = "color" | "length" | "font";
-interface FluidGridsThemeTokenMapping {
-  kind: FluidGridsThemeValueKind;
-  cssVariables: readonly string[];
-}
-type FluidGridsThemeTokenKey = `colors.${keyof FluidGridsThemeColors & string}` | `radius.${keyof FluidGridsThemeRadius & string}` | `font.${keyof FluidGridsThemeFont & string}`;
-declare const FLUIDGRIDS_THEME_TOKEN_MAP: Readonly<Record<FluidGridsThemeTokenKey, FluidGridsThemeTokenMapping>>;
-declare function themeToCssVariables(theme: FluidGridsTheme | null | undefined): Record<string, string>;
-declare function applyFluidGridsTheme(theme: FluidGridsTheme | null | undefined): () => void;
-interface WorkflowSavedResult {
-  dbId: string;
-  workflowKey: string;
-  version: string;
-  name: string;
-  description?: string;
-  operation: "created" | "updated" | "versioned";
-}
-interface FluidGridsRefreshedTokens {
-  authToken?: string;
-  workspaceToken?: string;
-}
-interface FluidGridsAuthConfig {
-  onTokenExpired?: () => Promise<string | FluidGridsRefreshedTokens>;
-}
-interface FluidGridsConfig {
-  apiGatewayUrl: string;
-  globalApiUrl?: string;
-  authToken?: string;
-  workspaceId: string;
-  workspaceToken?: string;
-  tenantId?: string;
-  organizationId?: string;
-  fluidgridFrontendUrl?: string;
-  productId?: string;
-  productName?: string;
-  trustedOrigins?: string[];
-  devportalBasePath?: string;
-  onWorkflowSaved?: (result: WorkflowSavedResult) => void | Promise<void>;
-  theme?: FluidGridsTheme;
-  auth?: FluidGridsAuthConfig;
-  onEvent?: FluidGridsEventHandler;
-}
-declare const config: FluidGridsConfig;
-declare function getFluidGridsConfig(): FluidGridsConfig;
-declare function setFluidGridsConfig(newConfig: Partial<FluidGridsConfig>): void;
-declare function resetFluidGridsConfig(): void;
-declare function getGraphQLEndpoint(baseUrl?: string): string;
-declare function resetFluidGridsExecutionState(): void;
 interface FluidGridsProviderProps {
   apiGatewayUrl?: string;
   globalApiUrl?: string;
@@ -493,6 +364,9 @@ interface WorkflowBuilderProps extends Omit<WorkflowBuilderCoreProps, "workflow"
 }
 declare function WorkflowBuilder$1({ workflowId, workflowVersion, initialWorkflow, apiGatewayUrl, globalApiUrl, authToken, workspaceId, tenantId, productId, userId, workspaceToken, organizationId, workspaceClient, globalClient, theme, auth, onEvent, ...coreProps }: WorkflowBuilderProps): import("react").JSX.Element;
 declare function WorkflowBuilder(): import("react").JSX.Element;
+declare namespace WorkflowSearchRedirect_d_exports {
+  export { WorkflowSearchRedirect };
+}
 declare function WorkflowSearchRedirect(): import("react").JSX.Element;
 interface ExecutionState {
   isExecuting: boolean;
@@ -685,4 +559,4 @@ interface IFlowState {
 }
 declare const useFlowStore: import("zustand").UseBoundStore<import("zustand").StoreApi<IFlowState>>;
 declare function refetchStoreNodes(): Promise<void>;
-export { FluidGridsThemeMode as $, FlowEdge as A, FluidGridsConfig as B, WorkflowData as C, EdgeCondition as D, ConditionRule as E, NodeManifest as F, getGraphQLEndpoint as G, WorkflowSavedResult as H, FluidGridsProvider as I, setFluidGridsConfig as J, resetFluidGridsConfig as K, FluidGridsProviderProps as L, FlowNodeData as M, MappingValue as N, EdgeMapping as O, NodeEndpointConfig as P, FluidGridsThemeFont as Q, useFluidGridsContext as R, Tag as S, WorkflowDefinitionJson as T, config as U, FluidGridsRefreshedTokens as V, getFluidGridsConfig as W, FluidGridsTheme as X, FLUIDGRIDS_THEME_TOKEN_MAP as Y, FluidGridsThemeColors as Z, RUN_STATUS_CONFIG as _, WorkflowBuilder as a, applyFluidGridsTheme as at, WorkflowRun as b, WorkflowBuilderCore as c, FLUIDGRIDS_EVENT_NAMES as ct, ExecutionLog as d, FluidGridsEventHandler as dt, FluidGridsThemeRadius as et, ExecutionsFilter as f, FluidGridsEventMap as ft, NodeStatus as g, NodeState as h, WorkflowSearchRedirect as i, FluidGridsThemeValueKind as it, FlowNode as j, ExtendedNodeType as k, WorkflowBuilderCoreProps as l, FluidGridsErrorSource as lt, NODE_STATUS_CONFIG as m, FluidGridsEventPayload as mt, IFlowState as n, FluidGridsThemeTokenMapping as nt, WorkflowBuilder$1 as o, themeToCssVariables as ot, ExecutionsPagination as p, FluidGridsEventName as pt, resetFluidGridsExecutionState as q, useFlowStore as r, FluidGridsThemeTokens as rt, WorkflowBuilderProps as s, FLUIDGRIDS_EVENTS_VERSION as st, refetchStoreNodes as t, FluidGridsThemeTokenKey as tt, ErrorType as u, FluidGridsEventArgs as ut, RunStatus as v, WorkflowDefinition as w, SidebarState as x, WorkflowError as y, FluidGridsAuthConfig as z };
+export { ExtendedNodeType as A, Tag as C, ConditionRule as D, WorkflowDefinitionJson as E, NodeEndpointConfig as F, NodeManifest as I, FluidGridsProvider as L, FlowNode as M, FlowNodeData as N, EdgeCondition as O, MappingValue as P, FluidGridsProviderProps as R, SidebarState as S, WorkflowDefinition as T, NodeStatus as _, WorkflowSearchRedirect_d_exports as a, WorkflowError as b, WorkflowBuilderProps as c, ErrorType as d, ExecutionLog as f, NodeState as g, NODE_STATUS_CONFIG as h, WorkflowSearchRedirect as i, FlowEdge as j, EdgeMapping as k, WorkflowBuilderCore as l, ExecutionsPagination as m, IFlowState as n, WorkflowBuilder as o, ExecutionsFilter as p, useFlowStore as r, WorkflowBuilder$1 as s, refetchStoreNodes as t, WorkflowBuilderCoreProps as u, RUN_STATUS_CONFIG as v, WorkflowData as w, WorkflowRun as x, RunStatus as y, useFluidGridsContext as z };