@terrazzo/parser 0.7.3 → 0.8.1

package/dist/index.d.ts

@@ -1,13 +1,706 @@
-export { default as build } from './build/index.js';
-export * from './build/index.js';
-export { default as defineConfig } from './config.js';
-export * from './config.js';
-export { default as lintRunner } from './lint/index.js';
-export * from './lint/index.js';
-export { default as Logger } from './logger.js';
-export * from './logger.js';
-export { default as parse } from './parse/index.js';
-export * from './parse/index.js';
-export * from './types.js';
-export * from '@terrazzo/token-tools/dist/types.js';
+import { AliasToken, AliasValue, BooleanToken, BooleanTokenNormalized, BooleanValue, BorderToken, BorderTokenNormalized, BorderValue, BorderValueNormalized, ColorSpace, ColorToken, ColorTokenNormalized, ColorValue, ColorValueNormalized, CubicBezierToken, CubicBezierTokenNormalized, CubicBezierValue, CustomTransformOptions, DimensionToken, DimensionTokenNormalized, DimensionValue, DurationToken, DurationTokenNormalized, DurationValue, FontFamilyToken, FontFamilyTokenNormalized, FontFamilyValue, FontFamilyValueNormalized, FontWeightToken, FontWeightTokenNormalized, FontWeightValue, FontWeightValueNormalized, GradientStop, GradientStopNormalized, GradientToken, GradientTokenNormalized, GradientValue, GradientValueNormalized, Group, GroupCore, GroupOrToken, LinkToken, LinkTokenNormalized, LinkValue, ModeMap, NumberToken, NumberTokenNormalized, NumberValue, ShadowToken, ShadowTokenNormalized, ShadowValue, ShadowValueNormalized, StringToken, StringTokenNormalized, StringValue, StrokeStyleToken, StrokeStyleTokenNormalized, StrokeStyleValue, StrokeStyleValueExpanded, Token, Token as Token$1, TokenCore, TokenMode, TokenNormalized, TokenNormalized as TokenNormalized$1, TokenNormalizedCore, TokenNormalizedSet, TokenNormalizedSet as TokenNormalizedSet$1, TokensSet, TransitionToken, TransitionTokenNormalized, TransitionValue, TransitionValueNormalized, TypographyToken, TypographyTokenNormalized, TypographyValue, TypographyValueNormalized } from "@terrazzo/token-tools";
+import { AnyNode, DocumentNode, MemberNode, ObjectNode, ParseOptions as ParseOptions$1, ValueNode } from "@humanwhocodes/momoa";
+import ytm from "yaml-to-momoa";
+
+//#region src/logger.d.ts
+declare const LOG_ORDER: readonly ["error", "warn", "info", "debug"];
+type LogSeverity = 'error' | 'warn' | 'info' | 'debug';
+type LogLevel = LogSeverity | 'silent';
+type LogGroup = 'config' | 'parser' | 'lint' | 'plugin' | 'server';
+interface LogEntry {
+  /** Originator of log message */
+  group: LogGroup;
+  /** Error message to be logged */
+  message: string;
+  /** Prefix message with label */
+  label?: string;
+  /** File in disk */
+  filename?: URL;
+  /**
+   * Continue on error?
+   * @default false
+   */
+  continueOnError?: boolean;
+  /** Show a code frame for the erring node */
+  node?: AnyNode;
+  /** To show a code frame, provide the original source code */
+  src?: string;
+}
+interface DebugEntry {
+  group: LogGroup;
+  /** Error message to be logged */
+  message: string;
+  /** Current subtask or submodule */
+  label?: string;
+  /** Show code below message */
+  codeFrame?: {
+    src: string;
+    line: number;
+    column: number;
+  };
+  /** Display performance timing */
+  timing?: number;
+}
+/**
+ * @param {Entry} entry
+ * @param {Severity} severity
+ * @return {string}
+ */
+declare function formatMessage(entry: LogEntry, severity: LogSeverity): string;
+declare class Logger {
+  level: LogLevel;
+  debugScope: string;
+  errorCount: number;
+  warnCount: number;
+  infoCount: number;
+  debugCount: number;
+  constructor(options?: {
+    level?: LogLevel;
+    debugScope?: string;
+  });
+  setLevel(level: LogLevel): void;
+  /** Log an error message (always; can’t be silenced) */
+  error(entry: LogEntry): void;
+  /** Log an info message (if logging level permits) */
+  info(entry: LogEntry): void;
+  /** Log a warning message (if logging level permits) */
+  warn(entry: LogEntry): void;
+  /** Log a diagnostics message (if logging level permits) */
+  debug(entry: DebugEntry): void;
+  /** Get stats for current logger instance */
+  stats(): {
+    errorCount: number;
+    warnCount: number;
+    infoCount: number;
+    debugCount: number;
+  };
+}
+declare class TokensJSONError extends Error {
+  constructor(message: string);
+}
+//# sourceMappingURL=logger.d.ts.map
+//#endregion
+//#region src/types.d.ts
+interface BuildHookOptions {
+  /** Map of tokens */
+  tokens: Record<string, TokenNormalized$1>;
+  /** Query transformed values */
+  getTransforms(params: TransformParams): TokenTransformed[];
+  /** Momoa documents */
+  sources: InputSource[];
+  outputFile: (/** Filename to output (relative to outDir) */
+  filename: string, /** Contents to write to file */
+  contents: string | Buffer) => void;
+}
+interface BuildRunnerResult {
+  outputFiles: OutputFile[];
+}
+interface BuildEndHookOptions {
+  /** Map of tokens */
+  tokens: Record<string, TokenNormalized$1>;
+  /** Query transformed values */
+  getTransforms(params: TransformParams): TokenTransformed[];
+  /** Momoa documents */
+  sources: InputSource[];
+  /** Final files to be written */
+  outputFiles: OutputFileExpanded[];
+}
+interface Config {
+  /**
+   * Path to tokens.json
+   * @default "./tokens.json"
+   */
+  tokens?: string | string[];
+  /**
+   * Output directory
+   * @default "./tokens/"
+   */
+  outDir?: string;
+  /** Specify plugins */
+  plugins?: Plugin[];
+  /** Specify linting settings */
+  lint?: {
+    /** Configure build behavior */
+    build?: {
+      /**
+       * Should linters run with `tz build`?
+       * @default true
+       */
+      enabled?: boolean;
+    };
+    /** Configure lint rules */
+    rules?: Record<string, LintRuleShorthand | LintRuleLonghand>;
+  };
+  /** Ignore token groups */
+  ignore?: {
+    /** Token patterns to ignore. Accepts globs. */
+    tokens?: string[];
+    /** Ignore deprecated tokens */
+    deprecated?: boolean;
+  };
+}
+interface ConfigInit {
+  tokens: URL[];
+  outDir: URL;
+  plugins: Plugin[];
+  lint: {
+    build: NonNullable<NonNullable<Config['lint']>['build']>;
+    rules: Record<string, LintRuleLonghand>;
+  };
+  ignore: {
+    tokens: NonNullable<NonNullable<Config['ignore']>['tokens']>;
+    deprecated: NonNullable<NonNullable<Config['ignore']>['deprecated']>;
+  };
+}
+interface ConfigOptions {
+  logger?: Logger;
+  /** @terrazzo/parser needs cwd so this can be run without Node.js. Importing defineConfig from @terrazzo/cli doesn’t need this. */
+  cwd: URL;
+}
+interface InputSource {
+  filename?: URL;
+  src: any;
+  document: DocumentNode;
+}
+interface LintNotice {
+  /** Lint message shown to the user */
+  message: string;
+  /** Erring node (used to point to a specific line) */
+  node?: AnyNode;
+}
+type LintRuleSeverity = 'error' | 'warn' | 'off';
+type LintRuleShorthand = LintRuleSeverity | 0 | 1 | 2;
+type LintRuleLonghand = [LintRuleSeverity | 0 | 1 | 2, any];
+interface LintRuleNormalized<O = any> {
+  id: string;
+  severity: LintRuleSeverity;
+  options?: O;
+}
+type LintReportDescriptor<MessageIds extends string> = {
+  /** To error on a specific token source file, provide an erring node */
+  node?: AnyNode;
+  /** To error on a specific token source file, also provide the source */
+  source?: InputSource;
+  /** Provide data for messages */
+  data?: Record<string, unknown>;
+} & ({
+  /** Provide the error message to display */
+  message: string;
+  messageId?: never;
+} | {
+  message?: never;
+  /** Provide the error message ID */
+  messageId: MessageIds;
+});
+interface LintRule<MessageIds extends string, LintRuleOptions extends object | undefined = undefined, LintRuleDocs = unknown> {
+  meta?: LintRuleMetaData<MessageIds, LintRuleOptions, LintRuleDocs>;
+  /**
+   * Function which returns an object with methods that ESLint calls to “visit”
+   * nodes while traversing the abstract syntax tree.
+   */
+  create(context: Readonly<LintRuleContext<MessageIds, LintRuleOptions>>): void | Promise<void>;
+  /**
+   * Default options the rule will be run with
+   */
+  defaultOptions: LintRuleOptions;
+}
+interface LintRuleContext<MessageIds extends string, LintRuleOptions extends object | undefined = undefined> {
+  /** The rule ID. */
+  id: string;
+  /**
+   * An array of the configured options for this rule. This array does not
+   * include the rule severity.
+   */
+  options: LintRuleOptions;
+  /** The current working directory. */
+  cwd?: URL;
+  /** Source file the token came from. */
+  src: string;
+  /** Source file location. */
+  filename?: URL;
+  /** ID:Token map of all tokens. */
+  tokens: Record<string, TokenNormalized$1>;
+  /** Reports a problem in the code. */
+  report(descriptor: LintReportDescriptor<MessageIds>): void;
+}
+interface LintRuleMetaData<MessageIds extends string, LintRuleOptions extends object | undefined = undefined, LintRuleDocs = unknown> {
+  /**
+   * Documentation for the rule
+   */
+  docs?: LintRuleDocs & LintRuleMetaDataDocs;
+  /**
+   * A map of messages which the rule can report. The key is the messageId, and
+   * the string is the parameterised error string.
+   */
+  messages?: Record<MessageIds, string>;
+  /**
+   * Specifies default options for the rule. If present, any user-provided
+   * options in their config will be merged on top of them recursively. This
+   * merging will be applied directly to `context.options`.
+   */
+  defaultOptions?: LintRuleOptions;
+}
+interface LintRuleMetaDataDocs {
+  /** Concise description of the rule. */
+  description: string;
+  /** The URL of the rule's docs. */
+  url?: string;
+}
+interface OutputFile {
+  /** Filename, relative to outDir */
+  filename: string;
+  /** File contents */
+  contents: string | Buffer;
+  /** Plugin name that generated the file */
+  plugin?: string;
+  /** Time taken to generate file */
+  time?: number;
+}
+interface OutputFileExpanded extends OutputFile {
+  /** The `name` of the plugin that produced this file. */
+  plugin: string;
+  /** How long this output took to make. */
+  time: number;
+}
+interface Plugin {
+  name: string;
+  /** Read config, and optionally modify */
+  config?(config: ConfigInit): void | ConfigInit | undefined;
+  /**
+   * Declare:
+   * - `"pre"`: run this plugin BEFORE all others
+   * - `"post"`: run this plugin AFTER all others
+   * - (default) run this plugin in default order (array order)
+   */
+  enforce?: 'pre' | 'post';
+  /** Throw lint errors/warnings */
+  lint?(): Record<string, LintRule<any, any, any>>;
+  transform?(options: TransformHookOptions): Promise<void>;
+  build?(options: BuildHookOptions): Promise<void>;
+  buildEnd?(result: BuildRunnerResult): Promise<void>;
+}
+/** Transformed token with a single value. Note that this may be any type! */
+interface TokenTransformedSingleValue {
+  /** Original Token ID */
+  id: string;
+  /** ID unique to this format. */
+  localID?: string;
+  type: 'SINGLE_VALUE';
+  value: string;
+  /**
+   * The mode of this value
+   * @default "."
+   */
+  mode: string;
+  /** The original token. */
+  token: TokenNormalized$1;
+}
+/** Transformed token with multiple values. Note that this may be any type! */
+interface TokenTransformedMultiValue {
+  /** Original Token ID */
+  id: string;
+  /** ID unique to this format.*/
+  localID?: string;
+  type: 'MULTI_VALUE';
+  value: Record<string, string>;
+  /**
+   * The mode of this value
+   * @default "."
+   */
+  mode: string;
+  /** The original token */
+  token: TokenNormalized$1;
+}
+type TokenTransformed = TokenTransformedSingleValue | TokenTransformedMultiValue;
+interface TransformParams {
+  /** ID of an existing format */
+  format: string;
+  /** Glob of tokens to select (e.g. `"color.*"` to select all tokens starting with `"color."`) */
+  id?: string | string[];
+  /** $type(s) to filter for */
+  $type?: string | string[];
+  /**
+   * Mode name, if selecting a mode
+   * @default "."
+   */
+  mode?: string | string[];
+}
+interface TransformHookOptions {
+  /** Map of tokens */
+  tokens: Record<string, TokenNormalized$1>;
+  /** Query transformed values */
+  getTransforms(params: TransformParams): TokenTransformed[];
+  /** Update transformed values */
+  setTransform(id: string, params: {
+    format: string;
+    localID?: string;
+    value: string | Record<string, string>;
+    mode?: string;
+  }): void;
+  /** Momoa documents */
+  sources: InputSource[];
+}
+//# sourceMappingURL=types.d.ts.map
+//#endregion
+//#region src/build/index.d.ts
+interface BuildRunnerOptions {
+  sources: {
+    filename?: URL;
+    src: string;
+    document: DocumentNode;
+  }[];
+  config: ConfigInit;
+  logger?: Logger;
+}
+declare const SINGLE_VALUE = "SINGLE_VALUE";
+declare const MULTI_VALUE = "MULTI_VALUE";
+/** Run build stage */
+declare function build(tokens: Record<string, TokenNormalized$1>, {
+  sources,
+  logger,
+  config
+}: BuildRunnerOptions): Promise<BuildRunnerResult>;
+//# sourceMappingURL=index.d.ts.map
+//#endregion
+//#region src/config.d.ts
+/**
+ * Validate and normalize a config
+ */
+declare function defineConfig(rawConfig: Config, {
+  logger,
+  cwd
+}?: ConfigOptions): ConfigInit;
+/** Merge configs */
+declare function mergeConfigs(a: Config, b: Config): Config;
+//# sourceMappingURL=config.d.ts.map
+//#endregion
+//#region src/lint/index.d.ts
+interface LintRunnerOptions {
+  tokens: Record<string, TokenNormalized$1>;
+  filename?: URL;
+  config: ConfigInit;
+  src: string;
+  logger: Logger;
+}
+declare function lintRunner({
+  tokens,
+  filename,
+  config,
+  src,
+  logger
+}: LintRunnerOptions): Promise<void>;
+//# sourceMappingURL=index.d.ts.map
+//#endregion
+//#region src/parse/normalize.d.ts
+declare const FONT_WEIGHT_MAP: {
+  thin: number;
+  hairline: number;
+  'extra-light': number;
+  'ultra-light': number;
+  light: number;
+  normal: number;
+  regular: number;
+  book: number;
+  medium: number;
+  'semi-bold': number;
+  'demi-bold': number;
+  bold: number;
+  'extra-bold': number;
+  'ultra-bold': number;
+  black: number;
+  heavy: number;
+  'extra-black': number;
+  'ultra-black': number;
+};
+/** Fill in defaults, and return predictable shapes for tokens */
+declare function normalizeValue<T extends Token$1>(token: T): T['$value'];
+//# sourceMappingURL=normalize.d.ts.map
+//#endregion
+//#region src/parse/validate.d.ts
+interface ValidateOptions {
+  filename?: URL;
+  src: string;
+  logger: Logger;
+}
+interface Visitors {
+  color?: Visitor;
+  dimension?: Visitor;
+  fontFamily?: Visitor;
+  fontWeight?: Visitor;
+  duration?: Visitor;
+  cubicBezier?: Visitor;
+  number?: Visitor;
+  link?: Visitor;
+  boolean?: Visitor;
+  strokeStyle?: Visitor;
+  border?: Visitor;
+  transition?: Visitor;
+  shadow?: Visitor;
+  gradient?: Visitor;
+  typography?: Visitor;
+  root?: Visitor;
+  group?: Visitor;
+  [key: string]: Visitor | undefined;
+}
+type Visitor = (json: any, path: string, ast: AnyNode) => any | undefined | null;
+declare const VALID_COLORSPACES: Set<string>;
+declare const FONT_WEIGHT_VALUES: Set<string>;
+declare const STROKE_STYLE_VALUES: Set<string>;
+declare const STROKE_STYLE_LINE_CAP_VALUES: Set<string>;
+/** Verify an Alias $value is formatted correctly */
+declare function validateAliasSyntax($value: ValueNode, _node: AnyNode, {
+  filename,
+  src,
+  logger
+}: ValidateOptions): void;
+/** Verify a Border token is valid */
+declare function validateBorder($value: ValueNode, node: AnyNode, {
+  filename,
+  src,
+  logger
+}: ValidateOptions): void;
+/** Verify a Color token is valid */
+declare function validateColor($value: ValueNode, node: AnyNode, {
+  filename,
+  src,
+  logger
+}: ValidateOptions): void;
+/** Verify a Cubic Bézier token is valid */
+declare function validateCubicBezier($value: ValueNode, _node: AnyNode, {
+  filename,
+  src,
+  logger
+}: ValidateOptions): void;
+/** Verify a Dimension token is valid */
+declare function validateDimension($value: ValueNode, _node: AnyNode, {
+  filename,
+  src,
+  logger
+}: ValidateOptions): void;
+/** Verify a Duration token is valid */
+declare function validateDuration($value: ValueNode, _node: AnyNode, {
+  filename,
+  src,
+  logger
+}: ValidateOptions): void;
+/**  Verify a Font Family token is valid */
+declare function validateFontFamily($value: ValueNode, _node: AnyNode, {
+  filename,
+  src,
+  logger
+}: ValidateOptions): void;
+/** Verify a Font Weight token is valid */
+declare function validateFontWeight($value: ValueNode, _node: AnyNode, {
+  filename,
+  src,
+  logger
+}: ValidateOptions): void;
+/** Verify a Gradient token is valid */
+declare function validateGradient($value: ValueNode, _node: AnyNode, {
+  filename,
+  src,
+  logger
+}: ValidateOptions): void;
+/** Verify a Number token is valid */
+declare function validateNumber($value: ValueNode, _node: AnyNode, {
+  filename,
+  src,
+  logger
+}: ValidateOptions): void;
+/** Verify a Boolean token is valid */
+declare function validateBoolean($value: ValueNode, _node: AnyNode, {
+  filename,
+  src,
+  logger
+}: ValidateOptions): void;
+/** Verify a Shadow token’s value is valid */
+declare function validateShadowLayer($value: ValueNode, node: AnyNode, {
+  filename,
+  src,
+  logger
+}: ValidateOptions): void;
+/** Verify a Stroke Style token is valid. */
+declare function validateStrokeStyle($value: ValueNode, node: AnyNode, {
+  filename,
+  src,
+  logger
+}: ValidateOptions): void;
+/** Verify a Transition token is valid */
+declare function validateTransition($value: ValueNode, node: AnyNode, {
+  filename,
+  src,
+  logger
+}: ValidateOptions): void;
+/**
+ * Validate a MemberNode (the entire token object, plus its key in the parent
+ * object) to see if it’s a valid DTCG token or not. Keeping the parent key
+ * really helps in debug messages.
+ */
+declare function validateTokenMemberNode(node: MemberNode, {
+  filename,
+  src,
+  logger
+}: ValidateOptions): void;
+/** Return any token node with its inherited $type */
+declare function getInheritedType(node: MemberNode, {
+  subpath,
+  $typeInheritance
+}: {
+  subpath: string[];
+  $typeInheritance?: Record<string, MemberNode>;
+}): MemberNode | undefined;
+interface ValidateTokenNodeOptions {
+  subpath: string[];
+  src: string;
+  filename: URL;
+  config: ConfigInit;
+  logger: Logger;
+  parent: AnyNode | undefined;
+  transform?: Visitors;
+  inheritedTypeNode?: MemberNode;
+}
+/**
+ * Validate does a little more than validate; it also converts to TokenNormalized
+ * and sets up the basic data structure. But aliases are unresolved, and we need
+ * a 2nd normalization pass afterward.
+ */
+declare function validateTokenNode(node: MemberNode, {
+  config,
+  filename,
+  logger,
+  parent,
+  inheritedTypeNode,
+  src,
+  subpath
+}: ValidateTokenNodeOptions): TokenNormalized$1 | undefined;
+//# sourceMappingURL=validate.d.ts.map
+//#endregion
+//#region src/parse/alias.d.ts
+interface ApplyAliasOptions {
+  tokensSet: TokenNormalizedSet$1;
+  filename: URL;
+  src: string;
+  node: ObjectNode;
+  logger: Logger;
+}
+type PreAliased<T extends TokenNormalized$1> = {
+  $value: T['$value'] | string;
+  mode: Record<string, T['mode'][string] & {
+    $value: T['$value'] | string;
+  }>;
+};
+/**
+ * Resolve aliases and update the token nodes.
+ *
+ * Data structures are in an awkward in-between phase, where they have
+ * placeholders for data but we still need to resolve everything. As such,
+ * TypeScript will raise errors expecting the final shape.
+ *
+ * This is also a bit tricky because different token types alias slightly
+ * differently. For example, color tokens and other “primitive” tokens behave
+ * as-expected. But composite tokens like Typography, Gradient, Border, etc. can
+ * either fully- or partially-alias their values. Then we add modes to the mix,
+ * and we have to do the work all over again for each mode declared.
+ *
+ * All that to say, there are a generous amount of TypeScript overrides here rather
+ * than try to codify indeterminate shapes.
+ */
+//#endregion
+//#region src/parse/json.d.ts
+interface JSONVisitor {
+  enter?: (node: AnyNode, parent: AnyNode | undefined, path: string[]) => void;
+  exit?: (node: AnyNode, parent: AnyNode | undefined, path: string[]) => void;
+}
+declare const CHILD_KEYS: {
+  Document: readonly ["body"];
+  Object: readonly ["members"];
+  Member: readonly ["name", "value"];
+  Element: readonly ["value"];
+  Array: readonly ["elements"];
+  String: readonly [];
+  Number: readonly [];
+  Boolean: readonly [];
+  Null: readonly [];
+  Identifier: readonly [];
+  NaN: readonly [];
+  Infinity: readonly [];
+};
+/** Determines if a given value is an AST node. */
+declare function isNode(value: unknown): boolean;
+type ValueNodeWithIndex = ValueNode & {
+  index: number;
+};
+/** Get ObjectNode members as object */
+declare function getObjMembers(node: ObjectNode): Record<string | number, ValueNodeWithIndex>;
+/** Inject members to ObjectNode */
+declare function injectObjMembers(node: ObjectNode, members?: MemberNode[]): void;
+/** Replace an ObjectNode’s contents outright with another */
+declare function replaceObjMembers(a: ObjectNode, b: DocumentNode | ObjectNode): void;
+/**
+ * Variation of Momoa’s traverse(), which keeps track of global path.
+ * Allows mutation of AST (along with any consequences)
+ */
+declare function traverse(root: AnyNode, visitor: JSONVisitor): void;
+/** Determine if an input is likely a JSON string */
+declare function maybeRawJSON(input: string): boolean;
+/** Find Momoa node by traversing paths */
+declare function findNode<T = AnyNode>(node: AnyNode, path: string[]): T | undefined;
+interface ToMomoaOptions {
+  filename?: URL;
+  continueOnError?: boolean;
+  logger: Logger;
+  yamlToMomoa?: typeof ytm;
+}
+declare function toMomoa(input: string | Record<string, any>, {
+  continueOnError,
+  filename,
+  logger,
+  yamlToMomoa: ytm
+}: ToMomoaOptions): InputSource;
+/** Momoa, just with default options pre-set */
+declare function parseJSON(input: string | Record<string, any>, options?: ParseOptions$1): any;
+//# sourceMappingURL=json.d.ts.map
+//#endregion
+//#region src/parse/index.d.ts
+interface ParseOptions {
+  logger?: Logger;
+  config: ConfigInit;
+  /**
+   * Skip lint step
+   * @default false
+   */
+  skipLint?: boolean;
+  /**
+   * Continue on error? (Useful for `tz check`)
+   * @default false
+   */
+  continueOnError?: boolean;
+  /** Provide yamlToMomoa module to parse YAML (by default, this isn’t shipped to cut down on package weight) */
+  yamlToMomoa?: typeof ytm;
+  /**
+   * Transform API
+   * @see https://terrazzo.app/docs/api/js#transform-api
+   */
+  transform?: Visitors;
+  /** (internal cache; do not use) */
+  _sources?: Record<string, InputSource>;
+}
+interface ParseResult {
+  tokens: Record<string, TokenNormalized$1>;
+  sources: InputSource[];
+}
+/** Parse */
+declare function parse(_input: Omit<InputSource, 'document'> | Omit<InputSource, 'document'>[], {
+  logger,
+  skipLint,
+  config,
+  continueOnError,
+  yamlToMomoa,
+  transform,
+  _sources
+}?: ParseOptions): Promise<ParseResult>;
+//# sourceMappingURL=index.d.ts.map
+
+//#endregion
+export { AliasToken, AliasValue, ApplyAliasOptions, BooleanToken, BooleanTokenNormalized, BooleanValue, BorderToken, BorderTokenNormalized, BorderValue, BorderValueNormalized, BuildEndHookOptions, BuildHookOptions, BuildRunnerOptions, BuildRunnerResult, CHILD_KEYS, ColorSpace, ColorToken, ColorTokenNormalized, ColorValue, ColorValueNormalized, Config, ConfigInit, ConfigOptions, CubicBezierToken, CubicBezierTokenNormalized, CubicBezierValue, CustomTransformOptions, DebugEntry, DimensionToken, DimensionTokenNormalized, DimensionValue, DurationToken, DurationTokenNormalized, DurationValue, FONT_WEIGHT_MAP, FONT_WEIGHT_VALUES, FontFamilyToken, FontFamilyTokenNormalized, FontFamilyValue, FontFamilyValueNormalized, FontWeightToken, FontWeightTokenNormalized, FontWeightValue, FontWeightValueNormalized, GradientStop, GradientStopNormalized, GradientToken, GradientTokenNormalized, GradientValue, GradientValueNormalized, Group, GroupCore, GroupOrToken, InputSource, JSONVisitor, LOG_ORDER, LinkToken, LinkTokenNormalized, LinkValue, LintNotice, LintReportDescriptor, LintRule, LintRuleContext, LintRuleLonghand, LintRuleMetaData, LintRuleMetaDataDocs, LintRuleNormalized, LintRuleSeverity, LintRuleShorthand, LintRunnerOptions, LogEntry, LogGroup, LogLevel, LogSeverity, Logger, MULTI_VALUE, ModeMap, NumberToken, NumberTokenNormalized, NumberValue, OutputFile, OutputFileExpanded, ParseOptions, ParseResult, Plugin, PreAliased, SINGLE_VALUE, STROKE_STYLE_LINE_CAP_VALUES, STROKE_STYLE_VALUES, ShadowToken, ShadowTokenNormalized, ShadowValue, ShadowValueNormalized, StringToken, StringTokenNormalized, StringValue, StrokeStyleToken, StrokeStyleTokenNormalized, StrokeStyleValue, StrokeStyleValueExpanded, ToMomoaOptions, Token, TokenCore, TokenMode, TokenNormalized, TokenNormalizedCore, TokenNormalizedSet, TokenTransformed, TokenTransformedMultiValue, TokenTransformedSingleValue, TokensJSONError, TokensSet, TransformHookOptions, TransformParams, TransitionToken, TransitionTokenNormalized, TransitionValue, TransitionValueNormalized, TypographyToken, TypographyTokenNormalized, TypographyValue, TypographyValueNormalized, VALID_COLORSPACES, ValidateOptions, ValidateTokenNodeOptions, ValueNodeWithIndex, Visitor, Visitors, build, defineConfig, findNode, formatMessage, getInheritedType, getObjMembers, injectObjMembers, isNode, lintRunner, maybeRawJSON, mergeConfigs, normalizeValue as normalize, parse, parseJSON, replaceObjMembers, toMomoa, traverse, validateAliasSyntax, validateBoolean, validateBorder, validateColor, validateCubicBezier, validateDimension, validateDuration, validateFontFamily, validateFontWeight, validateGradient, validateNumber, validateShadowLayer, validateStrokeStyle, validateTokenMemberNode, validateTokenNode, validateTransition };
 //# sourceMappingURL=index.d.ts.map