import { Token, Items, TokenBase, Pattern } from '../syntax/index.js';
export type Expr = Items;
export type Statement = Items;
export type Identifier = Token;
export type Type = Items;
export type Binder = {
    id: Identifier;
    type?: Type;
};
export interface TurnAction {
}
export interface FacetSetupAction extends TurnAction {
    body: Statement;
}
export interface SpawnStatement extends FacetSetupAction {
    name?: Expr;
    linkedToken: TokenBase | null;
    parentBinders: Binder[];
    parentInits: Expr[];
}
export interface FieldDeclarationStatement extends TurnAction {
    field: Binder;
    init?: Expr;
}
export interface AssertionEndpointStatement extends TurnAction {
    isDynamic: boolean;
    template: Expr;
    test?: Expr;
}
export interface StatementTurnAction extends TurnAction {
    body: Statement;
}
export type FacetToStop = 'default' | Expr;
export interface StopStatement extends StatementTurnAction {
    facetToStop: FacetToStop;
}
export interface SyncStatement extends StatementTurnAction {
    peerToSyncWith: Expr;
}
export interface GenericEventEndpointStatement extends StatementTurnAction {
    facetToStop: FacetToStop | 'none' | 'once-wrapper';
    once: boolean;
    isDynamic: boolean;
}
export interface DataflowEndpointStatement extends GenericEventEndpointStatement {
    triggerType: 'dataflow';
    predicate: Expr;
}
export interface PseudoEventEndpointStatement extends GenericEventEndpointStatement {
    triggerType: 'stop';
}
export interface AssertionEventEndpointStatement extends GenericEventEndpointStatement {
    triggerType: 'asserted' | 'retracted' | 'message';
    pattern: ValuePattern;
    test?: Expr;
}
export type EventHandlerEndpointStatement = DataflowEndpointStatement | PseudoEventEndpointStatement | AssertionEventEndpointStatement;
export interface TypeDefinitionStatement {
    expectedUse: 'message' | 'assertion';
    label: Identifier;
    fields: Binder[];
    wireName?: Expr;
}
export interface MessageSendStatement extends TurnAction {
    expr: Expr;
}
export interface DuringStatement extends FacetSetupAction {
    pattern: ValuePattern;
    test?: Expr;
}
export interface ReactStatement extends FacetSetupAction {
    label: Identifier | null;
}
export interface AtStatement {
    target: Expr;
    body: Statement;
}
export interface CreateExpression {
    entity: Expr;
}
export interface PCapture {
    type: 'PCapture';
    binder: Binder;
    inner: ValuePattern;
}
export interface PDiscard {
    type: 'PDiscard';
}
export interface PConstant {
    type: 'PConstant';
    value: Expr;
}
export interface PConstructor {
    type: 'PConstructor';
    ctor: Expr;
    arguments: ValuePattern[];
}
export interface PArray {
    type: 'PArray';
    elements: ValuePattern[];
}
export interface PDict {
    type: 'PDict';
    elements: [Expr, ValuePattern][];
}
export interface PUnquote {
    type: 'PUnquote';
    unquoted: ValuePattern;
}
export interface POuterUnquote {
    type: 'POuterUnquote';
    outer: Expr;
}
export interface PQuote {
    type: 'PQuote';
    quoted: ValuePattern;
}
export type ValuePattern = PCapture | PDiscard | PConstant | PConstructor | PArray | PDict | PUnquote | POuterUnquote | PQuote;
export interface StaticAnalysis {
    skeleton: Expr;
    captureBinders: Binder[];
}
export declare class SyndicateParser {
    block(acc?: Items): Pattern<Items>;
    readonly statementBoundary: Pattern<any>;
    readonly exprBoundary: Pattern<any>;
    readonly identifier: Pattern<Identifier>;
    binder(..._extraStops: Pattern<any>[]): Pattern<Binder>;
    readonly defaultBinder: Pattern<Binder>;
    expr(...extraStops: Pattern<any>[]): Pattern<Expr>;
    expr1(...extraStops: Pattern<any>[]): Pattern<Expr>;
    propertyNameExpr(): Pattern<Expr>;
    readonly type: (...extraStops: Pattern<any>[]) => Pattern<Type>;
    statement(acc: Items): Pattern<any>;
    turnAction<T extends TurnAction>(pattern: (scope: T) => Pattern<any>): Pattern<T>;
    readonly headerExpr: Pattern<Items>;
    readonly spawn: Pattern<SpawnStatement>;
    readonly fieldDeclarationStatement: Pattern<FieldDeclarationStatement>;
    readonly assertionEndpointStatement: Pattern<AssertionEndpointStatement>;
    blockTurnAction(kw: Pattern<any>): Pattern<StatementTurnAction>;
    readonly dataflowStatement: Pattern<StatementTurnAction>;
    mandatoryIfNotTerminal(o: GenericEventEndpointStatement, p: Pattern<any>): Pattern<any>;
    readonly eventHandlerEndpointStatement: Pattern<EventHandlerEndpointStatement>;
    readonly typeDefinitionStatement: Pattern<TypeDefinitionStatement>;
    readonly messageSendStatement: Pattern<MessageSendStatement>;
    readonly duringStatement: Pattern<DuringStatement>;
    readonly reactStatement: Pattern<ReactStatement>;
    readonly stopStatement: Pattern<StopStatement>;
    readonly syncStatement: Pattern<SyncStatement>;
    readonly atStatement: Pattern<AtStatement>;
    readonly createExpression: Pattern<CreateExpression>;
    pCaptureBinder: (b: Pattern<Binder>) => Pattern<Binder>;
    readonly pCaptureDefaultBinder: Pattern<Binder>;
    readonly pDiscard: Pattern<void>;
    pUnquote(level: number, extraStops: Pattern<any>[]): Pattern<PUnquote | POuterUnquote>;
    pQuote(level: number, extraStops: Pattern<any>[]): Pattern<PQuote>;
    hasCapturesOrDiscards(e: Expr): boolean;
    pArray(level: number): Pattern<PArray>;
    pDict(level: number): Pattern<PDict>;
    pConstructor(level: number, extraStops: Pattern<any>[]): Pattern<PConstructor>;
    valuePattern(level: number, ...extraStops: Pattern<any>[]): Pattern<ValuePattern>;
}
export declare class SyndicateTypedParser extends SyndicateParser {
    binder(...extraStops: Pattern<any>[]): Pattern<Binder>;
}
export declare function compilePattern(pattern: ValuePattern): StaticAnalysis;