@glimmer/syntax/dist/dev/lib/v2/objects/expr.d.ts

import type { PresentArray } from '@glimmer/interfaces';
import type { CallFields } from './base';
import type { VariableReference } from './refs';
import { SourceSlice } from '../../source/slice';
/**
 * A Handlebars literal.
 *
 * {@link https://handlebarsjs.com/guide/expressions.html#literal-segments}
 */
export type LiteralValue = string | boolean | number | undefined | null;
export interface LiteralTypes {
    string: string;
    boolean: boolean;
    number: number;
    null: null;
    undefined: undefined;
}
declare const LiteralExpression_base: import("./node").TypedNodeConstructor<"Literal", {
    value: LiteralValue;
} & import("./node").BaseNodeFields>;
/**
 * Corresponds to a Handlebars literal.
 *
 * @see {LiteralValue}
 */
export declare class LiteralExpression extends LiteralExpression_base {
    toSlice(this: StringLiteral): SourceSlice;
}
export type StringLiteral = LiteralExpression & {
    value: string;
};
/**
 * Returns true if an input {@see ExpressionNode} is a literal.
 */
export declare function isLiteral<K extends keyof LiteralTypes = keyof LiteralTypes>(node: ExpressionNode, kind?: K): node is StringLiteral;
declare const PathExpression_base: import("./node").TypedNodeConstructor<"Path", {
    ref: VariableReference;
    tail: readonly SourceSlice[];
} & import("./node").BaseNodeFields>;
/**
 * Corresponds to a path in expression position.
 *
 * ```hbs
 * this
 * this.x
 * @x
 * @x.y
 * x
 * x.y
 * ```
 */
export declare class PathExpression extends PathExpression_base {
}
declare const KeywordExpression_base: import("./node").TypedNodeConstructor<"Keyword", {
    name: string;
    symbol: number;
} & import("./node").BaseNodeFields>;
/**
 * Corresponds to a known strict-mode keyword. It behaves similarly to a
 * PathExpression with a FreeVarReference, but implies StrictResolution and
 * is guaranteed to not have a tail, since `{{outlet.foo}}` would have been
 * illegal.
 */
export declare class KeywordExpression extends KeywordExpression_base {
}
declare const CallExpression_base: import("./node").TypedNodeConstructor<"Call", CallFields & import("./node").BaseNodeFields>;
/**
 * Corresponds to a parenthesized call expression.
 *
 * ```hbs
 * (x)
 * (x.y)
 * (x y)
 * (x.y z)
 * ```
 */
export declare class CallExpression extends CallExpression_base {
}
declare const InterpolateExpression_base: import("./node").TypedNodeConstructor<"Interpolate", {
    parts: PresentArray<ExpressionNode>;
} & import("./node").BaseNodeFields>;
/**
 * Corresponds to an interpolation in attribute value position.
 *
 * ```hbs
 * <a href="{{url}}.html"
 * ```
 */
export declare class InterpolateExpression extends InterpolateExpression_base {
}
export type ExpressionNode = LiteralExpression | PathExpression | KeywordExpression | CallExpression | InterpolateExpression;
export {};