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


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


("-0.26") — Decimal.parse "-0.26" = some { toUInt64 := 2600 } 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.2") — Decimal.parse "-0.2" = some { toUInt64 := 2000 } but a leading '-' must yield a non-positive decimal


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


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


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


("-0.211") — Decimal.parse "-0.211" = some { toUInt64 := 2110 } 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


("-34.2_69") — Decimal.parse "-34.2_69" = some { toUInt64 := 18446744073709211347 } but underscores are disallowed


("-9_98.5") — Decimal.parse "-9_98.5" = some { toUInt64 := 18446744073699566616 } but underscores are disallowed


("-52_6.77") — Decimal.parse "-52_6.77" = some { toUInt64 := 18446744073704283916 } but underscores are disallowed


("5868.4_3") — Decimal.parse "5868.4_3" = some { toUInt64 := 58680430 } but underscores are disallowed


("-7_2.3") — Decimal.parse "-7_2.3" = some { toUInt64 := 18446744073708828616 } but underscores are disallowed


("-3_73.0") — Decimal.parse "-3_73.0" = some { toUInt64 := 18446744073705821616 } but underscores are disallowed


("-4.8_1") — Decimal.parse "-4.8_1" = some { toUInt64 := 18446744073709510806 } but underscores are disallowed


("4.9_7") — Decimal.parse "4.9_7" = some { toUInt64 := 40970 } but underscores are disallowed


("4.5_81") — Decimal.parse "4.5_81" = some { toUInt64 := 40581 } but underscores are disallowed


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


(({ ets := Cedar.Data.Map.mk
            [({ id := "Foo", path := [] },
              Cedar.Validation.EntitySchemaEntry.standard
                { ancestors := Cedar.Data.Set.mk [{ id := "Album", path := [] }, { id := "Foo", path := [] }],
                  attrs := Cedar.Data.Map.mk [],
                  tags := some (Cedar.Validation.CedarType.int) })],
   acts := Cedar.Data.Map.mk
             [({ ty := { id := "Album", path := [] }, eid := "a" },
               { appliesToPrincipal := Cedar.Data.Set.mk [{ id := "Album", path := [] }],
                 appliesToResource := Cedar.Data.Set.mk [{ id := "User", path := [] }],
                 ancestors := Cedar.Data.Set.mk [],
                 context := Cedar.Data.Map.mk
                              [("owner", Cedar.Validation.Qualified.required (Cedar.Validation.CedarType.int))] })] },
 Cedar.Data.Map.mk
   [({ ty := { id := "Album", path := [] }, eid := "a" },
     { attrs := Cedar.Data.Map.mk
                  [("7\\CcA2\\M`'b05A `Ac CCBC@C:/5:6c\x08", Cedar.Spec.Value.prim (Cedar.Spec.Prim.string "owner"))],
       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 := "Action", path := [] },
              Cedar.Validation.EntitySchemaEntry.standard
                { ancestors := Cedar.Data.Set.mk [{ id := "Photo", path := [] }],
                  attrs := Cedar.Data.Map.mk
                             [("flag",
                               Cedar.Validation.Qualified.optional
                                 (Cedar.Validation.CedarType.ext (Cedar.Validation.ExtType.datetime))),
                              ("owner",
                               Cedar.Validation.Qualified.required
                                 (Cedar.Validation.CedarType.ext (Cedar.Validation.ExtType.duration)))],
                  tags := some (Cedar.Validation.CedarType.ext (Cedar.Validation.ExtType.duration)) }),
             ({ id := "Photo", path := [] },
              Cedar.Validation.EntitySchemaEntry.standard
                { ancestors := Cedar.Data.Set.mk [],
                  attrs := Cedar.Data.Map.mk
                             [("owner",
                               Cedar.Validation.Qualified.required
                                 (Cedar.Validation.CedarType.bool (Cedar.Validation.BoolType.tt)))],
                  tags := none })],
   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 := "Action", path := [] }, { id := "User", path := [] }],
                 ancestors := Cedar.Data.Set.mk [],
                 context := Cedar.Data.Map.mk [] })] },
 Cedar.Data.Map.mk
   [({ ty := { id := "Album", path := [] }, eid := "bob" },
     { attrs := Cedar.Data.Map.mk
                  [("131A`\\1b:B\\\\:12\x120\x18,cb03`-\x0b2\\\x0f\\`aD\x15IB7+03EB;B\x0e:;\x19,A$A0;C\x143B\x17C1;B 3b3:",
                    Cedar.Spec.Value.prim
                      (Cedar.Spec.Prim.entityUID { ty := { id := "Action", path := [] }, eid := "bob" })),
                   ("C\x07\x11\x0d,C;Ba3<c:02B* 1B",
                    Cedar.Spec.Value.set (Cedar.Data.Set.mk [Cedar.Spec.Value.prim (Cedar.Spec.Prim.bool true)]))],
       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 [{ id := "Album", path := [] }, { id := "Photo", path := [] }],
                  attrs := Cedar.Data.Map.mk
                             [("age",
                               Cedar.Validation.Qualified.optional
                                 (Cedar.Validation.CedarType.bool (Cedar.Validation.BoolType.ff))),
                              ("owner",
                               Cedar.Validation.Qualified.optional
                                 (Cedar.Validation.CedarType.entity { id := "Album", path := [] }))],
                  tags := none }),
             ({ id := "Album", 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.tt)))],
                  tags := none }),
             ({ id := "Foo", path := [] },
              Cedar.Validation.EntitySchemaEntry.standard
                { ancestors := Cedar.Data.Set.mk [{ id := "Foo", path := [] }, { id := "User", path := [] }],
                  attrs := Cedar.Data.Map.mk
                             [("owner", Cedar.Validation.Qualified.required (Cedar.Validation.CedarType.string))],
                  tags := some (Cedar.Validation.CedarType.entity { id := "User", path := [] }) })],
   acts := Cedar.Data.Map.mk
             [({ ty := { id := "User", path := [] }, eid := "bob" },
               { appliesToPrincipal := Cedar.Data.Set.mk [{ id := "Foo", path := [] }],
                 appliesToResource := Cedar.Data.Set.mk [{ id := "Album", path := [] }],
                 ancestors := Cedar.Data.Set.mk [],
                 context := Cedar.Data.Map.mk
                              [("age",
                                Cedar.Validation.Qualified.optional
                                  (Cedar.Validation.CedarType.bool (Cedar.Validation.BoolType.ff)))] })] },
 Cedar.Data.Map.mk
   [({ ty := { id := "User", path := [] }, eid := "bob" },
     { attrs := Cedar.Data.Map.mk
                  [("\nDA\x03b1/2AD\x08Ba`\x16C3\x1f \x14Ab;:A\x08:-C,B3,`+\x06!Ba1aA\x18,3:\\,7a10:B:\x1e b:,a/;",
                    Cedar.Spec.Value.record (Cedar.Data.Map.mk []))],
       ancestors := Cedar.Data.Set.mk [],
       tags := Cedar.Data.Map.mk [] })])) — validateEntities passed but action entity User::"bob" has non-empty attrs


(({ ets := Cedar.Data.Map.mk [],
   acts := Cedar.Data.Map.mk
             [({ ty := { id := "Action", path := [] }, eid := "a" },
               { appliesToPrincipal := Cedar.Data.Set.mk [{ id := "Action", path := [] }],
                 appliesToResource := Cedar.Data.Set.mk [{ id := "Photo", path := [] }, { id := "User", path := [] }],
                 ancestors := Cedar.Data.Set.mk [],
                 context := Cedar.Data.Map.mk
                              [("flag", Cedar.Validation.Qualified.required (Cedar.Validation.CedarType.int)),
                               ("name",
                                Cedar.Validation.Qualified.required
                                  (Cedar.Validation.CedarType.ext (Cedar.Validation.ExtType.ipAddr)))] })] },
 Cedar.Data.Map.mk
   [({ ty := { id := "Action", path := [] }, eid := "a" },
     { attrs := Cedar.Data.Map.mk
                  [("A22BC\\b;a*`,:;b$ 1\\b/C;)'c%c:\x19\x072a//`0 00\x12a\\3cB;Ca3\x02",
                    Cedar.Spec.Value.set (Cedar.Data.Set.mk [])),
                   ("C3 1BB\x06bB\x05,2bba?13:1ca0b.\x0e\x0e0,`2;2J``N,C C;A02CaR2+",
                    Cedar.Spec.Value.prim (Cedar.Spec.Prim.bool true))],
       ancestors := Cedar.Data.Set.mk [],
       tags := Cedar.Data.Map.mk [] })])) — validateEntities passed but action entity Action::"a" has non-empty attrs


(({ ets := Cedar.Data.Map.mk
            [({ id := "Album", path := [] }, Cedar.Validation.EntitySchemaEntry.enum (Cedar.Data.Set.mk ["ghost"]))],
   acts := Cedar.Data.Map.mk
             [({ ty := { id := "User", path := [] }, eid := "a" },
               { appliesToPrincipal := Cedar.Data.Set.mk [{ id := "Album", path := [] }, { id := "User", path := [] }],
                 appliesToResource := Cedar.Data.Set.mk [{ id := "Photo", path := [] }],
                 ancestors := Cedar.Data.Set.mk [],
                 context := Cedar.Data.Map.mk [] })] },
 Cedar.Data.Map.mk
   [({ ty := { id := "User", path := [] }, eid := "a" },
     { attrs := Cedar.Data.Map.mk
                  [("a;C2acB/:0c0\x0e\x16:/B/a 0CAA031/cAa30B:;C\n\x15;",
                    Cedar.Spec.Value.record (Cedar.Data.Map.mk []))],
       ancestors := Cedar.Data.Set.mk [],
       tags := Cedar.Data.Map.mk [] })])) — validateEntities passed but action entity User::"a" has non-empty attrs


(({ ets := Cedar.Data.Map.mk [],
   acts := Cedar.Data.Map.mk
             [({ ty := { id := "Album", path := [] }, eid := "edit" },
               { appliesToPrincipal := Cedar.Data.Set.mk [{ id := "Album", path := [] }],
                 appliesToResource := Cedar.Data.Set.mk [{ id := "Action", path := [] }, { id := "Album", path := [] }],
                 ancestors := Cedar.Data.Set.mk [],
                 context := Cedar.Data.Map.mk
                              [("name",
                                Cedar.Validation.Qualified.required
                                  (Cedar.Validation.CedarType.bool (Cedar.Validation.BoolType.ff))),
                               ("owner",
                                Cedar.Validation.Qualified.optional
                                  (Cedar.Validation.CedarType.ext (Cedar.Validation.ExtType.ipAddr)))] })] },
 Cedar.Data.Map.mk
   [({ ty := { id := "Album", path := [] }, eid := "edit" },
     { attrs := Cedar.Data.Map.mk
                  [("", Cedar.Spec.Value.prim (Cedar.Spec.Prim.bool true)),
                   ("\x00", Cedar.Spec.Value.prim (Cedar.Spec.Prim.int { toUInt64 := 22 }))],
       ancestors := Cedar.Data.Set.mk [],
       tags := Cedar.Data.Map.mk [] })])) — validateEntities passed but action entity Album::"edit" has non-empty attrs


(({ 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.ext (Cedar.Validation.ExtType.decimal)))],
                  tags := some (Cedar.Validation.CedarType.bool (Cedar.Validation.BoolType.anyBool)) }),
             ({ id := "Photo", path := [] },
              Cedar.Validation.EntitySchemaEntry.standard
                { ancestors := Cedar.Data.Set.mk [],
                  attrs := Cedar.Data.Map.mk
                             [("age",
                               Cedar.Validation.Qualified.required
                                 (Cedar.Validation.CedarType.entity { id := "User", path := [] })),
                              ("name",
                               Cedar.Validation.Qualified.optional
                                 (Cedar.Validation.CedarType.entity { id := "Action", path := [] }))],
                  tags := some (Cedar.Validation.CedarType.string) })],
   acts := Cedar.Data.Map.mk
             [({ ty := { id := "Album", path := [] }, eid := "a" },
               { appliesToPrincipal := Cedar.Data.Set.mk [{ id := "Foo", path := [] }, { id := "Photo", path := [] }],
                 appliesToResource := Cedar.Data.Set.mk [{ id := "Action", path := [] }],
                 ancestors := Cedar.Data.Set.mk [],
                 context := Cedar.Data.Map.mk
                              [("flag", Cedar.Validation.Qualified.optional (Cedar.Validation.CedarType.int))] })] },
 Cedar.Data.Map.mk
   [({ ty := { id := "Album", path := [] }, eid := "a" },
     { attrs := Cedar.Data.Map.mk
                  [("0cbA$/A\\a\x11I b1K9c3\\0cBc,`\x1d \x1fbS1<&K`\x192,?\x18222 3C6c,,a,b1` b\\2;a,b3/3b\x0e2:\\\x05Nc`/b1",
                    Cedar.Spec.Value.set (Cedar.Data.Set.mk [])),
                   ("\\;2bP\x11b\x0f21a& >A1\\\x0ec\x1a;R\x01",
                    Cedar.Spec.Value.prim
                      (Cedar.Spec.Prim.entityUID { ty := { id := "Photo", path := [] }, eid := "ghost" })),
                   ("cC\"cCb[cE3BBc121\x02,Y/A/`0c3a133a`,,CB`\"KB ;\x0d;`;\\A0 ;bc\x01 c2` /\x11\\/;\x1dB:b\x15b1\x0bc/`<3a#0,,30122A3\x0f\\\x01;",
                    Cedar.Spec.Value.set
                      (Cedar.Data.Set.mk
                        [Cedar.Spec.Value.prim (Cedar.Spec.Prim.int { toUInt64 := 72 }),
                         Cedar.Spec.Value.prim (Cedar.Spec.Prim.bool false)]))],
       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 [],
   acts := Cedar.Data.Map.mk
             [({ ty := { id := "User", 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 [] })] },
 Cedar.Data.Map.mk
   [({ ty := { id := "User", path := [] }, eid := "x" },
     { attrs := Cedar.Data.Map.mk [("0:`/b\\\\", Cedar.Spec.Value.prim (Cedar.Spec.Prim.int { toUInt64 := 49 }))],
       ancestors := Cedar.Data.Set.mk [],
       tags := Cedar.Data.Map.mk [] })])) — validateEntities passed but action entity User::"x" has non-empty attrs


(({ ets := Cedar.Data.Map.mk [],
   acts := Cedar.Data.Map.mk
             [({ ty := { id := "Action", path := [] }, eid := "bob" },
               { appliesToPrincipal := Cedar.Data.Set.mk [{ id := "Foo", path := [] }],
                 appliesToResource := Cedar.Data.Set.mk [{ id := "Action", path := [] }, { id := "Photo", path := [] }],
                 ancestors := Cedar.Data.Set.mk [],
                 context := Cedar.Data.Map.mk
                              [("name",
                                Cedar.Validation.Qualified.optional
                                  (Cedar.Validation.CedarType.ext (Cedar.Validation.ExtType.datetime)))] })] },
 Cedar.Data.Map.mk
   [({ ty := { id := "Action", path := [] }, eid := "bob" },
     { attrs := Cedar.Data.Map.mk
                  [("\x0f`/2C3\\", Cedar.Spec.Value.set (Cedar.Data.Set.mk [])),
                   ("3bba/;\x15\x1bB`0\x0e2,` /0/0,1:/1,B 1a`b/:::. 1;b\x14\x0d/;BCB:\\C2/c`\x08*c",
                    Cedar.Spec.Value.prim
                      (Cedar.Spec.Prim.entityUID { ty := { id := "Album", path := [] }, eid := "alice" }))],
       ancestors := Cedar.Data.Set.mk [],
       tags := Cedar.Data.Map.mk [] })])) — validateEntities passed but action entity Action::"bob" has non-empty attrs


(({ ets := Cedar.Data.Map.mk [],
   acts := Cedar.Data.Map.mk
             [({ ty := { id := "Foo", path := [] }, eid := "a" },
               { appliesToPrincipal := Cedar.Data.Set.mk [{ id := "Foo", path := [] }],
                 appliesToResource := Cedar.Data.Set.mk [{ id := "Action", path := [] }, { id := "Foo", path := [] }],
                 ancestors := Cedar.Data.Set.mk [],
                 context := Cedar.Data.Map.mk [] })] },
 Cedar.Data.Map.mk
   [({ ty := { id := "Foo", path := [] }, eid := "a" },
     { attrs := Cedar.Data.Map.mk [("", Cedar.Spec.Value.record (Cedar.Data.Map.mk []))],
       ancestors := Cedar.Data.Set.mk [],
       tags := Cedar.Data.Map.mk [] })])) — validateEntities passed but action entity Foo::"a" has non-empty attrs


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


("/\x04\" A a") — encodeString("/\x04\" A a") wrapped to "\"/\\u{4}\" A a\"" has 3 '"' (odd; malformed SMT)


("b*\x1eC`232\"") — encodeString("b*\x1eC`232\"") wrapped to "\"b*\\u{1e}C`232\"\"" has 3 '"' (odd; malformed SMT)


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.is { id := "User", path := [] }),
    actionScope := Cedar.Spec.ActionScope.actionScope (Cedar.Spec.Scope.is { id := "Album", path := [] }),
    resourceScope := Cedar.Spec.ResourceScope.resourceScope (Cedar.Spec.Scope.any),
    condition := [] }],
 { ets := Cedar.Data.Map.mk
            [({ id := "Foo", path := [] },
              Cedar.Validation.EntitySchemaEntry.standard
                { ancestors := Cedar.Data.Set.mk
                                 [{ id := "Album", path := [] },
                                  { id := "Foo", path := [] },
                                  { id := "Photo", path := [] }],
                  attrs := Cedar.Data.Map.mk
                             [("owner", Cedar.Validation.Qualified.required (Cedar.Validation.CedarType.int))],
                  tags := some (Cedar.Validation.CedarType.entity { id := "Album", path := [] }) })],
   acts := Cedar.Data.Map.mk
             [({ ty := { id := "Action", path := [] }, eid := "a" },
               { appliesToPrincipal := Cedar.Data.Set.mk [],
                 appliesToResource := Cedar.Data.Set.mk [],
                 ancestors := Cedar.Data.Set.mk [{ ty := { id := "Action", path := [] }, eid := "bob" }],
                 context := Cedar.Data.Map.mk
                              [("name",
                                Cedar.Validation.Qualified.required
                                  (Cedar.Validation.CedarType.bool (Cedar.Validation.BoolType.ff)))] }),
              ({ ty := { id := "Album", path := [] }, eid := "p1" },
               { appliesToPrincipal := Cedar.Data.Set.mk [{ id := "Album", path := [] }, { id := "User", path := [] }],
                 appliesToResource := Cedar.Data.Set.mk [{ id := "Album", path := [] }],
                 ancestors := Cedar.Data.Set.mk
                                [{ ty := { id := "Action", path := [] }, eid := "p1" },
                                 { ty := { id := "Album", path := [] }, eid := "a" }],
                 context := Cedar.Data.Map.mk
                              [("age",
                                Cedar.Validation.Qualified.optional
                                  (Cedar.Validation.CedarType.entity { id := "Photo", path := [] }))] }),
              ({ ty := { id := "Photo", path := [] }, eid := "edit" },
               { appliesToPrincipal := Cedar.Data.Set.mk [{ id := "Action", path := [] }],
                 appliesToResource := Cedar.Data.Set.mk
                                        [{ id := "Action", path := [] },
                                         { id := "Foo", path := [] },
                                         { id := "Photo", path := [] }],
                 ancestors := Cedar.Data.Set.mk [{ ty := { id := "Photo", path := [] }, eid := "view" }],
                 context := Cedar.Data.Map.mk
                              [("flag",
                                Cedar.Validation.Qualified.optional
                                  (Cedar.Validation.CedarType.bool (Cedar.Validation.BoolType.ff)))] })] })) — validate passed but policy p0 references undeclared entities


(([{ id := "p0",
    effect := Cedar.Spec.Effect.permit,
    principalScope := Cedar.Spec.PrincipalScope.principalScope (Cedar.Spec.Scope.any),
    actionScope := Cedar.Spec.ActionScope.actionScope
                     (Cedar.Spec.Scope.isMem
                       { id := "Album", path := [] }
                       { ty := { id := "Album", path := [] }, eid := "b" }),
    resourceScope := Cedar.Spec.ResourceScope.resourceScope (Cedar.Spec.Scope.is { id := "User", path := [] }),
    condition := [] }],
 { ets := Cedar.Data.Map.mk
            [({ id := "Action", path := [] },
              Cedar.Validation.EntitySchemaEntry.standard
                { ancestors := Cedar.Data.Set.mk [], attrs := Cedar.Data.Map.mk [], tags := none }),
             ({ id := "Photo", path := [] },
              Cedar.Validation.EntitySchemaEntry.standard
                { ancestors := Cedar.Data.Set.mk [{ id := "Album", path := [] }],
                  attrs := Cedar.Data.Map.mk
                             [("age",
                               Cedar.Validation.Qualified.optional
                                 (Cedar.Validation.CedarType.ext (Cedar.Validation.ExtType.ipAddr)))],
                  tags := some (Cedar.Validation.CedarType.ext (Cedar.Validation.ExtType.ipAddr)) })],
   acts := Cedar.Data.Map.mk
             [({ ty := { id := "Album", path := [] }, eid := "b" },
               { appliesToPrincipal := Cedar.Data.Set.mk [{ id := "Foo", path := [] }, { id := "Photo", path := [] }],
                 appliesToResource := Cedar.Data.Set.mk [{ id := "Foo", path := [] }, { id := "User", path := [] }],
                 ancestors := Cedar.Data.Set.mk
                                [{ ty := { id := "Album", path := [] }, eid := "y" },
                                 { ty := { id := "User", path := [] }, eid := "alice" },
                                 { ty := { id := "User", path := [] }, eid := "view" }],
                 context := Cedar.Data.Map.mk
                              [("age",
                                Cedar.Validation.Qualified.required
                                  (Cedar.Validation.CedarType.ext (Cedar.Validation.ExtType.ipAddr)))] }),
              ({ ty := { id := "Foo", path := [] }, eid := "view" },
               { appliesToPrincipal := Cedar.Data.Set.mk [],
                 appliesToResource := Cedar.Data.Set.mk [],
                 ancestors := Cedar.Data.Set.mk [{ ty := { id := "Action", path := [] }, eid := "a" }],
                 context := Cedar.Data.Map.mk
                              [("owner",
                                Cedar.Validation.Qualified.optional
                                  (Cedar.Validation.CedarType.ext (Cedar.Validation.ExtType.datetime)))] })] })) — validate passed but policy p0 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.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 := "b" },
               { appliesToPrincipal := Cedar.Data.Set.mk [{ id := "User", path := [] }],
                 appliesToResource := Cedar.Data.Set.mk [{ id := "Action", path := [] }, { id := "Photo", path := [] }],
                 ancestors := Cedar.Data.Set.mk
                                [{ ty := { id := "Foo", path := [] }, eid := "p1" },
                                 { ty := { id := "Photo", path := [] }, eid := "edit" },
                                 { ty := { id := "Photo", path := [] }, eid := "p1" }],
                 context := Cedar.Data.Map.mk [] }),
              ({ ty := { id := "Photo", path := [] }, eid := "ghost" },
               { appliesToPrincipal := Cedar.Data.Set.mk [{ id := "Foo", path := [] }, { id := "Photo", path := [] }],
                 appliesToResource := Cedar.Data.Set.mk [{ id := "Album", path := [] }],
                 ancestors := Cedar.Data.Set.mk
                                [{ ty := { id := "Album", path := [] }, eid := "y" },
                                 { ty := { id := "Photo", path := [] }, eid := "edit" }],
                 context := Cedar.Data.Map.mk [] })] })) — validate passed but policy p0 references undeclared entities


(([{ id := "p2",
    effect := Cedar.Spec.Effect.permit,
    principalScope := Cedar.Spec.PrincipalScope.principalScope (Cedar.Spec.Scope.is { id := "Foo", path := [] }),
    actionScope := Cedar.Spec.ActionScope.actionScope
                     (Cedar.Spec.Scope.mem { ty := { id := "Action", path := [] }, eid := "alice" }),
    resourceScope := Cedar.Spec.ResourceScope.resourceScope (Cedar.Spec.Scope.any),
    condition := [] }],
 { ets := Cedar.Data.Map.mk
            [({ id := "Album", path := [] },
              Cedar.Validation.EntitySchemaEntry.standard
                { ancestors := Cedar.Data.Set.mk [], attrs := Cedar.Data.Map.mk [], tags := none }),
             ({ id := "User", path := [] }, Cedar.Validation.EntitySchemaEntry.enum (Cedar.Data.Set.mk []))],
   acts := Cedar.Data.Map.mk
             [({ ty := { id := "Action", path := [] }, eid := "alice" },
               { appliesToPrincipal := Cedar.Data.Set.mk [{ id := "Foo", path := [] }],
                 appliesToResource := Cedar.Data.Set.mk [{ id := "Photo", path := [] }],
                 ancestors := Cedar.Data.Set.mk [{ ty := { id := "User", path := [] }, eid := "b" }],
                 context := Cedar.Data.Map.mk
                              [("owner",
                                Cedar.Validation.Qualified.required
                                  (Cedar.Validation.CedarType.ext (Cedar.Validation.ExtType.ipAddr)))] }),
              ({ ty := { id := "Action", path := [] }, eid := "bob" },
               { appliesToPrincipal := Cedar.Data.Set.mk
                                         [{ id := "Action", path := [] },
                                          { id := "Album", path := [] },
                                          { id := "Foo", path := [] }],
                 appliesToResource := Cedar.Data.Set.mk
                                        [{ id := "Album", path := [] },
                                         { id := "Photo", path := [] },
                                         { id := "User", path := [] }],
                 ancestors := Cedar.Data.Set.mk [{ ty := { id := "Photo", path := [] }, eid := "view" }],
                 context := Cedar.Data.Map.mk
                              [("flag",
                                Cedar.Validation.Qualified.optional
                                  (Cedar.Validation.CedarType.ext (Cedar.Validation.ExtType.ipAddr)))] }),
              ({ ty := { id := "Photo", path := [] }, eid := "a" },
               { 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 := "Action", path := [] }, eid := "z" },
                                 { ty := { id := "Photo", path := [] }, eid := "y" }],
                 context := Cedar.Data.Map.mk [] })] })) — validate passed but policy p2 references undeclared entities


(([{ id := "p0",
    effect := Cedar.Spec.Effect.permit,
    principalScope := Cedar.Spec.PrincipalScope.principalScope (Cedar.Spec.Scope.is { id := "Album", 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 := "a" },
               { appliesToPrincipal := Cedar.Data.Set.mk [{ id := "Album", path := [] }],
                 appliesToResource := Cedar.Data.Set.mk
                                        [{ id := "Album", path := [] },
                                         { id := "Foo", path := [] },
                                         { id := "Photo", path := [] }],
                 ancestors := Cedar.Data.Set.mk [{ ty := { id := "User", path := [] }, eid := "a" }],
                 context := Cedar.Data.Map.mk
                              [("owner",
                                Cedar.Validation.Qualified.required
                                  (Cedar.Validation.CedarType.ext (Cedar.Validation.ExtType.decimal)))] }),
              ({ ty := { id := "Foo", path := [] }, eid := "a" },
               { appliesToPrincipal := Cedar.Data.Set.mk [{ id := "Album", path := [] }, { id := "Foo", path := [] }],
                 appliesToResource := Cedar.Data.Set.mk [{ id := "Action", path := [] }, { id := "User", path := [] }],
                 ancestors := Cedar.Data.Set.mk
                                [{ ty := { id := "Action", path := [] }, eid := "ghost" },
                                 { ty := { id := "Action", path := [] }, eid := "y" },
                                 { ty := { id := "Photo", path := [] }, eid := "p1" }],
                 context := Cedar.Data.Map.mk
                              [("owner",
                                Cedar.Validation.Qualified.optional
                                  (Cedar.Validation.CedarType.entity { id := "Photo", path := [] }))] })] })) — validate passed but policy p0 references undeclared entities


(([{ id := "p2",
    effect := Cedar.Spec.Effect.permit,
    principalScope := Cedar.Spec.PrincipalScope.principalScope (Cedar.Spec.Scope.is { id := "Photo", path := [] }),
    actionScope := Cedar.Spec.ActionScope.actionScope (Cedar.Spec.Scope.any),
    resourceScope := Cedar.Spec.ResourceScope.resourceScope
                       (Cedar.Spec.Scope.mem { ty := { id := "Album", path := [] }, eid := "view" }),
    condition := [] }],
 { 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 [],
                  tags := some (Cedar.Validation.CedarType.int) }),
             ({ id := "Foo", path := [] },
              Cedar.Validation.EntitySchemaEntry.standard
                { ancestors := Cedar.Data.Set.mk [],
                  attrs := Cedar.Data.Map.mk
                             [("name",
                               Cedar.Validation.Qualified.required
                                 (Cedar.Validation.CedarType.entity { id := "Album", path := [] }))],
                  tags := none })],
   acts := Cedar.Data.Map.mk
             [({ ty := { id := "User", path := [] }, eid := "a" },
               { appliesToPrincipal := Cedar.Data.Set.mk [{ id := "Photo", path := [] }],
                 appliesToResource := Cedar.Data.Set.mk
                                        [{ id := "Action", path := [] },
                                         { id := "Album", path := [] },
                                         { id := "Foo", path := [] }],
                 ancestors := Cedar.Data.Set.mk [{ ty := { id := "Foo", path := [] }, eid := "b" }],
                 context := Cedar.Data.Map.mk
                              [("flag", Cedar.Validation.Qualified.required (Cedar.Validation.CedarType.string))] }),
              ({ ty := { id := "User", path := [] }, eid := "x" },
               { appliesToPrincipal := Cedar.Data.Set.mk [{ id := "Action", path := [] }, { id := "User", path := [] }],
                 appliesToResource := Cedar.Data.Set.mk [{ id := "Album", path := [] }],
                 ancestors := Cedar.Data.Set.mk
                                [{ ty := { id := "Action", path := [] }, eid := "a" },
                                 { ty := { id := "Photo", path := [] }, eid := "edit" }],
                 context := Cedar.Data.Map.mk
                              [("name", Cedar.Validation.Qualified.required (Cedar.Validation.CedarType.int)),
                               ("owner",
                                Cedar.Validation.Qualified.required
                                  (Cedar.Validation.CedarType.bool (Cedar.Validation.BoolType.tt)))] })] })) — 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 := "Action", path := [] }),
    actionScope := Cedar.Spec.ActionScope.actionInAny [{ ty := { id := "Album", path := [] }, eid := "alice" }],
    resourceScope := Cedar.Spec.ResourceScope.resourceScope (Cedar.Spec.Scope.any),
    condition := [] }],
 { ets := Cedar.Data.Map.mk
            [({ id := "User", path := [] },
              Cedar.Validation.EntitySchemaEntry.standard
                { ancestors := Cedar.Data.Set.mk [{ id := "Album", path := [] }, { id := "Foo", path := [] }],
                  attrs := Cedar.Data.Map.mk
                             [("age",
                               Cedar.Validation.Qualified.required
                                 (Cedar.Validation.CedarType.ext (Cedar.Validation.ExtType.datetime))),
                              ("name",
                               Cedar.Validation.Qualified.required
                                 (Cedar.Validation.CedarType.ext (Cedar.Validation.ExtType.decimal)))],
                  tags := none })],
   acts := Cedar.Data.Map.mk
             [({ ty := { id := "Album", path := [] }, eid := "alice" },
               { appliesToPrincipal := Cedar.Data.Set.mk
                                         [{ id := "Action", path := [] },
                                          { id := "Foo", path := [] },
                                          { id := "Photo", path := [] }],
                 appliesToResource := Cedar.Data.Set.mk [{ id := "User", path := [] }],
                 ancestors := Cedar.Data.Set.mk
                                [{ ty := { id := "Foo", path := [] }, eid := "view" },
                                 { ty := { id := "Photo", path := [] }, eid := "x" },
                                 { ty := { id := "User", path := [] }, eid := "x" }],
                 context := Cedar.Data.Map.mk [] }),
              ({ ty := { id := "Foo", path := [] }, eid := "a" },
               { appliesToPrincipal := Cedar.Data.Set.mk [{ id := "Action", path := [] }],
                 appliesToResource := Cedar.Data.Set.mk [],
                 ancestors := Cedar.Data.Set.mk [],
                 context := Cedar.Data.Map.mk
                              [("age", Cedar.Validation.Qualified.optional (Cedar.Validation.CedarType.string)),
                               ("owner", Cedar.Validation.Qualified.required (Cedar.Validation.CedarType.string))] }),
              ({ ty := { id := "Photo", path := [] }, eid := "p1" },
               { appliesToPrincipal := Cedar.Data.Set.mk [],
                 appliesToResource := Cedar.Data.Set.mk [{ id := "Action", path := [] }],
                 ancestors := Cedar.Data.Set.mk
                                [{ ty := { id := "Action", path := [] }, eid := "view" },
                                 { ty := { id := "Action", path := [] }, eid := "x" },
                                 { ty := { id := "Action", path := [] }, eid := "z" }],
                 context := Cedar.Data.Map.mk
                              [("age",
                                Cedar.Validation.Qualified.required
                                  (Cedar.Validation.CedarType.bool (Cedar.Validation.BoolType.anyBool))),
                               ("flag", Cedar.Validation.Qualified.optional (Cedar.Validation.CedarType.int))] })] })) — validate passed but policy p0 references undeclared entities


(([{ id := "p0",
    effect := Cedar.Spec.Effect.forbid,
    principalScope := Cedar.Spec.PrincipalScope.principalScope (Cedar.Spec.Scope.is { id := "Photo", 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
            [({ id := "Action", path := [] },
              Cedar.Validation.EntitySchemaEntry.enum (Cedar.Data.Set.mk ["alice", "bob"])),
             ({ id := "Album", path := [] },
              Cedar.Validation.EntitySchemaEntry.enum (Cedar.Data.Set.mk ["alice", "ghost"])),
             ({ id := "User", path := [] },
              Cedar.Validation.EntitySchemaEntry.standard
                { ancestors := Cedar.Data.Set.mk [{ id := "Album", path := [] }, { id := "Foo", path := [] }],
                  attrs := Cedar.Data.Map.mk
                             [("owner",
                               Cedar.Validation.Qualified.optional
                                 (Cedar.Validation.CedarType.ext (Cedar.Validation.ExtType.ipAddr)))],
                  tags := none })],
   acts := Cedar.Data.Map.mk
             [({ ty := { id := "Album", path := [] }, eid := "a" },
               { appliesToPrincipal := Cedar.Data.Set.mk
                                         [{ id := "Action", path := [] },
                                          { id := "Album", path := [] },
                                          { id := "Photo", path := [] }],
                 appliesToResource := Cedar.Data.Set.mk [{ id := "Action", path := [] }, { id := "Photo", path := [] }],
                 ancestors := Cedar.Data.Set.mk [],
                 context := Cedar.Data.Map.mk
                              [("flag", Cedar.Validation.Qualified.optional (Cedar.Validation.CedarType.int)),
                               ("name",
                                Cedar.Validation.Qualified.optional
                                  (Cedar.Validation.CedarType.entity { id := "Photo", path := [] }))] }),
              ({ ty := { id := "Foo", path := [] }, eid := "alice" },
               { appliesToPrincipal := Cedar.Data.Set.mk [{ id := "Foo", path := [] }, { id := "Photo", path := [] }],
                 appliesToResource := Cedar.Data.Set.mk [{ id := "Photo", path := [] }],
                 ancestors := Cedar.Data.Set.mk
                                [{ ty := { id := "Action", path := [] }, eid := "x" },
                                 { ty := { id := "User", path := [] }, eid := "a" }],
                 context := Cedar.Data.Map.mk
                              [("flag", Cedar.Validation.Qualified.required (Cedar.Validation.CedarType.string))] }),
              ({ ty := { id := "User", path := [] }, eid := "y" },
               { appliesToPrincipal := Cedar.Data.Set.mk [],
                 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.bool (Cedar.Validation.BoolType.anyBool)))] })] })) — validate passed but policy p0 references undeclared entities


(([{ id := "p0",
    effect := Cedar.Spec.Effect.permit,
    principalScope := Cedar.Spec.PrincipalScope.principalScope (Cedar.Spec.Scope.is { id := "Album", path := [] }),
    actionScope := Cedar.Spec.ActionScope.actionScope
                     (Cedar.Spec.Scope.eq { ty := { id := "User", path := [] }, eid := "alice" }),
    resourceScope := Cedar.Spec.ResourceScope.resourceScope (Cedar.Spec.Scope.any),
    condition := [] }],
 { ets := Cedar.Data.Map.mk
            [({ id := "Action", path := [] },
              Cedar.Validation.EntitySchemaEntry.standard
                { ancestors := Cedar.Data.Set.mk [{ id := "Action", path := [] }, { id := "Photo", path := [] }],
                  attrs := Cedar.Data.Map.mk [],
                  tags := some (Cedar.Validation.CedarType.ext (Cedar.Validation.ExtType.duration)) }),
             ({ 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.datetime))),
                              ("name",
                               Cedar.Validation.Qualified.optional
                                 (Cedar.Validation.CedarType.ext (Cedar.Validation.ExtType.datetime)))],
                  tags := some (Cedar.Validation.CedarType.bool (Cedar.Validation.BoolType.anyBool)) })],
   acts := Cedar.Data.Map.mk
             [({ ty := { id := "Photo", path := [] }, eid := "edit" },
               { appliesToPrincipal := Cedar.Data.Set.mk [],
                 appliesToResource := Cedar.Data.Set.mk [{ id := "Foo", path := [] }, { id := "Photo", path := [] }],
                 ancestors := Cedar.Data.Set.mk [],
                 context := Cedar.Data.Map.mk
                              [("flag",
                                Cedar.Validation.Qualified.optional
                                  (Cedar.Validation.CedarType.entity { id := "User", path := [] }))] }),
              ({ ty := { id := "User", path := [] }, eid := "alice" },
               { appliesToPrincipal := Cedar.Data.Set.mk [{ id := "Album", path := [] }, { id := "Photo", path := [] }],
                 appliesToResource := Cedar.Data.Set.mk [{ id := "Action", path := [] }, { id := "Foo", path := [] }],
                 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.bool (Cedar.Validation.BoolType.tt)))] })] })) — validate passed but policy p0 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 := [] }],
 { ets := Cedar.Data.Map.mk
            [({ id := "Foo", path := [] },
              Cedar.Validation.EntitySchemaEntry.standard
                { ancestors := Cedar.Data.Set.mk [{ id := "Foo", path := [] }],
                  attrs := Cedar.Data.Map.mk [],
                  tags := none })],
   acts := Cedar.Data.Map.mk
             [({ ty := { id := "Action", path := [] }, eid := "alice" },
               { appliesToPrincipal := Cedar.Data.Set.mk [{ id := "Foo", path := [] }, { id := "Photo", path := [] }],
                 appliesToResource := Cedar.Data.Set.mk [{ id := "Action", path := [] }],
                 ancestors := Cedar.Data.Set.mk
                                [{ ty := { id := "Action", path := [] }, eid := "a" },
                                 { ty := { id := "Foo", path := [] }, eid := "b" },
                                 { ty := { id := "Photo", path := [] }, eid := "y" }],
                 context := Cedar.Data.Map.mk
                              [("owner",
                                Cedar.Validation.Qualified.required
                                  (Cedar.Validation.CedarType.bool (Cedar.Validation.BoolType.anyBool)))] }),
              ({ ty := { id := "Action", path := [] }, eid := "b" },
               { appliesToPrincipal := Cedar.Data.Set.mk [{ id := "Photo", path := [] }, { id := "User", path := [] }],
                 appliesToResource := Cedar.Data.Set.mk [{ id := "Action", path := [] }],
                 ancestors := Cedar.Data.Set.mk [{ ty := { id := "Album", path := [] }, eid := "z" }],
                 context := Cedar.Data.Map.mk
                              [("flag",
                                Cedar.Validation.Qualified.optional
                                  (Cedar.Validation.CedarType.bool (Cedar.Validation.BoolType.ff))),
                               ("name", Cedar.Validation.Qualified.optional (Cedar.Validation.CedarType.string))] })] })) — validate passed but policy p0 references undeclared entities


validate passed but policy p0 references undeclared entities


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


(({ ets := Cedar.Data.Map.mk
            [({ id := "Photo", path := [] },
              Cedar.Validation.EntitySchemaEntry.standard
                { ancestors := Cedar.Data.Set.mk [{ id := "User", path := [] }],
                  attrs := Cedar.Data.Map.mk [],
                  tags := none })],
   acts := Cedar.Data.Map.mk
             [({ ty := { id := "Album", path := [] }, eid := "p1" },
               { appliesToPrincipal := Cedar.Data.Set.mk [{ id := "Album", path := [] }],
                 appliesToResource := Cedar.Data.Set.mk [{ id := "Action", path := [] }, { id := "User", path := [] }],
                 ancestors := Cedar.Data.Set.mk [],
                 context := Cedar.Data.Map.mk [] }),
              ({ ty := { id := "Foo", path := [] }, eid := "p1" },
               { appliesToPrincipal := Cedar.Data.Set.mk [{ id := "Photo", 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.optional
                                  (Cedar.Validation.CedarType.entity { id := "Photo", path := [] }))] })] },
 { principal := { ty := { id := "Album", path := [] }, eid := "bob" },
   action := { ty := { id := "Album", path := [] }, eid := "p1" },
   resource := { ty := { id := "Action", path := [] }, eid := "b" },
   context := Cedar.Data.Map.mk [] })) — validateRequest passed but principal Album::"bob" is not declared in schema


(({ 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
                             [("age",
                               Cedar.Validation.Qualified.required
                                 (Cedar.Validation.CedarType.ext (Cedar.Validation.ExtType.duration)))],
                  tags := some (Cedar.Validation.CedarType.entity { id := "User", path := [] }) })],
   acts := Cedar.Data.Map.mk
             [({ ty := { id := "Foo", path := [] }, eid := "z" },
               { 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 := [] },
                                         { id := "Photo", path := [] }],
                 ancestors := Cedar.Data.Set.mk [],
                 context := Cedar.Data.Map.mk
                              [("age",
                                Cedar.Validation.Qualified.optional
                                  (Cedar.Validation.CedarType.entity { id := "User", path := [] }))] })] },
 { principal := { ty := { id := "Action", path := [] }, eid := "edit" },
   action := { ty := { id := "Foo", path := [] }, eid := "z" },
   resource := { ty := { id := "Album", path := [] }, eid := "bob" },
   context := Cedar.Data.Map.mk [] })) — validateRequest passed but principal Action::"edit" is not declared in schema


(({ ets := Cedar.Data.Map.mk [],
   acts := Cedar.Data.Map.mk
             [({ ty := { id := "Action", path := [] }, eid := "x" },
               { appliesToPrincipal := Cedar.Data.Set.mk
                                         [{ id := "Album", path := [] },
                                          { id := "Photo", path := [] },
                                          { id := "User", path := [] }],
                 appliesToResource := Cedar.Data.Set.mk
                                        [{ id := "Action", path := [] },
                                         { id := "Album", path := [] },
                                         { id := "Photo", path := [] }],
                 ancestors := Cedar.Data.Set.mk [],
                 context := Cedar.Data.Map.mk
                              [("age",
                                Cedar.Validation.Qualified.optional
                                  (Cedar.Validation.CedarType.bool (Cedar.Validation.BoolType.tt)))] }),
              ({ ty := { id := "Album", path := [] }, eid := "edit" },
               { appliesToPrincipal := Cedar.Data.Set.mk [{ 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.required
                                  (Cedar.Validation.CedarType.bool (Cedar.Validation.BoolType.anyBool))),
                               ("owner",
                                Cedar.Validation.Qualified.required
                                  (Cedar.Validation.CedarType.entity { id := "Album", path := [] }))] }),
              ({ ty := { id := "Foo", path := [] }, eid := "alice" },
               { appliesToPrincipal := Cedar.Data.Set.mk [{ id := "Action", path := [] }],
                 appliesToResource := Cedar.Data.Set.mk [{ id := "Foo", path := [] }, { id := "User", path := [] }],
                 ancestors := Cedar.Data.Set.mk [],
                 context := Cedar.Data.Map.mk
                              [("flag",
                                Cedar.Validation.Qualified.optional
                                  (Cedar.Validation.CedarType.bool (Cedar.Validation.BoolType.tt)))] })] },
 { principal := { ty := { id := "User", path := [] }, eid := "bob" },
   action := { ty := { id := "Action", path := [] }, eid := "x" },
   resource := { ty := { id := "Album", path := [] }, eid := "y" },
   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 := "Action", path := [] }, eid := "b" },
               { 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 [{ ty := { id := "Action", path := [] }, eid := "view" }],
                 context := Cedar.Data.Map.mk
                              [("owner",
                                Cedar.Validation.Qualified.optional
                                  (Cedar.Validation.CedarType.ext (Cedar.Validation.ExtType.duration)))] }),
              ({ ty := { id := "Action", path := [] }, eid := "y" },
               { appliesToPrincipal := Cedar.Data.Set.mk [{ id := "Foo", path := [] }, { id := "Photo", path := [] }],
                 appliesToResource := Cedar.Data.Set.mk [{ id := "Action", path := [] }],
                 ancestors := Cedar.Data.Set.mk
                                [{ ty := { id := "Action", path := [] }, eid := "b" },
                                 { ty := { id := "Photo", path := [] }, eid := "p1" }],
                 context := Cedar.Data.Map.mk
                              [("age", Cedar.Validation.Qualified.required (Cedar.Validation.CedarType.int)),
                               ("name",
                                Cedar.Validation.Qualified.optional
                                  (Cedar.Validation.CedarType.bool (Cedar.Validation.BoolType.tt)))] })] },
 { principal := { ty := { id := "User", path := [] }, eid := "ghost" },
   action := { ty := { id := "Action", path := [] }, eid := "b" },
   resource := { ty := { id := "User", path := [] }, eid := "view" },
   context := Cedar.Data.Map.mk [] })) — validateRequest passed but principal User::"ghost" is not declared in schema


(({ ets := Cedar.Data.Map.mk
            [({ id := "Album", path := [] },
              Cedar.Validation.EntitySchemaEntry.standard
                { ancestors := Cedar.Data.Set.mk [{ id := "Album", path := [] }],
                  attrs := Cedar.Data.Map.mk [],
                  tags := some (Cedar.Validation.CedarType.bool (Cedar.Validation.BoolType.tt)) }),
             ({ id := "Photo", path := [] },
              Cedar.Validation.EntitySchemaEntry.standard
                { ancestors := Cedar.Data.Set.mk [{ id := "Action", path := [] }, { id := "User", path := [] }],
                  attrs := Cedar.Data.Map.mk [],
                  tags := none }),
             ({ id := "User", path := [] },
              Cedar.Validation.EntitySchemaEntry.standard
                { ancestors := Cedar.Data.Set.mk
                                 [{ id := "Album", path := [] },
                                  { id := "Foo", path := [] },
                                  { id := "Photo", path := [] }],
                  attrs := Cedar.Data.Map.mk [],
                  tags := some (Cedar.Validation.CedarType.ext (Cedar.Validation.ExtType.datetime)) })],
   acts := Cedar.Data.Map.mk
             [({ ty := { id := "Album", path := [] }, eid := "edit" },
               { appliesToPrincipal := Cedar.Data.Set.mk [{ id := "Action", path := [] }, { id := "Foo", path := [] }],
                 appliesToResource := Cedar.Data.Set.mk [{ id := "Album", path := [] }],
                 ancestors := Cedar.Data.Set.mk [{ ty := { id := "Action", path := [] }, eid := "b" }],
                 context := Cedar.Data.Map.mk
                              [("age",
                                Cedar.Validation.Qualified.optional
                                  (Cedar.Validation.CedarType.ext (Cedar.Validation.ExtType.ipAddr))),
                               ("flag", Cedar.Validation.Qualified.optional (Cedar.Validation.CedarType.string))] }),
              ({ ty := { id := "Foo", path := [] }, eid := "b" },
               { appliesToPrincipal := Cedar.Data.Set.mk [{ id := "Foo", 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 := "p1" }],
                 context := Cedar.Data.Map.mk [] })] },
 { principal := { ty := { id := "Foo", path := [] }, eid := "ghost" },
   action := { ty := { id := "Foo", path := [] }, eid := "b" },
   resource := { ty := { id := "Album", path := [] }, eid := "alice" },
   context := Cedar.Data.Map.mk [] })) — validateRequest passed but principal Foo::"ghost" is not declared in schema


(({ ets := Cedar.Data.Map.mk
            [({ id := "Action", path := [] }, Cedar.Validation.EntitySchemaEntry.enum (Cedar.Data.Set.mk [])),
             ({ id := "Photo", path := [] },
              Cedar.Validation.EntitySchemaEntry.standard
                { ancestors := Cedar.Data.Set.mk [{ id := "Action", path := [] }, { id := "Foo", path := [] }],
                  attrs := Cedar.Data.Map.mk
                             [("owner", Cedar.Validation.Qualified.required (Cedar.Validation.CedarType.int))],
                  tags := none }),
             ({ id := "User", path := [] }, Cedar.Validation.EntitySchemaEntry.enum (Cedar.Data.Set.mk ["bob", "y"]))],
   acts := Cedar.Data.Map.mk
             [({ ty := { id := "Action", path := [] }, eid := "view" },
               { appliesToPrincipal := Cedar.Data.Set.mk
                                         [{ id := "Action", path := [] },
                                          { 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 := "Action", path := [] }, eid := "ghost" },
                                 { ty := { id := "User", path := [] }, eid := "ghost" }],
                 context := Cedar.Data.Map.mk [] })] },
 { principal := { ty := { id := "Action", path := [] }, eid := "edit" },
   action := { ty := { id := "Action", path := [] }, eid := "view" },
   resource := { ty := { id := "Action", path := [] }, eid := "ghost" },
   context := Cedar.Data.Map.mk [] })) — validateRequest passed but principal Action::"edit" is not declared in schema


(({ ets := Cedar.Data.Map.mk
            [({ id := "Album", path := [] }, Cedar.Validation.EntitySchemaEntry.enum (Cedar.Data.Set.mk []))],
   acts := Cedar.Data.Map.mk
             [({ ty := { id := "Foo", path := [] }, eid := "a" },
               { appliesToPrincipal := Cedar.Data.Set.mk
                                         [{ id := "Album", path := [] },
                                          { id := "Foo", path := [] },
                                          { id := "Photo", path := [] }],
                 appliesToResource := Cedar.Data.Set.mk [{ id := "User", path := [] }],
                 ancestors := Cedar.Data.Set.mk [],
                 context := Cedar.Data.Map.mk [] }),
              ({ ty := { id := "User", path := [] }, eid := "ghost" },
               { appliesToPrincipal := Cedar.Data.Set.mk [{ id := "Action", path := [] }, { id := "User", 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.entity { id := "Foo", path := [] })),
                               ("name",
                                Cedar.Validation.Qualified.required
                                  (Cedar.Validation.CedarType.ext (Cedar.Validation.ExtType.duration)))] })] },
 { principal := { ty := { id := "Photo", path := [] }, eid := "ghost" },
   action := { ty := { id := "Foo", path := [] }, eid := "a" },
   resource := { ty := { id := "User", path := [] }, eid := "ghost" },
   context := Cedar.Data.Map.mk [] })) — validateRequest passed but principal Photo::"ghost" is not declared in schema


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


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


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


({ ets := Cedar.Data.Map.mk
           [({ id := "Action", path := [] },
             Cedar.Validation.EntitySchemaEntry.standard
               { ancestors := Cedar.Data.Set.mk [],
                 attrs := Cedar.Data.Map.mk
                            [("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 [],
                 attrs := Cedar.Data.Map.mk
                            [("name", Cedar.Validation.Qualified.required (Cedar.Validation.CedarType.string))],
                 tags := some (Cedar.Validation.CedarType.ext (Cedar.Validation.ExtType.decimal)) }),
            ({ id := "User", path := [] }, Cedar.Validation.EntitySchemaEntry.enum (Cedar.Data.Set.mk ["bob", "z"]))],
  acts := Cedar.Data.Map.mk
            [({ ty := { id := "Album", path := [] }, eid := "a" },
              { appliesToPrincipal := Cedar.Data.Set.mk [{ id := "Action", path := [] }, { id := "Photo", path := [] }],
                appliesToResource := Cedar.Data.Set.mk
                                       [{ id := "Album", path := [] },
                                        { id := "Photo", path := [] },
                                        { id := "User", path := [] }],
                ancestors := Cedar.Data.Set.mk [],
                context := Cedar.Data.Map.mk
                             [("age",
                               Cedar.Validation.Qualified.optional
                                 (Cedar.Validation.CedarType.ext (Cedar.Validation.ExtType.datetime)))] })] }) — Schema.validateWellFormed passed but entity type Action 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 [], tags := none }),
            ({ id := "Photo", path := [] },
             Cedar.Validation.EntitySchemaEntry.standard
               { ancestors := Cedar.Data.Set.mk [], attrs := Cedar.Data.Map.mk [], tags := none }),
            ({ id := "User", path := [] },
             Cedar.Validation.EntitySchemaEntry.standard
               { ancestors := Cedar.Data.Set.mk [{ id := "User", path := [] }],
                 attrs := Cedar.Data.Map.mk
                            [("age",
                              Cedar.Validation.Qualified.required
                                (Cedar.Validation.CedarType.entity { id := "Photo", path := [] })),
                             ("owner",
                              Cedar.Validation.Qualified.required
                                (Cedar.Validation.CedarType.bool (Cedar.Validation.BoolType.tt)))],
                 tags := none })],
  acts := Cedar.Data.Map.mk
            [({ ty := { id := "Action", path := [] }, eid := "ghost" },
              { appliesToPrincipal := Cedar.Data.Set.mk [{ id := "Action", path := [] }, { id := "Foo", path := [] }],
                appliesToResource := Cedar.Data.Set.mk [{ id := "Album", path := [] }],
                ancestors := Cedar.Data.Set.mk [],
                context := Cedar.Data.Map.mk
                             [("name",
                               Cedar.Validation.Qualified.optional
                                 (Cedar.Validation.CedarType.entity { id := "User", path := [] }))] }),
             ({ ty := { id := "Album", path := [] }, eid := "view" },
              { appliesToPrincipal := Cedar.Data.Set.mk [{ id := "Action", path := [] }],
                appliesToResource := Cedar.Data.Set.mk [],
                ancestors := Cedar.Data.Set.mk [{ ty := { id := "Action", path := [] }, eid := "ghost" }],
                context := Cedar.Data.Map.mk
                             [("flag",
                               Cedar.Validation.Qualified.required
                                 (Cedar.Validation.CedarType.bool (Cedar.Validation.BoolType.anyBool)))] })] }) — Schema.validateWellFormed passed but entity type User has an unlifted (singleton-bool) attribute


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


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


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


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


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


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


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


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


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


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


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


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


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


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


(([{ id := "p2",
    effect := Cedar.Spec.Effect.forbid,
    principalScope := Cedar.Spec.PrincipalScope.principalScope (Cedar.Spec.Scope.any),
    actionScope := Cedar.Spec.ActionScope.actionInAny
                     [{ ty := { id := "Action", path := [] }, eid := "y" },
                      { ty := { id := "Action", path := [] }, eid := "view" }],
    resourceScope := Cedar.Spec.ResourceScope.resourceScope (Cedar.Spec.Scope.any),
    condition := [] }],
 { ets := Cedar.Data.Map.mk
            [({ id := "Action", path := [] },
              Cedar.Validation.EntitySchemaEntry.standard
                { ancestors := Cedar.Data.Set.mk [],
                  attrs := Cedar.Data.Map.mk
                             [("name",
                               Cedar.Validation.Qualified.required
                                 (Cedar.Validation.CedarType.entity { id := "User", path := [] }))],
                  tags := none }),
             ({ id := "User", path := [] },
              Cedar.Validation.EntitySchemaEntry.standard
                { ancestors := Cedar.Data.Set.mk
                                 [{ id := "Action", path := [] },
                                  { id := "Album", path := [] },
                                  { id := "Photo", path := [] }],
                  attrs := Cedar.Data.Map.mk
                             [("name",
                               Cedar.Validation.Qualified.required
                                 (Cedar.Validation.CedarType.entity { id := "Action", path := [] }))],
                  tags := some (Cedar.Validation.CedarType.entity { id := "User", path := [] }) })],
   acts := Cedar.Data.Map.mk
             [({ ty := { id := "Album", path := [] }, eid := "ghost" },
               { appliesToPrincipal := Cedar.Data.Set.mk [{ id := "Action", path := [] }],
                 appliesToResource := Cedar.Data.Set.mk [{ id := "Foo", path := [] }, { id := "User", path := [] }],
                 ancestors := Cedar.Data.Set.mk
                                [{ ty := { id := "Album", path := [] }, eid := "ghost" },
                                 { ty := { id := "User", path := [] }, eid := "b" }],
                 context := Cedar.Data.Map.mk
                              [("owner", Cedar.Validation.Qualified.optional (Cedar.Validation.CedarType.int))] }),
              ({ ty := { id := "Photo", path := [] }, eid := "alice" },
               { appliesToPrincipal := Cedar.Data.Set.mk
                                         [{ id := "Action", path := [] },
                                          { id := "Album", path := [] },
                                          { id := "Foo", path := [] }],
                 appliesToResource := Cedar.Data.Set.mk [{ id := "Album", path := [] }],
                 ancestors := Cedar.Data.Set.mk
                                [{ ty := { id := "Action", path := [] }, eid := "alice" },
                                 { ty := { id := "User", path := [] }, eid := "a" }],
                 context := Cedar.Data.Map.mk
                              [("age",
                                Cedar.Validation.Qualified.required
                                  (Cedar.Validation.CedarType.entity { id := "User", path := [] })),
                               ("owner",
                                Cedar.Validation.Qualified.required
                                  (Cedar.Validation.CedarType.bool (Cedar.Validation.BoolType.tt)))] }),
              ({ ty := { id := "User", path := [] }, eid := "a" },
               { appliesToPrincipal := Cedar.Data.Set.mk [{ id := "Album", path := [] }, { id := "User", path := [] }],
                 appliesToResource := Cedar.Data.Set.mk [],
                 ancestors := Cedar.Data.Set.mk
                                [{ ty := { id := "Album", path := [] }, eid := "alice" },
                                 { ty := { id := "Photo", path := [] }, eid := "b" }],
                 context := Cedar.Data.Map.mk
                              [("flag",
                                Cedar.Validation.Qualified.required
                                  (Cedar.Validation.CedarType.entity { id := "Photo", path := [] })),
                               ("name", Cedar.Validation.Qualified.required (Cedar.Validation.CedarType.string))] })] },
 4)) — validateWithLevel rejected policy p2 with .levelError — the level checker rejected an entity-access expression it should have allowed