import { Phrases, Phrases as Phrases$1 } from "@prismatic-io/translations";

//#region \0rolldown/runtime.js
//#endregion
//#region src/types/conditionalLogic.d.ts
declare enum BooleanOperator {
  and = "and",
  or = "or"
}
declare enum TermOperator {
  equal = "equal",
  notEqual = "notEqual",
  in = "in",
  notIn = "notIn",
  startsWith = "startsWith",
  doesNotStartWith = "doesNotStartWith",
  endsWith = "endsWith",
  doesNotEndWith = "doesNotEndWith"
}
type TermExpression = [TermOperator, unknown, unknown?];
type BooleanExpression = [BooleanOperator.and | BooleanOperator.or, ...ConditionalExpression[]];
type ConditionalExpression = TermExpression | BooleanExpression;
//#endregion
//#region src/types/filters.d.ts
interface MarketplaceFilters {
  category?: string;
  filterQuery?: ConditionalExpression;
  includeActiveIntegrations?: boolean;
  label?: string;
  strictMatchFilterQuery?: boolean;
}
interface ComponentsFilters {
  category?: string;
  filterQuery?: ConditionalExpression;
  label?: string;
}
interface IntegrationsFilters {
  category?: string;
  label?: string;
}
type Filters = {
  components?: ComponentsFilters;
  integrations?: IntegrationsFilters;
  marketplace?: MarketplaceFilters;
};
//#endregion
//#region src/types/screenConfiguration.d.ts
type TriggerDetails = "default" | "default-open" | "hidden";
interface InstanceScreenConfiguration {
  hideBackToMarketplace?: boolean;
  hideTabs?: Array<"Test" | "Executions" | "Logs">;
  hidePauseButton?: boolean;
  hideDeactivation?: boolean;
}
interface ConfigureInstanceScreenConfiguration {
  configuration?: "allow-details" | "always-show-details" | "disallow-details";
}
interface MarketplaceConfiguration {
  configuration?: "allow-details" | "always-show-details" | "disallow-details";
  hideSearch?: boolean;
  hideActiveIntegrationsFilter?: boolean;
}
interface WorkflowsConfiguration {
  includeIntegrations?: boolean;
}
type CopilotChatVisibility = "open" | "hide";
interface CopilotConfiguration {
  /**
   * Controls the initial state of the workflow builder copilot chat panel when
   * the builder is presented.
   * - `hide` (default): the copilot button is shown, the panel is collapsed
   *   until the user opens it.
   * - `open`: the copilot panel is expanded on load.
   *
   * Only takes effect when the copilot is enabled for the organization and customer.
   *
   * @default "hide"
   */
  initialChatVisibility?: CopilotChatVisibility;
}
interface WorkflowBuilderConfiguration {
  copilot?: CopilotConfiguration;
}
interface InitializingConfiguration {
  /** The background color of the loading screen */
  background: string;
  /** The font color of the loading screen text and loading icon */
  color: string;
}
interface ConfigurationWizardConfiguration {
  mode?: "streamlined" | "traditional";
  /**
   * Defines how customer-activated connections will be configured in the configuration wizard.
   * `inline` is the legacy way where inputs are inline in the config page
   * `reusable` means the user can choose from their credentials for that customer-activated connection in a way that the connection can also be reused in other instances
   * @default "reusable"
   */
  connectionConfiguration?: "inline" | "reusable";
  hideSidebar?: boolean;
  isInModal?: boolean;
  triggerDetailsConfiguration?: TriggerDetails;
  /**
   * Disable logs on integrations deployed via marketplace
   * @default "never"
   */
  logsDisabled?: "always" | "never" | "optional";
  /**
   * Disable step results on integrations deployed via marketplace
   * @default "never"
   */
  stepResultsDisabled?: "always" | "never" | "optional";
}
interface DashboardScreenConfiguration {
  hideTabs?: Array<"Attachments" | "Components" | "Credentials" | "Executions" | "Instances" | "Integrations" | "Logs" | "Marketplace">;
}
interface DesignerConfiguration {
  hideInstances?: boolean;
  hideMarketplace?: boolean;
  hideRemoveIntegration?: boolean;
}
interface ScreenConfiguration {
  configurationWizard?: ConfigurationWizardConfiguration;
  configureInstance?: ConfigureInstanceScreenConfiguration;
  dashboard?: DashboardScreenConfiguration;
  designer?: DesignerConfiguration;
  initializing?: InitializingConfiguration;
  instance?: InstanceScreenConfiguration;
  marketplace?: MarketplaceConfiguration;
  workflowBuilder?: WorkflowBuilderConfiguration;
  workflows?: WorkflowsConfiguration;
  isInPopover?: boolean;
}
//#endregion
//#region src/types/theme.d.ts
type Theme = "DARK" | "LIGHT";
//#endregion
//#region src/types/translation.d.ts
interface Translation {
  debugMode?: boolean;
  phrases?: Phrases$1;
}
//#endregion
//#region src/types/options.d.ts
interface OptionsBase {
  autoFocusIframe?: boolean;
  filters?: Filters;
  screenConfiguration?: ScreenConfiguration;
  theme?: Theme;
  translation?: Translation;
}
interface SelectorOptions extends OptionsBase {
  selector: string;
  usePopover?: false;
}
interface PopoverOptions extends OptionsBase {
  usePopover: true;
}
type Options = PopoverOptions | SelectorOptions;
//#endregion
//#region src/lib/configureInstance.d.ts
type ConfigureInstancesBase = Options & {
  skipRedirectOnRemove: boolean;
};
type ConfigureInstanceWithIntegrationName = ConfigureInstancesBase & {
  integrationName: string;
};
type ConfigureInstanceWithIntegrationId = ConfigureInstancesBase & {
  integrationId: string;
};
type ConfigureInstanceWithInstanceId = ConfigureInstancesBase & {
  instanceId: string;
};
type ConfigureInstanceProps = ConfigureInstanceWithIntegrationName | ConfigureInstanceWithIntegrationId | ConfigureInstanceWithInstanceId;
/**
 * Opens the configuration wizard for an integration, allowing a customer user
 * to activate and configure an instance. You can identify the target by
 * `integrationName`, `integrationId`, or `instanceId`.
 *
 * - Use `integrationName` to let a customer activate a new instance of a
 *   marketplace integration by its display name.
 * - Use `integrationId` to target a specific integration version.
 * - Use `instanceId` to reconfigure an already-deployed instance.
 *
 * @param props - Configuration options. Exactly one of `integrationName`, `integrationId`, or `instanceId` is required.
 * @param props.skipRedirectOnRemove - When `true`, prevents redirecting to the marketplace after the instance is removed.
 *
 * @example
 * // Configure by integration name (most common)
 * prismatic.configureInstance({
 *   integrationName: "Salesforce",
 *   usePopover: true,
 *   skipRedirectOnRemove: false,
 * });
 *
 * @example
 * // Reconfigure an existing instance inline
 * prismatic.configureInstance({
 *   instanceId: "SW5zdGFuY2U6OGE2YjZi...",
 *   selector: "#config-container",
 *   skipRedirectOnRemove: true,
 * });
 *
 * @see {@link https://prismatic.io/docs/embed/marketplace/ | Embedding the Marketplace}
 */
declare const configureInstance: ({
  ...props
}: ConfigureInstanceProps) => void;
/** Type guard that checks whether the props identify a target instance by `instanceId`. */
declare const isConfigureInstanceWithInstanceId: (props: ConfigureInstanceProps) => props is ConfigureInstanceWithInstanceId;
/** Type guard that checks whether the props identify a target integration by `integrationId`. */
declare const isConfigureInstanceWithIntegrationId: (props: ConfigureInstanceProps) => props is ConfigureInstanceWithIntegrationId;
/** Type guard that checks whether the props identify a target integration by `integrationName`. */
declare const isConfigureInstanceWithIntegrationName: (props: ConfigureInstanceProps) => props is ConfigureInstanceWithIntegrationName;
//#endregion
//#region src/lib/authenticate.d.ts
interface AuthenticateProps {
  prismaticUrl?: string;
  token: string;
}
/**
 * Authenticates an embedded user with a signed JWT token. This must be called after
 * {@link init} and before rendering any embedded screens. The token should be a
 * short-lived RS256-signed JWT generated on your backend.
 *
 * After the initial call, call `authenticate` again before the token expires
 * (typically ~60 seconds before expiry) to keep the session alive. All active
 * iframes update automatically when a new token is provided.
 *
 * @param options - Authentication options.
 * @param options.token - A signed JWT containing `sub`, `organization`, `customer`, `iat`, and `exp` claims.
 * @param options.prismaticUrl - Override the Prismatic app URL for this authentication request.
 * @throws {Error} If the token is missing or the server rejects it.
 *
 * @example
 * // Authenticate with a token fetched from your backend
 * const response = await fetch("/api/prismatic-token");
 * const { token } = await response.json();
 * await prismatic.authenticate({ token });
 *
 * @example
 * // Re-authenticate before token expiry
 * const TOKEN_LIFETIME_MS = 10 * 60 * 1000; // 10 minutes
 * const refreshToken = async () => {
 *   const { token } = await fetchToken();
 *   await prismatic.authenticate({ token });
 *   setTimeout(refreshToken, TOKEN_LIFETIME_MS - 60_000);
 * };
 * refreshToken();
 *
 * @see {@link https://prismatic.io/docs/embed/authenticate-users/ | Authenticating Embedded Users}
 */
declare const authenticate: (options: AuthenticateProps) => Promise<void>;
//#endregion
//#region src/lib/graphqlRequest.d.ts
interface GraphqlRequestProps<TVariables = Record<string, unknown>> {
  query: string;
  variables?: TVariables;
}
interface GraphqlRequestResponse<TData = unknown> {
  data: TData;
  errors?: {
    message: string;
  }[];
}
/**
 * Executes an authenticated GraphQL request against the Prismatic API.
 * The request is automatically authorized using the JWT from the most
 * recent {@link authenticate} call.
 *
 * This is useful for building custom UIs — for example, querying
 * `marketplaceIntegrations` to render a custom marketplace.
 *
 * @param props - The GraphQL query and optional variables.
 * @param props.query - The GraphQL query string.
 * @param props.variables - Optional variables to pass to the query.
 * @returns The parsed JSON response from the Prismatic API.
 *
 * @example
 * // Query available marketplace integrations
 * const result = await prismatic.graphqlRequest({
 *   query: `{
 *     marketplaceIntegrations(
 *       filters: { category: "ERP" }
 *     ) {
 *       nodes {
 *         id
 *         name
 *         description
 *         category
 *       }
 *     }
 *   }`,
 * });
 * console.log(result.data.marketplaceIntegrations.nodes);
 *
 * @example
 * // Query with variables
 * const result = await prismatic.graphqlRequest({
 *   query: `query ($integrationId: ID!) {
 *     integration(id: $integrationId) {
 *       name
 *       instances { nodes { id name } }
 *     }
 *   }`,
 *   variables: { integrationId: "SW50ZWdyYXRpb246..." },
 * });
 *
 * @see {@link https://prismatic.io/docs/embed/embedded-api-requests/ | Embedded API Requests}
 */
declare const graphqlRequest: <TData = unknown, TVariables = Record<string, unknown>>({
  query,
  variables
}: GraphqlRequestProps<TVariables>) => Promise<GraphqlRequestResponse<TData>>;
//#endregion
//#region src/lib/createWorkflow.d.ts
interface WorkflowContexts {}
interface CreateWorkflowArgs<TContextData = unknown> {
  name: string;
  contextData: TContextData;
  externalId?: string;
}
interface CreateWorkflowData {
  importWorkflow: {
    workflow: {
      id: string;
    };
    errors: {
      field: string;
      messages: string[];
    }[];
  };
}
declare function createWorkflow<TKey extends keyof WorkflowContexts | (string & {})>(contextStableKey: TKey, args: CreateWorkflowArgs<TKey extends keyof WorkflowContexts ? WorkflowContexts[TKey] : Record<string, unknown>>): Promise<GraphqlRequestResponse<CreateWorkflowData>>;
//#endregion
//#region src/lib/dispose.d.ts
/**
 * Removes every DOM node, listener, and piece of in-memory state created by
 * {@link init}. Use this when the embedded experience is being unmounted
 * (SPA route change, logout, conditional render) or to fully reset between
 * tests.
 *
 * After `dispose`, the next call to {@link init} starts from a clean slate:
 * the popover DOM, preload iframe, and stylesheet are recreated, and a fresh
 * Escape-key listener is attached.
 *
 * Calling `dispose` before `init`, or twice in a row, is a safe no-op.
 *
 * @example
 * // Fully reset the SDK
 * prismatic.dispose();
 *
 * @example
 * // Re-initialize with new options
 * prismatic.dispose();
 * prismatic.init({ theme: "DARK" });
 */
declare const dispose: () => void;
//#endregion
//#region src/lib/editInstanceConfiguration.d.ts
type EditInstanceConfigurationProps = {
  instanceId: string;
  selector: string;
  theme?: Theme;
  screenConfiguration?: {
    configurationWizard?: Omit<ConfigurationWizardConfiguration, "isInModal">;
  };
  onCancel?: () => void;
  onSuccess?: () => void;
  onDelete?: () => void;
};
/**
 * Renders the configuration wizard for an existing instance directly into a
 * DOM element (no popover). This is useful when you want to embed instance
 * configuration inline within your own application's UI.
 *
 * Unlike {@link configureInstance}, this function opens the config wizard directly,
 * supports lifecycle callbacks (`onSuccess`, `onCancel`, `onDelete`), and returns a
 * cleanup function to remove event listeners.
 *
 * @param props - Configuration and display options.
 * @param props.instanceId - The ID of the instance to configure.
 * @param props.selector - A CSS selector for the DOM element to render into.
 * @param props.theme - Optional theme override (`"LIGHT"` or `"DARK"`).
 * @param props.screenConfiguration - Optional screen configuration for the configuration wizard.
 * @param props.onSuccess - Called when the instance is successfully deployed.
 * @param props.onCancel - Called when the user cancels the configuration.
 * @param props.onDelete - Called when the user deletes the instance.
 * @returns A cleanup function that removes the event listeners, or `undefined` if no callbacks were provided.
 *
 * @example
 * // Edit an instance's configuration with lifecycle callbacks
 * const cleanup = prismatic.editInstanceConfiguration({
 *   instanceId: "SW5zdGFuY2U6OGE2YjZi...",
 *   selector: "#config-panel",
 *   onSuccess: () => console.log("Configuration saved!"),
 *   onCancel: () => console.log("Configuration canceled."),
 *   onDelete: () => console.log("Instance deleted."),
 * });
 *
 * // Call cleanup() when you're done to remove event listeners
 * cleanup?.();
 *
 * @see {@link https://prismatic.io/docs/embed/marketplace/ | Embedding the Marketplace}
 */
declare const editInstanceConfiguration: ({
  instanceId,
  selector,
  theme,
  screenConfiguration,
  onCancel,
  onSuccess,
  onDelete
}: EditInstanceConfigurationProps) => (() => void) | undefined;
//#endregion
//#region src/types/fontConfiguration.d.ts
interface GoogleFontFamilies {
  families: Array<string>;
}
interface FontConfiguration {
  google: GoogleFontFamilies;
}
//#endregion
//#region src/state.d.ts
interface State {
  filters: Filters;
  initComplete: boolean;
  jwt: string;
  embeddedDesignerEnabled: boolean;
  prismaticUrl: string;
  screenConfiguration?: ScreenConfiguration;
  skipPreload?: boolean;
  theme?: Theme;
  fontConfiguration?: FontConfiguration;
  translation?: Translation;
}
//#endregion
//#region src/lib/init.d.ts
interface InitProps extends Pick<State, "screenConfiguration" | "theme" | "fontConfiguration" | "translation">, Partial<Pick<State, "filters" | "prismaticUrl" | "skipPreload">> {}
declare const EMBEDDED_DEFAULTS: {
  filters: {
    marketplace: {
      includeActiveIntegrations: boolean;
    };
    integrations: {};
    components: {};
  };
  screenConfiguration: {
    configurationWizard: {};
    instance: {};
    marketplace: {};
    initializing: {};
  };
  skipPreload: boolean;
  theme: string;
  fontConfiguration: undefined;
  translation: {};
};
/**
 * Initializes the Prismatic embedded SDK. This must be called once before any other
 * SDK methods. It sets up the popover overlay, preloads Prismatic assets into the
 * browser cache, and applies global configuration (theme, filters, translations, etc.).
 *
 * Calling `init` again resets the in-memory SDK state with the new options,
 * but the popover DOM and document-level listeners are reused. Call
 * {@link dispose} first if you need a fully fresh teardown.
 *
 * @param optionsBase - Optional global configuration for the embedded SDK.
 * @param optionsBase.theme - The color theme to use (`"LIGHT"` or `"DARK"`). Defaults to `"LIGHT"`.
 * @param optionsBase.fontConfiguration - Google Font families to load for the embedded UI.
 * @param optionsBase.screenConfiguration - Per-screen display options (marketplace, config wizard, dashboard, etc.).
 * @param optionsBase.filters - Default filters for the marketplace, integrations, and components screens.
 * @param optionsBase.translation - Custom phrase overrides and debug mode for i18n.
 * @param optionsBase.prismaticUrl - Override the Prismatic app URL. Defaults to `"https://app.prismatic.io"`.
 * @param optionsBase.skipPreload - Skip preloading Prismatic assets. Defaults to `false`.
 *
 * @example
 * // Basic initialization with defaults
 * prismatic.init();
 *
 * @example
 * // Initialize with dark theme and custom screen configuration
 * prismatic.init({
 *   theme: "DARK",
 *   screenConfiguration: {
 *     marketplace: { configuration: "allow-details" },
 *     configurationWizard: { mode: "streamlined" },
 *   },
 *   filters: {
 *     marketplace: { category: "ERP" },
 *   },
 * });
 *
 * @see {@link https://prismatic.io/docs/embed/get-started/install-embedded-sdk/ | Installing the Embedded SDK}
 * @see {@link https://prismatic.io/docs/embed/theming/ | Theming}
 * @see {@link https://prismatic.io/docs/embed/translations-and-internationalization/ | Translations & i18n}
 */
declare const init: (optionsBase?: InitProps) => void;
//#endregion
//#region src/lib/queryWorkflows.d.ts
interface Workflow {
  id: string;
  name: string;
  versionNumber: number;
  description: string;
  externalId: string | null;
  updatedAt: string;
  lastExecutedAt: string | null;
  createdAt: string;
  category: string | null;
  labels: string[];
  customer: {
    id: string;
    name: string;
  };
  instance: {
    enabled: boolean;
  } | null;
  deployedVersion: {
    id: string;
  } | null;
}
interface QueryWorkflowsData {
  workflows: {
    nodes: Workflow[];
    pageInfo: {
      hasNextPage: boolean;
      endCursor: string | null;
    };
    totalCount: number;
  };
}
interface QueryWorkflowsProps extends Record<string, unknown> {
  searchTerm?: string;
  descriptionSearch?: string;
  categorySearch?: string;
  labelSearch?: string;
  contextStableKey?: string;
  externalId?: string;
  sortBy?: string[];
  first?: number;
  cursor?: string;
}
declare const queryWorkflows: (variables?: QueryWorkflowsProps) => Promise<GraphqlRequestResponse<QueryWorkflowsData>>;
//#endregion
//#region src/types/configVars.d.ts
type ScheduleTypeEnum = "none" | "custom" | "minute" | "hour" | "day" | "week";
type DefaultConfigVarDataTypeEnum = "boolean" | "code" | "connection" | "credential" | "date" | "picklist" | "schedule" | "string" | "timestamp";
type CollectionTypeEnum = "valuelist" | "keyvaluelist";
type CodeLanguageEnum = "json" | "xml" | "html";
interface BaseConfigVar {
  id: string;
  codeLanguage: CodeLanguageEnum | null;
  collectionType: CollectionTypeEnum | null;
  dataType: DefaultConfigVarDataTypeEnum | null;
  pickList: string[] | null;
  scheduleType: ScheduleTypeEnum | null;
  timeZone: string | null;
}
interface StringConfigVar extends BaseConfigVar {
  collectionType: null;
  value: string;
}
interface ValueListConfigVar extends BaseConfigVar {
  collectionType: "valuelist";
  value: string[];
}
interface KeyValueListConfigVar extends BaseConfigVar {
  collectionType: "keyvaluelist";
  value: Array<{
    key: string;
    value: string;
  }>;
}
type DefaultConfigVar = KeyValueListConfigVar | StringConfigVar | ValueListConfigVar;
declare enum InstanceConfigVariableStatus {
  ACTIVE = "ACTIVE",
  ERROR = "ERROR",
  PENDING = "PENDING"
}
interface ConnectionConfigVar extends BaseConfigVar {
  inputs: Record<string, {
    value: string;
  }>;
  status: InstanceConfigVariableStatus | null;
}
type ConfigVar = DefaultConfigVar | ConnectionConfigVar;
type ConfigVars = Record<string, DefaultConfigVarInput | ConnectionConfigVarInput>;
interface BaseConfigVarInput {
  value: string;
}
interface ValueListConfigVarInput {
  value: string[];
}
interface KeyValueListConfigVarInput {
  value: Array<{
    key: string;
    value: string;
  }>;
}
interface ScheduleConfigVarInput {
  scheduleType: ScheduleTypeEnum;
  timeZone: string | undefined;
  value: string;
}
interface ConnectionConfigVarInput {
  onPremiseResourceId?: string;
  inputs: Record<string, {
    value: string;
  }>;
}
type DefaultConfigVarInput = BaseConfigVarInput | KeyValueListConfigVarInput | ScheduleConfigVarInput | ValueListConfigVarInput;
//#endregion
//#region src/lib/setConfigVars.d.ts
interface SetConfigVarsPropsBase {
  configVars: ConfigVars;
}
interface SelectorSetConfigVarProps extends SetConfigVarsPropsBase {
  selector?: string;
}
interface IFrameSetConfigVarProps extends SetConfigVarsPropsBase {
  iframe: Element;
}
type SetConfigVarsProps = IFrameSetConfigVarProps | SelectorSetConfigVarProps;
/**
 * Programmatically sets configuration variable values on an active configuration
 * wizard. This is useful for pre-filling config values based on context from
 * your application (e.g., setting an API endpoint or customer-specific settings).
 *
 * You can target the iframe either by passing the iframe element directly
 * (obtained from {@link getMessageIframe}) or by passing a `selector` string.
 *
 * @param props - The config vars and target iframe.
 * @param props.configVars - A map of config variable keys to their values.
 * @param props.iframe - The iframe element to send config vars to (use with `getMessageIframe`).
 * @param props.selector - A CSS selector for the iframe to send config vars to.
 *
 * @example
 * // Set config vars using an iframe reference from a message event
 * window.addEventListener("message", (event) => {
 *   if (event.data.event === "INSTANCE_CONFIGURATION_LOADED") {
 *     const iframe = prismatic.getMessageIframe(event);
 *     prismatic.setConfigVars({
 *       iframe,
 *       configVars: {
 *         "API Endpoint": { value: "https://api.example.com" },
 *         "Sync Frequency": { value: "daily" },
 *       },
 *     });
 *   }
 * });
 *
 * @example
 * // Set config vars using a CSS selector
 * prismatic.setConfigVars({
 *   selector: "#config-container",
 *   configVars: {
 *     "API Key": { value: "my-api-key" },
 *   },
 * });
 *
 * @see {@link https://prismatic.io/docs/embed/marketplace/ | Embedding the Marketplace}
 */
declare const setConfigVars: ({
  configVars,
  ...options
}: SetConfigVarsProps) => void;
//#endregion
//#region src/lib/showComponent.d.ts
type ShowComponentProps = Options & {
  componentId: string;
};
/**
 * Renders the detail page for a specific component, showing its available
 * actions, triggers, and data sources.
 *
 * @param props - Display options including the component to show.
 * @param props.componentId - The ID of the component to display.
 *
 * @example
 * // Show a specific component in a popover
 * prismatic.showComponent({
 *   componentId: "Q29tcG9uZW50OmFiY2Rl...",
 *   usePopover: true,
 * });
 *
 * @example
 * // Show a specific component inline
 * prismatic.showComponent({
 *   componentId: "Q29tcG9uZW50OmFiY2Rl...",
 *   selector: "#component-detail",
 * });
 *
 * @see {@link https://prismatic.io/docs/embed/additional-screens/show-components/ | Embedding Components}
 */
declare const showComponent: ({
  componentId,
  ...options
}: ShowComponentProps) => void;
//#endregion
//#region src/lib/showComponents.d.ts
type ShowComponentsProps = Options & {};
/**
 * Renders the component browser, where your customer's users can browse
 * available components and their actions.
 *
 * Components can be filtered by category or label via the `filters` option.
 *
 * @param options - Display options for the components screen.
 *
 * @example
 * // Show components in a popover
 * prismatic.showComponents({ usePopover: true });
 *
 * @example
 * // Show components inline, filtered by category
 * prismatic.showComponents({
 *   selector: "#components-container",
 *   filters: { components: { category: "Data Platforms" } },
 * });
 *
 * @see {@link https://prismatic.io/docs/embed/additional-screens/show-components/ | Embedding Components}
 */
declare const showComponents: (options: ShowComponentsProps) => void;
//#endregion
//#region src/lib/showConnections.d.ts
type ShowConnectionsProps = Options & {};
/**
 * Renders the connections management screen, where your customer's users can
 * view and manage their reusable credential connections.
 *
 * @param options - Display options for the connections screen.
 *
 * @example
 * // Show connections in a popover
 * prismatic.showConnections({ usePopover: true });
 *
 * @example
 * // Show connections inline
 * prismatic.showConnections({ selector: "#connections-container" });
 *
 * @see {@link https://prismatic.io/docs/embed/additional-screens/show-connections/ | Embedding Connections}
 */
declare const showConnections: (options: ShowConnectionsProps) => void;
//#endregion
//#region src/lib/showDashboard.d.ts
type ShowDashboardProps = Options & {};
/**
 * Renders the customer dashboard, which provides an overview of the customer's
 * deployed instances, logs, connections, and other resources.
 *
 * Specific tabs can be hidden via `screenConfiguration.dashboard.hideTabs`.
 *
 * @param options - Display options for the dashboard.
 *
 * @example
 * // Show dashboard in a popover
 * prismatic.showDashboard({ usePopover: true });
 *
 * @example
 * // Show dashboard inline, hiding certain tabs
 * prismatic.showDashboard({
 *   selector: "#dashboard-container",
 *   screenConfiguration: {
 *     dashboard: { hideTabs: ["Logs", "Credentials"] },
 *   },
 * });
 *
 * @see {@link https://prismatic.io/docs/embed/additional-screens/show-dashboard/ | Embedding the Dashboard}
 */
declare const showDashboard: (options?: ShowDashboardProps) => void;
//#endregion
//#region src/lib/showDesigner.d.ts
type ShowDesignerProps = Options & {
  integrationId: string;
};
/**
 * Renders the embedded integration designer for a specific integration, allowing
 * your customer's users to build and modify integration workflows.
 *
 * Requires the embedded designer feature to be enabled for the customer.
 *
 * @param props - Display options including the integration to open.
 * @param props.integrationId - The ID of the integration to open in the designer.
 *
 * @example
 * // Open the designer for a specific integration in a popover
 * prismatic.showDesigner({
 *   integrationId: "SW50ZWdyYXRpb246YzNmOGU...",
 *   usePopover: true,
 * });
 *
 * @example
 * // Open the designer inline
 * prismatic.showDesigner({
 *   integrationId: "SW50ZWdyYXRpb246YzNmOGU...",
 *   selector: "#designer-container",
 * });
 *
 * @see {@link https://prismatic.io/docs/embed/workflow-builder/workflow-builder/ | Embedding the Workflow Builder}
 */
declare const showDesigner: ({
  integrationId,
  ...options
}: ShowDesignerProps) => void;
//#endregion
//#region src/lib/showIntegrations.d.ts
type ShowIntegrationsProps = Options & {};
/**
 * Renders the integrations list screen, where your customer's users can view
 * and manage integrations they have built with the embedded designer.
 *
 * Requires the embedded designer feature to be enabled for the customer.
 *
 * @param options - Display options for the integrations list.
 *
 * @example
 * // Show integrations list in a popover
 * prismatic.showIntegrations({ usePopover: true });
 *
 * @example
 * // Show integrations list inline
 * prismatic.showIntegrations({ selector: "#integrations-container" });
 */
declare const showIntegrations: (options: ShowIntegrationsProps) => void;
//#endregion
//#region src/lib/showLogs.d.ts
type ShowLogsProps = Options & {};
/**
 * Renders the logs screen, where your customer's users can view execution
 * logs for their deployed instances.
 *
 * @param options - Display options for the logs screen.
 *
 * @example
 * // Show logs in a popover
 * prismatic.showLogs({ usePopover: true });
 *
 * @example
 * // Show logs inline
 * prismatic.showLogs({ selector: "#logs-container" });
 *
 * @see {@link https://prismatic.io/docs/embed/additional-screens/show-logs/ | Embedding Logs}
 */
declare const showLogs: (options: ShowLogsProps) => void;
//#endregion
//#region src/lib/showMarketplace.d.ts
type ShowMarketplaceProps = Options & {};
/**
 * Renders Prismatic's integration marketplace, where your customers can browse,
 * activate, and configure available integrations.
 *
 * The marketplace can be displayed in a popover (default) or rendered inline
 * within a specific DOM element using the `selector` option.
 *
 * @param options - Display options for the marketplace.
 *
 * @example
 * // Show marketplace in a popover
 * prismatic.showMarketplace({ usePopover: true });
 *
 * @example
 * // Show marketplace inline in a specific DOM element
 * prismatic.showMarketplace({
 *   selector: "#marketplace-container",
 *   theme: "DARK",
 *   filters: { marketplace: { category: "ERP" } },
 * });
 *
 * @see {@link https://prismatic.io/docs/embed/marketplace/ | Embedding the Marketplace}
 */
declare const showMarketplace: (options?: ShowMarketplaceProps) => void;
//#endregion
//#region src/lib/showWorkflow.d.ts
type ShowWorkflowBuilderProps = Options & {
  workflowId: string;
  onDelete?: () => void;
};
/**
 * Renders the workflow builder for a specific workflow, allowing your customer's
 * users to view and modify the workflow's steps, triggers, and configuration.
 *
 * @param props - Display options including the workflow to open.
 * @param props.workflowId - The ID of the workflow to open in the builder.
 * @param props.onDelete - Called when the workflow is deleted.
 * @returns A cleanup function that removes the event listeners, or `undefined` if onDelete was not provided.
 *
 * @example
 * // Open a specific workflow in a popover
 * const cleanup = prismatic.showWorkflow({
 *   workflowId: "V29ya2Zsb3c6YTFiMmMz...",
 *   onDelete: () => console.log(`Workflow deleted.`),
 *   usePopover: true,
 * });
 * // Call cleanup() when you're done to remove event listeners
 * cleanup?.();
 *
 * @example
 * // Open a specific workflow inline
 * prismatic.showWorkflow({
 *   workflowId: "V29ya2Zsb3c6YTFiMmMz...",
 *   selector: "#workflow-container",
 * });
 *
 * @example
 * // Open the workflow builder with the copilot panel already expanded
 * prismatic.showWorkflow({
 *   workflowId: "V29ya2Zsb3c6YTFiMmMz...",
 *   selector: "#workflow-container",
 *   screenConfiguration: {
 *     workflowBuilder: { copilot: { initialChatVisibility: "open" } },
 *   },
 * });
 *
 * @see {@link https://prismatic.io/docs/embed/workflow-builder/workflow-builder/ | Embedding the Workflow Builder}
 */
declare const showWorkflow: ({
  workflowId,
  onDelete,
  ...options
}: ShowWorkflowBuilderProps) => (() => void) | undefined;
//#endregion
//#region src/lib/showWorkflows.d.ts
type ShowWorkflowsProps = Options & {};
/**
 * Renders the workflows list screen, where your customer's users can browse
 * and manage their workflows.
 *
 * Set `screenConfiguration.workflows.includeIntegrations` to also display
 * integrations alongside workflows.
 *
 * @param options - Display options for the workflows list.
 *
 * @example
 * // Show workflows list in a popover
 * prismatic.showWorkflows({ usePopover: true });
 *
 * @example
 * // Show workflows inline, including integrations
 * prismatic.showWorkflows({
 *   selector: "#workflows-container",
 *   screenConfiguration: {
 *     workflows: { includeIntegrations: true },
 *   },
 * });
 *
 * @see {@link https://prismatic.io/docs/embed/workflow-builder/workflow-builder/ | Embedding the Workflow Builder}
 */
declare const showWorkflows: (options: ShowWorkflowsProps) => void;
//#endregion
//#region src/types/postMessage.d.ts
interface WorkflowConfigurationData {
  customerId: string;
  customerName: string;
  instanceId: string;
  instanceName: string;
  workflowVersionId: string | null;
}
interface InstanceConfigurationData {
  customerId: string;
  customerName: string;
  instanceId: string;
  instanceName: string;
  integrationName: string;
  integrationVersionNumber: number;
  readOnly: boolean;
}
interface InstanceConfigurationLoadedData extends InstanceConfigurationData {
  configVars: Record<string, ConfigVar>;
}
interface InstanceConfigurationPageLoadedData extends InstanceConfigurationLoadedData {
  pageName: string;
  pageContent: Record<string, unknown>;
}
interface UserConfigurationData extends InstanceConfigurationData {
  userConfigId: string | undefined;
  userEmail: string;
  userId: string;
  userLevelConfigVariables: Record<string, ConfigVar>;
  userName: string;
}
interface UserConfigurationPageData extends UserConfigurationData {
  pageName: string;
  pageContent: Record<string, unknown>;
}
declare enum PrismaticMessageEvent {
  INSTANCE_CONFIGURATION_CANCELED = "INSTANCE_CONFIGURATION_CANCELED",
  INSTANCE_CONFIGURATION_CLOSED = "INSTANCE_CONFIGURATION_CLOSED",
  INSTANCE_CONFIGURATION_LOADED = "INSTANCE_CONFIGURATION_LOADED",
  INSTANCE_CONFIGURATION_PAGE_LOADED = "INSTANCE_CONFIGURATION_PAGE_LOADED",
  INSTANCE_CONFIGURATION_OPENED = "INSTANCE_CONFIGURATION_OPENED",
  INSTANCE_CREATED = "INSTANCE_CREATED",
  INSTANCE_DELETED = "INSTANCE_DELETED",
  INSTANCE_DEPLOYED = "INSTANCE_DEPLOYED",
  MARKETPLACE_CLOSED = "MARKETPLACE_CLOSED",
  POPOVER_CLOSE_REQUESTED = "POPOVER_CLOSE_REQUESTED",
  POPOVER_CLOSED = "POPOVER_CLOSED",
  SET_CONFIG_VAR = "SET_CONFIG_VAR",
  SET_FILTERS = "SET_FILTERS",
  SET_SCREEN_CONFIGURATION = "SET_SCREEN_CONFIGURATION",
  SET_TOKEN = "SET_TOKEN",
  SET_TRANSLATION = "SET_TRANSLATION",
  SET_VERSION = "SET_VERSION",
  USER_CONFIGURATION_CLOSED = "USER_CONFIGURATION_CLOSED",
  USER_CONFIGURATION_DELETED = "USER_CONFIGURATION_DELETED",
  USER_CONFIGURATION_DEPLOYED = "USER_CONFIGURATION_DEPLOYED",
  USER_CONFIGURATION_LOADED = "USER_CONFIGURATION_LOADED",
  USER_CONFIGURATION_PAGE_LOADED = "USER_CONFIGURATION_PAGE_LOADED",
  USER_CONFIGURATION_OPENED = "USER_CONFIGURATION_OPENED",
  WORKFLOW_ENABLED = "WORKFLOW_ENABLED",
  WORKFLOW_DELETED = "WORKFLOW_DELETED",
  WORKFLOW_DISABLED = "WORKFLOW_DISABLED"
}
type MessageData = {
  data: InstanceConfigurationData;
  event: PrismaticMessageEvent.INSTANCE_CONFIGURATION_CANCELED;
} | {
  data: InstanceConfigurationData;
  event: PrismaticMessageEvent.INSTANCE_CONFIGURATION_OPENED;
} | {
  data: InstanceConfigurationLoadedData;
  event: PrismaticMessageEvent.INSTANCE_CONFIGURATION_LOADED;
} | {
  data: InstanceConfigurationPageLoadedData;
  event: PrismaticMessageEvent.INSTANCE_CONFIGURATION_PAGE_LOADED;
} | {
  data: InstanceConfigurationData;
  event: PrismaticMessageEvent.INSTANCE_CONFIGURATION_CLOSED;
} | {
  data: InstanceConfigurationData;
  event: PrismaticMessageEvent.INSTANCE_CREATED;
} | {
  data: InstanceConfigurationData;
  event: PrismaticMessageEvent.INSTANCE_DELETED;
} | {
  data: InstanceConfigurationData;
  event: PrismaticMessageEvent.INSTANCE_DEPLOYED;
} | {
  data: Record<string, never>;
  event: PrismaticMessageEvent.POPOVER_CLOSE_REQUESTED;
} | {
  data: UserConfigurationData;
  event: PrismaticMessageEvent.USER_CONFIGURATION_DELETED;
} | {
  data: UserConfigurationData;
  event: PrismaticMessageEvent.USER_CONFIGURATION_DEPLOYED;
} | {
  data: UserConfigurationData;
  event: PrismaticMessageEvent.USER_CONFIGURATION_CLOSED;
} | {
  data: UserConfigurationData;
  event: PrismaticMessageEvent.USER_CONFIGURATION_LOADED;
} | {
  data: UserConfigurationPageData;
  event: PrismaticMessageEvent.USER_CONFIGURATION_PAGE_LOADED;
} | {
  data: UserConfigurationData;
  event: PrismaticMessageEvent.USER_CONFIGURATION_OPENED;
} | {
  data: WorkflowConfigurationData;
  event: PrismaticMessageEvent.WORKFLOW_ENABLED;
} | {
  data: WorkflowConfigurationData;
  event: PrismaticMessageEvent.WORKFLOW_DELETED;
} | {
  data: WorkflowConfigurationData;
  event: PrismaticMessageEvent.WORKFLOW_DISABLED;
};
//#endregion
//#region src/utils/popover.d.ts
/**
 * Programmatically closes the currently open Prismatic popover. This notifies
 * the embedded iframe that the marketplace was closed and dispatches a
 * `POPOVER_CLOSED` event on the window.
 *
 * The popover also closes automatically when the user clicks the close button,
 * clicks the overlay backdrop, or presses the Escape key.
 *
 * @example
 * // Close the popover from your own UI
 * document.getElementById("my-close-btn")
 *   .addEventListener("click", () => prismatic.closePopover());
 *
 * @example
 * // Listen for the popover closed event
 * window.addEventListener("message", (event) => {
 *   if (event.data.event === "POPOVER_CLOSED") {
 *     console.log("Popover was closed");
 *   }
 * });
 *
 * @see {@link https://prismatic.io/docs/embed/marketplace/ | Embedding the Marketplace}
 */
declare const closePopover: () => void;
//#endregion
//#region src/utils/postMessage.d.ts
/**
 * Returns the iframe element that sent a given `MessageEvent`. This is typically
 * used inside a `window.addEventListener("message", ...)` handler to identify
 * which Prismatic iframe dispatched an event, so you can pass it to
 * {@link setConfigVars} or perform other targeted operations.
 *
 * @param event - The `MessageEvent` received from `window.addEventListener("message", ...)`.
 * @returns The matching `HTMLIFrameElement`, or `undefined` if no iframe matches.
 *
 * @example
 * window.addEventListener("message", (event) => {
 *   if (event.data.event === "INSTANCE_CONFIGURATION_LOADED") {
 *     const iframe = prismatic.getMessageIframe(event);
 *     if (iframe) {
 *       prismatic.setConfigVars({
 *         iframe,
 *         configVars: { "My Config Var": { value: "preset-value" } },
 *       });
 *     }
 *   }
 * });
 *
 * @see {@link https://prismatic.io/docs/embed/marketplace/ | Embedding the Marketplace}
 */
declare const getMessageIframe: (event: MessageEvent) => HTMLIFrameElement | undefined;
declare namespace exports_d_exports {
  export { AuthenticateProps, BooleanOperator, ComponentsFilters, ConditionalExpression, ConfigVar, ConfigVars, ConfigurationWizardConfiguration, ConfigureInstanceProps, ConfigureInstanceScreenConfiguration, ConfigureInstanceWithInstanceId, ConfigureInstanceWithIntegrationId, ConfigureInstanceWithIntegrationName, ConnectionConfigVar, ConnectionConfigVarInput, CopilotChatVisibility, CopilotConfiguration, DashboardScreenConfiguration, DefaultConfigVar, DefaultConfigVarInput, EMBEDDED_DEFAULTS, EditInstanceConfigurationProps, Filters, FontConfiguration, GoogleFontFamilies, GraphqlRequestProps, InitProps, InitializingConfiguration, InstanceConfigurationData, InstanceConfigurationLoadedData, InstanceConfigurationPageLoadedData, InstanceScreenConfiguration, IntegrationsFilters, MarketplaceConfiguration, MarketplaceFilters, MessageData, Options, Phrases, PopoverOptions, PrismaticMessageEvent, ScreenConfiguration, SelectorOptions, SetConfigVarsProps, ShowComponentProps, ShowComponentsProps, ShowDashboardProps, ShowDesignerProps, ShowIntegrationsProps, ShowLogsProps, ShowMarketplaceProps, TermOperator, Theme, Translation, TriggerDetails, UserConfigurationData, UserConfigurationPageData, WorkflowBuilderConfiguration, WorkflowConfigurationData, authenticate, closePopover, configureInstance, createWorkflow, dispose, editInstanceConfiguration, getMessageIframe, graphqlRequest, init, isConfigureInstanceWithInstanceId, isConfigureInstanceWithIntegrationId, isConfigureInstanceWithIntegrationName, queryWorkflows, setConfigVars, showComponent, showComponents, showConnections, showDashboard, showDesigner, showIntegrations, showLogs, showMarketplace, showWorkflow, showWorkflows };
}
//#endregion
export { type AuthenticateProps, BooleanOperator, type ComponentsFilters, type ConditionalExpression, type ConfigVar, type ConfigVars, type ConfigurationWizardConfiguration, type ConfigureInstanceProps, type ConfigureInstanceScreenConfiguration, type ConfigureInstanceWithInstanceId, type ConfigureInstanceWithIntegrationId, type ConfigureInstanceWithIntegrationName, type ConnectionConfigVar, type ConnectionConfigVarInput, type CopilotChatVisibility, type CopilotConfiguration, type DashboardScreenConfiguration, type DefaultConfigVar, type DefaultConfigVarInput, EMBEDDED_DEFAULTS, type EditInstanceConfigurationProps, type Filters, type FontConfiguration, type GoogleFontFamilies, type GraphqlRequestProps, type InitProps, type InitializingConfiguration, type InstanceConfigurationData, type InstanceConfigurationLoadedData, type InstanceConfigurationPageLoadedData, type InstanceScreenConfiguration, type IntegrationsFilters, type MarketplaceConfiguration, type MarketplaceFilters, type MessageData, type Options, type Phrases, type PopoverOptions, PrismaticMessageEvent, type ScreenConfiguration, type SelectorOptions, type SetConfigVarsProps, type ShowComponentProps, type ShowComponentsProps, type ShowDashboardProps, type ShowDesignerProps, type ShowIntegrationsProps, type ShowLogsProps, type ShowMarketplaceProps, TermOperator, type Theme, type Translation, type TriggerDetails, type UserConfigurationData, type UserConfigurationPageData, type WorkflowBuilderConfiguration, type WorkflowConfigurationData, authenticate, closePopover, configureInstance, createWorkflow, exports_d_exports as default, dispose, editInstanceConfiguration, getMessageIframe, graphqlRequest, init, isConfigureInstanceWithInstanceId, isConfigureInstanceWithIntegrationId, isConfigureInstanceWithIntegrationName, queryWorkflows, setConfigVars, showComponent, showComponents, showConnections, showDashboard, showDesigner, showIntegrations, showLogs, showMarketplace, showWorkflow, showWorkflows };
//# sourceMappingURL=index.d.cts.map