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

Elm bindings for Morphir

import * as Morphir_Dependency_DAG from "./../../morphir/dependency/dag";
import * as Morphir_IR_FQName from "./../../morphir/ir/fq-name";
import * as Morphir_IR_Name from "./../../morphir/ir/name";
import * as Morphir_IR_Package from "./../../morphir/ir/package";
import * as Morphir_IR_Path from "./../../morphir/ir/path";
import * as Morphir_IR_Type from "./../../morphir/ir/type";
export type Component = {
    name: ComponentName;
    inputs: Map<DataSourceName, DataType>;
    states: Map<DataSourceName, DataType>;
    outputs: Map<OutputName, Array<OutputSource>>;
};
export declare function decodeComponent(input: any): Component;
export declare function encodeComponent(value: Component): any;
export type ComponentName = Morphir_IR_Path.Path;
export declare function decodeComponentName(input: any): ComponentName;
export declare function encodeComponentName(value: ComponentName): any;
export type DataSourceName = Morphir_IR_Name.Name;
export declare function decodeDataSourceName(input: any): DataSourceName;
export declare function encodeDataSourceName(value: DataSourceName): any;
export type DataType = Literal | RowSet;
export declare function decodeDataType(input: any): DataType;
export declare function encodeDataType(value: DataType): any;
export declare class Literal {
    arg1: LiteralType;
    kind: "Literal";
    constructor(arg1: LiteralType);
}
export declare function decodeLiteral(input: any): Literal;
export declare function encodeLiteral(value: Literal): any;
export declare class RowSet {
    arg1: Morphir_IR_FQName.FQName;
    kind: "RowSet";
    constructor(arg1: Morphir_IR_FQName.FQName);
}
export declare function decodeRowSet(input: any): RowSet;
export declare function encodeRowSet(value: RowSet): any;
export type Error = BrokenFunctionReference | CyclicDependency | InputStateNameConflict | MissingPackage | MultiplePackageShareSameName | OutputSourceTypeMismatch | ParamNotSupplied | UnknownInputStateReference | UnusedInputOrState;
export declare function decodeError(input: any): Error;
export declare function encodeError(value: Error): any;
export declare class BrokenFunctionReference {
    arg1: Morphir_IR_FQName.FQName;
    kind: "BrokenFunctionReference";
    constructor(arg1: Morphir_IR_FQName.FQName);
}
export declare function decodeBrokenFunctionReference(input: any): BrokenFunctionReference;
export declare function encodeBrokenFunctionReference(value: BrokenFunctionReference): any;
export declare class CyclicDependency {
    arg1: Morphir_Dependency_DAG.CycleDetected<[
        NodeType,
        Morphir_IR_FQName.FQName
    ]>;
    kind: "CyclicDependency";
    constructor(arg1: Morphir_Dependency_DAG.CycleDetected<[
        NodeType,
        Morphir_IR_FQName.FQName
    ]>);
}
export declare function decodeCyclicDependency(input: any): CyclicDependency;
export declare function encodeCyclicDependency(value: CyclicDependency): any;
export declare class InputStateNameConflict {
    arg1: Array<DataSourceName>;
    kind: "InputStateNameConflict";
    constructor(arg1: Array<DataSourceName>);
}
export declare function decodeInputStateNameConflict(input: any): InputStateNameConflict;
export declare function encodeInputStateNameConflict(value: InputStateNameConflict): any;
export declare class MissingPackage {
    arg1: Morphir_IR_Package.PackageName;
    kind: "MissingPackage";
    constructor(arg1: Morphir_IR_Package.PackageName);
}
export declare function decodeMissingPackage(input: any): MissingPackage;
export declare function encodeMissingPackage(value: MissingPackage): any;
export declare class MultiplePackageShareSameName {
    arg1: number;
    arg2: Morphir_IR_Package.PackageName;
    kind: "MultiplePackageShareSameName";
    constructor(arg1: number, arg2: Morphir_IR_Package.PackageName);
}
export declare function decodeMultiplePackageShareSameName(input: any): MultiplePackageShareSameName;
export declare function encodeMultiplePackageShareSameName(value: MultiplePackageShareSameName): any;
export declare class OutputSourceTypeMismatch {
    arg1: OutputName;
    arg2: Morphir_IR_Type.Type<[]>;
    arg3: Morphir_IR_Type.Type<[]>;
    kind: "OutputSourceTypeMismatch";
    constructor(arg1: OutputName, arg2: Morphir_IR_Type.Type<[]>, arg3: Morphir_IR_Type.Type<[]>);
}
export declare function decodeOutputSourceTypeMismatch(input: any): OutputSourceTypeMismatch;
export declare function encodeOutputSourceTypeMismatch(value: OutputSourceTypeMismatch): any;
export declare class ParamNotSupplied {
    arg1: OutputName;
    arg2: number;
    arg3: Morphir_IR_FQName.FQName;
    arg4: ParameterName;
    kind: "ParamNotSupplied";
    constructor(arg1: OutputName, arg2: number, arg3: Morphir_IR_FQName.FQName, arg4: ParameterName);
}
export declare function decodeParamNotSupplied(input: any): ParamNotSupplied;
export declare function encodeParamNotSupplied(value: ParamNotSupplied): any;
export declare class UnknownInputStateReference {
    arg1: OutputName;
    arg2: Array<DataSourceName>;
    kind: "UnknownInputStateReference";
    constructor(arg1: OutputName, arg2: Array<DataSourceName>);
}
export declare function decodeUnknownInputStateReference(input: any): UnknownInputStateReference;
export declare function encodeUnknownInputStateReference(value: UnknownInputStateReference): any;
export declare class UnusedInputOrState {
    arg1: DataSourceName;
    kind: "UnusedInputOrState";
    constructor(arg1: DataSourceName);
}
export declare function decodeUnusedInputOrState(input: any): UnusedInputOrState;
export declare function encodeUnusedInputOrState(value: UnusedInputOrState): any;
export type LiteralType = BoolLiteral | DecimalLiteral | FloatLiteral | LocalDateLiteral | LocalTimeLiteral | StringLiteral | WholeNumberLiteral;
export declare function decodeLiteralType(input: any): LiteralType;
export declare function encodeLiteralType(value: LiteralType): any;
export declare class BoolLiteral {
    kind: "BoolLiteral";
    constructor();
}
export declare function decodeBoolLiteral(input: any): BoolLiteral;
export declare function encodeBoolLiteral(value: BoolLiteral): any;
export declare class DecimalLiteral {
    kind: "DecimalLiteral";
    constructor();
}
export declare function decodeDecimalLiteral(input: any): DecimalLiteral;
export declare function encodeDecimalLiteral(value: DecimalLiteral): any;
export declare class FloatLiteral {
    kind: "FloatLiteral";
    constructor();
}
export declare function decodeFloatLiteral(input: any): FloatLiteral;
export declare function encodeFloatLiteral(value: FloatLiteral): any;
export declare class LocalDateLiteral {
    kind: "LocalDateLiteral";
    constructor();
}
export declare function decodeLocalDateLiteral(input: any): LocalDateLiteral;
export declare function encodeLocalDateLiteral(value: LocalDateLiteral): any;
export declare class LocalTimeLiteral {
    kind: "LocalTimeLiteral";
    constructor();
}
export declare function decodeLocalTimeLiteral(input: any): LocalTimeLiteral;
export declare function encodeLocalTimeLiteral(value: LocalTimeLiteral): any;
export declare class StringLiteral {
    kind: "StringLiteral";
    constructor();
}
export declare function decodeStringLiteral(input: any): StringLiteral;
export declare function encodeStringLiteral(value: StringLiteral): any;
export declare class WholeNumberLiteral {
    kind: "WholeNumberLiteral";
    constructor();
}
export declare function decodeWholeNumberLiteral(input: any): WholeNumberLiteral;
export declare function encodeWholeNumberLiteral(value: WholeNumberLiteral): any;
type NodeType = string;
export type OutputName = Morphir_IR_Name.Name;
export declare function decodeOutputName(input: any): OutputName;
export declare function encodeOutputName(value: OutputName): any;
export type OutputSource = {
    functionReference: Morphir_IR_FQName.FQName;
    arguments: Map<ParameterName, DataSourceName>;
};
export declare function decodeOutputSource(input: any): OutputSource;
export declare function encodeOutputSource(value: OutputSource): any;
export type ParameterName = Morphir_IR_Name.Name;
export declare function decodeParameterName(input: any): ParameterName;
export declare function encodeParameterName(value: ParameterName): any;
declare const _default: {};
export default _default;