@boomi/embedkit 1.2.10 → 1.2.12

package/dist/index.d.ts

@@ -0,0 +1,641 @@
+import { BrowseCandidate } from '@boomi/embedkit-sdk';
+import { default as default_2 } from 'react';
+import { EnvExtMinimal } from '../../types/ui';
+import { EnvExtMinimal as EnvExtMinimal_2 } from '@boomi/embedkit-sdk';
+import { Environment } from '@boomi/embedkit-sdk';
+import { EnvironmentExtensions } from '@boomi/embedkit-sdk';
+import { EnvironmentMapExtension } from '@boomi/embedkit-sdk';
+import { IntegrationPackInstance } from '@boomi/embedkit-sdk';
+import { PluginConfig } from './types/plugin.config';
+import { PluginUiConfig } from '../types/plugin-ui.config';
+import { ProcessSchedules } from '@boomi/embedkit-sdk';
+import { PropsWithChildren } from 'react';
+import { ReactElement } from 'react';
+import { Schedule } from '@boomi/embedkit-sdk';
+import { ServerApi } from '../types/plugin-context';
+import { TransformationStructuredOutput } from '@boomi/embedkit-sdk';
+import { UpdateResult } from '@boomi/embedkit-sdk';
+
+/**
+ * Stores the initial plugin configuration and (asynchronously) kicks off loading
+ * of an external configuration file, if provided. Call this once before
+ * {@link RenderComponent}.
+ *
+ * @public
+ * @param config - The base plugin configuration.
+ *
+ * @example
+ * ```ts
+ * BoomiPlugin({
+ *   apiBaseUrl: 'https://api.example.com',
+ *   accountGroup: 'my-group',
+ *   theme: { allowThemes: true, defaultTheme: 'boomi' },
+ * });
+ * ```
+ */
+declare function BoomiPlugin(config: PluginConfig): void;
+export { BoomiPlugin }
+export default BoomiPlugin;
+
+declare const componentMap: {
+    Integrations: default_2.FC<IntegrationsProps>;
+    ConfigureIntegration: default_2.FC<ConfigureIntegrationProps>;
+    ExecutionHistory: default_2.FC<ExecutionHistoryProps>;
+    UpdateConnections: default_2.ForwardRefExoticComponent<UpdateConnectionsProps & default_2.RefAttributes<UpdateConnectionsRef>>;
+    UpdateMaps: default_2.FC<UpdateMapsProps>;
+    UpdateSchedules: default_2.ForwardRefExoticComponent<UpdateSchedulesProps & default_2.RefAttributes<UpdateScheduleRef>>;
+};
+
+declare type ComponentName = keyof typeof componentMap;
+
+/**
+ * @interface ConfigureIntegrationProps
+ *
+ * @description
+ * Props for the `ConfigureIntegration` component.
+ *
+ * @property {boolean} [componentKey] - Unique key for the component instance
+ * @property {IntegrationPack} integration - The integration pack to configure.
+ * @property {number} [indexPage] - Optional initial page index to open in the wizard.
+ * @property {() => void} onBack - Callback to navigate back or cancel the flow.
+ * @property {(id: string) => void} onDelete - Callback to delete an integration by its ID.
+ */
+declare interface ConfigureIntegrationProps {
+    componentKey: string;
+    integration: IntegrationPackInstance;
+    indexPage?: number;
+    onBack: () => void;
+    hostId?: string;
+}
+
+export declare function createEmbedKit(overrides?: Partial<PluginConfig>): PluginConfig;
+
+/**
+ * Destroys the plugin Shadow DOM and React tree, with optional cleanup behaviors.
+ *
+ * @public
+ * @param opts - Optional clean-up behaviors.
+ * @param opts.removeHost - If true, remove the host element with id `#boomi` from the DOM.
+ * @param opts.clearAuth - If true, scrub auth fields from in-memory config.
+ *
+ * @example
+ * ```ts
+ * DestroyPlugin({ removeHost: true, clearTheme: true, clearAuth: true });
+ * ```
+ */
+export declare function DestroyPlugin(opts?: {
+    hostId?: HostId;
+    removeHost?: boolean;
+    clearAuth?: boolean;
+}): void;
+
+export declare function EmbedKitProvider({ config, children }: EmbedKitProviderProps): ReactElement;
+
+declare type EmbedKitProviderProps = PropsWithChildren & {
+    config: PluginConfig;
+};
+
+/**
+ * @interface ExecutionHistoryProps
+ *
+ * @description
+ * Props for the `ExecutionHistory` component.
+ *
+ * @property {boolean} [componentKey] - Unique key for the component instance
+ * @property {IntegrationPack} integration - The integration pack whose execution history is shown.
+ * @property {() => void} onBack - Callback function invoked when navigating back.
+ */
+declare interface ExecutionHistoryProps {
+    componentKey: string;
+    integration: IntegrationPackInstance;
+    onBack: () => void;
+}
+
+declare type HostId = string;
+
+/**
+ * @file IntegrationActions.tsx
+ * @component Integrations
+ * @license BSD-2-Clause
+ * @support https://bitbucket.org/officialboomi/embedkit
+ *
+ * @description
+ * The `Integrations` component displays a list of integration packs and allows users to add, edit, run, and delete integrations.
+ * It supports both grid and table views, search functionality, execution history viewing, and pagination.
+ * Provides UI for adding new integrations via a modal form and integrates with Boomi hooks for fetching, creating,
+ * deleting, and running integration packs.
+ *
+ * @return {JSX.Element} A fully functional integrations component with search, view, edit, delete, run, and history capabilities.
+ */
+/**
+ * @interface IntegrationsProps
+ *
+ * @description Props for the `Integrations` component.
+ *
+ * @property {boolean} [showUpdateControls] - Flag indicating whether to show update controls.
+ * @property {boolean} [componentKey] - Optional unique key for the component instance
+ * @property {'on' | 'off'} [defaultView] - Default view mode for displaying integrations, either 'on' or 'off'.
+ */
+declare interface IntegrationsProps {
+    componentKey: string;
+    showUpdateControls?: boolean;
+}
+
+declare type MaybeWithKey<P> = P extends {
+    componentKey: any;
+} ? Omit<P, 'componentKey'> & {
+    componentKey: string;
+} : P;
+
+export { PluginConfig }
+
+/**
+ * Stores the initial plugin configuration and (asynchronously) kicks off loading
+ * of an external configuration file, if provided. Call this once before
+ * {@link RenderComponent}.
+ *
+ * @public
+ * @param config - The base plugin configuration.
+ *
+ * @example
+ * ```ts
+ * BoomiPlugin({
+ *   apiBaseUrl: 'https://api.example.com',
+ *   accountGroup: 'my-group',
+ *   theme: { allowThemes: true, defaultTheme: 'boomi' },
+ *   configFile: '/boomi.config.js'
+ * });
+ * ```
+ */
+export declare function RenderComponent<T extends ComponentName>({ component, props, hostId, componentKey, }: {
+    component: T;
+    props: MaybeWithKey<Parameters<(typeof componentMap)[T]>[0]>;
+    hostId?: string;
+    componentKey?: string;
+}): void;
+
+/**
+ * @interface UpdateConnectionsProps
+ *
+ * @description
+ * Props for the `UpdateConnections` component.
+ *
+ * @property {IntegrationPack} integration - The integration pack to update connections for.
+ * @property {boolean} active - Whether this component is currently active/visible.
+ * @property {boolean} wizard - Indicates if the component is used inside a wizard flow.
+ * @property {() => void} [onSubmit] - Optional callback invoked after a successful submit.
+ * @property {(val: boolean) => void} [setIsLoading] - Optional callback to set loading state externally.
+ * @property {() => void} [onBack] - Optional callback invoked when navigating back.
+ */
+declare interface UpdateConnectionsProps {
+    componentKey: string;
+    integration: IntegrationPackInstance;
+    active: boolean;
+    wizard: boolean;
+    onSubmit?: () => void;
+    setIsLoading?: (val: boolean) => void;
+    onBack?: () => void;
+}
+
+/**
+ * @typedef UpdateConnectionsRef
+ *
+ * @description
+ * Methods exposed to parent components for controlling the `UpdateConnections` component.
+ *
+ * @property {boolean} [componentKey] - Unique key for the component instance
+ * @property {() => Promise<boolean>} submit - Submits the current connection updates. Returns `true` if successful.
+ * @property {() => void} load - Reloads the connection data.
+ */
+declare type UpdateConnectionsRef = {
+    submit: () => Promise<boolean>;
+};
+
+/**
+ * @interface UpdateMapsProps
+ *
+ * @description
+ * Props for the `UpdateMaps` component.
+ *
+ * @property {boolean} [componentKey] - Unique key for the component instance
+ * @property {boolean} active - Whether this component is currently active/visible.
+ * @property {boolean} wizard - Indicates if the component is used inside a wizard flow.
+ * @property {IntegrationPack} integration - The integration pack to update maps for.
+ * @property {EnvironmentMapExtension[]} maps - The list of environment map extensions to display and edit.
+ * @property {(updatedMaps: EnvironmentMapExtension[]) => void} [onMapsChange] - Optional callback invoked when the maps are updated.
+ * @property {() => void} [onBack] - Optional callback invoked to navigate back.
+ * @property {(val: boolean) => void} [setIsLoading] - Optional callback to set loading state externally.
+ */
+declare interface UpdateMapsProps {
+    componentKey: string;
+    active: boolean;
+    wizard: boolean;
+    integration: IntegrationPackInstance;
+    onBack?: () => void;
+    setIsLoading?: (val: boolean) => void;
+}
+
+/**
+ * @typedef UpdateScheduleRef
+ *
+ * @description
+ * Methods exposed via ref to parent components for controlling the `UpdateSchedules` component.
+ *
+ * @property {() => Promise<boolean>} submit - Submits the updated schedule. Returns `true` if successful.
+ */
+declare type UpdateScheduleRef = {
+    submit: () => Promise<boolean>;
+};
+
+/**
+ * @interface UpdateSchedulesProps
+ *
+ * @description
+ * Props for the `UpdateSchedules` component.
+ *
+ * @property {boolean} [componentKey] - Unique key for the component instance
+ * @property {IntegrationPack} integration - The integration pack to update schedules for.
+ * @property {(val: boolean) => void} [setIsLoading] - Optional callback to set loading state externally.
+ * @property {() => void} [onSubmit] - Optional callback invoked after a successful submit.
+ * @property {() => void} [onBack] - Optional callback invoked to navigate back in wizard mode.
+ * @property {boolean} active - Whether this component is currently active/visible.
+ * @property {boolean} wizard - Indicates if the component is used inside a wizard flow.
+ */
+declare interface UpdateSchedulesProps {
+    componentKey: string;
+    integration: IntegrationPackInstance;
+    setIsLoading?: (val: boolean) => void;
+    onSubmit?: () => void;
+    onBack?: () => void;
+    active: boolean;
+    wizard: boolean;
+}
+
+/**
+ * Provides an imperative `createInstance` function that:
+ *  1) Creates a new Integration Pack Instance.
+ *  2) Optionally attaches the provided environments to that instance.
+ *  3) Builds a convenient `IntegrationPack` config object for UI consumption.
+ *
+ * @return {{
+ *   integrationPackConfig: IntegrationPack | null;
+ *   environmentsAttached: Environment[];
+ *   isLoading: boolean;
+ *   error: string | null;
+ *   createInstance: (
+ *     integrationPackId: string,
+ *     isSingleInstall?: boolean,
+ *     integrationPackOverrideName?: string,
+ *     environments?: Environment[]
+ *   ) => Promise<IntegrationPack | undefined>;
+ * }}
+ *   Hook API including the latest config, attached environments, loading/error state, and the creator function.
+ *
+ * @throws {Error}
+ *   When the Boomi client/context is missing, required inputs are invalid,
+ *   or the create/attach operations fail.
+ */
+export declare const useCreateIntegrationPackInstance: () => {
+    integrationPackConfig: IntegrationPackInstance | null;
+    isLoading: boolean;
+    error: string | null;
+    createInstance: (integrationPackId: string, isSingleInstall: boolean | undefined, environmentId: string, integrationPackOverrideName?: string) => Promise<IntegrationPackInstance | undefined>;
+};
+
+/**
+ * Provides an imperative `deleteIntegrationPackInstance` function that removes
+ * an integration pack instance by ID.
+ *
+ * @return {{
+ *   deleteIntegrationPackInstance: (integrationPackInstanceId: string) => Promise<boolean>;
+ *   isLoading: boolean;
+ *   error: string | null;
+ * }}
+ *   Hook API with the delete function and request state.
+ *
+ * @throws {Error}
+ *   If the Boomi client or required context is missing, or if the ID is not provided.
+ */
+export declare const useDeleteIntegrationPackInstance: () => {
+    deleteIntegrationPackInstance: (integrationPackInstanceId: string) => Promise<boolean>;
+    isLoading: boolean;
+    error: string | null;
+};
+
+declare type UseEmbedKit = {
+    hostId?: string;
+    componentKey?: string;
+    pageIsLoading: boolean;
+    isReady: boolean;
+    accessToken: string | null;
+    serverApi: ServerApi;
+    boomiConfig?: PluginUiConfig;
+    setPageIsLoading: (v: boolean) => void;
+    logout: () => void;
+};
+
+export declare function useEmbedKit(): UseEmbedKit;
+
+/**
+ * React hook that:
+ *  1) Retrieves the current Boomi account group from context,
+ *  2) Queries the Boomi API for associated Integration Packs,
+ *  3) Filters out packs based on installation type and whether an instance already exists.
+ *
+ * @return {{
+ *   integrationPacks: any[];
+ *   isLoading: boolean;
+ *   error: string | null;
+ * }}
+ *   Hook result containing the eligible Integration Packs for the account group, loading state, and any error.
+ *
+ * @throws {Error}
+ *   If the Boomi SDK or required configuration values are missing.
+ */
+export declare const useFetchAccountGroupIntegrationPacks: () => {
+    integrationPacks: any[];
+    isLoading: boolean;
+    error: string | null;
+};
+
+/**
+ * Generates Boomi-compatible transformation functions via OpenAI:
+ *  1) Reads AI config (enabled, model, apiKey) from context.
+ *  2) Sends a structured prompt to produce name, script, inputs, outputs.
+ *  3) Validates the response against `AiTransformation` (zod).
+ *  4) Shapes the result into Boomi `MapExtensionsFunction` format.
+ *
+ * @return {{
+ *   result: any | null;
+ *   isLoading: boolean;
+ *   error: string | null;
+ *   fetchTransformation: (userPrompt: string, id: string) => Promise<any | void>;
+ * }}
+ *   Hook API with the latest generated result, loading/error state, and an invoker.
+ *
+ * @throws {Error}
+ *   When AI is enabled but model or apiKey is missing in context.
+ */
+export declare const useFetchAiTransformations: () => {
+    result: any;
+    isLoading: boolean;
+    error: string | null;
+    fetchTransformation: (userPrompt: string, id: string) => Promise<TransformationStructuredOutput | undefined>;
+};
+
+/**
+ * Retrieves environment extensions for the given environment(s) and integration pack instance.
+ * Identifies and strips sensitive OAuth2 access token fields while separately returning
+ * metadata about them.
+ *
+ * @return {{
+ *   extensions: EnvironmentExtensions[] | null;
+ *   fetchEnvironmentExtensions: (
+ *     environments: Environment[],
+ *     environmentId: string,
+ *     integrationPackInstanceId: string
+ *   ) => Promise<void>;
+ *   isLoading: boolean;
+ *   error: string | null;
+ * }}
+ *   Hook API with filtered extensions, matched token field metadata, loading/error state, and a refetch method.
+ *
+ * @throws {Error}
+ *   If the Boomi client, integrationPackInstanceId, or required environment inputs are missing.
+ */
+export declare const useFetchEnvironmentExtensions: ({}?: {}) => {
+    extensions: EnvExtMinimal[] | null;
+    rawExtensions: EnvironmentExtensions[] | null;
+    fetchEnvironmentExtensions: (environments: Environment[], environmentId: string, integrationPackInstanceId: string) => Promise<void>;
+    isLoading: boolean;
+    error: string | null;
+};
+
+/**
+ * Fetches environments from the Boomi API using classification (PROD/TEST/ALL)
+ * or a specific environment ID. When available, enriches environments with Atom
+ * attachments and computes an `isActive` flag (true if all attached Atoms are ONLINE).
+ *
+ *
+ * @return {{ environments: any[]; isLoading: boolean; error: string | null }}
+ *   An object containing the fetched environments with metadata, loading state, and any error.
+ *
+ * @throws {Error}
+ *   If required context (Boomi SDK, apiAccountId) or parameters are missing.
+ */
+export declare const useFetchEnvironments: () => {
+    fetchEnvironments: (includeEnvironments?: "PROD" | "TEST" | "ALL", environmentId?: string | null) => Promise<void>;
+    environments: any[];
+    isLoading: boolean;
+    error: string | null;
+};
+
+/**
+ * Fetches execution records for all processes under a given integration pack
+ * instance ID (`id`). Optionally filters by a search term (case-insensitive)
+ * against the record `message` field. Records are sorted (oldest → newest) when
+ * no search term is provided, and paginated with a fixed page size.
+ *
+ * @return {{
+ *   records: ExecutionRecord[];
+ *   isLoading: boolean;
+ *   error: string | null;
+ *   currentPage: number;
+ *   totalPages: number;
+ *   goToPage: (page: number) => void;
+ *   refetch: () => void;
+ * }}
+ *   Hook API with current page of records, loading/error state, pagination helpers, and a refetch method.
+ *
+ * @throws {Error}
+ *   Sets error state if Boomi client is missing or if required parameters are not provided.
+ */
+export declare const useFetchExecutionRecords: (id: string, searchTerm?: string) => {
+    records: any;
+    isLoading: boolean;
+    error: string | null;
+    currentPage: number;
+    totalPages: number;
+    goToPage: (page: number) => void;
+    refetch: () => void;
+};
+
+/**
+ * @function fetchIntegrationPackInstances
+ *
+ * @description
+ * Internal async helper that:
+ *  - Resolves the account group ID.
+ *  - Retrieves integration packs available to that group.
+ *  - Queries pack instances, applies search, paginates, and enriches results
+ *    with installation type, display name/description, and attached env IDs.
+ *
+ * @returns {Promise<void>} Resolves when state has been updated.
+ */
+export declare const useFetchIntegrationPackInstances: ({ search }: {
+    search?: string;
+}) => {
+    integrationPackInstances: IntegrationPackInstance[];
+    refetch: () => Promise<void>;
+    isLoading: boolean;
+    error: string | null;
+    currentPage: number;
+    totalPages: number;
+    goToPage: (page: number) => void;
+};
+
+/**
+ * Fetches map extension summaries (and, unless `breakOnSummary` is true, the full
+ * map extensions) for a given Integration Pack Instance ID. Results are de-duplicated
+ * across environments and processes.
+ *
+ * @return {{
+ *   maps: EnvironmentMapExtension[],
+ *   hasMaps: boolean,
+ *   fetchMapExtensions: () => Promise<void>,
+ *   isLoading: boolean,
+ *   error: string | null
+ * }}
+ *   Hook API including fetched maps (when not short-circuited), a boolean indicating if any maps exist,
+ *   a refetch method, and request state flags.
+ *
+ * @throws {Error}
+ *   Sets error state if the Boomi client is missing or if required parameters are invalid.
+ */
+export declare const useFetchMapExtensions: () => {
+    maps: EnvironmentMapExtension[];
+    hasMaps: boolean;
+    hasCandidates: boolean;
+    mapCandidates: BrowseCandidate[];
+    fetchMapExtensions: (integrationPackInstanceId: string, environmentId: string) => Promise<void>;
+    isLoading: boolean;
+    error: string | null;
+};
+
+/**
+ * Provides a method to fetch process schedules for a given environment and
+ * integration pack instance. Looks up atom attachments, queries processes, and
+ * then queries schedules per (atomId, processId) pair until one is found.
+ *
+ * @return {{
+ *   schedule: ProcessSchedules | null;
+ *   processes: Process[];
+ *   isLoading: boolean;
+ *   error: string | null;
+ *   fetchSchedules: (params: UseFetchProcessSchedulesParams) => Promise<void>;
+ * }}
+ *   Hook state and API.
+ *
+ * @throws {Error}
+ *   If required params are missing or queries fail.
+ */
+export declare const useFetchProcessSchedules: () => {
+    schedule: ProcessSchedules | null;
+    isLoading: boolean;
+    error: string | null;
+    fetchSchedules: (environmentId: string, integrationPackInstanceId: string) => Promise<void>;
+};
+
+/**
+ * @description
+ * Provides a `runAllProcesses` function to:
+ *  1. Retrieve all Atoms for the given environment.
+ *  2. Retrieve all processes for the given integration pack instance.
+ *  3. Trigger execution requests for every process/atom combination.
+ *  4. Return the execution record URLs for tracking.
+ *
+ * @return {{
+ *   isRunning: boolean;
+ *   recordUrls: string[];
+ *   error: string | null;
+ *   runAllProcesses: (params: UseRunAllProcessesParams) => Promise<string[] | void>;
+ * }}
+ *   Hook API containing loading state, execution URLs, errors, and the execution function.
+ *
+ * @throws {Error}
+ *   If Boomi is not initialized or required parameters are missing.
+ */
+export declare const useRunAllProcesses: () => {
+    isRunning: boolean;
+    recordUrls: string[];
+    error: string | null;
+    runAllProcesses: (environmentId: string, integrationPackInstanceId: string) => Promise<string[] | undefined>;
+};
+
+/**
+ * Provides an imperative `updateEnvironmentExtensions` function to update a single
+ * environment extension record. Sets `partial=true` prior to update to indicate a
+ * partial update. Updates plugin config after completion.
+ *
+ * @return {{
+ *   updateEnvironmentExtensions: (
+ *     extension: EnvironmentExtensions,
+ *     environmentId: string,
+ *     extensionGroupId: string
+ *   ) => Promise<void>;
+ *   isUpdating: boolean;
+ *   updateError: string | null;
+ *   updatedExtension: EnvironmentExtensions | null;
+ * }}
+ *   Hook API exposing the update function and request state.
+ *
+ * @throws {Error}
+ *   If required inputs are missing or the update call fails.
+ */
+export declare const useUpdateEnvironmentExtensions: () => {
+    updateFromCombined: (originals: EnvironmentExtensions[], combinedEdited: EnvExtMinimal_2[], environmentId: string, integrationPackInstanceId: string) => Promise<UpdateResult>;
+    isUpdating: boolean;
+    updateError: string | null;
+    editedConnections: EnvExtMinimal_2[] | null;
+    updatedExtension: EnvironmentExtensions | null;
+};
+
+/**
+ * Provides an imperative `updateMapExtensions` function that posts a single
+ * `EnvironmentMapExtension` update. Accepts JSON payloads and handles either JSON
+ * or XML responses from Boomi.
+ *
+ * @return {{
+ *   updateMapExtensions: (params: UseUpdateMapExtensionsUpdateParams) => Promise<EnvironmentMapExtension>,
+ *   isUpdating: boolean,
+ *   updateError: string | null,
+ *   updatedExtensions: EnvironmentMapExtension[]
+ * }}
+ *   Hook API exposing the updater function, loading/error state, and last updated extensions.
+ *
+ * @throws {Error}
+ *   If required inputs are missing or the update request fails.
+ */
+export declare const useUpdateMapExtensions: () => {
+    updateMapExtensions: (envMapExtension: EnvironmentMapExtension) => Promise<EnvironmentMapExtension>;
+    isUpdating: boolean;
+    updateError: string | null;
+    updatedExtensions: EnvironmentMapExtension[];
+};
+
+/**
+ * Provides an imperative `updateProcessSchedules` function that:
+ *  1) Resolves Atom IDs attached to an environment,
+ *  2) Retrieves all processes for an integration pack instance,
+ *  3) Constructs a `ProcessSchedules` payload (including a `Retry` policy),
+ *  4) Replaces schedules for every (processId × atomId) combination.
+ *
+ * @return {{
+ *   updateProcessSchedules: (params: UseUpdateProcessSchedulesParams) => Promise<void>;
+ *   isUpdating: boolean;
+ *   updateError: string | null;
+ *   updatedSchedules: ProcessSchedules[];
+ * }}
+ *   Hook API with the updater function, request state, and the list of updated schedule objects.
+ *
+ * @throws {Error}
+ *   If required context or parameters are missing, or if any update call fails.
+ */
+export declare const useUpdateProcessSchedules: () => {
+    updateProcessSchedules: (schedules: Schedule[], environmentId: string, integrationPackInstanceId: string) => Promise<void>;
+    isUpdating: boolean;
+    updateError: string | null;
+    updatedSchedules: ProcessSchedules[];
+};
+
+export { }