sfn-diagram 0.2.0

package/dist/index.d.cts

@@ -0,0 +1,1076 @@
+//#region node_modules/.pnpm/@smithy+types@4.9.0/node_modules/@smithy/types/dist-types/response.d.ts
+/**
+ * @public
+ */
+interface ResponseMetadata {
+  /**
+   * The status code of the last HTTP response received for this operation.
+   */
+  httpStatusCode?: number;
+  /**
+   * A unique identifier for the last request sent for this operation. Often
+   * requested by AWS service teams to aid in debugging.
+   */
+  requestId?: string;
+  /**
+   * A secondary identifier for the last request sent. Used for debugging.
+   */
+  extendedRequestId?: string;
+  /**
+   * A tertiary identifier for the last request sent. Used for debugging.
+   */
+  cfId?: string;
+  /**
+   * The number of times this operation was attempted.
+   */
+  attempts?: number;
+  /**
+   * The total amount of time (in milliseconds) that was spent waiting between
+   * retry attempts.
+   */
+  totalRetryDelay?: number;
+}
+/**
+ * @public
+ */
+interface MetadataBearer {
+  /**
+   * Metadata pertaining to this request.
+   */
+  $metadata: ResponseMetadata;
+}
+//#endregion
+//#region node_modules/.pnpm/@smithy+types@4.9.0/node_modules/@smithy/types/dist-types/http/httpHandlerInitialization.d.ts
+
+declare global {
+  /**
+   * interface merging stub.
+   */
+  interface RequestInit {}
+}
+//#endregion
+//#region node_modules/.pnpm/@aws-sdk+types@3.936.0/node_modules/@aws-sdk/types/dist-types/serde.d.ts
+/**
+ * @public
+ *
+ * Declare DOM interfaces in case dom.d.ts is not added to the tsconfig lib, causing
+ * interfaces to not be defined. For developers with dom.d.ts added, the interfaces will
+ * be merged correctly.
+ *
+ * This is also required for any clients with streaming interfaces where the corresponding
+ * types are also referred. The type is only declared here once since this `@aws-sdk/types`
+ * is depended by all `@aws-sdk` packages.
+ */
+declare global {
+  /**
+   * @public
+   */
+  export interface ReadableStream {}
+  /**
+   * @public
+   */
+  export interface Blob {}
+}
+//#endregion
+//#region node_modules/.pnpm/@aws-sdk+client-sfn@3.940.0/node_modules/@aws-sdk/client-sfn/dist-types/models/enums.d.ts
+/**
+ * @public
+ * @enum
+ */
+declare const EncryptionType: {
+  readonly AWS_OWNED_KEY: "AWS_OWNED_KEY";
+  readonly CUSTOMER_MANAGED_KMS_KEY: "CUSTOMER_MANAGED_KMS_KEY";
+};
+/**
+ * @public
+ */
+type EncryptionType = (typeof EncryptionType)[keyof typeof EncryptionType];
+/**
+ * @public
+ * @enum
+ */
+declare const LogLevel: {
+  readonly ALL: "ALL";
+  readonly ERROR: "ERROR";
+  readonly FATAL: "FATAL";
+  readonly OFF: "OFF";
+};
+/**
+ * @public
+ */
+type LogLevel = (typeof LogLevel)[keyof typeof LogLevel];
+/**
+ * @public
+ * @enum
+ */
+declare const StateMachineType: {
+  readonly EXPRESS: "EXPRESS";
+  readonly STANDARD: "STANDARD";
+};
+/**
+ * @public
+ */
+type StateMachineType = (typeof StateMachineType)[keyof typeof StateMachineType];
+/**
+ * @public
+ * @enum
+ */
+
+/**
+ * @public
+ * @enum
+ */
+declare const StateMachineStatus: {
+  readonly ACTIVE: "ACTIVE";
+  readonly DELETING: "DELETING";
+};
+/**
+ * @public
+ */
+type StateMachineStatus = (typeof StateMachineStatus)[keyof typeof StateMachineStatus];
+/**
+ * @public
+ * @enum
+ */
+
+//#endregion
+//#region node_modules/.pnpm/@aws-sdk+client-sfn@3.940.0/node_modules/@aws-sdk/client-sfn/dist-types/models/models_0.d.ts
+
+/**
+ * <p>Settings to configure server-side encryption. </p>
+ *          <p>
+ *         For additional control over security, you can encrypt your data using a <b>customer-managed key</b> for  Step Functions state machines and activities. You can configure a symmetric KMS key and data key reuse period when creating or updating a <b>State Machine</b>, and when creating an <b>Activity</b>. The execution history and state machine definition will be encrypted with the key applied to the State Machine. Activity inputs will be encrypted with the key applied to the Activity.
+ *     </p>
+ *          <note>
+ *             <p> Step Functions automatically enables encryption at rest using  Amazon Web Services owned keys at no charge. However, KMS charges apply when using a customer managed key. For more information about pricing, see <a href="https://aws.amazon.com/kms/pricing/">Key Management Service pricing</a>.</p>
+ *          </note>
+ *          <p>For more information on KMS, see <a href="https://docs.aws.amazon.com/kms/latest/developerguide/overview.html">What is  Key Management Service?</a>
+ *          </p>
+ * @public
+ */
+interface EncryptionConfiguration {
+  /**
+   * <p>An alias, alias ARN, key ID, or key ARN of a symmetric encryption KMS key to encrypt data. To specify a KMS key in a different Amazon Web Services  account, you must use the key ARN or alias ARN.</p>
+   * @public
+   */
+  kmsKeyId?: string | undefined;
+  /**
+   * <p>Maximum duration that Step Functions will reuse data keys. When the period expires, Step Functions will call <code>GenerateDataKey</code>. Only applies to customer managed keys.</p>
+   * @public
+   */
+  kmsDataKeyReusePeriodSeconds?: number | undefined;
+  /**
+   * <p>Encryption type</p>
+   * @public
+   */
+  type: EncryptionType | undefined;
+}
+/**
+ * <p>Tags are key-value pairs that can be associated with Step Functions state machines and
+ *       activities.</p>
+ *          <p>An array of key-value pairs. For more information, see <a href="https://docs.aws.amazon.com/awsaccountbilling/latest/aboutv2/cost-alloc-tags.html">Using
+ *       Cost Allocation Tags</a> in the <i>Amazon Web Services Billing and Cost Management User
+ *         Guide</i>, and <a href="https://docs.aws.amazon.com/IAM/latest/UserGuide/access_iam-tags.html">Controlling Access Using IAM
+ *           Tags</a>.</p>
+ *          <p>Tags may only contain Unicode letters, digits, white space, or these symbols: <code>_ . : / = + - @</code>.</p>
+ * @public
+ */
+
+/**
+ * <p></p>
+ * @public
+ */
+interface CloudWatchLogsLogGroup {
+  /**
+   * <p>The ARN of the the CloudWatch log group to which you want your logs emitted to. The ARN
+   *       must end with <code>:*</code>
+   *          </p>
+   * @public
+   */
+  logGroupArn?: string | undefined;
+}
+/**
+ * <p></p>
+ * @public
+ */
+interface LogDestination {
+  /**
+   * <p>An object describing a CloudWatch log group. For more information, see <a href="https://docs.aws.amazon.com/AWSCloudFormation/latest/UserGuide/aws-resource-logs-loggroup.html">AWS::Logs::LogGroup</a> in the CloudFormation User Guide.</p>
+   * @public
+   */
+  cloudWatchLogsLogGroup?: CloudWatchLogsLogGroup | undefined;
+}
+/**
+ * <p>The <code>LoggingConfiguration</code> data type is used to set CloudWatch Logs
+ *       options.</p>
+ * @public
+ */
+interface LoggingConfiguration {
+  /**
+   * <p>Defines which category of execution history events are logged.</p>
+   * @public
+   */
+  level?: LogLevel | undefined;
+  /**
+   * <p>Determines whether execution data is included in your log. When set to <code>false</code>,
+   *       data is excluded.</p>
+   * @public
+   */
+  includeExecutionData?: boolean | undefined;
+  /**
+   * <p>An array of objects that describes where your execution history events will be logged.
+   *       Limited to size 1. Required, if your log level is not set to <code>OFF</code>.</p>
+   * @public
+   */
+  destinations?: LogDestination[] | undefined;
+}
+/**
+ * <p>Selects whether or not the state machine's X-Ray tracing is enabled. Default is
+ *         <code>false</code>
+ *          </p>
+ * @public
+ */
+interface TracingConfiguration {
+  /**
+   * <p>When set to <code>true</code>, X-Ray tracing is enabled.</p>
+   * @public
+   */
+  enabled?: boolean | undefined;
+}
+/**
+ * @public
+ */
+
+/**
+ * @public
+ */
+interface DescribeStateMachineOutput {
+  /**
+   * <p>The Amazon Resource Name (ARN) that identifies the state machine.</p>
+   *          <p>If you specified a state machine version ARN in your request, the API returns the version ARN. The version ARN is a combination of state machine ARN and the version number separated by a colon (:). For example, <code>stateMachineARN:1</code>.</p>
+   * @public
+   */
+  stateMachineArn: string | undefined;
+  /**
+   * <p>The name of the state machine.</p>
+   *          <p>A name must <i>not</i> contain:</p>
+   *          <ul>
+   *             <li>
+   *                <p>white space</p>
+   *             </li>
+   *             <li>
+   *                <p>brackets <code>< > \{ \} [ ]</code>
+   *                </p>
+   *             </li>
+   *             <li>
+   *                <p>wildcard characters <code>? *</code>
+   *                </p>
+   *             </li>
+   *             <li>
+   *                <p>special characters <code>" # % \ ^ | ~ ` $ & , ; : /</code>
+   *                </p>
+   *             </li>
+   *             <li>
+   *                <p>control characters (<code>U+0000-001F</code>, <code>U+007F-009F</code>, <code>U+FFFE-FFFF</code>)</p>
+   *             </li>
+   *             <li>
+   *                <p>surrogates (<code>U+D800-DFFF</code>)</p>
+   *             </li>
+   *             <li>
+   *                <p>invalid characters (<code> U+10FFFF</code>)</p>
+   *             </li>
+   *          </ul>
+   *          <p>To enable logging with CloudWatch Logs, the name should only contain  0-9, A-Z, a-z, - and _.</p>
+   * @public
+   */
+  name: string | undefined;
+  /**
+   * <p>The current status of the state machine.</p>
+   * @public
+   */
+  status?: StateMachineStatus | undefined;
+  /**
+   * <p>The Amazon States Language definition of the state machine. See <a href="https://docs.aws.amazon.com/step-functions/latest/dg/concepts-amazon-states-language.html">Amazon States Language</a>.</p>
+   *          <p>If called with <code>includedData = METADATA_ONLY</code>, the returned definition will be <code>\{\}</code>.</p>
+   * @public
+   */
+  definition: string | undefined;
+  /**
+   * <p>The Amazon Resource Name (ARN) of the IAM role used when creating this state machine. (The IAM role
+   *       maintains security by granting Step Functions access to Amazon Web Services resources.)</p>
+   * @public
+   */
+  roleArn: string | undefined;
+  /**
+   * <p>The <code>type</code> of the state machine (<code>STANDARD</code> or
+   *       <code>EXPRESS</code>).</p>
+   * @public
+   */
+  type: StateMachineType | undefined;
+  /**
+   * <p>The date the state machine is created.</p>
+   *          <p>For a state machine version, <code>creationDate</code> is the date the version was created.</p>
+   * @public
+   */
+  creationDate: Date | undefined;
+  /**
+   * <p>The <code>LoggingConfiguration</code> data type is used to set CloudWatch Logs
+   *       options.</p>
+   * @public
+   */
+  loggingConfiguration?: LoggingConfiguration | undefined;
+  /**
+   * <p>Selects whether X-Ray tracing is enabled.</p>
+   * @public
+   */
+  tracingConfiguration?: TracingConfiguration | undefined;
+  /**
+   * <p>A user-defined or an auto-generated string that identifies a <code>Map</code> state. This parameter is present only if the <code>stateMachineArn</code> specified in input is a qualified state machine ARN.</p>
+   * @public
+   */
+  label?: string | undefined;
+  /**
+   * <p>The revision identifier for the state machine.</p>
+   *          <p>Use the <code>revisionId</code> parameter to compare between versions of a state machine
+   *       configuration used for executions without performing a diff of the properties, such as
+   *         <code>definition</code> and <code>roleArn</code>.</p>
+   * @public
+   */
+  revisionId?: string | undefined;
+  /**
+   * <p>The description of the state machine version.</p>
+   * @public
+   */
+  description?: string | undefined;
+  /**
+   * <p>Settings to configure server-side encryption. </p>
+   * @public
+   */
+  encryptionConfiguration?: EncryptionConfiguration | undefined;
+  /**
+   * <p>A map of <b>state name</b> to a list of variables referenced by that state. States that do not use variable references will not be shown in the response.</p>
+   * @public
+   */
+  variableReferences?: Record<string, string[]> | undefined;
+}
+/**
+ * @public
+ */
+//#endregion
+//#region node_modules/.pnpm/@aws-sdk+client-sfn@3.940.0/node_modules/@aws-sdk/client-sfn/dist-types/commands/DescribeStateMachineCommand.d.ts
+/**
+ * @public
+ *
+ * The output of {@link DescribeStateMachineCommand}.
+ */
+interface DescribeStateMachineCommandOutput extends DescribeStateMachineOutput, MetadataBearer {}
+//#endregion
+//#region src/types/index.d.ts
+type StateType = 'Pass' | 'Task' | 'Choice' | 'Wait' | 'Succeed' | 'Fail' | 'Parallel' | 'Map';
+interface CatchBlock {
+  ErrorEquals: string[];
+  Next?: string;
+  ResultPath?: string;
+}
+interface RetryBlock {
+  BackoffRate?: number;
+  ErrorEquals: string[];
+  IntervalSeconds?: number;
+  MaxAttempts?: number;
+}
+interface ChoiceRule {
+  BooleanEquals?: boolean;
+  Next: string;
+  NumericEquals?: number;
+  StringEquals?: string;
+  Variable?: string;
+  [key: string]: any;
+}
+interface AslState {
+  Assign?: Record<string, any>;
+  Branches?: AslDefinition[];
+  Catch?: CatchBlock[];
+  Cause?: string;
+  Choices?: ChoiceRule[];
+  Comment?: string;
+  Default?: string;
+  End?: boolean;
+  Error?: string;
+  Iterator?: AslDefinition;
+  Next?: string;
+  Output?: any;
+  Parameters?: Record<string, any>;
+  Resource?: string;
+  Result?: any;
+  ResultPath?: string;
+  Retry?: RetryBlock[];
+  Seconds?: number | string;
+  SecondsPath?: string;
+  Timestamp?: string;
+  TimestampPath?: string;
+  Type: StateType;
+}
+interface AslDefinition {
+  Comment?: string;
+  QueryLanguage?: 'JSONata' | 'JSONPath';
+  StartAt: string;
+  States: Record<string, AslState>;
+  TimeoutSeconds?: number;
+  Version?: string;
+}
+interface StateNode {
+  /** Child node IDs (for container nodes like Parallel/Map) */
+  children?: string[];
+  height?: number;
+  /** URL to AWS service icon (CDN path for Task states) */
+  iconUrl?: string;
+  id: string;
+  /** Whether this node is a container (Parallel or Map state) */
+  isContainer?: boolean;
+  label: string;
+  /** Parent node ID (for nodes inside Parallel/Map containers) */
+  parent?: string;
+  /** AWS service identifier for Task states (e.g., 'lambda', 's3') */
+  serviceType?: string;
+  style?: NodeStyle;
+  type: string;
+  width?: number;
+  x?: number;
+  y?: number;
+}
+/** Edge types for state transitions */
+type EdgeType = 'normal' | 'error' | 'choice' | 'default';
+interface GraphEdge {
+  condition?: string;
+  from: string;
+  label?: string;
+  to: string;
+  type?: EdgeType;
+  visualOnly?: boolean;
+}
+/** Node shape types for rendering state nodes */
+type NodeShape = 'rect' | 'diamond' | 'circle';
+interface NodeStyle {
+  fill: string;
+  stroke: string;
+  strokeWidth: number;
+  shape: NodeShape;
+}
+interface CustomTheme {
+  background: string;
+  edgeColors: {
+    choice: string;
+    default: string;
+    error: string;
+    normal: string;
+  };
+  fontFamily: string;
+  fontSize: number;
+  nodeColors: Record<StateType, {
+    fill: string;
+    stroke: string;
+  }>;
+  textColor: string;
+}
+/** Supported output formats for diagram generation */
+type DiagramFormat = 'svg' | 'mermaid' | 'png';
+/** Theme options: built-in themes or custom theme object */
+type ThemeOption = 'light' | 'dark' | CustomTheme;
+/** Graph layout direction */
+type LayoutDirection = 'TB' | 'LR' | 'RL' | 'BT';
+/** Edge path rendering style */
+type EdgePathStyle = 'straight' | 'curved' | 'orthogonal';
+/** Catch/Retry label display style */
+type CatchLabelStyle = 'error-type' | 'catch-number';
+/** Visual style preset for node shapes */
+type StylePreset = 'aws-standard' | 'enhanced';
+interface DiagramOptions {
+  /**
+   * Background color for PNG export
+   * @default 'transparent'
+   */
+  backgroundColor?: string | 'transparent';
+  /**
+   * Style for Catch block edge labels: 'error-type' shows error names, 'catch-number' shows "Catch #N"
+   * @default 'error-type'
+   */
+  catchLabelStyle?: CatchLabelStyle;
+  /** Custom styling overrides for specific state types */
+  customColors?: Partial<Record<StateType, NodeStyle>>;
+  /**
+   * Style of edge paths: straight, curved, or orthogonal
+   * @default 'curved'
+   */
+  edgeStyle?: EdgePathStyle;
+  /** Output format for the diagram */
+  format?: DiagramFormat;
+  /** Overall diagram height in pixels (auto-calculated if not specified) */
+  height?: number;
+  /**
+   * Position of AWS service icons relative to node label
+   * @default 'left'
+   */
+  iconPosition?: 'left' | 'top' | 'right';
+  /** Custom function to resolve icon URLs for services */
+  iconResolver?: (service: string) => string | null;
+  /**
+   * Size of AWS service icons in pixels
+   * @default 24
+   */
+  iconSize?: number;
+  /**
+   * Whether to use state comments as node labels
+   * @default true
+   */
+  includeComments?: boolean;
+  /** Graph layout direction: TB (top-bottom), LR (left-right), RL (right-left), BT (bottom-top) */
+  layout?: LayoutDirection;
+  /**
+   * Height of each state node in pixels
+   * @default 60
+   */
+  nodeHeight?: number;
+  /**
+   * Horizontal separation between nodes in pixels
+   * @default 50
+   */
+  nodeSeparation?: number;
+  /**
+   * Width of each state node in pixels
+   * @default 120
+   */
+  nodeWidth?: number;
+  /**
+   * Padding around the diagram in pixels
+   * @default 20
+   */
+  padding?: number;
+  /**
+   * PNG export quality from 1-100
+   * @default 90
+   */
+  pngQuality?: number;
+  /**
+   * Vertical separation between ranks in pixels
+   * @default 50
+   */
+  rankSeparation?: number;
+  /**
+   * Whether to display AWS service icons on Task state nodes
+   * @default false
+   */
+  showIcons?: boolean;
+  /**
+   * Whether to display state type labels on nodes
+   * @default false
+   */
+  showStateTypes?: boolean;
+  /**
+   * Visual style preset: 'aws-standard' uses rectangles (AWS parity), 'enhanced' uses shapes for visual distinction
+   * @default 'aws-standard'
+   */
+  stylePreset?: StylePreset;
+  /** Color theme: 'light', 'dark', or custom theme object */
+  theme?: ThemeOption;
+  /** Overall diagram width in pixels (auto-calculated if not specified) */
+  width?: number;
+}
+/** SVG diagram output */
+interface SvgOutput {
+  /** Height of the diagram in pixels */
+  height: number;
+  /** Metadata about the generated diagram */
+  metadata: {
+    /** Number of edges (transitions) in the diagram */
+    edgeCount: number;
+    /** Number of state nodes in the diagram */
+    nodeCount: number;
+  };
+  /** Complete SVG markup as a string */
+  svg: string;
+  /** Width of the diagram in pixels */
+  width: number;
+}
+/** Mermaid diagram code output */
+interface MermaidOutput {
+  /** Mermaid state diagram syntax */
+  code: string;
+  /** Metadata about the generated diagram */
+  metadata: {
+    /** Number of transitions in the diagram */
+    edgeCount: number;
+    /** Number of states in the diagram */
+    stateCount: number;
+  };
+}
+/** PNG image output */
+interface PngOutput {
+  /** PNG image data as a Buffer */
+  buffer: Buffer;
+  /** Height of the image in pixels */
+  height: number;
+  /** Metadata about the generated image */
+  metadata: {
+    /** Image format (always 'png') */
+    format: 'png';
+  };
+  /** Width of the image in pixels */
+  width: number;
+}
+interface GenerateSvgParams extends DiagramOptions {
+  /** ASL definition as object or JSON string */
+  aslDefinition: AslDefinition | string;
+}
+interface GenerateMermaidParams extends DiagramOptions {
+  /** ASL definition as object or JSON string */
+  aslDefinition: AslDefinition | string;
+}
+interface GenerateDiagramParams extends DiagramOptions {
+  /** ASL definition as object or JSON string */
+  aslDefinition: AslDefinition | string;
+}
+interface ExportPngParams extends DiagramOptions {
+  /** ASL definition as object or JSON string */
+  aslDefinition: AslDefinition | string;
+}
+interface GenerateFromAwsParams extends DiagramOptions {
+  /** AWS SDK DescribeStateMachine command output */
+  response: DescribeStateMachineCommandOutput;
+}
+//#endregion
+//#region src/config/themes.d.ts
+/**
+ * AWS Light Theme - matches the AWS Step Functions console light mode
+ */
+declare const AWS_LIGHT_THEME: CustomTheme;
+/**
+ * AWS Dark Theme - matches the AWS Step Functions console dark mode
+ */
+declare const AWS_DARK_THEME: CustomTheme;
+/**
+ * Get theme object from theme name or custom theme
+ */
+//#endregion
+//#region src/utils/iconEmbedder.d.ts
+interface EmbedIconsParams {
+  svg: string;
+  /** Timeout in milliseconds for each icon fetch (default: 5000) */
+  timeoutMs?: number;
+}
+/**
+ * Embed external icon URLs in SVG as base64 data URIs
+ *
+ * This function scans the SVG for external image references (href attributes)
+ * and replaces them with inline base64-encoded data URIs. This ensures icons
+ * display correctly in standalone SVG files, PNG exports, and contexts where
+ * external resources are blocked by security policies.
+ *
+ * @param params - Parameters for icon embedding
+ * @param params.svg - SVG string containing external icon URLs
+ * @returns Promise resolving to SVG string with embedded icons
+ *
+ * @example
+ * const svgWithExternalIcons = generateSvg({ aslDefinition, showIcons: true });
+ * const svgWithEmbeddedIcons = await embedIcons({ svg: svgWithExternalIcons.svg });
+ * writeFileSync('diagram.svg', svgWithEmbeddedIcons);
+ *
+ * @example
+ * // Chain with PNG export
+ * const { svg } = generateSvg({ aslDefinition, showIcons: true });
+ * const embeddedSvg = await embedIcons({ svg });
+ * const png = await exportPng({ svg: embeddedSvg });
+ */
+declare function embedIcons(params: EmbedIconsParams): Promise<string>;
+//#endregion
+//#region src/exporters/PngExporter.d.ts
+/** Parameters for converting SVG to PNG */
+interface ConvertParams {
+  /** Height of the SVG in pixels */
+  height: number;
+  /** SVG markup string */
+  svg: string;
+  /** Width of the SVG in pixels */
+  width: number;
+}
+/**
+ * PngExporter - Converts SVG to PNG using headless rendering
+ */
+declare class PngExporter {
+  private options;
+  constructor(options: DiagramOptions);
+  /**
+   * Convert SVG string to PNG buffer
+   *
+   * Note: External images (like AWS service icons from CDN) may not render in PNG export
+   * due to limitations with headless browser rendering. Use SVG output for best results
+   * when showIcons is enabled.
+   */
+  convert(params: ConvertParams): Promise<PngOutput>;
+  /**
+   * Wrap SVG in HTML for rendering
+   */
+  private wrapSvgInHtml;
+}
+//#endregion
+//#region src/AslParser.d.ts
+/**
+ * Error thrown when ASL validation fails
+ */
+declare class AslValidationError extends Error {
+  constructor(message: string);
+}
+/**
+ * Result of parsing an ASL definition into a graph structure
+ */
+
+interface ValidateAslParams {
+  /** The ASL definition to validate */
+  definition: unknown;
+}
+/**
+ * Validates an ASL definition and returns helpful error messages
+ *
+ * @param params - Validation parameters
+ * @throws {AslValidationError} When the ASL definition is invalid
+ */
+declare function validateAsl(params: ValidateAslParams): void;
+/**
+ * Parameters for parsing an ASL definition into a graph
+ */
+
+//#endregion
+//#region src/index.d.ts
+/**
+ * Generate an SVG diagram from an AWS Step Functions ASL definition
+ *
+ * This function parses an ASL definition and renders it as an SVG diagram using D3.js
+ * with automatic graph layout via Dagre. The output is a complete SVG string that can
+ * be saved to a file or embedded in HTML.
+ *
+ * @param params - Configuration object
+ * @param params.aslDefinition - ASL definition as an object or JSON string
+ * @param params.theme - Color theme: 'light' (default), 'dark', or a CustomTheme object
+ * @param params.layout - Layout direction: 'TB' (top-bottom, default), 'LR' (left-right), 'RL', or 'BT'
+ * @param params.nodeWidth - Width of state nodes in pixels (default: 120)
+ * @param params.nodeHeight - Height of state nodes in pixels (default: 60)
+ * @param params.rankSeparation - Vertical separation between ranks in pixels (default: 50)
+ * @param params.nodeSeparation - Horizontal separation between nodes in pixels (default: 50)
+ * @param params.padding - Padding around the diagram in pixels (default: 20)
+ * @param params.edgeStyle - Edge path style: 'curved' (default), 'straight', or 'orthogonal'
+ * @param params.showStateTypes - Whether to display state types on nodes (default: false)
+ * @param params.includeComments - Whether to use state comments as labels (default: true)
+ * @param params.customColors - Override colors for specific state types
+ *
+ * @returns SVG output containing the diagram string, dimensions, and metadata
+ *
+ * @throws {SyntaxError} If params.asl is a string with invalid JSON
+ * @throws {Error} If the ASL definition structure is invalid
+ *
+ * @example
+ * ```typescript
+ * import { generateSvg } from 'sfn-diagram';
+ * import { writeFileSync } from 'fs';
+ *
+ * const asl = {
+ *   StartAt: 'HelloWorld',
+ *   States: {
+ *     HelloWorld: { Type: 'Pass', Result: 'Hello!', End: true }
+ *   }
+ * };
+ *
+ * const { svg, width, height } = generateSvg({ aslDefinition: asl, theme: 'dark', layout: 'LR' });
+ * writeFileSync('diagram.svg', svg);
+ * console.log(`Generated ${width}x${height} diagram`);
+ * ```
+ *
+ * @example
+ * ```typescript
+ * // From JSON string
+ * const aslJson = fs.readFileSync('state-machine.json', 'utf-8');
+ * const result = generateSvg({ asl: aslJson, theme: 'light' });
+ * ```
+ *
+ * @example
+ * ```typescript
+ * // With AWS service icons
+ * const { svg } = generateSvg({
+ *   aslDefinition: asl,
+ *   showIcons: true,
+ *   iconPosition: 'left',
+ *   nodeWidth: 150
+ * });
+ * ```
+ */
+declare function generateSvg(params: GenerateSvgParams): SvgOutput;
+/**
+ * Generate Mermaid diagram syntax from an AWS Step Functions ASL definition
+ *
+ * This function converts an ASL definition into Mermaid state diagram syntax,
+ * which can be rendered using the Mermaid library or included in Markdown documentation.
+ * The output includes CSS classes for styling different state types.
+ *
+ * @param params - Configuration object
+ * @param params.aslDefinition - ASL definition as an object or JSON string
+ *
+ * @returns Mermaid output containing the diagram code and metadata
+ *
+ * @throws {SyntaxError} If params.asl is a string with invalid JSON
+ * @throws {Error} If the ASL definition structure is invalid
+ *
+ * @example
+ * ```typescript
+ * import { generateMermaid } from 'sfn-diagram';
+ *
+ * const asl = {
+ *   StartAt: 'Process',
+ *   States: {
+ *     Process: { Type: 'Task', Resource: 'arn:aws:...', Next: 'Done' },
+ *     Done: { Type: 'Succeed' }
+ *   }
+ * };
+ *
+ * const { code, metadata } = generateMermaid({ asl });
+ * console.log(code);
+ * // Output:
+ * // stateDiagram-v2
+ * //     [*] --> Process
+ * //     Process --> Done
+ * //     Done --> [*]
+ * //     ...
+ *
+ * console.log(`Generated diagram with ${metadata.stateCount} states`);
+ * ```
+ *
+ * @example
+ * ```typescript
+ * // Use in Markdown
+ * const { code } = generateMermaid({ asl: myStateMachine });
+ * const markdown = `\`\`\`mermaid\n${code}\n\`\`\``;
+ * fs.writeFileSync('diagram.md', markdown);
+ * ```
+ */
+declare function generateMermaid(params: GenerateMermaidParams): MermaidOutput;
+/**
+ * Generate a diagram from an ASL definition (auto-detects format from options)
+ *
+ * This is a convenience function that generates either an SVG or Mermaid diagram
+ * based on the `format` option. If no format is specified, defaults to SVG.
+ *
+ * @param params - Configuration object
+ * @param params.aslDefinition - ASL definition as an object or JSON string
+ * @param params.format - Output format: 'svg' (default) or 'mermaid'
+ * @param params.theme - Color theme (SVG only)
+ * @param params.layout - Layout direction (SVG only)
+ * @param ...params - Other options (see generateSvg or generateMermaid)
+ *
+ * @returns SVG output if format is 'svg', Mermaid output if format is 'mermaid'
+ *
+ * @throws {SyntaxError} If params.asl is a string with invalid JSON
+ * @throws {Error} If the ASL definition structure is invalid
+ *
+ * @example
+ * ```typescript
+ * import { generateDiagram } from 'sfn-diagram';
+ *
+ * // Generate SVG (default)
+ * const svgResult = generateDiagram({ asl: myAsl });
+ *
+ * // Generate Mermaid
+ * const mermaidResult = generateDiagram({ asl: myAsl, format: 'mermaid' });
+ * ```
+ */
+declare function generateDiagram(params: GenerateDiagramParams): SvgOutput | MermaidOutput;
+/**
+ * Export a diagram as PNG (asynchronous)
+ *
+ * This function generates an SVG diagram and converts it to PNG format using
+ * headless browser rendering. The output is a Buffer that can be written to a file.
+ *
+ * **Note:** This function is asynchronous and uses Puppeteer for rendering,
+ * which may take a moment on first run to download the browser binary.
+ *
+ * @param params - Configuration object
+ * @param params.aslDefinition - ASL definition as an object or JSON string
+ * @param params.pngQuality - PNG quality from 1-100 (default: 90)
+ * @param params.backgroundColor - Background color as CSS color or 'transparent' (default: 'transparent')
+ * @param ...params - Other SVG options (see generateSvg)
+ *
+ * @returns Promise resolving to PNG output with buffer and dimensions
+ *
+ * @throws {SyntaxError} If params.asl is a string with invalid JSON
+ * @throws {Error} If the ASL definition structure is invalid or PNG conversion fails
+ *
+ * @example
+ * ```typescript
+ * import { exportPng } from 'sfn-diagram';
+ * import { writeFileSync } from 'fs';
+ *
+ * const asl = { StartAt: 'Hello', States: { Hello: { Type: 'Pass', End: true } } };
+ *
+ * const { buffer, width, height } = await exportPng({
+ *   asl,
+ *   theme: 'dark',
+ *   pngQuality: 95,
+ *   backgroundColor: 'white'
+ * });
+ *
+ * writeFileSync('diagram.png', buffer);
+ * console.log(`Saved ${width}x${height} PNG`);
+ * ```
+ */
+declare function exportPng(params: ExportPngParams): Promise<PngOutput>;
+/**
+ * Generate a diagram from an AWS SDK DescribeStateMachine response
+ *
+ * This is a convenience function for integrating with the AWS SDK. It extracts
+ * the ASL definition from the response and generates a diagram.
+ *
+ * @param params - Configuration object
+ * @param params.response - AWS SDK DescribeStateMachine response object
+ * @param params.format - Output format: 'svg' (default) or 'mermaid'
+ * @param ...params - Other options (see generateSvg or generateMermaid)
+ *
+ * @returns SVG output if format is 'svg', Mermaid output if format is 'mermaid'
+ *
+ * @throws {Error} If response.definition is missing
+ * @throws {SyntaxError} If the definition contains invalid JSON
+ * @throws {Error} If the ASL definition structure is invalid
+ *
+ * @example
+ * ```typescript
+ * import { SFNClient, DescribeStateMachineCommand } from '@aws-sdk/client-sfn';
+ * import { generateFromAwsResponse } from 'sfn-diagram';
+ *
+ * const client = new SFNClient({ region: 'us-east-1' });
+ * const response = await client.send(
+ *   new DescribeStateMachineCommand({
+ *     stateMachineArn: 'arn:aws:states:...'
+ *   })
+ * );
+ *
+ * const { svg } = generateFromAwsResponse({
+ *   response,
+ *   theme: 'light',
+ *   layout: 'TB'
+ * });
+ * ```
+ */
+declare function generateFromAwsResponse(params: GenerateFromAwsParams): SvgOutput | MermaidOutput;
+/**
+ * Class-based API for advanced usage with fluent interface
+ *
+ * This class allows you to configure diagram options once and generate multiple
+ * diagrams with the same settings. Options can be updated using the fluent
+ * `setOptions()` method.
+ *
+ * @example
+ * ```typescript
+ * import { SfnDiagramGenerator } from 'sfn-diagram';
+ *
+ * const generator = new SfnDiagramGenerator({
+ *   theme: 'dark',
+ *   layout: 'LR',
+ *   nodeWidth: 150
+ * });
+ *
+ * // Generate multiple diagrams with the same options
+ * const diagram1 = generator.generateSvg({ asl: stateMachine1 });
+ * const diagram2 = generator.generateSvg({ asl: stateMachine2 });
+ *
+ * // Update options and generate more
+ * generator.setOptions({ theme: 'light' });
+ * const diagram3 = generator.generateSvg({ asl: stateMachine3 });
+ * ```
+ */
+declare class SfnDiagramGenerator {
+  private options;
+  /**
+   * Create a new diagram generator with default options
+   *
+   * @param options - Default diagram options for all subsequent generations
+   *
+   * @example
+   * ```typescript
+   * const generator = new SfnDiagramGenerator({ theme: 'dark', layout: 'LR' });
+   * ```
+   */
+  constructor(options?: DiagramOptions);
+  /**
+   * Generate a diagram (auto-detects format from options)
+   *
+   * @param params - Generation parameters
+   * @param params.asl - ASL definition as an object or JSON string
+   * @returns SVG or Mermaid output based on format option
+   *
+   * @example
+   * ```typescript
+   * const result = generator.generate({ asl: myStateMachine });
+   * ```
+   */
+  generate(params: {
+    aslDefinition: AslDefinition | string;
+  }): SvgOutput | MermaidOutput;
+  /**
+   * Generate an SVG diagram
+   *
+   * @param params - Generation parameters
+   * @param params.asl - ASL definition as an object or JSON string
+   * @returns SVG output with diagram and metadata
+   *
+   * @example
+   * ```typescript
+   * const { svg } = generator.generateSvg({ asl: myStateMachine });
+   * ```
+   */
+  generateSvg(params: {
+    aslDefinition: AslDefinition | string;
+  }): SvgOutput;
+  /**
+   * Generate Mermaid diagram syntax
+   *
+   * @param params - Generation parameters
+   * @param params.asl - ASL definition as an object or JSON string
+   * @returns Mermaid output with code and metadata
+   *
+   * @example
+   * ```typescript
+   * const { code } = generator.generateMermaid({ asl: myStateMachine });
+   * ```
+   */
+  generateMermaid(params: {
+    aslDefinition: AslDefinition | string;
+  }): MermaidOutput;
+  /**
+   * Export diagram as PNG
+   *
+   * @param params - Generation parameters
+   * @param params.asl - ASL definition as an object or JSON string
+   * @returns Promise resolving to PNG output
+   *
+   * @example
+   * ```typescript
+   * const { buffer } = await generator.exportPng({ asl: myStateMachine });
+   * ```
+   */
+  exportPng(params: {
+    aslDefinition: AslDefinition | string;
+  }): Promise<PngOutput>;
+  /**
+   * Update the generator's default options (fluent interface)
+   *
+   * @param options - Partial options to merge with existing options
+   * @returns This generator instance for method chaining
+   *
+   * @example
+   * ```typescript
+   * generator
+   *   .setOptions({ theme: 'dark' })
+   *   .setOptions({ layout: 'LR' });
+   *
+   * const result = generator.generateSvg({ asl: myAsl });
+   * ```
+   */
+  setOptions(options: Partial<DiagramOptions>): this;
+}
+//#endregion
+export { AWS_DARK_THEME, AWS_LIGHT_THEME, type AslDefinition, type AslState, AslValidationError, type CustomTheme, type DiagramFormat, type DiagramOptions, type EdgePathStyle, type EdgeType, type ExportPngParams, type GenerateDiagramParams, type GenerateFromAwsParams, type GenerateMermaidParams, type GenerateSvgParams, type GraphEdge, type LayoutDirection, type MermaidOutput, type NodeShape, type NodeStyle, PngExporter, type PngOutput, SfnDiagramGenerator, type StateNode, type StateType, type SvgOutput, type ThemeOption, embedIcons, exportPng, generateDiagram, generateFromAwsResponse, generateMermaid, generateSvg, validateAsl };