@f1studio/form-spec 5.0.0-alpha.101

package/src/PathwayExecutor.ts.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../FormSpec.FS/PathwayExecutor.fs","./fable_modules/Thoth.Json.10.4.1/Encode.fs"],"names":["hash","fieldName","bytes","i","b","labelToFieldKey","field","step","formSpec","matchValue","fieldReference","generateFieldKey","pluginData","tupledArg","a","formData","evaluator","actualValue","expectedValue","outArg","minVal","maxVal","actual","v","values","actualParts","s","evaluateFieldCondition","actualFieldValue","expectedConditionValue","condition","fieldKey","conditionValue","fieldValues","evaluateFieldConditionWithConditionValue","stateVisited","visitedStates","logicalOp","conditions","results","evaluateTransitionWithPartialData","resolver","r","cond","result","optionKey","matrixItemKey","optionValueOpt","fieldType","opt","guid","actualValueStr","optionValue","actualValues","containsOption","propertyKey","stateKey","states","state","extractFieldValues","context","transitionsFromCurrentStates","isFromCurrentState","t","transition","status","transitions","mode","activeTransitions","m","totalConditions","p","matched","fields","findState","toStateStr","extractActionsFromState","evaluateAllTransitions","totalStates","isTerminalState","sk","categorizeTransitions","pathway","createResolver","initialStates","statesWithIncoming","candidates","valueSource","action","valueToSet","resolveFieldValueSource","targetFieldOpt","targetField","stepOpt","f","stepOrder","fieldAnswer","executeSetFieldValueAction","executeAction","currentData","actions","maxIterations","patternInput","pending","active","selectedTransitions","selectTransitionsByMode","newStates","newActions","updatedFormData","executeActions","newLogEntries","arg10","arg20","updatedContext","isExecutionComplete","previousTransitionKeys","newKeys","startingAtTerminal","newContext","executeStep","_arg1","predictOutcomes","calculateCompletionPercentage","completedTransitions","log","plan","stateKeyStr"],"mappings":";;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;AA2FYA,wBAAO,WAAAC;AACPC,0CAA\u002BB,QAAA;AACG;AAAwB,YAAG,AAAAC,IAAI;AAAO,oBAAAD,OAAOC,GAAMC;;kBAAzF,cAA6BJ;AACe;AAAwB,YAAG,AAAAG,MAAI;AAAO,oBAAAD,OAAO,AAAAC,MAAI,GAAMC;;kBAAnG,cAA6B,AAAAJ,QAAS;AACM;AAAwB,YAAG,AAAAG,MAAI;AAAO,oBAAAD,OAAO,AAAAC,MAAI,GAAMC;;kBAAnG,cAA6B,AAAAJ,QAAS;AACM;AAAwB,YAAG,AAAAG,MAAI;AAAO,oBAAAD,OAAO,AAAAC,MAAI,IAAOC;;kBAApG,cAA6B,AAAAJ,QAAS;AACtC,WAAA,gCAAcE;;;;;;;AAKVG,gEAIG,gCADA,iIAAuB,AAAAC,wCAA8B,AAAAA,\u002BCADrD,gJAA0B,AAAAC,aAD7B,AAAAC;;;;AAQMC,oDAAA,iCADc,AAAAC,2CACYL;AAA1B,eAAA,CAAA,AAAAI,sBAEI,AAAAE,\u002BBAAiBD,0BADRD;;;;;;;;WAsChB,\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\u002BBADhC,CAAA,AAAAA,oCAEyB,AAAAA,\u002BBAFzB,CAAA,AAAAA,uCAG4B,AAAAA,\u002BBAH5B,CAAA,AAAAA,0CAI\u002BB,AAAAA,\u002BBAJ/B,CAAA,AAAAA,2CAKgC,AAAAA,8BAC/B;eAVZ,wFAA2B,OAAA,AAAA1C,gBAAiByB,aAD5C,gJAA0B,AAAAxB,aAD7B,QAAAC;iDAmBc,iCAAYuB,YAASE;AAArC,gBAAA,AAAAc;AAmCyBG,uCAAvB,AAAAL;AACJ,8BAA0B,KAAA,gGAA\u002BFK;;;iBApCvH,IAAA;gDA0CM,UADJ,AAAAnB;;;AAxCiBoB;AAAlBC,oDADDL;AAIEM,wDAGG,gBADA,6CAAoB,AAAA3B,8BADvByB,uBAAuB;;;AAKvBG,gDAAiB,iBADE,AAAAF,wCAC4BC;wBAK7CrC;;AACqB,4BAAGsC;;;;;;;AACA,4BAAG,CAAIA;;;;;;;AACP,4BAAGA;;;;;;;AACJ,4BAAG,CAAIA;;;;;;;AAUhC,4BAAG,AAAA3B,uBAAuBwB,kBAAenC,aAN/B,CAAA,AAAAgB,6CAEqD,KAAc,KAA5B,eAAN,AAAAA,gCAFjC,CAAA,AAAAA,2CAGiF,KAAc,KAA5C,mGAAe,AAAAnB,cAA7B,uCAAN,AAAAmB,iCAH/B,CAAA,AAAAA,iDAI6BpB,aAC/B,AAAAoB,4BC\u002BYK,SD/Y2B,GC\u002BY5C,AAzBA,6GDtX\u002BCpB,iBAJH,AAAAoB;;;;;;;;;;AAoBfuB,0DAG3B,AAAAzB;AAHiBC,gDAGjB,AAAAD;AAHwCd,uEAGxC,AAAAc;AAHmDE,mEAGnD,AAAAF;AAAArB,iDAAA,iCAAYsB,YAASE;AAArB,gBAAA,AAAAxB;gDAsCM,UADJ,AAAAsB;;;AApCDoB,yDAGH1C;AAAA;AACQmB,kGAA4C,uBACjCG,YACG,IACNoB;AAqBZ,2BAAA,AAAG,AAAAxB,uBAAuBwB,kBAAenC,aAT/B,CAAA,AAAAgB,6CAEqD,KAAc,KAA5B,eAAN,AAAAA,gCAFjC,CAAA,AAAAA,2CAGiF,KAAc,KAA5C,qGAAe,AAAAnB,gBAA7B,uCAAN,AAAAmB,iCAH/B,CAAA,AAAAA,iDAI6BpB,eAC/B,AAAAoB,4BCmWK,SDnW2B,GCmW5C,AAzBA,6GD1U\u002BCpB,mBAJH,AAAAoB;;;;;;;;;;;;;;;;WAyB1C,4FAAuB,OAAA,AAAAN,YAAa8B,WAA9CC;;;;;;;AAIMhD,yDAAA,AAAAiD;YAAAjD;;AACa,mBAAA,UAAA,AAAAA;;AACS,mBAAA,AAAAA;;AACPqB,0EACjB,AAAArB;AAAA,mBAAA,OAAA,UAAA,AAAAA,uBAA8B,qDAA9B,AAAAA;;;AACG,mBAAA;;;;;;;;AAID,QAAA,AAAAiD;eACU;;;eACT;;;;;;;;AAWHzB,4DAAc,AAAA0B,4CAAiC,AAAAC,uBAAsB,AAAAA;AAEzE,gBAAwB,KAAA,qDAAoD3B;AAC5E,gBAAwB,KAAA,wDAAuD,AAAA2B;AAC/E,gBAAwB,KAAA,yDAAwD,AAAAA;AAE5EC,2FAEG;AACKC,4CAAqB,0BAAa,AAAAC,aAAY,AAAAH;AAClD,oBAAwB,KAAA,6CAA4C,AAAAG,aAAa,MAAM,AAAAA,WAAW,qBAAqBD;eACvHA;OAJJ,AAAAF;AAOJ,gBAAwB,KAAA,8DAA6DC;AAGlF,WAAA;AACC,oBAAwB,KAAA,oDAAmD,AAAAG;AAC3E,oBAAwB,KAAA,mDAAkD,AAAAA;AAEtEC,gDAAS,AAAAzB,6CACG,AAAAoB,uBACM,AAAAA,kBACN3B,aACA,AAAA2B,uBACA,AAAAI;AAEhB,oBAAwB,KAAA,gDAA\u002BCC;AAEvE,eAAA,sBACiBD,YACqB,WAAvB,AAAAA,qBAA2C,MAC7CC;OAjBjBJ;;;;;;;YAuB4B,6DAAsB,OAAA,AAAAE,yCAArCG,cACgB;AAA4B,YAAA,AAAAH;mBAA2B;;;mBAAY;;OAAlFG,cACc,\u002BDAAsB,OAAA,AAAAH,wCAArCG;;;;;;;YAaPC;;AAuBI1D,6EAAA,AAAA0D;oBAAA1D;;2BAMF2D;;2BAGAA;;2BANAA;;;;mBAWJA;;AAlCM3D,yEAAA,AAAA0D;oBAAA1D;;AAWC,2BAAA,qCADA,2BADA,oEAAsB,AAAA4D,cADzBD;;;;AASG,2BAAA,qCADA,2BADA,oEAAsB,AAAAC,cADzBD;;;;AATG,2BAAA,qCADA,2BADA,kEAAsB,AAAAC,YADzBD;;;;;;;;;;;;YAwCFH;;mBAEM;;AAIR,mBAAA,CADqB,AAAMK,kBADR,OAAf,AAAAL,qBAEmBK;;mBALZ;;;;;;;;WA\u002BCZ,2BAAc,GADd,8EAAgC,AAAAC,eAlChC;AACO9D,oDAAA,AAAA\u002BD;gBAAA/D;;AAgBIgE,mDAEA,AAAAhE;AAAAA,8EAAA,AAAAiE,UAAU,AAAAF,4BAA2B,AAAAZ;AAArC,oBAAA,AAAAnD;AAWI,2BAAA;;;AARFkE,iDADA,AAAyB,AAAAH;AAExB,2BAAA,qBACWG,cACE,KACGF,QACC,AAAAG,gCANlBnE,gBAOckE;;;;AAId,uBAAA;;AA5BFlE,8EAAA,AAAAiE,UAAU,AAAAF,4BAA2B,AAAAZ;AAArC,oBAAA,AAAAnD;AAWI,2BAAA;;;AARFkE,\u002BCADA,AAAyB,AAAAH;AAExB,2BAAA,qBACWG,YACE,GACG,iBACC,AAAAC,gCANlBnE,gBAOckE;;;;OAhBT,AAAAE,kCAAuBjB;;;;;;;;;AA8CxCkB,iCAAc,OAAA,AAAAlB;AAGlB,QAAG,AAAAkB,gBAAc;eACb;;;AAEA,eAAA,CAAC,AALe,qBAAA,AAAAlB,yBAKCkB,eAAe;;;;;;;;AAcpC,QANO,wCAAYC,iBADZ,2HAAuB,AAAAL,UAAUM,IAAG,AAAApB,6BADpC,wBADH,AAAAA;eASJ;;SAAqB,IAFjB,QADI,AAAe,AAAAqB,sBAAsB,AAAArB;AAGD,eAAA,CAAI,uBAAA,AAAAA;;;eAA3B;;;;;;;;AAgBfnD,oEAAA,AAAAD;AAAA,QAAA,AAAAC;AA0DI,wBAAS;;;AAzDZyE,qEACCzE;AAAAgC,8DAAW,AAAA0C,wCAA6B3E;AAGxC4E;AACM3E,sDAAA,AAAAyE;AAAA,YAAA,AAAAzE;AAOE4E,mEAGG,0BADA,yHAAmB,AAAAtB,WADtB,AAAAmB;;;AAIAI,4DAGG,iHAAmB,AAAA5D,cADnB,yFAAsB,CAAK,0BAAa,AAAAA,YAAW2D,qBADtD,AAAAH;AAOJ,AArBJE,6BAqBI,AAAG,QAAAE,cAMI,WADA,2IAAqB,UAAC,AAAA5D,eADtB,yCADH,AAAAwD,kBAGuB,4BAEvBI;;;AAxBJ,AALJF,4BAKI,kBAAA3E;;AA0BR,eAAA,uBACkByE,SACH1E,UACK,0BAAW4E;;YACX,0BAAWA;;YACT;;YACE,4BACC,4BACH,4CACPrE,UACK0B,UAGT,2FACC,sBACgB,OACDe,UACF,eACC,oBANlB4B;;;;;;;;YAuBNG;;AAMC,mBAAA,WADA,iCADH,AAAAA,uBAAA,AAAA5B,4CAAkC,AAAAwB,wCAA6B3E,WAAUO,YAElD;;AACC8B,qDAExB,AAAA0C;AAgBG,mBAAA,WAdA;AACKvC,kCAAY,AAAA1C;AAWb,uBAAA,yEAAuB,AAAA2C,mBADvB,oEAAyB,OAAA,AAAAA,eAAgBJ,YARlC,CAAA,AAAAG,2CACgC,AAAAA,\u002BBADhC,CAAA,AAAAA,0CAE\u002BB,AAAAA,\u002BBAF/B,CAAA,AAAAA,2CAGgC,AAAAA,\u002BBAHhC,CAAA,AAAAA,uCAI4B,AAAAA,\u002BBAJ5B,CAAA,AAAAA,oCAKyB,AAAAA,8BACxB;eAVZ,gJAA0B,AAAAzC,aAD7B,AAAAC,kBAgBuB;;;AAxBa,mBAAA,AAAA\u002BE;;;;;;;;QAmC9B9E,gEACCqB,uDACCG,iDA6CQe;AArCpB,QAAG,GAVOvC,aAAA,AAAA\u002BE,kBAAA,CAAA,AAAA/E,sBAQI,SAPHqB,oBACCrB,cAAAwB,cAAc,AAAA0B,4CAAkC,AAAAwB,wCAA6B3E,WAAUO,WAGrF,AAAAyB,6CAFS,AAAA2C,wCAA6B3E,WAEWA,UAAUyB,aAD7C;;QACuEH;eAM/Ff;;;AAGI0E,mCAAa,AAAAC,mCAAwB,AAAAF,cAAahF,UAASO;AAG3D4E,oEAGG,wFAA2B,OAAA,AAAArF,gBAAiB,AAAAkF,qBAD5C,gJAA0B,AAAAjF,aAD7B,AAAAC;AAIE,YAAA,AAAAmF;mBA8DI5E;;;AA7DH6E,qEAECD;AAAAE,gEAEG,uFAAyC,iFAAsB,OAAA,AAAAC,YAAa,AAAAN,qBAAlD,AAAAjF,gBAD7B,AAAAC;AAGE,gBAAA,AAAAqF;uBAqDI9E;;;AAlDFgF,oDAAY,qBAAU,QAAtBF;AAOAG,wDAA2B,uBAChB,AAAAR,oBACG,AAAAI,mBACNH;AAsCZ,uBAAA,mCAAA,AAAA1E,gCAFyB,eAAA,AAAAA,sBAAyBgF,WAD1B,eAzCjB,WADA,wFAAAA,WADH,AAAAhF,uBAEuB;;qBAyCmB,AAAAyE,qBA9BtCxC,aAAY,AAAA4C,iDAoBhB,0BACiB,AAAAA,wBACP,AAAAJ,oBACE,AAAAI,4CAGuBI,cAFnB,AAAAJ,uBAZT,8FACC,uBAEkB,AAAA3C,iBACN,AAAAA,WAFI,AAAAA,iBAZd,CAAA,AAAAD,2CACgC,AAAAA,\u002BBADhC,CAAA,AAAAA,0CAE\u002BB,AAAAA,\u002BBAF/B,CAAA,AAAAA,2CAGgC,AAAAA,\u002BBAHhC,CAAA,AAAAA,uCAI4B,AAAAA,\u002BBAJ5B,CAAA,AAAAA,oCAKyB,AAAAA,8BACxB;;;;;;;;;;AAsCrB,QAAA,AAAAwC;AAEF,eAAA,AAAAS,sCAAA,AAAAT,kBAAqChF,UAASO;;;eAG9CA;;;;;;;;WAUD,qOACC,AAAAmF,yBAAcV,QAAOhF,UAAS2F,cAD/BpF,UADHqF;;;;;;;;;cAM6BxC,sDAAwCyC;AACrE,YAAG,AAAAA,iBAAiB;mBAChBzC;;;AAYI0C,gIAAqB,AAAArB,sBALJ,AAAAJ,kCAAuBjB;AAKhC2C,2DAAR,AAAAD;AAAAE,0DAAA,AAAAF;AAMAG,uEAAsB,AAAAC,wBAAwB,AAAA9C,mCAAkC4C;AAIpF,gBAAG,QAAAC;AAEC,uBAAA,uBAAA,AAAA7C,qBAAA,AAAAA,kBAAA,AAAAA,uBAAA,AAAAA,uBAAA,AAAAA,yBACwB4C,QACCD,SAFzB,AAAA3C,yBAAA,AAAAA,kBAAA,AAAAA,uBAAA,AAAAA;;;AAKI\u002BC,8DAA\u002BE,0BAA5C,mFAAmB,AAAA5C,sBAA1C0C;;;AACZG,kFAIG,4EAAahC,yBADb,2HAAuB,AAAAF,UAAUM,IAAG,AAAApB,6BADpC,wBADH\u002BC;AAMAE,mFAAkB,AAAAC,0BAAeF,YAAW,AAAAhD,kBAAiB,AAAAA;AAE7DmD,qEAEG;wBAKeC,aAAAC;2BAJd,sBACgB,OACD,AAAAlD,wBACF,iBACCiD,MAA8B,AAAsB,AAAAjD,qCAApDkD,QAAwG,AAA4B,AAAAlD,wCAApI,OAAQ,OAAA,mBAARiD,KAAAC;mBANlBR;AAUAS,sEAAiB,uBAAA,AAAAtD,qBAAA,AAAAA,kBAEG\u002BC,WACA,uBAAU,AAAA/C,uBAAsB\u002BC,YAC9B,uBAAU,AAAA/C,yBAAwB,AAAAA,wBAGhC4C,QACCD,SAHH,OAAA,AAAA3C,yBAA0BgD,aACjCC,iBANE,AAAAjD,uBASE,OAAA,AAAAA,sBAAuBmD;AAI9C,oBAAG,AAAAI,\u002BBAAoBD;2BACnBA;;;kCAEYA;yCAAgB,AAAAb,gBAAgB;AAA5C;;;;;;;;;;;;QAuCJe,yDAEAC;AA7BJC,wCAIG,wCAAYvC,iBADZ,2HAAuB,AAAAL,UAAUM,IAAG,AAAApB,6BADpC,wBADH,AAAAA;AAUAsD,0DAAiB,uBAAA,AAAAtD,qBAAA,AAAAA,kBAAA,AAAAA,uBAAA,AAAAA,uBAAA,AAAAA,yBAAA,AAAAA,2BAAA,AAAAA,4BAAA,AAAAA,yBAA0B7C,UAA1B,AAAA6C,uBAAA,AAAAA;AAOjB2D,sDAAa,AAAAC,uBAAYN,gBAAe;AAuB5C,WAAA,iCACcK,YAlBP,gEAAe,AAAAE,gBADf,wBADH,4BAAe,AAAAF,0BARE,AAAAL,kCAabE,yBAAkG,\u002BBAAlD,6FAAmB,AAAArD,4BAZjD,AAAAmD;;SAclBG,UAAU,iCADgG,\u002BBAAlD,\u002BFAAmB,AAAAtD,8BAAnD,AAAAwD;;QACuBH,yBAGhD,\u002BHAAmB,AAAArD,gBADnB,\u002BDAAsB,\u002BBAAa,AAAAA,8BAA2BsD,UADjE,AAAAE,kCAKc,AAAAG,2BAAgBH,aAGP,AAAAI,yCAA8BJ,aACxC,AAAAJ,\u002BBAAoBI;;;;;;;AAajCjB,wHAAqB,AAAArB,sBAAsB,AAAArB;AAE3CgE,qDAGG,qEAAqB,AAAAC,eADrB,gEAAwB,AAAAA,eAAa,iBADxC,AAAAjE;AAIJ,WAAA,uBACoB,AAAAA,uBACA,AAAAA,uBACc,6FAAmB,AAAAG,4BAVjD,AAAAuC,kBAWgC,\u002BFAAmB,AAAAvC,8BAXnD,AAAAuC,kBAYuBsB,sBACH,AAAAF,2BAAgB9D;;;;;;;WAoBrC,2DAAyB,AAAAkE,eAbzB;AACOrH,oEAAA,AAAAiE,UAAUlB,UAAS,AAAAI;gCAClBF;AADD,YAAA,AAAAjD;AAAA,gBACY,CAAI,QAAC,AAAAmE,gCAArBnE;;AAAKiD,kCAALjD;;;;;;;;;;;AAEMsH,4CADA,AAAAvE;AAEC,uBAAA,iBACQuE,aACC,AAAAnD,wBAAwBlB,WACpBqE,aACH,AAAArE;;;AAEZ,uBAAA;;OAZR,wBADH,AAAAE","file":null,"sourcesContent":null,"sourceRoot":null}

package/src/PathwayValidator.ts

@@ -0,0 +1,244 @@
+import { Record } from "@fable-org/fable-library-js/Types.js";
+import { tryFind, toList, ofList, FSharpMap } from "@fable-org/fable-library-js/Map.js";
+import { ClinicalPathway_StateDefinition, Values_DynamicFormResultData$1, Values_FieldDetails$1, Values_StepOrder, Values_DynamicFormSpecDetails, Values_Signature, Values_FormStatus_Complete, Spec_MatrixInfo, Shared_FieldValue_$union, Shared_FieldValue_Single, Shared_FieldAnswer, Shared_FieldValue_Matrix, Shared_MatrixAnswer, Shared_MatrixItemKey, Spec_FormSpec$1, Spec_FormStep$1, ClinicalPathway_ClinicalPathwaySpec, ClinicalPathway_TransitionDefinition, ClinicalPathway_TransitionCondition_$union, Spec_FormField$1, Shared_FieldOption, Spec_FieldType_$union, Shared_StateKey_$reflection, Shared_StateKey, Shared_FieldKey_$reflection, Shared_FieldKey } from "./FormSpec.js";
+import { stringHash, safeHash, compare, equals, IComparable, IEquatable } from "@fable-org/fable-library-js/Util.js";
+import { option_type, list_type, int32_type, bool_type, record_type, class_type, string_type, TypeInfo } from "@fable-org/fable-library-js/Reflection.js";
+import { ofList as ofList_1, intersect, isEmpty as isEmpty_1, empty as empty_1, FSharpSet } from "@fable-org/fable-library-js/Set.js";
+import { int32 } from "@fable-org/fable-library-js/Int32.js";
+import { reverse, choose, take, length, zip, mapIndexed, head as head_1, cons, tail as tail_1, collect, isEmpty, filter, exists, empty, singleton, ofArray, map, FSharpList } from "@fable-org/fable-library-js/List.js";
+import { isExecutionComplete, ExecutionContext$1, initializeExecution, executeStep, ExecutionLogEntry_$reflection, ExecutionLogEntry } from "./PathwayExecutor.js";
+import { map as map_1, value as value_2, Option } from "@fable-org/fable-library-js/Option.js";
+import { substring, join } from "@fable-org/fable-library-js/String.js";
+import { newGuid } from "@fable-org/fable-library-js/Guid.js";
+import { List_distinct, List_groupBy } from "@fable-org/fable-library-js/Seq2.js";
+import { min } from "@fable-org/fable-library-js/Double.js";
+
+export class TestScenario extends Record implements IEquatable<TestScenario>, IComparable<TestScenario> {
+    readonly ScenarioId: string;
+    readonly FieldValues: FSharpMap<Shared_FieldKey, string>;
+    readonly Description: string;
+    constructor(ScenarioId: string, FieldValues: FSharpMap<Shared_FieldKey, string>, Description: string) {
+        super();
+        this.ScenarioId = ScenarioId;
+        this.FieldValues = FieldValues;
+        this.Description = Description;
+    }
+}
+
+export function TestScenario_$reflection(): TypeInfo {
+    return record_type("F1.Studio.PathwayValidator.TestScenario", [], TestScenario, () => [["ScenarioId", string_type], ["FieldValues", class_type("Microsoft.FSharp.Collections.FSharpMap`2", [Shared_FieldKey_$reflection(), string_type])], ["Description", string_type]]);
+}
+
+export class ScenarioValidationResult extends Record implements IEquatable<ScenarioValidationResult>, IComparable<ScenarioValidationResult> {
+    readonly Scenario: TestScenario;
+    readonly ReachedTerminal: boolean;
+    readonly FinalStates: FSharpSet<Shared_StateKey>;
+    readonly ExecutionComplete: boolean;
+    readonly DeadEndDetected: boolean;
+    readonly InfiniteLoopDetected: boolean;
+    readonly MaxDepthExceeded: boolean;
+    readonly ExecutionIterations: int32;
+    readonly ExecutionLog: FSharpList<ExecutionLogEntry>;
+    readonly Error: Option<string>;
+    constructor(Scenario: TestScenario, ReachedTerminal: boolean, FinalStates: FSharpSet<Shared_StateKey>, ExecutionComplete: boolean, DeadEndDetected: boolean, InfiniteLoopDetected: boolean, MaxDepthExceeded: boolean, ExecutionIterations: int32, ExecutionLog: FSharpList<ExecutionLogEntry>, Error$: Option<string>) {
+        super();
+        this.Scenario = Scenario;
+        this.ReachedTerminal = ReachedTerminal;
+        this.FinalStates = FinalStates;
+        this.ExecutionComplete = ExecutionComplete;
+        this.DeadEndDetected = DeadEndDetected;
+        this.InfiniteLoopDetected = InfiniteLoopDetected;
+        this.MaxDepthExceeded = MaxDepthExceeded;
+        this.ExecutionIterations = (ExecutionIterations | 0);
+        this.ExecutionLog = ExecutionLog;
+        this.Error = Error$;
+    }
+}
+
+export function ScenarioValidationResult_$reflection(): TypeInfo {
+    return record_type("F1.Studio.PathwayValidator.ScenarioValidationResult", [], ScenarioValidationResult, () => [["Scenario", TestScenario_$reflection()], ["ReachedTerminal", bool_type], ["FinalStates", class_type("Microsoft.FSharp.Collections.FSharpSet`1", [Shared_StateKey_$reflection()])], ["ExecutionComplete", bool_type], ["DeadEndDetected", bool_type], ["InfiniteLoopDetected", bool_type], ["MaxDepthExceeded", bool_type], ["ExecutionIterations", int32_type], ["ExecutionLog", list_type(ExecutionLogEntry_$reflection())], ["Error", option_type(string_type)]]);
+}
+
+export class PathwayValidationResult extends Record implements IEquatable<PathwayValidationResult>, IComparable<PathwayValidationResult> {
+    readonly TotalScenarios: int32;
+    readonly ValidScenarios: int32;
+    readonly DeadEndScenarios: FSharpList<ScenarioValidationResult>;
+    readonly InfiniteLoopScenarios: FSharpList<ScenarioValidationResult>;
+    readonly OverComplexScenarios: FSharpList<ScenarioValidationResult>;
+    readonly Errors: FSharpList<string>;
+    constructor(TotalScenarios: int32, ValidScenarios: int32, DeadEndScenarios: FSharpList<ScenarioValidationResult>, InfiniteLoopScenarios: FSharpList<ScenarioValidationResult>, OverComplexScenarios: FSharpList<ScenarioValidationResult>, Errors: FSharpList<string>) {
+        super();
+        this.TotalScenarios = (TotalScenarios | 0);
+        this.ValidScenarios = (ValidScenarios | 0);
+        this.DeadEndScenarios = DeadEndScenarios;
+        this.InfiniteLoopScenarios = InfiniteLoopScenarios;
+        this.OverComplexScenarios = OverComplexScenarios;
+        this.Errors = Errors;
+    }
+}
+
+export function PathwayValidationResult_$reflection(): TypeInfo {
+    return record_type("F1.Studio.PathwayValidator.PathwayValidationResult", [], PathwayValidationResult, () => [["TotalScenarios", int32_type], ["ValidScenarios", int32_type], ["DeadEndScenarios", list_type(ScenarioValidationResult_$reflection())], ["InfiniteLoopScenarios", list_type(ScenarioValidationResult_$reflection())], ["OverComplexScenarios", list_type(ScenarioValidationResult_$reflection())], ["Errors", list_type(string_type)]]);
+}
+
+function getFieldPossibleValues(field: Spec_FormField$1<Spec_FieldType_$union>): FSharpList<string> {
+    const matchValue: Spec_FieldType_$union = field.FieldType;
+    switch (matchValue.tag) {
+        case /* SingleChoice */ 13:
+            return map<Shared_FieldOption, string>((opt: Shared_FieldOption): string => opt.Value, matchValue.fields[0].Options);
+        case /* MultiChoice */ 15:
+            return map<Shared_FieldOption, string>((opt_1: Shared_FieldOption): string => opt_1.Value, matchValue.fields[0].Options);
+        case /* CheckboxList */ 16:
+            return map<Shared_FieldOption, string>((opt_2: Shared_FieldOption): string => opt_2.Value, matchValue.fields[0].Options);
+        case /* Dropdown */ 14:
+            return map<Shared_FieldOption, string>((opt_3: Shared_FieldOption): string => opt_3.Value, matchValue.fields[0].Options);
+        case /* Radio */ 12:
+            return map<Shared_FieldOption, string>((opt_4: Shared_FieldOption): string => opt_4.Value, matchValue.fields[0].Options);
+        case /* Matrix */ 19:
+            return map<Shared_FieldOption, string>((opt_5: Shared_FieldOption): string => opt_5.Value, matchValue.fields[0].Options);
+        case /* Checkbox */ 11:
+            return ofArray(["true", "false"]);
+        case /* Number */ 6:
+            return ofArray(["0", "1", "10", "100"]);
+        case /* Text */ 0:
+        case /* TextArea */ 1:
+            return singleton("");
+        default:
+            return empty<string>();
+    }
+}
+
+function isFieldRelevantForPathway(field: Spec_FormField$1<Spec_FieldType_$union>, pathway: ClinicalPathway_ClinicalPathwaySpec): boolean {
+    const fieldKey: Shared_FieldKey = field.FieldKey;
+    return exists<ClinicalPathway_TransitionDefinition>((trans: ClinicalPathway_TransitionDefinition): boolean => {
+        const conditionUsesField = (cond: ClinicalPathway_TransitionCondition_$union): boolean => {
+            switch (cond.tag) {
+                case /* FieldCondition */ 0:
+                    return equals(cond.fields[0], fieldKey);
+                case /* FieldOptionCondition */ 1:
+                    return equals(cond.fields[0], fieldKey);
+                case /* PluginPropertyCondition */ 2:
+                    return equals(cond.fields[0], fieldKey);
+                case /* StateCondition */ 3:
+                    return false;
+                case /* CompositeCondition */ 4:
+                    return exists<ClinicalPathway_TransitionCondition_$union>(conditionUsesField, cond.fields[1]);
+                case /* TestResultCondition */ 5:
+                    return false;
+                default:
+                    return false;
+            }
+        };
+        return conditionUsesField(trans.Condition);
+    }, pathway.Transitions);
+}
+
+/**
+ * Generate test scenarios for pathway validation
+ * Strategy: Only generate scenarios for fields that are actually used in pathway conditions
+ * For Likert fields, generate scenarios for each item independently
+ */
+export function generateTestScenarios(formSpec: Spec_FormSpec$1<Spec_FieldType_$union>, pathway: ClinicalPathway_ClinicalPathwaySpec, maxScenarios: Option<int32>): FSharpList<TestScenario> {
+    let max: int32, max_1: int32;
+    const fieldValueOptions: FSharpList<[Shared_FieldKey, FSharpList<string>]> = filter<[Shared_FieldKey, FSharpList<string>]>((tupledArg: [Shared_FieldKey, FSharpList<string>]): boolean => !isEmpty(tupledArg[1]), map<Spec_FormField$1<Spec_FieldType_$union>, [Shared_FieldKey, FSharpList<string>]>((field_1: Spec_FormField$1<Spec_FieldType_$union>): [Shared_FieldKey, FSharpList<string>] => ([field_1.FieldKey, getFieldPossibleValues(field_1)] as [Shared_FieldKey, FSharpList<string>]), filter<Spec_FormField$1<Spec_FieldType_$union>>((field: Spec_FormField$1<Spec_FieldType_$union>): boolean => isFieldRelevantForPathway(field, pathway), collect<Spec_FormStep$1<Spec_FieldType_$union>, Spec_FormField$1<Spec_FieldType_$union>>((step: Spec_FormStep$1<Spec_FieldType_$union>): FSharpList<Spec_FormField$1<Spec_FieldType_$union>> => step.Fields, formSpec.Steps))));
+    const cartesianProduct = <a>(lists: FSharpList<FSharpList<a>>): FSharpList<FSharpList<a>> => {
+        if (!isEmpty(lists)) {
+            const tailProducts: FSharpList<FSharpList<a>> = cartesianProduct(tail_1(lists));
+            return collect<a, FSharpList<a>>((h: a): FSharpList<FSharpList<a>> => map<FSharpList<a>, FSharpList<a>>((t: FSharpList<a>): FSharpList<a> => cons(h, t), tailProducts), head_1(lists));
+        }
+        else {
+            return singleton(empty<a>());
+        }
+    };
+    const allCombinations: FSharpList<FSharpList<string>> = cartesianProduct(map<[Shared_FieldKey, FSharpList<string>], FSharpList<string>>((tuple: [Shared_FieldKey, FSharpList<string>]): FSharpList<string> => tuple[1], fieldValueOptions));
+    return mapIndexed<FSharpList<string>, TestScenario>((index: int32, combination: FSharpList<string>): TestScenario => {
+        const fieldValues: FSharpMap<Shared_FieldKey, string> = ofList<Shared_FieldKey, string>(map<[[Shared_FieldKey, FSharpList<string>], string], [Shared_FieldKey, string]>((tupledArg_1: [[Shared_FieldKey, FSharpList<string>], string]): [Shared_FieldKey, string] => ([tupledArg_1[0][0], tupledArg_1[1]] as [Shared_FieldKey, string]), zip<[Shared_FieldKey, FSharpList<string>], string>(fieldValueOptions, combination)), {
+            Compare: compare,
+        });
+        return new TestScenario(`scenario_${index + 1}`, fieldValues, join(", ", map<[Shared_FieldKey, string], string>((tupledArg_2: [Shared_FieldKey, string]): string => (`${substring(tupledArg_2[0].fields[0], 0, 8)}=${tupledArg_2[1]}`), toList<Shared_FieldKey, string>(fieldValues))));
+    }, (maxScenarios != null) ? (((max = (value_2(maxScenarios) | 0), length(allCombinations) > max)) ? ((max_1 = (value_2(maxScenarios) | 0), take<FSharpList<string>>(max_1, allCombinations))) : allCombinations) : allCombinations);
+}
+
+function scenarioToFormData(formSpec: Spec_FormSpec$1<Spec_FieldType_$union>, scenario: TestScenario): Values_DynamicFormResultData$1<Spec_FieldType_$union> {
+    const fieldValues: FSharpMap<Shared_FieldKey, Shared_FieldValue_$union> = ofList<Shared_FieldKey, Shared_FieldValue_$union>(choose<Spec_FormField$1<Spec_FieldType_$union>, [Shared_FieldKey, Shared_FieldValue_$union]>((field: Spec_FormField$1<Spec_FieldType_$union>): Option<[Shared_FieldKey, Shared_FieldValue_$union]> => map_1<string, [Shared_FieldKey, Shared_FieldValue_$union]>((value: string): [Shared_FieldKey, Shared_FieldValue_$union] => {
+        let matchValue: Spec_FieldType_$union, info: Spec_MatrixInfo;
+        return [field.FieldKey, (matchValue = field.FieldType, (matchValue.tag === /* Matrix */ 19) ? ((info = matchValue.fields[0], Shared_FieldValue_Matrix(new Shared_MatrixAnswer(field.FieldKey, field.Label, ofList<Shared_MatrixItemKey, string>(map<Shared_MatrixItemKey, [Shared_MatrixItemKey, string]>((itemKey: Shared_MatrixItemKey): [Shared_MatrixItemKey, string] => ([itemKey, value] as [Shared_MatrixItemKey, string]), singleton(new Shared_MatrixItemKey(newGuid()))), {
+            Compare: compare,
+        }))))) : Shared_FieldValue_Single(new Shared_FieldAnswer(field.FieldKey, field.Label, value)))] as [Shared_FieldKey, Shared_FieldValue_$union];
+    }, tryFind<Shared_FieldKey, string>(field.FieldKey, scenario.FieldValues)), collect<Spec_FormStep$1<Spec_FieldType_$union>, Spec_FormField$1<Spec_FieldType_$union>>((step: Spec_FormStep$1<Spec_FieldType_$union>): FSharpList<Spec_FormField$1<Spec_FieldType_$union>> => step.Fields, formSpec.Steps)), {
+        Compare: compare,
+    });
+    return new Values_DynamicFormResultData$1(new Values_DynamicFormSpecDetails(formSpec.Id, formSpec.Code, formSpec.FormSpecVersion, formSpec.Version, formSpec.Score, Values_FormStatus_Complete(), empty<Values_Signature>()), ofList<Values_StepOrder, FSharpMap<Shared_FieldKey, Values_FieldDetails$1<Spec_FieldType_$union>>>(map<Spec_FormStep$1<Spec_FieldType_$union>, [Values_StepOrder, FSharpMap<Shared_FieldKey, Values_FieldDetails$1<Spec_FieldType_$union>>]>((step_1: Spec_FormStep$1<Spec_FieldType_$union>): [Values_StepOrder, FSharpMap<Shared_FieldKey, Values_FieldDetails$1<Spec_FieldType_$union>>] => ([new Values_StepOrder(step_1.StepOrder), ofList<Shared_FieldKey, Values_FieldDetails$1<Spec_FieldType_$union>>(choose<Spec_FormField$1<Spec_FieldType_$union>, [Shared_FieldKey, Values_FieldDetails$1<Spec_FieldType_$union>]>((field_1: Spec_FormField$1<Spec_FieldType_$union>): Option<[Shared_FieldKey, Values_FieldDetails$1<Spec_FieldType_$union>]> => map_1<Shared_FieldValue_$union, [Shared_FieldKey, Values_FieldDetails$1<Spec_FieldType_$union>]>((value_1: Shared_FieldValue_$union): [Shared_FieldKey, Values_FieldDetails$1<Spec_FieldType_$union>] => {
+        let matchValue_1: Spec_FieldType_$union;
+        return [field_1.FieldKey, new Values_FieldDetails$1(field_1.FieldOrder, field_1.FieldKey, field_1.Label, value_1, field_1.FieldType, (matchValue_1 = field_1.FieldType, (matchValue_1.tag === /* SingleChoice */ 13) ? matchValue_1.fields[0].Options : ((matchValue_1.tag === /* MultiChoice */ 15) ? matchValue_1.fields[0].Options : ((matchValue_1.tag === /* CheckboxList */ 16) ? matchValue_1.fields[0].Options : ((matchValue_1.tag === /* Dropdown */ 14) ? matchValue_1.fields[0].Options : ((matchValue_1.tag === /* Radio */ 12) ? matchValue_1.fields[0].Options : ((matchValue_1.tag === /* Matrix */ 19) ? matchValue_1.fields[0].Options : empty<Shared_FieldOption>())))))))] as [Shared_FieldKey, Values_FieldDetails$1<Spec_FieldType_$union>];
+    }, tryFind<Shared_FieldKey, Shared_FieldValue_$union>(field_1.FieldKey, fieldValues)), step_1.Fields), {
+        Compare: compare,
+    })] as [Values_StepOrder, FSharpMap<Shared_FieldKey, Values_FieldDetails$1<Spec_FieldType_$union>>]), formSpec.Steps), {
+        Compare: compare,
+    }));
+}
+
+function isTerminalState(state: ClinicalPathway_StateDefinition): boolean {
+    if (state.StateType.tag === /* Terminal */ 5) {
+        return true;
+    }
+    else {
+        return false;
+    }
+}
+
+function detectInfiniteLoop(executionLog: FSharpList<ExecutionLogEntry>, maxDepth: int32): boolean {
+    let list_1: FSharpList<ExecutionLogEntry>;
+    if (length(executionLog) > maxDepth) {
+        return exists<[Shared_StateKey, int32]>((tupledArg_1: [Shared_StateKey, int32]): boolean => (tupledArg_1[1] >= 3), map<[Shared_StateKey, FSharpList<Shared_StateKey>], [Shared_StateKey, int32]>((tupledArg: [Shared_StateKey, FSharpList<Shared_StateKey>]): [Shared_StateKey, int32] => ([tupledArg[0], length(tupledArg[1])] as [Shared_StateKey, int32]), List_groupBy<Shared_StateKey, Shared_StateKey>((x: Shared_StateKey): Shared_StateKey => x, map<ExecutionLogEntry, Shared_StateKey>((log: ExecutionLogEntry): Shared_StateKey => log.StateKey, (list_1 = reverse<ExecutionLogEntry>(executionLog), take<ExecutionLogEntry>(min(20, length(executionLog)), list_1))), {
+            Equals: equals,
+            GetHashCode: safeHash,
+        })));
+    }
+    else {
+        return false;
+    }
+}
+
+function validateScenario(formSpec: Spec_FormSpec$1<Spec_FieldType_$union>, pathway: ClinicalPathway_ClinicalPathwaySpec, scenario: TestScenario, maxDepth: int32): ScenarioValidationResult {
+    try {
+        const finalContext: ExecutionContext$1<Spec_FieldType_$union> = executeStep<Spec_FieldType_$union>(initializeExecution<Spec_FieldType_$union>(formSpec, scenarioToFormData(formSpec, scenario)), maxDepth);
+        const reachedTerminal: boolean = !isEmpty_1<Shared_StateKey>(intersect<Shared_StateKey>(ofList_1<Shared_StateKey>(map<ClinicalPathway_StateDefinition, Shared_StateKey>((s: ClinicalPathway_StateDefinition): Shared_StateKey => s.StateKey, filter<ClinicalPathway_StateDefinition>(isTerminalState, pathway.States)), {
+            Compare: compare,
+        }), finalContext.CurrentStates));
+        const isComplete: boolean = isExecutionComplete<Spec_FieldType_$union>(finalContext);
+        const infiniteLoopDetected: boolean = detectInfiniteLoop(finalContext.ExecutionLog, maxDepth);
+        return new ScenarioValidationResult(scenario, reachedTerminal, finalContext.CurrentStates, isComplete, (((!isComplete && !reachedTerminal) && isEmpty(finalContext.ActiveTransitions)) && isEmpty(finalContext.PendingTransitions)) && !infiniteLoopDetected, infiniteLoopDetected, (length(finalContext.ExecutionLog) >= maxDepth) && !isComplete, length(finalContext.ExecutionLog), finalContext.ExecutionLog, undefined);
+    }
+    catch (ex: any) {
+        return new ScenarioValidationResult(scenario, false, empty_1<Shared_StateKey>({
+            Compare: compare,
+        }), false, true, false, false, 0, empty<ExecutionLogEntry>(), ex.message);
+    }
+}
+
+/**
+ * Validate pathway for dead-end scenarios, infinite loops, and overcomplexity
+ */
+export function validatePathwayCompleteness(formSpec: Spec_FormSpec$1<Spec_FieldType_$union>, pathway: ClinicalPathway_ClinicalPathwaySpec, maxScenarios: Option<int32>, maxDepth: int32): PathwayValidationResult {
+    const scenarios: FSharpList<TestScenario> = generateTestScenarios(formSpec, pathway, maxScenarios);
+    const results: FSharpList<ScenarioValidationResult> = map<TestScenario, ScenarioValidationResult>((scenario: TestScenario): ScenarioValidationResult => validateScenario(formSpec, pathway, scenario, maxDepth), scenarios);
+    const deadEnds: FSharpList<ScenarioValidationResult> = filter<ScenarioValidationResult>((r: ScenarioValidationResult): boolean => r.DeadEndDetected, results);
+    const infiniteLoops: FSharpList<ScenarioValidationResult> = filter<ScenarioValidationResult>((r_1: ScenarioValidationResult): boolean => r_1.InfiniteLoopDetected, results);
+    const overComplex: FSharpList<ScenarioValidationResult> = filter<ScenarioValidationResult>((r_2: ScenarioValidationResult): boolean => r_2.MaxDepthExceeded, results);
+    const valid: FSharpList<ScenarioValidationResult> = filter<ScenarioValidationResult>((r_3: ScenarioValidationResult): boolean => {
+        if (!r_3.DeadEndDetected && !r_3.InfiniteLoopDetected) {
+            return !r_3.MaxDepthExceeded;
+        }
+        else {
+            return false;
+        }
+    }, results);
+    const errors: FSharpList<string> = List_distinct<string>(choose<ScenarioValidationResult, string>((r_4: ScenarioValidationResult): Option<string> => r_4.Error, results), {
+        Equals: (x: string, y: string): boolean => (x === y),
+        GetHashCode: stringHash,
+    });
+    return new PathwayValidationResult(length(scenarios), length(valid), deadEnds, infiniteLoops, overComplex, errors);
+}
+
+//# sourceMappingURL=PathwayValidator.ts.map

package/src/PathwayValidator.ts.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../FormSpec.FS/PathwayValidator.fs"],"names":["matchValue","field","opt","fieldKey","conditionUsesField","cond","trans","pathway","max","fieldValueOptions","tupledArg","getFieldPossibleValues","isFieldRelevantForPathway","step","formSpec","cartesianProduct","lists","tailProducts","h","t","allCombinations","tuple","fieldValues","combination","index","maxScenarios","info","itemKey","value","scenario","state","list","executionLog","maxDepth","x","log","finalContext","scenarioToFormData","reachedTerminal","s","isTerminalState","isComplete","infiniteLoopDetected","detectInfiniteLoop","ex","scenarios","generateTestScenarios","results","validateScenario","deadEnds","r","infiniteLoops","overComplex","valid","errors"],"mappings":";;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;AAmDUA,8CAAA,AAAAC;YAAAD;;AAEc,mBAAA,qEAAqB,AAAAE,WAArC,AAAAF;;AAEgB,mBAAA,uEAAqB,AAAAE,aAArC,AAAAF;;AAEgB,mBAAA,uEAAqB,AAAAE,aAArC,AAAAF;;AAEgB,mBAAA,uEAAqB,AAAAE,aAArC,AAAAF;;AAEgB,mBAAA,uEAAqB,AAAAE,aAArC,AAAAF;;AAGgB,mBAAA,uEAAqB,AAAAE,aAArC,AAAAF;;AAEA,mBAAA,SAAC,QAAQ;;AAIT,mBAAA,SAAC,KAAK,KAAK,MAAM;;;AAKjB,mBAAA,UAAC;;AAGD,mBAAA;;;;;AAKAG,sCAAW,AAAAF;AAGZ,WAAA;AACSG;oBACEC;;AAEyB,2BAAA,OAAA,AAAAA,gBAAKF;;AACO,2BAAA,OAAA,AAAAE,gBAAKF;;AACL,2BAAA,OAAA,AAAAE,gBAAKF;;2BAC1B;;AAEJ,2BAAA,mDAAYC,oBAA1B,AAAAC;;2BACuB;;2BAPf;;;AAShB,eAAA,AAAAD,mBAAmB,AAAAE;OAbvB,AAAAC;;;;;;;;;QAyDWC,YAAAA;AAzBPC,iFAMG,6GAAgC,CAAI,QAAlB,AAAAC,eAJlB,mLAEE,AAAAT,kBADoB,AAAAU,uBAAuBV,qDAN7C,6GAA0B,AAAAW,0BAA0BX,OAAMM,UAD1D,gMAA0B,AAAAM,aAD7B,AAAAC;AAeIC;AACE,YAAA,CAAA,QAAAC;AAGEC,4DAAe,AAAAF,iBAAf,OAAAC;AAED,mBAAA,\u002BDACiB,uEAAmB,KAAAE,GAAKC,IAAxCF,eAHA,OAAAD;;;AAFA,mBAAA,UAAC;;;AAQTI,4DAAkB,AAAAL,iBAAuC,qIAAS,AAAAM,UAA9BZ;AAYrC,WAAA;AACKa,gEAGG,gCADA,\u002BKAAgB,AAAAZ,mBAAA,AAAAA,\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","file":null,"sourcesContent":null,"sourceRoot":null}

package/src/PluginInterface.ts

@@ -0,0 +1,79 @@
+import { Record } from "@fable-org/fable-library-js/Types.js";
+import { FSharpList } from "@fable-org/fable-library-js/List.js";
+import { comparePrimitives, IComparable, IEquatable } from "@fable-org/fable-library-js/Util.js";
+import { union_type, unit_type, lambda_type, option_type, obj_type, record_type, list_type, string_type, TypeInfo } from "@fable-org/fable-library-js/Reflection.js";
+import { Shared_PluginPropertyKey_$reflection, Shared_PluginDataProperty_$reflection, Shared_FieldOption_$reflection, Shared_FieldValue_$reflection, Shared_FieldKey_$reflection, Shared_PluginPropertyKey, Shared_PluginDataProperty, Shared_FieldOption, Shared_FieldValue_$union, Shared_FieldKey } from "./FormSpec.js";
+import { Option } from "@fable-org/fable-library-js/Option.js";
+import { FSharpResult$2, FSharpResult$2_$union } from "@fable-org/fable-library-js/Result.js";
+import { tryFind, FSharpMap__Add, FSharpMap, empty } from "@fable-org/fable-library-js/Map.js";
+import { int32 } from "@fable-org/fable-library-js/Int32.js";
+
+export class PluginMetadata extends Record implements IEquatable<PluginMetadata>, IComparable<PluginMetadata> {
+    readonly PluginId: string;
+    readonly Name: string;
+    readonly Description: string;
+    readonly Icon: string;
+    readonly Category: string;
+    readonly Version: string;
+    readonly Author: string;
+    readonly Dependencies: FSharpList<string>;
+    constructor(PluginId: string, Name: string, Description: string, Icon: string, Category: string, Version: string, Author: string, Dependencies: FSharpList<string>) {
+        super();
+        this.PluginId = PluginId;
+        this.Name = Name;
+        this.Description = Description;
+        this.Icon = Icon;
+        this.Category = Category;
+        this.Version = Version;
+        this.Author = Author;
+        this.Dependencies = Dependencies;
+    }
+}
+
+export function PluginMetadata_$reflection(): TypeInfo {
+    return record_type("F1.Studio.Plugin.Core.PluginMetadata", [], PluginMetadata, () => [["PluginId", string_type], ["Name", string_type], ["Description", string_type], ["Icon", string_type], ["Category", string_type], ["Version", string_type], ["Author", string_type], ["Dependencies", list_type(string_type)]]);
+}
+
+export class IPluginValueConverter extends Record {
+    readonly ToFieldValue: ((arg0: Shared_FieldKey, arg1: any) => Option<Shared_FieldValue_$union>);
+    readonly FromFieldValue: ((arg0: Shared_FieldValue_$union) => Option<any>);
+    readonly GetOptions: (() => Option<FSharpList<Shared_FieldOption>>);
+    readonly GetPropertyNames: (() => FSharpList<string>);
+    readonly GetPropertyMetadata: ((arg0: string) => Option<Shared_PluginDataProperty>);
+    readonly GetPropertyMetadataByKey: ((arg0: Shared_PluginPropertyKey) => Option<Shared_PluginDataProperty>);
+    readonly GetProperty: ((arg0: string, arg1: Shared_FieldValue_$union) => Option<Shared_PluginDataProperty>);
+    readonly GetPropertyByKey: ((arg0: Shared_PluginPropertyKey, arg1: Shared_FieldValue_$union) => Option<Shared_PluginDataProperty>);
+    readonly ValidateProperty: ((arg0: string, arg1: string) => FSharpResult$2_$union<void, string>);
+    readonly GetAllProperties: ((arg0: Shared_FieldValue_$union) => FSharpList<Shared_PluginDataProperty>);
+    constructor(ToFieldValue: ((arg0: Shared_FieldKey, arg1: any) => Option<Shared_FieldValue_$union>), FromFieldValue: ((arg0: Shared_FieldValue_$union) => Option<any>), GetOptions: (() => Option<FSharpList<Shared_FieldOption>>), GetPropertyNames: (() => FSharpList<string>), GetPropertyMetadata: ((arg0: string) => Option<Shared_PluginDataProperty>), GetPropertyMetadataByKey: ((arg0: Shared_PluginPropertyKey) => Option<Shared_PluginDataProperty>), GetProperty: ((arg0: string, arg1: Shared_FieldValue_$union) => Option<Shared_PluginDataProperty>), GetPropertyByKey: ((arg0: Shared_PluginPropertyKey, arg1: Shared_FieldValue_$union) => Option<Shared_PluginDataProperty>), ValidateProperty: ((arg0: string, arg1: string) => FSharpResult$2_$union<void, string>), GetAllProperties: ((arg0: Shared_FieldValue_$union) => FSharpList<Shared_PluginDataProperty>)) {
+        super();
+        this.ToFieldValue = ToFieldValue;
+        this.FromFieldValue = FromFieldValue;
+        this.GetOptions = GetOptions;
+        this.GetPropertyNames = GetPropertyNames;
+        this.GetPropertyMetadata = GetPropertyMetadata;
+        this.GetPropertyMetadataByKey = GetPropertyMetadataByKey;
+        this.GetProperty = GetProperty;
+        this.GetPropertyByKey = GetPropertyByKey;
+        this.ValidateProperty = ValidateProperty;
+        this.GetAllProperties = GetAllProperties;
+    }
+}
+
+export function IPluginValueConverter_$reflection(): TypeInfo {
+    return record_type("F1.Studio.Plugin.Core.IPluginValueConverter", [], IPluginValueConverter, () => [["ToFieldValue", lambda_type(Shared_FieldKey_$reflection(), lambda_type(obj_type, option_type(Shared_FieldValue_$reflection())))], ["FromFieldValue", lambda_type(Shared_FieldValue_$reflection(), option_type(obj_type))], ["GetOptions", lambda_type(unit_type, option_type(list_type(Shared_FieldOption_$reflection())))], ["GetPropertyNames", lambda_type(unit_type, list_type(string_type))], ["GetPropertyMetadata", lambda_type(string_type, option_type(Shared_PluginDataProperty_$reflection()))], ["GetPropertyMetadataByKey", lambda_type(Shared_PluginPropertyKey_$reflection(), option_type(Shared_PluginDataProperty_$reflection()))], ["GetProperty", lambda_type(string_type, lambda_type(Shared_FieldValue_$reflection(), option_type(Shared_PluginDataProperty_$reflection())))], ["GetPropertyByKey", lambda_type(Shared_PluginPropertyKey_$reflection(), lambda_type(Shared_FieldValue_$reflection(), option_type(Shared_PluginDataProperty_$reflection())))], ["ValidateProperty", lambda_type(string_type, lambda_type(string_type, union_type("Microsoft.FSharp.Core.FSharpResult`2", [unit_type, string_type], FSharpResult$2, () => [[["ResultValue", unit_type]], [["ErrorValue", string_type]]])))], ["GetAllProperties", lambda_type(Shared_FieldValue_$reflection(), list_type(Shared_PluginDataProperty_$reflection()))]]);
+}
+
+let PluginValueRegistry_converters: FSharpMap<string, IPluginValueConverter> = empty<string, IPluginValueConverter>({
+    Compare: comparePrimitives,
+});
+
+export function PluginValueRegistry_register(pluginId: string, converter: IPluginValueConverter): void {
+    PluginValueRegistry_converters = FSharpMap__Add(PluginValueRegistry_converters, pluginId, converter);
+}
+
+export function PluginValueRegistry_tryGet(pluginId: string): Option<IPluginValueConverter> {
+    return tryFind<string, IPluginValueConverter>(pluginId, PluginValueRegistry_converters);
+}
+
+//# sourceMappingURL=PluginInterface.ts.map

package/src/PluginInterface.ts.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../FormSpec.FS/PluginInterface.fs"],"names":["converters","pluginId","converter"],"mappings":";;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;\u002BEAuD0E;;;;;AAGlE,AAAAA,qCAAc,eAAAA,gCAAeC,UAAUC;;;;WAGzB,uCAAAD,UAAdD","file":null,"sourcesContent":null,"sourceRoot":null}

package/src/Prelude.ts

@@ -0,0 +1,21 @@
+import { FSharpList, ofArray } from "@fable-org/fable-library-js/List.js";
+
+export const FormSpec_availableVersions: FSharpList<string> = ofArray(["1.0.0", "1.0.1", "2.0.0"]);
+
+export const FormSpec_latestStableVersion = "1.0.1";
+
+export const FormSpec_latestSpecVersion = "2.0.0";
+
+export const FormSpec_productionVersion = "1.0.0";
+
+export const FormValues_availableVersions: FSharpList<string> = ofArray(["1.0.0", "1.0.1", "2.0.0"]);
+
+export const FormValues_latestStableVersion = "1.0.1";
+
+export const FormValues_latestSpecVersion = "2.0.0";
+
+export const FormValues_productionVersion = "1.0.0";
+
+export const FormValues_developmentVersion = "2.0.1b0";
+
+//# sourceMappingURL=Prelude.ts.map

package/src/Prelude.ts.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../FormSpec.FS/Prelude.fs"],"names":[],"mappings":";;8DAe4B,SACpB,SACA,SACA;;4CAGsB;;0CACF;;0CACA;;gEAIA,SACpB,SACA,SACA;;8CAGsB;;4CACF;;4CACA;;6CAEC","file":null,"sourcesContent":null,"sourceRoot":null}