morphir-elm/morphir-ts/dist/generated/morphir/ir/value.d.ts

Elm bindings for Morphir

import * as Morphir_IR_FQName from "./../../morphir/ir/fq-name";
import * as Morphir_IR_Literal from "./../../morphir/ir/literal";
import * as Morphir_IR_Name from "./../../morphir/ir/name";
import * as Morphir_IR_Type from "./../../morphir/ir/type";
export type Definition<Ta, Va> = {
    inputTypes: Array<[Morphir_IR_Name.Name, Va, Morphir_IR_Type.Type<Ta>]>;
    outputType: Morphir_IR_Type.Type<Ta>;
    body: Value<Ta, Va>;
};
export declare function decodeDefinition<Ta, Va>(decodeTa: (input: any) => Ta, decodeVa: (input: any) => Va, input: any): Definition<Ta, Va>;
export declare function encodeDefinition<Ta, Va>(encodeTa: (value: Ta) => any, encodeVa: (value: Va) => any, value: Definition<Ta, Va>): any;
export type Pattern<A> = AsPattern<A> | ConstructorPattern<A> | EmptyListPattern<A> | HeadTailPattern<A> | LiteralPattern<A> | TuplePattern<A> | UnitPattern<A> | WildcardPattern<A>;
export declare function decodePattern<A>(decodeA: (input: any) => A, input: any): Pattern<A>;
export declare function encodePattern<A>(encodeA: (value: A) => any, value: Pattern<A>): any;
export declare class AsPattern<A> {
    attrs: A;
    pattern: Pattern<A>;
    name: Morphir_IR_Name.Name;
    kind: "AsPattern";
    constructor(attrs: A, pattern: Pattern<A>, name: Morphir_IR_Name.Name);
}
export declare function decodeAsPattern<A>(decodeA: (input: any) => A, input: any): AsPattern<A>;
export declare function encodeAsPattern<A>(encodeA: (value: A) => any, value: AsPattern<A>): any;
export declare class ConstructorPattern<A> {
    attrs: A;
    constructorName: Morphir_IR_FQName.FQName;
    argumentPatterns: Array<Pattern<A>>;
    kind: "ConstructorPattern";
    constructor(attrs: A, constructorName: Morphir_IR_FQName.FQName, argumentPatterns: Array<Pattern<A>>);
}
export declare function decodeConstructorPattern<A>(decodeA: (input: any) => A, input: any): ConstructorPattern<A>;
export declare function encodeConstructorPattern<A>(encodeA: (value: A) => any, value: ConstructorPattern<A>): any;
export declare class EmptyListPattern<A> {
    attrs: A;
    kind: "EmptyListPattern";
    constructor(attrs: A);
}
export declare function decodeEmptyListPattern<A>(decodeA: (input: any) => A, input: any): EmptyListPattern<A>;
export declare function encodeEmptyListPattern<A>(encodeA: (value: A) => any, value: EmptyListPattern<A>): any;
export declare class HeadTailPattern<A> {
    attrs: A;
    headPattern: Pattern<A>;
    tailPattern: Pattern<A>;
    kind: "HeadTailPattern";
    constructor(attrs: A, headPattern: Pattern<A>, tailPattern: Pattern<A>);
}
export declare function decodeHeadTailPattern<A>(decodeA: (input: any) => A, input: any): HeadTailPattern<A>;
export declare function encodeHeadTailPattern<A>(encodeA: (value: A) => any, value: HeadTailPattern<A>): any;
export declare class LiteralPattern<A> {
    attrs: A;
    value: Morphir_IR_Literal.Literal;
    kind: "LiteralPattern";
    constructor(attrs: A, value: Morphir_IR_Literal.Literal);
}
export declare function decodeLiteralPattern<A>(decodeA: (input: any) => A, input: any): LiteralPattern<A>;
export declare function encodeLiteralPattern<A>(encodeA: (value: A) => any, value: LiteralPattern<A>): any;
export declare class TuplePattern<A> {
    attrs: A;
    elementPatterns: Array<Pattern<A>>;
    kind: "TuplePattern";
    constructor(attrs: A, elementPatterns: Array<Pattern<A>>);
}
export declare function decodeTuplePattern<A>(decodeA: (input: any) => A, input: any): TuplePattern<A>;
export declare function encodeTuplePattern<A>(encodeA: (value: A) => any, value: TuplePattern<A>): any;
export declare class UnitPattern<A> {
    attrs: A;
    kind: "UnitPattern";
    constructor(attrs: A);
}
export declare function decodeUnitPattern<A>(decodeA: (input: any) => A, input: any): UnitPattern<A>;
export declare function encodeUnitPattern<A>(encodeA: (value: A) => any, value: UnitPattern<A>): any;
export declare class WildcardPattern<A> {
    attrs: A;
    kind: "WildcardPattern";
    constructor(attrs: A);
}
export declare function decodeWildcardPattern<A>(decodeA: (input: any) => A, input: any): WildcardPattern<A>;
export declare function encodeWildcardPattern<A>(encodeA: (value: A) => any, value: WildcardPattern<A>): any;
export type RawValue = Value<[], []>;
export declare function decodeRawValue(input: any): RawValue;
export declare function encodeRawValue(value: RawValue): any;
export type Specification<Ta> = {
    inputs: Array<[Morphir_IR_Name.Name, Morphir_IR_Type.Type<Ta>]>;
    output: Morphir_IR_Type.Type<Ta>;
};
export declare function decodeSpecification<Ta>(decodeTa: (input: any) => Ta, input: any): Specification<Ta>;
export declare function encodeSpecification<Ta>(encodeTa: (value: Ta) => any, value: Specification<Ta>): any;
export type TypedValue = Value<[], Morphir_IR_Type.Type<[]>>;
export declare function decodeTypedValue(input: any): TypedValue;
export declare function encodeTypedValue(value: TypedValue): any;
export type Value<Ta, Va> = Apply<Va, Ta> | Constructor<Va> | Destructure<Va, Ta> | Field<Va, Ta> | FieldFunction<Va> | IfThenElse<Va, Ta> | Lambda<Va, Ta> | LetDefinition<Va, Ta> | LetRecursion<Va, Ta> | List<Va, Ta> | Literal<Va> | PatternMatch<Va, Ta> | Record<Va, Ta> | Reference<Va> | Tuple<Va, Ta> | Unit<Va> | UpdateRecord<Va, Ta> | Variable<Va>;
export declare function decodeValue<Ta, Va>(decodeTa: (input: any) => Ta, decodeVa: (input: any) => Va, input: any): Value<Ta, Va>;
export declare function encodeValue<Ta, Va>(encodeTa: (value: Ta) => any, encodeVa: (value: Va) => any, value: Value<Ta, Va>): any;
export declare class Apply<Va, Ta> {
    attrs: Va;
    func: Value<Ta, Va>;
    argument: Value<Ta, Va>;
    kind: "Apply";
    constructor(attrs: Va, func: Value<Ta, Va>, argument: Value<Ta, Va>);
}
export declare function decodeApply<Va, Ta>(decodeVa: (input: any) => Va, decodeTa: (input: any) => Ta, input: any): Apply<Va, Ta>;
export declare function encodeApply<Va, Ta>(encodeVa: (value: Va) => any, encodeTa: (value: Ta) => any, value: Apply<Va, Ta>): any;
export declare class Constructor<Va> {
    attrs: Va;
    fullyQualifiedName: Morphir_IR_FQName.FQName;
    kind: "Constructor";
    constructor(attrs: Va, fullyQualifiedName: Morphir_IR_FQName.FQName);
}
export declare function decodeConstructor<Va>(decodeVa: (input: any) => Va, input: any): Constructor<Va>;
export declare function encodeConstructor<Va>(encodeVa: (value: Va) => any, value: Constructor<Va>): any;
export declare class Destructure<Va, Ta> {
    attrs: Va;
    pattern: Pattern<Va>;
    valueToDestruct: Value<Ta, Va>;
    inValue: Value<Ta, Va>;
    kind: "Destructure";
    constructor(attrs: Va, pattern: Pattern<Va>, valueToDestruct: Value<Ta, Va>, inValue: Value<Ta, Va>);
}
export declare function decodeDestructure<Va, Ta>(decodeVa: (input: any) => Va, decodeTa: (input: any) => Ta, input: any): Destructure<Va, Ta>;
export declare function encodeDestructure<Va, Ta>(encodeVa: (value: Va) => any, encodeTa: (value: Ta) => any, value: Destructure<Va, Ta>): any;
export declare class Field<Va, Ta> {
    attrs: Va;
    subjectValue: Value<Ta, Va>;
    fieldName: Morphir_IR_Name.Name;
    kind: "Field";
    constructor(attrs: Va, subjectValue: Value<Ta, Va>, fieldName: Morphir_IR_Name.Name);
}
export declare function decodeField<Va, Ta>(decodeVa: (input: any) => Va, decodeTa: (input: any) => Ta, input: any): Field<Va, Ta>;
export declare function encodeField<Va, Ta>(encodeVa: (value: Va) => any, encodeTa: (value: Ta) => any, value: Field<Va, Ta>): any;
export declare class FieldFunction<Va> {
    attrs: Va;
    fieldName: Morphir_IR_Name.Name;
    kind: "FieldFunction";
    constructor(attrs: Va, fieldName: Morphir_IR_Name.Name);
}
export declare function decodeFieldFunction<Va>(decodeVa: (input: any) => Va, input: any): FieldFunction<Va>;
export declare function encodeFieldFunction<Va>(encodeVa: (value: Va) => any, value: FieldFunction<Va>): any;
export declare class IfThenElse<Va, Ta> {
    attrs: Va;
    condition: Value<Ta, Va>;
    thenBranch: Value<Ta, Va>;
    elseBranch: Value<Ta, Va>;
    kind: "IfThenElse";
    constructor(attrs: Va, condition: Value<Ta, Va>, thenBranch: Value<Ta, Va>, elseBranch: Value<Ta, Va>);
}
export declare function decodeIfThenElse<Va, Ta>(decodeVa: (input: any) => Va, decodeTa: (input: any) => Ta, input: any): IfThenElse<Va, Ta>;
export declare function encodeIfThenElse<Va, Ta>(encodeVa: (value: Va) => any, encodeTa: (value: Ta) => any, value: IfThenElse<Va, Ta>): any;
export declare class Lambda<Va, Ta> {
    attrs: Va;
    argumentPattern: Pattern<Va>;
    body: Value<Ta, Va>;
    kind: "Lambda";
    constructor(attrs: Va, argumentPattern: Pattern<Va>, body: Value<Ta, Va>);
}
export declare function decodeLambda<Va, Ta>(decodeVa: (input: any) => Va, decodeTa: (input: any) => Ta, input: any): Lambda<Va, Ta>;
export declare function encodeLambda<Va, Ta>(encodeVa: (value: Va) => any, encodeTa: (value: Ta) => any, value: Lambda<Va, Ta>): any;
export declare class LetDefinition<Va, Ta> {
    attrs: Va;
    valueName: Morphir_IR_Name.Name;
    valueDefinition: Definition<Ta, Va>;
    inValue: Value<Ta, Va>;
    kind: "LetDefinition";
    constructor(attrs: Va, valueName: Morphir_IR_Name.Name, valueDefinition: Definition<Ta, Va>, inValue: Value<Ta, Va>);
}
export declare function decodeLetDefinition<Va, Ta>(decodeVa: (input: any) => Va, decodeTa: (input: any) => Ta, input: any): LetDefinition<Va, Ta>;
export declare function encodeLetDefinition<Va, Ta>(encodeVa: (value: Va) => any, encodeTa: (value: Ta) => any, value: LetDefinition<Va, Ta>): any;
export declare class LetRecursion<Va, Ta> {
    attrs: Va;
    valueDefinitions: Map<Morphir_IR_Name.Name, Definition<Ta, Va>>;
    inValue: Value<Ta, Va>;
    kind: "LetRecursion";
    constructor(attrs: Va, valueDefinitions: Map<Morphir_IR_Name.Name, Definition<Ta, Va>>, inValue: Value<Ta, Va>);
}
export declare function decodeLetRecursion<Va, Ta>(decodeVa: (input: any) => Va, decodeTa: (input: any) => Ta, input: any): LetRecursion<Va, Ta>;
export declare function encodeLetRecursion<Va, Ta>(encodeVa: (value: Va) => any, encodeTa: (value: Ta) => any, value: LetRecursion<Va, Ta>): any;
export declare class List<Va, Ta> {
    attrs: Va;
    items: Array<Value<Ta, Va>>;
    kind: "List";
    constructor(attrs: Va, items: Array<Value<Ta, Va>>);
}
export declare function decodeList<Va, Ta>(decodeVa: (input: any) => Va, decodeTa: (input: any) => Ta, input: any): List<Va, Ta>;
export declare function encodeList<Va, Ta>(encodeVa: (value: Va) => any, encodeTa: (value: Ta) => any, value: List<Va, Ta>): any;
export declare class Literal<Va> {
    attrs: Va;
    value: Morphir_IR_Literal.Literal;
    kind: "Literal";
    constructor(attrs: Va, value: Morphir_IR_Literal.Literal);
}
export declare function decodeLiteral<Va>(decodeVa: (input: any) => Va, input: any): Literal<Va>;
export declare function encodeLiteral<Va>(encodeVa: (value: Va) => any, value: Literal<Va>): any;
export declare class PatternMatch<Va, Ta> {
    attrs: Va;
    branchOutOn: Value<Ta, Va>;
    cases: Array<[Pattern<Va>, Value<Ta, Va>]>;
    kind: "PatternMatch";
    constructor(attrs: Va, branchOutOn: Value<Ta, Va>, cases: Array<[Pattern<Va>, Value<Ta, Va>]>);
}
export declare function decodePatternMatch<Va, Ta>(decodeVa: (input: any) => Va, decodeTa: (input: any) => Ta, input: any): PatternMatch<Va, Ta>;
export declare function encodePatternMatch<Va, Ta>(encodeVa: (value: Va) => any, encodeTa: (value: Ta) => any, value: PatternMatch<Va, Ta>): any;
export declare class Record<Va, Ta> {
    attrs: Va;
    fields: Map<Morphir_IR_Name.Name, Value<Ta, Va>>;
    kind: "Record";
    constructor(attrs: Va, fields: Map<Morphir_IR_Name.Name, Value<Ta, Va>>);
}
export declare function decodeRecord<Va, Ta>(decodeVa: (input: any) => Va, decodeTa: (input: any) => Ta, input: any): Record<Va, Ta>;
export declare function encodeRecord<Va, Ta>(encodeVa: (value: Va) => any, encodeTa: (value: Ta) => any, value: Record<Va, Ta>): any;
export declare class Reference<Va> {
    attrs: Va;
    fullyQualifiedName: Morphir_IR_FQName.FQName;
    kind: "Reference";
    constructor(attrs: Va, fullyQualifiedName: Morphir_IR_FQName.FQName);
}
export declare function decodeReference<Va>(decodeVa: (input: any) => Va, input: any): Reference<Va>;
export declare function encodeReference<Va>(encodeVa: (value: Va) => any, value: Reference<Va>): any;
export declare class Tuple<Va, Ta> {
    attrs: Va;
    elements: Array<Value<Ta, Va>>;
    kind: "Tuple";
    constructor(attrs: Va, elements: Array<Value<Ta, Va>>);
}
export declare function decodeTuple<Va, Ta>(decodeVa: (input: any) => Va, decodeTa: (input: any) => Ta, input: any): Tuple<Va, Ta>;
export declare function encodeTuple<Va, Ta>(encodeVa: (value: Va) => any, encodeTa: (value: Ta) => any, value: Tuple<Va, Ta>): any;
export declare class Unit<Va> {
    attrs: Va;
    kind: "Unit";
    constructor(attrs: Va);
}
export declare function decodeUnit<Va>(decodeVa: (input: any) => Va, input: any): Unit<Va>;
export declare function encodeUnit<Va>(encodeVa: (value: Va) => any, value: Unit<Va>): any;
export declare class UpdateRecord<Va, Ta> {
    attrs: Va;
    valueToUpdate: Value<Ta, Va>;
    fieldsToUpdate: Map<Morphir_IR_Name.Name, Value<Ta, Va>>;
    kind: "UpdateRecord";
    constructor(attrs: Va, valueToUpdate: Value<Ta, Va>, fieldsToUpdate: Map<Morphir_IR_Name.Name, Value<Ta, Va>>);
}
export declare function decodeUpdateRecord<Va, Ta>(decodeVa: (input: any) => Va, decodeTa: (input: any) => Ta, input: any): UpdateRecord<Va, Ta>;
export declare function encodeUpdateRecord<Va, Ta>(encodeVa: (value: Va) => any, encodeTa: (value: Ta) => any, value: UpdateRecord<Va, Ta>): any;
export declare class Variable<Va> {
    attrs: Va;
    name: Morphir_IR_Name.Name;
    kind: "Variable";
    constructor(attrs: Va, name: Morphir_IR_Name.Name);
}
export declare function decodeVariable<Va>(decodeVa: (input: any) => Va, input: any): Variable<Va>;
export declare function encodeVariable<Va>(encodeVa: (value: Va) => any, value: Variable<Va>): any;
declare const _default: {};
export default _default;