("-0.8335") — Decimal.parse "-0.8335" = some { toUInt64 := 8335 } but a leading '-' must yield a non-positive decimal


("-0.2") — Decimal.parse "-0.2" = some { toUInt64 := 2000 } but a leading '-' must yield a non-positive decimal


("-0.6") — Decimal.parse "-0.6" = some { toUInt64 := 6000 } but a leading '-' must yield a non-positive decimal


("-0.7") — Decimal.parse "-0.7" = some { toUInt64 := 7000 } but a leading '-' must yield a non-positive decimal


("-0.4") — Decimal.parse "-0.4" = some { toUInt64 := 4000 } but a leading '-' must yield a non-positive decimal


("-0.61") — Decimal.parse "-0.61" = some { toUInt64 := 6100 } but a leading '-' must yield a non-positive decimal


("-0.2059") — Decimal.parse "-0.2059" = some { toUInt64 := 2059 } but a leading '-' must yield a non-positive decimal


("-0.812") — Decimal.parse "-0.812" = some { toUInt64 := 8120 } but a leading '-' must yield a non-positive decimal


("-0.518") — Decimal.parse "-0.518" = some { toUInt64 := 5180 } but a leading '-' must yield a non-positive decimal


Decimal.parse "-0.5" = some { toUInt64 := 5000 } but a leading '-' must yield a non-positive decimal


("2_71.94") — Decimal.parse "2_71.94" = some { toUInt64 := 2719400 } but underscores are disallowed


("-30.43_3") — Decimal.parse "-30.43_3" = some { toUInt64 := 18446744073709251183 } but underscores are disallowed


("0_2.956") — Decimal.parse "0_2.956" = some { toUInt64 := 29560 } but underscores are disallowed


("3_1.923") — Decimal.parse "3_1.923" = some { toUInt64 := 319230 } but underscores are disallowed


("95_0.94") — Decimal.parse "95_0.94" = some { toUInt64 := 9509400 } but underscores are disallowed


Decimal.parse "1_2.34" = some { toUInt64 := 123400 } but underscores are disallowed


(({ ets := Cedar.Data.Map.mk
            [({ id := "Photo", path := [] },
              Cedar.Validation.EntitySchemaEntry.standard
                { ancestors := Cedar.Data.Set.mk [{ id := "Action", path := [] }, { id := "Album", path := [] }],
                  attrs := Cedar.Data.Map.mk
                             [("flag",
                               Cedar.Validation.Qualified.optional
                                 (Cedar.Validation.CedarType.bool (Cedar.Validation.BoolType.anyBool)))],
                  tags := some (Cedar.Validation.CedarType.entity { id := "Action", path := [] }) })],
   acts := Cedar.Data.Map.mk
             [({ ty := { id := "Action", path := [] }, eid := "p1" },
               { appliesToPrincipal := Cedar.Data.Set.mk [{ id := "Album", path := [] }],
                 appliesToResource := Cedar.Data.Set.mk [{ id := "Foo", path := [] }, { id := "Photo", path := [] }],
                 ancestors := Cedar.Data.Set.mk [],
                 context := Cedar.Data.Map.mk [] })] },
 Cedar.Data.Map.mk
   [({ ty := { id := "Action", path := [] }, eid := "p1" },
     { attrs := Cedar.Data.Map.mk
                  [("0AAAC3Ea3 bA2`c\\CaC>BNcC5<3010,0\x0f:!cbAbE;UB",
                    Cedar.Spec.Value.set
                      (Cedar.Data.Set.mk [Cedar.Spec.Value.prim (Cedar.Spec.Prim.int { toUInt64 := 60 })])),
                   (":C3H2\\B,:\x16;\x0b`B02\x1d4\"0GCA\x0f:;B \\0BC ;9,CAAA\x1b  K2`01<,;A;CA/ /I,Jb ,B`\x1213\\ bC2/1b(\tA;:%cD3",
                    Cedar.Spec.Value.prim (Cedar.Spec.Prim.int { toUInt64 := 61 }))],
       ancestors := Cedar.Data.Set.mk [],
       tags := Cedar.Data.Map.mk [] })])) — validateEntities passed but action entity Action::"p1" has non-empty attrs


(({ ets := Cedar.Data.Map.mk
            [({ id := "User", path := [] },
              Cedar.Validation.EntitySchemaEntry.standard
                { ancestors := Cedar.Data.Set.mk [{ id := "Album", path := [] }],
                  attrs := Cedar.Data.Map.mk [],
                  tags := some (Cedar.Validation.CedarType.entity { id := "Foo", path := [] }) })],
   acts := Cedar.Data.Map.mk
             [({ ty := { id := "Photo", path := [] }, eid := "edit" },
               { appliesToPrincipal := Cedar.Data.Set.mk
                                         [{ id := "Action", path := [] },
                                          { id := "Album", path := [] },
                                          { id := "Foo", path := [] }],
                 appliesToResource := Cedar.Data.Set.mk [{ id := "Action", path := [] }, { id := "Photo", path := [] }],
                 ancestors := Cedar.Data.Set.mk [],
                 context := Cedar.Data.Map.mk
                              [("age",
                                Cedar.Validation.Qualified.required
                                  (Cedar.Validation.CedarType.ext (Cedar.Validation.ExtType.decimal))),
                               ("flag",
                                Cedar.Validation.Qualified.optional
                                  (Cedar.Validation.CedarType.entity { id := "Action", path := [] }))] })] },
 Cedar.Data.Map.mk
   [({ ty := { id := "Photo", path := [] }, eid := "edit" },
     { attrs := Cedar.Data.Map.mk
                  [(":\\ 0113`2;/",
                    Cedar.Spec.Value.set (Cedar.Data.Set.mk [Cedar.Spec.Value.prim (Cedar.Spec.Prim.string "age")])),
                   ("Cb0",
                    Cedar.Spec.Value.prim
                      (Cedar.Spec.Prim.entityUID { ty := { id := "Album", path := [] }, eid := "ghost" })),
                   ("\\a \x00\x04", Cedar.Spec.Value.record (Cedar.Data.Map.mk []))],
       ancestors := Cedar.Data.Set.mk [],
       tags := Cedar.Data.Map.mk [] })])) — validateEntities passed but action entity Photo::"edit" has non-empty attrs


(({ ets := Cedar.Data.Map.mk [],
   acts := Cedar.Data.Map.mk
             [({ ty := { id := "Album", path := [] }, eid := "x" },
               { appliesToPrincipal := Cedar.Data.Set.mk [{ id := "Album", path := [] }, { id := "User", path := [] }],
                 appliesToResource := Cedar.Data.Set.mk [{ id := "Album", path := [] }],
                 ancestors := Cedar.Data.Set.mk [],
                 context := Cedar.Data.Map.mk
                              [("flag",
                                Cedar.Validation.Qualified.required
                                  (Cedar.Validation.CedarType.bool (Cedar.Validation.BoolType.tt))),
                               ("name", Cedar.Validation.Qualified.required (Cedar.Validation.CedarType.int))] })] },
 Cedar.Data.Map.mk
   [({ ty := { id := "Album", path := [] }, eid := "x" },
     { attrs := Cedar.Data.Map.mk
                  [("\x01",
                    Cedar.Spec.Value.prim
                      (Cedar.Spec.Prim.entityUID { ty := { id := "Photo", path := [] }, eid := "a" })),
                   ("\x033,",
                    Cedar.Spec.Value.set
                      (Cedar.Data.Set.mk
                        [Cedar.Spec.Value.prim
                           (Cedar.Spec.Prim.entityUID { ty := { id := "User", path := [] }, eid := "x" }),
                         Cedar.Spec.Value.prim
                           (Cedar.Spec.Prim.entityUID { ty := { id := "User", path := [] }, eid := "z" })])),
                   ("1",
                    Cedar.Spec.Value.prim
                      (Cedar.Spec.Prim.entityUID { ty := { id := "Action", path := [] }, eid := "x" }))],
       ancestors := Cedar.Data.Set.mk [],
       tags := Cedar.Data.Map.mk [] })])) — validateEntities passed but action entity Album::"x" has non-empty attrs


(({ ets := Cedar.Data.Map.mk [],
   acts := Cedar.Data.Map.mk
             [({ ty := { id := "Album", path := [] }, eid := "a" },
               { appliesToPrincipal := Cedar.Data.Set.mk [{ id := "Photo", path := [] }],
                 appliesToResource := Cedar.Data.Set.mk [{ id := "Action", path := [] }, { id := "User", path := [] }],
                 ancestors := Cedar.Data.Set.mk [],
                 context := Cedar.Data.Map.mk [] })] },
 Cedar.Data.Map.mk
   [({ ty := { id := "Album", path := [] }, eid := "a" },
     { attrs := Cedar.Data.Map.mk
                  [("\x04,ac\x1f1A9\\\x05\\3B0 4Ac%,1C;;CC394\x06c,;:`", Cedar.Spec.Value.set (Cedar.Data.Set.mk [])),
                   ("Bc-;802\x18C2BA,`2<3\\>\x1a :`0/A;:'2\x1e-aAb;BA1 \"&C",
                    Cedar.Spec.Value.record
                      (Cedar.Data.Map.mk
                        [("age",
                          Cedar.Spec.Value.prim
                            (Cedar.Spec.Prim.entityUID { ty := { id := "Action", path := [] }, eid := "p1" }))]))],
       ancestors := Cedar.Data.Set.mk [],
       tags := Cedar.Data.Map.mk [] })])) — validateEntities passed but action entity Album::"a" has non-empty attrs


(({ ets := Cedar.Data.Map.mk
            [({ id := "Foo", path := [] },
              Cedar.Validation.EntitySchemaEntry.standard
                { ancestors := Cedar.Data.Set.mk
                                 [{ id := "Album", path := [] },
                                  { id := "Foo", path := [] },
                                  { id := "User", path := [] }],
                  attrs := Cedar.Data.Map.mk [],
                  tags := none })],
   acts := Cedar.Data.Map.mk
             [({ ty := { id := "Photo", path := [] }, eid := "bob" },
               { appliesToPrincipal := Cedar.Data.Set.mk [{ id := "Action", path := [] }, { id := "User", path := [] }],
                 appliesToResource := Cedar.Data.Set.mk [{ id := "Foo", path := [] }],
                 ancestors := Cedar.Data.Set.mk [],
                 context := Cedar.Data.Map.mk
                              [("age",
                                Cedar.Validation.Qualified.optional
                                  (Cedar.Validation.CedarType.ext (Cedar.Validation.ExtType.datetime))),
                               ("flag",
                                Cedar.Validation.Qualified.required
                                  (Cedar.Validation.CedarType.bool (Cedar.Validation.BoolType.ff)))] })] },
 Cedar.Data.Map.mk
   [({ ty := { id := "Foo", path := [] }, eid := "x" },
     { attrs := Cedar.Data.Map.mk [], ancestors := Cedar.Data.Set.mk [], tags := Cedar.Data.Map.mk [] }),
    ({ ty := { id := "Photo", path := [] }, eid := "bob" },
     { attrs := Cedar.Data.Map.mk [("`$01+\x06C;,", Cedar.Spec.Value.prim (Cedar.Spec.Prim.int { toUInt64 := 89 }))],
       ancestors := Cedar.Data.Set.mk [],
       tags := Cedar.Data.Map.mk [] })])) — validateEntities passed but action entity Photo::"bob" has non-empty attrs


(({ ets := Cedar.Data.Map.mk
            [({ id := "Photo", path := [] },
              Cedar.Validation.EntitySchemaEntry.standard
                { ancestors := Cedar.Data.Set.mk
                                 [{ id := "Action", path := [] },
                                  { id := "Foo", path := [] },
                                  { id := "Photo", path := [] }],
                  attrs := Cedar.Data.Map.mk
                             [("owner", Cedar.Validation.Qualified.optional (Cedar.Validation.CedarType.string))],
                  tags := none })],
   acts := Cedar.Data.Map.mk
             [({ ty := { id := "Album", path := [] }, eid := "ghost" },
               { appliesToPrincipal := Cedar.Data.Set.mk
                                         [{ id := "Album", path := [] },
                                          { id := "Foo", path := [] },
                                          { id := "Photo", path := [] }],
                 appliesToResource := Cedar.Data.Set.mk [{ id := "Action", path := [] }],
                 ancestors := Cedar.Data.Set.mk [],
                 context := Cedar.Data.Map.mk [] })] },
 Cedar.Data.Map.mk
   [({ ty := { id := "Album", path := [] }, eid := "ghost" },
     { attrs := Cedar.Data.Map.mk
                  [("\x1dbA/B\x1c2,,c0B\\1:a1CC`, 1,>\x11;2c:\x18Cc,0\x12,3`b1;33,a1\\BA",
                    Cedar.Spec.Value.set (Cedar.Data.Set.mk []))],
       ancestors := Cedar.Data.Set.mk [],
       tags := Cedar.Data.Map.mk [] })])) — validateEntities passed but action entity Album::"ghost" has non-empty attrs


(({ ets := Cedar.Data.Map.mk
            [({ id := "Action", path := [] },
              Cedar.Validation.EntitySchemaEntry.standard
                { ancestors := Cedar.Data.Set.mk [{ id := "Foo", path := [] }],
                  attrs := Cedar.Data.Map.mk
                             [("name",
                               Cedar.Validation.Qualified.required
                                 (Cedar.Validation.CedarType.entity { id := "Action", path := [] })),
                              ("owner", Cedar.Validation.Qualified.optional (Cedar.Validation.CedarType.int))],
                  tags := none })],
   acts := Cedar.Data.Map.mk
             [({ ty := { id := "Foo", path := [] }, eid := "bob" },
               { appliesToPrincipal := Cedar.Data.Set.mk [{ id := "Photo", path := [] }],
                 appliesToResource := Cedar.Data.Set.mk [{ id := "Album", path := [] }, { id := "Photo", path := [] }],
                 ancestors := Cedar.Data.Set.mk [],
                 context := Cedar.Data.Map.mk
                              [("flag", Cedar.Validation.Qualified.optional (Cedar.Validation.CedarType.int)),
                               ("owner",
                                Cedar.Validation.Qualified.required
                                  (Cedar.Validation.CedarType.bool (Cedar.Validation.BoolType.anyBool)))] })] },
 Cedar.Data.Map.mk
   [({ ty := { id := "Foo", path := [] }, eid := "bob" },
     { attrs := Cedar.Data.Map.mk
                  [("2 20`9cC1#`bB\x19B:0\"32:`C2B\x07C:3\x0d;C\\\x05)C;\x06/0*;a2 ",
                    Cedar.Spec.Value.set
                      (Cedar.Data.Set.mk
                        [Cedar.Spec.Value.prim (Cedar.Spec.Prim.int { toUInt64 := 25 }),
                         Cedar.Spec.Value.prim (Cedar.Spec.Prim.bool true)]))],
       ancestors := Cedar.Data.Set.mk [],
       tags := Cedar.Data.Map.mk [] })])) — validateEntities passed but action entity Foo::"bob" has non-empty attrs


(({ ets := Cedar.Data.Map.mk
            [({ id := "Foo", path := [] },
              Cedar.Validation.EntitySchemaEntry.standard
                { ancestors := Cedar.Data.Set.mk [{ id := "Action", path := [] }, { id := "Album", path := [] }],
                  attrs := Cedar.Data.Map.mk
                             [("flag",
                               Cedar.Validation.Qualified.optional
                                 (Cedar.Validation.CedarType.bool (Cedar.Validation.BoolType.ff)))],
                  tags := some (Cedar.Validation.CedarType.string) }),
             ({ id := "User", path := [] },
              Cedar.Validation.EntitySchemaEntry.standard
                { ancestors := Cedar.Data.Set.mk [],
                  attrs := Cedar.Data.Map.mk [],
                  tags := some (Cedar.Validation.CedarType.int) })],
   acts := Cedar.Data.Map.mk
             [({ ty := { id := "Album", path := [] }, eid := "bob" },
               { appliesToPrincipal := Cedar.Data.Set.mk [{ id := "User", path := [] }],
                 appliesToResource := Cedar.Data.Set.mk [{ id := "Foo", path := [] }],
                 ancestors := Cedar.Data.Set.mk [],
                 context := Cedar.Data.Map.mk
                              [("name", Cedar.Validation.Qualified.required (Cedar.Validation.CedarType.int))] })] },
 Cedar.Data.Map.mk
   [({ ty := { id := "Album", path := [] }, eid := "bob" },
     { attrs := Cedar.Data.Map.mk
                  [("\x14:1Ca3b\x14G,B\\#3AF9\x0b3;cC", Cedar.Spec.Value.prim (Cedar.Spec.Prim.string "flag"))],
       ancestors := Cedar.Data.Set.mk [],
       tags := Cedar.Data.Map.mk [] })])) — validateEntities passed but action entity Album::"bob" has non-empty attrs


(({ ets := Cedar.Data.Map.mk
            [({ id := "Action", path := [] },
              Cedar.Validation.EntitySchemaEntry.standard
                { ancestors := Cedar.Data.Set.mk [],
                  attrs := Cedar.Data.Map.mk
                             [("flag",
                               Cedar.Validation.Qualified.optional
                                 (Cedar.Validation.CedarType.bool (Cedar.Validation.BoolType.anyBool))),
                              ("owner",
                               Cedar.Validation.Qualified.required
                                 (Cedar.Validation.CedarType.entity { id := "Photo", path := [] }))],
                  tags := none }),
             ({ id := "Foo", path := [] },
              Cedar.Validation.EntitySchemaEntry.standard
                { ancestors := Cedar.Data.Set.mk [{ id := "Action", path := [] }],
                  attrs := Cedar.Data.Map.mk
                             [("flag", Cedar.Validation.Qualified.required (Cedar.Validation.CedarType.int))],
                  tags := some (Cedar.Validation.CedarType.string) })],
   acts := Cedar.Data.Map.mk
             [({ ty := { id := "Photo", path := [] }, eid := "a" },
               { appliesToPrincipal := Cedar.Data.Set.mk
                                         [{ id := "Foo", path := [] },
                                          { id := "Photo", path := [] },
                                          { id := "User", path := [] }],
                 appliesToResource := Cedar.Data.Set.mk [{ id := "Foo", path := [] }],
                 ancestors := Cedar.Data.Set.mk [],
                 context := Cedar.Data.Map.mk
                              [("age", Cedar.Validation.Qualified.required (Cedar.Validation.CedarType.int)),
                               ("name", Cedar.Validation.Qualified.optional (Cedar.Validation.CedarType.string))] })] },
 Cedar.Data.Map.mk
   [({ ty := { id := "Photo", path := [] }, eid := "a" },
     { attrs := Cedar.Data.Map.mk
                  [("':-3\x0012` T :D,``::%c.`110A;c)03/:1?B\\\x14Cb,c4.  b1c>:b\\\x00b,`",
                    Cedar.Spec.Value.set
                      (Cedar.Data.Set.mk
                        [Cedar.Spec.Value.prim (Cedar.Spec.Prim.bool false),
                         Cedar.Spec.Value.prim
                           (Cedar.Spec.Prim.entityUID { ty := { id := "Action", path := [] }, eid := "bob" })])),
                   ("1/aA(1,,\\ \x0e`B `B;%3\\ acA0\\c/b/A\x18/a1A0caA;;;E\x10",
                    Cedar.Spec.Value.prim (Cedar.Spec.Prim.int { toUInt64 := 28 }))],
       ancestors := Cedar.Data.Set.mk [],
       tags := Cedar.Data.Map.mk [] })])) — validateEntities passed but action entity Photo::"a" has non-empty attrs


(({ ets := Cedar.Data.Map.mk
            [({ id := "User", path := [] },
              Cedar.Validation.EntitySchemaEntry.standard
                { ancestors := Cedar.Data.Set.mk [{ id := "Photo", path := [] }, { id := "User", path := [] }],
                  attrs := Cedar.Data.Map.mk
                             [("owner", Cedar.Validation.Qualified.optional (Cedar.Validation.CedarType.int))],
                  tags := none })],
   acts := Cedar.Data.Map.mk
             [({ ty := { id := "Photo", path := [] }, eid := "edit" },
               { appliesToPrincipal := Cedar.Data.Set.mk [{ id := "Album", path := [] }],
                 appliesToResource := Cedar.Data.Set.mk [{ id := "Action", path := [] }, { id := "Foo", path := [] }],
                 ancestors := Cedar.Data.Set.mk [],
                 context := Cedar.Data.Map.mk
                              [("owner",
                                Cedar.Validation.Qualified.optional (Cedar.Validation.CedarType.string))] })] },
 Cedar.Data.Map.mk
   [({ ty := { id := "Photo", path := [] }, eid := "edit" },
     { attrs := Cedar.Data.Map.mk
                  [("0\t,A\x0721\\0c\t2\x122",
                    Cedar.Spec.Value.record
                      (Cedar.Data.Map.mk
                        [("age",
                          Cedar.Spec.Value.prim
                            (Cedar.Spec.Prim.entityUID { ty := { id := "Photo", path := [] }, eid := "x" })),
                         ("flag",
                          Cedar.Spec.Value.prim
                            (Cedar.Spec.Prim.entityUID { ty := { id := "Album", path := [] }, eid := "view" }))])),
                   ("1A;1/\\ c;\n\x16\x14\x04a/\x130A\x12A\x193",
                    Cedar.Spec.Value.set
                      (Cedar.Data.Set.mk
                        [Cedar.Spec.Value.prim
                           (Cedar.Spec.Prim.entityUID { ty := { id := "Photo", path := [] }, eid := "edit" }),
                         Cedar.Spec.Value.prim (Cedar.Spec.Prim.bool false)])),
                   ("a\x13`\\\x05C",
                    Cedar.Spec.Value.prim
                      (Cedar.Spec.Prim.entityUID { ty := { id := "Album", path := [] }, eid := "bob" }))],
       ancestors := Cedar.Data.Set.mk [],
       tags := Cedar.Data.Map.mk [] })])) — validateEntities passed but action entity Photo::"edit" has non-empty attrs


validateEntities passed but action entity Action::"a" has non-empty attrs


encodeString("x\"y") wrapped to "\"x\"y\"" has 3 '"' (odd; malformed SMT)


(([{ id := "p0",
    effect := Cedar.Spec.Effect.permit,
    principalScope := Cedar.Spec.PrincipalScope.principalScope (Cedar.Spec.Scope.any),
    actionScope := Cedar.Spec.ActionScope.actionScope (Cedar.Spec.Scope.is { id := "Action", path := [] }),
    resourceScope := Cedar.Spec.ResourceScope.resourceScope (Cedar.Spec.Scope.is { id := "User", path := [] }),
    condition := [] }],
 { ets := Cedar.Data.Map.mk [],
   acts := Cedar.Data.Map.mk
             [({ ty := { id := "Action", path := [] }, eid := "z" },
               { appliesToPrincipal := Cedar.Data.Set.mk [{ id := "Album", path := [] }, { id := "User", path := [] }],
                 appliesToResource := Cedar.Data.Set.mk [{ id := "Action", path := [] }, { id := "User", path := [] }],
                 ancestors := Cedar.Data.Set.mk [],
                 context := Cedar.Data.Map.mk
                              [("owner", Cedar.Validation.Qualified.required (Cedar.Validation.CedarType.string))] }),
              ({ ty := { id := "Album", path := [] }, eid := "ghost" },
               { appliesToPrincipal := Cedar.Data.Set.mk [{ id := "User", path := [] }],
                 appliesToResource := Cedar.Data.Set.mk [{ id := "Foo", path := [] }],
                 ancestors := Cedar.Data.Set.mk
                                [{ ty := { id := "Album", path := [] }, eid := "x" },
                                 { ty := { id := "Photo", path := [] }, eid := "bob" }],
                 context := Cedar.Data.Map.mk [] }),
              ({ ty := { id := "Foo", path := [] }, eid := "p1" },
               { appliesToPrincipal := Cedar.Data.Set.mk
                                         [{ id := "Action", path := [] },
                                          { id := "Photo", path := [] },
                                          { id := "User", path := [] }],
                 appliesToResource := Cedar.Data.Set.mk [],
                 ancestors := Cedar.Data.Set.mk
                                [{ ty := { id := "Photo", path := [] }, eid := "x" },
                                 { ty := { id := "Photo", path := [] }, eid := "z" },
                                 { ty := { id := "User", path := [] }, eid := "b" }],
                 context := Cedar.Data.Map.mk [] })] })) — validate passed but policy p0 references undeclared entities


(([{ id := "p1",
    effect := Cedar.Spec.Effect.permit,
    principalScope := Cedar.Spec.PrincipalScope.principalScope (Cedar.Spec.Scope.any),
    actionScope := Cedar.Spec.ActionScope.actionScope (Cedar.Spec.Scope.any),
    resourceScope := Cedar.Spec.ResourceScope.resourceScope (Cedar.Spec.Scope.is { id := "Foo", path := [] }),
    condition := [] }],
 { ets := Cedar.Data.Map.mk
            [({ id := "Album", path := [] },
              Cedar.Validation.EntitySchemaEntry.standard
                { ancestors := Cedar.Data.Set.mk
                                 [{ id := "Action", path := [] },
                                  { id := "Album", path := [] },
                                  { id := "Foo", path := [] }],
                  attrs := Cedar.Data.Map.mk [],
                  tags := none }),
             ({ id := "Photo", path := [] }, Cedar.Validation.EntitySchemaEntry.enum (Cedar.Data.Set.mk ["a", "y"]))],
   acts := Cedar.Data.Map.mk
             [({ ty := { id := "Album", path := [] }, eid := "z" },
               { appliesToPrincipal := Cedar.Data.Set.mk [],
                 appliesToResource := Cedar.Data.Set.mk [],
                 ancestors := Cedar.Data.Set.mk [],
                 context := Cedar.Data.Map.mk
                              [("owner",
                                Cedar.Validation.Qualified.optional
                                  (Cedar.Validation.CedarType.bool (Cedar.Validation.BoolType.tt)))] }),
              ({ ty := { id := "Photo", path := [] }, eid := "b" },
               { appliesToPrincipal := Cedar.Data.Set.mk
                                         [{ id := "Action", path := [] },
                                          { id := "Album", path := [] },
                                          { id := "Foo", path := [] }],
                 appliesToResource := Cedar.Data.Set.mk [{ id := "Foo", path := [] }, { id := "Photo", path := [] }],
                 ancestors := Cedar.Data.Set.mk
                                [{ ty := { id := "Foo", path := [] }, eid := "y" },
                                 { ty := { id := "User", path := [] }, eid := "a" }],
                 context := Cedar.Data.Map.mk [] })] })) — validate passed but policy p1 references undeclared entities


(([{ id := "p2",
    effect := Cedar.Spec.Effect.forbid,
    principalScope := Cedar.Spec.PrincipalScope.principalScope (Cedar.Spec.Scope.any),
    actionScope := Cedar.Spec.ActionScope.actionScope (Cedar.Spec.Scope.is { id := "Action", path := [] }),
    resourceScope := Cedar.Spec.ResourceScope.resourceScope (Cedar.Spec.Scope.is { id := "Photo", path := [] }),
    condition := [] }],
 { ets := Cedar.Data.Map.mk [],
   acts := Cedar.Data.Map.mk
             [({ ty := { id := "Action", path := [] }, eid := "edit" },
               { appliesToPrincipal := Cedar.Data.Set.mk [{ id := "Action", path := [] }, { id := "Foo", path := [] }],
                 appliesToResource := Cedar.Data.Set.mk [{ id := "Album", path := [] }, { id := "Photo", path := [] }],
                 ancestors := Cedar.Data.Set.mk
                                [{ ty := { id := "Foo", path := [] }, eid := "alice" },
                                 { ty := { id := "Foo", path := [] }, eid := "bob" },
                                 { ty := { id := "User", path := [] }, eid := "b" }],
                 context := Cedar.Data.Map.mk
                              [("name",
                                Cedar.Validation.Qualified.required
                                  (Cedar.Validation.CedarType.entity { id := "Foo", path := [] }))] }),
              ({ ty := { id := "Foo", path := [] }, eid := "alice" },
               { appliesToPrincipal := Cedar.Data.Set.mk [],
                 appliesToResource := Cedar.Data.Set.mk [],
                 ancestors := Cedar.Data.Set.mk
                                [{ ty := { id := "Foo", path := [] }, eid := "view" },
                                 { ty := { id := "Photo", path := [] }, eid := "a" }],
                 context := Cedar.Data.Map.mk
                              [("flag",
                                Cedar.Validation.Qualified.required
                                  (Cedar.Validation.CedarType.entity { id := "User", path := [] }))] })] })) — validate passed but policy p2 references undeclared entities


(([{ id := "p2",
    effect := Cedar.Spec.Effect.permit,
    principalScope := Cedar.Spec.PrincipalScope.principalScope (Cedar.Spec.Scope.any),
    actionScope := Cedar.Spec.ActionScope.actionScope (Cedar.Spec.Scope.any),
    resourceScope := Cedar.Spec.ResourceScope.resourceScope (Cedar.Spec.Scope.is { id := "Foo", path := [] }),
    condition := [] }],
 { ets := Cedar.Data.Map.mk
            [({ id := "Album", path := [] },
              Cedar.Validation.EntitySchemaEntry.standard
                { ancestors := Cedar.Data.Set.mk [{ id := "Foo", path := [] }],
                  attrs := Cedar.Data.Map.mk [],
                  tags := none }),
             ({ id := "User", path := [] },
              Cedar.Validation.EntitySchemaEntry.standard
                { ancestors := Cedar.Data.Set.mk [{ id := "Photo", path := [] }, { id := "User", path := [] }],
                  attrs := Cedar.Data.Map.mk [],
                  tags := none })],
   acts := Cedar.Data.Map.mk
             [({ ty := { id := "Album", path := [] }, eid := "bob" },
               { appliesToPrincipal := Cedar.Data.Set.mk [{ id := "Photo", path := [] }, { id := "User", path := [] }],
                 appliesToResource := Cedar.Data.Set.mk [{ id := "Foo", path := [] }],
                 ancestors := Cedar.Data.Set.mk
                                [{ ty := { id := "Action", path := [] }, eid := "ghost" },
                                 { ty := { id := "Photo", path := [] }, eid := "alice" }],
                 context := Cedar.Data.Map.mk
                              [("age", Cedar.Validation.Qualified.required (Cedar.Validation.CedarType.string))] }),
              ({ ty := { id := "Album", path := [] }, eid := "y" },
               { appliesToPrincipal := Cedar.Data.Set.mk [{ id := "Album", path := [] }, { id := "Photo", path := [] }],
                 appliesToResource := Cedar.Data.Set.mk [],
                 ancestors := Cedar.Data.Set.mk
                                [{ ty := { id := "Action", path := [] }, eid := "edit" },
                                 { ty := { id := "Foo", path := [] }, eid := "x" }],
                 context := Cedar.Data.Map.mk [] }),
              ({ ty := { id := "User", path := [] }, eid := "view" },
               { appliesToPrincipal := Cedar.Data.Set.mk [{ id := "Photo", path := [] }],
                 appliesToResource := Cedar.Data.Set.mk [{ id := "Album", path := [] }],
                 ancestors := Cedar.Data.Set.mk [],
                 context := Cedar.Data.Map.mk [] })] })) — validate passed but policy p2 references undeclared entities


(([{ id := "p0",
    effect := Cedar.Spec.Effect.forbid,
    principalScope := Cedar.Spec.PrincipalScope.principalScope (Cedar.Spec.Scope.is { id := "User", path := [] }),
    actionScope := Cedar.Spec.ActionScope.actionScope (Cedar.Spec.Scope.is { id := "Action", path := [] }),
    resourceScope := Cedar.Spec.ResourceScope.resourceScope (Cedar.Spec.Scope.any),
    condition := [{ kind := Cedar.Spec.ConditionKind.unless,
                    body := Cedar.Spec.Expr.and
                              (Cedar.Spec.Expr.binaryApp
                                (Cedar.Spec.BinaryOp.eq)
                                (Cedar.Spec.Expr.lit (Cedar.Spec.Prim.int { toUInt64 := 60 }))
                                (Cedar.Spec.Expr.lit (Cedar.Spec.Prim.int { toUInt64 := 7 })))
                              (Cedar.Spec.Expr.or
                                (Cedar.Spec.Expr.lit
                                  (Cedar.Spec.Prim.entityUID { ty := { id := "Album", path := [] }, eid := "a" }))
                                (Cedar.Spec.Expr.var (Cedar.Spec.Var.principal))) }] }],
 { ets := Cedar.Data.Map.mk
            [({ id := "Foo", path := [] }, Cedar.Validation.EntitySchemaEntry.enum (Cedar.Data.Set.mk []))],
   acts := Cedar.Data.Map.mk
             [({ ty := { id := "Action", path := [] }, eid := "z" },
               { appliesToPrincipal := Cedar.Data.Set.mk
                                         [{ id := "Action", path := [] },
                                          { id := "Foo", path := [] },
                                          { id := "User", path := [] }],
                 appliesToResource := Cedar.Data.Set.mk [{ id := "Foo", path := [] }],
                 ancestors := Cedar.Data.Set.mk
                                [{ ty := { id := "Album", path := [] }, eid := "x" },
                                 { ty := { id := "User", path := [] }, eid := "a" }],
                 context := Cedar.Data.Map.mk
                              [("name",
                                Cedar.Validation.Qualified.required
                                  (Cedar.Validation.CedarType.ext (Cedar.Validation.ExtType.duration)))] }),
              ({ ty := { id := "Album", path := [] }, eid := "alice" },
               { appliesToPrincipal := Cedar.Data.Set.mk [{ id := "Photo", path := [] }, { id := "User", path := [] }],
                 appliesToResource := Cedar.Data.Set.mk [{ id := "Action", path := [] }],
                 ancestors := Cedar.Data.Set.mk [],
                 context := Cedar.Data.Map.mk [] }),
              ({ ty := { id := "Photo", path := [] }, eid := "view" },
               { appliesToPrincipal := Cedar.Data.Set.mk [{ id := "Album", path := [] }],
                 appliesToResource := Cedar.Data.Set.mk [{ id := "Album", path := [] }],
                 ancestors := Cedar.Data.Set.mk
                                [{ ty := { id := "Album", path := [] }, eid := "view" },
                                 { ty := { id := "Photo", path := [] }, eid := "y" }],
                 context := Cedar.Data.Map.mk [] })] })) — validate passed but policy p0 references undeclared entities


(([{ id := "p2",
    effect := Cedar.Spec.Effect.forbid,
    principalScope := Cedar.Spec.PrincipalScope.principalScope (Cedar.Spec.Scope.any),
    actionScope := Cedar.Spec.ActionScope.actionScope (Cedar.Spec.Scope.any),
    resourceScope := Cedar.Spec.ResourceScope.resourceScope (Cedar.Spec.Scope.is { id := "Action", path := [] }),
    condition := [] }],
 { ets := Cedar.Data.Map.mk [],
   acts := Cedar.Data.Map.mk
             [({ ty := { id := "Foo", path := [] }, eid := "ghost" },
               { appliesToPrincipal := Cedar.Data.Set.mk [{ id := "Foo", path := [] }],
                 appliesToResource := Cedar.Data.Set.mk
                                        [{ id := "Action", path := [] },
                                         { id := "Album", path := [] },
                                         { id := "Foo", path := [] }],
                 ancestors := Cedar.Data.Set.mk
                                [{ ty := { id := "Action", path := [] }, eid := "a" },
                                 { ty := { id := "Foo", path := [] }, eid := "view" }],
                 context := Cedar.Data.Map.mk
                              [("flag",
                                Cedar.Validation.Qualified.required
                                  (Cedar.Validation.CedarType.ext (Cedar.Validation.ExtType.datetime))),
                               ("name",
                                Cedar.Validation.Qualified.optional
                                  (Cedar.Validation.CedarType.bool (Cedar.Validation.BoolType.tt)))] })] })) — validate passed but policy p2 references undeclared entities


(([{ id := "p2",
    effect := Cedar.Spec.Effect.forbid,
    principalScope := Cedar.Spec.PrincipalScope.principalScope (Cedar.Spec.Scope.is { id := "Foo", path := [] }),
    actionScope := Cedar.Spec.ActionScope.actionScope (Cedar.Spec.Scope.any),
    resourceScope := Cedar.Spec.ResourceScope.resourceScope (Cedar.Spec.Scope.any),
    condition := [] }],
 { ets := Cedar.Data.Map.mk [],
   acts := Cedar.Data.Map.mk
             [({ ty := { id := "Action", path := [] }, eid := "x" },
               { appliesToPrincipal := Cedar.Data.Set.mk [{ id := "Foo", path := [] }, { id := "Photo", path := [] }],
                 appliesToResource := Cedar.Data.Set.mk
                                        [{ id := "Action", path := [] },
                                         { id := "Foo", path := [] },
                                         { id := "User", path := [] }],
                 ancestors := Cedar.Data.Set.mk [{ ty := { id := "Album", path := [] }, eid := "alice" }],
                 context := Cedar.Data.Map.mk [] })] })) — validate passed but policy p2 references undeclared entities


(([{ id := "p2",
    effect := Cedar.Spec.Effect.permit,
    principalScope := Cedar.Spec.PrincipalScope.principalScope (Cedar.Spec.Scope.any),
    actionScope := Cedar.Spec.ActionScope.actionScope
                     (Cedar.Spec.Scope.mem { ty := { id := "Photo", path := [] }, eid := "x" }),
    resourceScope := Cedar.Spec.ResourceScope.resourceScope (Cedar.Spec.Scope.is { id := "User", path := [] }),
    condition := [] }],
 { ets := Cedar.Data.Map.mk [],
   acts := Cedar.Data.Map.mk
             [({ ty := { id := "Action", path := [] }, eid := "edit" },
               { appliesToPrincipal := Cedar.Data.Set.mk [{ id := "Album", path := [] }, { id := "Photo", path := [] }],
                 appliesToResource := Cedar.Data.Set.mk [{ id := "Album", path := [] }, { id := "Foo", path := [] }],
                 ancestors := Cedar.Data.Set.mk [{ ty := { id := "User", path := [] }, eid := "z" }],
                 context := Cedar.Data.Map.mk
                              [("name", Cedar.Validation.Qualified.required (Cedar.Validation.CedarType.int))] }),
              ({ ty := { id := "Photo", path := [] }, eid := "x" },
               { appliesToPrincipal := Cedar.Data.Set.mk [{ id := "Action", path := [] }],
                 appliesToResource := Cedar.Data.Set.mk [{ id := "Action", path := [] }, { id := "User", path := [] }],
                 ancestors := Cedar.Data.Set.mk
                                [{ ty := { id := "Album", path := [] }, eid := "z" },
                                 { ty := { id := "User", path := [] }, eid := "b" }],
                 context := Cedar.Data.Map.mk
                              [("age",
                                Cedar.Validation.Qualified.optional
                                  (Cedar.Validation.CedarType.bool (Cedar.Validation.BoolType.ff)))] })] })) — validate passed but policy p2 references undeclared entities


(([{ id := "p0",
    effect := Cedar.Spec.Effect.forbid,
    principalScope := Cedar.Spec.PrincipalScope.principalScope
                        (Cedar.Spec.Scope.eq { ty := { id := "Photo", path := [] }, eid := "y" }),
    actionScope := Cedar.Spec.ActionScope.actionScope (Cedar.Spec.Scope.any),
    resourceScope := Cedar.Spec.ResourceScope.resourceScope (Cedar.Spec.Scope.is { id := "Album", path := [] }),
    condition := [] }],
 { ets := Cedar.Data.Map.mk
            [({ id := "Photo", path := [] },
              Cedar.Validation.EntitySchemaEntry.standard
                { ancestors := Cedar.Data.Set.mk [{ id := "Action", path := [] }, { id := "Photo", path := [] }],
                  attrs := Cedar.Data.Map.mk
                             [("age",
                               Cedar.Validation.Qualified.optional
                                 (Cedar.Validation.CedarType.entity { id := "User", path := [] }))],
                  tags := none })],
   acts := Cedar.Data.Map.mk
             [({ ty := { id := "Foo", path := [] }, eid := "alice" },
               { appliesToPrincipal := Cedar.Data.Set.mk [{ id := "Photo", path := [] }, { id := "User", path := [] }],
                 appliesToResource := Cedar.Data.Set.mk [{ id := "Album", path := [] }, { id := "Photo", path := [] }],
                 ancestors := Cedar.Data.Set.mk [{ ty := { id := "User", path := [] }, eid := "b" }],
                 context := Cedar.Data.Map.mk [] })] })) — validate passed but policy p0 references undeclared entities


(([{ id := "p0",
    effect := Cedar.Spec.Effect.forbid,
    principalScope := Cedar.Spec.PrincipalScope.principalScope (Cedar.Spec.Scope.any),
    actionScope := Cedar.Spec.ActionScope.actionScope (Cedar.Spec.Scope.any),
    resourceScope := Cedar.Spec.ResourceScope.resourceScope (Cedar.Spec.Scope.is { id := "Photo", path := [] }),
    condition := [] }],
 { ets := Cedar.Data.Map.mk [],
   acts := Cedar.Data.Map.mk
             [({ ty := { id := "Action", path := [] }, eid := "ghost" },
               { appliesToPrincipal := Cedar.Data.Set.mk [{ id := "Foo", path := [] }, { id := "User", path := [] }],
                 appliesToResource := Cedar.Data.Set.mk [{ id := "Photo", path := [] }, { id := "User", path := [] }],
                 ancestors := Cedar.Data.Set.mk [{ ty := { id := "User", path := [] }, eid := "p1" }],
                 context := Cedar.Data.Map.mk
                              [("flag",
                                Cedar.Validation.Qualified.required
                                  (Cedar.Validation.CedarType.bool (Cedar.Validation.BoolType.anyBool)))] })] })) — validate passed but policy p0 references undeclared entities


validate passed but policy p0 references undeclared entities


(({ ets := Cedar.Data.Map.mk
            [({ id := "User", path := [] },
              Cedar.Validation.EntitySchemaEntry.standard
                { ancestors := Cedar.Data.Set.mk
                                 [{ id := "Foo", path := [] },
                                  { id := "Photo", path := [] },
                                  { id := "User", path := [] }],
                  attrs := Cedar.Data.Map.mk
                             [("owner", Cedar.Validation.Qualified.required (Cedar.Validation.CedarType.string))],
                  tags := none })],
   acts := Cedar.Data.Map.mk
             [({ ty := { id := "Album", path := [] }, eid := "bob" },
               { appliesToPrincipal := Cedar.Data.Set.mk [{ id := "Album", path := [] }],
                 appliesToResource := Cedar.Data.Set.mk [{ id := "Album", path := [] }, { id := "Foo", path := [] }],
                 ancestors := Cedar.Data.Set.mk
                                [{ ty := { id := "Action", path := [] }, eid := "a" },
                                 { ty := { id := "Photo", path := [] }, eid := "alice" }],
                 context := Cedar.Data.Map.mk
                              [("flag", Cedar.Validation.Qualified.optional (Cedar.Validation.CedarType.int)),
                               ("name",
                                Cedar.Validation.Qualified.optional
                                  (Cedar.Validation.CedarType.ext (Cedar.Validation.ExtType.duration)))] })] },
 { principal := { ty := { id := "Album", path := [] }, eid := "b" },
   action := { ty := { id := "Album", path := [] }, eid := "bob" },
   resource := { ty := { id := "Foo", path := [] }, eid := "z" },
   context := Cedar.Data.Map.mk [] })) — validateRequest passed but principal Album::"b" is not declared in schema


(({ ets := Cedar.Data.Map.mk
            [({ id := "Action", path := [] }, Cedar.Validation.EntitySchemaEntry.enum (Cedar.Data.Set.mk ["a", "y"])),
             ({ id := "Album", path := [] },
              Cedar.Validation.EntitySchemaEntry.standard
                { ancestors := Cedar.Data.Set.mk [{ id := "Foo", path := [] }],
                  attrs := Cedar.Data.Map.mk
                             [("age", Cedar.Validation.Qualified.required (Cedar.Validation.CedarType.string)),
                              ("name", Cedar.Validation.Qualified.required (Cedar.Validation.CedarType.string))],
                  tags := none }),
             ({ id := "User", path := [] },
              Cedar.Validation.EntitySchemaEntry.standard
                { ancestors := Cedar.Data.Set.mk [{ id := "Action", path := [] }, { id := "Album", path := [] }],
                  attrs := Cedar.Data.Map.mk
                             [("name", Cedar.Validation.Qualified.required (Cedar.Validation.CedarType.string))],
                  tags := some (Cedar.Validation.CedarType.entity { id := "User", path := [] }) })],
   acts := Cedar.Data.Map.mk
             [({ ty := { id := "Album", path := [] }, eid := "z" },
               { appliesToPrincipal := Cedar.Data.Set.mk [{ id := "Action", path := [] }, { id := "Foo", path := [] }],
                 appliesToResource := Cedar.Data.Set.mk [{ id := "Foo", path := [] }, { id := "User", path := [] }],
                 ancestors := Cedar.Data.Set.mk
                                [{ ty := { id := "Action", path := [] }, eid := "ghost" },
                                 { ty := { id := "Foo", path := [] }, eid := "view" },
                                 { ty := { id := "Photo", path := [] }, eid := "edit" }],
                 context := Cedar.Data.Map.mk [] }),
              ({ ty := { id := "Foo", path := [] }, eid := "p1" },
               { appliesToPrincipal := Cedar.Data.Set.mk
                                         [{ id := "Action", path := [] },
                                          { id := "Album", path := [] },
                                          { id := "User", path := [] }],
                 appliesToResource := Cedar.Data.Set.mk [{ id := "Photo", path := [] }, { id := "User", path := [] }],
                 ancestors := Cedar.Data.Set.mk
                                [{ ty := { id := "Album", path := [] }, eid := "edit" },
                                 { ty := { id := "Photo", path := [] }, eid := "z" },
                                 { ty := { id := "User", path := [] }, eid := "bob" }],
                 context := Cedar.Data.Map.mk [] }),
              ({ ty := { id := "User", path := [] }, eid := "edit" },
               { appliesToPrincipal := Cedar.Data.Set.mk [],
                 appliesToResource := Cedar.Data.Set.mk [{ id := "Album", path := [] }],
                 ancestors := Cedar.Data.Set.mk [],
                 context := Cedar.Data.Map.mk
                              [("age",
                                Cedar.Validation.Qualified.required
                                  (Cedar.Validation.CedarType.bool (Cedar.Validation.BoolType.anyBool)))] })] },
 { principal := { ty := { id := "Action", path := [] }, eid := "view" },
   action := { ty := { id := "Foo", path := [] }, eid := "p1" },
   resource := { ty := { id := "Photo", path := [] }, eid := "alice" },
   context := Cedar.Data.Map.mk [] })) — validateRequest passed but principal Action::"view" is not declared in schema


(({ ets := Cedar.Data.Map.mk
            [({ id := "Photo", path := [] },
              Cedar.Validation.EntitySchemaEntry.standard
                { ancestors := Cedar.Data.Set.mk [{ id := "Foo", path := [] }],
                  attrs := Cedar.Data.Map.mk [],
                  tags := none }),
             ({ id := "User", path := [] }, Cedar.Validation.EntitySchemaEntry.enum (Cedar.Data.Set.mk ["bob", "x"]))],
   acts := Cedar.Data.Map.mk
             [({ ty := { id := "Action", path := [] }, eid := "bob" },
               { appliesToPrincipal := Cedar.Data.Set.mk [{ id := "Album", path := [] }],
                 appliesToResource := Cedar.Data.Set.mk [{ id := "Action", path := [] }, { id := "Album", path := [] }],
                 ancestors := Cedar.Data.Set.mk
                                [{ ty := { id := "Action", path := [] }, eid := "x" },
                                 { ty := { id := "Foo", path := [] }, eid := "x" }],
                 context := Cedar.Data.Map.mk [] }),
              ({ ty := { id := "Foo", path := [] }, eid := "x" },
               { appliesToPrincipal := Cedar.Data.Set.mk
                                         [{ id := "Action", path := [] },
                                          { id := "Album", path := [] },
                                          { id := "User", path := [] }],
                 appliesToResource := Cedar.Data.Set.mk [{ id := "Action", path := [] }, { id := "Photo", path := [] }],
                 ancestors := Cedar.Data.Set.mk [{ ty := { id := "Photo", path := [] }, eid := "a" }],
                 context := Cedar.Data.Map.mk [] }),
              ({ ty := { id := "Photo", path := [] }, eid := "edit" },
               { appliesToPrincipal := Cedar.Data.Set.mk
                                         [{ id := "Action", path := [] }, { id := "Album", path := [] }],
                 appliesToResource := Cedar.Data.Set.mk [{ id := "Foo", path := [] }, { id := "User", path := [] }],
                 ancestors := Cedar.Data.Set.mk [],
                 context := Cedar.Data.Map.mk
                              [("name",
                                Cedar.Validation.Qualified.optional
                                  (Cedar.Validation.CedarType.ext (Cedar.Validation.ExtType.ipAddr)))] })] },
 { principal := { ty := { id := "User", path := [] }, eid := "edit" },
   action := { ty := { id := "Foo", path := [] }, eid := "x" },
   resource := { ty := { id := "Action", path := [] }, eid := "a" },
   context := Cedar.Data.Map.mk [] })) — validateRequest passed but principal User::"edit" is not declared in schema


(({ ets := Cedar.Data.Map.mk [],
   acts := Cedar.Data.Map.mk
             [({ ty := { id := "Foo", path := [] }, eid := "a" },
               { appliesToPrincipal := Cedar.Data.Set.mk
                                         [{ id := "Action", path := [] }, { id := "Album", path := [] }],
                 appliesToResource := Cedar.Data.Set.mk [{ id := "Action", path := [] }, { id := "Photo", path := [] }],
                 ancestors := Cedar.Data.Set.mk
                                [{ ty := { id := "Album", path := [] }, eid := "view" },
                                 { ty := { id := "User", path := [] }, eid := "a" }],
                 context := Cedar.Data.Map.mk [] })] },
 { principal := { ty := { id := "Action", path := [] }, eid := "ghost" },
   action := { ty := { id := "Foo", path := [] }, eid := "a" },
   resource := { ty := { id := "Photo", path := [] }, eid := "b" },
   context := Cedar.Data.Map.mk [] })) — validateRequest passed but principal Action::"ghost" is not declared in schema


(({ ets := Cedar.Data.Map.mk [],
   acts := Cedar.Data.Map.mk
             [({ ty := { id := "Action", path := [] }, eid := "bob" },
               { appliesToPrincipal := Cedar.Data.Set.mk [{ id := "Foo", path := [] }, { id := "User", path := [] }],
                 appliesToResource := Cedar.Data.Set.mk [{ id := "Photo", path := [] }, { id := "User", path := [] }],
                 ancestors := Cedar.Data.Set.mk
                                [{ ty := { id := "Action", path := [] }, eid := "edit" },
                                 { ty := { id := "Foo", path := [] }, eid := "z" }],
                 context := Cedar.Data.Map.mk
                              [("owner", Cedar.Validation.Qualified.required (Cedar.Validation.CedarType.int))] }),
              ({ ty := { id := "Photo", path := [] }, eid := "edit" },
               { appliesToPrincipal := Cedar.Data.Set.mk [{ id := "Action", path := [] }],
                 appliesToResource := Cedar.Data.Set.mk [{ id := "Album", path := [] }, { id := "Foo", path := [] }],
                 ancestors := Cedar.Data.Set.mk [],
                 context := Cedar.Data.Map.mk [] }),
              ({ ty := { id := "User", path := [] }, eid := "view" },
               { appliesToPrincipal := Cedar.Data.Set.mk
                                         [{ id := "Action", path := [] },
                                          { id := "Album", path := [] },
                                          { id := "User", path := [] }],
                 appliesToResource := Cedar.Data.Set.mk
                                        [{ id := "Album", path := [] },
                                         { id := "Foo", path := [] },
                                         { id := "User", path := [] }],
                 ancestors := Cedar.Data.Set.mk
                                [{ ty := { id := "Foo", path := [] }, eid := "alice" },
                                 { ty := { id := "Photo", path := [] }, eid := "p1" }],
                 context := Cedar.Data.Map.mk [] })] },
 { principal := { ty := { id := "User", path := [] }, eid := "bob" },
   action := { ty := { id := "User", path := [] }, eid := "view" },
   resource := { ty := { id := "Album", path := [] }, eid := "edit" },
   context := Cedar.Data.Map.mk [] })) — validateRequest passed but principal User::"bob" is not declared in schema


(({ ets := Cedar.Data.Map.mk [],
   acts := Cedar.Data.Map.mk
             [({ ty := { id := "Album", path := [] }, eid := "a" },
               { appliesToPrincipal := Cedar.Data.Set.mk [{ id := "Album", path := [] }, { id := "Photo", path := [] }],
                 appliesToResource := Cedar.Data.Set.mk [{ id := "Foo", path := [] }, { id := "Photo", path := [] }],
                 ancestors := Cedar.Data.Set.mk [{ ty := { id := "Action", path := [] }, eid := "view" }],
                 context := Cedar.Data.Map.mk
                              [("name",
                                Cedar.Validation.Qualified.optional
                                  (Cedar.Validation.CedarType.bool (Cedar.Validation.BoolType.tt)))] }),
              ({ ty := { id := "Foo", path := [] }, eid := "z" },
               { appliesToPrincipal := Cedar.Data.Set.mk [{ id := "Foo", path := [] }],
                 appliesToResource := Cedar.Data.Set.mk [{ id := "Photo", path := [] }, { id := "User", path := [] }],
                 ancestors := Cedar.Data.Set.mk
                                [{ ty := { id := "Action", path := [] }, eid := "y" },
                                 { ty := { id := "Photo", path := [] }, eid := "z" }],
                 context := Cedar.Data.Map.mk [] }),
              ({ ty := { id := "Photo", path := [] }, eid := "ghost" },
               { appliesToPrincipal := Cedar.Data.Set.mk [{ id := "Album", path := [] }, { id := "User", path := [] }],
                 appliesToResource := Cedar.Data.Set.mk [{ id := "User", path := [] }],
                 ancestors := Cedar.Data.Set.mk [],
                 context := Cedar.Data.Map.mk [] })] },
 { principal := { ty := { id := "User", path := [] }, eid := "x" },
   action := { ty := { id := "Photo", path := [] }, eid := "ghost" },
   resource := { ty := { id := "User", path := [] }, eid := "p1" },
   context := Cedar.Data.Map.mk [] })) — validateRequest passed but principal User::"x" is not declared in schema


(({ ets := Cedar.Data.Map.mk [],
   acts := Cedar.Data.Map.mk
             [({ ty := { id := "Action", path := [] }, eid := "ghost" },
               { appliesToPrincipal := Cedar.Data.Set.mk [],
                 appliesToResource := Cedar.Data.Set.mk [{ id := "Album", path := [] }, { id := "User", path := [] }],
                 ancestors := Cedar.Data.Set.mk [],
                 context := Cedar.Data.Map.mk
                              [("age",
                                Cedar.Validation.Qualified.required
                                  (Cedar.Validation.CedarType.bool (Cedar.Validation.BoolType.ff)))] }),
              ({ ty := { id := "Photo", path := [] }, eid := "bob" },
               { appliesToPrincipal := Cedar.Data.Set.mk [{ id := "Album", path := [] }, { id := "Foo", path := [] }],
                 appliesToResource := Cedar.Data.Set.mk
                                        [{ id := "Album", path := [] },
                                         { id := "Foo", path := [] },
                                         { id := "Photo", path := [] }],
                 ancestors := Cedar.Data.Set.mk [],
                 context := Cedar.Data.Map.mk
                              [("flag", Cedar.Validation.Qualified.required (Cedar.Validation.CedarType.string))] }),
              ({ ty := { id := "User", path := [] }, eid := "b" },
               { appliesToPrincipal := Cedar.Data.Set.mk
                                         [{ id := "Foo", path := [] },
                                          { id := "Photo", path := [] },
                                          { id := "User", path := [] }],
                 appliesToResource := Cedar.Data.Set.mk
                                        [{ id := "Album", path := [] },
                                         { id := "Foo", path := [] },
                                         { id := "User", path := [] }],
                 ancestors := Cedar.Data.Set.mk
                                [{ ty := { id := "Album", path := [] }, eid := "a" },
                                 { ty := { id := "Photo", path := [] }, eid := "a" },
                                 { ty := { id := "User", path := [] }, eid := "z" }],
                 context := Cedar.Data.Map.mk
                              [("flag",
                                Cedar.Validation.Qualified.optional
                                  (Cedar.Validation.CedarType.ext (Cedar.Validation.ExtType.decimal)))] })] },
 { principal := { ty := { id := "Foo", path := [] }, eid := "view" },
   action := { ty := { id := "User", path := [] }, eid := "b" },
   resource := { ty := { id := "User", path := [] }, eid := "p1" },
   context := Cedar.Data.Map.mk [] })) — validateRequest passed but principal Foo::"view" is not declared in schema


(({ ets := Cedar.Data.Map.mk
            [({ id := "Album", path := [] },
              Cedar.Validation.EntitySchemaEntry.standard
                { ancestors := Cedar.Data.Set.mk [],
                  attrs := Cedar.Data.Map.mk
                             [("flag", Cedar.Validation.Qualified.optional (Cedar.Validation.CedarType.int)),
                              ("owner", Cedar.Validation.Qualified.optional (Cedar.Validation.CedarType.int))],
                  tags := none }),
             ({ id := "User", path := [] },
              Cedar.Validation.EntitySchemaEntry.standard
                { ancestors := Cedar.Data.Set.mk [],
                  attrs := Cedar.Data.Map.mk
                             [("age", Cedar.Validation.Qualified.required (Cedar.Validation.CedarType.int)),
                              ("name", Cedar.Validation.Qualified.required (Cedar.Validation.CedarType.int))],
                  tags := none })],
   acts := Cedar.Data.Map.mk
             [({ ty := { id := "Album", path := [] }, eid := "alice" },
               { appliesToPrincipal := Cedar.Data.Set.mk [{ id := "Action", path := [] }],
                 appliesToResource := Cedar.Data.Set.mk [{ id := "Foo", path := [] }],
                 ancestors := Cedar.Data.Set.mk
                                [{ ty := { id := "Photo", path := [] }, eid := "x" },
                                 { ty := { id := "Photo", path := [] }, eid := "z" }],
                 context := Cedar.Data.Map.mk [] }),
              ({ ty := { id := "Photo", path := [] }, eid := "y" },
               { appliesToPrincipal := Cedar.Data.Set.mk [{ id := "Foo", path := [] }, { id := "Photo", path := [] }],
                 appliesToResource := Cedar.Data.Set.mk [{ id := "Album", path := [] }, { id := "Foo", path := [] }],
                 ancestors := Cedar.Data.Set.mk [{ ty := { id := "Album", path := [] }, eid := "ghost" }],
                 context := Cedar.Data.Map.mk
                              [("owner",
                                Cedar.Validation.Qualified.optional
                                  (Cedar.Validation.CedarType.bool (Cedar.Validation.BoolType.anyBool)))] }),
              ({ ty := { id := "User", path := [] }, eid := "alice" },
               { appliesToPrincipal := Cedar.Data.Set.mk
                                         [{ id := "Album", path := [] },
                                          { id := "Foo", path := [] },
                                          { id := "User", path := [] }],
                 appliesToResource := Cedar.Data.Set.mk [{ id := "Action", path := [] }, { id := "Foo", path := [] }],
                 ancestors := Cedar.Data.Set.mk
                                [{ ty := { id := "Album", path := [] }, eid := "a" },
                                 { ty := { id := "Album", path := [] }, eid := "b" }],
                 context := Cedar.Data.Map.mk [] })] },
 { principal := { ty := { id := "Foo", path := [] }, eid := "edit" },
   action := { ty := { id := "User", path := [] }, eid := "alice" },
   resource := { ty := { id := "Foo", path := [] }, eid := "z" },
   context := Cedar.Data.Map.mk [] })) — validateRequest passed but principal Foo::"edit" is not declared in schema


(({ ets := Cedar.Data.Map.mk
            [({ id := "Action", path := [] },
              Cedar.Validation.EntitySchemaEntry.standard
                { ancestors := Cedar.Data.Set.mk [{ id := "Action", path := [] }, { id := "Album", path := [] }],
                  attrs := Cedar.Data.Map.mk [],
                  tags := none }),
             ({ id := "Foo", path := [] },
              Cedar.Validation.EntitySchemaEntry.standard
                { ancestors := Cedar.Data.Set.mk [{ id := "User", path := [] }],
                  attrs := Cedar.Data.Map.mk [],
                  tags := some (Cedar.Validation.CedarType.string) })],
   acts := Cedar.Data.Map.mk
             [({ ty := { id := "Foo", path := [] }, eid := "z" },
               { appliesToPrincipal := Cedar.Data.Set.mk [{ id := "Album", path := [] }],
                 appliesToResource := Cedar.Data.Set.mk [{ id := "Photo", path := [] }],
                 ancestors := Cedar.Data.Set.mk
                                [{ ty := { id := "User", path := [] }, eid := "bob" },
                                 { ty := { id := "User", path := [] }, eid := "p1" }],
                 context := Cedar.Data.Map.mk
                              [("flag", Cedar.Validation.Qualified.required (Cedar.Validation.CedarType.int)),
                               ("owner", Cedar.Validation.Qualified.required (Cedar.Validation.CedarType.string))] }),
              ({ ty := { id := "Photo", path := [] }, eid := "bob" },
               { appliesToPrincipal := Cedar.Data.Set.mk
                                         [{ id := "Album", path := [] },
                                          { id := "Photo", path := [] },
                                          { id := "User", path := [] }],
                 appliesToResource := Cedar.Data.Set.mk [{ id := "User", path := [] }],
                 ancestors := Cedar.Data.Set.mk
                                [{ ty := { id := "Album", path := [] }, eid := "y" },
                                 { ty := { id := "Foo", path := [] }, eid := "alice" },
                                 { ty := { id := "Photo", path := [] }, eid := "edit" }],
                 context := Cedar.Data.Map.mk
                              [("flag",
                                Cedar.Validation.Qualified.optional
                                  (Cedar.Validation.CedarType.bool (Cedar.Validation.BoolType.ff)))] }),
              ({ ty := { id := "User", path := [] }, eid := "b" },
               { appliesToPrincipal := Cedar.Data.Set.mk [],
                 appliesToResource := Cedar.Data.Set.mk [],
                 ancestors := Cedar.Data.Set.mk
                                [{ ty := { id := "Foo", path := [] }, eid := "z" },
                                 { ty := { id := "Photo", path := [] }, eid := "ghost" }],
                 context := Cedar.Data.Map.mk [] })] },
 { principal := { ty := { id := "Photo", path := [] }, eid := "edit" },
   action := { ty := { id := "Photo", path := [] }, eid := "bob" },
   resource := { ty := { id := "User", path := [] }, eid := "a" },
   context := Cedar.Data.Map.mk [] })) — validateRequest passed but principal Photo::"edit" is not declared in schema


(({ ets := Cedar.Data.Map.mk [],
   acts := Cedar.Data.Map.mk
             [({ ty := { id := "Album", path := [] }, eid := "p1" },
               { appliesToPrincipal := Cedar.Data.Set.mk
                                         [{ id := "Action", path := [] },
                                          { id := "Foo", path := [] },
                                          { id := "User", path := [] }],
                 appliesToResource := Cedar.Data.Set.mk [{ id := "Action", path := [] }, { id := "Album", path := [] }],
                 ancestors := Cedar.Data.Set.mk [{ ty := { id := "User", path := [] }, eid := "x" }],
                 context := Cedar.Data.Map.mk [] })] },
 { principal := { ty := { id := "User", path := [] }, eid := "p1" },
   action := { ty := { id := "Album", path := [] }, eid := "p1" },
   resource := { ty := { id := "Action", path := [] }, eid := "p1" },
   context := Cedar.Data.Map.mk [] })) — validateRequest passed but principal User::"p1" is not declared in schema


validateRequest passed but principal User::"ghost" is not declared in schema


({ ets := Cedar.Data.Map.mk
           [({ id := "Foo", path := [] },
             Cedar.Validation.EntitySchemaEntry.standard
               { ancestors := Cedar.Data.Set.mk [],
                 attrs := Cedar.Data.Map.mk [],
                 tags := some (Cedar.Validation.CedarType.entity { id := "Foo", path := [] }) }),
            ({ id := "Photo", path := [] },
             Cedar.Validation.EntitySchemaEntry.standard
               { ancestors := Cedar.Data.Set.mk [],
                 attrs := Cedar.Data.Map.mk
                            [("flag",
                              Cedar.Validation.Qualified.required
                                (Cedar.Validation.CedarType.ext (Cedar.Validation.ExtType.ipAddr))),
                             ("owner",
                              Cedar.Validation.Qualified.required
                                (Cedar.Validation.CedarType.bool (Cedar.Validation.BoolType.ff)))],
                 tags := none })],
  acts := Cedar.Data.Map.mk
            [({ ty := { id := "User", path := [] }, eid := "ghost" },
              { appliesToPrincipal := Cedar.Data.Set.mk [{ id := "Photo", path := [] }],
                appliesToResource := Cedar.Data.Set.mk
                                       [{ id := "Foo", path := [] },
                                        { id := "Photo", path := [] },
                                        { id := "User", path := [] }],
                ancestors := Cedar.Data.Set.mk [],
                context := Cedar.Data.Map.mk
                             [("age",
                               Cedar.Validation.Qualified.required
                                 (Cedar.Validation.CedarType.bool (Cedar.Validation.BoolType.anyBool)))] })] }) — Schema.validateWellFormed passed but entity type Photo has an unlifted (singleton-bool) attribute


({ ets := Cedar.Data.Map.mk
           [({ id := "Action", path := [] }, Cedar.Validation.EntitySchemaEntry.enum (Cedar.Data.Set.mk ["ghost"])),
            ({ id := "Album", path := [] },
             Cedar.Validation.EntitySchemaEntry.standard
               { ancestors := Cedar.Data.Set.mk [],
                 attrs := Cedar.Data.Map.mk
                            [("flag",
                              Cedar.Validation.Qualified.optional
                                (Cedar.Validation.CedarType.bool (Cedar.Validation.BoolType.tt))),
                             ("name", Cedar.Validation.Qualified.required (Cedar.Validation.CedarType.int))],
                 tags := none }),
            ({ id := "Foo", path := [] },
             Cedar.Validation.EntitySchemaEntry.standard
               { ancestors := Cedar.Data.Set.mk [],
                 attrs := Cedar.Data.Map.mk
                            [("owner",
                              Cedar.Validation.Qualified.required
                                (Cedar.Validation.CedarType.entity { id := "Foo", path := [] }))],
                 tags := some (Cedar.Validation.CedarType.string) })],
  acts := Cedar.Data.Map.mk
            [({ ty := { id := "User", path := [] }, eid := "b" },
              { appliesToPrincipal := Cedar.Data.Set.mk [{ id := "User", path := [] }],
                appliesToResource := Cedar.Data.Set.mk
                                       [{ id := "Album", path := [] },
                                        { id := "Foo", path := [] },
                                        { id := "User", path := [] }],
                ancestors := Cedar.Data.Set.mk [],
                context := Cedar.Data.Map.mk
                             [("owner", Cedar.Validation.Qualified.required (Cedar.Validation.CedarType.string))] })] }) — Schema.validateWellFormed passed but entity type Album has an unlifted (singleton-bool) attribute


({ ets := Cedar.Data.Map.mk
           [({ id := "Photo", path := [] },
             Cedar.Validation.EntitySchemaEntry.standard
               { ancestors := Cedar.Data.Set.mk [],
                 attrs := Cedar.Data.Map.mk
                            [("flag",
                              Cedar.Validation.Qualified.required
                                (Cedar.Validation.CedarType.bool (Cedar.Validation.BoolType.ff)))],
                 tags := none })],
  acts := Cedar.Data.Map.mk
            [({ ty := { id := "Action", path := [] }, eid := "alice" },
              { appliesToPrincipal := Cedar.Data.Set.mk [{ id := "Action", path := [] }, { id := "Photo", path := [] }],
                appliesToResource := Cedar.Data.Set.mk [{ id := "Photo", path := [] }],
                ancestors := Cedar.Data.Set.mk [],
                context := Cedar.Data.Map.mk
                             [("age", Cedar.Validation.Qualified.required (Cedar.Validation.CedarType.string))] })] }) — Schema.validateWellFormed passed but entity type Photo has an unlifted (singleton-bool) attribute


({ ets := Cedar.Data.Map.mk
           [({ id := "Foo", path := [] },
             Cedar.Validation.EntitySchemaEntry.standard
               { ancestors := Cedar.Data.Set.mk [],
                 attrs := Cedar.Data.Map.mk
                            [("age", Cedar.Validation.Qualified.optional (Cedar.Validation.CedarType.int)),
                             ("name",
                              Cedar.Validation.Qualified.optional
                                (Cedar.Validation.CedarType.bool (Cedar.Validation.BoolType.tt)))],
                 tags := none }),
            ({ id := "Photo", path := [] },
             Cedar.Validation.EntitySchemaEntry.standard
               { ancestors := Cedar.Data.Set.mk [{ id := "Foo", path := [] }, { id := "Photo", path := [] }],
                 attrs := Cedar.Data.Map.mk
                            [("flag", Cedar.Validation.Qualified.optional (Cedar.Validation.CedarType.int)),
                             ("owner",
                              Cedar.Validation.Qualified.optional
                                (Cedar.Validation.CedarType.entity { id := "Photo", path := [] }))],
                 tags := some (Cedar.Validation.CedarType.bool (Cedar.Validation.BoolType.anyBool)) }),
            ({ id := "User", path := [] },
             Cedar.Validation.EntitySchemaEntry.standard
               { ancestors := Cedar.Data.Set.mk [], attrs := Cedar.Data.Map.mk [], tags := none })],
  acts := Cedar.Data.Map.mk
            [({ ty := { id := "Album", path := [] }, eid := "x" },
              { appliesToPrincipal := Cedar.Data.Set.mk [{ id := "Album", path := [] }, { id := "Photo", path := [] }],
                appliesToResource := Cedar.Data.Set.mk [{ id := "Album", path := [] }],
                ancestors := Cedar.Data.Set.mk [],
                context := Cedar.Data.Map.mk [] })] }) — Schema.validateWellFormed passed but entity type Foo has an unlifted (singleton-bool) attribute


({ ets := Cedar.Data.Map.mk
           [({ id := "Album", path := [] }, Cedar.Validation.EntitySchemaEntry.enum (Cedar.Data.Set.mk ["z"])),
            ({ id := "Foo", path := [] },
             Cedar.Validation.EntitySchemaEntry.standard
               { ancestors := Cedar.Data.Set.mk [],
                 attrs := Cedar.Data.Map.mk
                            [("flag", Cedar.Validation.Qualified.required (Cedar.Validation.CedarType.int))],
                 tags := some (Cedar.Validation.CedarType.int) }),
            ({ id := "User", path := [] },
             Cedar.Validation.EntitySchemaEntry.standard
               { ancestors := Cedar.Data.Set.mk [],
                 attrs := Cedar.Data.Map.mk
                            [("age",
                              Cedar.Validation.Qualified.optional
                                (Cedar.Validation.CedarType.bool (Cedar.Validation.BoolType.tt))),
                             ("flag", Cedar.Validation.Qualified.optional (Cedar.Validation.CedarType.string))],
                 tags := some (Cedar.Validation.CedarType.bool (Cedar.Validation.BoolType.anyBool)) })],
  acts := Cedar.Data.Map.mk
            [({ ty := { id := "Photo", path := [] }, eid := "b" },
              { appliesToPrincipal := Cedar.Data.Set.mk
                                        [{ id := "Album", path := [] },
                                         { id := "Foo", path := [] },
                                         { id := "User", path := [] }],
                appliesToResource := Cedar.Data.Set.mk [{ id := "Album", path := [] }, { id := "Foo", path := [] }],
                ancestors := Cedar.Data.Set.mk [],
                context := Cedar.Data.Map.mk [] }),
             ({ ty := { id := "Photo", path := [] }, eid := "z" },
              { appliesToPrincipal := Cedar.Data.Set.mk [{ id := "Foo", path := [] }, { id := "Photo", path := [] }],
                appliesToResource := Cedar.Data.Set.mk [],
                ancestors := Cedar.Data.Set.mk [],
                context := Cedar.Data.Map.mk
                             [("name", Cedar.Validation.Qualified.required (Cedar.Validation.CedarType.string)),
                              ("owner",
                               Cedar.Validation.Qualified.required
                                 (Cedar.Validation.CedarType.ext (Cedar.Validation.ExtType.ipAddr)))] })] }) — Schema.validateWellFormed passed but entity type User has an unlifted (singleton-bool) attribute


({ ets := Cedar.Data.Map.mk
           [({ id := "Album", path := [] },
             Cedar.Validation.EntitySchemaEntry.standard
               { ancestors := Cedar.Data.Set.mk [],
                 attrs := Cedar.Data.Map.mk
                            [("owner",
                              Cedar.Validation.Qualified.optional
                                (Cedar.Validation.CedarType.entity { id := "Photo", path := [] }))],
                 tags := none }),
            ({ id := "Photo", path := [] },
             Cedar.Validation.EntitySchemaEntry.standard
               { ancestors := Cedar.Data.Set.mk [{ id := "Album", path := [] }, { id := "Photo", path := [] }],
                 attrs := Cedar.Data.Map.mk
                            [("age",
                              Cedar.Validation.Qualified.required
                                (Cedar.Validation.CedarType.bool (Cedar.Validation.BoolType.tt)))],
                 tags := none })],
  acts := Cedar.Data.Map.mk
            [({ ty := { id := "Foo", path := [] }, eid := "p1" },
              { appliesToPrincipal := Cedar.Data.Set.mk [{ id := "Album", path := [] }, { id := "Foo", path := [] }],
                appliesToResource := Cedar.Data.Set.mk [{ id := "Photo", path := [] }],
                ancestors := Cedar.Data.Set.mk [],
                context := Cedar.Data.Map.mk [] })] }) — Schema.validateWellFormed passed but entity type Photo has an unlifted (singleton-bool) attribute


({ ets := Cedar.Data.Map.mk
           [({ id := "Action", path := [] },
             Cedar.Validation.EntitySchemaEntry.standard
               { ancestors := Cedar.Data.Set.mk [],
                 attrs := Cedar.Data.Map.mk
                            [("age", Cedar.Validation.Qualified.required (Cedar.Validation.CedarType.int))],
                 tags := none }),
            ({ id := "User", path := [] },
             Cedar.Validation.EntitySchemaEntry.standard
               { ancestors := Cedar.Data.Set.mk [],
                 attrs := Cedar.Data.Map.mk
                            [("name",
                              Cedar.Validation.Qualified.required
                                (Cedar.Validation.CedarType.ext (Cedar.Validation.ExtType.duration))),
                             ("owner",
                              Cedar.Validation.Qualified.required
                                (Cedar.Validation.CedarType.bool (Cedar.Validation.BoolType.tt)))],
                 tags := some (Cedar.Validation.CedarType.int) })],
  acts := Cedar.Data.Map.mk
            [({ ty := { id := "Photo", path := [] }, eid := "alice" },
              { appliesToPrincipal := Cedar.Data.Set.mk [{ id := "Action", path := [] }, { id := "User", path := [] }],
                appliesToResource := Cedar.Data.Set.mk [{ id := "Photo", path := [] }, { id := "User", path := [] }],
                ancestors := Cedar.Data.Set.mk [],
                context := Cedar.Data.Map.mk
                             [("owner",
                               Cedar.Validation.Qualified.optional
                                 (Cedar.Validation.CedarType.entity { id := "Photo", path := [] }))] })] }) — Schema.validateWellFormed passed but entity type User has an unlifted (singleton-bool) attribute


({ ets := Cedar.Data.Map.mk
           [({ id := "Album", path := [] },
             Cedar.Validation.EntitySchemaEntry.standard
               { ancestors := Cedar.Data.Set.mk [{ id := "Foo", path := [] }],
                 attrs := Cedar.Data.Map.mk
                            [("age",
                              Cedar.Validation.Qualified.required
                                (Cedar.Validation.CedarType.ext (Cedar.Validation.ExtType.ipAddr))),
                             ("name",
                              Cedar.Validation.Qualified.required
                                (Cedar.Validation.CedarType.ext (Cedar.Validation.ExtType.duration)))],
                 tags := none }),
            ({ id := "Foo", path := [] },
             Cedar.Validation.EntitySchemaEntry.standard
               { ancestors := Cedar.Data.Set.mk [{ id := "Album", path := [] }],
                 attrs := Cedar.Data.Map.mk
                            [("name",
                              Cedar.Validation.Qualified.optional
                                (Cedar.Validation.CedarType.bool (Cedar.Validation.BoolType.tt)))],
                 tags := none })],
  acts := Cedar.Data.Map.mk
            [({ ty := { id := "User", path := [] }, eid := "y" },
              { appliesToPrincipal := Cedar.Data.Set.mk [{ id := "Foo", path := [] }],
                appliesToResource := Cedar.Data.Set.mk [{ id := "User", path := [] }],
                ancestors := Cedar.Data.Set.mk [],
                context := Cedar.Data.Map.mk
                             [("age",
                               Cedar.Validation.Qualified.required
                                 (Cedar.Validation.CedarType.ext (Cedar.Validation.ExtType.ipAddr))),
                              ("owner", Cedar.Validation.Qualified.optional (Cedar.Validation.CedarType.string))] })] }) — Schema.validateWellFormed passed but entity type Foo has an unlifted (singleton-bool) attribute


({ ets := Cedar.Data.Map.mk
           [({ id := "Photo", path := [] },
             Cedar.Validation.EntitySchemaEntry.standard
               { ancestors := Cedar.Data.Set.mk [],
                 attrs := Cedar.Data.Map.mk
                            [("flag",
                              Cedar.Validation.Qualified.optional
                                (Cedar.Validation.CedarType.ext (Cedar.Validation.ExtType.ipAddr))),
                             ("owner",
                              Cedar.Validation.Qualified.optional
                                (Cedar.Validation.CedarType.bool (Cedar.Validation.BoolType.tt)))],
                 tags := some (Cedar.Validation.CedarType.ext (Cedar.Validation.ExtType.duration)) })],
  acts := Cedar.Data.Map.mk
            [({ ty := { id := "Action", path := [] }, eid := "alice" },
              { appliesToPrincipal := Cedar.Data.Set.mk [{ id := "Photo", path := [] }],
                appliesToResource := Cedar.Data.Set.mk [{ id := "Photo", path := [] }],
                ancestors := Cedar.Data.Set.mk [],
                context := Cedar.Data.Map.mk [] }),
             ({ ty := { id := "Album", path := [] }, eid := "a" },
              { appliesToPrincipal := Cedar.Data.Set.mk [{ id := "Photo", path := [] }],
                appliesToResource := Cedar.Data.Set.mk [],
                ancestors := Cedar.Data.Set.mk [],
                context := Cedar.Data.Map.mk
                             [("name", Cedar.Validation.Qualified.required (Cedar.Validation.CedarType.string)),
                              ("owner", Cedar.Validation.Qualified.optional (Cedar.Validation.CedarType.int))] })] }) — Schema.validateWellFormed passed but entity type Photo has an unlifted (singleton-bool) attribute


({ ets := Cedar.Data.Map.mk
           [({ id := "Foo", path := [] },
             Cedar.Validation.EntitySchemaEntry.standard
               { ancestors := Cedar.Data.Set.mk [],
                 attrs := Cedar.Data.Map.mk
                            [("flag",
                              Cedar.Validation.Qualified.optional
                                (Cedar.Validation.CedarType.bool (Cedar.Validation.BoolType.tt))),
                             ("name", Cedar.Validation.Qualified.required (Cedar.Validation.CedarType.string))],
                 tags := some (Cedar.Validation.CedarType.ext (Cedar.Validation.ExtType.decimal)) }),
            ({ id := "Photo", path := [] },
             Cedar.Validation.EntitySchemaEntry.standard
               { ancestors := Cedar.Data.Set.mk [], attrs := Cedar.Data.Map.mk [], tags := none })],
  acts := Cedar.Data.Map.mk
            [({ ty := { id := "Action", path := [] }, eid := "x" },
              { appliesToPrincipal := Cedar.Data.Set.mk [{ id := "Foo", path := [] }],
                appliesToResource := Cedar.Data.Set.mk [{ id := "User", path := [] }],
                ancestors := Cedar.Data.Set.mk [],
                context := Cedar.Data.Map.mk
                             [("flag", Cedar.Validation.Qualified.optional (Cedar.Validation.CedarType.string)),
                              ("name",
                               Cedar.Validation.Qualified.required
                                 (Cedar.Validation.CedarType.entity { id := "Photo", path := [] }))] }),
             ({ ty := { id := "User", path := [] }, eid := "bob" },
              { appliesToPrincipal := Cedar.Data.Set.mk [{ id := "Foo", path := [] }, { id := "User", path := [] }],
                appliesToResource := Cedar.Data.Set.mk [],
                ancestors := Cedar.Data.Set.mk [],
                context := Cedar.Data.Map.mk
                             [("flag",
                               Cedar.Validation.Qualified.required
                                 (Cedar.Validation.CedarType.entity { id := "Action", path := [] }))] }),
             ({ ty := { id := "User", path := [] }, eid := "p1" },
              { appliesToPrincipal := Cedar.Data.Set.mk [{ id := "Action", path := [] }, { id := "User", path := [] }],
                appliesToResource := Cedar.Data.Set.mk [],
                ancestors := Cedar.Data.Set.mk [{ ty := { id := "Action", path := [] }, eid := "x" }],
                context := Cedar.Data.Map.mk
                             [("owner",
                               Cedar.Validation.Qualified.optional
                                 (Cedar.Validation.CedarType.ext (Cedar.Validation.ExtType.datetime)))] })] }) — Schema.validateWellFormed passed but entity type Foo has an unlifted (singleton-bool) attribute


Schema.validateWellFormed passed but entity type User has an unlifted (singleton-bool) attribute


(([], { ty := { id := "Foo", path := [] }, eid := "b" })) — defineEntity for non-member b returned "U_enc_m0" instead of throwing (members: [])


(([], { ty := { id := "Photo", path := [] }, eid := "ghost" })) — defineEntity for non-member ghost returned "U_enc_m0" instead of throwing (members: [])


(([], { ty := { id := "Album", path := [] }, eid := "a" })) — defineEntity for non-member a returned "U_enc_m0" instead of throwing (members: [])


(([], { ty := { id := "User", path := [] }, eid := "a" })) — defineEntity for non-member a returned "U_enc_m0" instead of throwing (members: [])


(([], { ty := { id := "Action", path := [] }, eid := "y" })) — defineEntity for non-member y returned "U_enc_m0" instead of throwing (members: [])


(([], { ty := { id := "Photo", path := [] }, eid := "b" })) — defineEntity for non-member b returned "U_enc_m0" instead of throwing (members: [])


(([], { ty := { id := "Action", path := [] }, eid := "ghost" })) — defineEntity for non-member ghost returned "U_enc_m0" instead of throwing (members: [])


(([], { ty := { id := "User", path := [] }, eid := "p1" })) — defineEntity for non-member p1 returned "U_enc_m0" instead of throwing (members: [])


defineEntity for non-member zzz returned "U_enc_m2" instead of throwing (members: [alice, bob])