Skip to content

Instantly share code, notes, and snippets.

@tommy-mor

tommy-mor/config.edn Secret

Created January 22, 2023 19:31
Show Gist options
  • Save tommy-mor/3f6ef52a98dd742b2fe9cee33fb7b98f to your computer and use it in GitHub Desktop.
Save tommy-mor/3f6ef52a98dd742b2fe9cee33fb7b98f to your computer and use it in GitHub Desktop.
Download ZIP
Raw
config.edn
;; output of (phrag.context/options->config {:db {:connection conn}})
({:scan-tables true,
:router nil,
:db
{:connection
#object [org.postgresql.jdbc.PgConnection 302381606 "org.postgresql.jdbc.PgConnection@1205fa26"]},
:tables
{:groups
{:lcn-fields
{:rsc
{:access {:type Int},
:created_at {:type String},
:edited_at {:type String},
:id {:type Int},
:title {:type String},
:user_id {:type String},
:description {:type String}},
:clauses
{:description {:type :StrWhere},
:or {:type (list :GroupClauses)},
:title {:type :StrWhere},
:id {:type :IntWhere},
:and {:type (list :GroupClauses)},
:user_id {:type :StrWhere},
:access {:type :IntWhere},
:edited_at {:type :StrWhere},
:created_at {:type :StrWhere}},
:sort
{:access {:type :SortOperator},
:created_at {:type :SortOperator},
:edited_at {:type :SortOperator},
:id {:type :SortOperator},
:title {:type :SortOperator},
:user_id {:type :SortOperator},
:description {:type :SortOperator}},
:fields
{:access {:type Int},
:created_at {:type String},
:edited_at {:type String},
:id {:type Int},
:title {:type String},
:user_id {:type String},
:description {:type String}},
:aggregate
{:count {:type Int},
:sum {:type :GroupFields},
:avg {:type :GroupFields},
:max {:type :GroupFields},
:min {:type :GroupFields}},
:pks {:id {:type (non-null Int)}},
:pk-input {:id {:type (non-null Int)}},
:update
{:access {:type Int},
:created_at {:type String},
:edited_at {:type String},
:title {:type String},
:user_id {:type String},
:description {:type String}}},
:fks
{:access
{:field-keys
{:to :Access,
:has-many :groups,
:has-many-aggr :groups_aggregate,
:has-one :access_access}},
:user_id
{:field-keys
{:to :User,
:has-many :groups,
:has-many-aggr :groups_aggregate,
:has-one :user}}},
:lcn-mut-keys
{:create :createGroup, :update :updateGroup, :delete :deleteGroup},
:lcn-obj-keys
{:rsc :Group,
:clauses :GroupClauses,
:where :GroupWhere,
:sort :GroupSort,
:fields :GroupFields,
:aggregate :GroupAggregate,
:pks :GroupPks,
:pk-input :GroupPkColumns},
:lcn-qry-keys {:queries :groups, :aggregate :groups_aggregate},
:lcn-descs
{:rsc "Groups",
:query "Query Groups.",
:clauses
"Format for where clauses is {column: {operator: value}}. Multiple parameters are applied with `AND` operators. `AND`/`OR` conditions can be created as a list of clauses. It is possible to nest them to create sub groups of conditions.",
:sort "Sort format is {column: \"asc\" or \"desc\"}.",
:fields "Groupsfields for aggregation.",
:aggregate "Aggrecate Groups.",
:pks "Primary key fields.",
:pk-input "Primary key fields."},
:signals
{:query {:pre (), :post ()},
:create {:pre (), :post ()},
:delete {:pre (), :post ()},
:update {:pre (), :post ()}},
:pk-keys (:id),
:col-keys
#{:description
:title
:id
:user_id
:access
:edited_at
:created_at}},
:roles
{:lcn-fields
{:rsc
{:id {:type Int},
:group_id {:type Int},
:title {:type String},
:color {:type String}},
:clauses
{:and {:type (list :RoleClauses)},
:or {:type (list :RoleClauses)},
:id {:type :IntWhere},
:group_id {:type :IntWhere},
:title {:type :StrWhere},
:color {:type :StrWhere}},
:sort
{:id {:type :SortOperator},
:group_id {:type :SortOperator},
:title {:type :SortOperator},
:color {:type :SortOperator}},
:fields
{:id {:type Int},
:group_id {:type Int},
:title {:type String},
:color {:type String}},
:aggregate
{:count {:type Int},
:sum {:type :RoleFields},
:avg {:type :RoleFields},
:max {:type :RoleFields},
:min {:type :RoleFields}},
:pks {:id {:type (non-null Int)}},
:pk-input {:id {:type (non-null Int)}},
:update
{:group_id {:type Int},
:title {:type String},
:color {:type String}}},
:fks
{:group_id
{:field-keys
{:to :Group,
:has-many :roles,
:has-many-aggr :roles_aggregate,
:has-one :group}}},
:lcn-mut-keys
{:create :createRole, :update :updateRole, :delete :deleteRole},
:lcn-obj-keys
{:rsc :Role,
:clauses :RoleClauses,
:where :RoleWhere,
:sort :RoleSort,
:fields :RoleFields,
:aggregate :RoleAggregate,
:pks :RolePks,
:pk-input :RolePkColumns},
:lcn-qry-keys {:queries :roles, :aggregate :roles_aggregate},
:lcn-descs
{:rsc "Roles",
:query "Query Roles.",
:clauses
"Format for where clauses is {column: {operator: value}}. Multiple parameters are applied with `AND` operators. `AND`/`OR` conditions can be created as a list of clauses. It is possible to nest them to create sub groups of conditions.",
:sort "Sort format is {column: \"asc\" or \"desc\"}.",
:fields "Rolesfields for aggregation.",
:aggregate "Aggrecate Roles.",
:pks "Primary key fields.",
:pk-input "Primary key fields."},
:groups
{:lcn-fields
{:rsc
{:access {:type Int},
:created_at {:type String},
:edited_at {:type String},
:id {:type Int},
:title {:type String},
:user_id {:type String},
:description {:type String}},
:clauses
{:description {:type :StrWhere},
:or {:type (list :GroupClauses)},
:title {:type :StrWhere},
:id {:type :IntWhere},
:and {:type (list :GroupClauses)},
:user_id {:type :StrWhere},
:access {:type :IntWhere},
:edited_at {:type :StrWhere},
:created_at {:type :StrWhere}},
:sort
{:access {:type :SortOperator},
:created_at {:type :SortOperator},
:edited_at {:type :SortOperator},
:id {:type :SortOperator},
:title {:type :SortOperator},
:user_id {:type :SortOperator},
:description {:type :SortOperator}},
:fields
{:access {:type Int},
:created_at {:type String},
:edited_at {:type String},
:id {:type Int},
:title {:type String},
:user_id {:type String},
:description {:type String}},
:aggregate
{:count {:type Int},
:sum {:type :GroupFields},
:avg {:type :GroupFields},
:max {:type :GroupFields},
:min {:type :GroupFields}},
:pks {:id {:type (non-null Int)}},
:pk-input {:id {:type (non-null Int)}},
:update
{:access {:type Int},
:created_at {:type String},
:edited_at {:type String},
:title {:type String},
:user_id {:type String},
:description {:type String}}},
:fks
{:access
{:field-keys
{:to :Access,
:has-many :groups,
:has-many-aggr :groups_aggregate,
:has-one :access_access}},
:user_id
{:field-keys
{:to :User,
:has-many :groups,
:has-many-aggr :groups_aggregate,
:has-one :user}}},
:lcn-mut-keys
{:create :createGroup,
:update :updateGroup,
:delete :deleteGroup},
:lcn-obj-keys
{:rsc :Group,
:clauses :GroupClauses,
:where :GroupWhere,
:sort :GroupSort,
:fields :GroupFields,
:aggregate :GroupAggregate,
:pks :GroupPks,
:pk-input :GroupPkColumns},
:lcn-qry-keys {:queries :groups, :aggregate :groups_aggregate},
:lcn-descs
{:rsc "Groups",
:query "Query Groups.",
:clauses
"Format for where clauses is {column: {operator: value}}. Multiple parameters are applied with `AND` operators. `AND`/`OR` conditions can be created as a list of clauses. It is possible to nest them to create sub groups of conditions.",
:sort "Sort format is {column: \"asc\" or \"desc\"}.",
:fields "Groupsfields for aggregation.",
:aggregate "Aggrecate Groups.",
:pks "Primary key fields.",
:pk-input "Primary key fields."},
:signals
{:query {:pre (), :post ()},
:create {:pre (), :post ()},
:delete {:pre (), :post ()},
:update {:pre (), :post ()}},
:pk-keys (:id),
:col-keys
#{:description
:title
:id
:user_id
:access
:edited_at
:created_at}},
:signals
{:query {:pre (), :post ()},
:create {:pre (), :post ()},
:delete {:pre (), :post ()},
:update {:pre (), :post ()}},
:pk-keys (:id),
:col-keys #{:color :title :group_id :id}},
:access
{:lcn-fields
{:rsc
{:can_read {:type Boolean},
:inherit {:type Boolean},
:can_edit {:type Boolean},
:group_id {:type Int},
:id {:type Int},
:user_id {:type String},
:role_id {:type Int},
:next_access {:type Int},
:owner {:type Boolean}},
:clauses
{:can_read {:type :BoolWhere},
:inherit {:type :BoolWhere},
:can_edit {:type :BoolWhere},
:or {:type (list :AccessClauses)},
:group_id {:type :IntWhere},
:id {:type :IntWhere},
:and {:type (list :AccessClauses)},
:user_id {:type :StrWhere},
:role_id {:type :IntWhere},
:next_access {:type :IntWhere},
:owner {:type :BoolWhere}},
:sort
{:can_read {:type :SortOperator},
:inherit {:type :SortOperator},
:can_edit {:type :SortOperator},
:group_id {:type :SortOperator},
:id {:type :SortOperator},
:user_id {:type :SortOperator},
:role_id {:type :SortOperator},
:next_access {:type :SortOperator},
:owner {:type :SortOperator}},
:fields
{:can_read {:type Boolean},
:inherit {:type Boolean},
:can_edit {:type Boolean},
:group_id {:type Int},
:id {:type Int},
:user_id {:type String},
:role_id {:type Int},
:next_access {:type Int},
:owner {:type Boolean}},
:aggregate
{:count {:type Int},
:sum {:type :AccessFields},
:avg {:type :AccessFields},
:max {:type :AccessFields},
:min {:type :AccessFields}},
:pks {:id {:type (non-null Int)}},
:pk-input {:id {:type (non-null Int)}},
:update
{:can_read {:type Boolean},
:inherit {:type Boolean},
:can_edit {:type Boolean},
:group_id {:type Int},
:user_id {:type String},
:role_id {:type Int},
:next_access {:type Int},
:owner {:type Boolean}}},
:fks
{:next_access
{:field-keys
{:to :Access,
:has-many :accesses,
:has-many-aggr :accesses_aggregate,
:has-one :next_access_access}},
:role_id
{:field-keys
{:to :Role,
:has-many :accesses,
:has-many-aggr :accesses_aggregate,
:has-one :role}},
:user_id
{:field-keys
{:to :User,
:has-many :accesses,
:has-many-aggr :accesses_aggregate,
:has-one :user}},
:group_id
{:field-keys
{:to :Group,
:has-many :accesses,
:has-many-aggr :accesses_aggregate,
:has-one :group}}},
:lcn-mut-keys
{:create :createAccess,
:update :updateAccess,
:delete :deleteAccess},
:roles
{:lcn-fields
{:rsc
{:id {:type Int},
:group_id {:type Int},
:title {:type String},
:color {:type String}},
:clauses
{:and {:type (list :RoleClauses)},
:or {:type (list :RoleClauses)},
:id {:type :IntWhere},
:group_id {:type :IntWhere},
:title {:type :StrWhere},
:color {:type :StrWhere}},
:sort
{:id {:type :SortOperator},
:group_id {:type :SortOperator},
:title {:type :SortOperator},
:color {:type :SortOperator}},
:fields
{:id {:type Int},
:group_id {:type Int},
:title {:type String},
:color {:type String}},
:aggregate
{:count {:type Int},
:sum {:type :RoleFields},
:avg {:type :RoleFields},
:max {:type :RoleFields},
:min {:type :RoleFields}},
:pks {:id {:type (non-null Int)}},
:pk-input {:id {:type (non-null Int)}},
:update
{:group_id {:type Int},
:title {:type String},
:color {:type String}}},
:fks
{:group_id
{:field-keys
{:to :Group,
:has-many :roles,
:has-many-aggr :roles_aggregate,
:has-one :group}}},
:lcn-mut-keys
{:create :createRole, :update :updateRole, :delete :deleteRole},
:lcn-obj-keys
{:rsc :Role,
:clauses :RoleClauses,
:where :RoleWhere,
:sort :RoleSort,
:fields :RoleFields,
:aggregate :RoleAggregate,
:pks :RolePks,
:pk-input :RolePkColumns},
:lcn-qry-keys {:queries :roles, :aggregate :roles_aggregate},
:lcn-descs
{:rsc "Roles",
:query "Query Roles.",
:clauses
"Format for where clauses is {column: {operator: value}}. Multiple parameters are applied with `AND` operators. `AND`/`OR` conditions can be created as a list of clauses. It is possible to nest them to create sub groups of conditions.",
:sort "Sort format is {column: \"asc\" or \"desc\"}.",
:fields "Rolesfields for aggregation.",
:aggregate "Aggrecate Roles.",
:pks "Primary key fields.",
:pk-input "Primary key fields."},
:groups
{:lcn-fields
{:rsc
{:access {:type Int},
:created_at {:type String},
:edited_at {:type String},
:id {:type Int},
:title {:type String},
:user_id {:type String},
:description {:type String}},
:clauses
{:description {:type :StrWhere},
:or {:type (list :GroupClauses)},
:title {:type :StrWhere},
:id {:type :IntWhere},
:and {:type (list :GroupClauses)},
:user_id {:type :StrWhere},
:access {:type :IntWhere},
:edited_at {:type :StrWhere},
:created_at {:type :StrWhere}},
:sort
{:access {:type :SortOperator},
:created_at {:type :SortOperator},
:edited_at {:type :SortOperator},
:id {:type :SortOperator},
:title {:type :SortOperator},
:user_id {:type :SortOperator},
:description {:type :SortOperator}},
:fields
{:access {:type Int},
:created_at {:type String},
:edited_at {:type String},
:id {:type Int},
:title {:type String},
:user_id {:type String},
:description {:type String}},
:aggregate
{:count {:type Int},
:sum {:type :GroupFields},
:avg {:type :GroupFields},
:max {:type :GroupFields},
:min {:type :GroupFields}},
:pks {:id {:type (non-null Int)}},
:pk-input {:id {:type (non-null Int)}},
:update
{:access {:type Int},
:created_at {:type String},
:edited_at {:type String},
:title {:type String},
:user_id {:type String},
:description {:type String}}},
:fks
{:access
{:field-keys
{:to :Access,
:has-many :groups,
:has-many-aggr :groups_aggregate,
:has-one :access_access}},
:user_id
{:field-keys
{:to :User,
:has-many :groups,
:has-many-aggr :groups_aggregate,
:has-one :user}}},
:lcn-mut-keys
{:create :createGroup,
:update :updateGroup,
:delete :deleteGroup},
:lcn-obj-keys
{:rsc :Group,
:clauses :GroupClauses,
:where :GroupWhere,
:sort :GroupSort,
:fields :GroupFields,
:aggregate :GroupAggregate,
:pks :GroupPks,
:pk-input :GroupPkColumns},
:lcn-qry-keys {:queries :groups, :aggregate :groups_aggregate},
:lcn-descs
{:rsc "Groups",
:query "Query Groups.",
:clauses
"Format for where clauses is {column: {operator: value}}. Multiple parameters are applied with `AND` operators. `AND`/`OR` conditions can be created as a list of clauses. It is possible to nest them to create sub groups of conditions.",
:sort "Sort format is {column: \"asc\" or \"desc\"}.",
:fields "Groupsfields for aggregation.",
:aggregate "Aggrecate Groups.",
:pks "Primary key fields.",
:pk-input "Primary key fields."},
:signals
{:query {:pre (), :post ()},
:create {:pre (), :post ()},
:delete {:pre (), :post ()},
:update {:pre (), :post ()}},
:pk-keys (:id),
:col-keys
#{:description
:title
:id
:user_id
:access
:edited_at
:created_at}},
:signals
{:query {:pre (), :post ()},
:create {:pre (), :post ()},
:delete {:pre (), :post ()},
:update {:pre (), :post ()}},
:pk-keys (:id),
:col-keys #{:color :title :group_id :id}},
:lcn-obj-keys
{:rsc :Access,
:clauses :AccessClauses,
:where :AccessWhere,
:sort :AccessSort,
:fields :AccessFields,
:aggregate :AccessAggregate,
:pks :AccessPks,
:pk-input :AccessPkColumns},
:lcn-qry-keys {:queries :accesses, :aggregate :accesses_aggregate},
:lcn-descs
{:rsc "Accesses",
:query "Query Accesses.",
:clauses
"Format for where clauses is {column: {operator: value}}. Multiple parameters are applied with `AND` operators. `AND`/`OR` conditions can be created as a list of clauses. It is possible to nest them to create sub groups of conditions.",
:sort "Sort format is {column: \"asc\" or \"desc\"}.",
:fields "Accessesfields for aggregation.",
:aggregate "Aggrecate Accesses.",
:pks "Primary key fields.",
:pk-input "Primary key fields."},
:groups
{:lcn-fields
{:rsc
{:access {:type Int},
:created_at {:type String},
:edited_at {:type String},
:id {:type Int},
:title {:type String},
:user_id {:type String},
:description {:type String}},
:clauses
{:description {:type :StrWhere},
:or {:type (list :GroupClauses)},
:title {:type :StrWhere},
:id {:type :IntWhere},
:and {:type (list :GroupClauses)},
:user_id {:type :StrWhere},
:access {:type :IntWhere},
:edited_at {:type :StrWhere},
:created_at {:type :StrWhere}},
:sort
{:access {:type :SortOperator},
:created_at {:type :SortOperator},
:edited_at {:type :SortOperator},
:id {:type :SortOperator},
:title {:type :SortOperator},
:user_id {:type :SortOperator},
:description {:type :SortOperator}},
:fields
{:access {:type Int},
:created_at {:type String},
:edited_at {:type String},
:id {:type Int},
:title {:type String},
:user_id {:type String},
:description {:type String}},
:aggregate
{:count {:type Int},
:sum {:type :GroupFields},
:avg {:type :GroupFields},
:max {:type :GroupFields},
:min {:type :GroupFields}},
:pks {:id {:type (non-null Int)}},
:pk-input {:id {:type (non-null Int)}},
:update
{:access {:type Int},
:created_at {:type String},
:edited_at {:type String},
:title {:type String},
:user_id {:type String},
:description {:type String}}},
:fks
{:access
{:field-keys
{:to :Access,
:has-many :groups,
:has-many-aggr :groups_aggregate,
:has-one :access_access}},
:user_id
{:field-keys
{:to :User,
:has-many :groups,
:has-many-aggr :groups_aggregate,
:has-one :user}}},
:lcn-mut-keys
{:create :createGroup,
:update :updateGroup,
:delete :deleteGroup},
:lcn-obj-keys
{:rsc :Group,
:clauses :GroupClauses,
:where :GroupWhere,
:sort :GroupSort,
:fields :GroupFields,
:aggregate :GroupAggregate,
:pks :GroupPks,
:pk-input :GroupPkColumns},
:lcn-qry-keys {:queries :groups, :aggregate :groups_aggregate},
:lcn-descs
{:rsc "Groups",
:query "Query Groups.",
:clauses
"Format for where clauses is {column: {operator: value}}. Multiple parameters are applied with `AND` operators. `AND`/`OR` conditions can be created as a list of clauses. It is possible to nest them to create sub groups of conditions.",
:sort "Sort format is {column: \"asc\" or \"desc\"}.",
:fields "Groupsfields for aggregation.",
:aggregate "Aggrecate Groups.",
:pks "Primary key fields.",
:pk-input "Primary key fields."},
:signals
{:query {:pre (), :post ()},
:create {:pre (), :post ()},
:delete {:pre (), :post ()},
:update {:pre (), :post ()}},
:pk-keys (:id),
:col-keys
#{:description
:title
:id
:user_id
:access
:edited_at
:created_at}},
:signals
{:query {:pre (), :post ()},
:create {:pre (), :post ()},
:delete {:pre (), :post ()},
:update {:pre (), :post ()}},
:pk-keys (:id),
:col-keys
#{:can_read
:inherit
:can_edit
:group_id
:id
:user_id
:role_id
:next_access
:owner}},
:users_in_groups
{:lcn-fields
{:rsc
{:group_id {:type Int},
:role_id {:type Int},
:user_id {:type String}},
:clauses
{:and {:type (list :UsersInGroupClauses)},
:or {:type (list :UsersInGroupClauses)},
:group_id {:type :IntWhere},
:role_id {:type :IntWhere},
:user_id {:type :StrWhere}},
:sort
{:group_id {:type :SortOperator},
:role_id {:type :SortOperator},
:user_id {:type :SortOperator}},
:fields
{:group_id {:type Int},
:role_id {:type Int},
:user_id {:type String}},
:aggregate
{:count {:type Int},
:sum {:type :UsersInGroupFields},
:avg {:type :UsersInGroupFields},
:max {:type :UsersInGroupFields},
:min {:type :UsersInGroupFields}},
:pks
{:user_id {:type (non-null String)},
:group_id {:type (non-null Int)},
:role_id {:type (non-null Int)}},
:pk-input
{:user_id {:type (non-null String)},
:group_id {:type (non-null Int)},
:role_id {:type (non-null Int)}},
:update {}},
:fks
{:user_id
{:field-keys
{:to :User,
:has-many :users_in_groups,
:has-many-aggr :users_in_groups_aggregate,
:has-one :user}},
:group_id
{:field-keys
{:to :Group,
:has-many :users_in_groups,
:has-many-aggr :users_in_groups_aggregate,
:has-one :group}},
:role_id
{:field-keys
{:to :Role,
:has-many :users_in_groups,
:has-many-aggr :users_in_groups_aggregate,
:has-one :role}}},
:lcn-mut-keys
{:create :createUsersInGroup,
:update :updateUsersInGroup,
:delete :deleteUsersInGroup},
:roles
{:lcn-fields
{:rsc
{:id {:type Int},
:group_id {:type Int},
:title {:type String},
:color {:type String}},
:clauses
{:and {:type (list :RoleClauses)},
:or {:type (list :RoleClauses)},
:id {:type :IntWhere},
:group_id {:type :IntWhere},
:title {:type :StrWhere},
:color {:type :StrWhere}},
:sort
{:id {:type :SortOperator},
:group_id {:type :SortOperator},
:title {:type :SortOperator},
:color {:type :SortOperator}},
:fields
{:id {:type Int},
:group_id {:type Int},
:title {:type String},
:color {:type String}},
:aggregate
{:count {:type Int},
:sum {:type :RoleFields},
:avg {:type :RoleFields},
:max {:type :RoleFields},
:min {:type :RoleFields}},
:pks {:id {:type (non-null Int)}},
:pk-input {:id {:type (non-null Int)}},
:update
{:group_id {:type Int},
:title {:type String},
:color {:type String}}},
:fks
{:group_id
{:field-keys
{:to :Group,
:has-many :roles,
:has-many-aggr :roles_aggregate,
:has-one :group}}},
:lcn-mut-keys
{:create :createRole, :update :updateRole, :delete :deleteRole},
:lcn-obj-keys
{:rsc :Role,
:clauses :RoleClauses,
:where :RoleWhere,
:sort :RoleSort,
:fields :RoleFields,
:aggregate :RoleAggregate,
:pks :RolePks,
:pk-input :RolePkColumns},
:lcn-qry-keys {:queries :roles, :aggregate :roles_aggregate},
:lcn-descs
{:rsc "Roles",
:query "Query Roles.",
:clauses
"Format for where clauses is {column: {operator: value}}. Multiple parameters are applied with `AND` operators. `AND`/`OR` conditions can be created as a list of clauses. It is possible to nest them to create sub groups of conditions.",
:sort "Sort format is {column: \"asc\" or \"desc\"}.",
:fields "Rolesfields for aggregation.",
:aggregate "Aggrecate Roles.",
:pks "Primary key fields.",
:pk-input "Primary key fields."},
:groups
{:lcn-fields
{:rsc
{:access {:type Int},
:created_at {:type String},
:edited_at {:type String},
:id {:type Int},
:title {:type String},
:user_id {:type String},
:description {:type String}},
:clauses
{:description {:type :StrWhere},
:or {:type (list :GroupClauses)},
:title {:type :StrWhere},
:id {:type :IntWhere},
:and {:type (list :GroupClauses)},
:user_id {:type :StrWhere},
:access {:type :IntWhere},
:edited_at {:type :StrWhere},
:created_at {:type :StrWhere}},
:sort
{:access {:type :SortOperator},
:created_at {:type :SortOperator},
:edited_at {:type :SortOperator},
:id {:type :SortOperator},
:title {:type :SortOperator},
:user_id {:type :SortOperator},
:description {:type :SortOperator}},
:fields
{:access {:type Int},
:created_at {:type String},
:edited_at {:type String},
:id {:type Int},
:title {:type String},
:user_id {:type String},
:description {:type String}},
:aggregate
{:count {:type Int},
:sum {:type :GroupFields},
:avg {:type :GroupFields},
:max {:type :GroupFields},
:min {:type :GroupFields}},
:pks {:id {:type (non-null Int)}},
:pk-input {:id {:type (non-null Int)}},
:update
{:access {:type Int},
:created_at {:type String},
:edited_at {:type String},
:title {:type String},
:user_id {:type String},
:description {:type String}}},
:fks
{:access
{:field-keys
{:to :Access,
:has-many :groups,
:has-many-aggr :groups_aggregate,
:has-one :access_access}},
:user_id
{:field-keys
{:to :User,
:has-many :groups,
:has-many-aggr :groups_aggregate,
:has-one :user}}},
:lcn-mut-keys
{:create :createGroup,
:update :updateGroup,
:delete :deleteGroup},
:lcn-obj-keys
{:rsc :Group,
:clauses :GroupClauses,
:where :GroupWhere,
:sort :GroupSort,
:fields :GroupFields,
:aggregate :GroupAggregate,
:pks :GroupPks,
:pk-input :GroupPkColumns},
:lcn-qry-keys {:queries :groups, :aggregate :groups_aggregate},
:lcn-descs
{:rsc "Groups",
:query "Query Groups.",
:clauses
"Format for where clauses is {column: {operator: value}}. Multiple parameters are applied with `AND` operators. `AND`/`OR` conditions can be created as a list of clauses. It is possible to nest them to create sub groups of conditions.",
:sort "Sort format is {column: \"asc\" or \"desc\"}.",
:fields "Groupsfields for aggregation.",
:aggregate "Aggrecate Groups.",
:pks "Primary key fields.",
:pk-input "Primary key fields."},
:signals
{:query {:pre (), :post ()},
:create {:pre (), :post ()},
:delete {:pre (), :post ()},
:update {:pre (), :post ()}},
:pk-keys (:id),
:col-keys
#{:description
:title
:id
:user_id
:access
:edited_at
:created_at}},
:signals
{:query {:pre (), :post ()},
:create {:pre (), :post ()},
:delete {:pre (), :post ()},
:update {:pre (), :post ()}},
:pk-keys (:id),
:col-keys #{:color :title :group_id :id}},
:lcn-obj-keys
{:rsc :UsersInGroup,
:clauses :UsersInGroupClauses,
:where :UsersInGroupWhere,
:sort :UsersInGroupSort,
:fields :UsersInGroupFields,
:aggregate :UsersInGroupAggregate,
:pks :UsersInGroupPks,
:pk-input :UsersInGroupPkColumns},
:lcn-qry-keys
{:queries :users_in_groups, :aggregate :users_in_groups_aggregate},
:lcn-descs
{:rsc "UsersInGroups",
:query "Query UsersInGroups.",
:clauses
"Format for where clauses is {column: {operator: value}}. Multiple parameters are applied with `AND` operators. `AND`/`OR` conditions can be created as a list of clauses. It is possible to nest them to create sub groups of conditions.",
:sort "Sort format is {column: \"asc\" or \"desc\"}.",
:fields "UsersInGroupsfields for aggregation.",
:aggregate "Aggrecate UsersInGroups.",
:pks "Primary key fields.",
:pk-input "Primary key fields."},
:access
{:lcn-fields
{:rsc
{:can_read {:type Boolean},
:inherit {:type Boolean},
:can_edit {:type Boolean},
:group_id {:type Int},
:id {:type Int},
:user_id {:type String},
:role_id {:type Int},
:next_access {:type Int},
:owner {:type Boolean}},
:clauses
{:can_read {:type :BoolWhere},
:inherit {:type :BoolWhere},
:can_edit {:type :BoolWhere},
:or {:type (list :AccessClauses)},
:group_id {:type :IntWhere},
:id {:type :IntWhere},
:and {:type (list :AccessClauses)},
:user_id {:type :StrWhere},
:role_id {:type :IntWhere},
:next_access {:type :IntWhere},
:owner {:type :BoolWhere}},
:sort
{:can_read {:type :SortOperator},
:inherit {:type :SortOperator},
:can_edit {:type :SortOperator},
:group_id {:type :SortOperator},
:id {:type :SortOperator},
:user_id {:type :SortOperator},
:role_id {:type :SortOperator},
:next_access {:type :SortOperator},
:owner {:type :SortOperator}},
:fields
{:can_read {:type Boolean},
:inherit {:type Boolean},
:can_edit {:type Boolean},
:group_id {:type Int},
:id {:type Int},
:user_id {:type String},
:role_id {:type Int},
:next_access {:type Int},
:owner {:type Boolean}},
:aggregate
{:count {:type Int},
:sum {:type :AccessFields},
:avg {:type :AccessFields},
:max {:type :AccessFields},
:min {:type :AccessFields}},
:pks {:id {:type (non-null Int)}},
:pk-input {:id {:type (non-null Int)}},
:update
{:can_read {:type Boolean},
:inherit {:type Boolean},
:can_edit {:type Boolean},
:group_id {:type Int},
:user_id {:type String},
:role_id {:type Int},
:next_access {:type Int},
:owner {:type Boolean}}},
:fks
{:next_access
{:field-keys
{:to :Access,
:has-many :accesses,
:has-many-aggr :accesses_aggregate,
:has-one :next_access_access}},
:role_id
{:field-keys
{:to :Role,
:has-many :accesses,
:has-many-aggr :accesses_aggregate,
:has-one :role}},
:user_id
{:field-keys
{:to :User,
:has-many :accesses,
:has-many-aggr :accesses_aggregate,
:has-one :user}},
:group_id
{:field-keys
{:to :Group,
:has-many :accesses,
:has-many-aggr :accesses_aggregate,
:has-one :group}}},
:lcn-mut-keys
{:create :createAccess,
:update :updateAccess,
:delete :deleteAccess},
:roles
{:lcn-fields
{:rsc
{:id {:type Int},
:group_id {:type Int},
:title {:type String},
:color {:type String}},
:clauses
{:and {:type (list :RoleClauses)},
:or {:type (list :RoleClauses)},
:id {:type :IntWhere},
:group_id {:type :IntWhere},
:title {:type :StrWhere},
:color {:type :StrWhere}},
:sort
{:id {:type :SortOperator},
:group_id {:type :SortOperator},
:title {:type :SortOperator},
:color {:type :SortOperator}},
:fields
{:id {:type Int},
:group_id {:type Int},
:title {:type String},
:color {:type String}},
:aggregate
{:count {:type Int},
:sum {:type :RoleFields},
:avg {:type :RoleFields},
:max {:type :RoleFields},
:min {:type :RoleFields}},
:pks {:id {:type (non-null Int)}},
:pk-input {:id {:type (non-null Int)}},
:update
{:group_id {:type Int},
:title {:type String},
:color {:type String}}},
:fks
{:group_id
{:field-keys
{:to :Group,
:has-many :roles,
:has-many-aggr :roles_aggregate,
:has-one :group}}},
:lcn-mut-keys
{:create :createRole, :update :updateRole, :delete :deleteRole},
:lcn-obj-keys
{:rsc :Role,
:clauses :RoleClauses,
:where :RoleWhere,
:sort :RoleSort,
:fields :RoleFields,
:aggregate :RoleAggregate,
:pks :RolePks,
:pk-input :RolePkColumns},
:lcn-qry-keys {:queries :roles, :aggregate :roles_aggregate},
:lcn-descs
{:rsc "Roles",
:query "Query Roles.",
:clauses
"Format for where clauses is {column: {operator: value}}. Multiple parameters are applied with `AND` operators. `AND`/`OR` conditions can be created as a list of clauses. It is possible to nest them to create sub groups of conditions.",
:sort "Sort format is {column: \"asc\" or \"desc\"}.",
:fields "Rolesfields for aggregation.",
:aggregate "Aggrecate Roles.",
:pks "Primary key fields.",
:pk-input "Primary key fields."},
:groups
{:lcn-fields
{:rsc
{:access {:type Int},
:created_at {:type String},
:edited_at {:type String},
:id {:type Int},
:title {:type String},
:user_id {:type String},
:description {:type String}},
:clauses
{:description {:type :StrWhere},
:or {:type (list :GroupClauses)},
:title {:type :StrWhere},
:id {:type :IntWhere},
:and {:type (list :GroupClauses)},
:user_id {:type :StrWhere},
:access {:type :IntWhere},
:edited_at {:type :StrWhere},
:created_at {:type :StrWhere}},
:sort
{:access {:type :SortOperator},
:created_at {:type :SortOperator},
:edited_at {:type :SortOperator},
:id {:type :SortOperator},
:title {:type :SortOperator},
:user_id {:type :SortOperator},
:description {:type :SortOperator}},
:fields
{:access {:type Int},
:created_at {:type String},
:edited_at {:type String},
:id {:type Int},
:title {:type String},
:user_id {:type String},
:description {:type String}},
:aggregate
{:count {:type Int},
:sum {:type :GroupFields},
:avg {:type :GroupFields},
:max {:type :GroupFields},
:min {:type :GroupFields}},
:pks {:id {:type (non-null Int)}},
:pk-input {:id {:type (non-null Int)}},
:update
{:access {:type Int},
:created_at {:type String},
:edited_at {:type String},
:title {:type String},
:user_id {:type String},
:description {:type String}}},
:fks
{:access
{:field-keys
{:to :Access,
:has-many :groups,
:has-many-aggr :groups_aggregate,
:has-one :access_access}},
:user_id
{:field-keys
{:to :User,
:has-many :groups,
:has-many-aggr :groups_aggregate,
:has-one :user}}},
:lcn-mut-keys
{:create :createGroup,
:update :updateGroup,
:delete :deleteGroup},
:lcn-obj-keys
{:rsc :Group,
:clauses :GroupClauses,
:where :GroupWhere,
:sort :GroupSort,
:fields :GroupFields,
:aggregate :GroupAggregate,
:pks :GroupPks,
:pk-input :GroupPkColumns},
:lcn-qry-keys {:queries :groups, :aggregate :groups_aggregate},
:lcn-descs
{:rsc "Groups",
:query "Query Groups.",
:clauses
"Format for where clauses is {column: {operator: value}}. Multiple parameters are applied with `AND` operators. `AND`/`OR` conditions can be created as a list of clauses. It is possible to nest them to create sub groups of conditions.",
:sort "Sort format is {column: \"asc\" or \"desc\"}.",
:fields "Groupsfields for aggregation.",
:aggregate "Aggrecate Groups.",
:pks "Primary key fields.",
:pk-input "Primary key fields."},
:signals
{:query {:pre (), :post ()},
:create {:pre (), :post ()},
:delete {:pre (), :post ()},
:update {:pre (), :post ()}},
:pk-keys (:id),
:col-keys
#{:description
:title
:id
:user_id
:access
:edited_at
:created_at}},
:signals
{:query {:pre (), :post ()},
:create {:pre (), :post ()},
:delete {:pre (), :post ()},
:update {:pre (), :post ()}},
:pk-keys (:id),
:col-keys #{:color :title :group_id :id}},
:lcn-obj-keys
{:rsc :Access,
:clauses :AccessClauses,
:where :AccessWhere,
:sort :AccessSort,
:fields :AccessFields,
:aggregate :AccessAggregate,
:pks :AccessPks,
:pk-input :AccessPkColumns},
:lcn-qry-keys
{:queries :accesses, :aggregate :accesses_aggregate},
:lcn-descs
{:rsc "Accesses",
:query "Query Accesses.",
:clauses
"Format for where clauses is {column: {operator: value}}. Multiple parameters are applied with `AND` operators. `AND`/`OR` conditions can be created as a list of clauses. It is possible to nest them to create sub groups of conditions.",
:sort "Sort format is {column: \"asc\" or \"desc\"}.",
:fields "Accessesfields for aggregation.",
:aggregate "Aggrecate Accesses.",
:pks "Primary key fields.",
:pk-input "Primary key fields."},
:groups
{:lcn-fields
{:rsc
{:access {:type Int},
:created_at {:type String},
:edited_at {:type String},
:id {:type Int},
:title {:type String},
:user_id {:type String},
:description {:type String}},
:clauses
{:description {:type :StrWhere},
:or {:type (list :GroupClauses)},
:title {:type :StrWhere},
:id {:type :IntWhere},
:and {:type (list :GroupClauses)},
:user_id {:type :StrWhere},
:access {:type :IntWhere},
:edited_at {:type :StrWhere},
:created_at {:type :StrWhere}},
:sort
{:access {:type :SortOperator},
:created_at {:type :SortOperator},
:edited_at {:type :SortOperator},
:id {:type :SortOperator},
:title {:type :SortOperator},
:user_id {:type :SortOperator},
:description {:type :SortOperator}},
:fields
{:access {:type Int},
:created_at {:type String},
:edited_at {:type String},
:id {:type Int},
:title {:type String},
:user_id {:type String},
:description {:type String}},
:aggregate
{:count {:type Int},
:sum {:type :GroupFields},
:avg {:type :GroupFields},
:max {:type :GroupFields},
:min {:type :GroupFields}},
:pks {:id {:type (non-null Int)}},
:pk-input {:id {:type (non-null Int)}},
:update
{:access {:type Int},
:created_at {:type String},
:edited_at {:type String},
:title {:type String},
:user_id {:type String},
:description {:type String}}},
:fks
{:access
{:field-keys
{:to :Access,
:has-many :groups,
:has-many-aggr :groups_aggregate,
:has-one :access_access}},
:user_id
{:field-keys
{:to :User,
:has-many :groups,
:has-many-aggr :groups_aggregate,
:has-one :user}}},
:lcn-mut-keys
{:create :createGroup,
:update :updateGroup,
:delete :deleteGroup},
:lcn-obj-keys
{:rsc :Group,
:clauses :GroupClauses,
:where :GroupWhere,
:sort :GroupSort,
:fields :GroupFields,
:aggregate :GroupAggregate,
:pks :GroupPks,
:pk-input :GroupPkColumns},
:lcn-qry-keys {:queries :groups, :aggregate :groups_aggregate},
:lcn-descs
{:rsc "Groups",
:query "Query Groups.",
:clauses
"Format for where clauses is {column: {operator: value}}. Multiple parameters are applied with `AND` operators. `AND`/`OR` conditions can be created as a list of clauses. It is possible to nest them to create sub groups of conditions.",
:sort "Sort format is {column: \"asc\" or \"desc\"}.",
:fields "Groupsfields for aggregation.",
:aggregate "Aggrecate Groups.",
:pks "Primary key fields.",
:pk-input "Primary key fields."},
:signals
{:query {:pre (), :post ()},
:create {:pre (), :post ()},
:delete {:pre (), :post ()},
:update {:pre (), :post ()}},
:pk-keys (:id),
:col-keys
#{:description
:title
:id
:user_id
:access
:edited_at
:created_at}},
:signals
{:query {:pre (), :post ()},
:create {:pre (), :post ()},
:delete {:pre (), :post ()},
:update {:pre (), :post ()}},
:pk-keys (:id),
:col-keys
#{:can_read
:inherit
:can_edit
:group_id
:id
:user_id
:role_id
:next_access
:owner}},
:groups
{:lcn-fields
{:rsc
{:access {:type Int},
:created_at {:type String},
:edited_at {:type String},
:id {:type Int},
:title {:type String},
:user_id {:type String},
:description {:type String}},
:clauses
{:description {:type :StrWhere},
:or {:type (list :GroupClauses)},
:title {:type :StrWhere},
:id {:type :IntWhere},
:and {:type (list :GroupClauses)},
:user_id {:type :StrWhere},
:access {:type :IntWhere},
:edited_at {:type :StrWhere},
:created_at {:type :StrWhere}},
:sort
{:access {:type :SortOperator},
:created_at {:type :SortOperator},
:edited_at {:type :SortOperator},
:id {:type :SortOperator},
:title {:type :SortOperator},
:user_id {:type :SortOperator},
:description {:type :SortOperator}},
:fields
{:access {:type Int},
:created_at {:type String},
:edited_at {:type String},
:id {:type Int},
:title {:type String},
:user_id {:type String},
:description {:type String}},
:aggregate
{:count {:type Int},
:sum {:type :GroupFields},
:avg {:type :GroupFields},
:max {:type :GroupFields},
:min {:type :GroupFields}},
:pks {:id {:type (non-null Int)}},
:pk-input {:id {:type (non-null Int)}},
:update
{:access {:type Int},
:created_at {:type String},
:edited_at {:type String},
:title {:type String},
:user_id {:type String},
:description {:type String}}},
:fks
{:access
{:field-keys
{:to :Access,
:has-many :groups,
:has-many-aggr :groups_aggregate,
:has-one :access_access}},
:user_id
{:field-keys
{:to :User,
:has-many :groups,
:has-many-aggr :groups_aggregate,
:has-one :user}}},
:lcn-mut-keys
{:create :createGroup,
:update :updateGroup,
:delete :deleteGroup},
:lcn-obj-keys
{:rsc :Group,
:clauses :GroupClauses,
:where :GroupWhere,
:sort :GroupSort,
:fields :GroupFields,
:aggregate :GroupAggregate,
:pks :GroupPks,
:pk-input :GroupPkColumns},
:lcn-qry-keys {:queries :groups, :aggregate :groups_aggregate},
:lcn-descs
{:rsc "Groups",
:query "Query Groups.",
:clauses
"Format for where clauses is {column: {operator: value}}. Multiple parameters are applied with `AND` operators. `AND`/`OR` conditions can be created as a list of clauses. It is possible to nest them to create sub groups of conditions.",
:sort "Sort format is {column: \"asc\" or \"desc\"}.",
:fields "Groupsfields for aggregation.",
:aggregate "Aggrecate Groups.",
:pks "Primary key fields.",
:pk-input "Primary key fields."},
:signals
{:query {:pre (), :post ()},
:create {:pre (), :post ()},
:delete {:pre (), :post ()},
:update {:pre (), :post ()}},
:pk-keys (:id),
:col-keys
#{:description
:title
:id
:user_id
:access
:edited_at
:created_at}},
:signals
{:query {:pre (), :post ()},
:create {:pre (), :post ()},
:delete {:pre (), :post ()},
:update {:pre (), :post ()}},
:pk-keys (:user_id :group_id :role_id),
:col-keys #{:group_id :user_id :role_id}},
:items
{:lcn-fields
{:rsc
{:slug {:type String},
:domain_pk {:type String},
:title {:type String},
:domain_pk_namespace {:type String},
:id {:type Int},
:url {:type String},
:access {:type Int},
:edited_at {:type String},
:body {:type String},
:created_at {:type String}},
:clauses
{:slug {:type :StrWhere},
:domain_pk {:type :StrWhere},
:or {:type (list :ItemClauses)},
:title {:type :StrWhere},
:domain_pk_namespace {:type :StrWhere},
:id {:type :IntWhere},
:url {:type :StrWhere},
:and {:type (list :ItemClauses)},
:access {:type :IntWhere},
:edited_at {:type :StrWhere},
:body {:type :StrWhere},
:created_at {:type :StrWhere}},
:sort
{:slug {:type :SortOperator},
:domain_pk {:type :SortOperator},
:title {:type :SortOperator},
:domain_pk_namespace {:type :SortOperator},
:id {:type :SortOperator},
:url {:type :SortOperator},
:access {:type :SortOperator},
:edited_at {:type :SortOperator},
:body {:type :SortOperator},
:created_at {:type :SortOperator}},
:fields
{:slug {:type String},
:domain_pk {:type String},
:title {:type String},
:domain_pk_namespace {:type String},
:id {:type Int},
:url {:type String},
:access {:type Int},
:edited_at {:type String},
:body {:type String},
:created_at {:type String}},
:aggregate
{:count {:type Int},
:sum {:type :ItemFields},
:avg {:type :ItemFields},
:max {:type :ItemFields},
:min {:type :ItemFields}},
:pks {:id {:type (non-null Int)}},
:pk-input {:id {:type (non-null Int)}},
:update
{:slug {:type String},
:domain_pk {:type String},
:title {:type String},
:domain_pk_namespace {:type String},
:url {:type String},
:access {:type Int},
:edited_at {:type String},
:body {:type String},
:created_at {:type String}}},
:fks
{:access
{:field-keys
{:to :Access,
:has-many :items,
:has-many-aggr :items_aggregate,
:has-one :access_access}}},
:lcn-mut-keys
{:create :createItem, :update :updateItem, :delete :deleteItem},
:roles
{:lcn-fields
{:rsc
{:id {:type Int},
:group_id {:type Int},
:title {:type String},
:color {:type String}},
:clauses
{:and {:type (list :RoleClauses)},
:or {:type (list :RoleClauses)},
:id {:type :IntWhere},
:group_id {:type :IntWhere},
:title {:type :StrWhere},
:color {:type :StrWhere}},
:sort
{:id {:type :SortOperator},
:group_id {:type :SortOperator},
:title {:type :SortOperator},
:color {:type :SortOperator}},
:fields
{:id {:type Int},
:group_id {:type Int},
:title {:type String},
:color {:type String}},
:aggregate
{:count {:type Int},
:sum {:type :RoleFields},
:avg {:type :RoleFields},
:max {:type :RoleFields},
:min {:type :RoleFields}},
:pks {:id {:type (non-null Int)}},
:pk-input {:id {:type (non-null Int)}},
:update
{:group_id {:type Int},
:title {:type String},
:color {:type String}}},
:fks
{:group_id
{:field-keys
{:to :Group,
:has-many :roles,
:has-many-aggr :roles_aggregate,
:has-one :group}}},
:lcn-mut-keys
{:create :createRole, :update :updateRole, :delete :deleteRole},
:lcn-obj-keys
{:rsc :Role,
:clauses :RoleClauses,
:where :RoleWhere,
:sort :RoleSort,
:fields :RoleFields,
:aggregate :RoleAggregate,
:pks :RolePks,
:pk-input :RolePkColumns},
:lcn-qry-keys {:queries :roles, :aggregate :roles_aggregate},
:lcn-descs
{:rsc "Roles",
:query "Query Roles.",
:clauses
"Format for where clauses is {column: {operator: value}}. Multiple parameters are applied with `AND` operators. `AND`/`OR` conditions can be created as a list of clauses. It is possible to nest them to create sub groups of conditions.",
:sort "Sort format is {column: \"asc\" or \"desc\"}.",
:fields "Rolesfields for aggregation.",
:aggregate "Aggrecate Roles.",
:pks "Primary key fields.",
:pk-input "Primary key fields."},
:groups
{:lcn-fields
{:rsc
{:access {:type Int},
:created_at {:type String},
:edited_at {:type String},
:id {:type Int},
:title {:type String},
:user_id {:type String},
:description {:type String}},
:clauses
{:description {:type :StrWhere},
:or {:type (list :GroupClauses)},
:title {:type :StrWhere},
:id {:type :IntWhere},
:and {:type (list :GroupClauses)},
:user_id {:type :StrWhere},
:access {:type :IntWhere},
:edited_at {:type :StrWhere},
:created_at {:type :StrWhere}},
:sort
{:access {:type :SortOperator},
:created_at {:type :SortOperator},
:edited_at {:type :SortOperator},
:id {:type :SortOperator},
:title {:type :SortOperator},
:user_id {:type :SortOperator},
:description {:type :SortOperator}},
:fields
{:access {:type Int},
:created_at {:type String},
:edited_at {:type String},
:id {:type Int},
:title {:type String},
:user_id {:type String},
:description {:type String}},
:aggregate
{:count {:type Int},
:sum {:type :GroupFields},
:avg {:type :GroupFields},
:max {:type :GroupFields},
:min {:type :GroupFields}},
:pks {:id {:type (non-null Int)}},
:pk-input {:id {:type (non-null Int)}},
:update
{:access {:type Int},
:created_at {:type String},
:edited_at {:type String},
:title {:type String},
:user_id {:type String},
:description {:type String}}},
:fks
{:access
{:field-keys
{:to :Access,
:has-many :groups,
:has-many-aggr :groups_aggregate,
:has-one :access_access}},
:user_id
{:field-keys
{:to :User,
:has-many :groups,
:has-many-aggr :groups_aggregate,
:has-one :user}}},
:lcn-mut-keys
{:create :createGroup,
:update :updateGroup,
:delete :deleteGroup},
:lcn-obj-keys
{:rsc :Group,
:clauses :GroupClauses,
:where :GroupWhere,
:sort :GroupSort,
:fields :GroupFields,
:aggregate :GroupAggregate,
:pks :GroupPks,
:pk-input :GroupPkColumns},
:lcn-qry-keys {:queries :groups, :aggregate :groups_aggregate},
:lcn-descs
{:rsc "Groups",
:query "Query Groups.",
:clauses
"Format for where clauses is {column: {operator: value}}. Multiple parameters are applied with `AND` operators. `AND`/`OR` conditions can be created as a list of clauses. It is possible to nest them to create sub groups of conditions.",
:sort "Sort format is {column: \"asc\" or \"desc\"}.",
:fields "Groupsfields for aggregation.",
:aggregate "Aggrecate Groups.",
:pks "Primary key fields.",
:pk-input "Primary key fields."},
:signals
{:query {:pre (), :post ()},
:create {:pre (), :post ()},
:delete {:pre (), :post ()},
:update {:pre (), :post ()}},
:pk-keys (:id),
:col-keys
#{:description
:title
:id
:user_id
:access
:edited_at
:created_at}},
:signals
{:query {:pre (), :post ()},
:create {:pre (), :post ()},
:delete {:pre (), :post ()},
:update {:pre (), :post ()}},
:pk-keys (:id),
:col-keys #{:color :title :group_id :id}},
:lcn-obj-keys
{:rsc :Item,
:clauses :ItemClauses,
:where :ItemWhere,
:sort :ItemSort,
:fields :ItemFields,
:aggregate :ItemAggregate,
:pks :ItemPks,
:pk-input :ItemPkColumns},
:lcn-qry-keys {:queries :items, :aggregate :items_aggregate},
:lcn-descs
{:rsc "Items",
:query "Query Items.",
:clauses
"Format for where clauses is {column: {operator: value}}. Multiple parameters are applied with `AND` operators. `AND`/`OR` conditions can be created as a list of clauses. It is possible to nest them to create sub groups of conditions.",
:sort "Sort format is {column: \"asc\" or \"desc\"}.",
:fields "Itemsfields for aggregation.",
:aggregate "Aggrecate Items.",
:pks "Primary key fields.",
:pk-input "Primary key fields."},
:access
{:lcn-fields
{:rsc
{:can_read {:type Boolean},
:inherit {:type Boolean},
:can_edit {:type Boolean},
:group_id {:type Int},
:id {:type Int},
:user_id {:type String},
:role_id {:type Int},
:next_access {:type Int},
:owner {:type Boolean}},
:clauses
{:can_read {:type :BoolWhere},
:inherit {:type :BoolWhere},
:can_edit {:type :BoolWhere},
:or {:type (list :AccessClauses)},
:group_id {:type :IntWhere},
:id {:type :IntWhere},
:and {:type (list :AccessClauses)},
:user_id {:type :StrWhere},
:role_id {:type :IntWhere},
:next_access {:type :IntWhere},
:owner {:type :BoolWhere}},
:sort
{:can_read {:type :SortOperator},
:inherit {:type :SortOperator},
:can_edit {:type :SortOperator},
:group_id {:type :SortOperator},
:id {:type :SortOperator},
:user_id {:type :SortOperator},
:role_id {:type :SortOperator},
:next_access {:type :SortOperator},
:owner {:type :SortOperator}},
:fields
{:can_read {:type Boolean},
:inherit {:type Boolean},
:can_edit {:type Boolean},
:group_id {:type Int},
:id {:type Int},
:user_id {:type String},
:role_id {:type Int},
:next_access {:type Int},
:owner {:type Boolean}},
:aggregate
{:count {:type Int},
:sum {:type :AccessFields},
:avg {:type :AccessFields},
:max {:type :AccessFields},
:min {:type :AccessFields}},
:pks {:id {:type (non-null Int)}},
:pk-input {:id {:type (non-null Int)}},
:update
{:can_read {:type Boolean},
:inherit {:type Boolean},
:can_edit {:type Boolean},
:group_id {:type Int},
:user_id {:type String},
:role_id {:type Int},
:next_access {:type Int},
:owner {:type Boolean}}},
:fks
{:next_access
{:field-keys
{:to :Access,
:has-many :accesses,
:has-many-aggr :accesses_aggregate,
:has-one :next_access_access}},
:role_id
{:field-keys
{:to :Role,
:has-many :accesses,
:has-many-aggr :accesses_aggregate,
:has-one :role}},
:user_id
{:field-keys
{:to :User,
:has-many :accesses,
:has-many-aggr :accesses_aggregate,
:has-one :user}},
:group_id
{:field-keys
{:to :Group,
:has-many :accesses,
:has-many-aggr :accesses_aggregate,
:has-one :group}}},
:lcn-mut-keys
{:create :createAccess,
:update :updateAccess,
:delete :deleteAccess},
:roles
{:lcn-fields
{:rsc
{:id {:type Int},
:group_id {:type Int},
:title {:type String},
:color {:type String}},
:clauses
{:and {:type (list :RoleClauses)},
:or {:type (list :RoleClauses)},
:id {:type :IntWhere},
:group_id {:type :IntWhere},
:title {:type :StrWhere},
:color {:type :StrWhere}},
:sort
{:id {:type :SortOperator},
:group_id {:type :SortOperator},
:title {:type :SortOperator},
:color {:type :SortOperator}},
:fields
{:id {:type Int},
:group_id {:type Int},
:title {:type String},
:color {:type String}},
:aggregate
{:count {:type Int},
:sum {:type :RoleFields},
:avg {:type :RoleFields},
:max {:type :RoleFields},
:min {:type :RoleFields}},
:pks {:id {:type (non-null Int)}},
:pk-input {:id {:type (non-null Int)}},
:update
{:group_id {:type Int},
:title {:type String},
:color {:type String}}},
:fks
{:group_id
{:field-keys
{:to :Group,
:has-many :roles,
:has-many-aggr :roles_aggregate,
:has-one :group}}},
:lcn-mut-keys
{:create :createRole, :update :updateRole, :delete :deleteRole},
:lcn-obj-keys
{:rsc :Role,
:clauses :RoleClauses,
:where :RoleWhere,
:sort :RoleSort,
:fields :RoleFields,
:aggregate :RoleAggregate,
:pks :RolePks,
:pk-input :RolePkColumns},
:lcn-qry-keys {:queries :roles, :aggregate :roles_aggregate},
:lcn-descs
{:rsc "Roles",
:query "Query Roles.",
:clauses
"Format for where clauses is {column: {operator: value}}. Multiple parameters are applied with `AND` operators. `AND`/`OR` conditions can be created as a list of clauses. It is possible to nest them to create sub groups of conditions.",
:sort "Sort format is {column: \"asc\" or \"desc\"}.",
:fields "Rolesfields for aggregation.",
:aggregate "Aggrecate Roles.",
:pks "Primary key fields.",
:pk-input "Primary key fields."},
:groups
{:lcn-fields
{:rsc
{:access {:type Int},
:created_at {:type String},
:edited_at {:type String},
:id {:type Int},
:title {:type String},
:user_id {:type String},
:description {:type String}},
:clauses
{:description {:type :StrWhere},
:or {:type (list :GroupClauses)},
:title {:type :StrWhere},
:id {:type :IntWhere},
:and {:type (list :GroupClauses)},
:user_id {:type :StrWhere},
:access {:type :IntWhere},
:edited_at {:type :StrWhere},
:created_at {:type :StrWhere}},
:sort
{:access {:type :SortOperator},
:created_at {:type :SortOperator},
:edited_at {:type :SortOperator},
:id {:type :SortOperator},
:title {:type :SortOperator},
:user_id {:type :SortOperator},
:description {:type :SortOperator}},
:fields
{:access {:type Int},
:created_at {:type String},
:edited_at {:type String},
:id {:type Int},
:title {:type String},
:user_id {:type String},
:description {:type String}},
:aggregate
{:count {:type Int},
:sum {:type :GroupFields},
:avg {:type :GroupFields},
:max {:type :GroupFields},
:min {:type :GroupFields}},
:pks {:id {:type (non-null Int)}},
:pk-input {:id {:type (non-null Int)}},
:update
{:access {:type Int},
:created_at {:type String},
:edited_at {:type String},
:title {:type String},
:user_id {:type String},
:description {:type String}}},
:fks
{:access
{:field-keys
{:to :Access,
:has-many :groups,
:has-many-aggr :groups_aggregate,
:has-one :access_access}},
:user_id
{:field-keys
{:to :User,
:has-many :groups,
:has-many-aggr :groups_aggregate,
:has-one :user}}},
:lcn-mut-keys
{:create :createGroup,
:update :updateGroup,
:delete :deleteGroup},
:lcn-obj-keys
{:rsc :Group,
:clauses :GroupClauses,
:where :GroupWhere,
:sort :GroupSort,
:fields :GroupFields,
:aggregate :GroupAggregate,
:pks :GroupPks,
:pk-input :GroupPkColumns},
:lcn-qry-keys {:queries :groups, :aggregate :groups_aggregate},
:lcn-descs
{:rsc "Groups",
:query "Query Groups.",
:clauses
"Format for where clauses is {column: {operator: value}}. Multiple parameters are applied with `AND` operators. `AND`/`OR` conditions can be created as a list of clauses. It is possible to nest them to create sub groups of conditions.",
:sort "Sort format is {column: \"asc\" or \"desc\"}.",
:fields "Groupsfields for aggregation.",
:aggregate "Aggrecate Groups.",
:pks "Primary key fields.",
:pk-input "Primary key fields."},
:signals
{:query {:pre (), :post ()},
:create {:pre (), :post ()},
:delete {:pre (), :post ()},
:update {:pre (), :post ()}},
:pk-keys (:id),
:col-keys
#{:description
:title
:id
:user_id
:access
:edited_at
:created_at}},
:signals
{:query {:pre (), :post ()},
:create {:pre (), :post ()},
:delete {:pre (), :post ()},
:update {:pre (), :post ()}},
:pk-keys (:id),
:col-keys #{:color :title :group_id :id}},
:lcn-obj-keys
{:rsc :Access,
:clauses :AccessClauses,
:where :AccessWhere,
:sort :AccessSort,
:fields :AccessFields,
:aggregate :AccessAggregate,
:pks :AccessPks,
:pk-input :AccessPkColumns},
:lcn-qry-keys
{:queries :accesses, :aggregate :accesses_aggregate},
:lcn-descs
{:rsc "Accesses",
:query "Query Accesses.",
:clauses
"Format for where clauses is {column: {operator: value}}. Multiple parameters are applied with `AND` operators. `AND`/`OR` conditions can be created as a list of clauses. It is possible to nest them to create sub groups of conditions.",
:sort "Sort format is {column: \"asc\" or \"desc\"}.",
:fields "Accessesfields for aggregation.",
:aggregate "Aggrecate Accesses.",
:pks "Primary key fields.",
:pk-input "Primary key fields."},
:groups
{:lcn-fields
{:rsc
{:access {:type Int},
:created_at {:type String},
:edited_at {:type String},
:id {:type Int},
:title {:type String},
:user_id {:type String},
:description {:type String}},
:clauses
{:description {:type :StrWhere},
:or {:type (list :GroupClauses)},
:title {:type :StrWhere},
:id {:type :IntWhere},
:and {:type (list :GroupClauses)},
:user_id {:type :StrWhere},
:access {:type :IntWhere},
:edited_at {:type :StrWhere},
:created_at {:type :StrWhere}},
:sort
{:access {:type :SortOperator},
:created_at {:type :SortOperator},
:edited_at {:type :SortOperator},
:id {:type :SortOperator},
:title {:type :SortOperator},
:user_id {:type :SortOperator},
:description {:type :SortOperator}},
:fields
{:access {:type Int},
:created_at {:type String},
:edited_at {:type String},
:id {:type Int},
:title {:type String},
:user_id {:type String},
:description {:type String}},
:aggregate
{:count {:type Int},
:sum {:type :GroupFields},
:avg {:type :GroupFields},
:max {:type :GroupFields},
:min {:type :GroupFields}},
:pks {:id {:type (non-null Int)}},
:pk-input {:id {:type (non-null Int)}},
:update
{:access {:type Int},
:created_at {:type String},
:edited_at {:type String},
:title {:type String},
:user_id {:type String},
:description {:type String}}},
:fks
{:access
{:field-keys
{:to :Access,
:has-many :groups,
:has-many-aggr :groups_aggregate,
:has-one :access_access}},
:user_id
{:field-keys
{:to :User,
:has-many :groups,
:has-many-aggr :groups_aggregate,
:has-one :user}}},
:lcn-mut-keys
{:create :createGroup,
:update :updateGroup,
:delete :deleteGroup},
:lcn-obj-keys
{:rsc :Group,
:clauses :GroupClauses,
:where :GroupWhere,
:sort :GroupSort,
:fields :GroupFields,
:aggregate :GroupAggregate,
:pks :GroupPks,
:pk-input :GroupPkColumns},
:lcn-qry-keys {:queries :groups, :aggregate :groups_aggregate},
:lcn-descs
{:rsc "Groups",
:query "Query Groups.",
:clauses
"Format for where clauses is {column: {operator: value}}. Multiple parameters are applied with `AND` operators. `AND`/`OR` conditions can be created as a list of clauses. It is possible to nest them to create sub groups of conditions.",
:sort "Sort format is {column: \"asc\" or \"desc\"}.",
:fields "Groupsfields for aggregation.",
:aggregate "Aggrecate Groups.",
:pks "Primary key fields.",
:pk-input "Primary key fields."},
:signals
{:query {:pre (), :post ()},
:create {:pre (), :post ()},
:delete {:pre (), :post ()},
:update {:pre (), :post ()}},
:pk-keys (:id),
:col-keys
#{:description
:title
:id
:user_id
:access
:edited_at
:created_at}},
:signals
{:query {:pre (), :post ()},
:create {:pre (), :post ()},
:delete {:pre (), :post ()},
:update {:pre (), :post ()}},
:pk-keys (:id),
:col-keys
#{:can_read
:inherit
:can_edit
:group_id
:id
:user_id
:role_id
:next_access
:owner}},
:groups
{:lcn-fields
{:rsc
{:access {:type Int},
:created_at {:type String},
:edited_at {:type String},
:id {:type Int},
:title {:type String},
:user_id {:type String},
:description {:type String}},
:clauses
{:description {:type :StrWhere},
:or {:type (list :GroupClauses)},
:title {:type :StrWhere},
:id {:type :IntWhere},
:and {:type (list :GroupClauses)},
:user_id {:type :StrWhere},
:access {:type :IntWhere},
:edited_at {:type :StrWhere},
:created_at {:type :StrWhere}},
:sort
{:access {:type :SortOperator},
:created_at {:type :SortOperator},
:edited_at {:type :SortOperator},
:id {:type :SortOperator},
:title {:type :SortOperator},
:user_id {:type :SortOperator},
:description {:type :SortOperator}},
:fields
{:access {:type Int},
:created_at {:type String},
:edited_at {:type String},
:id {:type Int},
:title {:type String},
:user_id {:type String},
:description {:type String}},
:aggregate
{:count {:type Int},
:sum {:type :GroupFields},
:avg {:type :GroupFields},
:max {:type :GroupFields},
:min {:type :GroupFields}},
:pks {:id {:type (non-null Int)}},
:pk-input {:id {:type (non-null Int)}},
:update
{:access {:type Int},
:created_at {:type String},
:edited_at {:type String},
:title {:type String},
:user_id {:type String},
:description {:type String}}},
:fks
{:access
{:field-keys
{:to :Access,
:has-many :groups,
:has-many-aggr :groups_aggregate,
:has-one :access_access}},
:user_id
{:field-keys
{:to :User,
:has-many :groups,
:has-many-aggr :groups_aggregate,
:has-one :user}}},
:lcn-mut-keys
{:create :createGroup,
:update :updateGroup,
:delete :deleteGroup},
:lcn-obj-keys
{:rsc :Group,
:clauses :GroupClauses,
:where :GroupWhere,
:sort :GroupSort,
:fields :GroupFields,
:aggregate :GroupAggregate,
:pks :GroupPks,
:pk-input :GroupPkColumns},
:lcn-qry-keys {:queries :groups, :aggregate :groups_aggregate},
:lcn-descs
{:rsc "Groups",
:query "Query Groups.",
:clauses
"Format for where clauses is {column: {operator: value}}. Multiple parameters are applied with `AND` operators. `AND`/`OR` conditions can be created as a list of clauses. It is possible to nest them to create sub groups of conditions.",
:sort "Sort format is {column: \"asc\" or \"desc\"}.",
:fields "Groupsfields for aggregation.",
:aggregate "Aggrecate Groups.",
:pks "Primary key fields.",
:pk-input "Primary key fields."},
:signals
{:query {:pre (), :post ()},
:create {:pre (), :post ()},
:delete {:pre (), :post ()},
:update {:pre (), :post ()}},
:pk-keys (:id),
:col-keys
#{:description
:title
:id
:user_id
:access
:edited_at
:created_at}},
:signals
{:query {:pre (), :post ()},
:create {:pre (), :post ()},
:delete {:pre (), :post ()},
:update {:pre (), :post ()}},
:pk-keys (:id),
:col-keys
#{:slug
:domain_pk
:title
:domain_pk_namespace
:id
:url
:access
:edited_at
:body
:created_at},
:users_in_groups
{:lcn-fields
{:rsc
{:group_id {:type Int},
:role_id {:type Int},
:user_id {:type String}},
:clauses
{:and {:type (list :UsersInGroupClauses)},
:or {:type (list :UsersInGroupClauses)},
:group_id {:type :IntWhere},
:role_id {:type :IntWhere},
:user_id {:type :StrWhere}},
:sort
{:group_id {:type :SortOperator},
:role_id {:type :SortOperator},
:user_id {:type :SortOperator}},
:fields
{:group_id {:type Int},
:role_id {:type Int},
:user_id {:type String}},
:aggregate
{:count {:type Int},
:sum {:type :UsersInGroupFields},
:avg {:type :UsersInGroupFields},
:max {:type :UsersInGroupFields},
:min {:type :UsersInGroupFields}},
:pks
{:user_id {:type (non-null String)},
:group_id {:type (non-null Int)},
:role_id {:type (non-null Int)}},
:pk-input
{:user_id {:type (non-null String)},
:group_id {:type (non-null Int)},
:role_id {:type (non-null Int)}},
:update {}},
:fks
{:user_id
{:field-keys
{:to :User,
:has-many :users_in_groups,
:has-many-aggr :users_in_groups_aggregate,
:has-one :user}},
:group_id
{:field-keys
{:to :Group,
:has-many :users_in_groups,
:has-many-aggr :users_in_groups_aggregate,
:has-one :group}},
:role_id
{:field-keys
{:to :Role,
:has-many :users_in_groups,
:has-many-aggr :users_in_groups_aggregate,
:has-one :role}}},
:lcn-mut-keys
{:create :createUsersInGroup,
:update :updateUsersInGroup,
:delete :deleteUsersInGroup},
:roles
{:lcn-fields
{:rsc
{:id {:type Int},
:group_id {:type Int},
:title {:type String},
:color {:type String}},
:clauses
{:and {:type (list :RoleClauses)},
:or {:type (list :RoleClauses)},
:id {:type :IntWhere},
:group_id {:type :IntWhere},
:title {:type :StrWhere},
:color {:type :StrWhere}},
:sort
{:id {:type :SortOperator},
:group_id {:type :SortOperator},
:title {:type :SortOperator},
:color {:type :SortOperator}},
:fields
{:id {:type Int},
:group_id {:type Int},
:title {:type String},
:color {:type String}},
:aggregate
{:count {:type Int},
:sum {:type :RoleFields},
:avg {:type :RoleFields},
:max {:type :RoleFields},
:min {:type :RoleFields}},
:pks {:id {:type (non-null Int)}},
:pk-input {:id {:type (non-null Int)}},
:update
{:group_id {:type Int},
:title {:type String},
:color {:type String}}},
:fks
{:group_id
{:field-keys
{:to :Group,
:has-many :roles,
:has-many-aggr :roles_aggregate,
:has-one :group}}},
:lcn-mut-keys
{:create :createRole, :update :updateRole, :delete :deleteRole},
:lcn-obj-keys
{:rsc :Role,
:clauses :RoleClauses,
:where :RoleWhere,
:sort :RoleSort,
:fields :RoleFields,
:aggregate :RoleAggregate,
:pks :RolePks,
:pk-input :RolePkColumns},
:lcn-qry-keys {:queries :roles, :aggregate :roles_aggregate},
:lcn-descs
{:rsc "Roles",
:query "Query Roles.",
:clauses
"Format for where clauses is {column: {operator: value}}. Multiple parameters are applied with `AND` operators. `AND`/`OR` conditions can be created as a list of clauses. It is possible to nest them to create sub groups of conditions.",
:sort "Sort format is {column: \"asc\" or \"desc\"}.",
:fields "Rolesfields for aggregation.",
:aggregate "Aggrecate Roles.",
:pks "Primary key fields.",
:pk-input "Primary key fields."},
:groups
{:lcn-fields
{:rsc
{:access {:type Int},
:created_at {:type String},
:edited_at {:type String},
:id {:type Int},
:title {:type String},
:user_id {:type String},
:description {:type String}},
:clauses
{:description {:type :StrWhere},
:or {:type (list :GroupClauses)},
:title {:type :StrWhere},
:id {:type :IntWhere},
:and {:type (list :GroupClauses)},
:user_id {:type :StrWhere},
:access {:type :IntWhere},
:edited_at {:type :StrWhere},
:created_at {:type :StrWhere}},
:sort
{:access {:type :SortOperator},
:created_at {:type :SortOperator},
:edited_at {:type :SortOperator},
:id {:type :SortOperator},
:title {:type :SortOperator},
:user_id {:type :SortOperator},
:description {:type :SortOperator}},
:fields
{:access {:type Int},
:created_at {:type String},
:edited_at {:type String},
:id {:type Int},
:title {:type String},
:user_id {:type String},
:description {:type String}},
:aggregate
{:count {:type Int},
:sum {:type :GroupFields},
:avg {:type :GroupFields},
:max {:type :GroupFields},
:min {:type :GroupFields}},
:pks {:id {:type (non-null Int)}},
:pk-input {:id {:type (non-null Int)}},
:update
{:access {:type Int},
:created_at {:type String},
:edited_at {:type String},
:title {:type String},
:user_id {:type String},
:description {:type String}}},
:fks
{:access
{:field-keys
{:to :Access,
:has-many :groups,
:has-many-aggr :groups_aggregate,
:has-one :access_access}},
:user_id
{:field-keys
{:to :User,
:has-many :groups,
:has-many-aggr :groups_aggregate,
:has-one :user}}},
:lcn-mut-keys
{:create :createGroup,
:update :updateGroup,
:delete :deleteGroup},
:lcn-obj-keys
{:rsc :Group,
:clauses :GroupClauses,
:where :GroupWhere,
:sort :GroupSort,
:fields :GroupFields,
:aggregate :GroupAggregate,
:pks :GroupPks,
:pk-input :GroupPkColumns},
:lcn-qry-keys {:queries :groups, :aggregate :groups_aggregate},
:lcn-descs
{:rsc "Groups",
:query "Query Groups.",
:clauses
"Format for where clauses is {column: {operator: value}}. Multiple parameters are applied with `AND` operators. `AND`/`OR` conditions can be created as a list of clauses. It is possible to nest them to create sub groups of conditions.",
:sort "Sort format is {column: \"asc\" or \"desc\"}.",
:fields "Groupsfields for aggregation.",
:aggregate "Aggrecate Groups.",
:pks "Primary key fields.",
:pk-input "Primary key fields."},
:signals
{:query {:pre (), :post ()},
:create {:pre (), :post ()},
:delete {:pre (), :post ()},
:update {:pre (), :post ()}},
:pk-keys (:id),
:col-keys
#{:description
:title
:id
:user_id
:access
:edited_at
:created_at}},
:signals
{:query {:pre (), :post ()},
:create {:pre (), :post ()},
:delete {:pre (), :post ()},
:update {:pre (), :post ()}},
:pk-keys (:id),
:col-keys #{:color :title :group_id :id}},
:lcn-obj-keys
{:rsc :UsersInGroup,
:clauses :UsersInGroupClauses,
:where :UsersInGroupWhere,
:sort :UsersInGroupSort,
:fields :UsersInGroupFields,
:aggregate :UsersInGroupAggregate,
:pks :UsersInGroupPks,
:pk-input :UsersInGroupPkColumns},
:lcn-qry-keys
{:queries :users_in_groups,
:aggregate :users_in_groups_aggregate},
:lcn-descs
{:rsc "UsersInGroups",
:query "Query UsersInGroups.",
:clauses
"Format for where clauses is {column: {operator: value}}. Multiple parameters are applied with `AND` operators. `AND`/`OR` conditions can be created as a list of clauses. It is possible to nest them to create sub groups of conditions.",
:sort "Sort format is {column: \"asc\" or \"desc\"}.",
:fields "UsersInGroupsfields for aggregation.",
:aggregate "Aggrecate UsersInGroups.",
:pks "Primary key fields.",
:pk-input "Primary key fields."},
:access
{:lcn-fields
{:rsc
{:can_read {:type Boolean},
:inherit {:type Boolean},
:can_edit {:type Boolean},
:group_id {:type Int},
:id {:type Int},
:user_id {:type String},
:role_id {:type Int},
:next_access {:type Int},
:owner {:type Boolean}},
:clauses
{:can_read {:type :BoolWhere},
:inherit {:type :BoolWhere},
:can_edit {:type :BoolWhere},
:or {:type (list :AccessClauses)},
:group_id {:type :IntWhere},
:id {:type :IntWhere},
:and {:type (list :AccessClauses)},
:user_id {:type :StrWhere},
:role_id {:type :IntWhere},
:next_access {:type :IntWhere},
:owner {:type :BoolWhere}},
:sort
{:can_read {:type :SortOperator},
:inherit {:type :SortOperator},
:can_edit {:type :SortOperator},
:group_id {:type :SortOperator},
:id {:type :SortOperator},
:user_id {:type :SortOperator},
:role_id {:type :SortOperator},
:next_access {:type :SortOperator},
:owner {:type :SortOperator}},
:fields
{:can_read {:type Boolean},
:inherit {:type Boolean},
:can_edit {:type Boolean},
:group_id {:type Int},
:id {:type Int},
:user_id {:type String},
:role_id {:type Int},
:next_access {:type Int},
:owner {:type Boolean}},
:aggregate
{:count {:type Int},
:sum {:type :AccessFields},
:avg {:type :AccessFields},
:max {:type :AccessFields},
:min {:type :AccessFields}},
:pks {:id {:type (non-null Int)}},
:pk-input {:id {:type (non-null Int)}},
:update
{:can_read {:type Boolean},
:inherit {:type Boolean},
:can_edit {:type Boolean},
:group_id {:type Int},
:user_id {:type String},
:role_id {:type Int},
:next_access {:type Int},
:owner {:type Boolean}}},
:fks
{:next_access
{:field-keys
{:to :Access,
:has-many :accesses,
:has-many-aggr :accesses_aggregate,
:has-one :next_access_access}},
:role_id
{:field-keys
{:to :Role,
:has-many :accesses,
:has-many-aggr :accesses_aggregate,
:has-one :role}},
:user_id
{:field-keys
{:to :User,
:has-many :accesses,
:has-many-aggr :accesses_aggregate,
:has-one :user}},
:group_id
{:field-keys
{:to :Group,
:has-many :accesses,
:has-many-aggr :accesses_aggregate,
:has-one :group}}},
:lcn-mut-keys
{:create :createAccess,
:update :updateAccess,
:delete :deleteAccess},
:roles
{:lcn-fields
{:rsc
{:id {:type Int},
:group_id {:type Int},
:title {:type String},
:color {:type String}},
:clauses
{:and {:type (list :RoleClauses)},
:or {:type (list :RoleClauses)},
:id {:type :IntWhere},
:group_id {:type :IntWhere},
:title {:type :StrWhere},
:color {:type :StrWhere}},
:sort
{:id {:type :SortOperator},
:group_id {:type :SortOperator},
:title {:type :SortOperator},
:color {:type :SortOperator}},
:fields
{:id {:type Int},
:group_id {:type Int},
:title {:type String},
:color {:type String}},
:aggregate
{:count {:type Int},
:sum {:type :RoleFields},
:avg {:type :RoleFields},
:max {:type :RoleFields},
:min {:type :RoleFields}},
:pks {:id {:type (non-null Int)}},
:pk-input {:id {:type (non-null Int)}},
:update
{:group_id {:type Int},
:title {:type String},
:color {:type String}}},
:fks
{:group_id
{:field-keys
{:to :Group,
:has-many :roles,
:has-many-aggr :roles_aggregate,
:has-one :group}}},
:lcn-mut-keys
{:create :createRole, :update :updateRole, :delete :deleteRole},
:lcn-obj-keys
{:rsc :Role,
:clauses :RoleClauses,
:where :RoleWhere,
:sort :RoleSort,
:fields :RoleFields,
:aggregate :RoleAggregate,
:pks :RolePks,
:pk-input :RolePkColumns},
:lcn-qry-keys {:queries :roles, :aggregate :roles_aggregate},
:lcn-descs
{:rsc "Roles",
:query "Query Roles.",
:clauses
"Format for where clauses is {column: {operator: value}}. Multiple parameters are applied with `AND` operators. `AND`/`OR` conditions can be created as a list of clauses. It is possible to nest them to create sub groups of conditions.",
:sort "Sort format is {column: \"asc\" or \"desc\"}.",
:fields "Rolesfields for aggregation.",
:aggregate "Aggrecate Roles.",
:pks "Primary key fields.",
:pk-input "Primary key fields."},
:groups
{:lcn-fields
{:rsc
{:access {:type Int},
:created_at {:type String},
:edited_at {:type String},
:id {:type Int},
:title {:type String},
:user_id {:type String},
:description {:type String}},
:clauses
{:description {:type :StrWhere},
:or {:type (list :GroupClauses)},
:title {:type :StrWhere},
:id {:type :IntWhere},
:and {:type (list :GroupClauses)},
:user_id {:type :StrWhere},
:access {:type :IntWhere},
:edited_at {:type :StrWhere},
:created_at {:type :StrWhere}},
:sort
{:access {:type :SortOperator},
:created_at {:type :SortOperator},
:edited_at {:type :SortOperator},
:id {:type :SortOperator},
:title {:type :SortOperator},
:user_id {:type :SortOperator},
:description {:type :SortOperator}},
:fields
{:access {:type Int},
:created_at {:type String},
:edited_at {:type String},
:id {:type Int},
:title {:type String},
:user_id {:type String},
:description {:type String}},
:aggregate
{:count {:type Int},
:sum {:type :GroupFields},
:avg {:type :GroupFields},
:max {:type :GroupFields},
:min {:type :GroupFields}},
:pks {:id {:type (non-null Int)}},
:pk-input {:id {:type (non-null Int)}},
:update
{:access {:type Int},
:created_at {:type String},
:edited_at {:type String},
:title {:type String},
:user_id {:type String},
:description {:type String}}},
:fks
{:access
{:field-keys
{:to :Access,
:has-many :groups,
:has-many-aggr :groups_aggregate,
:has-one :access_access}},
:user_id
{:field-keys
{:to :User,
:has-many :groups,
:has-many-aggr :groups_aggregate,
:has-one :user}}},
:lcn-mut-keys
{:create :createGroup,
:update :updateGroup,
:delete :deleteGroup},
:lcn-obj-keys
{:rsc :Group,
:clauses :GroupClauses,
:where :GroupWhere,
:sort :GroupSort,
:fields :GroupFields,
:aggregate :GroupAggregate,
:pks :GroupPks,
:pk-input :GroupPkColumns},
:lcn-qry-keys {:queries :groups, :aggregate :groups_aggregate},
:lcn-descs
{:rsc "Groups",
:query "Query Groups.",
:clauses
"Format for where clauses is {column: {operator: value}}. Multiple parameters are applied with `AND` operators. `AND`/`OR` conditions can be created as a list of clauses. It is possible to nest them to create sub groups of conditions.",
:sort "Sort format is {column: \"asc\" or \"desc\"}.",
:fields "Groupsfields for aggregation.",
:aggregate "Aggrecate Groups.",
:pks "Primary key fields.",
:pk-input "Primary key fields."},
:signals
{:query {:pre (), :post ()},
:create {:pre (), :post ()},
:delete {:pre (), :post ()},
:update {:pre (), :post ()}},
:pk-keys (:id),
:col-keys
#{:description
:title
:id
:user_id
:access
:edited_at
:created_at}},
:signals
{:query {:pre (), :post ()},
:create {:pre (), :post ()},
:delete {:pre (), :post ()},
:update {:pre (), :post ()}},
:pk-keys (:id),
:col-keys #{:color :title :group_id :id}},
:lcn-obj-keys
{:rsc :Access,
:clauses :AccessClauses,
:where :AccessWhere,
:sort :AccessSort,
:fields :AccessFields,
:aggregate :AccessAggregate,
:pks :AccessPks,
:pk-input :AccessPkColumns},
:lcn-qry-keys
{:queries :accesses, :aggregate :accesses_aggregate},
:lcn-descs
{:rsc "Accesses",
:query "Query Accesses.",
:clauses
"Format for where clauses is {column: {operator: value}}. Multiple parameters are applied with `AND` operators. `AND`/`OR` conditions can be created as a list of clauses. It is possible to nest them to create sub groups of conditions.",
:sort "Sort format is {column: \"asc\" or \"desc\"}.",
:fields "Accessesfields for aggregation.",
:aggregate "Aggrecate Accesses.",
:pks "Primary key fields.",
:pk-input "Primary key fields."},
:groups
{:lcn-fields
{:rsc
{:access {:type Int},
:created_at {:type String},
:edited_at {:type String},
:id {:type Int},
:title {:type String},
:user_id {:type String},
:description {:type String}},
:clauses
{:description {:type :StrWhere},
:or {:type (list :GroupClauses)},
:title {:type :StrWhere},
:id {:type :IntWhere},
:and {:type (list :GroupClauses)},
:user_id {:type :StrWhere},
:access {:type :IntWhere},
:edited_at {:type :StrWhere},
:created_at {:type :StrWhere}},
:sort
{:access {:type :SortOperator},
:created_at {:type :SortOperator},
:edited_at {:type :SortOperator},
:id {:type :SortOperator},
:title {:type :SortOperator},
:user_id {:type :SortOperator},
:description {:type :SortOperator}},
:fields
{:access {:type Int},
:created_at {:type String},
:edited_at {:type String},
:id {:type Int},
:title {:type String},
:user_id {:type String},
:description {:type String}},
:aggregate
{:count {:type Int},
:sum {:type :GroupFields},
:avg {:type :GroupFields},
:max {:type :GroupFields},
:min {:type :GroupFields}},
:pks {:id {:type (non-null Int)}},
:pk-input {:id {:type (non-null Int)}},
:update
{:access {:type Int},
:created_at {:type String},
:edited_at {:type String},
:title {:type String},
:user_id {:type String},
:description {:type String}}},
:fks
{:access
{:field-keys
{:to :Access,
:has-many :groups,
:has-many-aggr :groups_aggregate,
:has-one :access_access}},
:user_id
{:field-keys
{:to :User,
:has-many :groups,
:has-many-aggr :groups_aggregate,
:has-one :user}}},
:lcn-mut-keys
{:create :createGroup,
:update :updateGroup,
:delete :deleteGroup},
:lcn-obj-keys
{:rsc :Group,
:clauses :GroupClauses,
:where :GroupWhere,
:sort :GroupSort,
:fields :GroupFields,
:aggregate :GroupAggregate,
:pks :GroupPks,
:pk-input :GroupPkColumns},
:lcn-qry-keys {:queries :groups, :aggregate :groups_aggregate},
:lcn-descs
{:rsc "Groups",
:query "Query Groups.",
:clauses
"Format for where clauses is {column: {operator: value}}. Multiple parameters are applied with `AND` operators. `AND`/`OR` conditions can be created as a list of clauses. It is possible to nest them to create sub groups of conditions.",
:sort "Sort format is {column: \"asc\" or \"desc\"}.",
:fields "Groupsfields for aggregation.",
:aggregate "Aggrecate Groups.",
:pks "Primary key fields.",
:pk-input "Primary key fields."},
:signals
{:query {:pre (), :post ()},
:create {:pre (), :post ()},
:delete {:pre (), :post ()},
:update {:pre (), :post ()}},
:pk-keys (:id),
:col-keys
#{:description
:title
:id
:user_id
:access
:edited_at
:created_at}},
:signals
{:query {:pre (), :post ()},
:create {:pre (), :post ()},
:delete {:pre (), :post ()},
:update {:pre (), :post ()}},
:pk-keys (:id),
:col-keys
#{:can_read
:inherit
:can_edit
:group_id
:id
:user_id
:role_id
:next_access
:owner}},
:groups
{:lcn-fields
{:rsc
{:access {:type Int},
:created_at {:type String},
:edited_at {:type String},
:id {:type Int},
:title {:type String},
:user_id {:type String},
:description {:type String}},
:clauses
{:description {:type :StrWhere},
:or {:type (list :GroupClauses)},
:title {:type :StrWhere},
:id {:type :IntWhere},
:and {:type (list :GroupClauses)},
:user_id {:type :StrWhere},
:access {:type :IntWhere},
:edited_at {:type :StrWhere},
:created_at {:type :StrWhere}},
:sort
{:access {:type :SortOperator},
:created_at {:type :SortOperator},
:edited_at {:type :SortOperator},
:id {:type :SortOperator},
:title {:type :SortOperator},
:user_id {:type :SortOperator},
:description {:type :SortOperator}},
:fields
{:access {:type Int},
:created_at {:type String},
:edited_at {:type String},
:id {:type Int},
:title {:type String},
:user_id {:type String},
:description {:type String}},
:aggregate
{:count {:type Int},
:sum {:type :GroupFields},
:avg {:type :GroupFields},
:max {:type :GroupFields},
:min {:type :GroupFields}},
:pks {:id {:type (non-null Int)}},
:pk-input {:id {:type (non-null Int)}},
:update
{:access {:type Int},
:created_at {:type String},
:edited_at {:type String},
:title {:type String},
:user_id {:type String},
:description {:type String}}},
:fks
{:access
{:field-keys
{:to :Access,
:has-many :groups,
:has-many-aggr :groups_aggregate,
:has-one :access_access}},
:user_id
{:field-keys
{:to :User,
:has-many :groups,
:has-many-aggr :groups_aggregate,
:has-one :user}}},
:lcn-mut-keys
{:create :createGroup,
:update :updateGroup,
:delete :deleteGroup},
:lcn-obj-keys
{:rsc :Group,
:clauses :GroupClauses,
:where :GroupWhere,
:sort :GroupSort,
:fields :GroupFields,
:aggregate :GroupAggregate,
:pks :GroupPks,
:pk-input :GroupPkColumns},
:lcn-qry-keys {:queries :groups, :aggregate :groups_aggregate},
:lcn-descs
{:rsc "Groups",
:query "Query Groups.",
:clauses
"Format for where clauses is {column: {operator: value}}. Multiple parameters are applied with `AND` operators. `AND`/`OR` conditions can be created as a list of clauses. It is possible to nest them to create sub groups of conditions.",
:sort "Sort format is {column: \"asc\" or \"desc\"}.",
:fields "Groupsfields for aggregation.",
:aggregate "Aggrecate Groups.",
:pks "Primary key fields.",
:pk-input "Primary key fields."},
:signals
{:query {:pre (), :post ()},
:create {:pre (), :post ()},
:delete {:pre (), :post ()},
:update {:pre (), :post ()}},
:pk-keys (:id),
:col-keys
#{:description
:title
:id
:user_id
:access
:edited_at
:created_at}},
:signals
{:query {:pre (), :post ()},
:create {:pre (), :post ()},
:delete {:pre (), :post ()},
:update {:pre (), :post ()}},
:pk-keys (:user_id :group_id :role_id),
:col-keys #{:group_id :user_id :role_id}}},
:attributes
{:lcn-fields
{:rsc
{:attribute_name {:type nil},
:description {:type String},
:udt_schema {:type nil},
:collation_schema {:type nil},
:numeric_scale {:type Int},
:character_set_schema {:type nil},
:dtd_identifier {:type nil},
:maximum_cardinality {:type Int},
:is_derived_reference_attribute {:type String},
:character_octet_length {:type Int},
:datetime_precision {:type Int},
:scope_catalog {:type nil},
:collation_catalog {:type nil},
:character_maximum_length {:type Int},
:is_nullable {:type String},
:character_set_catalog {:type nil},
:numeric_precision {:type Int},
:interval_type {:type String},
:udt_catalog {:type nil},
:title {:type String},
:scope_schema {:type nil},
:attribute_default {:type String},
:numeric_precision_radix {:type Int},
:interval_precision {:type Int},
:character_set_name {:type nil},
:attribute_udt_catalog {:type nil},
:id {:type Int},
:collation_name {:type nil},
:data_type {:type String},
:attribute_udt_schema {:type nil},
:access {:type Int},
:edited_at {:type String},
:scope_name {:type nil},
:udt_name {:type nil},
:created_at {:type String},
:ordinal_position {:type Int},
:attribute_udt_name {:type nil}},
:clauses
{:attribute_name {:type nil},
:description {:type :StrWhere},
:udt_schema {:type nil},
:collation_schema {:type nil},
:numeric_scale {:type :IntWhere},
:character_set_schema {:type nil},
:dtd_identifier {:type nil},
:maximum_cardinality {:type :IntWhere},
:is_derived_reference_attribute {:type :StrWhere},
:character_octet_length {:type :IntWhere},
:datetime_precision {:type :IntWhere},
:or {:type (list :AttributeClauses)},
:scope_catalog {:type nil},
:collation_catalog {:type nil},
:character_maximum_length {:type :IntWhere},
:is_nullable {:type :StrWhere},
:character_set_catalog {:type nil},
:numeric_precision {:type :IntWhere},
:interval_type {:type :StrWhere},
:udt_catalog {:type nil},
:title {:type :StrWhere},
:scope_schema {:type nil},
:attribute_default {:type :StrWhere},
:numeric_precision_radix {:type :IntWhere},
:interval_precision {:type :IntWhere},
:character_set_name {:type nil},
:attribute_udt_catalog {:type nil},
:id {:type :IntWhere},
:collation_name {:type nil},
:data_type {:type :StrWhere},
:attribute_udt_schema {:type nil},
:and {:type (list :AttributeClauses)},
:access {:type :IntWhere},
:edited_at {:type :StrWhere},
:scope_name {:type nil},
:udt_name {:type nil},
:created_at {:type :StrWhere},
:ordinal_position {:type :IntWhere},
:attribute_udt_name {:type nil}},
:sort
{:attribute_name {:type :SortOperator},
:description {:type :SortOperator},
:udt_schema {:type :SortOperator},
:collation_schema {:type :SortOperator},
:numeric_scale {:type :SortOperator},
:character_set_schema {:type :SortOperator},
:dtd_identifier {:type :SortOperator},
:maximum_cardinality {:type :SortOperator},
:is_derived_reference_attribute {:type :SortOperator},
:character_octet_length {:type :SortOperator},
:datetime_precision {:type :SortOperator},
:scope_catalog {:type :SortOperator},
:collation_catalog {:type :SortOperator},
:character_maximum_length {:type :SortOperator},
:is_nullable {:type :SortOperator},
:character_set_catalog {:type :SortOperator},
:numeric_precision {:type :SortOperator},
:interval_type {:type :SortOperator},
:udt_catalog {:type :SortOperator},
:title {:type :SortOperator},
:scope_schema {:type :SortOperator},
:attribute_default {:type :SortOperator},
:numeric_precision_radix {:type :SortOperator},
:interval_precision {:type :SortOperator},
:character_set_name {:type :SortOperator},
:attribute_udt_catalog {:type :SortOperator},
:id {:type :SortOperator},
:collation_name {:type :SortOperator},
:data_type {:type :SortOperator},
:attribute_udt_schema {:type :SortOperator},
:access {:type :SortOperator},
:edited_at {:type :SortOperator},
:scope_name {:type :SortOperator},
:udt_name {:type :SortOperator},
:created_at {:type :SortOperator},
:ordinal_position {:type :SortOperator},
:attribute_udt_name {:type :SortOperator}},
:fields
{:attribute_name {:type nil},
:description {:type String},
:udt_schema {:type nil},
:collation_schema {:type nil},
:numeric_scale {:type Int},
:character_set_schema {:type nil},
:dtd_identifier {:type nil},
:maximum_cardinality {:type Int},
:is_derived_reference_attribute {:type String},
:character_octet_length {:type Int},
:datetime_precision {:type Int},
:scope_catalog {:type nil},
:collation_catalog {:type nil},
:character_maximum_length {:type Int},
:is_nullable {:type String},
:character_set_catalog {:type nil},
:numeric_precision {:type Int},
:interval_type {:type String},
:udt_catalog {:type nil},
:title {:type String},
:scope_schema {:type nil},
:attribute_default {:type String},
:numeric_precision_radix {:type Int},
:interval_precision {:type Int},
:character_set_name {:type nil},
:attribute_udt_catalog {:type nil},
:id {:type Int},
:collation_name {:type nil},
:data_type {:type String},
:attribute_udt_schema {:type nil},
:access {:type Int},
:edited_at {:type String},
:scope_name {:type nil},
:udt_name {:type nil},
:created_at {:type String},
:ordinal_position {:type Int},
:attribute_udt_name {:type nil}},
:aggregate
{:count {:type Int},
:sum {:type :AttributeFields},
:avg {:type :AttributeFields},
:max {:type :AttributeFields},
:min {:type :AttributeFields}},
:pks {:id {:type (non-null Int)}},
:pk-input {:id {:type (non-null Int)}},
:update
{:attribute_name {:type nil},
:description {:type String},
:udt_schema {:type nil},
:collation_schema {:type nil},
:numeric_scale {:type Int},
:character_set_schema {:type nil},
:dtd_identifier {:type nil},
:maximum_cardinality {:type Int},
:is_derived_reference_attribute {:type String},
:character_octet_length {:type Int},
:datetime_precision {:type Int},
:scope_catalog {:type nil},
:collation_catalog {:type nil},
:character_maximum_length {:type Int},
:is_nullable {:type String},
:character_set_catalog {:type nil},
:numeric_precision {:type Int},
:interval_type {:type String},
:udt_catalog {:type nil},
:title {:type String},
:scope_schema {:type nil},
:attribute_default {:type String},
:numeric_precision_radix {:type Int},
:interval_precision {:type Int},
:character_set_name {:type nil},
:attribute_udt_catalog {:type nil},
:collation_name {:type nil},
:data_type {:type String},
:attribute_udt_schema {:type nil},
:access {:type Int},
:edited_at {:type String},
:scope_name {:type nil},
:udt_name {:type nil},
:created_at {:type String},
:ordinal_position {:type Int},
:attribute_udt_name {:type nil}}},
:fks
{:access
{:field-keys
{:to :Access,
:has-many :attributes,
:has-many-aggr :attributes_aggregate,
:has-one :access_access}}},
:lcn-mut-keys
{:create :createAttribute,
:update :updateAttribute,
:delete :deleteAttribute},
:roles
{:lcn-fields
{:rsc
{:id {:type Int},
:group_id {:type Int},
:title {:type String},
:color {:type String}},
:clauses
{:and {:type (list :RoleClauses)},
:or {:type (list :RoleClauses)},
:id {:type :IntWhere},
:group_id {:type :IntWhere},
:title {:type :StrWhere},
:color {:type :StrWhere}},
:sort
{:id {:type :SortOperator},
:group_id {:type :SortOperator},
:title {:type :SortOperator},
:color {:type :SortOperator}},
:fields
{:id {:type Int},
:group_id {:type Int},
:title {:type String},
:color {:type String}},
:aggregate
{:count {:type Int},
:sum {:type :RoleFields},
:avg {:type :RoleFields},
:max {:type :RoleFields},
:min {:type :RoleFields}},
:pks {:id {:type (non-null Int)}},
:pk-input {:id {:type (non-null Int)}},
:update
{:group_id {:type Int},
:title {:type String},
:color {:type String}}},
:fks
{:group_id
{:field-keys
{:to :Group,
:has-many :roles,
:has-many-aggr :roles_aggregate,
:has-one :group}}},
:lcn-mut-keys
{:create :createRole, :update :updateRole, :delete :deleteRole},
:lcn-obj-keys
{:rsc :Role,
:clauses :RoleClauses,
:where :RoleWhere,
:sort :RoleSort,
:fields :RoleFields,
:aggregate :RoleAggregate,
:pks :RolePks,
:pk-input :RolePkColumns},
:lcn-qry-keys {:queries :roles, :aggregate :roles_aggregate},
:lcn-descs
{:rsc "Roles",
:query "Query Roles.",
:clauses
"Format for where clauses is {column: {operator: value}}. Multiple parameters are applied with `AND` operators. `AND`/`OR` conditions can be created as a list of clauses. It is possible to nest them to create sub groups of conditions.",
:sort "Sort format is {column: \"asc\" or \"desc\"}.",
:fields "Rolesfields for aggregation.",
:aggregate "Aggrecate Roles.",
:pks "Primary key fields.",
:pk-input "Primary key fields."},
:groups
{:lcn-fields
{:rsc
{:access {:type Int},
:created_at {:type String},
:edited_at {:type String},
:id {:type Int},
:title {:type String},
:user_id {:type String},
:description {:type String}},
:clauses
{:description {:type :StrWhere},
:or {:type (list :GroupClauses)},
:title {:type :StrWhere},
:id {:type :IntWhere},
:and {:type (list :GroupClauses)},
:user_id {:type :StrWhere},
:access {:type :IntWhere},
:edited_at {:type :StrWhere},
:created_at {:type :StrWhere}},
:sort
{:access {:type :SortOperator},
:created_at {:type :SortOperator},
:edited_at {:type :SortOperator},
:id {:type :SortOperator},
:title {:type :SortOperator},
:user_id {:type :SortOperator},
:description {:type :SortOperator}},
:fields
{:access {:type Int},
:created_at {:type String},
:edited_at {:type String},
:id {:type Int},
:title {:type String},
:user_id {:type String},
:description {:type String}},
:aggregate
{:count {:type Int},
:sum {:type :GroupFields},
:avg {:type :GroupFields},
:max {:type :GroupFields},
:min {:type :GroupFields}},
:pks {:id {:type (non-null Int)}},
:pk-input {:id {:type (non-null Int)}},
:update
{:access {:type Int},
:created_at {:type String},
:edited_at {:type String},
:title {:type String},
:user_id {:type String},
:description {:type String}}},
:fks
{:access
{:field-keys
{:to :Access,
:has-many :groups,
:has-many-aggr :groups_aggregate,
:has-one :access_access}},
:user_id
{:field-keys
{:to :User,
:has-many :groups,
:has-many-aggr :groups_aggregate,
:has-one :user}}},
:lcn-mut-keys
{:create :createGroup,
:update :updateGroup,
:delete :deleteGroup},
:lcn-obj-keys
{:rsc :Group,
:clauses :GroupClauses,
:where :GroupWhere,
:sort :GroupSort,
:fields :GroupFields,
:aggregate :GroupAggregate,
:pks :GroupPks,
:pk-input :GroupPkColumns},
:lcn-qry-keys {:queries :groups, :aggregate :groups_aggregate},
:lcn-descs
{:rsc "Groups",
:query "Query Groups.",
:clauses
"Format for where clauses is {column: {operator: value}}. Multiple parameters are applied with `AND` operators. `AND`/`OR` conditions can be created as a list of clauses. It is possible to nest them to create sub groups of conditions.",
:sort "Sort format is {column: \"asc\" or \"desc\"}.",
:fields "Groupsfields for aggregation.",
:aggregate "Aggrecate Groups.",
:pks "Primary key fields.",
:pk-input "Primary key fields."},
:signals
{:query {:pre (), :post ()},
:create {:pre (), :post ()},
:delete {:pre (), :post ()},
:update {:pre (), :post ()}},
:pk-keys (:id),
:col-keys
#{:description
:title
:id
:user_id
:access
:edited_at
:created_at}},
:signals
{:query {:pre (), :post ()},
:create {:pre (), :post ()},
:delete {:pre (), :post ()},
:update {:pre (), :post ()}},
:pk-keys (:id),
:col-keys #{:color :title :group_id :id}},
:lcn-obj-keys
{:rsc :Attribute,
:clauses :AttributeClauses,
:where :AttributeWhere,
:sort :AttributeSort,
:fields :AttributeFields,
:aggregate :AttributeAggregate,
:pks :AttributePks,
:pk-input :AttributePkColumns},
:lcn-qry-keys
{:queries :attributes, :aggregate :attributes_aggregate},
:lcn-descs
{:rsc "Attributes",
:query "Query Attributes.",
:clauses
"Format for where clauses is {column: {operator: value}}. Multiple parameters are applied with `AND` operators. `AND`/`OR` conditions can be created as a list of clauses. It is possible to nest them to create sub groups of conditions.",
:sort "Sort format is {column: \"asc\" or \"desc\"}.",
:fields "Attributesfields for aggregation.",
:aggregate "Aggrecate Attributes.",
:pks "Primary key fields.",
:pk-input "Primary key fields."},
:access
{:lcn-fields
{:rsc
{:can_read {:type Boolean},
:inherit {:type Boolean},
:can_edit {:type Boolean},
:group_id {:type Int},
:id {:type Int},
:user_id {:type String},
:role_id {:type Int},
:next_access {:type Int},
:owner {:type Boolean}},
:clauses
{:can_read {:type :BoolWhere},
:inherit {:type :BoolWhere},
:can_edit {:type :BoolWhere},
:or {:type (list :AccessClauses)},
:group_id {:type :IntWhere},
:id {:type :IntWhere},
:and {:type (list :AccessClauses)},
:user_id {:type :StrWhere},
:role_id {:type :IntWhere},
:next_access {:type :IntWhere},
:owner {:type :BoolWhere}},
:sort
{:can_read {:type :SortOperator},
:inherit {:type :SortOperator},
:can_edit {:type :SortOperator},
:group_id {:type :SortOperator},
:id {:type :SortOperator},
:user_id {:type :SortOperator},
:role_id {:type :SortOperator},
:next_access {:type :SortOperator},
:owner {:type :SortOperator}},
:fields
{:can_read {:type Boolean},
:inherit {:type Boolean},
:can_edit {:type Boolean},
:group_id {:type Int},
:id {:type Int},
:user_id {:type String},
:role_id {:type Int},
:next_access {:type Int},
:owner {:type Boolean}},
:aggregate
{:count {:type Int},
:sum {:type :AccessFields},
:avg {:type :AccessFields},
:max {:type :AccessFields},
:min {:type :AccessFields}},
:pks {:id {:type (non-null Int)}},
:pk-input {:id {:type (non-null Int)}},
:update
{:can_read {:type Boolean},
:inherit {:type Boolean},
:can_edit {:type Boolean},
:group_id {:type Int},
:user_id {:type String},
:role_id {:type Int},
:next_access {:type Int},
:owner {:type Boolean}}},
:fks
{:next_access
{:field-keys
{:to :Access,
:has-many :accesses,
:has-many-aggr :accesses_aggregate,
:has-one :next_access_access}},
:role_id
{:field-keys
{:to :Role,
:has-many :accesses,
:has-many-aggr :accesses_aggregate,
:has-one :role}},
:user_id
{:field-keys
{:to :User,
:has-many :accesses,
:has-many-aggr :accesses_aggregate,
:has-one :user}},
:group_id
{:field-keys
{:to :Group,
:has-many :accesses,
:has-many-aggr :accesses_aggregate,
:has-one :group}}},
:lcn-mut-keys
{:create :createAccess,
:update :updateAccess,
:delete :deleteAccess},
:roles
{:lcn-fields
{:rsc
{:id {:type Int},
:group_id {:type Int},
:title {:type String},
:color {:type String}},
:clauses
{:and {:type (list :RoleClauses)},
:or {:type (list :RoleClauses)},
:id {:type :IntWhere},
:group_id {:type :IntWhere},
:title {:type :StrWhere},
:color {:type :StrWhere}},
:sort
{:id {:type :SortOperator},
:group_id {:type :SortOperator},
:title {:type :SortOperator},
:color {:type :SortOperator}},
:fields
{:id {:type Int},
:group_id {:type Int},
:title {:type String},
:color {:type String}},
:aggregate
{:count {:type Int},
:sum {:type :RoleFields},
:avg {:type :RoleFields},
:max {:type :RoleFields},
:min {:type :RoleFields}},
:pks {:id {:type (non-null Int)}},
:pk-input {:id {:type (non-null Int)}},
:update
{:group_id {:type Int},
:title {:type String},
:color {:type String}}},
:fks
{:group_id
{:field-keys
{:to :Group,
:has-many :roles,
:has-many-aggr :roles_aggregate,
:has-one :group}}},
:lcn-mut-keys
{:create :createRole, :update :updateRole, :delete :deleteRole},
:lcn-obj-keys
{:rsc :Role,
:clauses :RoleClauses,
:where :RoleWhere,
:sort :RoleSort,
:fields :RoleFields,
:aggregate :RoleAggregate,
:pks :RolePks,
:pk-input :RolePkColumns},
:lcn-qry-keys {:queries :roles, :aggregate :roles_aggregate},
:lcn-descs
{:rsc "Roles",
:query "Query Roles.",
:clauses
"Format for where clauses is {column: {operator: value}}. Multiple parameters are applied with `AND` operators. `AND`/`OR` conditions can be created as a list of clauses. It is possible to nest them to create sub groups of conditions.",
:sort "Sort format is {column: \"asc\" or \"desc\"}.",
:fields "Rolesfields for aggregation.",
:aggregate "Aggrecate Roles.",
:pks "Primary key fields.",
:pk-input "Primary key fields."},
:groups
{:lcn-fields
{:rsc
{:access {:type Int},
:created_at {:type String},
:edited_at {:type String},
:id {:type Int},
:title {:type String},
:user_id {:type String},
:description {:type String}},
:clauses
{:description {:type :StrWhere},
:or {:type (list :GroupClauses)},
:title {:type :StrWhere},
:id {:type :IntWhere},
:and {:type (list :GroupClauses)},
:user_id {:type :StrWhere},
:access {:type :IntWhere},
:edited_at {:type :StrWhere},
:created_at {:type :StrWhere}},
:sort
{:access {:type :SortOperator},
:created_at {:type :SortOperator},
:edited_at {:type :SortOperator},
:id {:type :SortOperator},
:title {:type :SortOperator},
:user_id {:type :SortOperator},
:description {:type :SortOperator}},
:fields
{:access {:type Int},
:created_at {:type String},
:edited_at {:type String},
:id {:type Int},
:title {:type String},
:user_id {:type String},
:description {:type String}},
:aggregate
{:count {:type Int},
:sum {:type :GroupFields},
:avg {:type :GroupFields},
:max {:type :GroupFields},
:min {:type :GroupFields}},
:pks {:id {:type (non-null Int)}},
:pk-input {:id {:type (non-null Int)}},
:update
{:access {:type Int},
:created_at {:type String},
:edited_at {:type String},
:title {:type String},
:user_id {:type String},
:description {:type String}}},
:fks
{:access
{:field-keys
{:to :Access,
:has-many :groups,
:has-many-aggr :groups_aggregate,
:has-one :access_access}},
:user_id
{:field-keys
{:to :User,
:has-many :groups,
:has-many-aggr :groups_aggregate,
:has-one :user}}},
:lcn-mut-keys
{:create :createGroup,
:update :updateGroup,
:delete :deleteGroup},
:lcn-obj-keys
{:rsc :Group,
:clauses :GroupClauses,
:where :GroupWhere,
:sort :GroupSort,
:fields :GroupFields,
:aggregate :GroupAggregate,
:pks :GroupPks,
:pk-input :GroupPkColumns},
:lcn-qry-keys {:queries :groups, :aggregate :groups_aggregate},
:lcn-descs
{:rsc "Groups",
:query "Query Groups.",
:clauses
"Format for where clauses is {column: {operator: value}}. Multiple parameters are applied with `AND` operators. `AND`/`OR` conditions can be created as a list of clauses. It is possible to nest them to create sub groups of conditions.",
:sort "Sort format is {column: \"asc\" or \"desc\"}.",
:fields "Groupsfields for aggregation.",
:aggregate "Aggrecate Groups.",
:pks "Primary key fields.",
:pk-input "Primary key fields."},
:signals
{:query {:pre (), :post ()},
:create {:pre (), :post ()},
:delete {:pre (), :post ()},
:update {:pre (), :post ()}},
:pk-keys (:id),
:col-keys
#{:description
:title
:id
:user_id
:access
:edited_at
:created_at}},
:signals
{:query {:pre (), :post ()},
:create {:pre (), :post ()},
:delete {:pre (), :post ()},
:update {:pre (), :post ()}},
:pk-keys (:id),
:col-keys #{:color :title :group_id :id}},
:lcn-obj-keys
{:rsc :Access,
:clauses :AccessClauses,
:where :AccessWhere,
:sort :AccessSort,
:fields :AccessFields,
:aggregate :AccessAggregate,
:pks :AccessPks,
:pk-input :AccessPkColumns},
:lcn-qry-keys
{:queries :accesses, :aggregate :accesses_aggregate},
:lcn-descs
{:rsc "Accesses",
:query "Query Accesses.",
:clauses
"Format for where clauses is {column: {operator: value}}. Multiple parameters are applied with `AND` operators. `AND`/`OR` conditions can be created as a list of clauses. It is possible to nest them to create sub groups of conditions.",
:sort "Sort format is {column: \"asc\" or \"desc\"}.",
:fields "Accessesfields for aggregation.",
:aggregate "Aggrecate Accesses.",
:pks "Primary key fields.",
:pk-input "Primary key fields."},
:groups
{:lcn-fields
{:rsc
{:access {:type Int},
:created_at {:type String},
:edited_at {:type String},
:id {:type Int},
:title {:type String},
:user_id {:type String},
:description {:type String}},
:clauses
{:description {:type :StrWhere},
:or {:type (list :GroupClauses)},
:title {:type :StrWhere},
:id {:type :IntWhere},
:and {:type (list :GroupClauses)},
:user_id {:type :StrWhere},
:access {:type :IntWhere},
:edited_at {:type :StrWhere},
:created_at {:type :StrWhere}},
:sort
{:access {:type :SortOperator},
:created_at {:type :SortOperator},
:edited_at {:type :SortOperator},
:id {:type :SortOperator},
:title {:type :SortOperator},
:user_id {:type :SortOperator},
:description {:type :SortOperator}},
:fields
{:access {:type Int},
:created_at {:type String},
:edited_at {:type String},
:id {:type Int},
:title {:type String},
:user_id {:type String},
:description {:type String}},
:aggregate
{:count {:type Int},
:sum {:type :GroupFields},
:avg {:type :GroupFields},
:max {:type :GroupFields},
:min {:type :GroupFields}},
:pks {:id {:type (non-null Int)}},
:pk-input {:id {:type (non-null Int)}},
:update
{:access {:type Int},
:created_at {:type String},
:edited_at {:type String},
:title {:type String},
:user_id {:type String},
:description {:type String}}},
:fks
{:access
{:field-keys
{:to :Access,
:has-many :groups,
:has-many-aggr :groups_aggregate,
:has-one :access_access}},
:user_id
{:field-keys
{:to :User,
:has-many :groups,
:has-many-aggr :groups_aggregate,
:has-one :user}}},
:lcn-mut-keys
{:create :createGroup,
:update :updateGroup,
:delete :deleteGroup},
:lcn-obj-keys
{:rsc :Group,
:clauses :GroupClauses,
:where :GroupWhere,
:sort :GroupSort,
:fields :GroupFields,
:aggregate :GroupAggregate,
:pks :GroupPks,
:pk-input :GroupPkColumns},
:lcn-qry-keys {:queries :groups, :aggregate :groups_aggregate},
:lcn-descs
{:rsc "Groups",
:query "Query Groups.",
:clauses
"Format for where clauses is {column: {operator: value}}. Multiple parameters are applied with `AND` operators. `AND`/`OR` conditions can be created as a list of clauses. It is possible to nest them to create sub groups of conditions.",
:sort "Sort format is {column: \"asc\" or \"desc\"}.",
:fields "Groupsfields for aggregation.",
:aggregate "Aggrecate Groups.",
:pks "Primary key fields.",
:pk-input "Primary key fields."},
:signals
{:query {:pre (), :post ()},
:create {:pre (), :post ()},
:delete {:pre (), :post ()},
:update {:pre (), :post ()}},
:pk-keys (:id),
:col-keys
#{:description
:title
:id
:user_id
:access
:edited_at
:created_at}},
:signals
{:query {:pre (), :post ()},
:create {:pre (), :post ()},
:delete {:pre (), :post ()},
:update {:pre (), :post ()}},
:pk-keys (:id),
:col-keys
#{:can_read
:inherit
:can_edit
:group_id
:id
:user_id
:role_id
:next_access
:owner}},
:groups
{:lcn-fields
{:rsc
{:access {:type Int},
:created_at {:type String},
:edited_at {:type String},
:id {:type Int},
:title {:type String},
:user_id {:type String},
:description {:type String}},
:clauses
{:description {:type :StrWhere},
:or {:type (list :GroupClauses)},
:title {:type :StrWhere},
:id {:type :IntWhere},
:and {:type (list :GroupClauses)},
:user_id {:type :StrWhere},
:access {:type :IntWhere},
:edited_at {:type :StrWhere},
:created_at {:type :StrWhere}},
:sort
{:access {:type :SortOperator},
:created_at {:type :SortOperator},
:edited_at {:type :SortOperator},
:id {:type :SortOperator},
:title {:type :SortOperator},
:user_id {:type :SortOperator},
:description {:type :SortOperator}},
:fields
{:access {:type Int},
:created_at {:type String},
:edited_at {:type String},
:id {:type Int},
:title {:type String},
:user_id {:type String},
:description {:type String}},
:aggregate
{:count {:type Int},
:sum {:type :GroupFields},
:avg {:type :GroupFields},
:max {:type :GroupFields},
:min {:type :GroupFields}},
:pks {:id {:type (non-null Int)}},
:pk-input {:id {:type (non-null Int)}},
:update
{:access {:type Int},
:created_at {:type String},
:edited_at {:type String},
:title {:type String},
:user_id {:type String},
:description {:type String}}},
:fks
{:access
{:field-keys
{:to :Access,
:has-many :groups,
:has-many-aggr :groups_aggregate,
:has-one :access_access}},
:user_id
{:field-keys
{:to :User,
:has-many :groups,
:has-many-aggr :groups_aggregate,
:has-one :user}}},
:lcn-mut-keys
{:create :createGroup,
:update :updateGroup,
:delete :deleteGroup},
:lcn-obj-keys
{:rsc :Group,
:clauses :GroupClauses,
:where :GroupWhere,
:sort :GroupSort,
:fields :GroupFields,
:aggregate :GroupAggregate,
:pks :GroupPks,
:pk-input :GroupPkColumns},
:lcn-qry-keys {:queries :groups, :aggregate :groups_aggregate},
:lcn-descs
{:rsc "Groups",
:query "Query Groups.",
:clauses
"Format for where clauses is {column: {operator: value}}. Multiple parameters are applied with `AND` operators. `AND`/`OR` conditions can be created as a list of clauses. It is possible to nest them to create sub groups of conditions.",
:sort "Sort format is {column: \"asc\" or \"desc\"}.",
:fields "Groupsfields for aggregation.",
:aggregate "Aggrecate Groups.",
:pks "Primary key fields.",
:pk-input "Primary key fields."},
:signals
{:query {:pre (), :post ()},
:create {:pre (), :post ()},
:delete {:pre (), :post ()},
:update {:pre (), :post ()}},
:pk-keys (:id),
:col-keys
#{:description
:title
:id
:user_id
:access
:edited_at
:created_at}},
:items
{:lcn-fields
{:rsc
{:slug {:type String},
:domain_pk {:type String},
:title {:type String},
:domain_pk_namespace {:type String},
:id {:type Int},
:url {:type String},
:access {:type Int},
:edited_at {:type String},
:body {:type String},
:created_at {:type String}},
:clauses
{:slug {:type :StrWhere},
:domain_pk {:type :StrWhere},
:or {:type (list :ItemClauses)},
:title {:type :StrWhere},
:domain_pk_namespace {:type :StrWhere},
:id {:type :IntWhere},
:url {:type :StrWhere},
:and {:type (list :ItemClauses)},
:access {:type :IntWhere},
:edited_at {:type :StrWhere},
:body {:type :StrWhere},
:created_at {:type :StrWhere}},
:sort
{:slug {:type :SortOperator},
:domain_pk {:type :SortOperator},
:title {:type :SortOperator},
:domain_pk_namespace {:type :SortOperator},
:id {:type :SortOperator},
:url {:type :SortOperator},
:access {:type :SortOperator},
:edited_at {:type :SortOperator},
:body {:type :SortOperator},
:created_at {:type :SortOperator}},
:fields
{:slug {:type String},
:domain_pk {:type String},
:title {:type String},
:domain_pk_namespace {:type String},
:id {:type Int},
:url {:type String},
:access {:type Int},
:edited_at {:type String},
:body {:type String},
:created_at {:type String}},
:aggregate
{:count {:type Int},
:sum {:type :ItemFields},
:avg {:type :ItemFields},
:max {:type :ItemFields},
:min {:type :ItemFields}},
:pks {:id {:type (non-null Int)}},
:pk-input {:id {:type (non-null Int)}},
:update
{:slug {:type String},
:domain_pk {:type String},
:title {:type String},
:domain_pk_namespace {:type String},
:url {:type String},
:access {:type Int},
:edited_at {:type String},
:body {:type String},
:created_at {:type String}}},
:fks
{:access
{:field-keys
{:to :Access,
:has-many :items,
:has-many-aggr :items_aggregate,
:has-one :access_access}}},
:lcn-mut-keys
{:create :createItem, :update :updateItem, :delete :deleteItem},
:roles
{:lcn-fields
{:rsc
{:id {:type Int},
:group_id {:type Int},
:title {:type String},
:color {:type String}},
:clauses
{:and {:type (list :RoleClauses)},
:or {:type (list :RoleClauses)},
:id {:type :IntWhere},
:group_id {:type :IntWhere},
:title {:type :StrWhere},
:color {:type :StrWhere}},
:sort
{:id {:type :SortOperator},
:group_id {:type :SortOperator},
:title {:type :SortOperator},
:color {:type :SortOperator}},
:fields
{:id {:type Int},
:group_id {:type Int},
:title {:type String},
:color {:type String}},
:aggregate
{:count {:type Int},
:sum {:type :RoleFields},
:avg {:type :RoleFields},
:max {:type :RoleFields},
:min {:type :RoleFields}},
:pks {:id {:type (non-null Int)}},
:pk-input {:id {:type (non-null Int)}},
:update
{:group_id {:type Int},
:title {:type String},
:color {:type String}}},
:fks
{:group_id
{:field-keys
{:to :Group,
:has-many :roles,
:has-many-aggr :roles_aggregate,
:has-one :group}}},
:lcn-mut-keys
{:create :createRole, :update :updateRole, :delete :deleteRole},
:lcn-obj-keys
{:rsc :Role,
:clauses :RoleClauses,
:where :RoleWhere,
:sort :RoleSort,
:fields :RoleFields,
:aggregate :RoleAggregate,
:pks :RolePks,
:pk-input :RolePkColumns},
:lcn-qry-keys {:queries :roles, :aggregate :roles_aggregate},
:lcn-descs
{:rsc "Roles",
:query "Query Roles.",
:clauses
"Format for where clauses is {column: {operator: value}}. Multiple parameters are applied with `AND` operators. `AND`/`OR` conditions can be created as a list of clauses. It is possible to nest them to create sub groups of conditions.",
:sort "Sort format is {column: \"asc\" or \"desc\"}.",
:fields "Rolesfields for aggregation.",
:aggregate "Aggrecate Roles.",
:pks "Primary key fields.",
:pk-input "Primary key fields."},
:groups
{:lcn-fields
{:rsc
{:access {:type Int},
:created_at {:type String},
:edited_at {:type String},
:id {:type Int},
:title {:type String},
:user_id {:type String},
:description {:type String}},
:clauses
{:description {:type :StrWhere},
:or {:type (list :GroupClauses)},
:title {:type :StrWhere},
:id {:type :IntWhere},
:and {:type (list :GroupClauses)},
:user_id {:type :StrWhere},
:access {:type :IntWhere},
:edited_at {:type :StrWhere},
:created_at {:type :StrWhere}},
:sort
{:access {:type :SortOperator},
:created_at {:type :SortOperator},
:edited_at {:type :SortOperator},
:id {:type :SortOperator},
:title {:type :SortOperator},
:user_id {:type :SortOperator},
:description {:type :SortOperator}},
:fields
{:access {:type Int},
:created_at {:type String},
:edited_at {:type String},
:id {:type Int},
:title {:type String},
:user_id {:type String},
:description {:type String}},
:aggregate
{:count {:type Int},
:sum {:type :GroupFields},
:avg {:type :GroupFields},
:max {:type :GroupFields},
:min {:type :GroupFields}},
:pks {:id {:type (non-null Int)}},
:pk-input {:id {:type (non-null Int)}},
:update
{:access {:type Int},
:created_at {:type String},
:edited_at {:type String},
:title {:type String},
:user_id {:type String},
:description {:type String}}},
:fks
{:access
{:field-keys
{:to :Access,
:has-many :groups,
:has-many-aggr :groups_aggregate,
:has-one :access_access}},
:user_id
{:field-keys
{:to :User,
:has-many :groups,
:has-many-aggr :groups_aggregate,
:has-one :user}}},
:lcn-mut-keys
{:create :createGroup,
:update :updateGroup,
:delete :deleteGroup},
:lcn-obj-keys
{:rsc :Group,
:clauses :GroupClauses,
:where :GroupWhere,
:sort :GroupSort,
:fields :GroupFields,
:aggregate :GroupAggregate,
:pks :GroupPks,
:pk-input :GroupPkColumns},
:lcn-qry-keys {:queries :groups, :aggregate :groups_aggregate},
:lcn-descs
{:rsc "Groups",
:query "Query Groups.",
:clauses
"Format for where clauses is {column: {operator: value}}. Multiple parameters are applied with `AND` operators. `AND`/`OR` conditions can be created as a list of clauses. It is possible to nest them to create sub groups of conditions.",
:sort "Sort format is {column: \"asc\" or \"desc\"}.",
:fields "Groupsfields for aggregation.",
:aggregate "Aggrecate Groups.",
:pks "Primary key fields.",
:pk-input "Primary key fields."},
:signals
{:query {:pre (), :post ()},
:create {:pre (), :post ()},
:delete {:pre (), :post ()},
:update {:pre (), :post ()}},
:pk-keys (:id),
:col-keys
#{:description
:title
:id
:user_id
:access
:edited_at
:created_at}},
:signals
{:query {:pre (), :post ()},
:create {:pre (), :post ()},
:delete {:pre (), :post ()},
:update {:pre (), :post ()}},
:pk-keys (:id),
:col-keys #{:color :title :group_id :id}},
:lcn-obj-keys
{:rsc :Item,
:clauses :ItemClauses,
:where :ItemWhere,
:sort :ItemSort,
:fields :ItemFields,
:aggregate :ItemAggregate,
:pks :ItemPks,
:pk-input :ItemPkColumns},
:lcn-qry-keys {:queries :items, :aggregate :items_aggregate},
:lcn-descs
{:rsc "Items",
:query "Query Items.",
:clauses
"Format for where clauses is {column: {operator: value}}. Multiple parameters are applied with `AND` operators. `AND`/`OR` conditions can be created as a list of clauses. It is possible to nest them to create sub groups of conditions.",
:sort "Sort format is {column: \"asc\" or \"desc\"}.",
:fields "Itemsfields for aggregation.",
:aggregate "Aggrecate Items.",
:pks "Primary key fields.",
:pk-input "Primary key fields."},
:access
{:lcn-fields
{:rsc
{:can_read {:type Boolean},
:inherit {:type Boolean},
:can_edit {:type Boolean},
:group_id {:type Int},
:id {:type Int},
:user_id {:type String},
:role_id {:type Int},
:next_access {:type Int},
:owner {:type Boolean}},
:clauses
{:can_read {:type :BoolWhere},
:inherit {:type :BoolWhere},
:can_edit {:type :BoolWhere},
:or {:type (list :AccessClauses)},
:group_id {:type :IntWhere},
:id {:type :IntWhere},
:and {:type (list :AccessClauses)},
:user_id {:type :StrWhere},
:role_id {:type :IntWhere},
:next_access {:type :IntWhere},
:owner {:type :BoolWhere}},
:sort
{:can_read {:type :SortOperator},
:inherit {:type :SortOperator},
:can_edit {:type :SortOperator},
:group_id {:type :SortOperator},
:id {:type :SortOperator},
:user_id {:type :SortOperator},
:role_id {:type :SortOperator},
:next_access {:type :SortOperator},
:owner {:type :SortOperator}},
:fields
{:can_read {:type Boolean},
:inherit {:type Boolean},
:can_edit {:type Boolean},
:group_id {:type Int},
:id {:type Int},
:user_id {:type String},
:role_id {:type Int},
:next_access {:type Int},
:owner {:type Boolean}},
:aggregate
{:count {:type Int},
:sum {:type :AccessFields},
:avg {:type :AccessFields},
:max {:type :AccessFields},
:min {:type :AccessFields}},
:pks {:id {:type (non-null Int)}},
:pk-input {:id {:type (non-null Int)}},
:update
{:can_read {:type Boolean},
:inherit {:type Boolean},
:can_edit {:type Boolean},
:group_id {:type Int},
:user_id {:type String},
:role_id {:type Int},
:next_access {:type Int},
:owner {:type Boolean}}},
:fks
{:next_access
{:field-keys
{:to :Access,
:has-many :accesses,
:has-many-aggr :accesses_aggregate,
:has-one :next_access_access}},
:role_id
{:field-keys
{:to :Role,
:has-many :accesses,
:has-many-aggr :accesses_aggregate,
:has-one :role}},
:user_id
{:field-keys
{:to :User,
:has-many :accesses,
:has-many-aggr :accesses_aggregate,
:has-one :user}},
:group_id
{:field-keys
{:to :Group,
:has-many :accesses,
:has-many-aggr :accesses_aggregate,
:has-one :group}}},
:lcn-mut-keys
{:create :createAccess,
:update :updateAccess,
:delete :deleteAccess},
:roles
{:lcn-fields
{:rsc
{:id {:type Int},
:group_id {:type Int},
:title {:type String},
:color {:type String}},
:clauses
{:and {:type (list :RoleClauses)},
:or {:type (list :RoleClauses)},
:id {:type :IntWhere},
:group_id {:type :IntWhere},
:title {:type :StrWhere},
:color {:type :StrWhere}},
:sort
{:id {:type :SortOperator},
:group_id {:type :SortOperator},
:title {:type :SortOperator},
:color {:type :SortOperator}},
:fields
{:id {:type Int},
:group_id {:type Int},
:title {:type String},
:color {:type String}},
:aggregate
{:count {:type Int},
:sum {:type :RoleFields},
:avg {:type :RoleFields},
:max {:type :RoleFields},
:min {:type :RoleFields}},
:pks {:id {:type (non-null Int)}},
:pk-input {:id {:type (non-null Int)}},
:update
{:group_id {:type Int},
:title {:type String},
:color {:type String}}},
:fks
{:group_id
{:field-keys
{:to :Group,
:has-many :roles,
:has-many-aggr :roles_aggregate,
:has-one :group}}},
:lcn-mut-keys
{:create :createRole, :update :updateRole, :delete :deleteRole},
:lcn-obj-keys
{:rsc :Role,
:clauses :RoleClauses,
:where :RoleWhere,
:sort :RoleSort,
:fields :RoleFields,
:aggregate :RoleAggregate,
:pks :RolePks,
:pk-input :RolePkColumns},
:lcn-qry-keys {:queries :roles, :aggregate :roles_aggregate},
:lcn-descs
{:rsc "Roles",
:query "Query Roles.",
:clauses
"Format for where clauses is {column: {operator: value}}. Multiple parameters are applied with `AND` operators. `AND`/`OR` conditions can be created as a list of clauses. It is possible to nest them to create sub groups of conditions.",
:sort "Sort format is {column: \"asc\" or \"desc\"}.",
:fields "Rolesfields for aggregation.",
:aggregate "Aggrecate Roles.",
:pks "Primary key fields.",
:pk-input "Primary key fields."},
:groups
{:lcn-fields
{:rsc
{:access {:type Int},
:created_at {:type String},
:edited_at {:type String},
:id {:type Int},
:title {:type String},
:user_id {:type String},
:description {:type String}},
:clauses
{:description {:type :StrWhere},
:or {:type (list :GroupClauses)},
:title {:type :StrWhere},
:id {:type :IntWhere},
:and {:type (list :GroupClauses)},
:user_id {:type :StrWhere},
:access {:type :IntWhere},
:edited_at {:type :StrWhere},
:created_at {:type :StrWhere}},
:sort
{:access {:type :SortOperator},
:created_at {:type :SortOperator},
:edited_at {:type :SortOperator},
:id {:type :SortOperator},
:title {:type :SortOperator},
:user_id {:type :SortOperator},
:description {:type :SortOperator}},
:fields
{:access {:type Int},
:created_at {:type String},
:edited_at {:type String},
:id {:type Int},
:title {:type String},
:user_id {:type String},
:description {:type String}},
:aggregate
{:count {:type Int},
:sum {:type :GroupFields},
:avg {:type :GroupFields},
:max {:type :GroupFields},
:min {:type :GroupFields}},
:pks {:id {:type (non-null Int)}},
:pk-input {:id {:type (non-null Int)}},
:update
{:access {:type Int},
:created_at {:type String},
:edited_at {:type String},
:title {:type String},
:user_id {:type String},
:description {:type String}}},
:fks
{:access
{:field-keys
{:to :Access,
:has-many :groups,
:has-many-aggr :groups_aggregate,
:has-one :access_access}},
:user_id
{:field-keys
{:to :User,
:has-many :groups,
:has-many-aggr :groups_aggregate,
:has-one :user}}},
:lcn-mut-keys
{:create :createGroup,
:update :updateGroup,
:delete :deleteGroup},
:lcn-obj-keys
{:rsc :Group,
:clauses :GroupClauses,
:where :GroupWhere,
:sort :GroupSort,
:fields :GroupFields,
:aggregate :GroupAggregate,
:pks :GroupPks,
:pk-input :GroupPkColumns},
:lcn-qry-keys {:queries :groups, :aggregate :groups_aggregate},
:lcn-descs
{:rsc "Groups",
:query "Query Groups.",
:clauses
"Format for where clauses is {column: {operator: value}}. Multiple parameters are applied with `AND` operators. `AND`/`OR` conditions can be created as a list of clauses. It is possible to nest them to create sub groups of conditions.",
:sort "Sort format is {column: \"asc\" or \"desc\"}.",
:fields "Groupsfields for aggregation.",
:aggregate "Aggrecate Groups.",
:pks "Primary key fields.",
:pk-input "Primary key fields."},
:signals
{:query {:pre (), :post ()},
:create {:pre (), :post ()},
:delete {:pre (), :post ()},
:update {:pre (), :post ()}},
:pk-keys (:id),
:col-keys
#{:description
:title
:id
:user_id
:access
:edited_at
:created_at}},
:signals
{:query {:pre (), :post ()},
:create {:pre (), :post ()},
:delete {:pre (), :post ()},
:update {:pre (), :post ()}},
:pk-keys (:id),
:col-keys #{:color :title :group_id :id}},
:lcn-obj-keys
{:rsc :Access,
:clauses :AccessClauses,
:where :AccessWhere,
:sort :AccessSort,
:fields :AccessFields,
:aggregate :AccessAggregate,
:pks :AccessPks,
:pk-input :AccessPkColumns},
:lcn-qry-keys
{:queries :accesses, :aggregate :accesses_aggregate},
:lcn-descs
{:rsc "Accesses",
:query "Query Accesses.",
:clauses
"Format for where clauses is {column: {operator: value}}. Multiple parameters are applied with `AND` operators. `AND`/`OR` conditions can be created as a list of clauses. It is possible to nest them to create sub groups of conditions.",
:sort "Sort format is {column: \"asc\" or \"desc\"}.",
:fields "Accessesfields for aggregation.",
:aggregate "Aggrecate Accesses.",
:pks "Primary key fields.",
:pk-input "Primary key fields."},
:groups
{:lcn-fields
{:rsc
{:access {:type Int},
:created_at {:type String},
:edited_at {:type String},
:id {:type Int},
:title {:type String},
:user_id {:type String},
:description {:type String}},
:clauses
{:description {:type :StrWhere},
:or {:type (list :GroupClauses)},
:title {:type :StrWhere},
:id {:type :IntWhere},
:and {:type (list :GroupClauses)},
:user_id {:type :StrWhere},
:access {:type :IntWhere},
:edited_at {:type :StrWhere},
:created_at {:type :StrWhere}},
:sort
{:access {:type :SortOperator},
:created_at {:type :SortOperator},
:edited_at {:type :SortOperator},
:id {:type :SortOperator},
:title {:type :SortOperator},
:user_id {:type :SortOperator},
:description {:type :SortOperator}},
:fields
{:access {:type Int},
:created_at {:type String},
:edited_at {:type String},
:id {:type Int},
:title {:type String},
:user_id {:type String},
:description {:type String}},
:aggregate
{:count {:type Int},
:sum {:type :GroupFields},
:avg {:type :GroupFields},
:max {:type :GroupFields},
:min {:type :GroupFields}},
:pks {:id {:type (non-null Int)}},
:pk-input {:id {:type (non-null Int)}},
:update
{:access {:type Int},
:created_at {:type String},
:edited_at {:type String},
:title {:type String},
:user_id {:type String},
:description {:type String}}},
:fks
{:access
{:field-keys
{:to :Access,
:has-many :groups,
:has-many-aggr :groups_aggregate,
:has-one :access_access}},
:user_id
{:field-keys
{:to :User,
:has-many :groups,
:has-many-aggr :groups_aggregate,
:has-one :user}}},
:lcn-mut-keys
{:create :createGroup,
:update :updateGroup,
:delete :deleteGroup},
:lcn-obj-keys
{:rsc :Group,
:clauses :GroupClauses,
:where :GroupWhere,
:sort :GroupSort,
:fields :GroupFields,
:aggregate :GroupAggregate,
:pks :GroupPks,
:pk-input :GroupPkColumns},
:lcn-qry-keys {:queries :groups, :aggregate :groups_aggregate},
:lcn-descs
{:rsc "Groups",
:query "Query Groups.",
:clauses
"Format for where clauses is {column: {operator: value}}. Multiple parameters are applied with `AND` operators. `AND`/`OR` conditions can be created as a list of clauses. It is possible to nest them to create sub groups of conditions.",
:sort "Sort format is {column: \"asc\" or \"desc\"}.",
:fields "Groupsfields for aggregation.",
:aggregate "Aggrecate Groups.",
:pks "Primary key fields.",
:pk-input "Primary key fields."},
:signals
{:query {:pre (), :post ()},
:create {:pre (), :post ()},
:delete {:pre (), :post ()},
:update {:pre (), :post ()}},
:pk-keys (:id),
:col-keys
#{:description
:title
:id
:user_id
:access
:edited_at
:created_at}},
:signals
{:query {:pre (), :post ()},
:create {:pre (), :post ()},
:delete {:pre (), :post ()},
:update {:pre (), :post ()}},
:pk-keys (:id),
:col-keys
#{:can_read
:inherit
:can_edit
:group_id
:id
:user_id
:role_id
:next_access
:owner}},
:groups
{:lcn-fields
{:rsc
{:access {:type Int},
:created_at {:type String},
:edited_at {:type String},
:id {:type Int},
:title {:type String},
:user_id {:type String},
:description {:type String}},
:clauses
{:description {:type :StrWhere},
:or {:type (list :GroupClauses)},
:title {:type :StrWhere},
:id {:type :IntWhere},
:and {:type (list :GroupClauses)},
:user_id {:type :StrWhere},
:access {:type :IntWhere},
:edited_at {:type :StrWhere},
:created_at {:type :StrWhere}},
:sort
{:access {:type :SortOperator},
:created_at {:type :SortOperator},
:edited_at {:type :SortOperator},
:id {:type :SortOperator},
:title {:type :SortOperator},
:user_id {:type :SortOperator},
:description {:type :SortOperator}},
:fields
{:access {:type Int},
:created_at {:type String},
:edited_at {:type String},
:id {:type Int},
:title {:type String},
:user_id {:type String},
:description {:type String}},
:aggregate
{:count {:type Int},
:sum {:type :GroupFields},
:avg {:type :GroupFields},
:max {:type :GroupFields},
:min {:type :GroupFields}},
:pks {:id {:type (non-null Int)}},
:pk-input {:id {:type (non-null Int)}},
:update
{:access {:type Int},
:created_at {:type String},
:edited_at {:type String},
:title {:type String},
:user_id {:type String},
:description {:type String}}},
:fks
{:access
{:field-keys
{:to :Access,
:has-many :groups,
:has-many-aggr :groups_aggregate,
:has-one :access_access}},
:user_id
{:field-keys
{:to :User,
:has-many :groups,
:has-many-aggr :groups_aggregate,
:has-one :user}}},
:lcn-mut-keys
{:create :createGroup,
:update :updateGroup,
:delete :deleteGroup},
:lcn-obj-keys
{:rsc :Group,
:clauses :GroupClauses,
:where :GroupWhere,
:sort :GroupSort,
:fields :GroupFields,
:aggregate :GroupAggregate,
:pks :GroupPks,
:pk-input :GroupPkColumns},
:lcn-qry-keys {:queries :groups, :aggregate :groups_aggregate},
:lcn-descs
{:rsc "Groups",
:query "Query Groups.",
:clauses
"Format for where clauses is {column: {operator: value}}. Multiple parameters are applied with `AND` operators. `AND`/`OR` conditions can be created as a list of clauses. It is possible to nest them to create sub groups of conditions.",
:sort "Sort format is {column: \"asc\" or \"desc\"}.",
:fields "Groupsfields for aggregation.",
:aggregate "Aggrecate Groups.",
:pks "Primary key fields.",
:pk-input "Primary key fields."},
:signals
{:query {:pre (), :post ()},
:create {:pre (), :post ()},
:delete {:pre (), :post ()},
:update {:pre (), :post ()}},
:pk-keys (:id),
:col-keys
#{:description
:title
:id
:user_id
:access
:edited_at
:created_at}},
:signals
{:query {:pre (), :post ()},
:create {:pre (), :post ()},
:delete {:pre (), :post ()},
:update {:pre (), :post ()}},
:pk-keys (:id),
:col-keys
#{:slug
:domain_pk
:title
:domain_pk_namespace
:id
:url
:access
:edited_at
:body
:created_at},
:users_in_groups
{:lcn-fields
{:rsc
{:group_id {:type Int},
:role_id {:type Int},
:user_id {:type String}},
:clauses
{:and {:type (list :UsersInGroupClauses)},
:or {:type (list :UsersInGroupClauses)},
:group_id {:type :IntWhere},
:role_id {:type :IntWhere},
:user_id {:type :StrWhere}},
:sort
{:group_id {:type :SortOperator},
:role_id {:type :SortOperator},
:user_id {:type :SortOperator}},
:fields
{:group_id {:type Int},
:role_id {:type Int},
:user_id {:type String}},
:aggregate
{:count {:type Int},
:sum {:type :UsersInGroupFields},
:avg {:type :UsersInGroupFields},
:max {:type :UsersInGroupFields},
:min {:type :UsersInGroupFields}},
:pks
{:user_id {:type (non-null String)},
:group_id {:type (non-null Int)},
:role_id {:type (non-null Int)}},
:pk-input
{:user_id {:type (non-null String)},
:group_id {:type (non-null Int)},
:role_id {:type (non-null Int)}},
:update {}},
:fks
{:user_id
{:field-keys
{:to :User,
:has-many :users_in_groups,
:has-many-aggr :users_in_groups_aggregate,
:has-one :user}},
:group_id
{:field-keys
{:to :Group,
:has-many :users_in_groups,
:has-many-aggr :users_in_groups_aggregate,
:has-one :group}},
:role_id
{:field-keys
{:to :Role,
:has-many :users_in_groups,
:has-many-aggr :users_in_groups_aggregate,
:has-one :role}}},
:lcn-mut-keys
{:create :createUsersInGroup,
:update :updateUsersInGroup,
:delete :deleteUsersInGroup},
:roles
{:lcn-fields
{:rsc
{:id {:type Int},
:group_id {:type Int},
:title {:type String},
:color {:type String}},
:clauses
{:and {:type (list :RoleClauses)},
:or {:type (list :RoleClauses)},
:id {:type :IntWhere},
:group_id {:type :IntWhere},
:title {:type :StrWhere},
:color {:type :StrWhere}},
:sort
{:id {:type :SortOperator},
:group_id {:type :SortOperator},
:title {:type :SortOperator},
:color {:type :SortOperator}},
:fields
{:id {:type Int},
:group_id {:type Int},
:title {:type String},
:color {:type String}},
:aggregate
{:count {:type Int},
:sum {:type :RoleFields},
:avg {:type :RoleFields},
:max {:type :RoleFields},
:min {:type :RoleFields}},
:pks {:id {:type (non-null Int)}},
:pk-input {:id {:type (non-null Int)}},
:update
{:group_id {:type Int},
:title {:type String},
:color {:type String}}},
:fks
{:group_id
{:field-keys
{:to :Group,
:has-many :roles,
:has-many-aggr :roles_aggregate,
:has-one :group}}},
:lcn-mut-keys
{:create :createRole, :update :updateRole, :delete :deleteRole},
:lcn-obj-keys
{:rsc :Role,
:clauses :RoleClauses,
:where :RoleWhere,
:sort :RoleSort,
:fields :RoleFields,
:aggregate :RoleAggregate,
:pks :RolePks,
:pk-input :RolePkColumns},
:lcn-qry-keys {:queries :roles, :aggregate :roles_aggregate},
:lcn-descs
{:rsc "Roles",
:query "Query Roles.",
:clauses
"Format for where clauses is {column: {operator: value}}. Multiple parameters are applied with `AND` operators. `AND`/`OR` conditions can be created as a list of clauses. It is possible to nest them to create sub groups of conditions.",
:sort "Sort format is {column: \"asc\" or \"desc\"}.",
:fields "Rolesfields for aggregation.",
:aggregate "Aggrecate Roles.",
:pks "Primary key fields.",
:pk-input "Primary key fields."},
:groups
{:lcn-fields
{:rsc
{:access {:type Int},
:created_at {:type String},
:edited_at {:type String},
:id {:type Int},
:title {:type String},
:user_id {:type String},
:description {:type String}},
:clauses
{:description {:type :StrWhere},
:or {:type (list :GroupClauses)},
:title {:type :StrWhere},
:id {:type :IntWhere},
:and {:type (list :GroupClauses)},
:user_id {:type :StrWhere},
:access {:type :IntWhere},
:edited_at {:type :StrWhere},
:created_at {:type :StrWhere}},
:sort
{:access {:type :SortOperator},
:created_at {:type :SortOperator},
:edited_at {:type :SortOperator},
:id {:type :SortOperator},
:title {:type :SortOperator},
:user_id {:type :SortOperator},
:description {:type :SortOperator}},
:fields
{:access {:type Int},
:created_at {:type String},
:edited_at {:type String},
:id {:type Int},
:title {:type String},
:user_id {:type String},
:description {:type String}},
:aggregate
{:count {:type Int},
:sum {:type :GroupFields},
:avg {:type :GroupFields},
:max {:type :GroupFields},
:min {:type :GroupFields}},
:pks {:id {:type (non-null Int)}},
:pk-input {:id {:type (non-null Int)}},
:update
{:access {:type Int},
:created_at {:type String},
:edited_at {:type String},
:title {:type String},
:user_id {:type String},
:description {:type String}}},
:fks
{:access
{:field-keys
{:to :Access,
:has-many :groups,
:has-many-aggr :groups_aggregate,
:has-one :access_access}},
:user_id
{:field-keys
{:to :User,
:has-many :groups,
:has-many-aggr :groups_aggregate,
:has-one :user}}},
:lcn-mut-keys
{:create :createGroup,
:update :updateGroup,
:delete :deleteGroup},
:lcn-obj-keys
{:rsc :Group,
:clauses :GroupClauses,
:where :GroupWhere,
:sort :GroupSort,
:fields :GroupFields,
:aggregate :GroupAggregate,
:pks :GroupPks,
:pk-input :GroupPkColumns},
:lcn-qry-keys {:queries :groups, :aggregate :groups_aggregate},
:lcn-descs
{:rsc "Groups",
:query "Query Groups.",
:clauses
"Format for where clauses is {column: {operator: value}}. Multiple parameters are applied with `AND` operators. `AND`/`OR` conditions can be created as a list of clauses. It is possible to nest them to create sub groups of conditions.",
:sort "Sort format is {column: \"asc\" or \"desc\"}.",
:fields "Groupsfields for aggregation.",
:aggregate "Aggrecate Groups.",
:pks "Primary key fields.",
:pk-input "Primary key fields."},
:signals
{:query {:pre (), :post ()},
:create {:pre (), :post ()},
:delete {:pre (), :post ()},
:update {:pre (), :post ()}},
:pk-keys (:id),
:col-keys
#{:description
:title
:id
:user_id
:access
:edited_at
:created_at}},
:signals
{:query {:pre (), :post ()},
:create {:pre (), :post ()},
:delete {:pre (), :post ()},
:update {:pre (), :post ()}},
:pk-keys (:id),
:col-keys #{:color :title :group_id :id}},
:lcn-obj-keys
{:rsc :UsersInGroup,
:clauses :UsersInGroupClauses,
:where :UsersInGroupWhere,
:sort :UsersInGroupSort,
:fields :UsersInGroupFields,
:aggregate :UsersInGroupAggregate,
:pks :UsersInGroupPks,
:pk-input :UsersInGroupPkColumns},
:lcn-qry-keys
{:queries :users_in_groups,
:aggregate :users_in_groups_aggregate},
:lcn-descs
{:rsc "UsersInGroups",
:query "Query UsersInGroups.",
:clauses
"Format for where clauses is {column: {operator: value}}. Multiple parameters are applied with `AND` operators. `AND`/`OR` conditions can be created as a list of clauses. It is possible to nest them to create sub groups of conditions.",
:sort "Sort format is {column: \"asc\" or \"desc\"}.",
:fields "UsersInGroupsfields for aggregation.",
:aggregate "Aggrecate UsersInGroups.",
:pks "Primary key fields.",
:pk-input "Primary key fields."},
:access
{:lcn-fields
{:rsc
{:can_read {:type Boolean},
:inherit {:type Boolean},
:can_edit {:type Boolean},
:group_id {:type Int},
:id {:type Int},
:user_id {:type String},
:role_id {:type Int},
:next_access {:type Int},
:owner {:type Boolean}},
:clauses
{:can_read {:type :BoolWhere},
:inherit {:type :BoolWhere},
:can_edit {:type :BoolWhere},
:or {:type (list :AccessClauses)},
:group_id {:type :IntWhere},
:id {:type :IntWhere},
:and {:type (list :AccessClauses)},
:user_id {:type :StrWhere},
:role_id {:type :IntWhere},
:next_access {:type :IntWhere},
:owner {:type :BoolWhere}},
:sort
{:can_read {:type :SortOperator},
:inherit {:type :SortOperator},
:can_edit {:type :SortOperator},
:group_id {:type :SortOperator},
:id {:type :SortOperator},
:user_id {:type :SortOperator},
:role_id {:type :SortOperator},
:next_access {:type :SortOperator},
:owner {:type :SortOperator}},
:fields
{:can_read {:type Boolean},
:inherit {:type Boolean},
:can_edit {:type Boolean},
:group_id {:type Int},
:id {:type Int},
:user_id {:type String},
:role_id {:type Int},
:next_access {:type Int},
:owner {:type Boolean}},
:aggregate
{:count {:type Int},
:sum {:type :AccessFields},
:avg {:type :AccessFields},
:max {:type :AccessFields},
:min {:type :AccessFields}},
:pks {:id {:type (non-null Int)}},
:pk-input {:id {:type (non-null Int)}},
:update
{:can_read {:type Boolean},
:inherit {:type Boolean},
:can_edit {:type Boolean},
:group_id {:type Int},
:user_id {:type String},
:role_id {:type Int},
:next_access {:type Int},
:owner {:type Boolean}}},
:fks
{:next_access
{:field-keys
{:to :Access,
:has-many :accesses,
:has-many-aggr :accesses_aggregate,
:has-one :next_access_access}},
:role_id
{:field-keys
{:to :Role,
:has-many :accesses,
:has-many-aggr :accesses_aggregate,
:has-one :role}},
:user_id
{:field-keys
{:to :User,
:has-many :accesses,
:has-many-aggr :accesses_aggregate,
:has-one :user}},
:group_id
{:field-keys
{:to :Group,
:has-many :accesses,
:has-many-aggr :accesses_aggregate,
:has-one :group}}},
:lcn-mut-keys
{:create :createAccess,
:update :updateAccess,
:delete :deleteAccess},
:roles
{:lcn-fields
{:rsc
{:id {:type Int},
:group_id {:type Int},
:title {:type String},
:color {:type String}},
:clauses
{:and {:type (list :RoleClauses)},
:or {:type (list :RoleClauses)},
:id {:type :IntWhere},
:group_id {:type :IntWhere},
:title {:type :StrWhere},
:color {:type :StrWhere}},
:sort
{:id {:type :SortOperator},
:group_id {:type :SortOperator},
:title {:type :SortOperator},
:color {:type :SortOperator}},
:fields
{:id {:type Int},
:group_id {:type Int},
:title {:type String},
:color {:type String}},
:aggregate
{:count {:type Int},
:sum {:type :RoleFields},
:avg {:type :RoleFields},
:max {:type :RoleFields},
:min {:type :RoleFields}},
:pks {:id {:type (non-null Int)}},
:pk-input {:id {:type (non-null Int)}},
:update
{:group_id {:type Int},
:title {:type String},
:color {:type String}}},
:fks
{:group_id
{:field-keys
{:to :Group,
:has-many :roles,
:has-many-aggr :roles_aggregate,
:has-one :group}}},
:lcn-mut-keys
{:create :createRole,
:update :updateRole,
:delete :deleteRole},
:lcn-obj-keys
{:rsc :Role,
:clauses :RoleClauses,
:where :RoleWhere,
:sort :RoleSort,
:fields :RoleFields,
:aggregate :RoleAggregate,
:pks :RolePks,
:pk-input :RolePkColumns},
:lcn-qry-keys {:queries :roles, :aggregate :roles_aggregate},
:lcn-descs
{:rsc "Roles",
:query "Query Roles.",
:clauses
"Format for where clauses is {column: {operator: value}}. Multiple parameters are applied with `AND` operators. `AND`/`OR` conditions can be created as a list of clauses. It is possible to nest them to create sub groups of conditions.",
:sort "Sort format is {column: \"asc\" or \"desc\"}.",
:fields "Rolesfields for aggregation.",
:aggregate "Aggrecate Roles.",
:pks "Primary key fields.",
:pk-input "Primary key fields."},
:groups
{:lcn-fields
{:rsc
{:access {:type Int},
:created_at {:type String},
:edited_at {:type String},
:id {:type Int},
:title {:type String},
:user_id {:type String},
:description {:type String}},
:clauses
{:description {:type :StrWhere},
:or {:type (list :GroupClauses)},
:title {:type :StrWhere},
:id {:type :IntWhere},
:and {:type (list :GroupClauses)},
:user_id {:type :StrWhere},
:access {:type :IntWhere},
:edited_at {:type :StrWhere},
:created_at {:type :StrWhere}},
:sort
{:access {:type :SortOperator},
:created_at {:type :SortOperator},
:edited_at {:type :SortOperator},
:id {:type :SortOperator},
:title {:type :SortOperator},
:user_id {:type :SortOperator},
:description {:type :SortOperator}},
:fields
{:access {:type Int},
:created_at {:type String},
:edited_at {:type String},
:id {:type Int},
:title {:type String},
:user_id {:type String},
:description {:type String}},
:aggregate
{:count {:type Int},
:sum {:type :GroupFields},
:avg {:type :GroupFields},
:max {:type :GroupFields},
:min {:type :GroupFields}},
:pks {:id {:type (non-null Int)}},
:pk-input {:id {:type (non-null Int)}},
:update
{:access {:type Int},
:created_at {:type String},
:edited_at {:type String},
:title {:type String},
:user_id {:type String},
:description {:type String}}},
:fks
{:access
{:field-keys
{:to :Access,
:has-many :groups,
:has-many-aggr :groups_aggregate,
:has-one :access_access}},
:user_id
{:field-keys
{:to :User,
:has-many :groups,
:has-many-aggr :groups_aggregate,
:has-one :user}}},
:lcn-mut-keys
{:create :createGroup,
:update :updateGroup,
:delete :deleteGroup},
:lcn-obj-keys
{:rsc :Group,
:clauses :GroupClauses,
:where :GroupWhere,
:sort :GroupSort,
:fields :GroupFields,
:aggregate :GroupAggregate,
:pks :GroupPks,
:pk-input :GroupPkColumns},
:lcn-qry-keys
{:queries :groups, :aggregate :groups_aggregate},
:lcn-descs
{:rsc "Groups",
:query "Query Groups.",
:clauses
"Format for where clauses is {column: {operator: value}}. Multiple parameters are applied with `AND` operators. `AND`/`OR` conditions can be created as a list of clauses. It is possible to nest them to create sub groups of conditions.",
:sort "Sort format is {column: \"asc\" or \"desc\"}.",
:fields "Groupsfields for aggregation.",
:aggregate "Aggrecate Groups.",
:pks "Primary key fields.",
:pk-input "Primary key fields."},
:signals
{:query {:pre (), :post ()},
:create {:pre (), :post ()},
:delete {:pre (), :post ()},
:update {:pre (), :post ()}},
:pk-keys (:id),
:col-keys
#{:description
:title
:id
:user_id
:access
:edited_at
:created_at}},
:signals
{:query {:pre (), :post ()},
:create {:pre (), :post ()},
:delete {:pre (), :post ()},
:update {:pre (), :post ()}},
:pk-keys (:id),
:col-keys #{:color :title :group_id :id}},
:lcn-obj-keys
{:rsc :Access,
:clauses :AccessClauses,
:where :AccessWhere,
:sort :AccessSort,
:fields :AccessFields,
:aggregate :AccessAggregate,
:pks :AccessPks,
:pk-input :AccessPkColumns},
:lcn-qry-keys
{:queries :accesses, :aggregate :accesses_aggregate},
:lcn-descs
{:rsc "Accesses",
:query "Query Accesses.",
:clauses
"Format for where clauses is {column: {operator: value}}. Multiple parameters are applied with `AND` operators. `AND`/`OR` conditions can be created as a list of clauses. It is possible to nest them to create sub groups of conditions.",
:sort "Sort format is {column: \"asc\" or \"desc\"}.",
:fields "Accessesfields for aggregation.",
:aggregate "Aggrecate Accesses.",
:pks "Primary key fields.",
:pk-input "Primary key fields."},
:groups
{:lcn-fields
{:rsc
{:access {:type Int},
:created_at {:type String},
:edited_at {:type String},
:id {:type Int},
:title {:type String},
:user_id {:type String},
:description {:type String}},
:clauses
{:description {:type :StrWhere},
:or {:type (list :GroupClauses)},
:title {:type :StrWhere},
:id {:type :IntWhere},
:and {:type (list :GroupClauses)},
:user_id {:type :StrWhere},
:access {:type :IntWhere},
:edited_at {:type :StrWhere},
:created_at {:type :StrWhere}},
:sort
{:access {:type :SortOperator},
:created_at {:type :SortOperator},
:edited_at {:type :SortOperator},
:id {:type :SortOperator},
:title {:type :SortOperator},
:user_id {:type :SortOperator},
:description {:type :SortOperator}},
:fields
{:access {:type Int},
:created_at {:type String},
:edited_at {:type String},
:id {:type Int},
:title {:type String},
:user_id {:type String},
:description {:type String}},
:aggregate
{:count {:type Int},
:sum {:type :GroupFields},
:avg {:type :GroupFields},
:max {:type :GroupFields},
:min {:type :GroupFields}},
:pks {:id {:type (non-null Int)}},
:pk-input {:id {:type (non-null Int)}},
:update
{:access {:type Int},
:created_at {:type String},
:edited_at {:type String},
:title {:type String},
:user_id {:type String},
:description {:type String}}},
:fks
{:access
{:field-keys
{:to :Access,
:has-many :groups,
:has-many-aggr :groups_aggregate,
:has-one :access_access}},
:user_id
{:field-keys
{:to :User,
:has-many :groups,
:has-many-aggr :groups_aggregate,
:has-one :user}}},
:lcn-mut-keys
{:create :createGroup,
:update :updateGroup,
:delete :deleteGroup},
:lcn-obj-keys
{:rsc :Group,
:clauses :GroupClauses,
:where :GroupWhere,
:sort :GroupSort,
:fields :GroupFields,
:aggregate :GroupAggregate,
:pks :GroupPks,
:pk-input :GroupPkColumns},
:lcn-qry-keys {:queries :groups, :aggregate :groups_aggregate},
:lcn-descs
{:rsc "Groups",
:query "Query Groups.",
:clauses
"Format for where clauses is {column: {operator: value}}. Multiple parameters are applied with `AND` operators. `AND`/`OR` conditions can be created as a list of clauses. It is possible to nest them to create sub groups of conditions.",
:sort "Sort format is {column: \"asc\" or \"desc\"}.",
:fields "Groupsfields for aggregation.",
:aggregate "Aggrecate Groups.",
:pks "Primary key fields.",
:pk-input "Primary key fields."},
:signals
{:query {:pre (), :post ()},
:create {:pre (), :post ()},
:delete {:pre (), :post ()},
:update {:pre (), :post ()}},
:pk-keys (:id),
:col-keys
#{:description
:title
:id
:user_id
:access
:edited_at
:created_at}},
:signals
{:query {:pre (), :post ()},
:create {:pre (), :post ()},
:delete {:pre (), :post ()},
:update {:pre (), :post ()}},
:pk-keys (:id),
:col-keys
#{:can_read
:inherit
:can_edit
:group_id
:id
:user_id
:role_id
:next_access
:owner}},
:groups
{:lcn-fields
{:rsc
{:access {:type Int},
:created_at {:type String},
:edited_at {:type String},
:id {:type Int},
:title {:type String},
:user_id {:type String},
:description {:type String}},
:clauses
{:description {:type :StrWhere},
:or {:type (list :GroupClauses)},
:title {:type :StrWhere},
:id {:type :IntWhere},
:and {:type (list :GroupClauses)},
:user_id {:type :StrWhere},
:access {:type :IntWhere},
:edited_at {:type :StrWhere},
:created_at {:type :StrWhere}},
:sort
{:access {:type :SortOperator},
:created_at {:type :SortOperator},
:edited_at {:type :SortOperator},
:id {:type :SortOperator},
:title {:type :SortOperator},
:user_id {:type :SortOperator},
:description {:type :SortOperator}},
:fields
{:access {:type Int},
:created_at {:type String},
:edited_at {:type String},
:id {:type Int},
:title {:type String},
:user_id {:type String},
:description {:type String}},
:aggregate
{:count {:type Int},
:sum {:type :GroupFields},
:avg {:type :GroupFields},
:max {:type :GroupFields},
:min {:type :GroupFields}},
:pks {:id {:type (non-null Int)}},
:pk-input {:id {:type (non-null Int)}},
:update
{:access {:type Int},
:created_at {:type String},
:edited_at {:type String},
:title {:type String},
:user_id {:type String},
:description {:type String}}},
:fks
{:access
{:field-keys
{:to :Access,
:has-many :groups,
:has-many-aggr :groups_aggregate,
:has-one :access_access}},
:user_id
{:field-keys
{:to :User,
:has-many :groups,
:has-many-aggr :groups_aggregate,
:has-one :user}}},
:lcn-mut-keys
{:create :createGroup,
:update :updateGroup,
:delete :deleteGroup},
:lcn-obj-keys
{:rsc :Group,
:clauses :GroupClauses,
:where :GroupWhere,
:sort :GroupSort,
:fields :GroupFields,
:aggregate :GroupAggregate,
:pks :GroupPks,
:pk-input :GroupPkColumns},
:lcn-qry-keys {:queries :groups, :aggregate :groups_aggregate},
:lcn-descs
{:rsc "Groups",
:query "Query Groups.",
:clauses
"Format for where clauses is {column: {operator: value}}. Multiple parameters are applied with `AND` operators. `AND`/`OR` conditions can be created as a list of clauses. It is possible to nest them to create sub groups of conditions.",
:sort "Sort format is {column: \"asc\" or \"desc\"}.",
:fields "Groupsfields for aggregation.",
:aggregate "Aggrecate Groups.",
:pks "Primary key fields.",
:pk-input "Primary key fields."},
:signals
{:query {:pre (), :post ()},
:create {:pre (), :post ()},
:delete {:pre (), :post ()},
:update {:pre (), :post ()}},
:pk-keys (:id),
:col-keys
#{:description
:title
:id
:user_id
:access
:edited_at
:created_at}},
:signals
{:query {:pre (), :post ()},
:create {:pre (), :post ()},
:delete {:pre (), :post ()},
:update {:pre (), :post ()}},
:pk-keys (:user_id :group_id :role_id),
:col-keys #{:group_id :user_id :role_id}}},
:signals
{:query {:pre (), :post ()},
:create {:pre (), :post ()},
:delete {:pre (), :post ()},
:update {:pre (), :post ()}},
:pk-keys (:id),
:col-keys
#{:attribute_name
:description
:udt_schema
:collation_schema
:numeric_scale
:character_set_schema
:dtd_identifier
:maximum_cardinality
:is_derived_reference_attribute
:character_octet_length
:datetime_precision
:scope_catalog
:collation_catalog
:character_maximum_length
:is_nullable
:character_set_catalog
:numeric_precision
:interval_type
:udt_catalog
:title
:scope_schema
:attribute_default
:numeric_precision_radix
:interval_precision
:character_set_name
:attribute_udt_catalog
:id
:collation_name
:data_type
:attribute_udt_schema
:access
:edited_at
:scope_name
:udt_name
:created_at
:ordinal_position
:attribute_udt_name},
:users_in_groups
{:lcn-fields
{:rsc
{:group_id {:type Int},
:role_id {:type Int},
:user_id {:type String}},
:clauses
{:and {:type (list :UsersInGroupClauses)},
:or {:type (list :UsersInGroupClauses)},
:group_id {:type :IntWhere},
:role_id {:type :IntWhere},
:user_id {:type :StrWhere}},
:sort
{:group_id {:type :SortOperator},
:role_id {:type :SortOperator},
:user_id {:type :SortOperator}},
:fields
{:group_id {:type Int},
:role_id {:type Int},
:user_id {:type String}},
:aggregate
{:count {:type Int},
:sum {:type :UsersInGroupFields},
:avg {:type :UsersInGroupFields},
:max {:type :UsersInGroupFields},
:min {:type :UsersInGroupFields}},
:pks
{:user_id {:type (non-null String)},
:group_id {:type (non-null Int)},
:role_id {:type (non-null Int)}},
:pk-input
{:user_id {:type (non-null String)},
:group_id {:type (non-null Int)},
:role_id {:type (non-null Int)}},
:update {}},
:fks
{:user_id
{:field-keys
{:to :User,
:has-many :users_in_groups,
:has-many-aggr :users_in_groups_aggregate,
:has-one :user}},
:group_id
{:field-keys
{:to :Group,
:has-many :users_in_groups,
:has-many-aggr :users_in_groups_aggregate,
:has-one :group}},
:role_id
{:field-keys
{:to :Role,
:has-many :users_in_groups,
:has-many-aggr :users_in_groups_aggregate,
:has-one :role}}},
:lcn-mut-keys
{:create :createUsersInGroup,
:update :updateUsersInGroup,
:delete :deleteUsersInGroup},
:roles
{:lcn-fields
{:rsc
{:id {:type Int},
:group_id {:type Int},
:title {:type String},
:color {:type String}},
:clauses
{:and {:type (list :RoleClauses)},
:or {:type (list :RoleClauses)},
:id {:type :IntWhere},
:group_id {:type :IntWhere},
:title {:type :StrWhere},
:color {:type :StrWhere}},
:sort
{:id {:type :SortOperator},
:group_id {:type :SortOperator},
:title {:type :SortOperator},
:color {:type :SortOperator}},
:fields
{:id {:type Int},
:group_id {:type Int},
:title {:type String},
:color {:type String}},
:aggregate
{:count {:type Int},
:sum {:type :RoleFields},
:avg {:type :RoleFields},
:max {:type :RoleFields},
:min {:type :RoleFields}},
:pks {:id {:type (non-null Int)}},
:pk-input {:id {:type (non-null Int)}},
:update
{:group_id {:type Int},
:title {:type String},
:color {:type String}}},
:fks
{:group_id
{:field-keys
{:to :Group,
:has-many :roles,
:has-many-aggr :roles_aggregate,
:has-one :group}}},
:lcn-mut-keys
{:create :createRole, :update :updateRole, :delete :deleteRole},
:lcn-obj-keys
{:rsc :Role,
:clauses :RoleClauses,
:where :RoleWhere,
:sort :RoleSort,
:fields :RoleFields,
:aggregate :RoleAggregate,
:pks :RolePks,
:pk-input :RolePkColumns},
:lcn-qry-keys {:queries :roles, :aggregate :roles_aggregate},
:lcn-descs
{:rsc "Roles",
:query "Query Roles.",
:clauses
"Format for where clauses is {column: {operator: value}}. Multiple parameters are applied with `AND` operators. `AND`/`OR` conditions can be created as a list of clauses. It is possible to nest them to create sub groups of conditions.",
:sort "Sort format is {column: \"asc\" or \"desc\"}.",
:fields "Rolesfields for aggregation.",
:aggregate "Aggrecate Roles.",
:pks "Primary key fields.",
:pk-input "Primary key fields."},
:groups
{:lcn-fields
{:rsc
{:access {:type Int},
:created_at {:type String},
:edited_at {:type String},
:id {:type Int},
:title {:type String},
:user_id {:type String},
:description {:type String}},
:clauses
{:description {:type :StrWhere},
:or {:type (list :GroupClauses)},
:title {:type :StrWhere},
:id {:type :IntWhere},
:and {:type (list :GroupClauses)},
:user_id {:type :StrWhere},
:access {:type :IntWhere},
:edited_at {:type :StrWhere},
:created_at {:type :StrWhere}},
:sort
{:access {:type :SortOperator},
:created_at {:type :SortOperator},
:edited_at {:type :SortOperator},
:id {:type :SortOperator},
:title {:type :SortOperator},
:user_id {:type :SortOperator},
:description {:type :SortOperator}},
:fields
{:access {:type Int},
:created_at {:type String},
:edited_at {:type String},
:id {:type Int},
:title {:type String},
:user_id {:type String},
:description {:type String}},
:aggregate
{:count {:type Int},
:sum {:type :GroupFields},
:avg {:type :GroupFields},
:max {:type :GroupFields},
:min {:type :GroupFields}},
:pks {:id {:type (non-null Int)}},
:pk-input {:id {:type (non-null Int)}},
:update
{:access {:type Int},
:created_at {:type String},
:edited_at {:type String},
:title {:type String},
:user_id {:type String},
:description {:type String}}},
:fks
{:access
{:field-keys
{:to :Access,
:has-many :groups,
:has-many-aggr :groups_aggregate,
:has-one :access_access}},
:user_id
{:field-keys
{:to :User,
:has-many :groups,
:has-many-aggr :groups_aggregate,
:has-one :user}}},
:lcn-mut-keys
{:create :createGroup,
:update :updateGroup,
:delete :deleteGroup},
:lcn-obj-keys
{:rsc :Group,
:clauses :GroupClauses,
:where :GroupWhere,
:sort :GroupSort,
:fields :GroupFields,
:aggregate :GroupAggregate,
:pks :GroupPks,
:pk-input :GroupPkColumns},
:lcn-qry-keys {:queries :groups, :aggregate :groups_aggregate},
:lcn-descs
{:rsc "Groups",
:query "Query Groups.",
:clauses
"Format for where clauses is {column: {operator: value}}. Multiple parameters are applied with `AND` operators. `AND`/`OR` conditions can be created as a list of clauses. It is possible to nest them to create sub groups of conditions.",
:sort "Sort format is {column: \"asc\" or \"desc\"}.",
:fields "Groupsfields for aggregation.",
:aggregate "Aggrecate Groups.",
:pks "Primary key fields.",
:pk-input "Primary key fields."},
:signals
{:query {:pre (), :post ()},
:create {:pre (), :post ()},
:delete {:pre (), :post ()},
:update {:pre (), :post ()}},
:pk-keys (:id),
:col-keys
#{:description
:title
:id
:user_id
:access
:edited_at
:created_at}},
:signals
{:query {:pre (), :post ()},
:create {:pre (), :post ()},
:delete {:pre (), :post ()},
:update {:pre (), :post ()}},
:pk-keys (:id),
:col-keys #{:color :title :group_id :id}},
:lcn-obj-keys
{:rsc :UsersInGroup,
:clauses :UsersInGroupClauses,
:where :UsersInGroupWhere,
:sort :UsersInGroupSort,
:fields :UsersInGroupFields,
:aggregate :UsersInGroupAggregate,
:pks :UsersInGroupPks,
:pk-input :UsersInGroupPkColumns},
:lcn-qry-keys
{:queries :users_in_groups,
:aggregate :users_in_groups_aggregate},
:lcn-descs
{:rsc "UsersInGroups",
:query "Query UsersInGroups.",
:clauses
"Format for where clauses is {column: {operator: value}}. Multiple parameters are applied with `AND` operators. `AND`/`OR` conditions can be created as a list of clauses. It is possible to nest them to create sub groups of conditions.",
:sort "Sort format is {column: \"asc\" or \"desc\"}.",
:fields "UsersInGroupsfields for aggregation.",
:aggregate "Aggrecate UsersInGroups.",
:pks "Primary key fields.",
:pk-input "Primary key fields."},
:access
{:lcn-fields
{:rsc
{:can_read {:type Boolean},
:inherit {:type Boolean},
:can_edit {:type Boolean},
:group_id {:type Int},
:id {:type Int},
:user_id {:type String},
:role_id {:type Int},
:next_access {:type Int},
:owner {:type Boolean}},
:clauses
{:can_read {:type :BoolWhere},
:inherit {:type :BoolWhere},
:can_edit {:type :BoolWhere},
:or {:type (list :AccessClauses)},
:group_id {:type :IntWhere},
:id {:type :IntWhere},
:and {:type (list :AccessClauses)},
:user_id {:type :StrWhere},
:role_id {:type :IntWhere},
:next_access {:type :IntWhere},
:owner {:type :BoolWhere}},
:sort
{:can_read {:type :SortOperator},
:inherit {:type :SortOperator},
:can_edit {:type :SortOperator},
:group_id {:type :SortOperator},
:id {:type :SortOperator},
:user_id {:type :SortOperator},
:role_id {:type :SortOperator},
:next_access {:type :SortOperator},
:owner {:type :SortOperator}},
:fields
{:can_read {:type Boolean},
:inherit {:type Boolean},
:can_edit {:type Boolean},
:group_id {:type Int},
:id {:type Int},
:user_id {:type String},
:role_id {:type Int},
:next_access {:type Int},
:owner {:type Boolean}},
:aggregate
{:count {:type Int},
:sum {:type :AccessFields},
:avg {:type :AccessFields},
:max {:type :AccessFields},
:min {:type :AccessFields}},
:pks {:id {:type (non-null Int)}},
:pk-input {:id {:type (non-null Int)}},
:update
{:can_read {:type Boolean},
:inherit {:type Boolean},
:can_edit {:type Boolean},
:group_id {:type Int},
:user_id {:type String},
:role_id {:type Int},
:next_access {:type Int},
:owner {:type Boolean}}},
:fks
{:next_access
{:field-keys
{:to :Access,
:has-many :accesses,
:has-many-aggr :accesses_aggregate,
:has-one :next_access_access}},
:role_id
{:field-keys
{:to :Role,
:has-many :accesses,
:has-many-aggr :accesses_aggregate,
:has-one :role}},
:user_id
{:field-keys
{:to :User,
:has-many :accesses,
:has-many-aggr :accesses_aggregate,
:has-one :user}},
:group_id
{:field-keys
{:to :Group,
:has-many :accesses,
:has-many-aggr :accesses_aggregate,
:has-one :group}}},
:lcn-mut-keys
{:create :createAccess,
:update :updateAccess,
:delete :deleteAccess},
:roles
{:lcn-fields
{:rsc
{:id {:type Int},
:group_id {:type Int},
:title {:type String},
:color {:type String}},
:clauses
{:and {:type (list :RoleClauses)},
:or {:type (list :RoleClauses)},
:id {:type :IntWhere},
:group_id {:type :IntWhere},
:title {:type :StrWhere},
:color {:type :StrWhere}},
:sort
{:id {:type :SortOperator},
:group_id {:type :SortOperator},
:title {:type :SortOperator},
:color {:type :SortOperator}},
:fields
{:id {:type Int},
:group_id {:type Int},
:title {:type String},
:color {:type String}},
:aggregate
{:count {:type Int},
:sum {:type :RoleFields},
:avg {:type :RoleFields},
:max {:type :RoleFields},
:min {:type :RoleFields}},
:pks {:id {:type (non-null Int)}},
:pk-input {:id {:type (non-null Int)}},
:update
{:group_id {:type Int},
:title {:type String},
:color {:type String}}},
:fks
{:group_id
{:field-keys
{:to :Group,
:has-many :roles,
:has-many-aggr :roles_aggregate,
:has-one :group}}},
:lcn-mut-keys
{:create :createRole, :update :updateRole, :delete :deleteRole},
:lcn-obj-keys
{:rsc :Role,
:clauses :RoleClauses,
:where :RoleWhere,
:sort :RoleSort,
:fields :RoleFields,
:aggregate :RoleAggregate,
:pks :RolePks,
:pk-input :RolePkColumns},
:lcn-qry-keys {:queries :roles, :aggregate :roles_aggregate},
:lcn-descs
{:rsc "Roles",
:query "Query Roles.",
:clauses
"Format for where clauses is {column: {operator: value}}. Multiple parameters are applied with `AND` operators. `AND`/`OR` conditions can be created as a list of clauses. It is possible to nest them to create sub groups of conditions.",
:sort "Sort format is {column: \"asc\" or \"desc\"}.",
:fields "Rolesfields for aggregation.",
:aggregate "Aggrecate Roles.",
:pks "Primary key fields.",
:pk-input "Primary key fields."},
:groups
{:lcn-fields
{:rsc
{:access {:type Int},
:created_at {:type String},
:edited_at {:type String},
:id {:type Int},
:title {:type String},
:user_id {:type String},
:description {:type String}},
:clauses
{:description {:type :StrWhere},
:or {:type (list :GroupClauses)},
:title {:type :StrWhere},
:id {:type :IntWhere},
:and {:type (list :GroupClauses)},
:user_id {:type :StrWhere},
:access {:type :IntWhere},
:edited_at {:type :StrWhere},
:created_at {:type :StrWhere}},
:sort
{:access {:type :SortOperator},
:created_at {:type :SortOperator},
:edited_at {:type :SortOperator},
:id {:type :SortOperator},
:title {:type :SortOperator},
:user_id {:type :SortOperator},
:description {:type :SortOperator}},
:fields
{:access {:type Int},
:created_at {:type String},
:edited_at {:type String},
:id {:type Int},
:title {:type String},
:user_id {:type String},
:description {:type String}},
:aggregate
{:count {:type Int},
:sum {:type :GroupFields},
:avg {:type :GroupFields},
:max {:type :GroupFields},
:min {:type :GroupFields}},
:pks {:id {:type (non-null Int)}},
:pk-input {:id {:type (non-null Int)}},
:update
{:access {:type Int},
:created_at {:type String},
:edited_at {:type String},
:title {:type String},
:user_id {:type String},
:description {:type String}}},
:fks
{:access
{:field-keys
{:to :Access,
:has-many :groups,
:has-many-aggr :groups_aggregate,
:has-one :access_access}},
:user_id
{:field-keys
{:to :User,
:has-many :groups,
:has-many-aggr :groups_aggregate,
:has-one :user}}},
:lcn-mut-keys
{:create :createGroup,
:update :updateGroup,
:delete :deleteGroup},
:lcn-obj-keys
{:rsc :Group,
:clauses :GroupClauses,
:where :GroupWhere,
:sort :GroupSort,
:fields :GroupFields,
:aggregate :GroupAggregate,
:pks :GroupPks,
:pk-input :GroupPkColumns},
:lcn-qry-keys {:queries :groups, :aggregate :groups_aggregate},
:lcn-descs
{:rsc "Groups",
:query "Query Groups.",
:clauses
"Format for where clauses is {column: {operator: value}}. Multiple parameters are applied with `AND` operators. `AND`/`OR` conditions can be created as a list of clauses. It is possible to nest them to create sub groups of conditions.",
:sort "Sort format is {column: \"asc\" or \"desc\"}.",
:fields "Groupsfields for aggregation.",
:aggregate "Aggrecate Groups.",
:pks "Primary key fields.",
:pk-input "Primary key fields."},
:signals
{:query {:pre (), :post ()},
:create {:pre (), :post ()},
:delete {:pre (), :post ()},
:update {:pre (), :post ()}},
:pk-keys (:id),
:col-keys
#{:description
:title
:id
:user_id
:access
:edited_at
:created_at}},
:signals
{:query {:pre (), :post ()},
:create {:pre (), :post ()},
:delete {:pre (), :post ()},
:update {:pre (), :post ()}},
:pk-keys (:id),
:col-keys #{:color :title :group_id :id}},
:lcn-obj-keys
{:rsc :Access,
:clauses :AccessClauses,
:where :AccessWhere,
:sort :AccessSort,
:fields :AccessFields,
:aggregate :AccessAggregate,
:pks :AccessPks,
:pk-input :AccessPkColumns},
:lcn-qry-keys
{:queries :accesses, :aggregate :accesses_aggregate},
:lcn-descs
{:rsc "Accesses",
:query "Query Accesses.",
:clauses
"Format for where clauses is {column: {operator: value}}. Multiple parameters are applied with `AND` operators. `AND`/`OR` conditions can be created as a list of clauses. It is possible to nest them to create sub groups of conditions.",
:sort "Sort format is {column: \"asc\" or \"desc\"}.",
:fields "Accessesfields for aggregation.",
:aggregate "Aggrecate Accesses.",
:pks "Primary key fields.",
:pk-input "Primary key fields."},
:groups
{:lcn-fields
{:rsc
{:access {:type Int},
:created_at {:type String},
:edited_at {:type String},
:id {:type Int},
:title {:type String},
:user_id {:type String},
:description {:type String}},
:clauses
{:description {:type :StrWhere},
:or {:type (list :GroupClauses)},
:title {:type :StrWhere},
:id {:type :IntWhere},
:and {:type (list :GroupClauses)},
:user_id {:type :StrWhere},
:access {:type :IntWhere},
:edited_at {:type :StrWhere},
:created_at {:type :StrWhere}},
:sort
{:access {:type :SortOperator},
:created_at {:type :SortOperator},
:edited_at {:type :SortOperator},
:id {:type :SortOperator},
:title {:type :SortOperator},
:user_id {:type :SortOperator},
:description {:type :SortOperator}},
:fields
{:access {:type Int},
:created_at {:type String},
:edited_at {:type String},
:id {:type Int},
:title {:type String},
:user_id {:type String},
:description {:type String}},
:aggregate
{:count {:type Int},
:sum {:type :GroupFields},
:avg {:type :GroupFields},
:max {:type :GroupFields},
:min {:type :GroupFields}},
:pks {:id {:type (non-null Int)}},
:pk-input {:id {:type (non-null Int)}},
:update
{:access {:type Int},
:created_at {:type String},
:edited_at {:type String},
:title {:type String},
:user_id {:type String},
:description {:type String}}},
:fks
{:access
{:field-keys
{:to :Access,
:has-many :groups,
:has-many-aggr :groups_aggregate,
:has-one :access_access}},
:user_id
{:field-keys
{:to :User,
:has-many :groups,
:has-many-aggr :groups_aggregate,
:has-one :user}}},
:lcn-mut-keys
{:create :createGroup,
:update :updateGroup,
:delete :deleteGroup},
:lcn-obj-keys
{:rsc :Group,
:clauses :GroupClauses,
:where :GroupWhere,
:sort :GroupSort,
:fields :GroupFields,
:aggregate :GroupAggregate,
:pks :GroupPks,
:pk-input :GroupPkColumns},
:lcn-qry-keys {:queries :groups, :aggregate :groups_aggregate},
:lcn-descs
{:rsc "Groups",
:query "Query Groups.",
:clauses
"Format for where clauses is {column: {operator: value}}. Multiple parameters are applied with `AND` operators. `AND`/`OR` conditions can be created as a list of clauses. It is possible to nest them to create sub groups of conditions.",
:sort "Sort format is {column: \"asc\" or \"desc\"}.",
:fields "Groupsfields for aggregation.",
:aggregate "Aggrecate Groups.",
:pks "Primary key fields.",
:pk-input "Primary key fields."},
:signals
{:query {:pre (), :post ()},
:create {:pre (), :post ()},
:delete {:pre (), :post ()},
:update {:pre (), :post ()}},
:pk-keys (:id),
:col-keys
#{:description
:title
:id
:user_id
:access
:edited_at
:created_at}},
:signals
{:query {:pre (), :post ()},
:create {:pre (), :post ()},
:delete {:pre (), :post ()},
:update {:pre (), :post ()}},
:pk-keys (:id),
:col-keys
#{:can_read
:inherit
:can_edit
:group_id
:id
:user_id
:role_id
:next_access
:owner}},
:groups
{:lcn-fields
{:rsc
{:access {:type Int},
:created_at {:type String},
:edited_at {:type String},
:id {:type Int},
:title {:type String},
:user_id {:type String},
:description {:type String}},
:clauses
{:description {:type :StrWhere},
:or {:type (list :GroupClauses)},
:title {:type :StrWhere},
:id {:type :IntWhere},
:and {:type (list :GroupClauses)},
:user_id {:type :StrWhere},
:access {:type :IntWhere},
:edited_at {:type :StrWhere},
:created_at {:type :StrWhere}},
:sort
{:access {:type :SortOperator},
:created_at {:type :SortOperator},
:edited_at {:type :SortOperator},
:id {:type :SortOperator},
:title {:type :SortOperator},
:user_id {:type :SortOperator},
:description {:type :SortOperator}},
:fields
{:access {:type Int},
:created_at {:type String},
:edited_at {:type String},
:id {:type Int},
:title {:type String},
:user_id {:type String},
:description {:type String}},
:aggregate
{:count {:type Int},
:sum {:type :GroupFields},
:avg {:type :GroupFields},
:max {:type :GroupFields},
:min {:type :GroupFields}},
:pks {:id {:type (non-null Int)}},
:pk-input {:id {:type (non-null Int)}},
:update
{:access {:type Int},
:created_at {:type String},
:edited_at {:type String},
:title {:type String},
:user_id {:type String},
:description {:type String}}},
:fks
{:access
{:field-keys
{:to :Access,
:has-many :groups,
:has-many-aggr :groups_aggregate,
:has-one :access_access}},
:user_id
{:field-keys
{:to :User,
:has-many :groups,
:has-many-aggr :groups_aggregate,
:has-one :user}}},
:lcn-mut-keys
{:create :createGroup,
:update :updateGroup,
:delete :deleteGroup},
:lcn-obj-keys
{:rsc :Group,
:clauses :GroupClauses,
:where :GroupWhere,
:sort :GroupSort,
:fields :GroupFields,
:aggregate :GroupAggregate,
:pks :GroupPks,
:pk-input :GroupPkColumns},
:lcn-qry-keys {:queries :groups, :aggregate :groups_aggregate},
:lcn-descs
{:rsc "Groups",
:query "Query Groups.",
:clauses
"Format for where clauses is {column: {operator: value}}. Multiple parameters are applied with `AND` operators. `AND`/`OR` conditions can be created as a list of clauses. It is possible to nest them to create sub groups of conditions.",
:sort "Sort format is {column: \"asc\" or \"desc\"}.",
:fields "Groupsfields for aggregation.",
:aggregate "Aggrecate Groups.",
:pks "Primary key fields.",
:pk-input "Primary key fields."},
:signals
{:query {:pre (), :post ()},
:create {:pre (), :post ()},
:delete {:pre (), :post ()},
:update {:pre (), :post ()}},
:pk-keys (:id),
:col-keys
#{:description
:title
:id
:user_id
:access
:edited_at
:created_at}},
:signals
{:query {:pre (), :post ()},
:create {:pre (), :post ()},
:delete {:pre (), :post ()},
:update {:pre (), :post ()}},
:pk-keys (:user_id :group_id :role_id),
:col-keys #{:group_id :user_id :role_id}}},
:votes
{:lcn-fields
{:rsc
{:attribute {:type Int},
:magnitude {:type Int},
:domain_pk_namespace {:type String},
:id {:type Int},
:access {:type Int},
:edited_at {:type String},
:right_item_id {:type Int},
:created_at {:type String},
:left_item_id {:type Int}},
:clauses
{:attribute {:type :IntWhere},
:or {:type (list :VoteClauses)},
:magnitude {:type :IntWhere},
:domain_pk_namespace {:type :StrWhere},
:id {:type :IntWhere},
:and {:type (list :VoteClauses)},
:access {:type :IntWhere},
:edited_at {:type :StrWhere},
:right_item_id {:type :IntWhere},
:created_at {:type :StrWhere},
:left_item_id {:type :IntWhere}},
:sort
{:attribute {:type :SortOperator},
:magnitude {:type :SortOperator},
:domain_pk_namespace {:type :SortOperator},
:id {:type :SortOperator},
:access {:type :SortOperator},
:edited_at {:type :SortOperator},
:right_item_id {:type :SortOperator},
:created_at {:type :SortOperator},
:left_item_id {:type :SortOperator}},
:fields
{:attribute {:type Int},
:magnitude {:type Int},
:domain_pk_namespace {:type String},
:id {:type Int},
:access {:type Int},
:edited_at {:type String},
:right_item_id {:type Int},
:created_at {:type String},
:left_item_id {:type Int}},
:aggregate
{:count {:type Int},
:sum {:type :VoteFields},
:avg {:type :VoteFields},
:max {:type :VoteFields},
:min {:type :VoteFields}},
:pks {:id {:type (non-null Int)}},
:pk-input {:id {:type (non-null Int)}},
:update
{:attribute {:type Int},
:magnitude {:type Int},
:domain_pk_namespace {:type String},
:access {:type Int},
:edited_at {:type String},
:right_item_id {:type Int},
:created_at {:type String},
:left_item_id {:type Int}}},
:fks
{:access
{:field-keys
{:to :Access,
:has-many :votes,
:has-many-aggr :votes_aggregate,
:has-one :access_access}},
:left_item_id
{:field-keys
{:to :Item,
:has-many :votes_on_left_item_id,
:has-many-aggr :votes_on_left_item_id_aggregate,
:has-one :left_item}},
:right_item_id
{:field-keys
{:to :Item,
:has-many :votes_on_right_item_id,
:has-many-aggr :votes_on_right_item_id_aggregate,
:has-one :right_item}},
:attribute
{:field-keys
{:to :Attribute,
:has-many :votes,
:has-many-aggr :votes_aggregate,
:has-one :attribute_attribute}}},
:lcn-mut-keys
{:create :createVote, :update :updateVote, :delete :deleteVote},
:roles
{:lcn-fields
{:rsc
{:id {:type Int},
:group_id {:type Int},
:title {:type String},
:color {:type String}},
:clauses
{:and {:type (list :RoleClauses)},
:or {:type (list :RoleClauses)},
:id {:type :IntWhere},
:group_id {:type :IntWhere},
:title {:type :StrWhere},
:color {:type :StrWhere}},
:sort
{:id {:type :SortOperator},
:group_id {:type :SortOperator},
:title {:type :SortOperator},
:color {:type :SortOperator}},
:fields
{:id {:type Int},
:group_id {:type Int},
:title {:type String},
:color {:type String}},
:aggregate
{:count {:type Int},
:sum {:type :RoleFields},
:avg {:type :RoleFields},
:max {:type :RoleFields},
:min {:type :RoleFields}},
:pks {:id {:type (non-null Int)}},
:pk-input {:id {:type (non-null Int)}},
:update
{:group_id {:type Int},
:title {:type String},
:color {:type String}}},
:fks
{:group_id
{:field-keys
{:to :Group,
:has-many :roles,
:has-many-aggr :roles_aggregate,
:has-one :group}}},
:lcn-mut-keys
{:create :createRole, :update :updateRole, :delete :deleteRole},
:lcn-obj-keys
{:rsc :Role,
:clauses :RoleClauses,
:where :RoleWhere,
:sort :RoleSort,
:fields :RoleFields,
:aggregate :RoleAggregate,
:pks :RolePks,
:pk-input :RolePkColumns},
:lcn-qry-keys {:queries :roles, :aggregate :roles_aggregate},
:lcn-descs
{:rsc "Roles",
:query "Query Roles.",
:clauses
"Format for where clauses is {column: {operator: value}}. Multiple parameters are applied with `AND` operators. `AND`/`OR` conditions can be created as a list of clauses. It is possible to nest them to create sub groups of conditions.",
:sort "Sort format is {column: \"asc\" or \"desc\"}.",
:fields "Rolesfields for aggregation.",
:aggregate "Aggrecate Roles.",
:pks "Primary key fields.",
:pk-input "Primary key fields."},
:groups
{:lcn-fields
{:rsc
{:access {:type Int},
:created_at {:type String},
:edited_at {:type String},
:id {:type Int},
:title {:type String},
:user_id {:type String},
:description {:type String}},
:clauses
{:description {:type :StrWhere},
:or {:type (list :GroupClauses)},
:title {:type :StrWhere},
:id {:type :IntWhere},
:and {:type (list :GroupClauses)},
:user_id {:type :StrWhere},
:access {:type :IntWhere},
:edited_at {:type :StrWhere},
:created_at {:type :StrWhere}},
:sort
{:access {:type :SortOperator},
:created_at {:type :SortOperator},
:edited_at {:type :SortOperator},
:id {:type :SortOperator},
:title {:type :SortOperator},
:user_id {:type :SortOperator},
:description {:type :SortOperator}},
:fields
{:access {:type Int},
:created_at {:type String},
:edited_at {:type String},
:id {:type Int},
:title {:type String},
:user_id {:type String},
:description {:type String}},
:aggregate
{:count {:type Int},
:sum {:type :GroupFields},
:avg {:type :GroupFields},
:max {:type :GroupFields},
:min {:type :GroupFields}},
:pks {:id {:type (non-null Int)}},
:pk-input {:id {:type (non-null Int)}},
:update
{:access {:type Int},
:created_at {:type String},
:edited_at {:type String},
:title {:type String},
:user_id {:type String},
:description {:type String}}},
:fks
{:access
{:field-keys
{:to :Access,
:has-many :groups,
:has-many-aggr :groups_aggregate,
:has-one :access_access}},
:user_id
{:field-keys
{:to :User,
:has-many :groups,
:has-many-aggr :groups_aggregate,
:has-one :user}}},
:lcn-mut-keys
{:create :createGroup,
:update :updateGroup,
:delete :deleteGroup},
:lcn-obj-keys
{:rsc :Group,
:clauses :GroupClauses,
:where :GroupWhere,
:sort :GroupSort,
:fields :GroupFields,
:aggregate :GroupAggregate,
:pks :GroupPks,
:pk-input :GroupPkColumns},
:lcn-qry-keys {:queries :groups, :aggregate :groups_aggregate},
:lcn-descs
{:rsc "Groups",
:query "Query Groups.",
:clauses
"Format for where clauses is {column: {operator: value}}. Multiple parameters are applied with `AND` operators. `AND`/`OR` conditions can be created as a list of clauses. It is possible to nest them to create sub groups of conditions.",
:sort "Sort format is {column: \"asc\" or \"desc\"}.",
:fields "Groupsfields for aggregation.",
:aggregate "Aggrecate Groups.",
:pks "Primary key fields.",
:pk-input "Primary key fields."},
:signals
{:query {:pre (), :post ()},
:create {:pre (), :post ()},
:delete {:pre (), :post ()},
:update {:pre (), :post ()}},
:pk-keys (:id),
:col-keys
#{:description
:title
:id
:user_id
:access
:edited_at
:created_at}},
:signals
{:query {:pre (), :post ()},
:create {:pre (), :post ()},
:delete {:pre (), :post ()},
:update {:pre (), :post ()}},
:pk-keys (:id),
:col-keys #{:color :title :group_id :id}},
:lcn-obj-keys
{:rsc :Vote,
:clauses :VoteClauses,
:where :VoteWhere,
:sort :VoteSort,
:fields :VoteFields,
:aggregate :VoteAggregate,
:pks :VotePks,
:pk-input :VotePkColumns},
:lcn-qry-keys {:queries :votes, :aggregate :votes_aggregate},
:lcn-descs
{:rsc "Votes",
:query "Query Votes.",
:clauses
"Format for where clauses is {column: {operator: value}}. Multiple parameters are applied with `AND` operators. `AND`/`OR` conditions can be created as a list of clauses. It is possible to nest them to create sub groups of conditions.",
:sort "Sort format is {column: \"asc\" or \"desc\"}.",
:fields "Votesfields for aggregation.",
:aggregate "Aggrecate Votes.",
:pks "Primary key fields.",
:pk-input "Primary key fields."},
:access
{:lcn-fields
{:rsc
{:can_read {:type Boolean},
:inherit {:type Boolean},
:can_edit {:type Boolean},
:group_id {:type Int},
:id {:type Int},
:user_id {:type String},
:role_id {:type Int},
:next_access {:type Int},
:owner {:type Boolean}},
:clauses
{:can_read {:type :BoolWhere},
:inherit {:type :BoolWhere},
:can_edit {:type :BoolWhere},
:or {:type (list :AccessClauses)},
:group_id {:type :IntWhere},
:id {:type :IntWhere},
:and {:type (list :AccessClauses)},
:user_id {:type :StrWhere},
:role_id {:type :IntWhere},
:next_access {:type :IntWhere},
:owner {:type :BoolWhere}},
:sort
{:can_read {:type :SortOperator},
:inherit {:type :SortOperator},
:can_edit {:type :SortOperator},
:group_id {:type :SortOperator},
:id {:type :SortOperator},
:user_id {:type :SortOperator},
:role_id {:type :SortOperator},
:next_access {:type :SortOperator},
:owner {:type :SortOperator}},
:fields
{:can_read {:type Boolean},
:inherit {:type Boolean},
:can_edit {:type Boolean},
:group_id {:type Int},
:id {:type Int},
:user_id {:type String},
:role_id {:type Int},
:next_access {:type Int},
:owner {:type Boolean}},
:aggregate
{:count {:type Int},
:sum {:type :AccessFields},
:avg {:type :AccessFields},
:max {:type :AccessFields},
:min {:type :AccessFields}},
:pks {:id {:type (non-null Int)}},
:pk-input {:id {:type (non-null Int)}},
:update
{:can_read {:type Boolean},
:inherit {:type Boolean},
:can_edit {:type Boolean},
:group_id {:type Int},
:user_id {:type String},
:role_id {:type Int},
:next_access {:type Int},
:owner {:type Boolean}}},
:fks
{:next_access
{:field-keys
{:to :Access,
:has-many :accesses,
:has-many-aggr :accesses_aggregate,
:has-one :next_access_access}},
:role_id
{:field-keys
{:to :Role,
:has-many :accesses,
:has-many-aggr :accesses_aggregate,
:has-one :role}},
:user_id
{:field-keys
{:to :User,
:has-many :accesses,
:has-many-aggr :accesses_aggregate,
:has-one :user}},
:group_id
{:field-keys
{:to :Group,
:has-many :accesses,
:has-many-aggr :accesses_aggregate,
:has-one :group}}},
:lcn-mut-keys
{:create :createAccess,
:update :updateAccess,
:delete :deleteAccess},
:roles
{:lcn-fields
{:rsc
{:id {:type Int},
:group_id {:type Int},
:title {:type String},
:color {:type String}},
:clauses
{:and {:type (list :RoleClauses)},
:or {:type (list :RoleClauses)},
:id {:type :IntWhere},
:group_id {:type :IntWhere},
:title {:type :StrWhere},
:color {:type :StrWhere}},
:sort
{:id {:type :SortOperator},
:group_id {:type :SortOperator},
:title {:type :SortOperator},
:color {:type :SortOperator}},
:fields
{:id {:type Int},
:group_id {:type Int},
:title {:type String},
:color {:type String}},
:aggregate
{:count {:type Int},
:sum {:type :RoleFields},
:avg {:type :RoleFields},
:max {:type :RoleFields},
:min {:type :RoleFields}},
:pks {:id {:type (non-null Int)}},
:pk-input {:id {:type (non-null Int)}},
:update
{:group_id {:type Int},
:title {:type String},
:color {:type String}}},
:fks
{:group_id
{:field-keys
{:to :Group,
:has-many :roles,
:has-many-aggr :roles_aggregate,
:has-one :group}}},
:lcn-mut-keys
{:create :createRole, :update :updateRole, :delete :deleteRole},
:lcn-obj-keys
{:rsc :Role,
:clauses :RoleClauses,
:where :RoleWhere,
:sort :RoleSort,
:fields :RoleFields,
:aggregate :RoleAggregate,
:pks :RolePks,
:pk-input :RolePkColumns},
:lcn-qry-keys {:queries :roles, :aggregate :roles_aggregate},
:lcn-descs
{:rsc "Roles",
:query "Query Roles.",
:clauses
"Format for where clauses is {column: {operator: value}}. Multiple parameters are applied with `AND` operators. `AND`/`OR` conditions can be created as a list of clauses. It is possible to nest them to create sub groups of conditions.",
:sort "Sort format is {column: \"asc\" or \"desc\"}.",
:fields "Rolesfields for aggregation.",
:aggregate "Aggrecate Roles.",
:pks "Primary key fields.",
:pk-input "Primary key fields."},
:groups
{:lcn-fields
{:rsc
{:access {:type Int},
:created_at {:type String},
:edited_at {:type String},
:id {:type Int},
:title {:type String},
:user_id {:type String},
:description {:type String}},
:clauses
{:description {:type :StrWhere},
:or {:type (list :GroupClauses)},
:title {:type :StrWhere},
:id {:type :IntWhere},
:and {:type (list :GroupClauses)},
:user_id {:type :StrWhere},
:access {:type :IntWhere},
:edited_at {:type :StrWhere},
:created_at {:type :StrWhere}},
:sort
{:access {:type :SortOperator},
:created_at {:type :SortOperator},
:edited_at {:type :SortOperator},
:id {:type :SortOperator},
:title {:type :SortOperator},
:user_id {:type :SortOperator},
:description {:type :SortOperator}},
:fields
{:access {:type Int},
:created_at {:type String},
:edited_at {:type String},
:id {:type Int},
:title {:type String},
:user_id {:type String},
:description {:type String}},
:aggregate
{:count {:type Int},
:sum {:type :GroupFields},
:avg {:type :GroupFields},
:max {:type :GroupFields},
:min {:type :GroupFields}},
:pks {:id {:type (non-null Int)}},
:pk-input {:id {:type (non-null Int)}},
:update
{:access {:type Int},
:created_at {:type String},
:edited_at {:type String},
:title {:type String},
:user_id {:type String},
:description {:type String}}},
:fks
{:access
{:field-keys
{:to :Access,
:has-many :groups,
:has-many-aggr :groups_aggregate,
:has-one :access_access}},
:user_id
{:field-keys
{:to :User,
:has-many :groups,
:has-many-aggr :groups_aggregate,
:has-one :user}}},
:lcn-mut-keys
{:create :createGroup,
:update :updateGroup,
:delete :deleteGroup},
:lcn-obj-keys
{:rsc :Group,
:clauses :GroupClauses,
:where :GroupWhere,
:sort :GroupSort,
:fields :GroupFields,
:aggregate :GroupAggregate,
:pks :GroupPks,
:pk-input :GroupPkColumns},
:lcn-qry-keys {:queries :groups, :aggregate :groups_aggregate},
:lcn-descs
{:rsc "Groups",
:query "Query Groups.",
:clauses
"Format for where clauses is {column: {operator: value}}. Multiple parameters are applied with `AND` operators. `AND`/`OR` conditions can be created as a list of clauses. It is possible to nest them to create sub groups of conditions.",
:sort "Sort format is {column: \"asc\" or \"desc\"}.",
:fields "Groupsfields for aggregation.",
:aggregate "Aggrecate Groups.",
:pks "Primary key fields.",
:pk-input "Primary key fields."},
:signals
{:query {:pre (), :post ()},
:create {:pre (), :post ()},
:delete {:pre (), :post ()},
:update {:pre (), :post ()}},
:pk-keys (:id),
:col-keys
#{:description
:title
:id
:user_id
:access
:edited_at
:created_at}},
:signals
{:query {:pre (), :post ()},
:create {:pre (), :post ()},
:delete {:pre (), :post ()},
:update {:pre (), :post ()}},
:pk-keys (:id),
:col-keys #{:color :title :group_id :id}},
:lcn-obj-keys
{:rsc :Access,
:clauses :AccessClauses,
:where :AccessWhere,
:sort :AccessSort,
:fields :AccessFields,
:aggregate :AccessAggregate,
:pks :AccessPks,
:pk-input :AccessPkColumns},
:lcn-qry-keys
{:queries :accesses, :aggregate :accesses_aggregate},
:lcn-descs
{:rsc "Accesses",
:query "Query Accesses.",
:clauses
"Format for where clauses is {column: {operator: value}}. Multiple parameters are applied with `AND` operators. `AND`/`OR` conditions can be created as a list of clauses. It is possible to nest them to create sub groups of conditions.",
:sort "Sort format is {column: \"asc\" or \"desc\"}.",
:fields "Accessesfields for aggregation.",
:aggregate "Aggrecate Accesses.",
:pks "Primary key fields.",
:pk-input "Primary key fields."},
:groups
{:lcn-fields
{:rsc
{:access {:type Int},
:created_at {:type String},
:edited_at {:type String},
:id {:type Int},
:title {:type String},
:user_id {:type String},
:description {:type String}},
:clauses
{:description {:type :StrWhere},
:or {:type (list :GroupClauses)},
:title {:type :StrWhere},
:id {:type :IntWhere},
:and {:type (list :GroupClauses)},
:user_id {:type :StrWhere},
:access {:type :IntWhere},
:edited_at {:type :StrWhere},
:created_at {:type :StrWhere}},
:sort
{:access {:type :SortOperator},
:created_at {:type :SortOperator},
:edited_at {:type :SortOperator},
:id {:type :SortOperator},
:title {:type :SortOperator},
:user_id {:type :SortOperator},
:description {:type :SortOperator}},
:fields
{:access {:type Int},
:created_at {:type String},
:edited_at {:type String},
:id {:type Int},
:title {:type String},
:user_id {:type String},
:description {:type String}},
:aggregate
{:count {:type Int},
:sum {:type :GroupFields},
:avg {:type :GroupFields},
:max {:type :GroupFields},
:min {:type :GroupFields}},
:pks {:id {:type (non-null Int)}},
:pk-input {:id {:type (non-null Int)}},
:update
{:access {:type Int},
:created_at {:type String},
:edited_at {:type String},
:title {:type String},
:user_id {:type String},
:description {:type String}}},
:fks
{:access
{:field-keys
{:to :Access,
:has-many :groups,
:has-many-aggr :groups_aggregate,
:has-one :access_access}},
:user_id
{:field-keys
{:to :User,
:has-many :groups,
:has-many-aggr :groups_aggregate,
:has-one :user}}},
:lcn-mut-keys
{:create :createGroup,
:update :updateGroup,
:delete :deleteGroup},
:lcn-obj-keys
{:rsc :Group,
:clauses :GroupClauses,
:where :GroupWhere,
:sort :GroupSort,
:fields :GroupFields,
:aggregate :GroupAggregate,
:pks :GroupPks,
:pk-input :GroupPkColumns},
:lcn-qry-keys {:queries :groups, :aggregate :groups_aggregate},
:lcn-descs
{:rsc "Groups",
:query "Query Groups.",
:clauses
"Format for where clauses is {column: {operator: value}}. Multiple parameters are applied with `AND` operators. `AND`/`OR` conditions can be created as a list of clauses. It is possible to nest them to create sub groups of conditions.",
:sort "Sort format is {column: \"asc\" or \"desc\"}.",
:fields "Groupsfields for aggregation.",
:aggregate "Aggrecate Groups.",
:pks "Primary key fields.",
:pk-input "Primary key fields."},
:signals
{:query {:pre (), :post ()},
:create {:pre (), :post ()},
:delete {:pre (), :post ()},
:update {:pre (), :post ()}},
:pk-keys (:id),
:col-keys
#{:description
:title
:id
:user_id
:access
:edited_at
:created_at}},
:signals
{:query {:pre (), :post ()},
:create {:pre (), :post ()},
:delete {:pre (), :post ()},
:update {:pre (), :post ()}},
:pk-keys (:id),
:col-keys
#{:can_read
:inherit
:can_edit
:group_id
:id
:user_id
:role_id
:next_access
:owner}},
:groups
{:lcn-fields
{:rsc
{:access {:type Int},
:created_at {:type String},
:edited_at {:type String},
:id {:type Int},
:title {:type String},
:user_id {:type String},
:description {:type String}},
:clauses
{:description {:type :StrWhere},
:or {:type (list :GroupClauses)},
:title {:type :StrWhere},
:id {:type :IntWhere},
:and {:type (list :GroupClauses)},
:user_id {:type :StrWhere},
:access {:type :IntWhere},
:edited_at {:type :StrWhere},
:created_at {:type :StrWhere}},
:sort
{:access {:type :SortOperator},
:created_at {:type :SortOperator},
:edited_at {:type :SortOperator},
:id {:type :SortOperator},
:title {:type :SortOperator},
:user_id {:type :SortOperator},
:description {:type :SortOperator}},
:fields
{:access {:type Int},
:created_at {:type String},
:edited_at {:type String},
:id {:type Int},
:title {:type String},
:user_id {:type String},
:description {:type String}},
:aggregate
{:count {:type Int},
:sum {:type :GroupFields},
:avg {:type :GroupFields},
:max {:type :GroupFields},
:min {:type :GroupFields}},
:pks {:id {:type (non-null Int)}},
:pk-input {:id {:type (non-null Int)}},
:update
{:access {:type Int},
:created_at {:type String},
:edited_at {:type String},
:title {:type String},
:user_id {:type String},
:description {:type String}}},
:fks
{:access
{:field-keys
{:to :Access,
:has-many :groups,
:has-many-aggr :groups_aggregate,
:has-one :access_access}},
:user_id
{:field-keys
{:to :User,
:has-many :groups,
:has-many-aggr :groups_aggregate,
:has-one :user}}},
:lcn-mut-keys
{:create :createGroup,
:update :updateGroup,
:delete :deleteGroup},
:lcn-obj-keys
{:rsc :Group,
:clauses :GroupClauses,
:where :GroupWhere,
:sort :GroupSort,
:fields :GroupFields,
:aggregate :GroupAggregate,
:pks :GroupPks,
:pk-input :GroupPkColumns},
:lcn-qry-keys {:queries :groups, :aggregate :groups_aggregate},
:lcn-descs
{:rsc "Groups",
:query "Query Groups.",
:clauses
"Format for where clauses is {column: {operator: value}}. Multiple parameters are applied with `AND` operators. `AND`/`OR` conditions can be created as a list of clauses. It is possible to nest them to create sub groups of conditions.",
:sort "Sort format is {column: \"asc\" or \"desc\"}.",
:fields "Groupsfields for aggregation.",
:aggregate "Aggrecate Groups.",
:pks "Primary key fields.",
:pk-input "Primary key fields."},
:signals
{:query {:pre (), :post ()},
:create {:pre (), :post ()},
:delete {:pre (), :post ()},
:update {:pre (), :post ()}},
:pk-keys (:id),
:col-keys
#{:description
:title
:id
:user_id
:access
:edited_at
:created_at}},
:items
{:lcn-fields
{:rsc
{:slug {:type String},
:domain_pk {:type String},
:title {:type String},
:domain_pk_namespace {:type String},
:id {:type Int},
:url {:type String},
:access {:type Int},
:edited_at {:type String},
:body {:type String},
:created_at {:type String}},
:clauses
{:slug {:type :StrWhere},
:domain_pk {:type :StrWhere},
:or {:type (list :ItemClauses)},
:title {:type :StrWhere},
:domain_pk_namespace {:type :StrWhere},
:id {:type :IntWhere},
:url {:type :StrWhere},
:and {:type (list :ItemClauses)},
:access {:type :IntWhere},
:edited_at {:type :StrWhere},
:body {:type :StrWhere},
:created_at {:type :StrWhere}},
:sort
{:slug {:type :SortOperator},
:domain_pk {:type :SortOperator},
:title {:type :SortOperator},
:domain_pk_namespace {:type :SortOperator},
:id {:type :SortOperator},
:url {:type :SortOperator},
:access {:type :SortOperator},
:edited_at {:type :SortOperator},
:body {:type :SortOperator},
:created_at {:type :SortOperator}},
:fields
{:slug {:type String},
:domain_pk {:type String},
:title {:type String},
:domain_pk_namespace {:type String},
:id {:type Int},
:url {:type String},
:access {:type Int},
:edited_at {:type String},
:body {:type String},
:created_at {:type String}},
:aggregate
{:count {:type Int},
:sum {:type :ItemFields},
:avg {:type :ItemFields},
:max {:type :ItemFields},
:min {:type :ItemFields}},
:pks {:id {:type (non-null Int)}},
:pk-input {:id {:type (non-null Int)}},
:update
{:slug {:type String},
:domain_pk {:type String},
:title {:type String},
:domain_pk_namespace {:type String},
:url {:type String},
:access {:type Int},
:edited_at {:type String},
:body {:type String},
:created_at {:type String}}},
:fks
{:access
{:field-keys
{:to :Access,
:has-many :items,
:has-many-aggr :items_aggregate,
:has-one :access_access}}},
:lcn-mut-keys
{:create :createItem, :update :updateItem, :delete :deleteItem},
:roles
{:lcn-fields
{:rsc
{:id {:type Int},
:group_id {:type Int},
:title {:type String},
:color {:type String}},
:clauses
{:and {:type (list :RoleClauses)},
:or {:type (list :RoleClauses)},
:id {:type :IntWhere},
:group_id {:type :IntWhere},
:title {:type :StrWhere},
:color {:type :StrWhere}},
:sort
{:id {:type :SortOperator},
:group_id {:type :SortOperator},
:title {:type :SortOperator},
:color {:type :SortOperator}},
:fields
{:id {:type Int},
:group_id {:type Int},
:title {:type String},
:color {:type String}},
:aggregate
{:count {:type Int},
:sum {:type :RoleFields},
:avg {:type :RoleFields},
:max {:type :RoleFields},
:min {:type :RoleFields}},
:pks {:id {:type (non-null Int)}},
:pk-input {:id {:type (non-null Int)}},
:update
{:group_id {:type Int},
:title {:type String},
:color {:type String}}},
:fks
{:group_id
{:field-keys
{:to :Group,
:has-many :roles,
:has-many-aggr :roles_aggregate,
:has-one :group}}},
:lcn-mut-keys
{:create :createRole, :update :updateRole, :delete :deleteRole},
:lcn-obj-keys
{:rsc :Role,
:clauses :RoleClauses,
:where :RoleWhere,
:sort :RoleSort,
:fields :RoleFields,
:aggregate :RoleAggregate,
:pks :RolePks,
:pk-input :RolePkColumns},
:lcn-qry-keys {:queries :roles, :aggregate :roles_aggregate},
:lcn-descs
{:rsc "Roles",
:query "Query Roles.",
:clauses
"Format for where clauses is {column: {operator: value}}. Multiple parameters are applied with `AND` operators. `AND`/`OR` conditions can be created as a list of clauses. It is possible to nest them to create sub groups of conditions.",
:sort "Sort format is {column: \"asc\" or \"desc\"}.",
:fields "Rolesfields for aggregation.",
:aggregate "Aggrecate Roles.",
:pks "Primary key fields.",
:pk-input "Primary key fields."},
:groups
{:lcn-fields
{:rsc
{:access {:type Int},
:created_at {:type String},
:edited_at {:type String},
:id {:type Int},
:title {:type String},
:user_id {:type String},
:description {:type String}},
:clauses
{:description {:type :StrWhere},
:or {:type (list :GroupClauses)},
:title {:type :StrWhere},
:id {:type :IntWhere},
:and {:type (list :GroupClauses)},
:user_id {:type :StrWhere},
:access {:type :IntWhere},
:edited_at {:type :StrWhere},
:created_at {:type :StrWhere}},
:sort
{:access {:type :SortOperator},
:created_at {:type :SortOperator},
:edited_at {:type :SortOperator},
:id {:type :SortOperator},
:title {:type :SortOperator},
:user_id {:type :SortOperator},
:description {:type :SortOperator}},
:fields
{:access {:type Int},
:created_at {:type String},
:edited_at {:type String},
:id {:type Int},
:title {:type String},
:user_id {:type String},
:description {:type String}},
:aggregate
{:count {:type Int},
:sum {:type :GroupFields},
:avg {:type :GroupFields},
:max {:type :GroupFields},
:min {:type :GroupFields}},
:pks {:id {:type (non-null Int)}},
:pk-input {:id {:type (non-null Int)}},
:update
{:access {:type Int},
:created_at {:type String},
:edited_at {:type String},
:title {:type String},
:user_id {:type String},
:description {:type String}}},
:fks
{:access
{:field-keys
{:to :Access,
:has-many :groups,
:has-many-aggr :groups_aggregate,
:has-one :access_access}},
:user_id
{:field-keys
{:to :User,
:has-many :groups,
:has-many-aggr :groups_aggregate,
:has-one :user}}},
:lcn-mut-keys
{:create :createGroup,
:update :updateGroup,
:delete :deleteGroup},
:lcn-obj-keys
{:rsc :Group,
:clauses :GroupClauses,
:where :GroupWhere,
:sort :GroupSort,
:fields :GroupFields,
:aggregate :GroupAggregate,
:pks :GroupPks,
:pk-input :GroupPkColumns},
:lcn-qry-keys {:queries :groups, :aggregate :groups_aggregate},
:lcn-descs
{:rsc "Groups",
:query "Query Groups.",
:clauses
"Format for where clauses is {column: {operator: value}}. Multiple parameters are applied with `AND` operators. `AND`/`OR` conditions can be created as a list of clauses. It is possible to nest them to create sub groups of conditions.",
:sort "Sort format is {column: \"asc\" or \"desc\"}.",
:fields "Groupsfields for aggregation.",
:aggregate "Aggrecate Groups.",
:pks "Primary key fields.",
:pk-input "Primary key fields."},
:signals
{:query {:pre (), :post ()},
:create {:pre (), :post ()},
:delete {:pre (), :post ()},
:update {:pre (), :post ()}},
:pk-keys (:id),
:col-keys
#{:description
:title
:id
:user_id
:access
:edited_at
:created_at}},
:signals
{:query {:pre (), :post ()},
:create {:pre (), :post ()},
:delete {:pre (), :post ()},
:update {:pre (), :post ()}},
:pk-keys (:id),
:col-keys #{:color :title :group_id :id}},
:lcn-obj-keys
{:rsc :Item,
:clauses :ItemClauses,
:where :ItemWhere,
:sort :ItemSort,
:fields :ItemFields,
:aggregate :ItemAggregate,
:pks :ItemPks,
:pk-input :ItemPkColumns},
:lcn-qry-keys {:queries :items, :aggregate :items_aggregate},
:lcn-descs
{:rsc "Items",
:query "Query Items.",
:clauses
"Format for where clauses is {column: {operator: value}}. Multiple parameters are applied with `AND` operators. `AND`/`OR` conditions can be created as a list of clauses. It is possible to nest them to create sub groups of conditions.",
:sort "Sort format is {column: \"asc\" or \"desc\"}.",
:fields "Itemsfields for aggregation.",
:aggregate "Aggrecate Items.",
:pks "Primary key fields.",
:pk-input "Primary key fields."},
:access
{:lcn-fields
{:rsc
{:can_read {:type Boolean},
:inherit {:type Boolean},
:can_edit {:type Boolean},
:group_id {:type Int},
:id {:type Int},
:user_id {:type String},
:role_id {:type Int},
:next_access {:type Int},
:owner {:type Boolean}},
:clauses
{:can_read {:type :BoolWhere},
:inherit {:type :BoolWhere},
:can_edit {:type :BoolWhere},
:or {:type (list :AccessClauses)},
:group_id {:type :IntWhere},
:id {:type :IntWhere},
:and {:type (list :AccessClauses)},
:user_id {:type :StrWhere},
:role_id {:type :IntWhere},
:next_access {:type :IntWhere},
:owner {:type :BoolWhere}},
:sort
{:can_read {:type :SortOperator},
:inherit {:type :SortOperator},
:can_edit {:type :SortOperator},
:group_id {:type :SortOperator},
:id {:type :SortOperator},
:user_id {:type :SortOperator},
:role_id {:type :SortOperator},
:next_access {:type :SortOperator},
:owner {:type :SortOperator}},
:fields
{:can_read {:type Boolean},
:inherit {:type Boolean},
:can_edit {:type Boolean},
:group_id {:type Int},
:id {:type Int},
:user_id {:type String},
:role_id {:type Int},
:next_access {:type Int},
:owner {:type Boolean}},
:aggregate
{:count {:type Int},
:sum {:type :AccessFields},
:avg {:type :AccessFields},
:max {:type :AccessFields},
:min {:type :AccessFields}},
:pks {:id {:type (non-null Int)}},
:pk-input {:id {:type (non-null Int)}},
:update
{:can_read {:type Boolean},
:inherit {:type Boolean},
:can_edit {:type Boolean},
:group_id {:type Int},
:user_id {:type String},
:role_id {:type Int},
:next_access {:type Int},
:owner {:type Boolean}}},
:fks
{:next_access
{:field-keys
{:to :Access,
:has-many :accesses,
:has-many-aggr :accesses_aggregate,
:has-one :next_access_access}},
:role_id
{:field-keys
{:to :Role,
:has-many :accesses,
:has-many-aggr :accesses_aggregate,
:has-one :role}},
:user_id
{:field-keys
{:to :User,
:has-many :accesses,
:has-many-aggr :accesses_aggregate,
:has-one :user}},
:group_id
{:field-keys
{:to :Group,
:has-many :accesses,
:has-many-aggr :accesses_aggregate,
:has-one :group}}},
:lcn-mut-keys
{:create :createAccess,
:update :updateAccess,
:delete :deleteAccess},
:roles
{:lcn-fields
{:rsc
{:id {:type Int},
:group_id {:type Int},
:title {:type String},
:color {:type String}},
:clauses
{:and {:type (list :RoleClauses)},
:or {:type (list :RoleClauses)},
:id {:type :IntWhere},
:group_id {:type :IntWhere},
:title {:type :StrWhere},
:color {:type :StrWhere}},
:sort
{:id {:type :SortOperator},
:group_id {:type :SortOperator},
:title {:type :SortOperator},
:color {:type :SortOperator}},
:fields
{:id {:type Int},
:group_id {:type Int},
:title {:type String},
:color {:type String}},
:aggregate
{:count {:type Int},
:sum {:type :RoleFields},
:avg {:type :RoleFields},
:max {:type :RoleFields},
:min {:type :RoleFields}},
:pks {:id {:type (non-null Int)}},
:pk-input {:id {:type (non-null Int)}},
:update
{:group_id {:type Int},
:title {:type String},
:color {:type String}}},
:fks
{:group_id
{:field-keys
{:to :Group,
:has-many :roles,
:has-many-aggr :roles_aggregate,
:has-one :group}}},
:lcn-mut-keys
{:create :createRole, :update :updateRole, :delete :deleteRole},
:lcn-obj-keys
{:rsc :Role,
:clauses :RoleClauses,
:where :RoleWhere,
:sort :RoleSort,
:fields :RoleFields,
:aggregate :RoleAggregate,
:pks :RolePks,
:pk-input :RolePkColumns},
:lcn-qry-keys {:queries :roles, :aggregate :roles_aggregate},
:lcn-descs
{:rsc "Roles",
:query "Query Roles.",
:clauses
"Format for where clauses is {column: {operator: value}}. Multiple parameters are applied with `AND` operators. `AND`/`OR` conditions can be created as a list of clauses. It is possible to nest them to create sub groups of conditions.",
:sort "Sort format is {column: \"asc\" or \"desc\"}.",
:fields "Rolesfields for aggregation.",
:aggregate "Aggrecate Roles.",
:pks "Primary key fields.",
:pk-input "Primary key fields."},
:groups
{:lcn-fields
{:rsc
{:access {:type Int},
:created_at {:type String},
:edited_at {:type String},
:id {:type Int},
:title {:type String},
:user_id {:type String},
:description {:type String}},
:clauses
{:description {:type :StrWhere},
:or {:type (list :GroupClauses)},
:title {:type :StrWhere},
:id {:type :IntWhere},
:and {:type (list :GroupClauses)},
:user_id {:type :StrWhere},
:access {:type :IntWhere},
:edited_at {:type :StrWhere},
:created_at {:type :StrWhere}},
:sort
{:access {:type :SortOperator},
:created_at {:type :SortOperator},
:edited_at {:type :SortOperator},
:id {:type :SortOperator},
:title {:type :SortOperator},
:user_id {:type :SortOperator},
:description {:type :SortOperator}},
:fields
{:access {:type Int},
:created_at {:type String},
:edited_at {:type String},
:id {:type Int},
:title {:type String},
:user_id {:type String},
:description {:type String}},
:aggregate
{:count {:type Int},
:sum {:type :GroupFields},
:avg {:type :GroupFields},
:max {:type :GroupFields},
:min {:type :GroupFields}},
:pks {:id {:type (non-null Int)}},
:pk-input {:id {:type (non-null Int)}},
:update
{:access {:type Int},
:created_at {:type String},
:edited_at {:type String},
:title {:type String},
:user_id {:type String},
:description {:type String}}},
:fks
{:access
{:field-keys
{:to :Access,
:has-many :groups,
:has-many-aggr :groups_aggregate,
:has-one :access_access}},
:user_id
{:field-keys
{:to :User,
:has-many :groups,
:has-many-aggr :groups_aggregate,
:has-one :user}}},
:lcn-mut-keys
{:create :createGroup,
:update :updateGroup,
:delete :deleteGroup},
:lcn-obj-keys
{:rsc :Group,
:clauses :GroupClauses,
:where :GroupWhere,
:sort :GroupSort,
:fields :GroupFields,
:aggregate :GroupAggregate,
:pks :GroupPks,
:pk-input :GroupPkColumns},
:lcn-qry-keys {:queries :groups, :aggregate :groups_aggregate},
:lcn-descs
{:rsc "Groups",
:query "Query Groups.",
:clauses
"Format for where clauses is {column: {operator: value}}. Multiple parameters are applied with `AND` operators. `AND`/`OR` conditions can be created as a list of clauses. It is possible to nest them to create sub groups of conditions.",
:sort "Sort format is {column: \"asc\" or \"desc\"}.",
:fields "Groupsfields for aggregation.",
:aggregate "Aggrecate Groups.",
:pks "Primary key fields.",
:pk-input "Primary key fields."},
:signals
{:query {:pre (), :post ()},
:create {:pre (), :post ()},
:delete {:pre (), :post ()},
:update {:pre (), :post ()}},
:pk-keys (:id),
:col-keys
#{:description
:title
:id
:user_id
:access
:edited_at
:created_at}},
:signals
{:query {:pre (), :post ()},
:create {:pre (), :post ()},
:delete {:pre (), :post ()},
:update {:pre (), :post ()}},
:pk-keys (:id),
:col-keys #{:color :title :group_id :id}},
:lcn-obj-keys
{:rsc :Access,
:clauses :AccessClauses,
:where :AccessWhere,
:sort :AccessSort,
:fields :AccessFields,
:aggregate :AccessAggregate,
:pks :AccessPks,
:pk-input :AccessPkColumns},
:lcn-qry-keys
{:queries :accesses, :aggregate :accesses_aggregate},
:lcn-descs
{:rsc "Accesses",
:query "Query Accesses.",
:clauses
"Format for where clauses is {column: {operator: value}}. Multiple parameters are applied with `AND` operators. `AND`/`OR` conditions can be created as a list of clauses. It is possible to nest them to create sub groups of conditions.",
:sort "Sort format is {column: \"asc\" or \"desc\"}.",
:fields "Accessesfields for aggregation.",
:aggregate "Aggrecate Accesses.",
:pks "Primary key fields.",
:pk-input "Primary key fields."},
:groups
{:lcn-fields
{:rsc
{:access {:type Int},
:created_at {:type String},
:edited_at {:type String},
:id {:type Int},
:title {:type String},
:user_id {:type String},
:description {:type String}},
:clauses
{:description {:type :StrWhere},
:or {:type (list :GroupClauses)},
:title {:type :StrWhere},
:id {:type :IntWhere},
:and {:type (list :GroupClauses)},
:user_id {:type :StrWhere},
:access {:type :IntWhere},
:edited_at {:type :StrWhere},
:created_at {:type :StrWhere}},
:sort
{:access {:type :SortOperator},
:created_at {:type :SortOperator},
:edited_at {:type :SortOperator},
:id {:type :SortOperator},
:title {:type :SortOperator},
:user_id {:type :SortOperator},
:description {:type :SortOperator}},
:fields
{:access {:type Int},
:created_at {:type String},
:edited_at {:type String},
:id {:type Int},
:title {:type String},
:user_id {:type String},
:description {:type String}},
:aggregate
{:count {:type Int},
:sum {:type :GroupFields},
:avg {:type :GroupFields},
:max {:type :GroupFields},
:min {:type :GroupFields}},
:pks {:id {:type (non-null Int)}},
:pk-input {:id {:type (non-null Int)}},
:update
{:access {:type Int},
:created_at {:type String},
:edited_at {:type String},
:title {:type String},
:user_id {:type String},
:description {:type String}}},
:fks
{:access
{:field-keys
{:to :Access,
:has-many :groups,
:has-many-aggr :groups_aggregate,
:has-one :access_access}},
:user_id
{:field-keys
{:to :User,
:has-many :groups,
:has-many-aggr :groups_aggregate,
:has-one :user}}},
:lcn-mut-keys
{:create :createGroup,
:update :updateGroup,
:delete :deleteGroup},
:lcn-obj-keys
{:rsc :Group,
:clauses :GroupClauses,
:where :GroupWhere,
:sort :GroupSort,
:fields :GroupFields,
:aggregate :GroupAggregate,
:pks :GroupPks,
:pk-input :GroupPkColumns},
:lcn-qry-keys {:queries :groups, :aggregate :groups_aggregate},
:lcn-descs
{:rsc "Groups",
:query "Query Groups.",
:clauses
"Format for where clauses is {column: {operator: value}}. Multiple parameters are applied with `AND` operators. `AND`/`OR` conditions can be created as a list of clauses. It is possible to nest them to create sub groups of conditions.",
:sort "Sort format is {column: \"asc\" or \"desc\"}.",
:fields "Groupsfields for aggregation.",
:aggregate "Aggrecate Groups.",
:pks "Primary key fields.",
:pk-input "Primary key fields."},
:signals
{:query {:pre (), :post ()},
:create {:pre (), :post ()},
:delete {:pre (), :post ()},
:update {:pre (), :post ()}},
:pk-keys (:id),
:col-keys
#{:description
:title
:id
:user_id
:access
:edited_at
:created_at}},
:signals
{:query {:pre (), :post ()},
:create {:pre (), :post ()},
:delete {:pre (), :post ()},
:update {:pre (), :post ()}},
:pk-keys (:id),
:col-keys
#{:can_read
:inherit
:can_edit
:group_id
:id
:user_id
:role_id
:next_access
:owner}},
:groups
{:lcn-fields
{:rsc
{:access {:type Int},
:created_at {:type String},
:edited_at {:type String},
:id {:type Int},
:title {:type String},
:user_id {:type String},
:description {:type String}},
:clauses
{:description {:type :StrWhere},
:or {:type (list :GroupClauses)},
:title {:type :StrWhere},
:id {:type :IntWhere},
:and {:type (list :GroupClauses)},
:user_id {:type :StrWhere},
:access {:type :IntWhere},
:edited_at {:type :StrWhere},
:created_at {:type :StrWhere}},
:sort
{:access {:type :SortOperator},
:created_at {:type :SortOperator},
:edited_at {:type :SortOperator},
:id {:type :SortOperator},
:title {:type :SortOperator},
:user_id {:type :SortOperator},
:description {:type :SortOperator}},
:fields
{:access {:type Int},
:created_at {:type String},
:edited_at {:type String},
:id {:type Int},
:title {:type String},
:user_id {:type String},
:description {:type String}},
:aggregate
{:count {:type Int},
:sum {:type :GroupFields},
:avg {:type :GroupFields},
:max {:type :GroupFields},
:min {:type :GroupFields}},
:pks {:id {:type (non-null Int)}},
:pk-input {:id {:type (non-null Int)}},
:update
{:access {:type Int},
:created_at {:type String},
:edited_at {:type String},
:title {:type String},
:user_id {:type String},
:description {:type String}}},
:fks
{:access
{:field-keys
{:to :Access,
:has-many :groups,
:has-many-aggr :groups_aggregate,
:has-one :access_access}},
:user_id
{:field-keys
{:to :User,
:has-many :groups,
:has-many-aggr :groups_aggregate,
:has-one :user}}},
:lcn-mut-keys
{:create :createGroup,
:update :updateGroup,
:delete :deleteGroup},
:lcn-obj-keys
{:rsc :Group,
:clauses :GroupClauses,
:where :GroupWhere,
:sort :GroupSort,
:fields :GroupFields,
:aggregate :GroupAggregate,
:pks :GroupPks,
:pk-input :GroupPkColumns},
:lcn-qry-keys {:queries :groups, :aggregate :groups_aggregate},
:lcn-descs
{:rsc "Groups",
:query "Query Groups.",
:clauses
"Format for where clauses is {column: {operator: value}}. Multiple parameters are applied with `AND` operators. `AND`/`OR` conditions can be created as a list of clauses. It is possible to nest them to create sub groups of conditions.",
:sort "Sort format is {column: \"asc\" or \"desc\"}.",
:fields "Groupsfields for aggregation.",
:aggregate "Aggrecate Groups.",
:pks "Primary key fields.",
:pk-input "Primary key fields."},
:signals
{:query {:pre (), :post ()},
:create {:pre (), :post ()},
:delete {:pre (), :post ()},
:update {:pre (), :post ()}},
:pk-keys (:id),
:col-keys
#{:description
:title
:id
:user_id
:access
:edited_at
:created_at}},
:signals
{:query {:pre (), :post ()},
:create {:pre (), :post ()},
:delete {:pre (), :post ()},
:update {:pre (), :post ()}},
:pk-keys (:id),
:col-keys
#{:slug
:domain_pk
:title
:domain_pk_namespace
:id
:url
:access
:edited_at
:body
:created_at},
:users_in_groups
{:lcn-fields
{:rsc
{:group_id {:type Int},
:role_id {:type Int},
:user_id {:type String}},
:clauses
{:and {:type (list :UsersInGroupClauses)},
:or {:type (list :UsersInGroupClauses)},
:group_id {:type :IntWhere},
:role_id {:type :IntWhere},
:user_id {:type :StrWhere}},
:sort
{:group_id {:type :SortOperator},
:role_id {:type :SortOperator},
:user_id {:type :SortOperator}},
:fields
{:group_id {:type Int},
:role_id {:type Int},
:user_id {:type String}},
:aggregate
{:count {:type Int},
:sum {:type :UsersInGroupFields},
:avg {:type :UsersInGroupFields},
:max {:type :UsersInGroupFields},
:min {:type :UsersInGroupFields}},
:pks
{:user_id {:type (non-null String)},
:group_id {:type (non-null Int)},
:role_id {:type (non-null Int)}},
:pk-input
{:user_id {:type (non-null String)},
:group_id {:type (non-null Int)},
:role_id {:type (non-null Int)}},
:update {}},
:fks
{:user_id
{:field-keys
{:to :User,
:has-many :users_in_groups,
:has-many-aggr :users_in_groups_aggregate,
:has-one :user}},
:group_id
{:field-keys
{:to :Group,
:has-many :users_in_groups,
:has-many-aggr :users_in_groups_aggregate,
:has-one :group}},
:role_id
{:field-keys
{:to :Role,
:has-many :users_in_groups,
:has-many-aggr :users_in_groups_aggregate,
:has-one :role}}},
:lcn-mut-keys
{:create :createUsersInGroup,
:update :updateUsersInGroup,
:delete :deleteUsersInGroup},
:roles
{:lcn-fields
{:rsc
{:id {:type Int},
:group_id {:type Int},
:title {:type String},
:color {:type String}},
:clauses
{:and {:type (list :RoleClauses)},
:or {:type (list :RoleClauses)},
:id {:type :IntWhere},
:group_id {:type :IntWhere},
:title {:type :StrWhere},
:color {:type :StrWhere}},
:sort
{:id {:type :SortOperator},
:group_id {:type :SortOperator},
:title {:type :SortOperator},
:color {:type :SortOperator}},
:fields
{:id {:type Int},
:group_id {:type Int},
:title {:type String},
:color {:type String}},
:aggregate
{:count {:type Int},
:sum {:type :RoleFields},
:avg {:type :RoleFields},
:max {:type :RoleFields},
:min {:type :RoleFields}},
:pks {:id {:type (non-null Int)}},
:pk-input {:id {:type (non-null Int)}},
:update
{:group_id {:type Int},
:title {:type String},
:color {:type String}}},
:fks
{:group_id
{:field-keys
{:to :Group,
:has-many :roles,
:has-many-aggr :roles_aggregate,
:has-one :group}}},
:lcn-mut-keys
{:create :createRole, :update :updateRole, :delete :deleteRole},
:lcn-obj-keys
{:rsc :Role,
:clauses :RoleClauses,
:where :RoleWhere,
:sort :RoleSort,
:fields :RoleFields,
:aggregate :RoleAggregate,
:pks :RolePks,
:pk-input :RolePkColumns},
:lcn-qry-keys {:queries :roles, :aggregate :roles_aggregate},
:lcn-descs
{:rsc "Roles",
:query "Query Roles.",
:clauses
"Format for where clauses is {column: {operator: value}}. Multiple parameters are applied with `AND` operators. `AND`/`OR` conditions can be created as a list of clauses. It is possible to nest them to create sub groups of conditions.",
:sort "Sort format is {column: \"asc\" or \"desc\"}.",
:fields "Rolesfields for aggregation.",
:aggregate "Aggrecate Roles.",
:pks "Primary key fields.",
:pk-input "Primary key fields."},
:groups
{:lcn-fields
{:rsc
{:access {:type Int},
:created_at {:type String},
:edited_at {:type String},
:id {:type Int},
:title {:type String},
:user_id {:type String},
:description {:type String}},
:clauses
{:description {:type :StrWhere},
:or {:type (list :GroupClauses)},
:title {:type :StrWhere},
:id {:type :IntWhere},
:and {:type (list :GroupClauses)},
:user_id {:type :StrWhere},
:access {:type :IntWhere},
:edited_at {:type :StrWhere},
:created_at {:type :StrWhere}},
:sort
{:access {:type :SortOperator},
:created_at {:type :SortOperator},
:edited_at {:type :SortOperator},
:id {:type :SortOperator},
:title {:type :SortOperator},
:user_id {:type :SortOperator},
:description {:type :SortOperator}},
:fields
{:access {:type Int},
:created_at {:type String},
:edited_at {:type String},
:id {:type Int},
:title {:type String},
:user_id {:type String},
:description {:type String}},
:aggregate
{:count {:type Int},
:sum {:type :GroupFields},
:avg {:type :GroupFields},
:max {:type :GroupFields},
:min {:type :GroupFields}},
:pks {:id {:type (non-null Int)}},
:pk-input {:id {:type (non-null Int)}},
:update
{:access {:type Int},
:created_at {:type String},
:edited_at {:type String},
:title {:type String},
:user_id {:type String},
:description {:type String}}},
:fks
{:access
{:field-keys
{:to :Access,
:has-many :groups,
:has-many-aggr :groups_aggregate,
:has-one :access_access}},
:user_id
{:field-keys
{:to :User,
:has-many :groups,
:has-many-aggr :groups_aggregate,
:has-one :user}}},
:lcn-mut-keys
{:create :createGroup,
:update :updateGroup,
:delete :deleteGroup},
:lcn-obj-keys
{:rsc :Group,
:clauses :GroupClauses,
:where :GroupWhere,
:sort :GroupSort,
:fields :GroupFields,
:aggregate :GroupAggregate,
:pks :GroupPks,
:pk-input :GroupPkColumns},
:lcn-qry-keys {:queries :groups, :aggregate :groups_aggregate},
:lcn-descs
{:rsc "Groups",
:query "Query Groups.",
:clauses
"Format for where clauses is {column: {operator: value}}. Multiple parameters are applied with `AND` operators. `AND`/`OR` conditions can be created as a list of clauses. It is possible to nest them to create sub groups of conditions.",
:sort "Sort format is {column: \"asc\" or \"desc\"}.",
:fields "Groupsfields for aggregation.",
:aggregate "Aggrecate Groups.",
:pks "Primary key fields.",
:pk-input "Primary key fields."},
:signals
{:query {:pre (), :post ()},
:create {:pre (), :post ()},
:delete {:pre (), :post ()},
:update {:pre (), :post ()}},
:pk-keys (:id),
:col-keys
#{:description
:title
:id
:user_id
:access
:edited_at
:created_at}},
:signals
{:query {:pre (), :post ()},
:create {:pre (), :post ()},
:delete {:pre (), :post ()},
:update {:pre (), :post ()}},
:pk-keys (:id),
:col-keys #{:color :title :group_id :id}},
:lcn-obj-keys
{:rsc :UsersInGroup,
:clauses :UsersInGroupClauses,
:where :UsersInGroupWhere,
:sort :UsersInGroupSort,
:fields :UsersInGroupFields,
:aggregate :UsersInGroupAggregate,
:pks :UsersInGroupPks,
:pk-input :UsersInGroupPkColumns},
:lcn-qry-keys
{:queries :users_in_groups,
:aggregate :users_in_groups_aggregate},
:lcn-descs
{:rsc "UsersInGroups",
:query "Query UsersInGroups.",
:clauses
"Format for where clauses is {column: {operator: value}}. Multiple parameters are applied with `AND` operators. `AND`/`OR` conditions can be created as a list of clauses. It is possible to nest them to create sub groups of conditions.",
:sort "Sort format is {column: \"asc\" or \"desc\"}.",
:fields "UsersInGroupsfields for aggregation.",
:aggregate "Aggrecate UsersInGroups.",
:pks "Primary key fields.",
:pk-input "Primary key fields."},
:access
{:lcn-fields
{:rsc
{:can_read {:type Boolean},
:inherit {:type Boolean},
:can_edit {:type Boolean},
:group_id {:type Int},
:id {:type Int},
:user_id {:type String},
:role_id {:type Int},
:next_access {:type Int},
:owner {:type Boolean}},
:clauses
{:can_read {:type :BoolWhere},
:inherit {:type :BoolWhere},
:can_edit {:type :BoolWhere},
:or {:type (list :AccessClauses)},
:group_id {:type :IntWhere},
:id {:type :IntWhere},
:and {:type (list :AccessClauses)},
:user_id {:type :StrWhere},
:role_id {:type :IntWhere},
:next_access {:type :IntWhere},
:owner {:type :BoolWhere}},
:sort
{:can_read {:type :SortOperator},
:inherit {:type :SortOperator},
:can_edit {:type :SortOperator},
:group_id {:type :SortOperator},
:id {:type :SortOperator},
:user_id {:type :SortOperator},
:role_id {:type :SortOperator},
:next_access {:type :SortOperator},
:owner {:type :SortOperator}},
:fields
{:can_read {:type Boolean},
:inherit {:type Boolean},
:can_edit {:type Boolean},
:group_id {:type Int},
:id {:type Int},
:user_id {:type String},
:role_id {:type Int},
:next_access {:type Int},
:owner {:type Boolean}},
:aggregate
{:count {:type Int},
:sum {:type :AccessFields},
:avg {:type :AccessFields},
:max {:type :AccessFields},
:min {:type :AccessFields}},
:pks {:id {:type (non-null Int)}},
:pk-input {:id {:type (non-null Int)}},
:update
{:can_read {:type Boolean},
:inherit {:type Boolean},
:can_edit {:type Boolean},
:group_id {:type Int},
:user_id {:type String},
:role_id {:type Int},
:next_access {:type Int},
:owner {:type Boolean}}},
:fks
{:next_access
{:field-keys
{:to :Access,
:has-many :accesses,
:has-many-aggr :accesses_aggregate,
:has-one :next_access_access}},
:role_id
{:field-keys
{:to :Role,
:has-many :accesses,
:has-many-aggr :accesses_aggregate,
:has-one :role}},
:user_id
{:field-keys
{:to :User,
:has-many :accesses,
:has-many-aggr :accesses_aggregate,
:has-one :user}},
:group_id
{:field-keys
{:to :Group,
:has-many :accesses,
:has-many-aggr :accesses_aggregate,
:has-one :group}}},
:lcn-mut-keys
{:create :createAccess,
:update :updateAccess,
:delete :deleteAccess},
:roles
{:lcn-fields
{:rsc
{:id {:type Int},
:group_id {:type Int},
:title {:type String},
:color {:type String}},
:clauses
{:and {:type (list :RoleClauses)},
:or {:type (list :RoleClauses)},
:id {:type :IntWhere},
:group_id {:type :IntWhere},
:title {:type :StrWhere},
:color {:type :StrWhere}},
:sort
{:id {:type :SortOperator},
:group_id {:type :SortOperator},
:title {:type :SortOperator},
:color {:type :SortOperator}},
:fields
{:id {:type Int},
:group_id {:type Int},
:title {:type String},
:color {:type String}},
:aggregate
{:count {:type Int},
:sum {:type :RoleFields},
:avg {:type :RoleFields},
:max {:type :RoleFields},
:min {:type :RoleFields}},
:pks {:id {:type (non-null Int)}},
:pk-input {:id {:type (non-null Int)}},
:update
{:group_id {:type Int},
:title {:type String},
:color {:type String}}},
:fks
{:group_id
{:field-keys
{:to :Group,
:has-many :roles,
:has-many-aggr :roles_aggregate,
:has-one :group}}},
:lcn-mut-keys
{:create :createRole,
:update :updateRole,
:delete :deleteRole},
:lcn-obj-keys
{:rsc :Role,
:clauses :RoleClauses,
:where :RoleWhere,
:sort :RoleSort,
:fields :RoleFields,
:aggregate :RoleAggregate,
:pks :RolePks,
:pk-input :RolePkColumns},
:lcn-qry-keys {:queries :roles, :aggregate :roles_aggregate},
:lcn-descs
{:rsc "Roles",
:query "Query Roles.",
:clauses
"Format for where clauses is {column: {operator: value}}. Multiple parameters are applied with `AND` operators. `AND`/`OR` conditions can be created as a list of clauses. It is possible to nest them to create sub groups of conditions.",
:sort "Sort format is {column: \"asc\" or \"desc\"}.",
:fields "Rolesfields for aggregation.",
:aggregate "Aggrecate Roles.",
:pks "Primary key fields.",
:pk-input "Primary key fields."},
:groups
{:lcn-fields
{:rsc
{:access {:type Int},
:created_at {:type String},
:edited_at {:type String},
:id {:type Int},
:title {:type String},
:user_id {:type String},
:description {:type String}},
:clauses
{:description {:type :StrWhere},
:or {:type (list :GroupClauses)},
:title {:type :StrWhere},
:id {:type :IntWhere},
:and {:type (list :GroupClauses)},
:user_id {:type :StrWhere},
:access {:type :IntWhere},
:edited_at {:type :StrWhere},
:created_at {:type :StrWhere}},
:sort
{:access {:type :SortOperator},
:created_at {:type :SortOperator},
:edited_at {:type :SortOperator},
:id {:type :SortOperator},
:title {:type :SortOperator},
:user_id {:type :SortOperator},
:description {:type :SortOperator}},
:fields
{:access {:type Int},
:created_at {:type String},
:edited_at {:type String},
:id {:type Int},
:title {:type String},
:user_id {:type String},
:description {:type String}},
:aggregate
{:count {:type Int},
:sum {:type :GroupFields},
:avg {:type :GroupFields},
:max {:type :GroupFields},
:min {:type :GroupFields}},
:pks {:id {:type (non-null Int)}},
:pk-input {:id {:type (non-null Int)}},
:update
{:access {:type Int},
:created_at {:type String},
:edited_at {:type String},
:title {:type String},
:user_id {:type String},
:description {:type String}}},
:fks
{:access
{:field-keys
{:to :Access,
:has-many :groups,
:has-many-aggr :groups_aggregate,
:has-one :access_access}},
:user_id
{:field-keys
{:to :User,
:has-many :groups,
:has-many-aggr :groups_aggregate,
:has-one :user}}},
:lcn-mut-keys
{:create :createGroup,
:update :updateGroup,
:delete :deleteGroup},
:lcn-obj-keys
{:rsc :Group,
:clauses :GroupClauses,
:where :GroupWhere,
:sort :GroupSort,
:fields :GroupFields,
:aggregate :GroupAggregate,
:pks :GroupPks,
:pk-input :GroupPkColumns},
:lcn-qry-keys
{:queries :groups, :aggregate :groups_aggregate},
:lcn-descs
{:rsc "Groups",
:query "Query Groups.",
:clauses
"Format for where clauses is {column: {operator: value}}. Multiple parameters are applied with `AND` operators. `AND`/`OR` conditions can be created as a list of clauses. It is possible to nest them to create sub groups of conditions.",
:sort "Sort format is {column: \"asc\" or \"desc\"}.",
:fields "Groupsfields for aggregation.",
:aggregate "Aggrecate Groups.",
:pks "Primary key fields.",
:pk-input "Primary key fields."},
:signals
{:query {:pre (), :post ()},
:create {:pre (), :post ()},
:delete {:pre (), :post ()},
:update {:pre (), :post ()}},
:pk-keys (:id),
:col-keys
#{:description
:title
:id
:user_id
:access
:edited_at
:created_at}},
:signals
{:query {:pre (), :post ()},
:create {:pre (), :post ()},
:delete {:pre (), :post ()},
:update {:pre (), :post ()}},
:pk-keys (:id),
:col-keys #{:color :title :group_id :id}},
:lcn-obj-keys
{:rsc :Access,
:clauses :AccessClauses,
:where :AccessWhere,
:sort :AccessSort,
:fields :AccessFields,
:aggregate :AccessAggregate,
:pks :AccessPks,
:pk-input :AccessPkColumns},
:lcn-qry-keys
{:queries :accesses, :aggregate :accesses_aggregate},
:lcn-descs
{:rsc "Accesses",
:query "Query Accesses.",
:clauses
"Format for where clauses is {column: {operator: value}}. Multiple parameters are applied with `AND` operators. `AND`/`OR` conditions can be created as a list of clauses. It is possible to nest them to create sub groups of conditions.",
:sort "Sort format is {column: \"asc\" or \"desc\"}.",
:fields "Accessesfields for aggregation.",
:aggregate "Aggrecate Accesses.",
:pks "Primary key fields.",
:pk-input "Primary key fields."},
:groups
{:lcn-fields
{:rsc
{:access {:type Int},
:created_at {:type String},
:edited_at {:type String},
:id {:type Int},
:title {:type String},
:user_id {:type String},
:description {:type String}},
:clauses
{:description {:type :StrWhere},
:or {:type (list :GroupClauses)},
:title {:type :StrWhere},
:id {:type :IntWhere},
:and {:type (list :GroupClauses)},
:user_id {:type :StrWhere},
:access {:type :IntWhere},
:edited_at {:type :StrWhere},
:created_at {:type :StrWhere}},
:sort
{:access {:type :SortOperator},
:created_at {:type :SortOperator},
:edited_at {:type :SortOperator},
:id {:type :SortOperator},
:title {:type :SortOperator},
:user_id {:type :SortOperator},
:description {:type :SortOperator}},
:fields
{:access {:type Int},
:created_at {:type String},
:edited_at {:type String},
:id {:type Int},
:title {:type String},
:user_id {:type String},
:description {:type String}},
:aggregate
{:count {:type Int},
:sum {:type :GroupFields},
:avg {:type :GroupFields},
:max {:type :GroupFields},
:min {:type :GroupFields}},
:pks {:id {:type (non-null Int)}},
:pk-input {:id {:type (non-null Int)}},
:update
{:access {:type Int},
:created_at {:type String},
:edited_at {:type String},
:title {:type String},
:user_id {:type String},
:description {:type String}}},
:fks
{:access
{:field-keys
{:to :Access,
:has-many :groups,
:has-many-aggr :groups_aggregate,
:has-one :access_access}},
:user_id
{:field-keys
{:to :User,
:has-many :groups,
:has-many-aggr :groups_aggregate,
:has-one :user}}},
:lcn-mut-keys
{:create :createGroup,
:update :updateGroup,
:delete :deleteGroup},
:lcn-obj-keys
{:rsc :Group,
:clauses :GroupClauses,
:where :GroupWhere,
:sort :GroupSort,
:fields :GroupFields,
:aggregate :GroupAggregate,
:pks :GroupPks,
:pk-input :GroupPkColumns},
:lcn-qry-keys {:queries :groups, :aggregate :groups_aggregate},
:lcn-descs
{:rsc "Groups",
:query "Query Groups.",
:clauses
"Format for where clauses is {column: {operator: value}}. Multiple parameters are applied with `AND` operators. `AND`/`OR` conditions can be created as a list of clauses. It is possible to nest them to create sub groups of conditions.",
:sort "Sort format is {column: \"asc\" or \"desc\"}.",
:fields "Groupsfields for aggregation.",
:aggregate "Aggrecate Groups.",
:pks "Primary key fields.",
:pk-input "Primary key fields."},
:signals
{:query {:pre (), :post ()},
:create {:pre (), :post ()},
:delete {:pre (), :post ()},
:update {:pre (), :post ()}},
:pk-keys (:id),
:col-keys
#{:description
:title
:id
:user_id
:access
:edited_at
:created_at}},
:signals
{:query {:pre (), :post ()},
:create {:pre (), :post ()},
:delete {:pre (), :post ()},
:update {:pre (), :post ()}},
:pk-keys (:id),
:col-keys
#{:can_read
:inherit
:can_edit
:group_id
:id
:user_id
:role_id
:next_access
:owner}},
:groups
{:lcn-fields
{:rsc
{:access {:type Int},
:created_at {:type String},
:edited_at {:type String},
:id {:type Int},
:title {:type String},
:user_id {:type String},
:description {:type String}},
:clauses
{:description {:type :StrWhere},
:or {:type (list :GroupClauses)},
:title {:type :StrWhere},
:id {:type :IntWhere},
:and {:type (list :GroupClauses)},
:user_id {:type :StrWhere},
:access {:type :IntWhere},
:edited_at {:type :StrWhere},
:created_at {:type :StrWhere}},
:sort
{:access {:type :SortOperator},
:created_at {:type :SortOperator},
:edited_at {:type :SortOperator},
:id {:type :SortOperator},
:title {:type :SortOperator},
:user_id {:type :SortOperator},
:description {:type :SortOperator}},
:fields
{:access {:type Int},
:created_at {:type String},
:edited_at {:type String},
:id {:type Int},
:title {:type String},
:user_id {:type String},
:description {:type String}},
:aggregate
{:count {:type Int},
:sum {:type :GroupFields},
:avg {:type :GroupFields},
:max {:type :GroupFields},
:min {:type :GroupFields}},
:pks {:id {:type (non-null Int)}},
:pk-input {:id {:type (non-null Int)}},
:update
{:access {:type Int},
:created_at {:type String},
:edited_at {:type String},
:title {:type String},
:user_id {:type String},
:description {:type String}}},
:fks
{:access
{:field-keys
{:to :Access,
:has-many :groups,
:has-many-aggr :groups_aggregate,
:has-one :access_access}},
:user_id
{:field-keys
{:to :User,
:has-many :groups,
:has-many-aggr :groups_aggregate,
:has-one :user}}},
:lcn-mut-keys
{:create :createGroup,
:update :updateGroup,
:delete :deleteGroup},
:lcn-obj-keys
{:rsc :Group,
:clauses :GroupClauses,
:where :GroupWhere,
:sort :GroupSort,
:fields :GroupFields,
:aggregate :GroupAggregate,
:pks :GroupPks,
:pk-input :GroupPkColumns},
:lcn-qry-keys {:queries :groups, :aggregate :groups_aggregate},
:lcn-descs
{:rsc "Groups",
:query "Query Groups.",
:clauses
"Format for where clauses is {column: {operator: value}}. Multiple parameters are applied with `AND` operators. `AND`/`OR` conditions can be created as a list of clauses. It is possible to nest them to create sub groups of conditions.",
:sort "Sort format is {column: \"asc\" or \"desc\"}.",
:fields "Groupsfields for aggregation.",
:aggregate "Aggrecate Groups.",
:pks "Primary key fields.",
:pk-input "Primary key fields."},
:signals
{:query {:pre (), :post ()},
:create {:pre (), :post ()},
:delete {:pre (), :post ()},
:update {:pre (), :post ()}},
:pk-keys (:id),
:col-keys
#{:description
:title
:id
:user_id
:access
:edited_at
:created_at}},
:signals
{:query {:pre (), :post ()},
:create {:pre (), :post ()},
:delete {:pre (), :post ()},
:update {:pre (), :post ()}},
:pk-keys (:user_id :group_id :role_id),
:col-keys #{:group_id :user_id :role_id}}},
:attributes
{:lcn-fields
{:rsc
{:attribute_name {:type nil},
:description {:type String},
:udt_schema {:type nil},
:collation_schema {:type nil},
:numeric_scale {:type Int},
:character_set_schema {:type nil},
:dtd_identifier {:type nil},
:maximum_cardinality {:type Int},
:is_derived_reference_attribute {:type String},
:character_octet_length {:type Int},
:datetime_precision {:type Int},
:scope_catalog {:type nil},
:collation_catalog {:type nil},
:character_maximum_length {:type Int},
:is_nullable {:type String},
:character_set_catalog {:type nil},
:numeric_precision {:type Int},
:interval_type {:type String},
:udt_catalog {:type nil},
:title {:type String},
:scope_schema {:type nil},
:attribute_default {:type String},
:numeric_precision_radix {:type Int},
:interval_precision {:type Int},
:character_set_name {:type nil},
:attribute_udt_catalog {:type nil},
:id {:type Int},
:collation_name {:type nil},
:data_type {:type String},
:attribute_udt_schema {:type nil},
:access {:type Int},
:edited_at {:type String},
:scope_name {:type nil},
:udt_name {:type nil},
:created_at {:type String},
:ordinal_position {:type Int},
:attribute_udt_name {:type nil}},
:clauses
{:attribute_name {:type nil},
:description {:type :StrWhere},
:udt_schema {:type nil},
:collation_schema {:type nil},
:numeric_scale {:type :IntWhere},
:character_set_schema {:type nil},
:dtd_identifier {:type nil},
:maximum_cardinality {:type :IntWhere},
:is_derived_reference_attribute {:type :StrWhere},
:character_octet_length {:type :IntWhere},
:datetime_precision {:type :IntWhere},
:or {:type (list :AttributeClauses)},
:scope_catalog {:type nil},
:collation_catalog {:type nil},
:character_maximum_length {:type :IntWhere},
:is_nullable {:type :StrWhere},
:character_set_catalog {:type nil},
:numeric_precision {:type :IntWhere},
:interval_type {:type :StrWhere},
:udt_catalog {:type nil},
:title {:type :StrWhere},
:scope_schema {:type nil},
:attribute_default {:type :StrWhere},
:numeric_precision_radix {:type :IntWhere},
:interval_precision {:type :IntWhere},
:character_set_name {:type nil},
:attribute_udt_catalog {:type nil},
:id {:type :IntWhere},
:collation_name {:type nil},
:data_type {:type :StrWhere},
:attribute_udt_schema {:type nil},
:and {:type (list :AttributeClauses)},
:access {:type :IntWhere},
:edited_at {:type :StrWhere},
:scope_name {:type nil},
:udt_name {:type nil},
:created_at {:type :StrWhere},
:ordinal_position {:type :IntWhere},
:attribute_udt_name {:type nil}},
:sort
{:attribute_name {:type :SortOperator},
:description {:type :SortOperator},
:udt_schema {:type :SortOperator},
:collation_schema {:type :SortOperator},
:numeric_scale {:type :SortOperator},
:character_set_schema {:type :SortOperator},
:dtd_identifier {:type :SortOperator},
:maximum_cardinality {:type :SortOperator},
:is_derived_reference_attribute {:type :SortOperator},
:character_octet_length {:type :SortOperator},
:datetime_precision {:type :SortOperator},
:scope_catalog {:type :SortOperator},
:collation_catalog {:type :SortOperator},
:character_maximum_length {:type :SortOperator},
:is_nullable {:type :SortOperator},
:character_set_catalog {:type :SortOperator},
:numeric_precision {:type :SortOperator},
:interval_type {:type :SortOperator},
:udt_catalog {:type :SortOperator},
:title {:type :SortOperator},
:scope_schema {:type :SortOperator},
:attribute_default {:type :SortOperator},
:numeric_precision_radix {:type :SortOperator},
:interval_precision {:type :SortOperator},
:character_set_name {:type :SortOperator},
:attribute_udt_catalog {:type :SortOperator},
:id {:type :SortOperator},
:collation_name {:type :SortOperator},
:data_type {:type :SortOperator},
:attribute_udt_schema {:type :SortOperator},
:access {:type :SortOperator},
:edited_at {:type :SortOperator},
:scope_name {:type :SortOperator},
:udt_name {:type :SortOperator},
:created_at {:type :SortOperator},
:ordinal_position {:type :SortOperator},
:attribute_udt_name {:type :SortOperator}},
:fields
{:attribute_name {:type nil},
:description {:type String},
:udt_schema {:type nil},
:collation_schema {:type nil},
:numeric_scale {:type Int},
:character_set_schema {:type nil},
:dtd_identifier {:type nil},
:maximum_cardinality {:type Int},
:is_derived_reference_attribute {:type String},
:character_octet_length {:type Int},
:datetime_precision {:type Int},
:scope_catalog {:type nil},
:collation_catalog {:type nil},
:character_maximum_length {:type Int},
:is_nullable {:type String},
:character_set_catalog {:type nil},
:numeric_precision {:type Int},
:interval_type {:type String},
:udt_catalog {:type nil},
:title {:type String},
:scope_schema {:type nil},
:attribute_default {:type String},
:numeric_precision_radix {:type Int},
:interval_precision {:type Int},
:character_set_name {:type nil},
:attribute_udt_catalog {:type nil},
:id {:type Int},
:collation_name {:type nil},
:data_type {:type String},
:attribute_udt_schema {:type nil},
:access {:type Int},
:edited_at {:type String},
:scope_name {:type nil},
:udt_name {:type nil},
:created_at {:type String},
:ordinal_position {:type Int},
:attribute_udt_name {:type nil}},
:aggregate
{:count {:type Int},
:sum {:type :AttributeFields},
:avg {:type :AttributeFields},
:max {:type :AttributeFields},
:min {:type :AttributeFields}},
:pks {:id {:type (non-null Int)}},
:pk-input {:id {:type (non-null Int)}},
:update
{:attribute_name {:type nil},
:description {:type String},
:udt_schema {:type nil},
:collation_schema {:type nil},
:numeric_scale {:type Int},
:character_set_schema {:type nil},
:dtd_identifier {:type nil},
:maximum_cardinality {:type Int},
:is_derived_reference_attribute {:type String},
:character_octet_length {:type Int},
:datetime_precision {:type Int},
:scope_catalog {:type nil},
:collation_catalog {:type nil},
:character_maximum_length {:type Int},
:is_nullable {:type String},
:character_set_catalog {:type nil},
:numeric_precision {:type Int},
:interval_type {:type String},
:udt_catalog {:type nil},
:title {:type String},
:scope_schema {:type nil},
:attribute_default {:type String},
:numeric_precision_radix {:type Int},
:interval_precision {:type Int},
:character_set_name {:type nil},
:attribute_udt_catalog {:type nil},
:collation_name {:type nil},
:data_type {:type String},
:attribute_udt_schema {:type nil},
:access {:type Int},
:edited_at {:type String},
:scope_name {:type nil},
:udt_name {:type nil},
:created_at {:type String},
:ordinal_position {:type Int},
:attribute_udt_name {:type nil}}},
:fks
{:access
{:field-keys
{:to :Access,
:has-many :attributes,
:has-many-aggr :attributes_aggregate,
:has-one :access_access}}},
:lcn-mut-keys
{:create :createAttribute,
:update :updateAttribute,
:delete :deleteAttribute},
:roles
{:lcn-fields
{:rsc
{:id {:type Int},
:group_id {:type Int},
:title {:type String},
:color {:type String}},
:clauses
{:and {:type (list :RoleClauses)},
:or {:type (list :RoleClauses)},
:id {:type :IntWhere},
:group_id {:type :IntWhere},
:title {:type :StrWhere},
:color {:type :StrWhere}},
:sort
{:id {:type :SortOperator},
:group_id {:type :SortOperator},
:title {:type :SortOperator},
:color {:type :SortOperator}},
:fields
{:id {:type Int},
:group_id {:type Int},
:title {:type String},
:color {:type String}},
:aggregate
{:count {:type Int},
:sum {:type :RoleFields},
:avg {:type :RoleFields},
:max {:type :RoleFields},
:min {:type :RoleFields}},
:pks {:id {:type (non-null Int)}},
:pk-input {:id {:type (non-null Int)}},
:update
{:group_id {:type Int},
:title {:type String},
:color {:type String}}},
:fks
{:group_id
{:field-keys
{:to :Group,
:has-many :roles,
:has-many-aggr :roles_aggregate,
:has-one :group}}},
:lcn-mut-keys
{:create :createRole, :update :updateRole, :delete :deleteRole},
:lcn-obj-keys
{:rsc :Role,
:clauses :RoleClauses,
:where :RoleWhere,
:sort :RoleSort,
:fields :RoleFields,
:aggregate :RoleAggregate,
:pks :RolePks,
:pk-input :RolePkColumns},
:lcn-qry-keys {:queries :roles, :aggregate :roles_aggregate},
:lcn-descs
{:rsc "Roles",
:query "Query Roles.",
:clauses
"Format for where clauses is {column: {operator: value}}. Multiple parameters are applied with `AND` operators. `AND`/`OR` conditions can be created as a list of clauses. It is possible to nest them to create sub groups of conditions.",
:sort "Sort format is {column: \"asc\" or \"desc\"}.",
:fields "Rolesfields for aggregation.",
:aggregate "Aggrecate Roles.",
:pks "Primary key fields.",
:pk-input "Primary key fields."},
:groups
{:lcn-fields
{:rsc
{:access {:type Int},
:created_at {:type String},
:edited_at {:type String},
:id {:type Int},
:title {:type String},
:user_id {:type String},
:description {:type String}},
:clauses
{:description {:type :StrWhere},
:or {:type (list :GroupClauses)},
:title {:type :StrWhere},
:id {:type :IntWhere},
:and {:type (list :GroupClauses)},
:user_id {:type :StrWhere},
:access {:type :IntWhere},
:edited_at {:type :StrWhere},
:created_at {:type :StrWhere}},
:sort
{:access {:type :SortOperator},
:created_at {:type :SortOperator},
:edited_at {:type :SortOperator},
:id {:type :SortOperator},
:title {:type :SortOperator},
:user_id {:type :SortOperator},
:description {:type :SortOperator}},
:fields
{:access {:type Int},
:created_at {:type String},
:edited_at {:type String},
:id {:type Int},
:title {:type String},
:user_id {:type String},
:description {:type String}},
:aggregate
{:count {:type Int},
:sum {:type :GroupFields},
:avg {:type :GroupFields},
:max {:type :GroupFields},
:min {:type :GroupFields}},
:pks {:id {:type (non-null Int)}},
:pk-input {:id {:type (non-null Int)}},
:update
{:access {:type Int},
:created_at {:type String},
:edited_at {:type String},
:title {:type String},
:user_id {:type String},
:description {:type String}}},
:fks
{:access
{:field-keys
{:to :Access,
:has-many :groups,
:has-many-aggr :groups_aggregate,
:has-one :access_access}},
:user_id
{:field-keys
{:to :User,
:has-many :groups,
:has-many-aggr :groups_aggregate,
:has-one :user}}},
:lcn-mut-keys
{:create :createGroup,
:update :updateGroup,
:delete :deleteGroup},
:lcn-obj-keys
{:rsc :Group,
:clauses :GroupClauses,
:where :GroupWhere,
:sort :GroupSort,
:fields :GroupFields,
:aggregate :GroupAggregate,
:pks :GroupPks,
:pk-input :GroupPkColumns},
:lcn-qry-keys {:queries :groups, :aggregate :groups_aggregate},
:lcn-descs
{:rsc "Groups",
:query "Query Groups.",
:clauses
"Format for where clauses is {column: {operator: value}}. Multiple parameters are applied with `AND` operators. `AND`/`OR` conditions can be created as a list of clauses. It is possible to nest them to create sub groups of conditions.",
:sort "Sort format is {column: \"asc\" or \"desc\"}.",
:fields "Groupsfields for aggregation.",
:aggregate "Aggrecate Groups.",
:pks "Primary key fields.",
:pk-input "Primary key fields."},
:signals
{:query {:pre (), :post ()},
:create {:pre (), :post ()},
:delete {:pre (), :post ()},
:update {:pre (), :post ()}},
:pk-keys (:id),
:col-keys
#{:description
:title
:id
:user_id
:access
:edited_at
:created_at}},
:signals
{:query {:pre (), :post ()},
:create {:pre (), :post ()},
:delete {:pre (), :post ()},
:update {:pre (), :post ()}},
:pk-keys (:id),
:col-keys #{:color :title :group_id :id}},
:lcn-obj-keys
{:rsc :Attribute,
:clauses :AttributeClauses,
:where :AttributeWhere,
:sort :AttributeSort,
:fields :AttributeFields,
:aggregate :AttributeAggregate,
:pks :AttributePks,
:pk-input :AttributePkColumns},
:lcn-qry-keys
{:queries :attributes, :aggregate :attributes_aggregate},
:lcn-descs
{:rsc "Attributes",
:query "Query Attributes.",
:clauses
"Format for where clauses is {column: {operator: value}}. Multiple parameters are applied with `AND` operators. `AND`/`OR` conditions can be created as a list of clauses. It is possible to nest them to create sub groups of conditions.",
:sort "Sort format is {column: \"asc\" or \"desc\"}.",
:fields "Attributesfields for aggregation.",
:aggregate "Aggrecate Attributes.",
:pks "Primary key fields.",
:pk-input "Primary key fields."},
:access
{:lcn-fields
{:rsc
{:can_read {:type Boolean},
:inherit {:type Boolean},
:can_edit {:type Boolean},
:group_id {:type Int},
:id {:type Int},
:user_id {:type String},
:role_id {:type Int},
:next_access {:type Int},
:owner {:type Boolean}},
:clauses
{:can_read {:type :BoolWhere},
:inherit {:type :BoolWhere},
:can_edit {:type :BoolWhere},
:or {:type (list :AccessClauses)},
:group_id {:type :IntWhere},
:id {:type :IntWhere},
:and {:type (list :AccessClauses)},
:user_id {:type :StrWhere},
:role_id {:type :IntWhere},
:next_access {:type :IntWhere},
:owner {:type :BoolWhere}},
:sort
{:can_read {:type :SortOperator},
:inherit {:type :SortOperator},
:can_edit {:type :SortOperator},
:group_id {:type :SortOperator},
:id {:type :SortOperator},
:user_id {:type :SortOperator},
:role_id {:type :SortOperator},
:next_access {:type :SortOperator},
:owner {:type :SortOperator}},
:fields
{:can_read {:type Boolean},
:inherit {:type Boolean},
:can_edit {:type Boolean},
:group_id {:type Int},
:id {:type Int},
:user_id {:type String},
:role_id {:type Int},
:next_access {:type Int},
:owner {:type Boolean}},
:aggregate
{:count {:type Int},
:sum {:type :AccessFields},
:avg {:type :AccessFields},
:max {:type :AccessFields},
:min {:type :AccessFields}},
:pks {:id {:type (non-null Int)}},
:pk-input {:id {:type (non-null Int)}},
:update
{:can_read {:type Boolean},
:inherit {:type Boolean},
:can_edit {:type Boolean},
:group_id {:type Int},
:user_id {:type String},
:role_id {:type Int},
:next_access {:type Int},
:owner {:type Boolean}}},
:fks
{:next_access
{:field-keys
{:to :Access,
:has-many :accesses,
:has-many-aggr :accesses_aggregate,
:has-one :next_access_access}},
:role_id
{:field-keys
{:to :Role,
:has-many :accesses,
:has-many-aggr :accesses_aggregate,
:has-one :role}},
:user_id
{:field-keys
{:to :User,
:has-many :accesses,
:has-many-aggr :accesses_aggregate,
:has-one :user}},
:group_id
{:field-keys
{:to :Group,
:has-many :accesses,
:has-many-aggr :accesses_aggregate,
:has-one :group}}},
:lcn-mut-keys
{:create :createAccess,
:update :updateAccess,
:delete :deleteAccess},
:roles
{:lcn-fields
{:rsc
{:id {:type Int},
:group_id {:type Int},
:title {:type String},
:color {:type String}},
:clauses
{:and {:type (list :RoleClauses)},
:or {:type (list :RoleClauses)},
:id {:type :IntWhere},
:group_id {:type :IntWhere},
:title {:type :StrWhere},
:color {:type :StrWhere}},
:sort
{:id {:type :SortOperator},
:group_id {:type :SortOperator},
:title {:type :SortOperator},
:color {:type :SortOperator}},
:fields
{:id {:type Int},
:group_id {:type Int},
:title {:type String},
:color {:type String}},
:aggregate
{:count {:type Int},
:sum {:type :RoleFields},
:avg {:type :RoleFields},
:max {:type :RoleFields},
:min {:type :RoleFields}},
:pks {:id {:type (non-null Int)}},
:pk-input {:id {:type (non-null Int)}},
:update
{:group_id {:type Int},
:title {:type String},
:color {:type String}}},
:fks
{:group_id
{:field-keys
{:to :Group,
:has-many :roles,
:has-many-aggr :roles_aggregate,
:has-one :group}}},
:lcn-mut-keys
{:create :createRole, :update :updateRole, :delete :deleteRole},
:lcn-obj-keys
{:rsc :Role,
:clauses :RoleClauses,
:where :RoleWhere,
:sort :RoleSort,
:fields :RoleFields,
:aggregate :RoleAggregate,
:pks :RolePks,
:pk-input :RolePkColumns},
:lcn-qry-keys {:queries :roles, :aggregate :roles_aggregate},
:lcn-descs
{:rsc "Roles",
:query "Query Roles.",
:clauses
"Format for where clauses is {column: {operator: value}}. Multiple parameters are applied with `AND` operators. `AND`/`OR` conditions can be created as a list of clauses. It is possible to nest them to create sub groups of conditions.",
:sort "Sort format is {column: \"asc\" or \"desc\"}.",
:fields "Rolesfields for aggregation.",
:aggregate "Aggrecate Roles.",
:pks "Primary key fields.",
:pk-input "Primary key fields."},
:groups
{:lcn-fields
{:rsc
{:access {:type Int},
:created_at {:type String},
:edited_at {:type String},
:id {:type Int},
:title {:type String},
:user_id {:type String},
:description {:type String}},
:clauses
{:description {:type :StrWhere},
:or {:type (list :GroupClauses)},
:title {:type :StrWhere},
:id {:type :IntWhere},
:and {:type (list :GroupClauses)},
:user_id {:type :StrWhere},
:access {:type :IntWhere},
:edited_at {:type :StrWhere},
:created_at {:type :StrWhere}},
:sort
{:access {:type :SortOperator},
:created_at {:type :SortOperator},
:edited_at {:type :SortOperator},
:id {:type :SortOperator},
:title {:type :SortOperator},
:user_id {:type :SortOperator},
:description {:type :SortOperator}},
:fields
{:access {:type Int},
:created_at {:type String},
:edited_at {:type String},
:id {:type Int},
:title {:type String},
:user_id {:type String},
:description {:type String}},
:aggregate
{:count {:type Int},
:sum {:type :GroupFields},
:avg {:type :GroupFields},
:max {:type :GroupFields},
:min {:type :GroupFields}},
:pks {:id {:type (non-null Int)}},
:pk-input {:id {:type (non-null Int)}},
:update
{:access {:type Int},
:created_at {:type String},
:edited_at {:type String},
:title {:type String},
:user_id {:type String},
:description {:type String}}},
:fks
{:access
{:field-keys
{:to :Access,
:has-many :groups,
:has-many-aggr :groups_aggregate,
:has-one :access_access}},
:user_id
{:field-keys
{:to :User,
:has-many :groups,
:has-many-aggr :groups_aggregate,
:has-one :user}}},
:lcn-mut-keys
{:create :createGroup,
:update :updateGroup,
:delete :deleteGroup},
:lcn-obj-keys
{:rsc :Group,
:clauses :GroupClauses,
:where :GroupWhere,
:sort :GroupSort,
:fields :GroupFields,
:aggregate :GroupAggregate,
:pks :GroupPks,
:pk-input :GroupPkColumns},
:lcn-qry-keys {:queries :groups, :aggregate :groups_aggregate},
:lcn-descs
{:rsc "Groups",
:query "Query Groups.",
:clauses
"Format for where clauses is {column: {operator: value}}. Multiple parameters are applied with `AND` operators. `AND`/`OR` conditions can be created as a list of clauses. It is possible to nest them to create sub groups of conditions.",
:sort "Sort format is {column: \"asc\" or \"desc\"}.",
:fields "Groupsfields for aggregation.",
:aggregate "Aggrecate Groups.",
:pks "Primary key fields.",
:pk-input "Primary key fields."},
:signals
{:query {:pre (), :post ()},
:create {:pre (), :post ()},
:delete {:pre (), :post ()},
:update {:pre (), :post ()}},
:pk-keys (:id),
:col-keys
#{:description
:title
:id
:user_id
:access
:edited_at
:created_at}},
:signals
{:query {:pre (), :post ()},
:create {:pre (), :post ()},
:delete {:pre (), :post ()},
:update {:pre (), :post ()}},
:pk-keys (:id),
:col-keys #{:color :title :group_id :id}},
:lcn-obj-keys
{:rsc :Access,
:clauses :AccessClauses,
:where :AccessWhere,
:sort :AccessSort,
:fields :AccessFields,
:aggregate :AccessAggregate,
:pks :AccessPks,
:pk-input :AccessPkColumns},
:lcn-qry-keys
{:queries :accesses, :aggregate :accesses_aggregate},
:lcn-descs
{:rsc "Accesses",
:query "Query Accesses.",
:clauses
"Format for where clauses is {column: {operator: value}}. Multiple parameters are applied with `AND` operators. `AND`/`OR` conditions can be created as a list of clauses. It is possible to nest them to create sub groups of conditions.",
:sort "Sort format is {column: \"asc\" or \"desc\"}.",
:fields "Accessesfields for aggregation.",
:aggregate "Aggrecate Accesses.",
:pks "Primary key fields.",
:pk-input "Primary key fields."},
:groups
{:lcn-fields
{:rsc
{:access {:type Int},
:created_at {:type String},
:edited_at {:type String},
:id {:type Int},
:title {:type String},
:user_id {:type String},
:description {:type String}},
:clauses
{:description {:type :StrWhere},
:or {:type (list :GroupClauses)},
:title {:type :StrWhere},
:id {:type :IntWhere},
:and {:type (list :GroupClauses)},
:user_id {:type :StrWhere},
:access {:type :IntWhere},
:edited_at {:type :StrWhere},
:created_at {:type :StrWhere}},
:sort
{:access {:type :SortOperator},
:created_at {:type :SortOperator},
:edited_at {:type :SortOperator},
:id {:type :SortOperator},
:title {:type :SortOperator},
:user_id {:type :SortOperator},
:description {:type :SortOperator}},
:fields
{:access {:type Int},
:created_at {:type String},
:edited_at {:type String},
:id {:type Int},
:title {:type String},
:user_id {:type String},
:description {:type String}},
:aggregate
{:count {:type Int},
:sum {:type :GroupFields},
:avg {:type :GroupFields},
:max {:type :GroupFields},
:min {:type :GroupFields}},
:pks {:id {:type (non-null Int)}},
:pk-input {:id {:type (non-null Int)}},
:update
{:access {:type Int},
:created_at {:type String},
:edited_at {:type String},
:title {:type String},
:user_id {:type String},
:description {:type String}}},
:fks
{:access
{:field-keys
{:to :Access,
:has-many :groups,
:has-many-aggr :groups_aggregate,
:has-one :access_access}},
:user_id
{:field-keys
{:to :User,
:has-many :groups,
:has-many-aggr :groups_aggregate,
:has-one :user}}},
:lcn-mut-keys
{:create :createGroup,
:update :updateGroup,
:delete :deleteGroup},
:lcn-obj-keys
{:rsc :Group,
:clauses :GroupClauses,
:where :GroupWhere,
:sort :GroupSort,
:fields :GroupFields,
:aggregate :GroupAggregate,
:pks :GroupPks,
:pk-input :GroupPkColumns},
:lcn-qry-keys {:queries :groups, :aggregate :groups_aggregate},
:lcn-descs
{:rsc "Groups",
:query "Query Groups.",
:clauses
"Format for where clauses is {column: {operator: value}}. Multiple parameters are applied with `AND` operators. `AND`/`OR` conditions can be created as a list of clauses. It is possible to nest them to create sub groups of conditions.",
:sort "Sort format is {column: \"asc\" or \"desc\"}.",
:fields "Groupsfields for aggregation.",
:aggregate "Aggrecate Groups.",
:pks "Primary key fields.",
:pk-input "Primary key fields."},
:signals
{:query {:pre (), :post ()},
:create {:pre (), :post ()},
:delete {:pre (), :post ()},
:update {:pre (), :post ()}},
:pk-keys (:id),
:col-keys
#{:description
:title
:id
:user_id
:access
:edited_at
:created_at}},
:signals
{:query {:pre (), :post ()},
:create {:pre (), :post ()},
:delete {:pre (), :post ()},
:update {:pre (), :post ()}},
:pk-keys (:id),
:col-keys
#{:can_read
:inherit
:can_edit
:group_id
:id
:user_id
:role_id
:next_access
:owner}},
:groups
{:lcn-fields
{:rsc
{:access {:type Int},
:created_at {:type String},
:edited_at {:type String},
:id {:type Int},
:title {:type String},
:user_id {:type String},
:description {:type String}},
:clauses
{:description {:type :StrWhere},
:or {:type (list :GroupClauses)},
:title {:type :StrWhere},
:id {:type :IntWhere},
:and {:type (list :GroupClauses)},
:user_id {:type :StrWhere},
:access {:type :IntWhere},
:edited_at {:type :StrWhere},
:created_at {:type :StrWhere}},
:sort
{:access {:type :SortOperator},
:created_at {:type :SortOperator},
:edited_at {:type :SortOperator},
:id {:type :SortOperator},
:title {:type :SortOperator},
:user_id {:type :SortOperator},
:description {:type :SortOperator}},
:fields
{:access {:type Int},
:created_at {:type String},
:edited_at {:type String},
:id {:type Int},
:title {:type String},
:user_id {:type String},
:description {:type String}},
:aggregate
{:count {:type Int},
:sum {:type :GroupFields},
:avg {:type :GroupFields},
:max {:type :GroupFields},
:min {:type :GroupFields}},
:pks {:id {:type (non-null Int)}},
:pk-input {:id {:type (non-null Int)}},
:update
{:access {:type Int},
:created_at {:type String},
:edited_at {:type String},
:title {:type String},
:user_id {:type String},
:description {:type String}}},
:fks
{:access
{:field-keys
{:to :Access,
:has-many :groups,
:has-many-aggr :groups_aggregate,
:has-one :access_access}},
:user_id
{:field-keys
{:to :User,
:has-many :groups,
:has-many-aggr :groups_aggregate,
:has-one :user}}},
:lcn-mut-keys
{:create :createGroup,
:update :updateGroup,
:delete :deleteGroup},
:lcn-obj-keys
{:rsc :Group,
:clauses :GroupClauses,
:where :GroupWhere,
:sort :GroupSort,
:fields :GroupFields,
:aggregate :GroupAggregate,
:pks :GroupPks,
:pk-input :GroupPkColumns},
:lcn-qry-keys {:queries :groups, :aggregate :groups_aggregate},
:lcn-descs
{:rsc "Groups",
:query "Query Groups.",
:clauses
"Format for where clauses is {column: {operator: value}}. Multiple parameters are applied with `AND` operators. `AND`/`OR` conditions can be created as a list of clauses. It is possible to nest them to create sub groups of conditions.",
:sort "Sort format is {column: \"asc\" or \"desc\"}.",
:fields "Groupsfields for aggregation.",
:aggregate "Aggrecate Groups.",
:pks "Primary key fields.",
:pk-input "Primary key fields."},
:signals
{:query {:pre (), :post ()},
:create {:pre (), :post ()},
:delete {:pre (), :post ()},
:update {:pre (), :post ()}},
:pk-keys (:id),
:col-keys
#{:description
:title
:id
:user_id
:access
:edited_at
:created_at}},
:items
{:lcn-fields
{:rsc
{:slug {:type String},
:domain_pk {:type String},
:title {:type String},
:domain_pk_namespace {:type String},
:id {:type Int},
:url {:type String},
:access {:type Int},
:edited_at {:type String},
:body {:type String},
:created_at {:type String}},
:clauses
{:slug {:type :StrWhere},
:domain_pk {:type :StrWhere},
:or {:type (list :ItemClauses)},
:title {:type :StrWhere},
:domain_pk_namespace {:type :StrWhere},
:id {:type :IntWhere},
:url {:type :StrWhere},
:and {:type (list :ItemClauses)},
:access {:type :IntWhere},
:edited_at {:type :StrWhere},
:body {:type :StrWhere},
:created_at {:type :StrWhere}},
:sort
{:slug {:type :SortOperator},
:domain_pk {:type :SortOperator},
:title {:type :SortOperator},
:domain_pk_namespace {:type :SortOperator},
:id {:type :SortOperator},
:url {:type :SortOperator},
:access {:type :SortOperator},
:edited_at {:type :SortOperator},
:body {:type :SortOperator},
:created_at {:type :SortOperator}},
:fields
{:slug {:type String},
:domain_pk {:type String},
:title {:type String},
:domain_pk_namespace {:type String},
:id {:type Int},
:url {:type String},
:access {:type Int},
:edited_at {:type String},
:body {:type String},
:created_at {:type String}},
:aggregate
{:count {:type Int},
:sum {:type :ItemFields},
:avg {:type :ItemFields},
:max {:type :ItemFields},
:min {:type :ItemFields}},
:pks {:id {:type (non-null Int)}},
:pk-input {:id {:type (non-null Int)}},
:update
{:slug {:type String},
:domain_pk {:type String},
:title {:type String},
:domain_pk_namespace {:type String},
:url {:type String},
:access {:type Int},
:edited_at {:type String},
:body {:type String},
:created_at {:type String}}},
:fks
{:access
{:field-keys
{:to :Access,
:has-many :items,
:has-many-aggr :items_aggregate,
:has-one :access_access}}},
:lcn-mut-keys
{:create :createItem, :update :updateItem, :delete :deleteItem},
:roles
{:lcn-fields
{:rsc
{:id {:type Int},
:group_id {:type Int},
:title {:type String},
:color {:type String}},
:clauses
{:and {:type (list :RoleClauses)},
:or {:type (list :RoleClauses)},
:id {:type :IntWhere},
:group_id {:type :IntWhere},
:title {:type :StrWhere},
:color {:type :StrWhere}},
:sort
{:id {:type :SortOperator},
:group_id {:type :SortOperator},
:title {:type :SortOperator},
:color {:type :SortOperator}},
:fields
{:id {:type Int},
:group_id {:type Int},
:title {:type String},
:color {:type String}},
:aggregate
{:count {:type Int},
:sum {:type :RoleFields},
:avg {:type :RoleFields},
:max {:type :RoleFields},
:min {:type :RoleFields}},
:pks {:id {:type (non-null Int)}},
:pk-input {:id {:type (non-null Int)}},
:update
{:group_id {:type Int},
:title {:type String},
:color {:type String}}},
:fks
{:group_id
{:field-keys
{:to :Group,
:has-many :roles,
:has-many-aggr :roles_aggregate,
:has-one :group}}},
:lcn-mut-keys
{:create :createRole, :update :updateRole, :delete :deleteRole},
:lcn-obj-keys
{:rsc :Role,
:clauses :RoleClauses,
:where :RoleWhere,
:sort :RoleSort,
:fields :RoleFields,
:aggregate :RoleAggregate,
:pks :RolePks,
:pk-input :RolePkColumns},
:lcn-qry-keys {:queries :roles, :aggregate :roles_aggregate},
:lcn-descs
{:rsc "Roles",
:query "Query Roles.",
:clauses
"Format for where clauses is {column: {operator: value}}. Multiple parameters are applied with `AND` operators. `AND`/`OR` conditions can be created as a list of clauses. It is possible to nest them to create sub groups of conditions.",
:sort "Sort format is {column: \"asc\" or \"desc\"}.",
:fields "Rolesfields for aggregation.",
:aggregate "Aggrecate Roles.",
:pks "Primary key fields.",
:pk-input "Primary key fields."},
:groups
{:lcn-fields
{:rsc
{:access {:type Int},
:created_at {:type String},
:edited_at {:type String},
:id {:type Int},
:title {:type String},
:user_id {:type String},
:description {:type String}},
:clauses
{:description {:type :StrWhere},
:or {:type (list :GroupClauses)},
:title {:type :StrWhere},
:id {:type :IntWhere},
:and {:type (list :GroupClauses)},
:user_id {:type :StrWhere},
:access {:type :IntWhere},
:edited_at {:type :StrWhere},
:created_at {:type :StrWhere}},
:sort
{:access {:type :SortOperator},
:created_at {:type :SortOperator},
:edited_at {:type :SortOperator},
:id {:type :SortOperator},
:title {:type :SortOperator},
:user_id {:type :SortOperator},
:description {:type :SortOperator}},
:fields
{:access {:type Int},
:created_at {:type String},
:edited_at {:type String},
:id {:type Int},
:title {:type String},
:user_id {:type String},
:description {:type String}},
:aggregate
{:count {:type Int},
:sum {:type :GroupFields},
:avg {:type :GroupFields},
:max {:type :GroupFields},
:min {:type :GroupFields}},
:pks {:id {:type (non-null Int)}},
:pk-input {:id {:type (non-null Int)}},
:update
{:access {:type Int},
:created_at {:type String},
:edited_at {:type String},
:title {:type String},
:user_id {:type String},
:description {:type String}}},
:fks
{:access
{:field-keys
{:to :Access,
:has-many :groups,
:has-many-aggr :groups_aggregate,
:has-one :access_access}},
:user_id
{:field-keys
{:to :User,
:has-many :groups,
:has-many-aggr :groups_aggregate,
:has-one :user}}},
:lcn-mut-keys
{:create :createGroup,
:update :updateGroup,
:delete :deleteGroup},
:lcn-obj-keys
{:rsc :Group,
:clauses :GroupClauses,
:where :GroupWhere,
:sort :GroupSort,
:fields :GroupFields,
:aggregate :GroupAggregate,
:pks :GroupPks,
:pk-input :GroupPkColumns},
:lcn-qry-keys {:queries :groups, :aggregate :groups_aggregate},
:lcn-descs
{:rsc "Groups",
:query "Query Groups.",
:clauses
"Format for where clauses is {column: {operator: value}}. Multiple parameters are applied with `AND` operators. `AND`/`OR` conditions can be created as a list of clauses. It is possible to nest them to create sub groups of conditions.",
:sort "Sort format is {column: \"asc\" or \"desc\"}.",
:fields "Groupsfields for aggregation.",
:aggregate "Aggrecate Groups.",
:pks "Primary key fields.",
:pk-input "Primary key fields."},
:signals
{:query {:pre (), :post ()},
:create {:pre (), :post ()},
:delete {:pre (), :post ()},
:update {:pre (), :post ()}},
:pk-keys (:id),
:col-keys
#{:description
:title
:id
:user_id
:access
:edited_at
:created_at}},
:signals
{:query {:pre (), :post ()},
:create {:pre (), :post ()},
:delete {:pre (), :post ()},
:update {:pre (), :post ()}},
:pk-keys (:id),
:col-keys #{:color :title :group_id :id}},
:lcn-obj-keys
{:rsc :Item,
:clauses :ItemClauses,
:where :ItemWhere,
:sort :ItemSort,
:fields :ItemFields,
:aggregate :ItemAggregate,
:pks :ItemPks,
:pk-input :ItemPkColumns},
:lcn-qry-keys {:queries :items, :aggregate :items_aggregate},
:lcn-descs
{:rsc "Items",
:query "Query Items.",
:clauses
"Format for where clauses is {column: {operator: value}}. Multiple parameters are applied with `AND` operators. `AND`/`OR` conditions can be created as a list of clauses. It is possible to nest them to create sub groups of conditions.",
:sort "Sort format is {column: \"asc\" or \"desc\"}.",
:fields "Itemsfields for aggregation.",
:aggregate "Aggrecate Items.",
:pks "Primary key fields.",
:pk-input "Primary key fields."},
:access
{:lcn-fields
{:rsc
{:can_read {:type Boolean},
:inherit {:type Boolean},
:can_edit {:type Boolean},
:group_id {:type Int},
:id {:type Int},
:user_id {:type String},
:role_id {:type Int},
:next_access {:type Int},
:owner {:type Boolean}},
:clauses
{:can_read {:type :BoolWhere},
:inherit {:type :BoolWhere},
:can_edit {:type :BoolWhere},
:or {:type (list :AccessClauses)},
:group_id {:type :IntWhere},
:id {:type :IntWhere},
:and {:type (list :AccessClauses)},
:user_id {:type :StrWhere},
:role_id {:type :IntWhere},
:next_access {:type :IntWhere},
:owner {:type :BoolWhere}},
:sort
{:can_read {:type :SortOperator},
:inherit {:type :SortOperator},
:can_edit {:type :SortOperator},
:group_id {:type :SortOperator},
:id {:type :SortOperator},
:user_id {:type :SortOperator},
:role_id {:type :SortOperator},
:next_access {:type :SortOperator},
:owner {:type :SortOperator}},
:fields
{:can_read {:type Boolean},
:inherit {:type Boolean},
:can_edit {:type Boolean},
:group_id {:type Int},
:id {:type Int},
:user_id {:type String},
:role_id {:type Int},
:next_access {:type Int},
:owner {:type Boolean}},
:aggregate
{:count {:type Int},
:sum {:type :AccessFields},
:avg {:type :AccessFields},
:max {:type :AccessFields},
:min {:type :AccessFields}},
:pks {:id {:type (non-null Int)}},
:pk-input {:id {:type (non-null Int)}},
:update
{:can_read {:type Boolean},
:inherit {:type Boolean},
:can_edit {:type Boolean},
:group_id {:type Int},
:user_id {:type String},
:role_id {:type Int},
:next_access {:type Int},
:owner {:type Boolean}}},
:fks
{:next_access
{:field-keys
{:to :Access,
:has-many :accesses,
:has-many-aggr :accesses_aggregate,
:has-one :next_access_access}},
:role_id
{:field-keys
{:to :Role,
:has-many :accesses,
:has-many-aggr :accesses_aggregate,
:has-one :role}},
:user_id
{:field-keys
{:to :User,
:has-many :accesses,
:has-many-aggr :accesses_aggregate,
:has-one :user}},
:group_id
{:field-keys
{:to :Group,
:has-many :accesses,
:has-many-aggr :accesses_aggregate,
:has-one :group}}},
:lcn-mut-keys
{:create :createAccess,
:update :updateAccess,
:delete :deleteAccess},
:roles
{:lcn-fields
{:rsc
{:id {:type Int},
:group_id {:type Int},
:title {:type String},
:color {:type String}},
:clauses
{:and {:type (list :RoleClauses)},
:or {:type (list :RoleClauses)},
:id {:type :IntWhere},
:group_id {:type :IntWhere},
:title {:type :StrWhere},
:color {:type :StrWhere}},
:sort
{:id {:type :SortOperator},
:group_id {:type :SortOperator},
:title {:type :SortOperator},
:color {:type :SortOperator}},
:fields
{:id {:type Int},
:group_id {:type Int},
:title {:type String},
:color {:type String}},
:aggregate
{:count {:type Int},
:sum {:type :RoleFields},
:avg {:type :RoleFields},
:max {:type :RoleFields},
:min {:type :RoleFields}},
:pks {:id {:type (non-null Int)}},
:pk-input {:id {:type (non-null Int)}},
:update
{:group_id {:type Int},
:title {:type String},
:color {:type String}}},
:fks
{:group_id
{:field-keys
{:to :Group,
:has-many :roles,
:has-many-aggr :roles_aggregate,
:has-one :group}}},
:lcn-mut-keys
{:create :createRole,
:update :updateRole,
:delete :deleteRole},
:lcn-obj-keys
{:rsc :Role,
:clauses :RoleClauses,
:where :RoleWhere,
:sort :RoleSort,
:fields :RoleFields,
:aggregate :RoleAggregate,
:pks :RolePks,
:pk-input :RolePkColumns},
:lcn-qry-keys {:queries :roles, :aggregate :roles_aggregate},
:lcn-descs
{:rsc "Roles",
:query "Query Roles.",
:clauses
"Format for where clauses is {column: {operator: value}}. Multiple parameters are applied with `AND` operators. `AND`/`OR` conditions can be created as a list of clauses. It is possible to nest them to create sub groups of conditions.",
:sort "Sort format is {column: \"asc\" or \"desc\"}.",
:fields "Rolesfields for aggregation.",
:aggregate "Aggrecate Roles.",
:pks "Primary key fields.",
:pk-input "Primary key fields."},
:groups
{:lcn-fields
{:rsc
{:access {:type Int},
:created_at {:type String},
:edited_at {:type String},
:id {:type Int},
:title {:type String},
:user_id {:type String},
:description {:type String}},
:clauses
{:description {:type :StrWhere},
:or {:type (list :GroupClauses)},
:title {:type :StrWhere},
:id {:type :IntWhere},
:and {:type (list :GroupClauses)},
:user_id {:type :StrWhere},
:access {:type :IntWhere},
:edited_at {:type :StrWhere},
:created_at {:type :StrWhere}},
:sort
{:access {:type :SortOperator},
:created_at {:type :SortOperator},
:edited_at {:type :SortOperator},
:id {:type :SortOperator},
:title {:type :SortOperator},
:user_id {:type :SortOperator},
:description {:type :SortOperator}},
:fields
{:access {:type Int},
:created_at {:type String},
:edited_at {:type String},
:id {:type Int},
:title {:type String},
:user_id {:type String},
:description {:type String}},
:aggregate
{:count {:type Int},
:sum {:type :GroupFields},
:avg {:type :GroupFields},
:max {:type :GroupFields},
:min {:type :GroupFields}},
:pks {:id {:type (non-null Int)}},
:pk-input {:id {:type (non-null Int)}},
:update
{:access {:type Int},
:created_at {:type String},
:edited_at {:type String},
:title {:type String},
:user_id {:type String},
:description {:type String}}},
:fks
{:access
{:field-keys
{:to :Access,
:has-many :groups,
:has-many-aggr :groups_aggregate,
:has-one :access_access}},
:user_id
{:field-keys
{:to :User,
:has-many :groups,
:has-many-aggr :groups_aggregate,
:has-one :user}}},
:lcn-mut-keys
{:create :createGroup,
:update :updateGroup,
:delete :deleteGroup},
:lcn-obj-keys
{:rsc :Group,
:clauses :GroupClauses,
:where :GroupWhere,
:sort :GroupSort,
:fields :GroupFields,
:aggregate :GroupAggregate,
:pks :GroupPks,
:pk-input :GroupPkColumns},
:lcn-qry-keys
{:queries :groups, :aggregate :groups_aggregate},
:lcn-descs
{:rsc "Groups",
:query "Query Groups.",
:clauses
"Format for where clauses is {column: {operator: value}}. Multiple parameters are applied with `AND` operators. `AND`/`OR` conditions can be created as a list of clauses. It is possible to nest them to create sub groups of conditions.",
:sort "Sort format is {column: \"asc\" or \"desc\"}.",
:fields "Groupsfields for aggregation.",
:aggregate "Aggrecate Groups.",
:pks "Primary key fields.",
:pk-input "Primary key fields."},
:signals
{:query {:pre (), :post ()},
:create {:pre (), :post ()},
:delete {:pre (), :post ()},
:update {:pre (), :post ()}},
:pk-keys (:id),
:col-keys
#{:description
:title
:id
:user_id
:access
:edited_at
:created_at}},
:signals
{:query {:pre (), :post ()},
:create {:pre (), :post ()},
:delete {:pre (), :post ()},
:update {:pre (), :post ()}},
:pk-keys (:id),
:col-keys #{:color :title :group_id :id}},
:lcn-obj-keys
{:rsc :Access,
:clauses :AccessClauses,
:where :AccessWhere,
:sort :AccessSort,
:fields :AccessFields,
:aggregate :AccessAggregate,
:pks :AccessPks,
:pk-input :AccessPkColumns},
:lcn-qry-keys
{:queries :accesses, :aggregate :accesses_aggregate},
:lcn-descs
{:rsc "Accesses",
:query "Query Accesses.",
:clauses
"Format for where clauses is {column: {operator: value}}. Multiple parameters are applied with `AND` operators. `AND`/`OR` conditions can be created as a list of clauses. It is possible to nest them to create sub groups of conditions.",
:sort "Sort format is {column: \"asc\" or \"desc\"}.",
:fields "Accessesfields for aggregation.",
:aggregate "Aggrecate Accesses.",
:pks "Primary key fields.",
:pk-input "Primary key fields."},
:groups
{:lcn-fields
{:rsc
{:access {:type Int},
:created_at {:type String},
:edited_at {:type String},
:id {:type Int},
:title {:type String},
:user_id {:type String},
:description {:type String}},
:clauses
{:description {:type :StrWhere},
:or {:type (list :GroupClauses)},
:title {:type :StrWhere},
:id {:type :IntWhere},
:and {:type (list :GroupClauses)},
:user_id {:type :StrWhere},
:access {:type :IntWhere},
:edited_at {:type :StrWhere},
:created_at {:type :StrWhere}},
:sort
{:access {:type :SortOperator},
:created_at {:type :SortOperator},
:edited_at {:type :SortOperator},
:id {:type :SortOperator},
:title {:type :SortOperator},
:user_id {:type :SortOperator},
:description {:type :SortOperator}},
:fields
{:access {:type Int},
:created_at {:type String},
:edited_at {:type String},
:id {:type Int},
:title {:type String},
:user_id {:type String},
:description {:type String}},
:aggregate
{:count {:type Int},
:sum {:type :GroupFields},
:avg {:type :GroupFields},
:max {:type :GroupFields},
:min {:type :GroupFields}},
:pks {:id {:type (non-null Int)}},
:pk-input {:id {:type (non-null Int)}},
:update
{:access {:type Int},
:created_at {:type String},
:edited_at {:type String},
:title {:type String},
:user_id {:type String},
:description {:type String}}},
:fks
{:access
{:field-keys
{:to :Access,
:has-many :groups,
:has-many-aggr :groups_aggregate,
:has-one :access_access}},
:user_id
{:field-keys
{:to :User,
:has-many :groups,
:has-many-aggr :groups_aggregate,
:has-one :user}}},
:lcn-mut-keys
{:create :createGroup,
:update :updateGroup,
:delete :deleteGroup},
:lcn-obj-keys
{:rsc :Group,
:clauses :GroupClauses,
:where :GroupWhere,
:sort :GroupSort,
:fields :GroupFields,
:aggregate :GroupAggregate,
:pks :GroupPks,
:pk-input :GroupPkColumns},
:lcn-qry-keys {:queries :groups, :aggregate :groups_aggregate},
:lcn-descs
{:rsc "Groups",
:query "Query Groups.",
:clauses
"Format for where clauses is {column: {operator: value}}. Multiple parameters are applied with `AND` operators. `AND`/`OR` conditions can be created as a list of clauses. It is possible to nest them to create sub groups of conditions.",
:sort "Sort format is {column: \"asc\" or \"desc\"}.",
:fields "Groupsfields for aggregation.",
:aggregate "Aggrecate Groups.",
:pks "Primary key fields.",
:pk-input "Primary key fields."},
:signals
{:query {:pre (), :post ()},
:create {:pre (), :post ()},
:delete {:pre (), :post ()},
:update {:pre (), :post ()}},
:pk-keys (:id),
:col-keys
#{:description
:title
:id
:user_id
:access
:edited_at
:created_at}},
:signals
{:query {:pre (), :post ()},
:create {:pre (), :post ()},
:delete {:pre (), :post ()},
:update {:pre (), :post ()}},
:pk-keys (:id),
:col-keys
#{:can_read
:inherit
:can_edit
:group_id
:id
:user_id
:role_id
:next_access
:owner}},
:groups
{:lcn-fields
{:rsc
{:access {:type Int},
:created_at {:type String},
:edited_at {:type String},
:id {:type Int},
:title {:type String},
:user_id {:type String},
:description {:type String}},
:clauses
{:description {:type :StrWhere},
:or {:type (list :GroupClauses)},
:title {:type :StrWhere},
:id {:type :IntWhere},
:and {:type (list :GroupClauses)},
:user_id {:type :StrWhere},
:access {:type :IntWhere},
:edited_at {:type :StrWhere},
:created_at {:type :StrWhere}},
:sort
{:access {:type :SortOperator},
:created_at {:type :SortOperator},
:edited_at {:type :SortOperator},
:id {:type :SortOperator},
:title {:type :SortOperator},
:user_id {:type :SortOperator},
:description {:type :SortOperator}},
:fields
{:access {:type Int},
:created_at {:type String},
:edited_at {:type String},
:id {:type Int},
:title {:type String},
:user_id {:type String},
:description {:type String}},
:aggregate
{:count {:type Int},
:sum {:type :GroupFields},
:avg {:type :GroupFields},
:max {:type :GroupFields},
:min {:type :GroupFields}},
:pks {:id {:type (non-null Int)}},
:pk-input {:id {:type (non-null Int)}},
:update
{:access {:type Int},
:created_at {:type String},
:edited_at {:type String},
:title {:type String},
:user_id {:type String},
:description {:type String}}},
:fks
{:access
{:field-keys
{:to :Access,
:has-many :groups,
:has-many-aggr :groups_aggregate,
:has-one :access_access}},
:user_id
{:field-keys
{:to :User,
:has-many :groups,
:has-many-aggr :groups_aggregate,
:has-one :user}}},
:lcn-mut-keys
{:create :createGroup,
:update :updateGroup,
:delete :deleteGroup},
:lcn-obj-keys
{:rsc :Group,
:clauses :GroupClauses,
:where :GroupWhere,
:sort :GroupSort,
:fields :GroupFields,
:aggregate :GroupAggregate,
:pks :GroupPks,
:pk-input :GroupPkColumns},
:lcn-qry-keys {:queries :groups, :aggregate :groups_aggregate},
:lcn-descs
{:rsc "Groups",
:query "Query Groups.",
:clauses
"Format for where clauses is {column: {operator: value}}. Multiple parameters are applied with `AND` operators. `AND`/`OR` conditions can be created as a list of clauses. It is possible to nest them to create sub groups of conditions.",
:sort "Sort format is {column: \"asc\" or \"desc\"}.",
:fields "Groupsfields for aggregation.",
:aggregate "Aggrecate Groups.",
:pks "Primary key fields.",
:pk-input "Primary key fields."},
:signals
{:query {:pre (), :post ()},
:create {:pre (), :post ()},
:delete {:pre (), :post ()},
:update {:pre (), :post ()}},
:pk-keys (:id),
:col-keys
#{:description
:title
:id
:user_id
:access
:edited_at
:created_at}},
:signals
{:query {:pre (), :post ()},
:create {:pre (), :post ()},
:delete {:pre (), :post ()},
:update {:pre (), :post ()}},
:pk-keys (:id),
:col-keys
#{:slug
:domain_pk
:title
:domain_pk_namespace
:id
:url
:access
:edited_at
:body
:created_at},
:users_in_groups
{:lcn-fields
{:rsc
{:group_id {:type Int},
:role_id {:type Int},
:user_id {:type String}},
:clauses
{:and {:type (list :UsersInGroupClauses)},
:or {:type (list :UsersInGroupClauses)},
:group_id {:type :IntWhere},
:role_id {:type :IntWhere},
:user_id {:type :StrWhere}},
:sort
{:group_id {:type :SortOperator},
:role_id {:type :SortOperator},
:user_id {:type :SortOperator}},
:fields
{:group_id {:type Int},
:role_id {:type Int},
:user_id {:type String}},
:aggregate
{:count {:type Int},
:sum {:type :UsersInGroupFields},
:avg {:type :UsersInGroupFields},
:max {:type :UsersInGroupFields},
:min {:type :UsersInGroupFields}},
:pks
{:user_id {:type (non-null String)},
:group_id {:type (non-null Int)},
:role_id {:type (non-null Int)}},
:pk-input
{:user_id {:type (non-null String)},
:group_id {:type (non-null Int)},
:role_id {:type (non-null Int)}},
:update {}},
:fks
{:user_id
{:field-keys
{:to :User,
:has-many :users_in_groups,
:has-many-aggr :users_in_groups_aggregate,
:has-one :user}},
:group_id
{:field-keys
{:to :Group,
:has-many :users_in_groups,
:has-many-aggr :users_in_groups_aggregate,
:has-one :group}},
:role_id
{:field-keys
{:to :Role,
:has-many :users_in_groups,
:has-many-aggr :users_in_groups_aggregate,
:has-one :role}}},
:lcn-mut-keys
{:create :createUsersInGroup,
:update :updateUsersInGroup,
:delete :deleteUsersInGroup},
:roles
{:lcn-fields
{:rsc
{:id {:type Int},
:group_id {:type Int},
:title {:type String},
:color {:type String}},
:clauses
{:and {:type (list :RoleClauses)},
:or {:type (list :RoleClauses)},
:id {:type :IntWhere},
:group_id {:type :IntWhere},
:title {:type :StrWhere},
:color {:type :StrWhere}},
:sort
{:id {:type :SortOperator},
:group_id {:type :SortOperator},
:title {:type :SortOperator},
:color {:type :SortOperator}},
:fields
{:id {:type Int},
:group_id {:type Int},
:title {:type String},
:color {:type String}},
:aggregate
{:count {:type Int},
:sum {:type :RoleFields},
:avg {:type :RoleFields},
:max {:type :RoleFields},
:min {:type :RoleFields}},
:pks {:id {:type (non-null Int)}},
:pk-input {:id {:type (non-null Int)}},
:update
{:group_id {:type Int},
:title {:type String},
:color {:type String}}},
:fks
{:group_id
{:field-keys
{:to :Group,
:has-many :roles,
:has-many-aggr :roles_aggregate,
:has-one :group}}},
:lcn-mut-keys
{:create :createRole,
:update :updateRole,
:delete :deleteRole},
:lcn-obj-keys
{:rsc :Role,
:clauses :RoleClauses,
:where :RoleWhere,
:sort :RoleSort,
:fields :RoleFields,
:aggregate :RoleAggregate,
:pks :RolePks,
:pk-input :RolePkColumns},
:lcn-qry-keys {:queries :roles, :aggregate :roles_aggregate},
:lcn-descs
{:rsc "Roles",
:query "Query Roles.",
:clauses
"Format for where clauses is {column: {operator: value}}. Multiple parameters are applied with `AND` operators. `AND`/`OR` conditions can be created as a list of clauses. It is possible to nest them to create sub groups of conditions.",
:sort "Sort format is {column: \"asc\" or \"desc\"}.",
:fields "Rolesfields for aggregation.",
:aggregate "Aggrecate Roles.",
:pks "Primary key fields.",
:pk-input "Primary key fields."},
:groups
{:lcn-fields
{:rsc
{:access {:type Int},
:created_at {:type String},
:edited_at {:type String},
:id {:type Int},
:title {:type String},
:user_id {:type String},
:description {:type String}},
:clauses
{:description {:type :StrWhere},
:or {:type (list :GroupClauses)},
:title {:type :StrWhere},
:id {:type :IntWhere},
:and {:type (list :GroupClauses)},
:user_id {:type :StrWhere},
:access {:type :IntWhere},
:edited_at {:type :StrWhere},
:created_at {:type :StrWhere}},
:sort
{:access {:type :SortOperator},
:created_at {:type :SortOperator},
:edited_at {:type :SortOperator},
:id {:type :SortOperator},
:title {:type :SortOperator},
:user_id {:type :SortOperator},
:description {:type :SortOperator}},
:fields
{:access {:type Int},
:created_at {:type String},
:edited_at {:type String},
:id {:type Int},
:title {:type String},
:user_id {:type String},
:description {:type String}},
:aggregate
{:count {:type Int},
:sum {:type :GroupFields},
:avg {:type :GroupFields},
:max {:type :GroupFields},
:min {:type :GroupFields}},
:pks {:id {:type (non-null Int)}},
:pk-input {:id {:type (non-null Int)}},
:update
{:access {:type Int},
:created_at {:type String},
:edited_at {:type String},
:title {:type String},
:user_id {:type String},
:description {:type String}}},
:fks
{:access
{:field-keys
{:to :Access,
:has-many :groups,
:has-many-aggr :groups_aggregate,
:has-one :access_access}},
:user_id
{:field-keys
{:to :User,
:has-many :groups,
:has-many-aggr :groups_aggregate,
:has-one :user}}},
:lcn-mut-keys
{:create :createGroup,
:update :updateGroup,
:delete :deleteGroup},
:lcn-obj-keys
{:rsc :Group,
:clauses :GroupClauses,
:where :GroupWhere,
:sort :GroupSort,
:fields :GroupFields,
:aggregate :GroupAggregate,
:pks :GroupPks,
:pk-input :GroupPkColumns},
:lcn-qry-keys
{:queries :groups, :aggregate :groups_aggregate},
:lcn-descs
{:rsc "Groups",
:query "Query Groups.",
:clauses
"Format for where clauses is {column: {operator: value}}. Multiple parameters are applied with `AND` operators. `AND`/`OR` conditions can be created as a list of clauses. It is possible to nest them to create sub groups of conditions.",
:sort "Sort format is {column: \"asc\" or \"desc\"}.",
:fields "Groupsfields for aggregation.",
:aggregate "Aggrecate Groups.",
:pks "Primary key fields.",
:pk-input "Primary key fields."},
:signals
{:query {:pre (), :post ()},
:create {:pre (), :post ()},
:delete {:pre (), :post ()},
:update {:pre (), :post ()}},
:pk-keys (:id),
:col-keys
#{:description
:title
:id
:user_id
:access
:edited_at
:created_at}},
:signals
{:query {:pre (), :post ()},
:create {:pre (), :post ()},
:delete {:pre (), :post ()},
:update {:pre (), :post ()}},
:pk-keys (:id),
:col-keys #{:color :title :group_id :id}},
:lcn-obj-keys
{:rsc :UsersInGroup,
:clauses :UsersInGroupClauses,
:where :UsersInGroupWhere,
:sort :UsersInGroupSort,
:fields :UsersInGroupFields,
:aggregate :UsersInGroupAggregate,
:pks :UsersInGroupPks,
:pk-input :UsersInGroupPkColumns},
:lcn-qry-keys
{:queries :users_in_groups,
:aggregate :users_in_groups_aggregate},
:lcn-descs
{:rsc "UsersInGroups",
:query "Query UsersInGroups.",
:clauses
"Format for where clauses is {column: {operator: value}}. Multiple parameters are applied with `AND` operators. `AND`/`OR` conditions can be created as a list of clauses. It is possible to nest them to create sub groups of conditions.",
:sort "Sort format is {column: \"asc\" or \"desc\"}.",
:fields "UsersInGroupsfields for aggregation.",
:aggregate "Aggrecate UsersInGroups.",
:pks "Primary key fields.",
:pk-input "Primary key fields."},
:access
{:lcn-fields
{:rsc
{:can_read {:type Boolean},
:inherit {:type Boolean},
:can_edit {:type Boolean},
:group_id {:type Int},
:id {:type Int},
:user_id {:type String},
:role_id {:type Int},
:next_access {:type Int},
:owner {:type Boolean}},
:clauses
{:can_read {:type :BoolWhere},
:inherit {:type :BoolWhere},
:can_edit {:type :BoolWhere},
:or {:type (list :AccessClauses)},
:group_id {:type :IntWhere},
:id {:type :IntWhere},
:and {:type (list :AccessClauses)},
:user_id {:type :StrWhere},
:role_id {:type :IntWhere},
:next_access {:type :IntWhere},
:owner {:type :BoolWhere}},
:sort
{:can_read {:type :SortOperator},
:inherit {:type :SortOperator},
:can_edit {:type :SortOperator},
:group_id {:type :SortOperator},
:id {:type :SortOperator},
:user_id {:type :SortOperator},
:role_id {:type :SortOperator},
:next_access {:type :SortOperator},
:owner {:type :SortOperator}},
:fields
{:can_read {:type Boolean},
:inherit {:type Boolean},
:can_edit {:type Boolean},
:group_id {:type Int},
:id {:type Int},
:user_id {:type String},
:role_id {:type Int},
:next_access {:type Int},
:owner {:type Boolean}},
:aggregate
{:count {:type Int},
:sum {:type :AccessFields},
:avg {:type :AccessFields},
:max {:type :AccessFields},
:min {:type :AccessFields}},
:pks {:id {:type (non-null Int)}},
:pk-input {:id {:type (non-null Int)}},
:update
{:can_read {:type Boolean},
:inherit {:type Boolean},
:can_edit {:type Boolean},
:group_id {:type Int},
:user_id {:type String},
:role_id {:type Int},
:next_access {:type Int},
:owner {:type Boolean}}},
:fks
{:next_access
{:field-keys
{:to :Access,
:has-many :accesses,
:has-many-aggr :accesses_aggregate,
:has-one :next_access_access}},
:role_id
{:field-keys
{:to :Role,
:has-many :accesses,
:has-many-aggr :accesses_aggregate,
:has-one :role}},
:user_id
{:field-keys
{:to :User,
:has-many :accesses,
:has-many-aggr :accesses_aggregate,
:has-one :user}},
:group_id
{:field-keys
{:to :Group,
:has-many :accesses,
:has-many-aggr :accesses_aggregate,
:has-one :group}}},
:lcn-mut-keys
{:create :createAccess,
:update :updateAccess,
:delete :deleteAccess},
:roles
{:lcn-fields
{:rsc
{:id {:type Int},
:group_id {:type Int},
:title {:type String},
:color {:type String}},
:clauses
{:and {:type (list :RoleClauses)},
:or {:type (list :RoleClauses)},
:id {:type :IntWhere},
:group_id {:type :IntWhere},
:title {:type :StrWhere},
:color {:type :StrWhere}},
:sort
{:id {:type :SortOperator},
:group_id {:type :SortOperator},
:title {:type :SortOperator},
:color {:type :SortOperator}},
:fields
{:id {:type Int},
:group_id {:type Int},
:title {:type String},
:color {:type String}},
:aggregate
{:count {:type Int},
:sum {:type :RoleFields},
:avg {:type :RoleFields},
:max {:type :RoleFields},
:min {:type :RoleFields}},
:pks {:id {:type (non-null Int)}},
:pk-input {:id {:type (non-null Int)}},
:update
{:group_id {:type Int},
:title {:type String},
:color {:type String}}},
:fks
{:group_id
{:field-keys
{:to :Group,
:has-many :roles,
:has-many-aggr :roles_aggregate,
:has-one :group}}},
:lcn-mut-keys
{:create :createRole,
:update :updateRole,
:delete :deleteRole},
:lcn-obj-keys
{:rsc :Role,
:clauses :RoleClauses,
:where :RoleWhere,
:sort :RoleSort,
:fields :RoleFields,
:aggregate :RoleAggregate,
:pks :RolePks,
:pk-input :RolePkColumns},
:lcn-qry-keys {:queries :roles, :aggregate :roles_aggregate},
:lcn-descs
{:rsc "Roles",
:query "Query Roles.",
:clauses
"Format for where clauses is {column: {operator: value}}. Multiple parameters are applied with `AND` operators. `AND`/`OR` conditions can be created as a list of clauses. It is possible to nest them to create sub groups of conditions.",
:sort "Sort format is {column: \"asc\" or \"desc\"}.",
:fields "Rolesfields for aggregation.",
:aggregate "Aggrecate Roles.",
:pks "Primary key fields.",
:pk-input "Primary key fields."},
:groups
{:lcn-fields
{:rsc
{:access {:type Int},
:created_at {:type String},
:edited_at {:type String},
:id {:type Int},
:title {:type String},
:user_id {:type String},
:description {:type String}},
:clauses
{:description {:type :StrWhere},
:or {:type (list :GroupClauses)},
:title {:type :StrWhere},
:id {:type :IntWhere},
:and {:type (list :GroupClauses)},
:user_id {:type :StrWhere},
:access {:type :IntWhere},
:edited_at {:type :StrWhere},
:created_at {:type :StrWhere}},
:sort
{:access {:type :SortOperator},
:created_at {:type :SortOperator},
:edited_at {:type :SortOperator},
:id {:type :SortOperator},
:title {:type :SortOperator},
:user_id {:type :SortOperator},
:description {:type :SortOperator}},
:fields
{:access {:type Int},
:created_at {:type String},
:edited_at {:type String},
:id {:type Int},
:title {:type String},
:user_id {:type String},
:description {:type String}},
:aggregate
{:count {:type Int},
:sum {:type :GroupFields},
:avg {:type :GroupFields},
:max {:type :GroupFields},
:min {:type :GroupFields}},
:pks {:id {:type (non-null Int)}},
:pk-input {:id {:type (non-null Int)}},
:update
{:access {:type Int},
:created_at {:type String},
:edited_at {:type String},
:title {:type String},
:user_id {:type String},
:description {:type String}}},
:fks
{:access
{:field-keys
{:to :Access,
:has-many :groups,
:has-many-aggr :groups_aggregate,
:has-one :access_access}},
:user_id
{:field-keys
{:to :User,
:has-many :groups,
:has-many-aggr :groups_aggregate,
:has-one :user}}},
:lcn-mut-keys
{:create :createGroup,
:update :updateGroup,
:delete :deleteGroup},
:lcn-obj-keys
{:rsc :Group,
:clauses :GroupClauses,
:where :GroupWhere,
:sort :GroupSort,
:fields :GroupFields,
:aggregate :GroupAggregate,
:pks :GroupPks,
:pk-input :GroupPkColumns},
:lcn-qry-keys
{:queries :groups, :aggregate :groups_aggregate},
:lcn-descs
{:rsc "Groups",
:query "Query Groups.",
:clauses
"Format for where clauses is {column: {operator: value}}. Multiple parameters are applied with `AND` operators. `AND`/`OR` conditions can be created as a list of clauses. It is possible to nest them to create sub groups of conditions.",
:sort "Sort format is {column: \"asc\" or \"desc\"}.",
:fields "Groupsfields for aggregation.",
:aggregate "Aggrecate Groups.",
:pks "Primary key fields.",
:pk-input "Primary key fields."},
:signals
{:query {:pre (), :post ()},
:create {:pre (), :post ()},
:delete {:pre (), :post ()},
:update {:pre (), :post ()}},
:pk-keys (:id),
:col-keys
#{:description
:title
:id
:user_id
:access
:edited_at
:created_at}},
:signals
{:query {:pre (), :post ()},
:create {:pre (), :post ()},
:delete {:pre (), :post ()},
:update {:pre (), :post ()}},
:pk-keys (:id),
:col-keys #{:color :title :group_id :id}},
:lcn-obj-keys
{:rsc :Access,
:clauses :AccessClauses,
:where :AccessWhere,
:sort :AccessSort,
:fields :AccessFields,
:aggregate :AccessAggregate,
:pks :AccessPks,
:pk-input :AccessPkColumns},
:lcn-qry-keys
{:queries :accesses, :aggregate :accesses_aggregate},
:lcn-descs
{:rsc "Accesses",
:query "Query Accesses.",
:clauses
"Format for where clauses is {column: {operator: value}}. Multiple parameters are applied with `AND` operators. `AND`/`OR` conditions can be created as a list of clauses. It is possible to nest them to create sub groups of conditions.",
:sort "Sort format is {column: \"asc\" or \"desc\"}.",
:fields "Accessesfields for aggregation.",
:aggregate "Aggrecate Accesses.",
:pks "Primary key fields.",
:pk-input "Primary key fields."},
:groups
{:lcn-fields
{:rsc
{:access {:type Int},
:created_at {:type String},
:edited_at {:type String},
:id {:type Int},
:title {:type String},
:user_id {:type String},
:description {:type String}},
:clauses
{:description {:type :StrWhere},
:or {:type (list :GroupClauses)},
:title {:type :StrWhere},
:id {:type :IntWhere},
:and {:type (list :GroupClauses)},
:user_id {:type :StrWhere},
:access {:type :IntWhere},
:edited_at {:type :StrWhere},
:created_at {:type :StrWhere}},
:sort
{:access {:type :SortOperator},
:created_at {:type :SortOperator},
:edited_at {:type :SortOperator},
:id {:type :SortOperator},
:title {:type :SortOperator},
:user_id {:type :SortOperator},
:description {:type :SortOperator}},
:fields
{:access {:type Int},
:created_at {:type String},
:edited_at {:type String},
:id {:type Int},
:title {:type String},
:user_id {:type String},
:description {:type String}},
:aggregate
{:count {:type Int},
:sum {:type :GroupFields},
:avg {:type :GroupFields},
:max {:type :GroupFields},
:min {:type :GroupFields}},
:pks {:id {:type (non-null Int)}},
:pk-input {:id {:type (non-null Int)}},
:update
{:access {:type Int},
:created_at {:type String},
:edited_at {:type String},
:title {:type String},
:user_id {:type String},
:description {:type String}}},
:fks
{:access
{:field-keys
{:to :Access,
:has-many :groups,
:has-many-aggr :groups_aggregate,
:has-one :access_access}},
:user_id
{:field-keys
{:to :User,
:has-many :groups,
:has-many-aggr :groups_aggregate,
:has-one :user}}},
:lcn-mut-keys
{:create :createGroup,
:update :updateGroup,
:delete :deleteGroup},
:lcn-obj-keys
{:rsc :Group,
:clauses :GroupClauses,
:where :GroupWhere,
:sort :GroupSort,
:fields :GroupFields,
:aggregate :GroupAggregate,
:pks :GroupPks,
:pk-input :GroupPkColumns},
:lcn-qry-keys
{:queries :groups, :aggregate :groups_aggregate},
:lcn-descs
{:rsc "Groups",
:query "Query Groups.",
:clauses
"Format for where clauses is {column: {operator: value}}. Multiple parameters are applied with `AND` operators. `AND`/`OR` conditions can be created as a list of clauses. It is possible to nest them to create sub groups of conditions.",
:sort "Sort format is {column: \"asc\" or \"desc\"}.",
:fields "Groupsfields for aggregation.",
:aggregate "Aggrecate Groups.",
:pks "Primary key fields.",
:pk-input "Primary key fields."},
:signals
{:query {:pre (), :post ()},
:create {:pre (), :post ()},
:delete {:pre (), :post ()},
:update {:pre (), :post ()}},
:pk-keys (:id),
:col-keys
#{:description
:title
:id
:user_id
:access
:edited_at
:created_at}},
:signals
{:query {:pre (), :post ()},
:create {:pre (), :post ()},
:delete {:pre (), :post ()},
:update {:pre (), :post ()}},
:pk-keys (:id),
:col-keys
#{:can_read
:inherit
:can_edit
:group_id
:id
:user_id
:role_id
:next_access
:owner}},
:groups
{:lcn-fields
{:rsc
{:access {:type Int},
:created_at {:type String},
:edited_at {:type String},
:id {:type Int},
:title {:type String},
:user_id {:type String},
:description {:type String}},
:clauses
{:description {:type :StrWhere},
:or {:type (list :GroupClauses)},
:title {:type :StrWhere},
:id {:type :IntWhere},
:and {:type (list :GroupClauses)},
:user_id {:type :StrWhere},
:access {:type :IntWhere},
:edited_at {:type :StrWhere},
:created_at {:type :StrWhere}},
:sort
{:access {:type :SortOperator},
:created_at {:type :SortOperator},
:edited_at {:type :SortOperator},
:id {:type :SortOperator},
:title {:type :SortOperator},
:user_id {:type :SortOperator},
:description {:type :SortOperator}},
:fields
{:access {:type Int},
:created_at {:type String},
:edited_at {:type String},
:id {:type Int},
:title {:type String},
:user_id {:type String},
:description {:type String}},
:aggregate
{:count {:type Int},
:sum {:type :GroupFields},
:avg {:type :GroupFields},
:max {:type :GroupFields},
:min {:type :GroupFields}},
:pks {:id {:type (non-null Int)}},
:pk-input {:id {:type (non-null Int)}},
:update
{:access {:type Int},
:created_at {:type String},
:edited_at {:type String},
:title {:type String},
:user_id {:type String},
:description {:type String}}},
:fks
{:access
{:field-keys
{:to :Access,
:has-many :groups,
:has-many-aggr :groups_aggregate,
:has-one :access_access}},
:user_id
{:field-keys
{:to :User,
:has-many :groups,
:has-many-aggr :groups_aggregate,
:has-one :user}}},
:lcn-mut-keys
{:create :createGroup,
:update :updateGroup,
:delete :deleteGroup},
:lcn-obj-keys
{:rsc :Group,
:clauses :GroupClauses,
:where :GroupWhere,
:sort :GroupSort,
:fields :GroupFields,
:aggregate :GroupAggregate,
:pks :GroupPks,
:pk-input :GroupPkColumns},
:lcn-qry-keys {:queries :groups, :aggregate :groups_aggregate},
:lcn-descs
{:rsc "Groups",
:query "Query Groups.",
:clauses
"Format for where clauses is {column: {operator: value}}. Multiple parameters are applied with `AND` operators. `AND`/`OR` conditions can be created as a list of clauses. It is possible to nest them to create sub groups of conditions.",
:sort "Sort format is {column: \"asc\" or \"desc\"}.",
:fields "Groupsfields for aggregation.",
:aggregate "Aggrecate Groups.",
:pks "Primary key fields.",
:pk-input "Primary key fields."},
:signals
{:query {:pre (), :post ()},
:create {:pre (), :post ()},
:delete {:pre (), :post ()},
:update {:pre (), :post ()}},
:pk-keys (:id),
:col-keys
#{:description
:title
:id
:user_id
:access
:edited_at
:created_at}},
:signals
{:query {:pre (), :post ()},
:create {:pre (), :post ()},
:delete {:pre (), :post ()},
:update {:pre (), :post ()}},
:pk-keys (:user_id :group_id :role_id),
:col-keys #{:group_id :user_id :role_id}}},
:signals
{:query {:pre (), :post ()},
:create {:pre (), :post ()},
:delete {:pre (), :post ()},
:update {:pre (), :post ()}},
:pk-keys (:id),
:col-keys
#{:attribute_name
:description
:udt_schema
:collation_schema
:numeric_scale
:character_set_schema
:dtd_identifier
:maximum_cardinality
:is_derived_reference_attribute
:character_octet_length
:datetime_precision
:scope_catalog
:collation_catalog
:character_maximum_length
:is_nullable
:character_set_catalog
:numeric_precision
:interval_type
:udt_catalog
:title
:scope_schema
:attribute_default
:numeric_precision_radix
:interval_precision
:character_set_name
:attribute_udt_catalog
:id
:collation_name
:data_type
:attribute_udt_schema
:access
:edited_at
:scope_name
:udt_name
:created_at
:ordinal_position
:attribute_udt_name},
:users_in_groups
{:lcn-fields
{:rsc
{:group_id {:type Int},
:role_id {:type Int},
:user_id {:type String}},
:clauses
{:and {:type (list :UsersInGroupClauses)},
:or {:type (list :UsersInGroupClauses)},
:group_id {:type :IntWhere},
:role_id {:type :IntWhere},
:user_id {:type :StrWhere}},
:sort
{:group_id {:type :SortOperator},
:role_id {:type :SortOperator},
:user_id {:type :SortOperator}},
:fields
{:group_id {:type Int},
:role_id {:type Int},
:user_id {:type String}},
:aggregate
{:count {:type Int},
:sum {:type :UsersInGroupFields},
:avg {:type :UsersInGroupFields},
:max {:type :UsersInGroupFields},
:min {:type :UsersInGroupFields}},
:pks
{:user_id {:type (non-null String)},
:group_id {:type (non-null Int)},
:role_id {:type (non-null Int)}},
:pk-input
{:user_id {:type (non-null String)},
:group_id {:type (non-null Int)},
:role_id {:type (non-null Int)}},
:update {}},
:fks
{:user_id
{:field-keys
{:to :User,
:has-many :users_in_groups,
:has-many-aggr :users_in_groups_aggregate,
:has-one :user}},
:group_id
{:field-keys
{:to :Group,
:has-many :users_in_groups,
:has-many-aggr :users_in_groups_aggregate,
:has-one :group}},
:role_id
{:field-keys
{:to :Role,
:has-many :users_in_groups,
:has-many-aggr :users_in_groups_aggregate,
:has-one :role}}},
:lcn-mut-keys
{:create :createUsersInGroup,
:update :updateUsersInGroup,
:delete :deleteUsersInGroup},
:roles
{:lcn-fields
{:rsc
{:id {:type Int},
:group_id {:type Int},
:title {:type String},
:color {:type String}},
:clauses
{:and {:type (list :RoleClauses)},
:or {:type (list :RoleClauses)},
:id {:type :IntWhere},
:group_id {:type :IntWhere},
:title {:type :StrWhere},
:color {:type :StrWhere}},
:sort
{:id {:type :SortOperator},
:group_id {:type :SortOperator},
:title {:type :SortOperator},
:color {:type :SortOperator}},
:fields
{:id {:type Int},
:group_id {:type Int},
:title {:type String},
:color {:type String}},
:aggregate
{:count {:type Int},
:sum {:type :RoleFields},
:avg {:type :RoleFields},
:max {:type :RoleFields},
:min {:type :RoleFields}},
:pks {:id {:type (non-null Int)}},
:pk-input {:id {:type (non-null Int)}},
:update
{:group_id {:type Int},
:title {:type String},
:color {:type String}}},
:fks
{:group_id
{:field-keys
{:to :Group,
:has-many :roles,
:has-many-aggr :roles_aggregate,
:has-one :group}}},
:lcn-mut-keys
{:create :createRole, :update :updateRole, :delete :deleteRole},
:lcn-obj-keys
{:rsc :Role,
:clauses :RoleClauses,
:where :RoleWhere,
:sort :RoleSort,
:fields :RoleFields,
:aggregate :RoleAggregate,
:pks :RolePks,
:pk-input :RolePkColumns},
:lcn-qry-keys {:queries :roles, :aggregate :roles_aggregate},
:lcn-descs
{:rsc "Roles",
:query "Query Roles.",
:clauses
"Format for where clauses is {column: {operator: value}}. Multiple parameters are applied with `AND` operators. `AND`/`OR` conditions can be created as a list of clauses. It is possible to nest them to create sub groups of conditions.",
:sort "Sort format is {column: \"asc\" or \"desc\"}.",
:fields "Rolesfields for aggregation.",
:aggregate "Aggrecate Roles.",
:pks "Primary key fields.",
:pk-input "Primary key fields."},
:groups
{:lcn-fields
{:rsc
{:access {:type Int},
:created_at {:type String},
:edited_at {:type String},
:id {:type Int},
:title {:type String},
:user_id {:type String},
:description {:type String}},
:clauses
{:description {:type :StrWhere},
:or {:type (list :GroupClauses)},
:title {:type :StrWhere},
:id {:type :IntWhere},
:and {:type (list :GroupClauses)},
:user_id {:type :StrWhere},
:access {:type :IntWhere},
:edited_at {:type :StrWhere},
:created_at {:type :StrWhere}},
:sort
{:access {:type :SortOperator},
:created_at {:type :SortOperator},
:edited_at {:type :SortOperator},
:id {:type :SortOperator},
:title {:type :SortOperator},
:user_id {:type :SortOperator},
:description {:type :SortOperator}},
:fields
{:access {:type Int},
:created_at {:type String},
:edited_at {:type String},
:id {:type Int},
:title {:type String},
:user_id {:type String},
:description {:type String}},
:aggregate
{:count {:type Int},
:sum {:type :GroupFields},
:avg {:type :GroupFields},
:max {:type :GroupFields},
:min {:type :GroupFields}},
:pks {:id {:type (non-null Int)}},
:pk-input {:id {:type (non-null Int)}},
:update
{:access {:type Int},
:created_at {:type String},
:edited_at {:type String},
:title {:type String},
:user_id {:type String},
:description {:type String}}},
:fks
{:access
{:field-keys
{:to :Access,
:has-many :groups,
:has-many-aggr :groups_aggregate,
:has-one :access_access}},
:user_id
{:field-keys
{:to :User,
:has-many :groups,
:has-many-aggr :groups_aggregate,
:has-one :user}}},
:lcn-mut-keys
{:create :createGroup,
:update :updateGroup,
:delete :deleteGroup},
:lcn-obj-keys
{:rsc :Group,
:clauses :GroupClauses,
:where :GroupWhere,
:sort :GroupSort,
:fields :GroupFields,
:aggregate :GroupAggregate,
:pks :GroupPks,
:pk-input :GroupPkColumns},
:lcn-qry-keys {:queries :groups, :aggregate :groups_aggregate},
:lcn-descs
{:rsc "Groups",
:query "Query Groups.",
:clauses
"Format for where clauses is {column: {operator: value}}. Multiple parameters are applied with `AND` operators. `AND`/`OR` conditions can be created as a list of clauses. It is possible to nest them to create sub groups of conditions.",
:sort "Sort format is {column: \"asc\" or \"desc\"}.",
:fields "Groupsfields for aggregation.",
:aggregate "Aggrecate Groups.",
:pks "Primary key fields.",
:pk-input "Primary key fields."},
:signals
{:query {:pre (), :post ()},
:create {:pre (), :post ()},
:delete {:pre (), :post ()},
:update {:pre (), :post ()}},
:pk-keys (:id),
:col-keys
#{:description
:title
:id
:user_id
:access
:edited_at
:created_at}},
:signals
{:query {:pre (), :post ()},
:create {:pre (), :post ()},
:delete {:pre (), :post ()},
:update {:pre (), :post ()}},
:pk-keys (:id),
:col-keys #{:color :title :group_id :id}},
:lcn-obj-keys
{:rsc :UsersInGroup,
:clauses :UsersInGroupClauses,
:where :UsersInGroupWhere,
:sort :UsersInGroupSort,
:fields :UsersInGroupFields,
:aggregate :UsersInGroupAggregate,
:pks :UsersInGroupPks,
:pk-input :UsersInGroupPkColumns},
:lcn-qry-keys
{:queries :users_in_groups,
:aggregate :users_in_groups_aggregate},
:lcn-descs
{:rsc "UsersInGroups",
:query "Query UsersInGroups.",
:clauses
"Format for where clauses is {column: {operator: value}}. Multiple parameters are applied with `AND` operators. `AND`/`OR` conditions can be created as a list of clauses. It is possible to nest them to create sub groups of conditions.",
:sort "Sort format is {column: \"asc\" or \"desc\"}.",
:fields "UsersInGroupsfields for aggregation.",
:aggregate "Aggrecate UsersInGroups.",
:pks "Primary key fields.",
:pk-input "Primary key fields."},
:access
{:lcn-fields
{:rsc
{:can_read {:type Boolean},
:inherit {:type Boolean},
:can_edit {:type Boolean},
:group_id {:type Int},
:id {:type Int},
:user_id {:type String},
:role_id {:type Int},
:next_access {:type Int},
:owner {:type Boolean}},
:clauses
{:can_read {:type :BoolWhere},
:inherit {:type :BoolWhere},
:can_edit {:type :BoolWhere},
:or {:type (list :AccessClauses)},
:group_id {:type :IntWhere},
:id {:type :IntWhere},
:and {:type (list :AccessClauses)},
:user_id {:type :StrWhere},
:role_id {:type :IntWhere},
:next_access {:type :IntWhere},
:owner {:type :BoolWhere}},
:sort
{:can_read {:type :SortOperator},
:inherit {:type :SortOperator},
:can_edit {:type :SortOperator},
:group_id {:type :SortOperator},
:id {:type :SortOperator},
:user_id {:type :SortOperator},
:role_id {:type :SortOperator},
:next_access {:type :SortOperator},
:owner {:type :SortOperator}},
:fields
{:can_read {:type Boolean},
:inherit {:type Boolean},
:can_edit {:type Boolean},
:group_id {:type Int},
:id {:type Int},
:user_id {:type String},
:role_id {:type Int},
:next_access {:type Int},
:owner {:type Boolean}},
:aggregate
{:count {:type Int},
:sum {:type :AccessFields},
:avg {:type :AccessFields},
:max {:type :AccessFields},
:min {:type :AccessFields}},
:pks {:id {:type (non-null Int)}},
:pk-input {:id {:type (non-null Int)}},
:update
{:can_read {:type Boolean},
:inherit {:type Boolean},
:can_edit {:type Boolean},
:group_id {:type Int},
:user_id {:type String},
:role_id {:type Int},
:next_access {:type Int},
:owner {:type Boolean}}},
:fks
{:next_access
{:field-keys
{:to :Access,
:has-many :accesses,
:has-many-aggr :accesses_aggregate,
:has-one :next_access_access}},
:role_id
{:field-keys
{:to :Role,
:has-many :accesses,
:has-many-aggr :accesses_aggregate,
:has-one :role}},
:user_id
{:field-keys
{:to :User,
:has-many :accesses,
:has-many-aggr :accesses_aggregate,
:has-one :user}},
:group_id
{:field-keys
{:to :Group,
:has-many :accesses,
:has-many-aggr :accesses_aggregate,
:has-one :group}}},
:lcn-mut-keys
{:create :createAccess,
:update :updateAccess,
:delete :deleteAccess},
:roles
{:lcn-fields
{:rsc
{:id {:type Int},
:group_id {:type Int},
:title {:type String},
:color {:type String}},
:clauses
{:and {:type (list :RoleClauses)},
:or {:type (list :RoleClauses)},
:id {:type :IntWhere},
:group_id {:type :IntWhere},
:title {:type :StrWhere},
:color {:type :StrWhere}},
:sort
{:id {:type :SortOperator},
:group_id {:type :SortOperator},
:title {:type :SortOperator},
:color {:type :SortOperator}},
:fields
{:id {:type Int},
:group_id {:type Int},
:title {:type String},
:color {:type String}},
:aggregate
{:count {:type Int},
:sum {:type :RoleFields},
:avg {:type :RoleFields},
:max {:type :RoleFields},
:min {:type :RoleFields}},
:pks {:id {:type (non-null Int)}},
:pk-input {:id {:type (non-null Int)}},
:update
{:group_id {:type Int},
:title {:type String},
:color {:type String}}},
:fks
{:group_id
{:field-keys
{:to :Group,
:has-many :roles,
:has-many-aggr :roles_aggregate,
:has-one :group}}},
:lcn-mut-keys
{:create :createRole,
:update :updateRole,
:delete :deleteRole},
:lcn-obj-keys
{:rsc :Role,
:clauses :RoleClauses,
:where :RoleWhere,
:sort :RoleSort,
:fields :RoleFields,
:aggregate :RoleAggregate,
:pks :RolePks,
:pk-input :RolePkColumns},
:lcn-qry-keys {:queries :roles, :aggregate :roles_aggregate},
:lcn-descs
{:rsc "Roles",
:query "Query Roles.",
:clauses
"Format for where clauses is {column: {operator: value}}. Multiple parameters are applied with `AND` operators. `AND`/`OR` conditions can be created as a list of clauses. It is possible to nest them to create sub groups of conditions.",
:sort "Sort format is {column: \"asc\" or \"desc\"}.",
:fields "Rolesfields for aggregation.",
:aggregate "Aggrecate Roles.",
:pks "Primary key fields.",
:pk-input "Primary key fields."},
:groups
{:lcn-fields
{:rsc
{:access {:type Int},
:created_at {:type String},
:edited_at {:type String},
:id {:type Int},
:title {:type String},
:user_id {:type String},
:description {:type String}},
:clauses
{:description {:type :StrWhere},
:or {:type (list :GroupClauses)},
:title {:type :StrWhere},
:id {:type :IntWhere},
:and {:type (list :GroupClauses)},
:user_id {:type :StrWhere},
:access {:type :IntWhere},
:edited_at {:type :StrWhere},
:created_at {:type :StrWhere}},
:sort
{:access {:type :SortOperator},
:created_at {:type :SortOperator},
:edited_at {:type :SortOperator},
:id {:type :SortOperator},
:title {:type :SortOperator},
:user_id {:type :SortOperator},
:description {:type :SortOperator}},
:fields
{:access {:type Int},
:created_at {:type String},
:edited_at {:type String},
:id {:type Int},
:title {:type String},
:user_id {:type String},
:description {:type String}},
:aggregate
{:count {:type Int},
:sum {:type :GroupFields},
:avg {:type :GroupFields},
:max {:type :GroupFields},
:min {:type :GroupFields}},
:pks {:id {:type (non-null Int)}},
:pk-input {:id {:type (non-null Int)}},
:update
{:access {:type Int},
:created_at {:type String},
:edited_at {:type String},
:title {:type String},
:user_id {:type String},
:description {:type String}}},
:fks
{:access
{:field-keys
{:to :Access,
:has-many :groups,
:has-many-aggr :groups_aggregate,
:has-one :access_access}},
:user_id
{:field-keys
{:to :User,
:has-many :groups,
:has-many-aggr :groups_aggregate,
:has-one :user}}},
:lcn-mut-keys
{:create :createGroup,
:update :updateGroup,
:delete :deleteGroup},
:lcn-obj-keys
{:rsc :Group,
:clauses :GroupClauses,
:where :GroupWhere,
:sort :GroupSort,
:fields :GroupFields,
:aggregate :GroupAggregate,
:pks :GroupPks,
:pk-input :GroupPkColumns},
:lcn-qry-keys
{:queries :groups, :aggregate :groups_aggregate},
:lcn-descs
{:rsc "Groups",
:query "Query Groups.",
:clauses
"Format for where clauses is {column: {operator: value}}. Multiple parameters are applied with `AND` operators. `AND`/`OR` conditions can be created as a list of clauses. It is possible to nest them to create sub groups of conditions.",
:sort "Sort format is {column: \"asc\" or \"desc\"}.",
:fields "Groupsfields for aggregation.",
:aggregate "Aggrecate Groups.",
:pks "Primary key fields.",
:pk-input "Primary key fields."},
:signals
{:query {:pre (), :post ()},
:create {:pre (), :post ()},
:delete {:pre (), :post ()},
:update {:pre (), :post ()}},
:pk-keys (:id),
:col-keys
#{:description
:title
:id
:user_id
:access
:edited_at
:created_at}},
:signals
{:query {:pre (), :post ()},
:create {:pre (), :post ()},
:delete {:pre (), :post ()},
:update {:pre (), :post ()}},
:pk-keys (:id),
:col-keys #{:color :title :group_id :id}},
:lcn-obj-keys
{:rsc :Access,
:clauses :AccessClauses,
:where :AccessWhere,
:sort :AccessSort,
:fields :AccessFields,
:aggregate :AccessAggregate,
:pks :AccessPks,
:pk-input :AccessPkColumns},
:lcn-qry-keys
{:queries :accesses, :aggregate :accesses_aggregate},
:lcn-descs
{:rsc "Accesses",
:query "Query Accesses.",
:clauses
"Format for where clauses is {column: {operator: value}}. Multiple parameters are applied with `AND` operators. `AND`/`OR` conditions can be created as a list of clauses. It is possible to nest them to create sub groups of conditions.",
:sort "Sort format is {column: \"asc\" or \"desc\"}.",
:fields "Accessesfields for aggregation.",
:aggregate "Aggrecate Accesses.",
:pks "Primary key fields.",
:pk-input "Primary key fields."},
:groups
{:lcn-fields
{:rsc
{:access {:type Int},
:created_at {:type String},
:edited_at {:type String},
:id {:type Int},
:title {:type String},
:user_id {:type String},
:description {:type String}},
:clauses
{:description {:type :StrWhere},
:or {:type (list :GroupClauses)},
:title {:type :StrWhere},
:id {:type :IntWhere},
:and {:type (list :GroupClauses)},
:user_id {:type :StrWhere},
:access {:type :IntWhere},
:edited_at {:type :StrWhere},
:created_at {:type :StrWhere}},
:sort
{:access {:type :SortOperator},
:created_at {:type :SortOperator},
:edited_at {:type :SortOperator},
:id {:type :SortOperator},
:title {:type :SortOperator},
:user_id {:type :SortOperator},
:description {:type :SortOperator}},
:fields
{:access {:type Int},
:created_at {:type String},
:edited_at {:type String},
:id {:type Int},
:title {:type String},
:user_id {:type String},
:description {:type String}},
:aggregate
{:count {:type Int},
:sum {:type :GroupFields},
:avg {:type :GroupFields},
:max {:type :GroupFields},
:min {:type :GroupFields}},
:pks {:id {:type (non-null Int)}},
:pk-input {:id {:type (non-null Int)}},
:update
{:access {:type Int},
:created_at {:type String},
:edited_at {:type String},
:title {:type String},
:user_id {:type String},
:description {:type String}}},
:fks
{:access
{:field-keys
{:to :Access,
:has-many :groups,
:has-many-aggr :groups_aggregate,
:has-one :access_access}},
:user_id
{:field-keys
{:to :User,
:has-many :groups,
:has-many-aggr :groups_aggregate,
:has-one :user}}},
:lcn-mut-keys
{:create :createGroup,
:update :updateGroup,
:delete :deleteGroup},
:lcn-obj-keys
{:rsc :Group,
:clauses :GroupClauses,
:where :GroupWhere,
:sort :GroupSort,
:fields :GroupFields,
:aggregate :GroupAggregate,
:pks :GroupPks,
:pk-input :GroupPkColumns},
:lcn-qry-keys {:queries :groups, :aggregate :groups_aggregate},
:lcn-descs
{:rsc "Groups",
:query "Query Groups.",
:clauses
"Format for where clauses is {column: {operator: value}}. Multiple parameters are applied with `AND` operators. `AND`/`OR` conditions can be created as a list of clauses. It is possible to nest them to create sub groups of conditions.",
:sort "Sort format is {column: \"asc\" or \"desc\"}.",
:fields "Groupsfields for aggregation.",
:aggregate "Aggrecate Groups.",
:pks "Primary key fields.",
:pk-input "Primary key fields."},
:signals
{:query {:pre (), :post ()},
:create {:pre (), :post ()},
:delete {:pre (), :post ()},
:update {:pre (), :post ()}},
:pk-keys (:id),
:col-keys
#{:description
:title
:id
:user_id
:access
:edited_at
:created_at}},
:signals
{:query {:pre (), :post ()},
:create {:pre (), :post ()},
:delete {:pre (), :post ()},
:update {:pre (), :post ()}},
:pk-keys (:id),
:col-keys
#{:can_read
:inherit
:can_edit
:group_id
:id
:user_id
:role_id
:next_access
:owner}},
:groups
{:lcn-fields
{:rsc
{:access {:type Int},
:created_at {:type String},
:edited_at {:type String},
:id {:type Int},
:title {:type String},
:user_id {:type String},
:description {:type String}},
:clauses
{:description {:type :StrWhere},
:or {:type (list :GroupClauses)},
:title {:type :StrWhere},
:id {:type :IntWhere},
:and {:type (list :GroupClauses)},
:user_id {:type :StrWhere},
:access {:type :IntWhere},
:edited_at {:type :StrWhere},
:created_at {:type :StrWhere}},
:sort
{:access {:type :SortOperator},
:created_at {:type :SortOperator},
:edited_at {:type :SortOperator},
:id {:type :SortOperator},
:title {:type :SortOperator},
:user_id {:type :SortOperator},
:description {:type :SortOperator}},
:fields
{:access {:type Int},
:created_at {:type String},
:edited_at {:type String},
:id {:type Int},
:title {:type String},
:user_id {:type String},
:description {:type String}},
:aggregate
{:count {:type Int},
:sum {:type :GroupFields},
:avg {:type :GroupFields},
:max {:type :GroupFields},
:min {:type :GroupFields}},
:pks {:id {:type (non-null Int)}},
:pk-input {:id {:type (non-null Int)}},
:update
{:access {:type Int},
:created_at {:type String},
:edited_at {:type String},
:title {:type String},
:user_id {:type String},
:description {:type String}}},
:fks
{:access
{:field-keys
{:to :Access,
:has-many :groups,
:has-many-aggr :groups_aggregate,
:has-one :access_access}},
:user_id
{:field-keys
{:to :User,
:has-many :groups,
:has-many-aggr :groups_aggregate,
:has-one :user}}},
:lcn-mut-keys
{:create :createGroup,
:update :updateGroup,
:delete :deleteGroup},
:lcn-obj-keys
{:rsc :Group,
:clauses :GroupClauses,
:where :GroupWhere,
:sort :GroupSort,
:fields :GroupFields,
:aggregate :GroupAggregate,
:pks :GroupPks,
:pk-input :GroupPkColumns},
:lcn-qry-keys {:queries :groups, :aggregate :groups_aggregate},
:lcn-descs
{:rsc "Groups",
:query "Query Groups.",
:clauses
"Format for where clauses is {column: {operator: value}}. Multiple parameters are applied with `AND` operators. `AND`/`OR` conditions can be created as a list of clauses. It is possible to nest them to create sub groups of conditions.",
:sort "Sort format is {column: \"asc\" or \"desc\"}.",
:fields "Groupsfields for aggregation.",
:aggregate "Aggrecate Groups.",
:pks "Primary key fields.",
:pk-input "Primary key fields."},
:signals
{:query {:pre (), :post ()},
:create {:pre (), :post ()},
:delete {:pre (), :post ()},
:update {:pre (), :post ()}},
:pk-keys (:id),
:col-keys
#{:description
:title
:id
:user_id
:access
:edited_at
:created_at}},
:signals
{:query {:pre (), :post ()},
:create {:pre (), :post ()},
:delete {:pre (), :post ()},
:update {:pre (), :post ()}},
:pk-keys (:user_id :group_id :role_id),
:col-keys #{:group_id :user_id :role_id}}},
:signals
{:query {:pre (), :post ()},
:create {:pre (), :post ()},
:delete {:pre (), :post ()},
:update {:pre (), :post ()}},
:pk-keys (:id),
:col-keys
#{:attribute
:magnitude
:domain_pk_namespace
:id
:access
:edited_at
:right_item_id
:created_at
:left_item_id},
:users_in_groups
{:lcn-fields
{:rsc
{:group_id {:type Int},
:role_id {:type Int},
:user_id {:type String}},
:clauses
{:and {:type (list :UsersInGroupClauses)},
:or {:type (list :UsersInGroupClauses)},
:group_id {:type :IntWhere},
:role_id {:type :IntWhere},
:user_id {:type :StrWhere}},
:sort
{:group_id {:type :SortOperator},
:role_id {:type :SortOperator},
:user_id {:type :SortOperator}},
:fields
{:group_id {:type Int},
:role_id {:type Int},
:user_id {:type String}},
:aggregate
{:count {:type Int},
:sum {:type :UsersInGroupFields},
:avg {:type :UsersInGroupFields},
:max {:type :UsersInGroupFields},
:min {:type :UsersInGroupFields}},
:pks
{:user_id {:type (non-null String)},
:group_id {:type (non-null Int)},
:role_id {:type (non-null Int)}},
:pk-input
{:user_id {:type (non-null String)},
:group_id {:type (non-null Int)},
:role_id {:type (non-null Int)}},
:update {}},
:fks
{:user_id
{:field-keys
{:to :User,
:has-many :users_in_groups,
:has-many-aggr :users_in_groups_aggregate,
:has-one :user}},
:group_id
{:field-keys
{:to :Group,
:has-many :users_in_groups,
:has-many-aggr :users_in_groups_aggregate,
:has-one :group}},
:role_id
{:field-keys
{:to :Role,
:has-many :users_in_groups,
:has-many-aggr :users_in_groups_aggregate,
:has-one :role}}},
:lcn-mut-keys
{:create :createUsersInGroup,
:update :updateUsersInGroup,
:delete :deleteUsersInGroup},
:roles
{:lcn-fields
{:rsc
{:id {:type Int},
:group_id {:type Int},
:title {:type String},
:color {:type String}},
:clauses
{:and {:type (list :RoleClauses)},
:or {:type (list :RoleClauses)},
:id {:type :IntWhere},
:group_id {:type :IntWhere},
:title {:type :StrWhere},
:color {:type :StrWhere}},
:sort
{:id {:type :SortOperator},
:group_id {:type :SortOperator},
:title {:type :SortOperator},
:color {:type :SortOperator}},
:fields
{:id {:type Int},
:group_id {:type Int},
:title {:type String},
:color {:type String}},
:aggregate
{:count {:type Int},
:sum {:type :RoleFields},
:avg {:type :RoleFields},
:max {:type :RoleFields},
:min {:type :RoleFields}},
:pks {:id {:type (non-null Int)}},
:pk-input {:id {:type (non-null Int)}},
:update
{:group_id {:type Int},
:title {:type String},
:color {:type String}}},
:fks
{:group_id
{:field-keys
{:to :Group,
:has-many :roles,
:has-many-aggr :roles_aggregate,
:has-one :group}}},
:lcn-mut-keys
{:create :createRole, :update :updateRole, :delete :deleteRole},
:lcn-obj-keys
{:rsc :Role,
:clauses :RoleClauses,
:where :RoleWhere,
:sort :RoleSort,
:fields :RoleFields,
:aggregate :RoleAggregate,
:pks :RolePks,
:pk-input :RolePkColumns},
:lcn-qry-keys {:queries :roles, :aggregate :roles_aggregate},
:lcn-descs
{:rsc "Roles",
:query "Query Roles.",
:clauses
"Format for where clauses is {column: {operator: value}}. Multiple parameters are applied with `AND` operators. `AND`/`OR` conditions can be created as a list of clauses. It is possible to nest them to create sub groups of conditions.",
:sort "Sort format is {column: \"asc\" or \"desc\"}.",
:fields "Rolesfields for aggregation.",
:aggregate "Aggrecate Roles.",
:pks "Primary key fields.",
:pk-input "Primary key fields."},
:groups
{:lcn-fields
{:rsc
{:access {:type Int},
:created_at {:type String},
:edited_at {:type String},
:id {:type Int},
:title {:type String},
:user_id {:type String},
:description {:type String}},
:clauses
{:description {:type :StrWhere},
:or {:type (list :GroupClauses)},
:title {:type :StrWhere},
:id {:type :IntWhere},
:and {:type (list :GroupClauses)},
:user_id {:type :StrWhere},
:access {:type :IntWhere},
:edited_at {:type :StrWhere},
:created_at {:type :StrWhere}},
:sort
{:access {:type :SortOperator},
:created_at {:type :SortOperator},
:edited_at {:type :SortOperator},
:id {:type :SortOperator},
:title {:type :SortOperator},
:user_id {:type :SortOperator},
:description {:type :SortOperator}},
:fields
{:access {:type Int},
:created_at {:type String},
:edited_at {:type String},
:id {:type Int},
:title {:type String},
:user_id {:type String},
:description {:type String}},
:aggregate
{:count {:type Int},
:sum {:type :GroupFields},
:avg {:type :GroupFields},
:max {:type :GroupFields},
:min {:type :GroupFields}},
:pks {:id {:type (non-null Int)}},
:pk-input {:id {:type (non-null Int)}},
:update
{:access {:type Int},
:created_at {:type String},
:edited_at {:type String},
:title {:type String},
:user_id {:type String},
:description {:type String}}},
:fks
{:access
{:field-keys
{:to :Access,
:has-many :groups,
:has-many-aggr :groups_aggregate,
:has-one :access_access}},
:user_id
{:field-keys
{:to :User,
:has-many :groups,
:has-many-aggr :groups_aggregate,
:has-one :user}}},
:lcn-mut-keys
{:create :createGroup,
:update :updateGroup,
:delete :deleteGroup},
:lcn-obj-keys
{:rsc :Group,
:clauses :GroupClauses,
:where :GroupWhere,
:sort :GroupSort,
:fields :GroupFields,
:aggregate :GroupAggregate,
:pks :GroupPks,
:pk-input :GroupPkColumns},
:lcn-qry-keys {:queries :groups, :aggregate :groups_aggregate},
:lcn-descs
{:rsc "Groups",
:query "Query Groups.",
:clauses
"Format for where clauses is {column: {operator: value}}. Multiple parameters are applied with `AND` operators. `AND`/`OR` conditions can be created as a list of clauses. It is possible to nest them to create sub groups of conditions.",
:sort "Sort format is {column: \"asc\" or \"desc\"}.",
:fields "Groupsfields for aggregation.",
:aggregate "Aggrecate Groups.",
:pks "Primary key fields.",
:pk-input "Primary key fields."},
:signals
{:query {:pre (), :post ()},
:create {:pre (), :post ()},
:delete {:pre (), :post ()},
:update {:pre (), :post ()}},
:pk-keys (:id),
:col-keys
#{:description
:title
:id
:user_id
:access
:edited_at
:created_at}},
:signals
{:query {:pre (), :post ()},
:create {:pre (), :post ()},
:delete {:pre (), :post ()},
:update {:pre (), :post ()}},
:pk-keys (:id),
:col-keys #{:color :title :group_id :id}},
:lcn-obj-keys
{:rsc :UsersInGroup,
:clauses :UsersInGroupClauses,
:where :UsersInGroupWhere,
:sort :UsersInGroupSort,
:fields :UsersInGroupFields,
:aggregate :UsersInGroupAggregate,
:pks :UsersInGroupPks,
:pk-input :UsersInGroupPkColumns},
:lcn-qry-keys
{:queries :users_in_groups,
:aggregate :users_in_groups_aggregate},
:lcn-descs
{:rsc "UsersInGroups",
:query "Query UsersInGroups.",
:clauses
"Format for where clauses is {column: {operator: value}}. Multiple parameters are applied with `AND` operators. `AND`/`OR` conditions can be created as a list of clauses. It is possible to nest them to create sub groups of conditions.",
:sort "Sort format is {column: \"asc\" or \"desc\"}.",
:fields "UsersInGroupsfields for aggregation.",
:aggregate "Aggrecate UsersInGroups.",
:pks "Primary key fields.",
:pk-input "Primary key fields."},
:access
{:lcn-fields
{:rsc
{:can_read {:type Boolean},
:inherit {:type Boolean},
:can_edit {:type Boolean},
:group_id {:type Int},
:id {:type Int},
:user_id {:type String},
:role_id {:type Int},
:next_access {:type Int},
:owner {:type Boolean}},
:clauses
{:can_read {:type :BoolWhere},
:inherit {:type :BoolWhere},
:can_edit {:type :BoolWhere},
:or {:type (list :AccessClauses)},
:group_id {:type :IntWhere},
:id {:type :IntWhere},
:and {:type (list :AccessClauses)},
:user_id {:type :StrWhere},
:role_id {:type :IntWhere},
:next_access {:type :IntWhere},
:owner {:type :BoolWhere}},
:sort
{:can_read {:type :SortOperator},
:inherit {:type :SortOperator},
:can_edit {:type :SortOperator},
:group_id {:type :SortOperator},
:id {:type :SortOperator},
:user_id {:type :SortOperator},
:role_id {:type :SortOperator},
:next_access {:type :SortOperator},
:owner {:type :SortOperator}},
:fields
{:can_read {:type Boolean},
:inherit {:type Boolean},
:can_edit {:type Boolean},
:group_id {:type Int},
:id {:type Int},
:user_id {:type String},
:role_id {:type Int},
:next_access {:type Int},
:owner {:type Boolean}},
:aggregate
{:count {:type Int},
:sum {:type :AccessFields},
:avg {:type :AccessFields},
:max {:type :AccessFields},
:min {:type :AccessFields}},
:pks {:id {:type (non-null Int)}},
:pk-input {:id {:type (non-null Int)}},
:update
{:can_read {:type Boolean},
:inherit {:type Boolean},
:can_edit {:type Boolean},
:group_id {:type Int},
:user_id {:type String},
:role_id {:type Int},
:next_access {:type Int},
:owner {:type Boolean}}},
:fks
{:next_access
{:field-keys
{:to :Access,
:has-many :accesses,
:has-many-aggr :accesses_aggregate,
:has-one :next_access_access}},
:role_id
{:field-keys
{:to :Role,
:has-many :accesses,
:has-many-aggr :accesses_aggregate,
:has-one :role}},
:user_id
{:field-keys
{:to :User,
:has-many :accesses,
:has-many-aggr :accesses_aggregate,
:has-one :user}},
:group_id
{:field-keys
{:to :Group,
:has-many :accesses,
:has-many-aggr :accesses_aggregate,
:has-one :group}}},
:lcn-mut-keys
{:create :createAccess,
:update :updateAccess,
:delete :deleteAccess},
:roles
{:lcn-fields
{:rsc
{:id {:type Int},
:group_id {:type Int},
:title {:type String},
:color {:type String}},
:clauses
{:and {:type (list :RoleClauses)},
:or {:type (list :RoleClauses)},
:id {:type :IntWhere},
:group_id {:type :IntWhere},
:title {:type :StrWhere},
:color {:type :StrWhere}},
:sort
{:id {:type :SortOperator},
:group_id {:type :SortOperator},
:title {:type :SortOperator},
:color {:type :SortOperator}},
:fields
{:id {:type Int},
:group_id {:type Int},
:title {:type String},
:color {:type String}},
:aggregate
{:count {:type Int},
:sum {:type :RoleFields},
:avg {:type :RoleFields},
:max {:type :RoleFields},
:min {:type :RoleFields}},
:pks {:id {:type (non-null Int)}},
:pk-input {:id {:type (non-null Int)}},
:update
{:group_id {:type Int},
:title {:type String},
:color {:type String}}},
:fks
{:group_id
{:field-keys
{:to :Group,
:has-many :roles,
:has-many-aggr :roles_aggregate,
:has-one :group}}},
:lcn-mut-keys
{:create :createRole, :update :updateRole, :delete :deleteRole},
:lcn-obj-keys
{:rsc :Role,
:clauses :RoleClauses,
:where :RoleWhere,
:sort :RoleSort,
:fields :RoleFields,
:aggregate :RoleAggregate,
:pks :RolePks,
:pk-input :RolePkColumns},
:lcn-qry-keys {:queries :roles, :aggregate :roles_aggregate},
:lcn-descs
{:rsc "Roles",
:query "Query Roles.",
:clauses
"Format for where clauses is {column: {operator: value}}. Multiple parameters are applied with `AND` operators. `AND`/`OR` conditions can be created as a list of clauses. It is possible to nest them to create sub groups of conditions.",
:sort "Sort format is {column: \"asc\" or \"desc\"}.",
:fields "Rolesfields for aggregation.",
:aggregate "Aggrecate Roles.",
:pks "Primary key fields.",
:pk-input "Primary key fields."},
:groups
{:lcn-fields
{:rsc
{:access {:type Int},
:created_at {:type String},
:edited_at {:type String},
:id {:type Int},
:title {:type String},
:user_id {:type String},
:description {:type String}},
:clauses
{:description {:type :StrWhere},
:or {:type (list :GroupClauses)},
:title {:type :StrWhere},
:id {:type :IntWhere},
:and {:type (list :GroupClauses)},
:user_id {:type :StrWhere},
:access {:type :IntWhere},
:edited_at {:type :StrWhere},
:created_at {:type :StrWhere}},
:sort
{:access {:type :SortOperator},
:created_at {:type :SortOperator},
:edited_at {:type :SortOperator},
:id {:type :SortOperator},
:title {:type :SortOperator},
:user_id {:type :SortOperator},
:description {:type :SortOperator}},
:fields
{:access {:type Int},
:created_at {:type String},
:edited_at {:type String},
:id {:type Int},
:title {:type String},
:user_id {:type String},
:description {:type String}},
:aggregate
{:count {:type Int},
:sum {:type :GroupFields},
:avg {:type :GroupFields},
:max {:type :GroupFields},
:min {:type :GroupFields}},
:pks {:id {:type (non-null Int)}},
:pk-input {:id {:type (non-null Int)}},
:update
{:access {:type Int},
:created_at {:type String},
:edited_at {:type String},
:title {:type String},
:user_id {:type String},
:description {:type String}}},
:fks
{:access
{:field-keys
{:to :Access,
:has-many :groups,
:has-many-aggr :groups_aggregate,
:has-one :access_access}},
:user_id
{:field-keys
{:to :User,
:has-many :groups,
:has-many-aggr :groups_aggregate,
:has-one :user}}},
:lcn-mut-keys
{:create :createGroup,
:update :updateGroup,
:delete :deleteGroup},
:lcn-obj-keys
{:rsc :Group,
:clauses :GroupClauses,
:where :GroupWhere,
:sort :GroupSort,
:fields :GroupFields,
:aggregate :GroupAggregate,
:pks :GroupPks,
:pk-input :GroupPkColumns},
:lcn-qry-keys {:queries :groups, :aggregate :groups_aggregate},
:lcn-descs
{:rsc "Groups",
:query "Query Groups.",
:clauses
"Format for where clauses is {column: {operator: value}}. Multiple parameters are applied with `AND` operators. `AND`/`OR` conditions can be created as a list of clauses. It is possible to nest them to create sub groups of conditions.",
:sort "Sort format is {column: \"asc\" or \"desc\"}.",
:fields "Groupsfields for aggregation.",
:aggregate "Aggrecate Groups.",
:pks "Primary key fields.",
:pk-input "Primary key fields."},
:signals
{:query {:pre (), :post ()},
:create {:pre (), :post ()},
:delete {:pre (), :post ()},
:update {:pre (), :post ()}},
:pk-keys (:id),
:col-keys
#{:description
:title
:id
:user_id
:access
:edited_at
:created_at}},
:signals
{:query {:pre (), :post ()},
:create {:pre (), :post ()},
:delete {:pre (), :post ()},
:update {:pre (), :post ()}},
:pk-keys (:id),
:col-keys #{:color :title :group_id :id}},
:lcn-obj-keys
{:rsc :Access,
:clauses :AccessClauses,
:where :AccessWhere,
:sort :AccessSort,
:fields :AccessFields,
:aggregate :AccessAggregate,
:pks :AccessPks,
:pk-input :AccessPkColumns},
:lcn-qry-keys
{:queries :accesses, :aggregate :accesses_aggregate},
:lcn-descs
{:rsc "Accesses",
:query "Query Accesses.",
:clauses
"Format for where clauses is {column: {operator: value}}. Multiple parameters are applied with `AND` operators. `AND`/`OR` conditions can be created as a list of clauses. It is possible to nest them to create sub groups of conditions.",
:sort "Sort format is {column: \"asc\" or \"desc\"}.",
:fields "Accessesfields for aggregation.",
:aggregate "Aggrecate Accesses.",
:pks "Primary key fields.",
:pk-input "Primary key fields."},
:groups
{:lcn-fields
{:rsc
{:access {:type Int},
:created_at {:type String},
:edited_at {:type String},
:id {:type Int},
:title {:type String},
:user_id {:type String},
:description {:type String}},
:clauses
{:description {:type :StrWhere},
:or {:type (list :GroupClauses)},
:title {:type :StrWhere},
:id {:type :IntWhere},
:and {:type (list :GroupClauses)},
:user_id {:type :StrWhere},
:access {:type :IntWhere},
:edited_at {:type :StrWhere},
:created_at {:type :StrWhere}},
:sort
{:access {:type :SortOperator},
:created_at {:type :SortOperator},
:edited_at {:type :SortOperator},
:id {:type :SortOperator},
:title {:type :SortOperator},
:user_id {:type :SortOperator},
:description {:type :SortOperator}},
:fields
{:access {:type Int},
:created_at {:type String},
:edited_at {:type String},
:id {:type Int},
:title {:type String},
:user_id {:type String},
:description {:type String}},
:aggregate
{:count {:type Int},
:sum {:type :GroupFields},
:avg {:type :GroupFields},
:max {:type :GroupFields},
:min {:type :GroupFields}},
:pks {:id {:type (non-null Int)}},
:pk-input {:id {:type (non-null Int)}},
:update
{:access {:type Int},
:created_at {:type String},
:edited_at {:type String},
:title {:type String},
:user_id {:type String},
:description {:type String}}},
:fks
{:access
{:field-keys
{:to :Access,
:has-many :groups,
:has-many-aggr :groups_aggregate,
:has-one :access_access}},
:user_id
{:field-keys
{:to :User,
:has-many :groups,
:has-many-aggr :groups_aggregate,
:has-one :user}}},
:lcn-mut-keys
{:create :createGroup,
:update :updateGroup,
:delete :deleteGroup},
:lcn-obj-keys
{:rsc :Group,
:clauses :GroupClauses,
:where :GroupWhere,
:sort :GroupSort,
:fields :GroupFields,
:aggregate :GroupAggregate,
:pks :GroupPks,
:pk-input :GroupPkColumns},
:lcn-qry-keys {:queries :groups, :aggregate :groups_aggregate},
:lcn-descs
{:rsc "Groups",
:query "Query Groups.",
:clauses
"Format for where clauses is {column: {operator: value}}. Multiple parameters are applied with `AND` operators. `AND`/`OR` conditions can be created as a list of clauses. It is possible to nest them to create sub groups of conditions.",
:sort "Sort format is {column: \"asc\" or \"desc\"}.",
:fields "Groupsfields for aggregation.",
:aggregate "Aggrecate Groups.",
:pks "Primary key fields.",
:pk-input "Primary key fields."},
:signals
{:query {:pre (), :post ()},
:create {:pre (), :post ()},
:delete {:pre (), :post ()},
:update {:pre (), :post ()}},
:pk-keys (:id),
:col-keys
#{:description
:title
:id
:user_id
:access
:edited_at
:created_at}},
:signals
{:query {:pre (), :post ()},
:create {:pre (), :post ()},
:delete {:pre (), :post ()},
:update {:pre (), :post ()}},
:pk-keys (:id),
:col-keys
#{:can_read
:inherit
:can_edit
:group_id
:id
:user_id
:role_id
:next_access
:owner}},
:groups
{:lcn-fields
{:rsc
{:access {:type Int},
:created_at {:type String},
:edited_at {:type String},
:id {:type Int},
:title {:type String},
:user_id {:type String},
:description {:type String}},
:clauses
{:description {:type :StrWhere},
:or {:type (list :GroupClauses)},
:title {:type :StrWhere},
:id {:type :IntWhere},
:and {:type (list :GroupClauses)},
:user_id {:type :StrWhere},
:access {:type :IntWhere},
:edited_at {:type :StrWhere},
:created_at {:type :StrWhere}},
:sort
{:access {:type :SortOperator},
:created_at {:type :SortOperator},
:edited_at {:type :SortOperator},
:id {:type :SortOperator},
:title {:type :SortOperator},
:user_id {:type :SortOperator},
:description {:type :SortOperator}},
:fields
{:access {:type Int},
:created_at {:type String},
:edited_at {:type String},
:id {:type Int},
:title {:type String},
:user_id {:type String},
:description {:type String}},
:aggregate
{:count {:type Int},
:sum {:type :GroupFields},
:avg {:type :GroupFields},
:max {:type :GroupFields},
:min {:type :GroupFields}},
:pks {:id {:type (non-null Int)}},
:pk-input {:id {:type (non-null Int)}},
:update
{:access {:type Int},
:created_at {:type String},
:edited_at {:type String},
:title {:type String},
:user_id {:type String},
:description {:type String}}},
:fks
{:access
{:field-keys
{:to :Access,
:has-many :groups,
:has-many-aggr :groups_aggregate,
:has-one :access_access}},
:user_id
{:field-keys
{:to :User,
:has-many :groups,
:has-many-aggr :groups_aggregate,
:has-one :user}}},
:lcn-mut-keys
{:create :createGroup,
:update :updateGroup,
:delete :deleteGroup},
:lcn-obj-keys
{:rsc :Group,
:clauses :GroupClauses,
:where :GroupWhere,
:sort :GroupSort,
:fields :GroupFields,
:aggregate :GroupAggregate,
:pks :GroupPks,
:pk-input :GroupPkColumns},
:lcn-qry-keys {:queries :groups, :aggregate :groups_aggregate},
:lcn-descs
{:rsc "Groups",
:query "Query Groups.",
:clauses
"Format for where clauses is {column: {operator: value}}. Multiple parameters are applied with `AND` operators. `AND`/`OR` conditions can be created as a list of clauses. It is possible to nest them to create sub groups of conditions.",
:sort "Sort format is {column: \"asc\" or \"desc\"}.",
:fields "Groupsfields for aggregation.",
:aggregate "Aggrecate Groups.",
:pks "Primary key fields.",
:pk-input "Primary key fields."},
:signals
{:query {:pre (), :post ()},
:create {:pre (), :post ()},
:delete {:pre (), :post ()},
:update {:pre (), :post ()}},
:pk-keys (:id),
:col-keys
#{:description
:title
:id
:user_id
:access
:edited_at
:created_at}},
:signals
{:query {:pre (), :post ()},
:create {:pre (), :post ()},
:delete {:pre (), :post ()},
:update {:pre (), :post ()}},
:pk-keys (:user_id :group_id :role_id),
:col-keys #{:group_id :user_id :role_id}}},
:users
{:lcn-fields
{:rsc
{:created_at {:type String},
:user_name {:type String},
:email {:type String},
:password_hash {:type String}},
:clauses
{:and {:type (list :UserClauses)},
:or {:type (list :UserClauses)},
:created_at {:type :StrWhere},
:user_name {:type :StrWhere},
:email {:type :StrWhere},
:password_hash {:type :StrWhere}},
:sort
{:created_at {:type :SortOperator},
:user_name {:type :SortOperator},
:email {:type :SortOperator},
:password_hash {:type :SortOperator}},
:fields
{:created_at {:type String},
:user_name {:type String},
:email {:type String},
:password_hash {:type String}},
:aggregate
{:count {:type Int},
:sum {:type :UserFields},
:avg {:type :UserFields},
:max {:type :UserFields},
:min {:type :UserFields}},
:pks {:user_name {:type (non-null String)}},
:pk-input {:user_name {:type (non-null String)}},
:update
{:created_at {:type String},
:email {:type String},
:password_hash {:type String}}},
:votes
{:lcn-fields
{:rsc
{:attribute {:type Int},
:magnitude {:type Int},
:domain_pk_namespace {:type String},
:id {:type Int},
:access {:type Int},
:edited_at {:type String},
:right_item_id {:type Int},
:created_at {:type String},
:left_item_id {:type Int}},
:clauses
{:attribute {:type :IntWhere},
:or {:type (list :VoteClauses)},
:magnitude {:type :IntWhere},
:domain_pk_namespace {:type :StrWhere},
:id {:type :IntWhere},
:and {:type (list :VoteClauses)},
:access {:type :IntWhere},
:edited_at {:type :StrWhere},
:right_item_id {:type :IntWhere},
:created_at {:type :StrWhere},
:left_item_id {:type :IntWhere}},
:sort
{:attribute {:type :SortOperator},
:magnitude {:type :SortOperator},
:domain_pk_namespace {:type :SortOperator},
:id {:type :SortOperator},
:access {:type :SortOperator},
:edited_at {:type :SortOperator},
:right_item_id {:type :SortOperator},
:created_at {:type :SortOperator},
:left_item_id {:type :SortOperator}},
:fields
{:attribute {:type Int},
:magnitude {:type Int},
:domain_pk_namespace {:type String},
:id {:type Int},
:access {:type Int},
:edited_at {:type String},
:right_item_id {:type Int},
:created_at {:type String},
:left_item_id {:type Int}},
:aggregate
{:count {:type Int},
:sum {:type :VoteFields},
:avg {:type :VoteFields},
:max {:type :VoteFields},
:min {:type :VoteFields}},
:pks {:id {:type (non-null Int)}},
:pk-input {:id {:type (non-null Int)}},
:update
{:attribute {:type Int},
:magnitude {:type Int},
:domain_pk_namespace {:type String},
:access {:type Int},
:edited_at {:type String},
:right_item_id {:type Int},
:created_at {:type String},
:left_item_id {:type Int}}},
:fks
{:access
{:field-keys
{:to :Access,
:has-many :votes,
:has-many-aggr :votes_aggregate,
:has-one :access_access}},
:left_item_id
{:field-keys
{:to :Item,
:has-many :votes_on_left_item_id,
:has-many-aggr :votes_on_left_item_id_aggregate,
:has-one :left_item}},
:right_item_id
{:field-keys
{:to :Item,
:has-many :votes_on_right_item_id,
:has-many-aggr :votes_on_right_item_id_aggregate,
:has-one :right_item}},
:attribute
{:field-keys
{:to :Attribute,
:has-many :votes,
:has-many-aggr :votes_aggregate,
:has-one :attribute_attribute}}},
:lcn-mut-keys
{:create :createVote, :update :updateVote, :delete :deleteVote},
:roles
{:lcn-fields
{:rsc
{:id {:type Int},
:group_id {:type Int},
:title {:type String},
:color {:type String}},
:clauses
{:and {:type (list :RoleClauses)},
:or {:type (list :RoleClauses)},
:id {:type :IntWhere},
:group_id {:type :IntWhere},
:title {:type :StrWhere},
:color {:type :StrWhere}},
:sort
{:id {:type :SortOperator},
:group_id {:type :SortOperator},
:title {:type :SortOperator},
:color {:type :SortOperator}},
:fields
{:id {:type Int},
:group_id {:type Int},
:title {:type String},
:color {:type String}},
:aggregate
{:count {:type Int},
:sum {:type :RoleFields},
:avg {:type :RoleFields},
:max {:type :RoleFields},
:min {:type :RoleFields}},
:pks {:id {:type (non-null Int)}},
:pk-input {:id {:type (non-null Int)}},
:update
{:group_id {:type Int},
:title {:type String},
:color {:type String}}},
:fks
{:group_id
{:field-keys
{:to :Group,
:has-many :roles,
:has-many-aggr :roles_aggregate,
:has-one :group}}},
:lcn-mut-keys
{:create :createRole, :update :updateRole, :delete :deleteRole},
:lcn-obj-keys
{:rsc :Role,
:clauses :RoleClauses,
:where :RoleWhere,
:sort :RoleSort,
:fields :RoleFields,
:aggregate :RoleAggregate,
:pks :RolePks,
:pk-input :RolePkColumns},
:lcn-qry-keys {:queries :roles, :aggregate :roles_aggregate},
:lcn-descs
{:rsc "Roles",
:query "Query Roles.",
:clauses
"Format for where clauses is {column: {operator: value}}. Multiple parameters are applied with `AND` operators. `AND`/`OR` conditions can be created as a list of clauses. It is possible to nest them to create sub groups of conditions.",
:sort "Sort format is {column: \"asc\" or \"desc\"}.",
:fields "Rolesfields for aggregation.",
:aggregate "Aggrecate Roles.",
:pks "Primary key fields.",
:pk-input "Primary key fields."},
:groups
{:lcn-fields
{:rsc
{:access {:type Int},
:created_at {:type String},
:edited_at {:type String},
:id {:type Int},
:title {:type String},
:user_id {:type String},
:description {:type String}},
:clauses
{:description {:type :StrWhere},
:or {:type (list :GroupClauses)},
:title {:type :StrWhere},
:id {:type :IntWhere},
:and {:type (list :GroupClauses)},
:user_id {:type :StrWhere},
:access {:type :IntWhere},
:edited_at {:type :StrWhere},
:created_at {:type :StrWhere}},
:sort
{:access {:type :SortOperator},
:created_at {:type :SortOperator},
:edited_at {:type :SortOperator},
:id {:type :SortOperator},
:title {:type :SortOperator},
:user_id {:type :SortOperator},
:description {:type :SortOperator}},
:fields
{:access {:type Int},
:created_at {:type String},
:edited_at {:type String},
:id {:type Int},
:title {:type String},
:user_id {:type String},
:description {:type String}},
:aggregate
{:count {:type Int},
:sum {:type :GroupFields},
:avg {:type :GroupFields},
:max {:type :GroupFields},
:min {:type :GroupFields}},
:pks {:id {:type (non-null Int)}},
:pk-input {:id {:type (non-null Int)}},
:update
{:access {:type Int},
:created_at {:type String},
:edited_at {:type String},
:title {:type String},
:user_id {:type String},
:description {:type String}}},
:fks
{:access
{:field-keys
{:to :Access,
:has-many :groups,
:has-many-aggr :groups_aggregate,
:has-one :access_access}},
:user_id
{:field-keys
{:to :User,
:has-many :groups,
:has-many-aggr :groups_aggregate,
:has-one :user}}},
:lcn-mut-keys
{:create :createGroup,
:update :updateGroup,
:delete :deleteGroup},
:lcn-obj-keys
{:rsc :Group,
:clauses :GroupClauses,
:where :GroupWhere,
:sort :GroupSort,
:fields :GroupFields,
:aggregate :GroupAggregate,
:pks :GroupPks,
:pk-input :GroupPkColumns},
:lcn-qry-keys {:queries :groups, :aggregate :groups_aggregate},
:lcn-descs
{:rsc "Groups",
:query "Query Groups.",
:clauses
"Format for where clauses is {column: {operator: value}}. Multiple parameters are applied with `AND` operators. `AND`/`OR` conditions can be created as a list of clauses. It is possible to nest them to create sub groups of conditions.",
:sort "Sort format is {column: \"asc\" or \"desc\"}.",
:fields "Groupsfields for aggregation.",
:aggregate "Aggrecate Groups.",
:pks "Primary key fields.",
:pk-input "Primary key fields."},
:signals
{:query {:pre (), :post ()},
:create {:pre (), :post ()},
:delete {:pre (), :post ()},
:update {:pre (), :post ()}},
:pk-keys (:id),
:col-keys
#{:description
:title
:id
:user_id
:access
:edited_at
:created_at}},
:signals
{:query {:pre (), :post ()},
:create {:pre (), :post ()},
:delete {:pre (), :post ()},
:update {:pre (), :post ()}},
:pk-keys (:id),
:col-keys #{:color :title :group_id :id}},
:lcn-obj-keys
{:rsc :Vote,
:clauses :VoteClauses,
:where :VoteWhere,
:sort :VoteSort,
:fields :VoteFields,
:aggregate :VoteAggregate,
:pks :VotePks,
:pk-input :VotePkColumns},
:lcn-qry-keys {:queries :votes, :aggregate :votes_aggregate},
:lcn-descs
{:rsc "Votes",
:query "Query Votes.",
:clauses
"Format for where clauses is {column: {operator: value}}. Multiple parameters are applied with `AND` operators. `AND`/`OR` conditions can be created as a list of clauses. It is possible to nest them to create sub groups of conditions.",
:sort "Sort format is {column: \"asc\" or \"desc\"}.",
:fields "Votesfields for aggregation.",
:aggregate "Aggrecate Votes.",
:pks "Primary key fields.",
:pk-input "Primary key fields."},
:access
{:lcn-fields
{:rsc
{:can_read {:type Boolean},
:inherit {:type Boolean},
:can_edit {:type Boolean},
:group_id {:type Int},
:id {:type Int},
:user_id {:type String},
:role_id {:type Int},
:next_access {:type Int},
:owner {:type Boolean}},
:clauses
{:can_read {:type :BoolWhere},
:inherit {:type :BoolWhere},
:can_edit {:type :BoolWhere},
:or {:type (list :AccessClauses)},
:group_id {:type :IntWhere},
:id {:type :IntWhere},
:and {:type (list :AccessClauses)},
:user_id {:type :StrWhere},
:role_id {:type :IntWhere},
:next_access {:type :IntWhere},
:owner {:type :BoolWhere}},
:sort
{:can_read {:type :SortOperator},
:inherit {:type :SortOperator},
:can_edit {:type :SortOperator},
:group_id {:type :SortOperator},
:id {:type :SortOperator},
:user_id {:type :SortOperator},
:role_id {:type :SortOperator},
:next_access {:type :SortOperator},
:owner {:type :SortOperator}},
:fields
{:can_read {:type Boolean},
:inherit {:type Boolean},
:can_edit {:type Boolean},
:group_id {:type Int},
:id {:type Int},
:user_id {:type String},
:role_id {:type Int},
:next_access {:type Int},
:owner {:type Boolean}},
:aggregate
{:count {:type Int},
:sum {:type :AccessFields},
:avg {:type :AccessFields},
:max {:type :AccessFields},
:min {:type :AccessFields}},
:pks {:id {:type (non-null Int)}},
:pk-input {:id {:type (non-null Int)}},
:update
{:can_read {:type Boolean},
:inherit {:type Boolean},
:can_edit {:type Boolean},
:group_id {:type Int},
:user_id {:type String},
:role_id {:type Int},
:next_access {:type Int},
:owner {:type Boolean}}},
:fks
{:next_access
{:field-keys
{:to :Access,
:has-many :accesses,
:has-many-aggr :accesses_aggregate,
:has-one :next_access_access}},
:role_id
{:field-keys
{:to :Role,
:has-many :accesses,
:has-many-aggr :accesses_aggregate,
:has-one :role}},
:user_id
{:field-keys
{:to :User,
:has-many :accesses,
:has-many-aggr :accesses_aggregate,
:has-one :user}},
:group_id
{:field-keys
{:to :Group,
:has-many :accesses,
:has-many-aggr :accesses_aggregate,
:has-one :group}}},
:lcn-mut-keys
{:create :createAccess,
:update :updateAccess,
:delete :deleteAccess},
:roles
{:lcn-fields
{:rsc
{:id {:type Int},
:group_id {:type Int},
:title {:type String},
:color {:type String}},
:clauses
{:and {:type (list :RoleClauses)},
:or {:type (list :RoleClauses)},
:id {:type :IntWhere},
:group_id {:type :IntWhere},
:title {:type :StrWhere},
:color {:type :StrWhere}},
:sort
{:id {:type :SortOperator},
:group_id {:type :SortOperator},
:title {:type :SortOperator},
:color {:type :SortOperator}},
:fields
{:id {:type Int},
:group_id {:type Int},
:title {:type String},
:color {:type String}},
:aggregate
{:count {:type Int},
:sum {:type :RoleFields},
:avg {:type :RoleFields},
:max {:type :RoleFields},
:min {:type :RoleFields}},
:pks {:id {:type (non-null Int)}},
:pk-input {:id {:type (non-null Int)}},
:update
{:group_id {:type Int},
:title {:type String},
:color {:type String}}},
:fks
{:group_id
{:field-keys
{:to :Group,
:has-many :roles,
:has-many-aggr :roles_aggregate,
:has-one :group}}},
:lcn-mut-keys
{:create :createRole, :update :updateRole, :delete :deleteRole},
:lcn-obj-keys
{:rsc :Role,
:clauses :RoleClauses,
:where :RoleWhere,
:sort :RoleSort,
:fields :RoleFields,
:aggregate :RoleAggregate,
:pks :RolePks,
:pk-input :RolePkColumns},
:lcn-qry-keys {:queries :roles, :aggregate :roles_aggregate},
:lcn-descs
{:rsc "Roles",
:query "Query Roles.",
:clauses
"Format for where clauses is {column: {operator: value}}. Multiple parameters are applied with `AND` operators. `AND`/`OR` conditions can be created as a list of clauses. It is possible to nest them to create sub groups of conditions.",
:sort "Sort format is {column: \"asc\" or \"desc\"}.",
:fields "Rolesfields for aggregation.",
:aggregate "Aggrecate Roles.",
:pks "Primary key fields.",
:pk-input "Primary key fields."},
:groups
{:lcn-fields
{:rsc
{:access {:type Int},
:created_at {:type String},
:edited_at {:type String},
:id {:type Int},
:title {:type String},
:user_id {:type String},
:description {:type String}},
:clauses
{:description {:type :StrWhere},
:or {:type (list :GroupClauses)},
:title {:type :StrWhere},
:id {:type :IntWhere},
:and {:type (list :GroupClauses)},
:user_id {:type :StrWhere},
:access {:type :IntWhere},
:edited_at {:type :StrWhere},
:created_at {:type :StrWhere}},
:sort
{:access {:type :SortOperator},
:created_at {:type :SortOperator},
:edited_at {:type :SortOperator},
:id {:type :SortOperator},
:title {:type :SortOperator},
:user_id {:type :SortOperator},
:description {:type :SortOperator}},
:fields
{:access {:type Int},
:created_at {:type String},
:edited_at {:type String},
:id {:type Int},
:title {:type String},
:user_id {:type String},
:description {:type String}},
:aggregate
{:count {:type Int},
:sum {:type :GroupFields},
:avg {:type :GroupFields},
:max {:type :GroupFields},
:min {:type :GroupFields}},
:pks {:id {:type (non-null Int)}},
:pk-input {:id {:type (non-null Int)}},
:update
{:access {:type Int},
:created_at {:type String},
:edited_at {:type String},
:title {:type String},
:user_id {:type String},
:description {:type String}}},
:fks
{:access
{:field-keys
{:to :Access,
:has-many :groups,
:has-many-aggr :groups_aggregate,
:has-one :access_access}},
:user_id
{:field-keys
{:to :User,
:has-many :groups,
:has-many-aggr :groups_aggregate,
:has-one :user}}},
:lcn-mut-keys
{:create :createGroup,
:update :updateGroup,
:delete :deleteGroup},
:lcn-obj-keys
{:rsc :Group,
:clauses :GroupClauses,
:where :GroupWhere,
:sort :GroupSort,
:fields :GroupFields,
:aggregate :GroupAggregate,
:pks :GroupPks,
:pk-input :GroupPkColumns},
:lcn-qry-keys {:queries :groups, :aggregate :groups_aggregate},
:lcn-descs
{:rsc "Groups",
:query "Query Groups.",
:clauses
"Format for where clauses is {column: {operator: value}}. Multiple parameters are applied with `AND` operators. `AND`/`OR` conditions can be created as a list of clauses. It is possible to nest them to create sub groups of conditions.",
:sort "Sort format is {column: \"asc\" or \"desc\"}.",
:fields "Groupsfields for aggregation.",
:aggregate "Aggrecate Groups.",
:pks "Primary key fields.",
:pk-input "Primary key fields."},
:signals
{:query {:pre (), :post ()},
:create {:pre (), :post ()},
:delete {:pre (), :post ()},
:update {:pre (), :post ()}},
:pk-keys (:id),
:col-keys
#{:description
:title
:id
:user_id
:access
:edited_at
:created_at}},
:signals
{:query {:pre (), :post ()},
:create {:pre (), :post ()},
:delete {:pre (), :post ()},
:update {:pre (), :post ()}},
:pk-keys (:id),
:col-keys #{:color :title :group_id :id}},
:lcn-obj-keys
{:rsc :Access,
:clauses :AccessClauses,
:where :AccessWhere,
:sort :AccessSort,
:fields :AccessFields,
:aggregate :AccessAggregate,
:pks :AccessPks,
:pk-input :AccessPkColumns},
:lcn-qry-keys
{:queries :accesses, :aggregate :accesses_aggregate},
:lcn-descs
{:rsc "Accesses",
:query "Query Accesses.",
:clauses
"Format for where clauses is {column: {operator: value}}. Multiple parameters are applied with `AND` operators. `AND`/`OR` conditions can be created as a list of clauses. It is possible to nest them to create sub groups of conditions.",
:sort "Sort format is {column: \"asc\" or \"desc\"}.",
:fields "Accessesfields for aggregation.",
:aggregate "Aggrecate Accesses.",
:pks "Primary key fields.",
:pk-input "Primary key fields."},
:groups
{:lcn-fields
{:rsc
{:access {:type Int},
:created_at {:type String},
:edited_at {:type String},
:id {:type Int},
:title {:type String},
:user_id {:type String},
:description {:type String}},
:clauses
{:description {:type :StrWhere},
:or {:type (list :GroupClauses)},
:title {:type :StrWhere},
:id {:type :IntWhere},
:and {:type (list :GroupClauses)},
:user_id {:type :StrWhere},
:access {:type :IntWhere},
:edited_at {:type :StrWhere},
:created_at {:type :StrWhere}},
:sort
{:access {:type :SortOperator},
:created_at {:type :SortOperator},
:edited_at {:type :SortOperator},
:id {:type :SortOperator},
:title {:type :SortOperator},
:user_id {:type :SortOperator},
:description {:type :SortOperator}},
:fields
{:access {:type Int},
:created_at {:type String},
:edited_at {:type String},
:id {:type Int},
:title {:type String},
:user_id {:type String},
:description {:type String}},
:aggregate
{:count {:type Int},
:sum {:type :GroupFields},
:avg {:type :GroupFields},
:max {:type :GroupFields},
:min {:type :GroupFields}},
:pks {:id {:type (non-null Int)}},
:pk-input {:id {:type (non-null Int)}},
:update
{:access {:type Int},
:created_at {:type String},
:edited_at {:type String},
:title {:type String},
:user_id {:type String},
:description {:type String}}},
:fks
{:access
{:field-keys
{:to :Access,
:has-many :groups,
:has-many-aggr :groups_aggregate,
:has-one :access_access}},
:user_id
{:field-keys
{:to :User,
:has-many :groups,
:has-many-aggr :groups_aggregate,
:has-one :user}}},
:lcn-mut-keys
{:create :createGroup,
:update :updateGroup,
:delete :deleteGroup},
:lcn-obj-keys
{:rsc :Group,
:clauses :GroupClauses,
:where :GroupWhere,
:sort :GroupSort,
:fields :GroupFields,
:aggregate :GroupAggregate,
:pks :GroupPks,
:pk-input :GroupPkColumns},
:lcn-qry-keys {:queries :groups, :aggregate :groups_aggregate},
:lcn-descs
{:rsc "Groups",
:query "Query Groups.",
:clauses
"Format for where clauses is {column: {operator: value}}. Multiple parameters are applied with `AND` operators. `AND`/`OR` conditions can be created as a list of clauses. It is possible to nest them to create sub groups of conditions.",
:sort "Sort format is {column: \"asc\" or \"desc\"}.",
:fields "Groupsfields for aggregation.",
:aggregate "Aggrecate Groups.",
:pks "Primary key fields.",
:pk-input "Primary key fields."},
:signals
{:query {:pre (), :post ()},
:create {:pre (), :post ()},
:delete {:pre (), :post ()},
:update {:pre (), :post ()}},
:pk-keys (:id),
:col-keys
#{:description
:title
:id
:user_id
:access
:edited_at
:created_at}},
:signals
{:query {:pre (), :post ()},
:create {:pre (), :post ()},
:delete {:pre (), :post ()},
:update {:pre (), :post ()}},
:pk-keys (:id),
:col-keys
#{:can_read
:inherit
:can_edit
:group_id
:id
:user_id
:role_id
:next_access
:owner}},
:groups
{:lcn-fields
{:rsc
{:access {:type Int},
:created_at {:type String},
:edited_at {:type String},
:id {:type Int},
:title {:type String},
:user_id {:type String},
:description {:type String}},
:clauses
{:description {:type :StrWhere},
:or {:type (list :GroupClauses)},
:title {:type :StrWhere},
:id {:type :IntWhere},
:and {:type (list :GroupClauses)},
:user_id {:type :StrWhere},
:access {:type :IntWhere},
:edited_at {:type :StrWhere},
:created_at {:type :StrWhere}},
:sort
{:access {:type :SortOperator},
:created_at {:type :SortOperator},
:edited_at {:type :SortOperator},
:id {:type :SortOperator},
:title {:type :SortOperator},
:user_id {:type :SortOperator},
:description {:type :SortOperator}},
:fields
{:access {:type Int},
:created_at {:type String},
:edited_at {:type String},
:id {:type Int},
:title {:type String},
:user_id {:type String},
:description {:type String}},
:aggregate
{:count {:type Int},
:sum {:type :GroupFields},
:avg {:type :GroupFields},
:max {:type :GroupFields},
:min {:type :GroupFields}},
:pks {:id {:type (non-null Int)}},
:pk-input {:id {:type (non-null Int)}},
:update
{:access {:type Int},
:created_at {:type String},
:edited_at {:type String},
:title {:type String},
:user_id {:type String},
:description {:type String}}},
:fks
{:access
{:field-keys
{:to :Access,
:has-many :groups,
:has-many-aggr :groups_aggregate,
:has-one :access_access}},
:user_id
{:field-keys
{:to :User,
:has-many :groups,
:has-many-aggr :groups_aggregate,
:has-one :user}}},
:lcn-mut-keys
{:create :createGroup,
:update :updateGroup,
:delete :deleteGroup},
:lcn-obj-keys
{:rsc :Group,
:clauses :GroupClauses,
:where :GroupWhere,
:sort :GroupSort,
:fields :GroupFields,
:aggregate :GroupAggregate,
:pks :GroupPks,
:pk-input :GroupPkColumns},
:lcn-qry-keys {:queries :groups, :aggregate :groups_aggregate},
:lcn-descs
{:rsc "Groups",
:query "Query Groups.",
:clauses
"Format for where clauses is {column: {operator: value}}. Multiple parameters are applied with `AND` operators. `AND`/`OR` conditions can be created as a list of clauses. It is possible to nest them to create sub groups of conditions.",
:sort "Sort format is {column: \"asc\" or \"desc\"}.",
:fields "Groupsfields for aggregation.",
:aggregate "Aggrecate Groups.",
:pks "Primary key fields.",
:pk-input "Primary key fields."},
:signals
{:query {:pre (), :post ()},
:create {:pre (), :post ()},
:delete {:pre (), :post ()},
:update {:pre (), :post ()}},
:pk-keys (:id),
:col-keys
#{:description
:title
:id
:user_id
:access
:edited_at
:created_at}},
:items
{:lcn-fields
{:rsc
{:slug {:type String},
:domain_pk {:type String},
:title {:type String},
:domain_pk_namespace {:type String},
:id {:type Int},
:url {:type String},
:access {:type Int},
:edited_at {:type String},
:body {:type String},
:created_at {:type String}},
:clauses
{:slug {:type :StrWhere},
:domain_pk {:type :StrWhere},
:or {:type (list :ItemClauses)},
:title {:type :StrWhere},
:domain_pk_namespace {:type :StrWhere},
:id {:type :IntWhere},
:url {:type :StrWhere},
:and {:type (list :ItemClauses)},
:access {:type :IntWhere},
:edited_at {:type :StrWhere},
:body {:type :StrWhere},
:created_at {:type :StrWhere}},
:sort
{:slug {:type :SortOperator},
:domain_pk {:type :SortOperator},
:title {:type :SortOperator},
:domain_pk_namespace {:type :SortOperator},
:id {:type :SortOperator},
:url {:type :SortOperator},
:access {:type :SortOperator},
:edited_at {:type :SortOperator},
:body {:type :SortOperator},
:created_at {:type :SortOperator}},
:fields
{:slug {:type String},
:domain_pk {:type String},
:title {:type String},
:domain_pk_namespace {:type String},
:id {:type Int},
:url {:type String},
:access {:type Int},
:edited_at {:type String},
:body {:type String},
:created_at {:type String}},
:aggregate
{:count {:type Int},
:sum {:type :ItemFields},
:avg {:type :ItemFields},
:max {:type :ItemFields},
:min {:type :ItemFields}},
:pks {:id {:type (non-null Int)}},
:pk-input {:id {:type (non-null Int)}},
:update
{:slug {:type String},
:domain_pk {:type String},
:title {:type String},
:domain_pk_namespace {:type String},
:url {:type String},
:access {:type Int},
:edited_at {:type String},
:body {:type String},
:created_at {:type String}}},
:fks
{:access
{:field-keys
{:to :Access,
:has-many :items,
:has-many-aggr :items_aggregate,
:has-one :access_access}}},
:lcn-mut-keys
{:create :createItem, :update :updateItem, :delete :deleteItem},
:roles
{:lcn-fields
{:rsc
{:id {:type Int},
:group_id {:type Int},
:title {:type String},
:color {:type String}},
:clauses
{:and {:type (list :RoleClauses)},
:or {:type (list :RoleClauses)},
:id {:type :IntWhere},
:group_id {:type :IntWhere},
:title {:type :StrWhere},
:color {:type :StrWhere}},
:sort
{:id {:type :SortOperator},
:group_id {:type :SortOperator},
:title {:type :SortOperator},
:color {:type :SortOperator}},
:fields
{:id {:type Int},
:group_id {:type Int},
:title {:type String},
:color {:type String}},
:aggregate
{:count {:type Int},
:sum {:type :RoleFields},
:avg {:type :RoleFields},
:max {:type :RoleFields},
:min {:type :RoleFields}},
:pks {:id {:type (non-null Int)}},
:pk-input {:id {:type (non-null Int)}},
:update
{:group_id {:type Int},
:title {:type String},
:color {:type String}}},
:fks
{:group_id
{:field-keys
{:to :Group,
:has-many :roles,
:has-many-aggr :roles_aggregate,
:has-one :group}}},
:lcn-mut-keys
{:create :createRole, :update :updateRole, :delete :deleteRole},
:lcn-obj-keys
{:rsc :Role,
:clauses :RoleClauses,
:where :RoleWhere,
:sort :RoleSort,
:fields :RoleFields,
:aggregate :RoleAggregate,
:pks :RolePks,
:pk-input :RolePkColumns},
:lcn-qry-keys {:queries :roles, :aggregate :roles_aggregate},
:lcn-descs
{:rsc "Roles",
:query "Query Roles.",
:clauses
"Format for where clauses is {column: {operator: value}}. Multiple parameters are applied with `AND` operators. `AND`/`OR` conditions can be created as a list of clauses. It is possible to nest them to create sub groups of conditions.",
:sort "Sort format is {column: \"asc\" or \"desc\"}.",
:fields "Rolesfields for aggregation.",
:aggregate "Aggrecate Roles.",
:pks "Primary key fields.",
:pk-input "Primary key fields."},
:groups
{:lcn-fields
{:rsc
{:access {:type Int},
:created_at {:type String},
:edited_at {:type String},
:id {:type Int},
:title {:type String},
:user_id {:type String},
:description {:type String}},
:clauses
{:description {:type :StrWhere},
:or {:type (list :GroupClauses)},
:title {:type :StrWhere},
:id {:type :IntWhere},
:and {:type (list :GroupClauses)},
:user_id {:type :StrWhere},
:access {:type :IntWhere},
:edited_at {:type :StrWhere},
:created_at {:type :StrWhere}},
:sort
{:access {:type :SortOperator},
:created_at {:type :SortOperator},
:edited_at {:type :SortOperator},
:id {:type :SortOperator},
:title {:type :SortOperator},
:user_id {:type :SortOperator},
:description {:type :SortOperator}},
:fields
{:access {:type Int},
:created_at {:type String},
:edited_at {:type String},
:id {:type Int},
:title {:type String},
:user_id {:type String},
:description {:type String}},
:aggregate
{:count {:type Int},
:sum {:type :GroupFields},
:avg {:type :GroupFields},
:max {:type :GroupFields},
:min {:type :GroupFields}},
:pks {:id {:type (non-null Int)}},
:pk-input {:id {:type (non-null Int)}},
:update
{:access {:type Int},
:created_at {:type String},
:edited_at {:type String},
:title {:type String},
:user_id {:type String},
:description {:type String}}},
:fks
{:access
{:field-keys
{:to :Access,
:has-many :groups,
:has-many-aggr :groups_aggregate,
:has-one :access_access}},
:user_id
{:field-keys
{:to :User,
:has-many :groups,
:has-many-aggr :groups_aggregate,
:has-one :user}}},
:lcn-mut-keys
{:create :createGroup,
:update :updateGroup,
:delete :deleteGroup},
:lcn-obj-keys
{:rsc :Group,
:clauses :GroupClauses,
:where :GroupWhere,
:sort :GroupSort,
:fields :GroupFields,
:aggregate :GroupAggregate,
:pks :GroupPks,
:pk-input :GroupPkColumns},
:lcn-qry-keys {:queries :groups, :aggregate :groups_aggregate},
:lcn-descs
{:rsc "Groups",
:query "Query Groups.",
:clauses
"Format for where clauses is {column: {operator: value}}. Multiple parameters are applied with `AND` operators. `AND`/`OR` conditions can be created as a list of clauses. It is possible to nest them to create sub groups of conditions.",
:sort "Sort format is {column: \"asc\" or \"desc\"}.",
:fields "Groupsfields for aggregation.",
:aggregate "Aggrecate Groups.",
:pks "Primary key fields.",
:pk-input "Primary key fields."},
:signals
{:query {:pre (), :post ()},
:create {:pre (), :post ()},
:delete {:pre (), :post ()},
:update {:pre (), :post ()}},
:pk-keys (:id),
:col-keys
#{:description
:title
:id
:user_id
:access
:edited_at
:created_at}},
:signals
{:query {:pre (), :post ()},
:create {:pre (), :post ()},
:delete {:pre (), :post ()},
:update {:pre (), :post ()}},
:pk-keys (:id),
:col-keys #{:color :title :group_id :id}},
:lcn-obj-keys
{:rsc :Item,
:clauses :ItemClauses,
:where :ItemWhere,
:sort :ItemSort,
:fields :ItemFields,
:aggregate :ItemAggregate,
:pks :ItemPks,
:pk-input :ItemPkColumns},
:lcn-qry-keys {:queries :items, :aggregate :items_aggregate},
:lcn-descs
{:rsc "Items",
:query "Query Items.",
:clauses
"Format for where clauses is {column: {operator: value}}. Multiple parameters are applied with `AND` operators. `AND`/`OR` conditions can be created as a list of clauses. It is possible to nest them to create sub groups of conditions.",
:sort "Sort format is {column: \"asc\" or \"desc\"}.",
:fields "Itemsfields for aggregation.",
:aggregate "Aggrecate Items.",
:pks "Primary key fields.",
:pk-input "Primary key fields."},
:access
{:lcn-fields
{:rsc
{:can_read {:type Boolean},
:inherit {:type Boolean},
:can_edit {:type Boolean},
:group_id {:type Int},
:id {:type Int},
:user_id {:type String},
:role_id {:type Int},
:next_access {:type Int},
:owner {:type Boolean}},
:clauses
{:can_read {:type :BoolWhere},
:inherit {:type :BoolWhere},
:can_edit {:type :BoolWhere},
:or {:type (list :AccessClauses)},
:group_id {:type :IntWhere},
:id {:type :IntWhere},
:and {:type (list :AccessClauses)},
:user_id {:type :StrWhere},
:role_id {:type :IntWhere},
:next_access {:type :IntWhere},
:owner {:type :BoolWhere}},
:sort
{:can_read {:type :SortOperator},
:inherit {:type :SortOperator},
:can_edit {:type :SortOperator},
:group_id {:type :SortOperator},
:id {:type :SortOperator},
:user_id {:type :SortOperator},
:role_id {:type :SortOperator},
:next_access {:type :SortOperator},
:owner {:type :SortOperator}},
:fields
{:can_read {:type Boolean},
:inherit {:type Boolean},
:can_edit {:type Boolean},
:group_id {:type Int},
:id {:type Int},
:user_id {:type String},
:role_id {:type Int},
:next_access {:type Int},
:owner {:type Boolean}},
:aggregate
{:count {:type Int},
:sum {:type :AccessFields},
:avg {:type :AccessFields},
:max {:type :AccessFields},
:min {:type :AccessFields}},
:pks {:id {:type (non-null Int)}},
:pk-input {:id {:type (non-null Int)}},
:update
{:can_read {:type Boolean},
:inherit {:type Boolean},
:can_edit {:type Boolean},
:group_id {:type Int},
:user_id {:type String},
:role_id {:type Int},
:next_access {:type Int},
:owner {:type Boolean}}},
:fks
{:next_access
{:field-keys
{:to :Access,
:has-many :accesses,
:has-many-aggr :accesses_aggregate,
:has-one :next_access_access}},
:role_id
{:field-keys
{:to :Role,
:has-many :accesses,
:has-many-aggr :accesses_aggregate,
:has-one :role}},
:user_id
{:field-keys
{:to :User,
:has-many :accesses,
:has-many-aggr :accesses_aggregate,
:has-one :user}},
:group_id
{:field-keys
{:to :Group,
:has-many :accesses,
:has-many-aggr :accesses_aggregate,
:has-one :group}}},
:lcn-mut-keys
{:create :createAccess,
:update :updateAccess,
:delete :deleteAccess},
:roles
{:lcn-fields
{:rsc
{:id {:type Int},
:group_id {:type Int},
:title {:type String},
:color {:type String}},
:clauses
{:and {:type (list :RoleClauses)},
:or {:type (list :RoleClauses)},
:id {:type :IntWhere},
:group_id {:type :IntWhere},
:title {:type :StrWhere},
:color {:type :StrWhere}},
:sort
{:id {:type :SortOperator},
:group_id {:type :SortOperator},
:title {:type :SortOperator},
:color {:type :SortOperator}},
:fields
{:id {:type Int},
:group_id {:type Int},
:title {:type String},
:color {:type String}},
:aggregate
{:count {:type Int},
:sum {:type :RoleFields},
:avg {:type :RoleFields},
:max {:type :RoleFields},
:min {:type :RoleFields}},
:pks {:id {:type (non-null Int)}},
:pk-input {:id {:type (non-null Int)}},
:update
{:group_id {:type Int},
:title {:type String},
:color {:type String}}},
:fks
{:group_id
{:field-keys
{:to :Group,
:has-many :roles,
:has-many-aggr :roles_aggregate,
:has-one :group}}},
:lcn-mut-keys
{:create :createRole,
:update :updateRole,
:delete :deleteRole},
:lcn-obj-keys
{:rsc :Role,
:clauses :RoleClauses,
:where :RoleWhere,
:sort :RoleSort,
:fields :RoleFields,
:aggregate :RoleAggregate,
:pks :RolePks,
:pk-input :RolePkColumns},
:lcn-qry-keys {:queries :roles, :aggregate :roles_aggregate},
:lcn-descs
{:rsc "Roles",
:query "Query Roles.",
:clauses
"Format for where clauses is {column: {operator: value}}. Multiple parameters are applied with `AND` operators. `AND`/`OR` conditions can be created as a list of clauses. It is possible to nest them to create sub groups of conditions.",
:sort "Sort format is {column: \"asc\" or \"desc\"}.",
:fields "Rolesfields for aggregation.",
:aggregate "Aggrecate Roles.",
:pks "Primary key fields.",
:pk-input "Primary key fields."},
:groups
{:lcn-fields
{:rsc
{:access {:type Int},
:created_at {:type String},
:edited_at {:type String},
:id {:type Int},
:title {:type String},
:user_id {:type String},
:description {:type String}},
:clauses
{:description {:type :StrWhere},
:or {:type (list :GroupClauses)},
:title {:type :StrWhere},
:id {:type :IntWhere},
:and {:type (list :GroupClauses)},
:user_id {:type :StrWhere},
:access {:type :IntWhere},
:edited_at {:type :StrWhere},
:created_at {:type :StrWhere}},
:sort
{:access {:type :SortOperator},
:created_at {:type :SortOperator},
:edited_at {:type :SortOperator},
:id {:type :SortOperator},
:title {:type :SortOperator},
:user_id {:type :SortOperator},
:description {:type :SortOperator}},
:fields
{:access {:type Int},
:created_at {:type String},
:edited_at {:type String},
:id {:type Int},
:title {:type String},
:user_id {:type String},
:description {:type String}},
:aggregate
{:count {:type Int},
:sum {:type :GroupFields},
:avg {:type :GroupFields},
:max {:type :GroupFields},
:min {:type :GroupFields}},
:pks {:id {:type (non-null Int)}},
:pk-input {:id {:type (non-null Int)}},
:update
{:access {:type Int},
:created_at {:type String},
:edited_at {:type String},
:title {:type String},
:user_id {:type String},
:description {:type String}}},
:fks
{:access
{:field-keys
{:to :Access,
:has-many :groups,
:has-many-aggr :groups_aggregate,
:has-one :access_access}},
:user_id
{:field-keys
{:to :User,
:has-many :groups,
:has-many-aggr :groups_aggregate,
:has-one :user}}},
:lcn-mut-keys
{:create :createGroup,
:update :updateGroup,
:delete :deleteGroup},
:lcn-obj-keys
{:rsc :Group,
:clauses :GroupClauses,
:where :GroupWhere,
:sort :GroupSort,
:fields :GroupFields,
:aggregate :GroupAggregate,
:pks :GroupPks,
:pk-input :GroupPkColumns},
:lcn-qry-keys
{:queries :groups, :aggregate :groups_aggregate},
:lcn-descs
{:rsc "Groups",
:query "Query Groups.",
:clauses
"Format for where clauses is {column: {operator: value}}. Multiple parameters are applied with `AND` operators. `AND`/`OR` conditions can be created as a list of clauses. It is possible to nest them to create sub groups of conditions.",
:sort "Sort format is {column: \"asc\" or \"desc\"}.",
:fields "Groupsfields for aggregation.",
:aggregate "Aggrecate Groups.",
:pks "Primary key fields.",
:pk-input "Primary key fields."},
:signals
{:query {:pre (), :post ()},
:create {:pre (), :post ()},
:delete {:pre (), :post ()},
:update {:pre (), :post ()}},
:pk-keys (:id),
:col-keys
#{:description
:title
:id
:user_id
:access
:edited_at
:created_at}},
:signals
{:query {:pre (), :post ()},
:create {:pre (), :post ()},
:delete {:pre (), :post ()},
:update {:pre (), :post ()}},
:pk-keys (:id),
:col-keys #{:color :title :group_id :id}},
:lcn-obj-keys
{:rsc :Access,
:clauses :AccessClauses,
:where :AccessWhere,
:sort :AccessSort,
:fields :AccessFields,
:aggregate :AccessAggregate,
:pks :AccessPks,
:pk-input :AccessPkColumns},
:lcn-qry-keys
{:queries :accesses, :aggregate :accesses_aggregate},
:lcn-descs
{:rsc "Accesses",
:query "Query Accesses.",
:clauses
"Format for where clauses is {column: {operator: value}}. Multiple parameters are applied with `AND` operators. `AND`/`OR` conditions can be created as a list of clauses. It is possible to nest them to create sub groups of conditions.",
:sort "Sort format is {column: \"asc\" or \"desc\"}.",
:fields "Accessesfields for aggregation.",
:aggregate "Aggrecate Accesses.",
:pks "Primary key fields.",
:pk-input "Primary key fields."},
:groups
{:lcn-fields
{:rsc
{:access {:type Int},
:created_at {:type String},
:edited_at {:type String},
:id {:type Int},
:title {:type String},
:user_id {:type String},
:description {:type String}},
:clauses
{:description {:type :StrWhere},
:or {:type (list :GroupClauses)},
:title {:type :StrWhere},
:id {:type :IntWhere},
:and {:type (list :GroupClauses)},
:user_id {:type :StrWhere},
:access {:type :IntWhere},
:edited_at {:type :StrWhere},
:created_at {:type :StrWhere}},
:sort
{:access {:type :SortOperator},
:created_at {:type :SortOperator},
:edited_at {:type :SortOperator},
:id {:type :SortOperator},
:title {:type :SortOperator},
:user_id {:type :SortOperator},
:description {:type :SortOperator}},
:fields
{:access {:type Int},
:created_at {:type String},
:edited_at {:type String},
:id {:type Int},
:title {:type String},
:user_id {:type String},
:description {:type String}},
:aggregate
{:count {:type Int},
:sum {:type :GroupFields},
:avg {:type :GroupFields},
:max {:type :GroupFields},
:min {:type :GroupFields}},
:pks {:id {:type (non-null Int)}},
:pk-input {:id {:type (non-null Int)}},
:update
{:access {:type Int},
:created_at {:type String},
:edited_at {:type String},
:title {:type String},
:user_id {:type String},
:description {:type String}}},
:fks
{:access
{:field-keys
{:to :Access,
:has-many :groups,
:has-many-aggr :groups_aggregate,
:has-one :access_access}},
:user_id
{:field-keys
{:to :User,
:has-many :groups,
:has-many-aggr :groups_aggregate,
:has-one :user}}},
:lcn-mut-keys
{:create :createGroup,
:update :updateGroup,
:delete :deleteGroup},
:lcn-obj-keys
{:rsc :Group,
:clauses :GroupClauses,
:where :GroupWhere,
:sort :GroupSort,
:fields :GroupFields,
:aggregate :GroupAggregate,
:pks :GroupPks,
:pk-input :GroupPkColumns},
:lcn-qry-keys {:queries :groups, :aggregate :groups_aggregate},
:lcn-descs
{:rsc "Groups",
:query "Query Groups.",
:clauses
"Format for where clauses is {column: {operator: value}}. Multiple parameters are applied with `AND` operators. `AND`/`OR` conditions can be created as a list of clauses. It is possible to nest them to create sub groups of conditions.",
:sort "Sort format is {column: \"asc\" or \"desc\"}.",
:fields "Groupsfields for aggregation.",
:aggregate "Aggrecate Groups.",
:pks "Primary key fields.",
:pk-input "Primary key fields."},
:signals
{:query {:pre (), :post ()},
:create {:pre (), :post ()},
:delete {:pre (), :post ()},
:update {:pre (), :post ()}},
:pk-keys (:id),
:col-keys
#{:description
:title
:id
:user_id
:access
:edited_at
:created_at}},
:signals
{:query {:pre (), :post ()},
:create {:pre (), :post ()},
:delete {:pre (), :post ()},
:update {:pre (), :post ()}},
:pk-keys (:id),
:col-keys
#{:can_read
:inherit
:can_edit
:group_id
:id
:user_id
:role_id
:next_access
:owner}},
:groups
{:lcn-fields
{:rsc
{:access {:type Int},
:created_at {:type String},
:edited_at {:type String},
:id {:type Int},
:title {:type String},
:user_id {:type String},
:description {:type String}},
:clauses
{:description {:type :StrWhere},
:or {:type (list :GroupClauses)},
:title {:type :StrWhere},
:id {:type :IntWhere},
:and {:type (list :GroupClauses)},
:user_id {:type :StrWhere},
:access {:type :IntWhere},
:edited_at {:type :StrWhere},
:created_at {:type :StrWhere}},
:sort
{:access {:type :SortOperator},
:created_at {:type :SortOperator},
:edited_at {:type :SortOperator},
:id {:type :SortOperator},
:title {:type :SortOperator},
:user_id {:type :SortOperator},
:description {:type :SortOperator}},
:fields
{:access {:type Int},
:created_at {:type String},
:edited_at {:type String},
:id {:type Int},
:title {:type String},
:user_id {:type String},
:description {:type String}},
:aggregate
{:count {:type Int},
:sum {:type :GroupFields},
:avg {:type :GroupFields},
:max {:type :GroupFields},
:min {:type :GroupFields}},
:pks {:id {:type (non-null Int)}},
:pk-input {:id {:type (non-null Int)}},
:update
{:access {:type Int},
:created_at {:type String},
:edited_at {:type String},
:title {:type String},
:user_id {:type String},
:description {:type String}}},
:fks
{:access
{:field-keys
{:to :Access,
:has-many :groups,
:has-many-aggr :groups_aggregate,
:has-one :access_access}},
:user_id
{:field-keys
{:to :User,
:has-many :groups,
:has-many-aggr :groups_aggregate,
:has-one :user}}},
:lcn-mut-keys
{:create :createGroup,
:update :updateGroup,
:delete :deleteGroup},
:lcn-obj-keys
{:rsc :Group,
:clauses :GroupClauses,
:where :GroupWhere,
:sort :GroupSort,
:fields :GroupFields,
:aggregate :GroupAggregate,
:pks :GroupPks,
:pk-input :GroupPkColumns},
:lcn-qry-keys {:queries :groups, :aggregate :groups_aggregate},
:lcn-descs
{:rsc "Groups",
:query "Query Groups.",
:clauses
"Format for where clauses is {column: {operator: value}}. Multiple parameters are applied with `AND` operators. `AND`/`OR` conditions can be created as a list of clauses. It is possible to nest them to create sub groups of conditions.",
:sort "Sort format is {column: \"asc\" or \"desc\"}.",
:fields "Groupsfields for aggregation.",
:aggregate "Aggrecate Groups.",
:pks "Primary key fields.",
:pk-input "Primary key fields."},
:signals
{:query {:pre (), :post ()},
:create {:pre (), :post ()},
:delete {:pre (), :post ()},
:update {:pre (), :post ()}},
:pk-keys (:id),
:col-keys
#{:description
:title
:id
:user_id
:access
:edited_at
:created_at}},
:signals
{:query {:pre (), :post ()},
:create {:pre (), :post ()},
:delete {:pre (), :post ()},
:update {:pre (), :post ()}},
:pk-keys (:id),
:col-keys
#{:slug
:domain_pk
:title
:domain_pk_namespace
:id
:url
:access
:edited_at
:body
:created_at},
:users_in_groups
{:lcn-fields
{:rsc
{:group_id {:type Int},
:role_id {:type Int},
:user_id {:type String}},
:clauses
{:and {:type (list :UsersInGroupClauses)},
:or {:type (list :UsersInGroupClauses)},
:group_id {:type :IntWhere},
:role_id {:type :IntWhere},
:user_id {:type :StrWhere}},
:sort
{:group_id {:type :SortOperator},
:role_id {:type :SortOperator},
:user_id {:type :SortOperator}},
:fields
{:group_id {:type Int},
:role_id {:type Int},
:user_id {:type String}},
:aggregate
{:count {:type Int},
:sum {:type :UsersInGroupFields},
:avg {:type :UsersInGroupFields},
:max {:type :UsersInGroupFields},
:min {:type :UsersInGroupFields}},
:pks
{:user_id {:type (non-null String)},
:group_id {:type (non-null Int)},
:role_id {:type (non-null Int)}},
:pk-input
{:user_id {:type (non-null String)},
:group_id {:type (non-null Int)},
:role_id {:type (non-null Int)}},
:update {}},
:fks
{:user_id
{:field-keys
{:to :User,
:has-many :users_in_groups,
:has-many-aggr :users_in_groups_aggregate,
:has-one :user}},
:group_id
{:field-keys
{:to :Group,
:has-many :users_in_groups,
:has-many-aggr :users_in_groups_aggregate,
:has-one :group}},
:role_id
{:field-keys
{:to :Role,
:has-many :users_in_groups,
:has-many-aggr :users_in_groups_aggregate,
:has-one :role}}},
:lcn-mut-keys
{:create :createUsersInGroup,
:update :updateUsersInGroup,
:delete :deleteUsersInGroup},
:roles
{:lcn-fields
{:rsc
{:id {:type Int},
:group_id {:type Int},
:title {:type String},
:color {:type String}},
:clauses
{:and {:type (list :RoleClauses)},
:or {:type (list :RoleClauses)},
:id {:type :IntWhere},
:group_id {:type :IntWhere},
:title {:type :StrWhere},
:color {:type :StrWhere}},
:sort
{:id {:type :SortOperator},
:group_id {:type :SortOperator},
:title {:type :SortOperator},
:color {:type :SortOperator}},
:fields
{:id {:type Int},
:group_id {:type Int},
:title {:type String},
:color {:type String}},
:aggregate
{:count {:type Int},
:sum {:type :RoleFields},
:avg {:type :RoleFields},
:max {:type :RoleFields},
:min {:type :RoleFields}},
:pks {:id {:type (non-null Int)}},
:pk-input {:id {:type (non-null Int)}},
:update
{:group_id {:type Int},
:title {:type String},
:color {:type String}}},
:fks
{:group_id
{:field-keys
{:to :Group,
:has-many :roles,
:has-many-aggr :roles_aggregate,
:has-one :group}}},
:lcn-mut-keys
{:create :createRole,
:update :updateRole,
:delete :deleteRole},
:lcn-obj-keys
{:rsc :Role,
:clauses :RoleClauses,
:where :RoleWhere,
:sort :RoleSort,
:fields :RoleFields,
:aggregate :RoleAggregate,
:pks :RolePks,
:pk-input :RolePkColumns},
:lcn-qry-keys {:queries :roles, :aggregate :roles_aggregate},
:lcn-descs
{:rsc "Roles",
:query "Query Roles.",
:clauses
"Format for where clauses is {column: {operator: value}}. Multiple parameters are applied with `AND` operators. `AND`/`OR` conditions can be created as a list of clauses. It is possible to nest them to create sub groups of conditions.",
:sort "Sort format is {column: \"asc\" or \"desc\"}.",
:fields "Rolesfields for aggregation.",
:aggregate "Aggrecate Roles.",
:pks "Primary key fields.",
:pk-input "Primary key fields."},
:groups
{:lcn-fields
{:rsc
{:access {:type Int},
:created_at {:type String},
:edited_at {:type String},
:id {:type Int},
:title {:type String},
:user_id {:type String},
:description {:type String}},
:clauses
{:description {:type :StrWhere},
:or {:type (list :GroupClauses)},
:title {:type :StrWhere},
:id {:type :IntWhere},
:and {:type (list :GroupClauses)},
:user_id {:type :StrWhere},
:access {:type :IntWhere},
:edited_at {:type :StrWhere},
:created_at {:type :StrWhere}},
:sort
{:access {:type :SortOperator},
:created_at {:type :SortOperator},
:edited_at {:type :SortOperator},
:id {:type :SortOperator},
:title {:type :SortOperator},
:user_id {:type :SortOperator},
:description {:type :SortOperator}},
:fields
{:access {:type Int},
:created_at {:type String},
:edited_at {:type String},
:id {:type Int},
:title {:type String},
:user_id {:type String},
:description {:type String}},
:aggregate
{:count {:type Int},
:sum {:type :GroupFields},
:avg {:type :GroupFields},
:max {:type :GroupFields},
:min {:type :GroupFields}},
:pks {:id {:type (non-null Int)}},
:pk-input {:id {:type (non-null Int)}},
:update
{:access {:type Int},
:created_at {:type String},
:edited_at {:type String},
:title {:type String},
:user_id {:type String},
:description {:type String}}},
:fks
{:access
{:field-keys
{:to :Access,
:has-many :groups,
:has-many-aggr :groups_aggregate,
:has-one :access_access}},
:user_id
{:field-keys
{:to :User,
:has-many :groups,
:has-many-aggr :groups_aggregate,
:has-one :user}}},
:lcn-mut-keys
{:create :createGroup,
:update :updateGroup,
:delete :deleteGroup},
:lcn-obj-keys
{:rsc :Group,
:clauses :GroupClauses,
:where :GroupWhere,
:sort :GroupSort,
:fields :GroupFields,
:aggregate :GroupAggregate,
:pks :GroupPks,
:pk-input :GroupPkColumns},
:lcn-qry-keys
{:queries :groups, :aggregate :groups_aggregate},
:lcn-descs
{:rsc "Groups",
:query "Query Groups.",
:clauses
"Format for where clauses is {column: {operator: value}}. Multiple parameters are applied with `AND` operators. `AND`/`OR` conditions can be created as a list of clauses. It is possible to nest them to create sub groups of conditions.",
:sort "Sort format is {column: \"asc\" or \"desc\"}.",
:fields "Groupsfields for aggregation.",
:aggregate "Aggrecate Groups.",
:pks "Primary key fields.",
:pk-input "Primary key fields."},
:signals
{:query {:pre (), :post ()},
:create {:pre (), :post ()},
:delete {:pre (), :post ()},
:update {:pre (), :post ()}},
:pk-keys (:id),
:col-keys
#{:description
:title
:id
:user_id
:access
:edited_at
:created_at}},
:signals
{:query {:pre (), :post ()},
:create {:pre (), :post ()},
:delete {:pre (), :post ()},
:update {:pre (), :post ()}},
:pk-keys (:id),
:col-keys #{:color :title :group_id :id}},
:lcn-obj-keys
{:rsc :UsersInGroup,
:clauses :UsersInGroupClauses,
:where :UsersInGroupWhere,
:sort :UsersInGroupSort,
:fields :UsersInGroupFields,
:aggregate :UsersInGroupAggregate,
:pks :UsersInGroupPks,
:pk-input :UsersInGroupPkColumns},
:lcn-qry-keys
{:queries :users_in_groups,
:aggregate :users_in_groups_aggregate},
:lcn-descs
{:rsc "UsersInGroups",
:query "Query UsersInGroups.",
:clauses
"Format for where clauses is {column: {operator: value}}. Multiple parameters are applied with `AND` operators. `AND`/`OR` conditions can be created as a list of clauses. It is possible to nest them to create sub groups of conditions.",
:sort "Sort format is {column: \"asc\" or \"desc\"}.",
:fields "UsersInGroupsfields for aggregation.",
:aggregate "Aggrecate UsersInGroups.",
:pks "Primary key fields.",
:pk-input "Primary key fields."},
:access
{:lcn-fields
{:rsc
{:can_read {:type Boolean},
:inherit {:type Boolean},
:can_edit {:type Boolean},
:group_id {:type Int},
:id {:type Int},
:user_id {:type String},
:role_id {:type Int},
:next_access {:type Int},
:owner {:type Boolean}},
:clauses
{:can_read {:type :BoolWhere},
:inherit {:type :BoolWhere},
:can_edit {:type :BoolWhere},
:or {:type (list :AccessClauses)},
:group_id {:type :IntWhere},
:id {:type :IntWhere},
:and {:type (list :AccessClauses)},
:user_id {:type :StrWhere},
:role_id {:type :IntWhere},
:next_access {:type :IntWhere},
:owner {:type :BoolWhere}},
:sort
{:can_read {:type :SortOperator},
:inherit {:type :SortOperator},
:can_edit {:type :SortOperator},
:group_id {:type :SortOperator},
:id {:type :SortOperator},
:user_id {:type :SortOperator},
:role_id {:type :SortOperator},
:next_access {:type :SortOperator},
:owner {:type :SortOperator}},
:fields
{:can_read {:type Boolean},
:inherit {:type Boolean},
:can_edit {:type Boolean},
:group_id {:type Int},
:id {:type Int},
:user_id {:type String},
:role_id {:type Int},
:next_access {:type Int},
:owner {:type Boolean}},
:aggregate
{:count {:type Int},
:sum {:type :AccessFields},
:avg {:type :AccessFields},
:max {:type :AccessFields},
:min {:type :AccessFields}},
:pks {:id {:type (non-null Int)}},
:pk-input {:id {:type (non-null Int)}},
:update
{:can_read {:type Boolean},
:inherit {:type Boolean},
:can_edit {:type Boolean},
:group_id {:type Int},
:user_id {:type String},
:role_id {:type Int},
:next_access {:type Int},
:owner {:type Boolean}}},
:fks
{:next_access
{:field-keys
{:to :Access,
:has-many :accesses,
:has-many-aggr :accesses_aggregate,
:has-one :next_access_access}},
:role_id
{:field-keys
{:to :Role,
:has-many :accesses,
:has-many-aggr :accesses_aggregate,
:has-one :role}},
:user_id
{:field-keys
{:to :User,
:has-many :accesses,
:has-many-aggr :accesses_aggregate,
:has-one :user}},
:group_id
{:field-keys
{:to :Group,
:has-many :accesses,
:has-many-aggr :accesses_aggregate,
:has-one :group}}},
:lcn-mut-keys
{:create :createAccess,
:update :updateAccess,
:delete :deleteAccess},
:roles
{:lcn-fields
{:rsc
{:id {:type Int},
:group_id {:type Int},
:title {:type String},
:color {:type String}},
:clauses
{:and {:type (list :RoleClauses)},
:or {:type (list :RoleClauses)},
:id {:type :IntWhere},
:group_id {:type :IntWhere},
:title {:type :StrWhere},
:color {:type :StrWhere}},
:sort
{:id {:type :SortOperator},
:group_id {:type :SortOperator},
:title {:type :SortOperator},
:color {:type :SortOperator}},
:fields
{:id {:type Int},
:group_id {:type Int},
:title {:type String},
:color {:type String}},
:aggregate
{:count {:type Int},
:sum {:type :RoleFields},
:avg {:type :RoleFields},
:max {:type :RoleFields},
:min {:type :RoleFields}},
:pks {:id {:type (non-null Int)}},
:pk-input {:id {:type (non-null Int)}},
:update
{:group_id {:type Int},
:title {:type String},
:color {:type String}}},
:fks
{:group_id
{:field-keys
{:to :Group,
:has-many :roles,
:has-many-aggr :roles_aggregate,
:has-one :group}}},
:lcn-mut-keys
{:create :createRole,
:update :updateRole,
:delete :deleteRole},
:lcn-obj-keys
{:rsc :Role,
:clauses :RoleClauses,
:where :RoleWhere,
:sort :RoleSort,
:fields :RoleFields,
:aggregate :RoleAggregate,
:pks :RolePks,
:pk-input :RolePkColumns},
:lcn-qry-keys {:queries :roles, :aggregate :roles_aggregate},
:lcn-descs
{:rsc "Roles",
:query "Query Roles.",
:clauses
"Format for where clauses is {column: {operator: value}}. Multiple parameters are applied with `AND` operators. `AND`/`OR` conditions can be created as a list of clauses. It is possible to nest them to create sub groups of conditions.",
:sort "Sort format is {column: \"asc\" or \"desc\"}.",
:fields "Rolesfields for aggregation.",
:aggregate "Aggrecate Roles.",
:pks "Primary key fields.",
:pk-input "Primary key fields."},
:groups
{:lcn-fields
{:rsc
{:access {:type Int},
:created_at {:type String},
:edited_at {:type String},
:id {:type Int},
:title {:type String},
:user_id {:type String},
:description {:type String}},
:clauses
{:description {:type :StrWhere},
:or {:type (list :GroupClauses)},
:title {:type :StrWhere},
:id {:type :IntWhere},
:and {:type (list :GroupClauses)},
:user_id {:type :StrWhere},
:access {:type :IntWhere},
:edited_at {:type :StrWhere},
:created_at {:type :StrWhere}},
:sort
{:access {:type :SortOperator},
:created_at {:type :SortOperator},
:edited_at {:type :SortOperator},
:id {:type :SortOperator},
:title {:type :SortOperator},
:user_id {:type :SortOperator},
:description {:type :SortOperator}},
:fields
{:access {:type Int},
:created_at {:type String},
:edited_at {:type String},
:id {:type Int},
:title {:type String},
:user_id {:type String},
:description {:type String}},
:aggregate
{:count {:type Int},
:sum {:type :GroupFields},
:avg {:type :GroupFields},
:max {:type :GroupFields},
:min {:type :GroupFields}},
:pks {:id {:type (non-null Int)}},
:pk-input {:id {:type (non-null Int)}},
:update
{:access {:type Int},
:created_at {:type String},
:edited_at {:type String},
:title {:type String},
:user_id {:type String},
:description {:type String}}},
:fks
{:access
{:field-keys
{:to :Access,
:has-many :groups,
:has-many-aggr :groups_aggregate,
:has-one :access_access}},
:user_id
{:field-keys
{:to :User,
:has-many :groups,
:has-many-aggr :groups_aggregate,
:has-one :user}}},
:lcn-mut-keys
{:create :createGroup,
:update :updateGroup,
:delete :deleteGroup},
:lcn-obj-keys
{:rsc :Group,
:clauses :GroupClauses,
:where :GroupWhere,
:sort :GroupSort,
:fields :GroupFields,
:aggregate :GroupAggregate,
:pks :GroupPks,
:pk-input :GroupPkColumns},
:lcn-qry-keys
{:queries :groups, :aggregate :groups_aggregate},
:lcn-descs
{:rsc "Groups",
:query "Query Groups.",
:clauses
"Format for where clauses is {column: {operator: value}}. Multiple parameters are applied with `AND` operators. `AND`/`OR` conditions can be created as a list of clauses. It is possible to nest them to create sub groups of conditions.",
:sort "Sort format is {column: \"asc\" or \"desc\"}.",
:fields "Groupsfields for aggregation.",
:aggregate "Aggrecate Groups.",
:pks "Primary key fields.",
:pk-input "Primary key fields."},
:signals
{:query {:pre (), :post ()},
:create {:pre (), :post ()},
:delete {:pre (), :post ()},
:update {:pre (), :post ()}},
:pk-keys (:id),
:col-keys
#{:description
:title
:id
:user_id
:access
:edited_at
:created_at}},
:signals
{:query {:pre (), :post ()},
:create {:pre (), :post ()},
:delete {:pre (), :post ()},
:update {:pre (), :post ()}},
:pk-keys (:id),
:col-keys #{:color :title :group_id :id}},
:lcn-obj-keys
{:rsc :Access,
:clauses :AccessClauses,
:where :AccessWhere,
:sort :AccessSort,
:fields :AccessFields,
:aggregate :AccessAggregate,
:pks :AccessPks,
:pk-input :AccessPkColumns},
:lcn-qry-keys
{:queries :accesses, :aggregate :accesses_aggregate},
:lcn-descs
{:rsc "Accesses",
:query "Query Accesses.",
:clauses
"Format for where clauses is {column: {operator: value}}. Multiple parameters are applied with `AND` operators. `AND`/`OR` conditions can be created as a list of clauses. It is possible to nest them to create sub groups of conditions.",
:sort "Sort format is {column: \"asc\" or \"desc\"}.",
:fields "Accessesfields for aggregation.",
:aggregate "Aggrecate Accesses.",
:pks "Primary key fields.",
:pk-input "Primary key fields."},
:groups
{:lcn-fields
{:rsc
{:access {:type Int},
:created_at {:type String},
:edited_at {:type String},
:id {:type Int},
:title {:type String},
:user_id {:type String},
:description {:type String}},
:clauses
{:description {:type :StrWhere},
:or {:type (list :GroupClauses)},
:title {:type :StrWhere},
:id {:type :IntWhere},
:and {:type (list :GroupClauses)},
:user_id {:type :StrWhere},
:access {:type :IntWhere},
:edited_at {:type :StrWhere},
:created_at {:type :StrWhere}},
:sort
{:access {:type :SortOperator},
:created_at {:type :SortOperator},
:edited_at {:type :SortOperator},
:id {:type :SortOperator},
:title {:type :SortOperator},
:user_id {:type :SortOperator},
:description {:type :SortOperator}},
:fields
{:access {:type Int},
:created_at {:type String},
:edited_at {:type String},
:id {:type Int},
:title {:type String},
:user_id {:type String},
:description {:type String}},
:aggregate
{:count {:type Int},
:sum {:type :GroupFields},
:avg {:type :GroupFields},
:max {:type :GroupFields},
:min {:type :GroupFields}},
:pks {:id {:type (non-null Int)}},
:pk-input {:id {:type (non-null Int)}},
:update
{:access {:type Int},
:created_at {:type String},
:edited_at {:type String},
:title {:type String},
:user_id {:type String},
:description {:type String}}},
:fks
{:access
{:field-keys
{:to :Access,
:has-many :groups,
:has-many-aggr :groups_aggregate,
:has-one :access_access}},
:user_id
{:field-keys
{:to :User,
:has-many :groups,
:has-many-aggr :groups_aggregate,
:has-one :user}}},
:lcn-mut-keys
{:create :createGroup,
:update :updateGroup,
:delete :deleteGroup},
:lcn-obj-keys
{:rsc :Group,
:clauses :GroupClauses,
:where :GroupWhere,
:sort :GroupSort,
:fields :GroupFields,
:aggregate :GroupAggregate,
:pks :GroupPks,
:pk-input :GroupPkColumns},
:lcn-qry-keys
{:queries :groups, :aggregate :groups_aggregate},
:lcn-descs
{:rsc "Groups",
:query "Query Groups.",
:clauses
"Format for where clauses is {column: {operator: value}}. Multiple parameters are applied with `AND` operators. `AND`/`OR` conditions can be created as a list of clauses. It is possible to nest them to create sub groups of conditions.",
:sort "Sort format is {column: \"asc\" or \"desc\"}.",
:fields "Groupsfields for aggregation.",
:aggregate "Aggrecate Groups.",
:pks "Primary key fields.",
:pk-input "Primary key fields."},
:signals
{:query {:pre (), :post ()},
:create {:pre (), :post ()},
:delete {:pre (), :post ()},
:update {:pre (), :post ()}},
:pk-keys (:id),
:col-keys
#{:description
:title
:id
:user_id
:access
:edited_at
:created_at}},
:signals
{:query {:pre (), :post ()},
:create {:pre (), :post ()},
:delete {:pre (), :post ()},
:update {:pre (), :post ()}},
:pk-keys (:id),
:col-keys
#{:can_read
:inherit
:can_edit
:group_id
:id
:user_id
:role_id
:next_access
:owner}},
:groups
{:lcn-fields
{:rsc
{:access {:type Int},
:created_at {:type String},
:edited_at {:type String},
:id {:type Int},
:title {:type String},
:user_id {:type String},
:description {:type String}},
:clauses
{:description {:type :StrWhere},
:or {:type (list :GroupClauses)},
:title {:type :StrWhere},
:id {:type :IntWhere},
:and {:type (list :GroupClauses)},
:user_id {:type :StrWhere},
:access {:type :IntWhere},
:edited_at {:type :StrWhere},
:created_at {:type :StrWhere}},
:sort
{:access {:type :SortOperator},
:created_at {:type :SortOperator},
:edited_at {:type :SortOperator},
:id {:type :SortOperator},
:title {:type :SortOperator},
:user_id {:type :SortOperator},
:description {:type :SortOperator}},
:fields
{:access {:type Int},
:created_at {:type String},
:edited_at {:type String},
:id {:type Int},
:title {:type String},
:user_id {:type String},
:description {:type String}},
:aggregate
{:count {:type Int},
:sum {:type :GroupFields},
:avg {:type :GroupFields},
:max {:type :GroupFields},
:min {:type :GroupFields}},
:pks {:id {:type (non-null Int)}},
:pk-input {:id {:type (non-null Int)}},
:update
{:access {:type Int},
:created_at {:type String},
:edited_at {:type String},
:title {:type String},
:user_id {:type String},
:description {:type String}}},
:fks
{:access
{:field-keys
{:to :Access,
:has-many :groups,
:has-many-aggr :groups_aggregate,
:has-one :access_access}},
:user_id
{:field-keys
{:to :User,
:has-many :groups,
:has-many-aggr :groups_aggregate,
:has-one :user}}},
:lcn-mut-keys
{:create :createGroup,
:update :updateGroup,
:delete :deleteGroup},
:lcn-obj-keys
{:rsc :Group,
:clauses :GroupClauses,
:where :GroupWhere,
:sort :GroupSort,
:fields :GroupFields,
:aggregate :GroupAggregate,
:pks :GroupPks,
:pk-input :GroupPkColumns},
:lcn-qry-keys {:queries :groups, :aggregate :groups_aggregate},
:lcn-descs
{:rsc "Groups",
:query "Query Groups.",
:clauses
"Format for where clauses is {column: {operator: value}}. Multiple parameters are applied with `AND` operators. `AND`/`OR` conditions can be created as a list of clauses. It is possible to nest them to create sub groups of conditions.",
:sort "Sort format is {column: \"asc\" or \"desc\"}.",
:fields "Groupsfields for aggregation.",
:aggregate "Aggrecate Groups.",
:pks "Primary key fields.",
:pk-input "Primary key fields."},
:signals
{:query {:pre (), :post ()},
:create {:pre (), :post ()},
:delete {:pre (), :post ()},
:update {:pre (), :post ()}},
:pk-keys (:id),
:col-keys
#{:description
:title
:id
:user_id
:access
:edited_at
:created_at}},
:signals
{:query {:pre (), :post ()},
:create {:pre (), :post ()},
:delete {:pre (), :post ()},
:update {:pre (), :post ()}},
:pk-keys (:user_id :group_id :role_id),
:col-keys #{:group_id :user_id :role_id}}},
:attributes
{:lcn-fields
{:rsc
{:attribute_name {:type nil},
:description {:type String},
:udt_schema {:type nil},
:collation_schema {:type nil},
:numeric_scale {:type Int},
:character_set_schema {:type nil},
:dtd_identifier {:type nil},
:maximum_cardinality {:type Int},
:is_derived_reference_attribute {:type String},
:character_octet_length {:type Int},
:datetime_precision {:type Int},
:scope_catalog {:type nil},
:collation_catalog {:type nil},
:character_maximum_length {:type Int},
:is_nullable {:type String},
:character_set_catalog {:type nil},
:numeric_precision {:type Int},
:interval_type {:type String},
:udt_catalog {:type nil},
:title {:type String},
:scope_schema {:type nil},
:attribute_default {:type String},
:numeric_precision_radix {:type Int},
:interval_precision {:type Int},
:character_set_name {:type nil},
:attribute_udt_catalog {:type nil},
:id {:type Int},
:collation_name {:type nil},
:data_type {:type String},
:attribute_udt_schema {:type nil},
:access {:type Int},
:edited_at {:type String},
:scope_name {:type nil},
:udt_name {:type nil},
:created_at {:type String},
:ordinal_position {:type Int},
:attribute_udt_name {:type nil}},
:clauses
{:attribute_name {:type nil},
:description {:type :StrWhere},
:udt_schema {:type nil},
:collation_schema {:type nil},
:numeric_scale {:type :IntWhere},
:character_set_schema {:type nil},
:dtd_identifier {:type nil},
:maximum_cardinality {:type :IntWhere},
:is_derived_reference_attribute {:type :StrWhere},
:character_octet_length {:type :IntWhere},
:datetime_precision {:type :IntWhere},
:or {:type (list :AttributeClauses)},
:scope_catalog {:type nil},
:collation_catalog {:type nil},
:character_maximum_length {:type :IntWhere},
:is_nullable {:type :StrWhere},
:character_set_catalog {:type nil},
:numeric_precision {:type :IntWhere},
:interval_type {:type :StrWhere},
:udt_catalog {:type nil},
:title {:type :StrWhere},
:scope_schema {:type nil},
:attribute_default {:type :StrWhere},
:numeric_precision_radix {:type :IntWhere},
:interval_precision {:type :IntWhere},
:character_set_name {:type nil},
:attribute_udt_catalog {:type nil},
:id {:type :IntWhere},
:collation_name {:type nil},
:data_type {:type :StrWhere},
:attribute_udt_schema {:type nil},
:and {:type (list :AttributeClauses)},
:access {:type :IntWhere},
:edited_at {:type :StrWhere},
:scope_name {:type nil},
:udt_name {:type nil},
:created_at {:type :StrWhere},
:ordinal_position {:type :IntWhere},
:attribute_udt_name {:type nil}},
:sort
{:attribute_name {:type :SortOperator},
:description {:type :SortOperator},
:udt_schema {:type :SortOperator},
:collation_schema {:type :SortOperator},
:numeric_scale {:type :SortOperator},
:character_set_schema {:type :SortOperator},
:dtd_identifier {:type :SortOperator},
:maximum_cardinality {:type :SortOperator},
:is_derived_reference_attribute {:type :SortOperator},
:character_octet_length {:type :SortOperator},
:datetime_precision {:type :SortOperator},
:scope_catalog {:type :SortOperator},
:collation_catalog {:type :SortOperator},
:character_maximum_length {:type :SortOperator},
:is_nullable {:type :SortOperator},
:character_set_catalog {:type :SortOperator},
:numeric_precision {:type :SortOperator},
:interval_type {:type :SortOperator},
:udt_catalog {:type :SortOperator},
:title {:type :SortOperator},
:scope_schema {:type :SortOperator},
:attribute_default {:type :SortOperator},
:numeric_precision_radix {:type :SortOperator},
:interval_precision {:type :SortOperator},
:character_set_name {:type :SortOperator},
:attribute_udt_catalog {:type :SortOperator},
:id {:type :SortOperator},
:collation_name {:type :SortOperator},
:data_type {:type :SortOperator},
:attribute_udt_schema {:type :SortOperator},
:access {:type :SortOperator},
:edited_at {:type :SortOperator},
:scope_name {:type :SortOperator},
:udt_name {:type :SortOperator},
:created_at {:type :SortOperator},
:ordinal_position {:type :SortOperator},
:attribute_udt_name {:type :SortOperator}},
:fields
{:attribute_name {:type nil},
:description {:type String},
:udt_schema {:type nil},
:collation_schema {:type nil},
:numeric_scale {:type Int},
:character_set_schema {:type nil},
:dtd_identifier {:type nil},
:maximum_cardinality {:type Int},
:is_derived_reference_attribute {:type String},
:character_octet_length {:type Int},
:datetime_precision {:type Int},
:scope_catalog {:type nil},
:collation_catalog {:type nil},
:character_maximum_length {:type Int},
:is_nullable {:type String},
:character_set_catalog {:type nil},
:numeric_precision {:type Int},
:interval_type {:type String},
:udt_catalog {:type nil},
:title {:type String},
:scope_schema {:type nil},
:attribute_default {:type String},
:numeric_precision_radix {:type Int},
:interval_precision {:type Int},
:character_set_name {:type nil},
:attribute_udt_catalog {:type nil},
:id {:type Int},
:collation_name {:type nil},
:data_type {:type String},
:attribute_udt_schema {:type nil},
:access {:type Int},
:edited_at {:type String},
:scope_name {:type nil},
:udt_name {:type nil},
:created_at {:type String},
:ordinal_position {:type Int},
:attribute_udt_name {:type nil}},
:aggregate
{:count {:type Int},
:sum {:type :AttributeFields},
:avg {:type :AttributeFields},
:max {:type :AttributeFields},
:min {:type :AttributeFields}},
:pks {:id {:type (non-null Int)}},
:pk-input {:id {:type (non-null Int)}},
:update
{:attribute_name {:type nil},
:description {:type String},
:udt_schema {:type nil},
:collation_schema {:type nil},
:numeric_scale {:type Int},
:character_set_schema {:type nil},
:dtd_identifier {:type nil},
:maximum_cardinality {:type Int},
:is_derived_reference_attribute {:type String},
:character_octet_length {:type Int},
:datetime_precision {:type Int},
:scope_catalog {:type nil},
:collation_catalog {:type nil},
:character_maximum_length {:type Int},
:is_nullable {:type String},
:character_set_catalog {:type nil},
:numeric_precision {:type Int},
:interval_type {:type String},
:udt_catalog {:type nil},
:title {:type String},
:scope_schema {:type nil},
:attribute_default {:type String},
:numeric_precision_radix {:type Int},
:interval_precision {:type Int},
:character_set_name {:type nil},
:attribute_udt_catalog {:type nil},
:collation_name {:type nil},
:data_type {:type String},
:attribute_udt_schema {:type nil},
:access {:type Int},
:edited_at {:type String},
:scope_name {:type nil},
:udt_name {:type nil},
:created_at {:type String},
:ordinal_position {:type Int},
:attribute_udt_name {:type nil}}},
:fks
{:access
{:field-keys
{:to :Access,
:has-many :attributes,
:has-many-aggr :attributes_aggregate,
:has-one :access_access}}},
:lcn-mut-keys
{:create :createAttribute,
:update :updateAttribute,
:delete :deleteAttribute},
:roles
{:lcn-fields
{:rsc
{:id {:type Int},
:group_id {:type Int},
:title {:type String},
:color {:type String}},
:clauses
{:and {:type (list :RoleClauses)},
:or {:type (list :RoleClauses)},
:id {:type :IntWhere},
:group_id {:type :IntWhere},
:title {:type :StrWhere},
:color {:type :StrWhere}},
:sort
{:id {:type :SortOperator},
:group_id {:type :SortOperator},
:title {:type :SortOperator},
:color {:type :SortOperator}},
:fields
{:id {:type Int},
:group_id {:type Int},
:title {:type String},
:color {:type String}},
:aggregate
{:count {:type Int},
:sum {:type :RoleFields},
:avg {:type :RoleFields},
:max {:type :RoleFields},
:min {:type :RoleFields}},
:pks {:id {:type (non-null Int)}},
:pk-input {:id {:type (non-null Int)}},
:update
{:group_id {:type Int},
:title {:type String},
:color {:type String}}},
:fks
{:group_id
{:field-keys
{:to :Group,
:has-many :roles,
:has-many-aggr :roles_aggregate,
:has-one :group}}},
:lcn-mut-keys
{:create :createRole, :update :updateRole, :delete :deleteRole},
:lcn-obj-keys
{:rsc :Role,
:clauses :RoleClauses,
:where :RoleWhere,
:sort :RoleSort,
:fields :RoleFields,
:aggregate :RoleAggregate,
:pks :RolePks,
:pk-input :RolePkColumns},
:lcn-qry-keys {:queries :roles, :aggregate :roles_aggregate},
:lcn-descs
{:rsc "Roles",
:query "Query Roles.",
:clauses
"Format for where clauses is {column: {operator: value}}. Multiple parameters are applied with `AND` operators. `AND`/`OR` conditions can be created as a list of clauses. It is possible to nest them to create sub groups of conditions.",
:sort "Sort format is {column: \"asc\" or \"desc\"}.",
:fields "Rolesfields for aggregation.",
:aggregate "Aggrecate Roles.",
:pks "Primary key fields.",
:pk-input "Primary key fields."},
:groups
{:lcn-fields
{:rsc
{:access {:type Int},
:created_at {:type String},
:edited_at {:type String},
:id {:type Int},
:title {:type String},
:user_id {:type String},
:description {:type String}},
:clauses
{:description {:type :StrWhere},
:or {:type (list :GroupClauses)},
:title {:type :StrWhere},
:id {:type :IntWhere},
:and {:type (list :GroupClauses)},
:user_id {:type :StrWhere},
:access {:type :IntWhere},
:edited_at {:type :StrWhere},
:created_at {:type :StrWhere}},
:sort
{:access {:type :SortOperator},
:created_at {:type :SortOperator},
:edited_at {:type :SortOperator},
:id {:type :SortOperator},
:title {:type :SortOperator},
:user_id {:type :SortOperator},
:description {:type :SortOperator}},
:fields
{:access {:type Int},
:created_at {:type String},
:edited_at {:type String},
:id {:type Int},
:title {:type String},
:user_id {:type String},
:description {:type String}},
:aggregate
{:count {:type Int},
:sum {:type :GroupFields},
:avg {:type :GroupFields},
:max {:type :GroupFields},
:min {:type :GroupFields}},
:pks {:id {:type (non-null Int)}},
:pk-input {:id {:type (non-null Int)}},
:update
{:access {:type Int},
:created_at {:type String},
:edited_at {:type String},
:title {:type String},
:user_id {:type String},
:description {:type String}}},
:fks
{:access
{:field-keys
{:to :Access,
:has-many :groups,
:has-many-aggr :groups_aggregate,
:has-one :access_access}},
:user_id
{:field-keys
{:to :User,
:has-many :groups,
:has-many-aggr :groups_aggregate,
:has-one :user}}},
:lcn-mut-keys
{:create :createGroup,
:update :updateGroup,
:delete :deleteGroup},
:lcn-obj-keys
{:rsc :Group,
:clauses :GroupClauses,
:where :GroupWhere,
:sort :GroupSort,
:fields :GroupFields,
:aggregate :GroupAggregate,
:pks :GroupPks,
:pk-input :GroupPkColumns},
:lcn-qry-keys {:queries :groups, :aggregate :groups_aggregate},
:lcn-descs
{:rsc "Groups",
:query "Query Groups.",
:clauses
"Format for where clauses is {column: {operator: value}}. Multiple parameters are applied with `AND` operators. `AND`/`OR` conditions can be created as a list of clauses. It is possible to nest them to create sub groups of conditions.",
:sort "Sort format is {column: \"asc\" or \"desc\"}.",
:fields "Groupsfields for aggregation.",
:aggregate "Aggrecate Groups.",
:pks "Primary key fields.",
:pk-input "Primary key fields."},
:signals
{:query {:pre (), :post ()},
:create {:pre (), :post ()},
:delete {:pre (), :post ()},
:update {:pre (), :post ()}},
:pk-keys (:id),
:col-keys
#{:description
:title
:id
:user_id
:access
:edited_at
:created_at}},
:signals
{:query {:pre (), :post ()},
:create {:pre (), :post ()},
:delete {:pre (), :post ()},
:update {:pre (), :post ()}},
:pk-keys (:id),
:col-keys #{:color :title :group_id :id}},
:lcn-obj-keys
{:rsc :Attribute,
:clauses :AttributeClauses,
:where :AttributeWhere,
:sort :AttributeSort,
:fields :AttributeFields,
:aggregate :AttributeAggregate,
:pks :AttributePks,
:pk-input :AttributePkColumns},
:lcn-qry-keys
{:queries :attributes, :aggregate :attributes_aggregate},
:lcn-descs
{:rsc "Attributes",
:query "Query Attributes.",
:clauses
"Format for where clauses is {column: {operator: value}}. Multiple parameters are applied with `AND` operators. `AND`/`OR` conditions can be created as a list of clauses. It is possible to nest them to create sub groups of conditions.",
:sort "Sort format is {column: \"asc\" or \"desc\"}.",
:fields "Attributesfields for aggregation.",
:aggregate "Aggrecate Attributes.",
:pks "Primary key fields.",
:pk-input "Primary key fields."},
:access
{:lcn-fields
{:rsc
{:can_read {:type Boolean},
:inherit {:type Boolean},
:can_edit {:type Boolean},
:group_id {:type Int},
:id {:type Int},
:user_id {:type String},
:role_id {:type Int},
:next_access {:type Int},
:owner {:type Boolean}},
:clauses
{:can_read {:type :BoolWhere},
:inherit {:type :BoolWhere},
:can_edit {:type :BoolWhere},
:or {:type (list :AccessClauses)},
:group_id {:type :IntWhere},
:id {:type :IntWhere},
:and {:type (list :AccessClauses)},
:user_id {:type :StrWhere},
:role_id {:type :IntWhere},
:next_access {:type :IntWhere},
:owner {:type :BoolWhere}},
:sort
{:can_read {:type :SortOperator},
:inherit {:type :SortOperator},
:can_edit {:type :SortOperator},
:group_id {:type :SortOperator},
:id {:type :SortOperator},
:user_id {:type :SortOperator},
:role_id {:type :SortOperator},
:next_access {:type :SortOperator},
:owner {:type :SortOperator}},
:fields
{:can_read {:type Boolean},
:inherit {:type Boolean},
:can_edit {:type Boolean},
:group_id {:type Int},
:id {:type Int},
:user_id {:type String},
:role_id {:type Int},
:next_access {:type Int},
:owner {:type Boolean}},
:aggregate
{:count {:type Int},
:sum {:type :AccessFields},
:avg {:type :AccessFields},
:max {:type :AccessFields},
:min {:type :AccessFields}},
:pks {:id {:type (non-null Int)}},
:pk-input {:id {:type (non-null Int)}},
:update
{:can_read {:type Boolean},
:inherit {:type Boolean},
:can_edit {:type Boolean},
:group_id {:type Int},
:user_id {:type String},
:role_id {:type Int},
:next_access {:type Int},
:owner {:type Boolean}}},
:fks
{:next_access
{:field-keys
{:to :Access,
:has-many :accesses,
:has-many-aggr :accesses_aggregate,
:has-one :next_access_access}},
:role_id
{:field-keys
{:to :Role,
:has-many :accesses,
:has-many-aggr :accesses_aggregate,
:has-one :role}},
:user_id
{:field-keys
{:to :User,
:has-many :accesses,
:has-many-aggr :accesses_aggregate,
:has-one :user}},
:group_id
{:field-keys
{:to :Group,
:has-many :accesses,
:has-many-aggr :accesses_aggregate,
:has-one :group}}},
:lcn-mut-keys
{:create :createAccess,
:update :updateAccess,
:delete :deleteAccess},
:roles
{:lcn-fields
{:rsc
{:id {:type Int},
:group_id {:type Int},
:title {:type String},
:color {:type String}},
:clauses
{:and {:type (list :RoleClauses)},
:or {:type (list :RoleClauses)},
:id {:type :IntWhere},
:group_id {:type :IntWhere},
:title {:type :StrWhere},
:color {:type :StrWhere}},
:sort
{:id {:type :SortOperator},
:group_id {:type :SortOperator},
:title {:type :SortOperator},
:color {:type :SortOperator}},
:fields
{:id {:type Int},
:group_id {:type Int},
:title {:type String},
:color {:type String}},
:aggregate
{:count {:type Int},
:sum {:type :RoleFields},
:avg {:type :RoleFields},
:max {:type :RoleFields},
:min {:type :RoleFields}},
:pks {:id {:type (non-null Int)}},
:pk-input {:id {:type (non-null Int)}},
:update
{:group_id {:type Int},
:title {:type String},
:color {:type String}}},
:fks
{:group_id
{:field-keys
{:to :Group,
:has-many :roles,
:has-many-aggr :roles_aggregate,
:has-one :group}}},
:lcn-mut-keys
{:create :createRole,
:update :updateRole,
:delete :deleteRole},
:lcn-obj-keys
{:rsc :Role,
:clauses :RoleClauses,
:where :RoleWhere,
:sort :RoleSort,
:fields :RoleFields,
:aggregate :RoleAggregate,
:pks :RolePks,
:pk-input :RolePkColumns},
:lcn-qry-keys {:queries :roles, :aggregate :roles_aggregate},
:lcn-descs
{:rsc "Roles",
:query "Query Roles.",
:clauses
"Format for where clauses is {column: {operator: value}}. Multiple parameters are applied with `AND` operators. `AND`/`OR` conditions can be created as a list of clauses. It is possible to nest them to create sub groups of conditions.",
:sort "Sort format is {column: \"asc\" or \"desc\"}.",
:fields "Rolesfields for aggregation.",
:aggregate "Aggrecate Roles.",
:pks "Primary key fields.",
:pk-input "Primary key fields."},
:groups
{:lcn-fields
{:rsc
{:access {:type Int},
:created_at {:type String},
:edited_at {:type String},
:id {:type Int},
:title {:type String},
:user_id {:type String},
:description {:type String}},
:clauses
{:description {:type :StrWhere},
:or {:type (list :GroupClauses)},
:title {:type :StrWhere},
:id {:type :IntWhere},
:and {:type (list :GroupClauses)},
:user_id {:type :StrWhere},
:access {:type :IntWhere},
:edited_at {:type :StrWhere},
:created_at {:type :StrWhere}},
:sort
{:access {:type :SortOperator},
:created_at {:type :SortOperator},
:edited_at {:type :SortOperator},
:id {:type :SortOperator},
:title {:type :SortOperator},
:user_id {:type :SortOperator},
:description {:type :SortOperator}},
:fields
{:access {:type Int},
:created_at {:type String},
:edited_at {:type String},
:id {:type Int},
:title {:type String},
:user_id {:type String},
:description {:type String}},
:aggregate
{:count {:type Int},
:sum {:type :GroupFields},
:avg {:type :GroupFields},
:max {:type :GroupFields},
:min {:type :GroupFields}},
:pks {:id {:type (non-null Int)}},
:pk-input {:id {:type (non-null Int)}},
:update
{:access {:type Int},
:created_at {:type String},
:edited_at {:type String},
:title {:type String},
:user_id {:type String},
:description {:type String}}},
:fks
{:access
{:field-keys
{:to :Access,
:has-many :groups,
:has-many-aggr :groups_aggregate,
:has-one :access_access}},
:user_id
{:field-keys
{:to :User,
:has-many :groups,
:has-many-aggr :groups_aggregate,
:has-one :user}}},
:lcn-mut-keys
{:create :createGroup,
:update :updateGroup,
:delete :deleteGroup},
:lcn-obj-keys
{:rsc :Group,
:clauses :GroupClauses,
:where :GroupWhere,
:sort :GroupSort,
:fields :GroupFields,
:aggregate :GroupAggregate,
:pks :GroupPks,
:pk-input :GroupPkColumns},
:lcn-qry-keys
{:queries :groups, :aggregate :groups_aggregate},
:lcn-descs
{:rsc "Groups",
:query "Query Groups.",
:clauses
"Format for where clauses is {column: {operator: value}}. Multiple parameters are applied with `AND` operators. `AND`/`OR` conditions can be created as a list of clauses. It is possible to nest them to create sub groups of conditions.",
:sort "Sort format is {column: \"asc\" or \"desc\"}.",
:fields "Groupsfields for aggregation.",
:aggregate "Aggrecate Groups.",
:pks "Primary key fields.",
:pk-input "Primary key fields."},
:signals
{:query {:pre (), :post ()},
:create {:pre (), :post ()},
:delete {:pre (), :post ()},
:update {:pre (), :post ()}},
:pk-keys (:id),
:col-keys
#{:description
:title
:id
:user_id
:access
:edited_at
:created_at}},
:signals
{:query {:pre (), :post ()},
:create {:pre (), :post ()},
:delete {:pre (), :post ()},
:update {:pre (), :post ()}},
:pk-keys (:id),
:col-keys #{:color :title :group_id :id}},
:lcn-obj-keys
{:rsc :Access,
:clauses :AccessClauses,
:where :AccessWhere,
:sort :AccessSort,
:fields :AccessFields,
:aggregate :AccessAggregate,
:pks :AccessPks,
:pk-input :AccessPkColumns},
:lcn-qry-keys
{:queries :accesses, :aggregate :accesses_aggregate},
:lcn-descs
{:rsc "Accesses",
:query "Query Accesses.",
:clauses
"Format for where clauses is {column: {operator: value}}. Multiple parameters are applied with `AND` operators. `AND`/`OR` conditions can be created as a list of clauses. It is possible to nest them to create sub groups of conditions.",
:sort "Sort format is {column: \"asc\" or \"desc\"}.",
:fields "Accessesfields for aggregation.",
:aggregate "Aggrecate Accesses.",
:pks "Primary key fields.",
:pk-input "Primary key fields."},
:groups
{:lcn-fields
{:rsc
{:access {:type Int},
:created_at {:type String},
:edited_at {:type String},
:id {:type Int},
:title {:type String},
:user_id {:type String},
:description {:type String}},
:clauses
{:description {:type :StrWhere},
:or {:type (list :GroupClauses)},
:title {:type :StrWhere},
:id {:type :IntWhere},
:and {:type (list :GroupClauses)},
:user_id {:type :StrWhere},
:access {:type :IntWhere},
:edited_at {:type :StrWhere},
:created_at {:type :StrWhere}},
:sort
{:access {:type :SortOperator},
:created_at {:type :SortOperator},
:edited_at {:type :SortOperator},
:id {:type :SortOperator},
:title {:type :SortOperator},
:user_id {:type :SortOperator},
:description {:type :SortOperator}},
:fields
{:access {:type Int},
:created_at {:type String},
:edited_at {:type String},
:id {:type Int},
:title {:type String},
:user_id {:type String},
:description {:type String}},
:aggregate
{:count {:type Int},
:sum {:type :GroupFields},
:avg {:type :GroupFields},
:max {:type :GroupFields},
:min {:type :GroupFields}},
:pks {:id {:type (non-null Int)}},
:pk-input {:id {:type (non-null Int)}},
:update
{:access {:type Int},
:created_at {:type String},
:edited_at {:type String},
:title {:type String},
:user_id {:type String},
:description {:type String}}},
:fks
{:access
{:field-keys
{:to :Access,
:has-many :groups,
:has-many-aggr :groups_aggregate,
:has-one :access_access}},
:user_id
{:field-keys
{:to :User,
:has-many :groups,
:has-many-aggr :groups_aggregate,
:has-one :user}}},
:lcn-mut-keys
{:create :createGroup,
:update :updateGroup,
:delete :deleteGroup},
:lcn-obj-keys
{:rsc :Group,
:clauses :GroupClauses,
:where :GroupWhere,
:sort :GroupSort,
:fields :GroupFields,
:aggregate :GroupAggregate,
:pks :GroupPks,
:pk-input :GroupPkColumns},
:lcn-qry-keys {:queries :groups, :aggregate :groups_aggregate},
:lcn-descs
{:rsc "Groups",
:query "Query Groups.",
:clauses
"Format for where clauses is {column: {operator: value}}. Multiple parameters are applied with `AND` operators. `AND`/`OR` conditions can be created as a list of clauses. It is possible to nest them to create sub groups of conditions.",
:sort "Sort format is {column: \"asc\" or \"desc\"}.",
:fields "Groupsfields for aggregation.",
:aggregate "Aggrecate Groups.",
:pks "Primary key fields.",
:pk-input "Primary key fields."},
:signals
{:query {:pre (), :post ()},
:create {:pre (), :post ()},
:delete {:pre (), :post ()},
:update {:pre (), :post ()}},
:pk-keys (:id),
:col-keys
#{:description
:title
:id
:user_id
:access
:edited_at
:created_at}},
:signals
{:query {:pre (), :post ()},
:create {:pre (), :post ()},
:delete {:pre (), :post ()},
:update {:pre (), :post ()}},
:pk-keys (:id),
:col-keys
#{:can_read
:inherit
:can_edit
:group_id
:id
:user_id
:role_id
:next_access
:owner}},
:groups
{:lcn-fields
{:rsc
{:access {:type Int},
:created_at {:type String},
:edited_at {:type String},
:id {:type Int},
:title {:type String},
:user_id {:type String},
:description {:type String}},
:clauses
{:description {:type :StrWhere},
:or {:type (list :GroupClauses)},
:title {:type :StrWhere},
:id {:type :IntWhere},
:and {:type (list :GroupClauses)},
:user_id {:type :StrWhere},
:access {:type :IntWhere},
:edited_at {:type :StrWhere},
:created_at {:type :StrWhere}},
:sort
{:access {:type :SortOperator},
:created_at {:type :SortOperator},
:edited_at {:type :SortOperator},
:id {:type :SortOperator},
:title {:type :SortOperator},
:user_id {:type :SortOperator},
:description {:type :SortOperator}},
:fields
{:access {:type Int},
:created_at {:type String},
:edited_at {:type String},
:id {:type Int},
:title {:type String},
:user_id {:type String},
:description {:type String}},
:aggregate
{:count {:type Int},
:sum {:type :GroupFields},
:avg {:type :GroupFields},
:max {:type :GroupFields},
:min {:type :GroupFields}},
:pks {:id {:type (non-null Int)}},
:pk-input {:id {:type (non-null Int)}},
:update
{:access {:type Int},
:created_at {:type String},
:edited_at {:type String},
:title {:type String},
:user_id {:type String},
:description {:type String}}},
:fks
{:access
{:field-keys
{:to :Access,
:has-many :groups,
:has-many-aggr :groups_aggregate,
:has-one :access_access}},
:user_id
{:field-keys
{:to :User,
:has-many :groups,
:has-many-aggr :groups_aggregate,
:has-one :user}}},
:lcn-mut-keys
{:create :createGroup,
:update :updateGroup,
:delete :deleteGroup},
:lcn-obj-keys
{:rsc :Group,
:clauses :GroupClauses,
:where :GroupWhere,
:sort :GroupSort,
:fields :GroupFields,
:aggregate :GroupAggregate,
:pks :GroupPks,
:pk-input :GroupPkColumns},
:lcn-qry-keys {:queries :groups, :aggregate :groups_aggregate},
:lcn-descs
{:rsc "Groups",
:query "Query Groups.",
:clauses
"Format for where clauses is {column: {operator: value}}. Multiple parameters are applied with `AND` operators. `AND`/`OR` conditions can be created as a list of clauses. It is possible to nest them to create sub groups of conditions.",
:sort "Sort format is {column: \"asc\" or \"desc\"}.",
:fields "Groupsfields for aggregation.",
:aggregate "Aggrecate Groups.",
:pks "Primary key fields.",
:pk-input "Primary key fields."},
:signals
{:query {:pre (), :post ()},
:create {:pre (), :post ()},
:delete {:pre (), :post ()},
:update {:pre (), :post ()}},
:pk-keys (:id),
:col-keys
#{:description
:title
:id
:user_id
:access
:edited_at
:created_at}},
:items
{:lcn-fields
{:rsc
{:slug {:type String},
:domain_pk {:type String},
:title {:type String},
:domain_pk_namespace {:type String},
:id {:type Int},
:url {:type String},
:access {:type Int},
:edited_at {:type String},
:body {:type String},
:created_at {:type String}},
:clauses
{:slug {:type :StrWhere},
:domain_pk {:type :StrWhere},
:or {:type (list :ItemClauses)},
:title {:type :StrWhere},
:domain_pk_namespace {:type :StrWhere},
:id {:type :IntWhere},
:url {:type :StrWhere},
:and {:type (list :ItemClauses)},
:access {:type :IntWhere},
:edited_at {:type :StrWhere},
:body {:type :StrWhere},
:created_at {:type :StrWhere}},
:sort
{:slug {:type :SortOperator},
:domain_pk {:type :SortOperator},
:title {:type :SortOperator},
:domain_pk_namespace {:type :SortOperator},
:id {:type :SortOperator},
:url {:type :SortOperator},
:access {:type :SortOperator},
:edited_at {:type :SortOperator},
:body {:type :SortOperator},
:created_at {:type :SortOperator}},
:fields
{:slug {:type String},
:domain_pk {:type String},
:title {:type String},
:domain_pk_namespace {:type String},
:id {:type Int},
:url {:type String},
:access {:type Int},
:edited_at {:type String},
:body {:type String},
:created_at {:type String}},
:aggregate
{:count {:type Int},
:sum {:type :ItemFields},
:avg {:type :ItemFields},
:max {:type :ItemFields},
:min {:type :ItemFields}},
:pks {:id {:type (non-null Int)}},
:pk-input {:id {:type (non-null Int)}},
:update
{:slug {:type String},
:domain_pk {:type String},
:title {:type String},
:domain_pk_namespace {:type String},
:url {:type String},
:access {:type Int},
:edited_at {:type String},
:body {:type String},
:created_at {:type String}}},
:fks
{:access
{:field-keys
{:to :Access,
:has-many :items,
:has-many-aggr :items_aggregate,
:has-one :access_access}}},
:lcn-mut-keys
{:create :createItem, :update :updateItem, :delete :deleteItem},
:roles
{:lcn-fields
{:rsc
{:id {:type Int},
:group_id {:type Int},
:title {:type String},
:color {:type String}},
:clauses
{:and {:type (list :RoleClauses)},
:or {:type (list :RoleClauses)},
:id {:type :IntWhere},
:group_id {:type :IntWhere},
:title {:type :StrWhere},
:color {:type :StrWhere}},
:sort
{:id {:type :SortOperator},
:group_id {:type :SortOperator},
:title {:type :SortOperator},
:color {:type :SortOperator}},
:fields
{:id {:type Int},
:group_id {:type Int},
:title {:type String},
:color {:type String}},
:aggregate
{:count {:type Int},
:sum {:type :RoleFields},
:avg {:type :RoleFields},
:max {:type :RoleFields},
:min {:type :RoleFields}},
:pks {:id {:type (non-null Int)}},
:pk-input {:id {:type (non-null Int)}},
:update
{:group_id {:type Int},
:title {:type String},
:color {:type String}}},
:fks
{:group_id
{:field-keys
{:to :Group,
:has-many :roles,
:has-many-aggr :roles_aggregate,
:has-one :group}}},
:lcn-mut-keys
{:create :createRole,
:update :updateRole,
:delete :deleteRole},
:lcn-obj-keys
{:rsc :Role,
:clauses :RoleClauses,
:where :RoleWhere,
:sort :RoleSort,
:fields :RoleFields,
:aggregate :RoleAggregate,
:pks :RolePks,
:pk-input :RolePkColumns},
:lcn-qry-keys {:queries :roles, :aggregate :roles_aggregate},
:lcn-descs
{:rsc "Roles",
:query "Query Roles.",
:clauses
"Format for where clauses is {column: {operator: value}}. Multiple parameters are applied with `AND` operators. `AND`/`OR` conditions can be created as a list of clauses. It is possible to nest them to create sub groups of conditions.",
:sort "Sort format is {column: \"asc\" or \"desc\"}.",
:fields "Rolesfields for aggregation.",
:aggregate "Aggrecate Roles.",
:pks "Primary key fields.",
:pk-input "Primary key fields."},
:groups
{:lcn-fields
{:rsc
{:access {:type Int},
:created_at {:type String},
:edited_at {:type String},
:id {:type Int},
:title {:type String},
:user_id {:type String},
:description {:type String}},
:clauses
{:description {:type :StrWhere},
:or {:type (list :GroupClauses)},
:title {:type :StrWhere},
:id {:type :IntWhere},
:and {:type (list :GroupClauses)},
:user_id {:type :StrWhere},
:access {:type :IntWhere},
:edited_at {:type :StrWhere},
:created_at {:type :StrWhere}},
:sort
{:access {:type :SortOperator},
:created_at {:type :SortOperator},
:edited_at {:type :SortOperator},
:id {:type :SortOperator},
:title {:type :SortOperator},
:user_id {:type :SortOperator},
:description {:type :SortOperator}},
:fields
{:access {:type Int},
:created_at {:type String},
:edited_at {:type String},
:id {:type Int},
:title {:type String},
:user_id {:type String},
:description {:type String}},
:aggregate
{:count {:type Int},
:sum {:type :GroupFields},
:avg {:type :GroupFields},
:max {:type :GroupFields},
:min {:type :GroupFields}},
:pks {:id {:type (non-null Int)}},
:pk-input {:id {:type (non-null Int)}},
:update
{:access {:type Int},
:created_at {:type String},
:edited_at {:type String},
:title {:type String},
:user_id {:type String},
:description {:type String}}},
:fks
{:access
{:field-keys
{:to :Access,
:has-many :groups,
:has-many-aggr :groups_aggregate,
:has-one :access_access}},
:user_id
{:field-keys
{:to :User,
:has-many :groups,
:has-many-aggr :groups_aggregate,
:has-one :user}}},
:lcn-mut-keys
{:create :createGroup,
:update :updateGroup,
:delete :deleteGroup},
:lcn-obj-keys
{:rsc :Group,
:clauses :GroupClauses,
:where :GroupWhere,
:sort :GroupSort,
:fields :GroupFields,
:aggregate :GroupAggregate,
:pks :GroupPks,
:pk-input :GroupPkColumns},
:lcn-qry-keys
{:queries :groups, :aggregate :groups_aggregate},
:lcn-descs
{:rsc "Groups",
:query "Query Groups.",
:clauses
"Format for where clauses is {column: {operator: value}}. Multiple parameters are applied with `AND` operators. `AND`/`OR` conditions can be created as a list of clauses. It is possible to nest them to create sub groups of conditions.",
:sort "Sort format is {column: \"asc\" or \"desc\"}.",
:fields "Groupsfields for aggregation.",
:aggregate "Aggrecate Groups.",
:pks "Primary key fields.",
:pk-input "Primary key fields."},
:signals
{:query {:pre (), :post ()},
:create {:pre (), :post ()},
:delete {:pre (), :post ()},
:update {:pre (), :post ()}},
:pk-keys (:id),
:col-keys
#{:description
:title
:id
:user_id
:access
:edited_at
:created_at}},
:signals
{:query {:pre (), :post ()},
:create {:pre (), :post ()},
:delete {:pre (), :post ()},
:update {:pre (), :post ()}},
:pk-keys (:id),
:col-keys #{:color :title :group_id :id}},
:lcn-obj-keys
{:rsc :Item,
:clauses :ItemClauses,
:where :ItemWhere,
:sort :ItemSort,
:fields :ItemFields,
:aggregate :ItemAggregate,
:pks :ItemPks,
:pk-input :ItemPkColumns},
:lcn-qry-keys {:queries :items, :aggregate :items_aggregate},
:lcn-descs
{:rsc "Items",
:query "Query Items.",
:clauses
"Format for where clauses is {column: {operator: value}}. Multiple parameters are applied with `AND` operators. `AND`/`OR` conditions can be created as a list of clauses. It is possible to nest them to create sub groups of conditions.",
:sort "Sort format is {column: \"asc\" or \"desc\"}.",
:fields "Itemsfields for aggregation.",
:aggregate "Aggrecate Items.",
:pks "Primary key fields.",
:pk-input "Primary key fields."},
:access
{:lcn-fields
{:rsc
{:can_read {:type Boolean},
:inherit {:type Boolean},
:can_edit {:type Boolean},
:group_id {:type Int},
:id {:type Int},
:user_id {:type String},
:role_id {:type Int},
:next_access {:type Int},
:owner {:type Boolean}},
:clauses
{:can_read {:type :BoolWhere},
:inherit {:type :BoolWhere},
:can_edit {:type :BoolWhere},
:or {:type (list :AccessClauses)},
:group_id {:type :IntWhere},
:id {:type :IntWhere},
:and {:type (list :AccessClauses)},
:user_id {:type :StrWhere},
:role_id {:type :IntWhere},
:next_access {:type :IntWhere},
:owner {:type :BoolWhere}},
:sort
{:can_read {:type :SortOperator},
:inherit {:type :SortOperator},
:can_edit {:type :SortOperator},
:group_id {:type :SortOperator},
:id {:type :SortOperator},
:user_id {:type :SortOperator},
:role_id {:type :SortOperator},
:next_access {:type :SortOperator},
:owner {:type :SortOperator}},
:fields
{:can_read {:type Boolean},
:inherit {:type Boolean},
:can_edit {:type Boolean},
:group_id {:type Int},
:id {:type Int},
:user_id {:type String},
:role_id {:type Int},
:next_access {:type Int},
:owner {:type Boolean}},
:aggregate
{:count {:type Int},
:sum {:type :AccessFields},
:avg {:type :AccessFields},
:max {:type :AccessFields},
:min {:type :AccessFields}},
:pks {:id {:type (non-null Int)}},
:pk-input {:id {:type (non-null Int)}},
:update
{:can_read {:type Boolean},
:inherit {:type Boolean},
:can_edit {:type Boolean},
:group_id {:type Int},
:user_id {:type String},
:role_id {:type Int},
:next_access {:type Int},
:owner {:type Boolean}}},
:fks
{:next_access
{:field-keys
{:to :Access,
:has-many :accesses,
:has-many-aggr :accesses_aggregate,
:has-one :next_access_access}},
:role_id
{:field-keys
{:to :Role,
:has-many :accesses,
:has-many-aggr :accesses_aggregate,
:has-one :role}},
:user_id
{:field-keys
{:to :User,
:has-many :accesses,
:has-many-aggr :accesses_aggregate,
:has-one :user}},
:group_id
{:field-keys
{:to :Group,
:has-many :accesses,
:has-many-aggr :accesses_aggregate,
:has-one :group}}},
:lcn-mut-keys
{:create :createAccess,
:update :updateAccess,
:delete :deleteAccess},
:roles
{:lcn-fields
{:rsc
{:id {:type Int},
:group_id {:type Int},
:title {:type String},
:color {:type String}},
:clauses
{:and {:type (list :RoleClauses)},
:or {:type (list :RoleClauses)},
:id {:type :IntWhere},
:group_id {:type :IntWhere},
:title {:type :StrWhere},
:color {:type :StrWhere}},
:sort
{:id {:type :SortOperator},
:group_id {:type :SortOperator},
:title {:type :SortOperator},
:color {:type :SortOperator}},
:fields
{:id {:type Int},
:group_id {:type Int},
:title {:type String},
:color {:type String}},
:aggregate
{:count {:type Int},
:sum {:type :RoleFields},
:avg {:type :RoleFields},
:max {:type :RoleFields},
:min {:type :RoleFields}},
:pks {:id {:type (non-null Int)}},
:pk-input {:id {:type (non-null Int)}},
:update
{:group_id {:type Int},
:title {:type String},
:color {:type String}}},
:fks
{:group_id
{:field-keys
{:to :Group,
:has-many :roles,
:has-many-aggr :roles_aggregate,
:has-one :group}}},
:lcn-mut-keys
{:create :createRole,
:update :updateRole,
:delete :deleteRole},
:lcn-obj-keys
{:rsc :Role,
:clauses :RoleClauses,
:where :RoleWhere,
:sort :RoleSort,
:fields :RoleFields,
:aggregate :RoleAggregate,
:pks :RolePks,
:pk-input :RolePkColumns},
:lcn-qry-keys {:queries :roles, :aggregate :roles_aggregate},
:lcn-descs
{:rsc "Roles",
:query "Query Roles.",
:clauses
"Format for where clauses is {column: {operator: value}}. Multiple parameters are applied with `AND` operators. `AND`/`OR` conditions can be created as a list of clauses. It is possible to nest them to create sub groups of conditions.",
:sort "Sort format is {column: \"asc\" or \"desc\"}.",
:fields "Rolesfields for aggregation.",
:aggregate "Aggrecate Roles.",
:pks "Primary key fields.",
:pk-input "Primary key fields."},
:groups
{:lcn-fields
{:rsc
{:access {:type Int},
:created_at {:type String},
:edited_at {:type String},
:id {:type Int},
:title {:type String},
:user_id {:type String},
:description {:type String}},
:clauses
{:description {:type :StrWhere},
:or {:type (list :GroupClauses)},
:title {:type :StrWhere},
:id {:type :IntWhere},
:and {:type (list :GroupClauses)},
:user_id {:type :StrWhere},
:access {:type :IntWhere},
:edited_at {:type :StrWhere},
:created_at {:type :StrWhere}},
:sort
{:access {:type :SortOperator},
:created_at {:type :SortOperator},
:edited_at {:type :SortOperator},
:id {:type :SortOperator},
:title {:type :SortOperator},
:user_id {:type :SortOperator},
:description {:type :SortOperator}},
:fields
{:access {:type Int},
:created_at {:type String},
:edited_at {:type String},
:id {:type Int},
:title {:type String},
:user_id {:type String},
:description {:type String}},
:aggregate
{:count {:type Int},
:sum {:type :GroupFields},
:avg {:type :GroupFields},
:max {:type :GroupFields},
:min {:type :GroupFields}},
:pks {:id {:type (non-null Int)}},
:pk-input {:id {:type (non-null Int)}},
:update
{:access {:type Int},
:created_at {:type String},
:edited_at {:type String},
:title {:type String},
:user_id {:type String},
:description {:type String}}},
:fks
{:access
{:field-keys
{:to :Access,
:has-many :groups,
:has-many-aggr :groups_aggregate,
:has-one :access_access}},
:user_id
{:field-keys
{:to :User,
:has-many :groups,
:has-many-aggr :groups_aggregate,
:has-one :user}}},
:lcn-mut-keys
{:create :createGroup,
:update :updateGroup,
:delete :deleteGroup},
:lcn-obj-keys
{:rsc :Group,
:clauses :GroupClauses,
:where :GroupWhere,
:sort :GroupSort,
:fields :GroupFields,
:aggregate :GroupAggregate,
:pks :GroupPks,
:pk-input :GroupPkColumns},
:lcn-qry-keys
{:queries :groups, :aggregate :groups_aggregate},
:lcn-descs
{:rsc "Groups",
:query "Query Groups.",
:clauses
"Format for where clauses is {column: {operator: value}}. Multiple parameters are applied with `AND` operators. `AND`/`OR` conditions can be created as a list of clauses. It is possible to nest them to create sub groups of conditions.",
:sort "Sort format is {column: \"asc\" or \"desc\"}.",
:fields "Groupsfields for aggregation.",
:aggregate "Aggrecate Groups.",
:pks "Primary key fields.",
:pk-input "Primary key fields."},
:signals
{:query {:pre (), :post ()},
:create {:pre (), :post ()},
:delete {:pre (), :post ()},
:update {:pre (), :post ()}},
:pk-keys (:id),
:col-keys
#{:description
:title
:id
:user_id
:access
:edited_at
:created_at}},
:signals
{:query {:pre (), :post ()},
:create {:pre (), :post ()},
:delete {:pre (), :post ()},
:update {:pre (), :post ()}},
:pk-keys (:id),
:col-keys #{:color :title :group_id :id}},
:lcn-obj-keys
{:rsc :Access,
:clauses :AccessClauses,
:where :AccessWhere,
:sort :AccessSort,
:fields :AccessFields,
:aggregate :AccessAggregate,
:pks :AccessPks,
:pk-input :AccessPkColumns},
:lcn-qry-keys
{:queries :accesses, :aggregate :accesses_aggregate},
:lcn-descs
{:rsc "Accesses",
:query "Query Accesses.",
:clauses
"Format for where clauses is {column: {operator: value}}. Multiple parameters are applied with `AND` operators. `AND`/`OR` conditions can be created as a list of clauses. It is possible to nest them to create sub groups of conditions.",
:sort "Sort format is {column: \"asc\" or \"desc\"}.",
:fields "Accessesfields for aggregation.",
:aggregate "Aggrecate Accesses.",
:pks "Primary key fields.",
:pk-input "Primary key fields."},
:groups
{:lcn-fields
{:rsc
{:access {:type Int},
:created_at {:type String},
:edited_at {:type String},
:id {:type Int},
:title {:type String},
:user_id {:type String},
:description {:type String}},
:clauses
{:description {:type :StrWhere},
:or {:type (list :GroupClauses)},
:title {:type :StrWhere},
:id {:type :IntWhere},
:and {:type (list :GroupClauses)},
:user_id {:type :StrWhere},
:access {:type :IntWhere},
:edited_at {:type :StrWhere},
:created_at {:type :StrWhere}},
:sort
{:access {:type :SortOperator},
:created_at {:type :SortOperator},
:edited_at {:type :SortOperator},
:id {:type :SortOperator},
:title {:type :SortOperator},
:user_id {:type :SortOperator},
:description {:type :SortOperator}},
:fields
{:access {:type Int},
:created_at {:type String},
:edited_at {:type String},
:id {:type Int},
:title {:type String},
:user_id {:type String},
:description {:type String}},
:aggregate
{:count {:type Int},
:sum {:type :GroupFields},
:avg {:type :GroupFields},
:max {:type :GroupFields},
:min {:type :GroupFields}},
:pks {:id {:type (non-null Int)}},
:pk-input {:id {:type (non-null Int)}},
:update
{:access {:type Int},
:created_at {:type String},
:edited_at {:type String},
:title {:type String},
:user_id {:type String},
:description {:type String}}},
:fks
{:access
{:field-keys
{:to :Access,
:has-many :groups,
:has-many-aggr :groups_aggregate,
:has-one :access_access}},
:user_id
{:field-keys
{:to :User,
:has-many :groups,
:has-many-aggr :groups_aggregate,
:has-one :user}}},
:lcn-mut-keys
{:create :createGroup,
:update :updateGroup,
:delete :deleteGroup},
:lcn-obj-keys
{:rsc :Group,
:clauses :GroupClauses,
:where :GroupWhere,
:sort :GroupSort,
:fields :GroupFields,
:aggregate :GroupAggregate,
:pks :GroupPks,
:pk-input :GroupPkColumns},
:lcn-qry-keys
{:queries :groups, :aggregate :groups_aggregate},
:lcn-descs
{:rsc "Groups",
:query "Query Groups.",
:clauses
"Format for where clauses is {column: {operator: value}}. Multiple parameters are applied with `AND` operators. `AND`/`OR` conditions can be created as a list of clauses. It is possible to nest them to create sub groups of conditions.",
:sort "Sort format is {column: \"asc\" or \"desc\"}.",
:fields "Groupsfields for aggregation.",
:aggregate "Aggrecate Groups.",
:pks "Primary key fields.",
:pk-input "Primary key fields."},
:signals
{:query {:pre (), :post ()},
:create {:pre (), :post ()},
:delete {:pre (), :post ()},
:update {:pre (), :post ()}},
:pk-keys (:id),
:col-keys
#{:description
:title
:id
:user_id
:access
:edited_at
:created_at}},
:signals
{:query {:pre (), :post ()},
:create {:pre (), :post ()},
:delete {:pre (), :post ()},
:update {:pre (), :post ()}},
:pk-keys (:id),
:col-keys
#{:can_read
:inherit
:can_edit
:group_id
:id
:user_id
:role_id
:next_access
:owner}},
:groups
{:lcn-fields
{:rsc
{:access {:type Int},
:created_at {:type String},
:edited_at {:type String},
:id {:type Int},
:title {:type String},
:user_id {:type String},
:description {:type String}},
:clauses
{:description {:type :StrWhere},
:or {:type (list :GroupClauses)},
:title {:type :StrWhere},
:id {:type :IntWhere},
:and {:type (list :GroupClauses)},
:user_id {:type :StrWhere},
:access {:type :IntWhere},
:edited_at {:type :StrWhere},
:created_at {:type :StrWhere}},
:sort
{:access {:type :SortOperator},
:created_at {:type :SortOperator},
:edited_at {:type :SortOperator},
:id {:type :SortOperator},
:title {:type :SortOperator},
:user_id {:type :SortOperator},
:description {:type :SortOperator}},
:fields
{:access {:type Int},
:created_at {:type String},
:edited_at {:type String},
:id {:type Int},
:title {:type String},
:user_id {:type String},
:description {:type String}},
:aggregate
{:count {:type Int},
:sum {:type :GroupFields},
:avg {:type :GroupFields},
:max {:type :GroupFields},
:min {:type :GroupFields}},
:pks {:id {:type (non-null Int)}},
:pk-input {:id {:type (non-null Int)}},
:update
{:access {:type Int},
:created_at {:type String},
:edited_at {:type String},
:title {:type String},
:user_id {:type String},
:description {:type String}}},
:fks
{:access
{:field-keys
{:to :Access,
:has-many :groups,
:has-many-aggr :groups_aggregate,
:has-one :access_access}},
:user_id
{:field-keys
{:to :User,
:has-many :groups,
:has-many-aggr :groups_aggregate,
:has-one :user}}},
:lcn-mut-keys
{:create :createGroup,
:update :updateGroup,
:delete :deleteGroup},
:lcn-obj-keys
{:rsc :Group,
:clauses :GroupClauses,
:where :GroupWhere,
:sort :GroupSort,
:fields :GroupFields,
:aggregate :GroupAggregate,
:pks :GroupPks,
:pk-input :GroupPkColumns},
:lcn-qry-keys {:queries :groups, :aggregate :groups_aggregate},
:lcn-descs
{:rsc "Groups",
:query "Query Groups.",
:clauses
"Format for where clauses is {column: {operator: value}}. Multiple parameters are applied with `AND` operators. `AND`/`OR` conditions can be created as a list of clauses. It is possible to nest them to create sub groups of conditions.",
:sort "Sort format is {column: \"asc\" or \"desc\"}.",
:fields "Groupsfields for aggregation.",
:aggregate "Aggrecate Groups.",
:pks "Primary key fields.",
:pk-input "Primary key fields."},
:signals
{:query {:pre (), :post ()},
:create {:pre (), :post ()},
:delete {:pre (), :post ()},
:update {:pre (), :post ()}},
:pk-keys (:id),
:col-keys
#{:description
:title
:id
:user_id
:access
:edited_at
:created_at}},
:signals
{:query {:pre (), :post ()},
:create {:pre (), :post ()},
:delete {:pre (), :post ()},
:update {:pre (), :post ()}},
:pk-keys (:id),
:col-keys
#{:slug
:domain_pk
:title
:domain_pk_namespace
:id
:url
:access
:edited_at
:body
:created_at},
:users_in_groups
{:lcn-fields
{:rsc
{:group_id {:type Int},
:role_id {:type Int},
:user_id {:type String}},
:clauses
{:and {:type (list :UsersInGroupClauses)},
:or {:type (list :UsersInGroupClauses)},
:group_id {:type :IntWhere},
:role_id {:type :IntWhere},
:user_id {:type :StrWhere}},
:sort
{:group_id {:type :SortOperator},
:role_id {:type :SortOperator},
:user_id {:type :SortOperator}},
:fields
{:group_id {:type Int},
:role_id {:type Int},
:user_id {:type String}},
:aggregate
{:count {:type Int},
:sum {:type :UsersInGroupFields},
:avg {:type :UsersInGroupFields},
:max {:type :UsersInGroupFields},
:min {:type :UsersInGroupFields}},
:pks
{:user_id {:type (non-null String)},
:group_id {:type (non-null Int)},
:role_id {:type (non-null Int)}},
:pk-input
{:user_id {:type (non-null String)},
:group_id {:type (non-null Int)},
:role_id {:type (non-null Int)}},
:update {}},
:fks
{:user_id
{:field-keys
{:to :User,
:has-many :users_in_groups,
:has-many-aggr :users_in_groups_aggregate,
:has-one :user}},
:group_id
{:field-keys
{:to :Group,
:has-many :users_in_groups,
:has-many-aggr :users_in_groups_aggregate,
:has-one :group}},
:role_id
{:field-keys
{:to :Role,
:has-many :users_in_groups,
:has-many-aggr :users_in_groups_aggregate,
:has-one :role}}},
:lcn-mut-keys
{:create :createUsersInGroup,
:update :updateUsersInGroup,
:delete :deleteUsersInGroup},
:roles
{:lcn-fields
{:rsc
{:id {:type Int},
:group_id {:type Int},
:title {:type String},
:color {:type String}},
:clauses
{:and {:type (list :RoleClauses)},
:or {:type (list :RoleClauses)},
:id {:type :IntWhere},
:group_id {:type :IntWhere},
:title {:type :StrWhere},
:color {:type :StrWhere}},
:sort
{:id {:type :SortOperator},
:group_id {:type :SortOperator},
:title {:type :SortOperator},
:color {:type :SortOperator}},
:fields
{:id {:type Int},
:group_id {:type Int},
:title {:type String},
:color {:type String}},
:aggregate
{:count {:type Int},
:sum {:type :RoleFields},
:avg {:type :RoleFields},
:max {:type :RoleFields},
:min {:type :RoleFields}},
:pks {:id {:type (non-null Int)}},
:pk-input {:id {:type (non-null Int)}},
:update
{:group_id {:type Int},
:title {:type String},
:color {:type String}}},
:fks
{:group_id
{:field-keys
{:to :Group,
:has-many :roles,
:has-many-aggr :roles_aggregate,
:has-one :group}}},
:lcn-mut-keys
{:create :createRole,
:update :updateRole,
:delete :deleteRole},
:lcn-obj-keys
{:rsc :Role,
:clauses :RoleClauses,
:where :RoleWhere,
:sort :RoleSort,
:fields :RoleFields,
:aggregate :RoleAggregate,
:pks :RolePks,
:pk-input :RolePkColumns},
:lcn-qry-keys {:queries :roles, :aggregate :roles_aggregate},
:lcn-descs
{:rsc "Roles",
:query "Query Roles.",
:clauses
"Format for where clauses is {column: {operator: value}}. Multiple parameters are applied with `AND` operators. `AND`/`OR` conditions can be created as a list of clauses. It is possible to nest them to create sub groups of conditions.",
:sort "Sort format is {column: \"asc\" or \"desc\"}.",
:fields "Rolesfields for aggregation.",
:aggregate "Aggrecate Roles.",
:pks "Primary key fields.",
:pk-input "Primary key fields."},
:groups
{:lcn-fields
{:rsc
{:access {:type Int},
:created_at {:type String},
:edited_at {:type String},
:id {:type Int},
:title {:type String},
:user_id {:type String},
:description {:type String}},
:clauses
{:description {:type :StrWhere},
:or {:type (list :GroupClauses)},
:title {:type :StrWhere},
:id {:type :IntWhere},
:and {:type (list :GroupClauses)},
:user_id {:type :StrWhere},
:access {:type :IntWhere},
:edited_at {:type :StrWhere},
:created_at {:type :StrWhere}},
:sort
{:access {:type :SortOperator},
:created_at {:type :SortOperator},
:edited_at {:type :SortOperator},
:id {:type :SortOperator},
:title {:type :SortOperator},
:user_id {:type :SortOperator},
:description {:type :SortOperator}},
:fields
{:access {:type Int},
:created_at {:type String},
:edited_at {:type String},
:id {:type Int},
:title {:type String},
:user_id {:type String},
:description {:type String}},
:aggregate
{:count {:type Int},
:sum {:type :GroupFields},
:avg {:type :GroupFields},
:max {:type :GroupFields},
:min {:type :GroupFields}},
:pks {:id {:type (non-null Int)}},
:pk-input {:id {:type (non-null Int)}},
:update
{:access {:type Int},
:created_at {:type String},
:edited_at {:type String},
:title {:type String},
:user_id {:type String},
:description {:type String}}},
:fks
{:access
{:field-keys
{:to :Access,
:has-many :groups,
:has-many-aggr :groups_aggregate,
:has-one :access_access}},
:user_id
{:field-keys
{:to :User,
:has-many :groups,
:has-many-aggr :groups_aggregate,
:has-one :user}}},
:lcn-mut-keys
{:create :createGroup,
:update :updateGroup,
:delete :deleteGroup},
:lcn-obj-keys
{:rsc :Group,
:clauses :GroupClauses,
:where :GroupWhere,
:sort :GroupSort,
:fields :GroupFields,
:aggregate :GroupAggregate,
:pks :GroupPks,
:pk-input :GroupPkColumns},
:lcn-qry-keys
{:queries :groups, :aggregate :groups_aggregate},
:lcn-descs
{:rsc "Groups",
:query "Query Groups.",
:clauses
"Format for where clauses is {column: {operator: value}}. Multiple parameters are applied with `AND` operators. `AND`/`OR` conditions can be created as a list of clauses. It is possible to nest them to create sub groups of conditions.",
:sort "Sort format is {column: \"asc\" or \"desc\"}.",
:fields "Groupsfields for aggregation.",
:aggregate "Aggrecate Groups.",
:pks "Primary key fields.",
:pk-input "Primary key fields."},
:signals
{:query {:pre (), :post ()},
:create {:pre (), :post ()},
:delete {:pre (), :post ()},
:update {:pre (), :post ()}},
:pk-keys (:id),
:col-keys
#{:description
:title
:id
:user_id
:access
:edited_at
:created_at}},
:signals
{:query {:pre (), :post ()},
:create {:pre (), :post ()},
:delete {:pre (), :post ()},
:update {:pre (), :post ()}},
:pk-keys (:id),
:col-keys #{:color :title :group_id :id}},
:lcn-obj-keys
{:rsc :UsersInGroup,
:clauses :UsersInGroupClauses,
:where :UsersInGroupWhere,
:sort :UsersInGroupSort,
:fields :UsersInGroupFields,
:aggregate :UsersInGroupAggregate,
:pks :UsersInGroupPks,
:pk-input :UsersInGroupPkColumns},
:lcn-qry-keys
{:queries :users_in_groups,
:aggregate :users_in_groups_aggregate},
:lcn-descs
{:rsc "UsersInGroups",
:query "Query UsersInGroups.",
:clauses
"Format for where clauses is {column: {operator: value}}. Multiple parameters are applied with `AND` operators. `AND`/`OR` conditions can be created as a list of clauses. It is possible to nest them to create sub groups of conditions.",
:sort "Sort format is {column: \"asc\" or \"desc\"}.",
:fields "UsersInGroupsfields for aggregation.",
:aggregate "Aggrecate UsersInGroups.",
:pks "Primary key fields.",
:pk-input "Primary key fields."},
:access
{:lcn-fields
{:rsc
{:can_read {:type Boolean},
:inherit {:type Boolean},
:can_edit {:type Boolean},
:group_id {:type Int},
:id {:type Int},
:user_id {:type String},
:role_id {:type Int},
:next_access {:type Int},
:owner {:type Boolean}},
:clauses
{:can_read {:type :BoolWhere},
:inherit {:type :BoolWhere},
:can_edit {:type :BoolWhere},
:or {:type (list :AccessClauses)},
:group_id {:type :IntWhere},
:id {:type :IntWhere},
:and {:type (list :AccessClauses)},
:user_id {:type :StrWhere},
:role_id {:type :IntWhere},
:next_access {:type :IntWhere},
:owner {:type :BoolWhere}},
:sort
{:can_read {:type :SortOperator},
:inherit {:type :SortOperator},
:can_edit {:type :SortOperator},
:group_id {:type :SortOperator},
:id {:type :SortOperator},
:user_id {:type :SortOperator},
:role_id {:type :SortOperator},
:next_access {:type :SortOperator},
:owner {:type :SortOperator}},
:fields
{:can_read {:type Boolean},
:inherit {:type Boolean},
:can_edit {:type Boolean},
:group_id {:type Int},
:id {:type Int},
:user_id {:type String},
:role_id {:type Int},
:next_access {:type Int},
:owner {:type Boolean}},
:aggregate
{:count {:type Int},
:sum {:type :AccessFields},
:avg {:type :AccessFields},
:max {:type :AccessFields},
:min {:type :AccessFields}},
:pks {:id {:type (non-null Int)}},
:pk-input {:id {:type (non-null Int)}},
:update
{:can_read {:type Boolean},
:inherit {:type Boolean},
:can_edit {:type Boolean},
:group_id {:type Int},
:user_id {:type String},
:role_id {:type Int},
:next_access {:type Int},
:owner {:type Boolean}}},
:fks
{:next_access
{:field-keys
{:to :Access,
:has-many :accesses,
:has-many-aggr :accesses_aggregate,
:has-one :next_access_access}},
:role_id
{:field-keys
{:to :Role,
:has-many :accesses,
:has-many-aggr :accesses_aggregate,
:has-one :role}},
:user_id
{:field-keys
{:to :User,
:has-many :accesses,
:has-many-aggr :accesses_aggregate,
:has-one :user}},
:group_id
{:field-keys
{:to :Group,
:has-many :accesses,
:has-many-aggr :accesses_aggregate,
:has-one :group}}},
:lcn-mut-keys
{:create :createAccess,
:update :updateAccess,
:delete :deleteAccess},
:roles
{:lcn-fields
{:rsc
{:id {:type Int},
:group_id {:type Int},
:title {:type String},
:color {:type String}},
:clauses
{:and {:type (list :RoleClauses)},
:or {:type (list :RoleClauses)},
:id {:type :IntWhere},
:group_id {:type :IntWhere},
:title {:type :StrWhere},
:color {:type :StrWhere}},
:sort
{:id {:type :SortOperator},
:group_id {:type :SortOperator},
:title {:type :SortOperator},
:color {:type :SortOperator}},
:fields
{:id {:type Int},
:group_id {:type Int},
:title {:type String},
:color {:type String}},
:aggregate
{:count {:type Int},
:sum {:type :RoleFields},
:avg {:type :RoleFields},
:max {:type :RoleFields},
:min {:type :RoleFields}},
:pks {:id {:type (non-null Int)}},
:pk-input {:id {:type (non-null Int)}},
:update
{:group_id {:type Int},
:title {:type String},
:color {:type String}}},
:fks
{:group_id
{:field-keys
{:to :Group,
:has-many :roles,
:has-many-aggr :roles_aggregate,
:has-one :group}}},
:lcn-mut-keys
{:create :createRole,
:update :updateRole,
:delete :deleteRole},
:lcn-obj-keys
{:rsc :Role,
:clauses :RoleClauses,
:where :RoleWhere,
:sort :RoleSort,
:fields :RoleFields,
:aggregate :RoleAggregate,
:pks :RolePks,
:pk-input :RolePkColumns},
:lcn-qry-keys {:queries :roles, :aggregate :roles_aggregate},
:lcn-descs
{:rsc "Roles",
:query "Query Roles.",
:clauses
"Format for where clauses is {column: {operator: value}}. Multiple parameters are applied with `AND` operators. `AND`/`OR` conditions can be created as a list of clauses. It is possible to nest them to create sub groups of conditions.",
:sort "Sort format is {column: \"asc\" or \"desc\"}.",
:fields "Rolesfields for aggregation.",
:aggregate "Aggrecate Roles.",
:pks "Primary key fields.",
:pk-input "Primary key fields."},
:groups
{:lcn-fields
{:rsc
{:access {:type Int},
:created_at {:type String},
:edited_at {:type String},
:id {:type Int},
:title {:type String},
:user_id {:type String},
:description {:type String}},
:clauses
{:description {:type :StrWhere},
:or {:type (list :GroupClauses)},
:title {:type :StrWhere},
:id {:type :IntWhere},
:and {:type (list :GroupClauses)},
:user_id {:type :StrWhere},
:access {:type :IntWhere},
:edited_at {:type :StrWhere},
:created_at {:type :StrWhere}},
:sort
{:access {:type :SortOperator},
:created_at {:type :SortOperator},
:edited_at {:type :SortOperator},
:id {:type :SortOperator},
:title {:type :SortOperator},
:user_id {:type :SortOperator},
:description {:type :SortOperator}},
:fields
{:access {:type Int},
:created_at {:type String},
:edited_at {:type String},
:id {:type Int},
:title {:type String},
:user_id {:type String},
:description {:type String}},
:aggregate
{:count {:type Int},
:sum {:type :GroupFields},
:avg {:type :GroupFields},
:max {:type :GroupFields},
:min {:type :GroupFields}},
:pks {:id {:type (non-null Int)}},
:pk-input {:id {:type (non-null Int)}},
:update
{:access {:type Int},
:created_at {:type String},
:edited_at {:type String},
:title {:type String},
:user_id {:type String},
:description {:type String}}},
:fks
{:access
{:field-keys
{:to :Access,
:has-many :groups,
:has-many-aggr :groups_aggregate,
:has-one :access_access}},
:user_id
{:field-keys
{:to :User,
:has-many :groups,
:has-many-aggr :groups_aggregate,
:has-one :user}}},
:lcn-mut-keys
{:create :createGroup,
:update :updateGroup,
:delete :deleteGroup},
:lcn-obj-keys
{:rsc :Group,
:clauses :GroupClauses,
:where :GroupWhere,
:sort :GroupSort,
:fields :GroupFields,
:aggregate :GroupAggregate,
:pks :GroupPks,
:pk-input :GroupPkColumns},
:lcn-qry-keys
{:queries :groups, :aggregate :groups_aggregate},
:lcn-descs
{:rsc "Groups",
:query "Query Groups.",
:clauses
"Format for where clauses is {column: {operator: value}}. Multiple parameters are applied with `AND` operators. `AND`/`OR` conditions can be created as a list of clauses. It is possible to nest them to create sub groups of conditions.",
:sort "Sort format is {column: \"asc\" or \"desc\"}.",
:fields "Groupsfields for aggregation.",
:aggregate "Aggrecate Groups.",
:pks "Primary key fields.",
:pk-input "Primary key fields."},
:signals
{:query {:pre (), :post ()},
:create {:pre (), :post ()},
:delete {:pre (), :post ()},
:update {:pre (), :post ()}},
:pk-keys (:id),
:col-keys
#{:description
:title
:id
:user_id
:access
:edited_at
:created_at}},
:signals
{:query {:pre (), :post ()},
:create {:pre (), :post ()},
:delete {:pre (), :post ()},
:update {:pre (), :post ()}},
:pk-keys (:id),
:col-keys #{:color :title :group_id :id}},
:lcn-obj-keys
{:rsc :Access,
:clauses :AccessClauses,
:where :AccessWhere,
:sort :AccessSort,
:fields :AccessFields,
:aggregate :AccessAggregate,
:pks :AccessPks,
:pk-input :AccessPkColumns},
:lcn-qry-keys
{:queries :accesses, :aggregate :accesses_aggregate},
:lcn-descs
{:rsc "Accesses",
:query "Query Accesses.",
:clauses
"Format for where clauses is {column: {operator: value}}. Multiple parameters are applied with `AND` operators. `AND`/`OR` conditions can be created as a list of clauses. It is possible to nest them to create sub groups of conditions.",
:sort "Sort format is {column: \"asc\" or \"desc\"}.",
:fields "Accessesfields for aggregation.",
:aggregate "Aggrecate Accesses.",
:pks "Primary key fields.",
:pk-input "Primary key fields."},
:groups
{:lcn-fields
{:rsc
{:access {:type Int},
:created_at {:type String},
:edited_at {:type String},
:id {:type Int},
:title {:type String},
:user_id {:type String},
:description {:type String}},
:clauses
{:description {:type :StrWhere},
:or {:type (list :GroupClauses)},
:title {:type :StrWhere},
:id {:type :IntWhere},
:and {:type (list :GroupClauses)},
:user_id {:type :StrWhere},
:access {:type :IntWhere},
:edited_at {:type :StrWhere},
:created_at {:type :StrWhere}},
:sort
{:access {:type :SortOperator},
:created_at {:type :SortOperator},
:edited_at {:type :SortOperator},
:id {:type :SortOperator},
:title {:type :SortOperator},
:user_id {:type :SortOperator},
:description {:type :SortOperator}},
:fields
{:access {:type Int},
:created_at {:type String},
:edited_at {:type String},
:id {:type Int},
:title {:type String},
:user_id {:type String},
:description {:type String}},
:aggregate
{:count {:type Int},
:sum {:type :GroupFields},
:avg {:type :GroupFields},
:max {:type :GroupFields},
:min {:type :GroupFields}},
:pks {:id {:type (non-null Int)}},
:pk-input {:id {:type (non-null Int)}},
:update
{:access {:type Int},
:created_at {:type String},
:edited_at {:type String},
:title {:type String},
:user_id {:type String},
:description {:type String}}},
:fks
{:access
{:field-keys
{:to :Access,
:has-many :groups,
:has-many-aggr :groups_aggregate,
:has-one :access_access}},
:user_id
{:field-keys
{:to :User,
:has-many :groups,
:has-many-aggr :groups_aggregate,
:has-one :user}}},
:lcn-mut-keys
{:create :createGroup,
:update :updateGroup,
:delete :deleteGroup},
:lcn-obj-keys
{:rsc :Group,
:clauses :GroupClauses,
:where :GroupWhere,
:sort :GroupSort,
:fields :GroupFields,
:aggregate :GroupAggregate,
:pks :GroupPks,
:pk-input :GroupPkColumns},
:lcn-qry-keys
{:queries :groups, :aggregate :groups_aggregate},
:lcn-descs
{:rsc "Groups",
:query "Query Groups.",
:clauses
"Format for where clauses is {column: {operator: value}}. Multiple parameters are applied with `AND` operators. `AND`/`OR` conditions can be created as a list of clauses. It is possible to nest them to create sub groups of conditions.",
:sort "Sort format is {column: \"asc\" or \"desc\"}.",
:fields "Groupsfields for aggregation.",
:aggregate "Aggrecate Groups.",
:pks "Primary key fields.",
:pk-input "Primary key fields."},
:signals
{:query {:pre (), :post ()},
:create {:pre (), :post ()},
:delete {:pre (), :post ()},
:update {:pre (), :post ()}},
:pk-keys (:id),
:col-keys
#{:description
:title
:id
:user_id
:access
:edited_at
:created_at}},
:signals
{:query {:pre (), :post ()},
:create {:pre (), :post ()},
:delete {:pre (), :post ()},
:update {:pre (), :post ()}},
:pk-keys (:id),
:col-keys
#{:can_read
:inherit
:can_edit
:group_id
:id
:user_id
:role_id
:next_access
:owner}},
:groups
{:lcn-fields
{:rsc
{:access {:type Int},
:created_at {:type String},
:edited_at {:type String},
:id {:type Int},
:title {:type String},
:user_id {:type String},
:description {:type String}},
:clauses
{:description {:type :StrWhere},
:or {:type (list :GroupClauses)},
:title {:type :StrWhere},
:id {:type :IntWhere},
:and {:type (list :GroupClauses)},
:user_id {:type :StrWhere},
:access {:type :IntWhere},
:edited_at {:type :StrWhere},
:created_at {:type :StrWhere}},
:sort
{:access {:type :SortOperator},
:created_at {:type :SortOperator},
:edited_at {:type :SortOperator},
:id {:type :SortOperator},
:title {:type :SortOperator},
:user_id {:type :SortOperator},
:description {:type :SortOperator}},
:fields
{:access {:type Int},
:created_at {:type String},
:edited_at {:type String},
:id {:type Int},
:title {:type String},
:user_id {:type String},
:description {:type String}},
:aggregate
{:count {:type Int},
:sum {:type :GroupFields},
:avg {:type :GroupFields},
:max {:type :GroupFields},
:min {:type :GroupFields}},
:pks {:id {:type (non-null Int)}},
:pk-input {:id {:type (non-null Int)}},
:update
{:access {:type Int},
:created_at {:type String},
:edited_at {:type String},
:title {:type String},
:user_id {:type String},
:description {:type String}}},
:fks
{:access
{:field-keys
{:to :Access,
:has-many :groups,
:has-many-aggr :groups_aggregate,
:has-one :access_access}},
:user_id
{:field-keys
{:to :User,
:has-many :groups,
:has-many-aggr :groups_aggregate,
:has-one :user}}},
:lcn-mut-keys
{:create :createGroup,
:update :updateGroup,
:delete :deleteGroup},
:lcn-obj-keys
{:rsc :Group,
:clauses :GroupClauses,
:where :GroupWhere,
:sort :GroupSort,
:fields :GroupFields,
:aggregate :GroupAggregate,
:pks :GroupPks,
:pk-input :GroupPkColumns},
:lcn-qry-keys
{:queries :groups, :aggregate :groups_aggregate},
:lcn-descs
{:rsc "Groups",
:query "Query Groups.",
:clauses
"Format for where clauses is {column: {operator: value}}. Multiple parameters are applied with `AND` operators. `AND`/`OR` conditions can be created as a list of clauses. It is possible to nest them to create sub groups of conditions.",
:sort "Sort format is {column: \"asc\" or \"desc\"}.",
:fields "Groupsfields for aggregation.",
:aggregate "Aggrecate Groups.",
:pks "Primary key fields.",
:pk-input "Primary key fields."},
:signals
{:query {:pre (), :post ()},
:create {:pre (), :post ()},
:delete {:pre (), :post ()},
:update {:pre (), :post ()}},
:pk-keys (:id),
:col-keys
#{:description
:title
:id
:user_id
:access
:edited_at
:created_at}},
:signals
{:query {:pre (), :post ()},
:create {:pre (), :post ()},
:delete {:pre (), :post ()},
:update {:pre (), :post ()}},
:pk-keys (:user_id :group_id :role_id),
:col-keys #{:group_id :user_id :role_id}}},
:signals
{:query {:pre (), :post ()},
:create {:pre (), :post ()},
:delete {:pre (), :post ()},
:update {:pre (), :post ()}},
:pk-keys (:id),
:col-keys
#{:attribute_name
:description
:udt_schema
:collation_schema
:numeric_scale
:character_set_schema
:dtd_identifier
:maximum_cardinality
:is_derived_reference_attribute
:character_octet_length
:datetime_precision
:scope_catalog
:collation_catalog
:character_maximum_length
:is_nullable
:character_set_catalog
:numeric_precision
:interval_type
:udt_catalog
:title
:scope_schema
:attribute_default
:numeric_precision_radix
:interval_precision
:character_set_name
:attribute_udt_catalog
:id
:collation_name
:data_type
:attribute_udt_schema
:access
:edited_at
:scope_name
:udt_name
:created_at
:ordinal_position
:attribute_udt_name},
:users_in_groups
{:lcn-fields
{:rsc
{:group_id {:type Int},
:role_id {:type Int},
:user_id {:type String}},
:clauses
{:and {:type (list :UsersInGroupClauses)},
:or {:type (list :UsersInGroupClauses)},
:group_id {:type :IntWhere},
:role_id {:type :IntWhere},
:user_id {:type :StrWhere}},
:sort
{:group_id {:type :SortOperator},
:role_id {:type :SortOperator},
:user_id {:type :SortOperator}},
:fields
{:group_id {:type Int},
:role_id {:type Int},
:user_id {:type String}},
:aggregate
{:count {:type Int},
:sum {:type :UsersInGroupFields},
:avg {:type :UsersInGroupFields},
:max {:type :UsersInGroupFields},
:min {:type :UsersInGroupFields}},
:pks
{:user_id {:type (non-null String)},
:group_id {:type (non-null Int)},
:role_id {:type (non-null Int)}},
:pk-input
{:user_id {:type (non-null String)},
:group_id {:type (non-null Int)},
:role_id {:type (non-null Int)}},
:update {}},
:fks
{:user_id
{:field-keys
{:to :User,
:has-many :users_in_groups,
:has-many-aggr :users_in_groups_aggregate,
:has-one :user}},
:group_id
{:field-keys
{:to :Group,
:has-many :users_in_groups,
:has-many-aggr :users_in_groups_aggregate,
:has-one :group}},
:role_id
{:field-keys
{:to :Role,
:has-many :users_in_groups,
:has-many-aggr :users_in_groups_aggregate,
:has-one :role}}},
:lcn-mut-keys
{:create :createUsersInGroup,
:update :updateUsersInGroup,
:delete :deleteUsersInGroup},
:roles
{:lcn-fields
{:rsc
{:id {:type Int},
:group_id {:type Int},
:title {:type String},
:color {:type String}},
:clauses
{:and {:type (list :RoleClauses)},
:or {:type (list :RoleClauses)},
:id {:type :IntWhere},
:group_id {:type :IntWhere},
:title {:type :StrWhere},
:color {:type :StrWhere}},
:sort
{:id {:type :SortOperator},
:group_id {:type :SortOperator},
:title {:type :SortOperator},
:color {:type :SortOperator}},
:fields
{:id {:type Int},
:group_id {:type Int},
:title {:type String},
:color {:type String}},
:aggregate
{:count {:type Int},
:sum {:type :RoleFields},
:avg {:type :RoleFields},
:max {:type :RoleFields},
:min {:type :RoleFields}},
:pks {:id {:type (non-null Int)}},
:pk-input {:id {:type (non-null Int)}},
:update
{:group_id {:type Int},
:title {:type String},
:color {:type String}}},
:fks
{:group_id
{:field-keys
{:to :Group,
:has-many :roles,
:has-many-aggr :roles_aggregate,
:has-one :group}}},
:lcn-mut-keys
{:create :createRole,
:update :updateRole,
:delete :deleteRole},
:lcn-obj-keys
{:rsc :Role,
:clauses :RoleClauses,
:where :RoleWhere,
:sort :RoleSort,
:fields :RoleFields,
:aggregate :RoleAggregate,
:pks :RolePks,
:pk-input :RolePkColumns},
:lcn-qry-keys {:queries :roles, :aggregate :roles_aggregate},
:lcn-descs
{:rsc "Roles",
:query "Query Roles.",
:clauses
"Format for where clauses is {column: {operator: value}}. Multiple parameters are applied with `AND` operators. `AND`/`OR` conditions can be created as a list of clauses. It is possible to nest them to create sub groups of conditions.",
:sort "Sort format is {column: \"asc\" or \"desc\"}.",
:fields "Rolesfields for aggregation.",
:aggregate "Aggrecate Roles.",
:pks "Primary key fields.",
:pk-input "Primary key fields."},
:groups
{:lcn-fields
{:rsc
{:access {:type Int},
:created_at {:type String},
:edited_at {:type String},
:id {:type Int},
:title {:type String},
:user_id {:type String},
:description {:type String}},
:clauses
{:description {:type :StrWhere},
:or {:type (list :GroupClauses)},
:title {:type :StrWhere},
:id {:type :IntWhere},
:and {:type (list :GroupClauses)},
:user_id {:type :StrWhere},
:access {:type :IntWhere},
:edited_at {:type :StrWhere},
:created_at {:type :StrWhere}},
:sort
{:access {:type :SortOperator},
:created_at {:type :SortOperator},
:edited_at {:type :SortOperator},
:id {:type :SortOperator},
:title {:type :SortOperator},
:user_id {:type :SortOperator},
:description {:type :SortOperator}},
:fields
{:access {:type Int},
:created_at {:type String},
:edited_at {:type String},
:id {:type Int},
:title {:type String},
:user_id {:type String},
:description {:type String}},
:aggregate
{:count {:type Int},
:sum {:type :GroupFields},
:avg {:type :GroupFields},
:max {:type :GroupFields},
:min {:type :GroupFields}},
:pks {:id {:type (non-null Int)}},
:pk-input {:id {:type (non-null Int)}},
:update
{:access {:type Int},
:created_at {:type String},
:edited_at {:type String},
:title {:type String},
:user_id {:type String},
:description {:type String}}},
:fks
{:access
{:field-keys
{:to :Access,
:has-many :groups,
:has-many-aggr :groups_aggregate,
:has-one :access_access}},
:user_id
{:field-keys
{:to :User,
:has-many :groups,
:has-many-aggr :groups_aggregate,
:has-one :user}}},
:lcn-mut-keys
{:create :createGroup,
:update :updateGroup,
:delete :deleteGroup},
:lcn-obj-keys
{:rsc :Group,
:clauses :GroupClauses,
:where :GroupWhere,
:sort :GroupSort,
:fields :GroupFields,
:aggregate :GroupAggregate,
:pks :GroupPks,
:pk-input :GroupPkColumns},
:lcn-qry-keys
{:queries :groups, :aggregate :groups_aggregate},
:lcn-descs
{:rsc "Groups",
:query "Query Groups.",
:clauses
"Format for where clauses is {column: {operator: value}}. Multiple parameters are applied with `AND` operators. `AND`/`OR` conditions can be created as a list of clauses. It is possible to nest them to create sub groups of conditions.",
:sort "Sort format is {column: \"asc\" or \"desc\"}.",
:fields "Groupsfields for aggregation.",
:aggregate "Aggrecate Groups.",
:pks "Primary key fields.",
:pk-input "Primary key fields."},
:signals
{:query {:pre (), :post ()},
:create {:pre (), :post ()},
:delete {:pre (), :post ()},
:update {:pre (), :post ()}},
:pk-keys (:id),
:col-keys
#{:description
:title
:id
:user_id
:access
:edited_at
:created_at}},
:signals
{:query {:pre (), :post ()},
:create {:pre (), :post ()},
:delete {:pre (), :post ()},
:update {:pre (), :post ()}},
:pk-keys (:id),
:col-keys #{:color :title :group_id :id}},
:lcn-obj-keys
{:rsc :UsersInGroup,
:clauses :UsersInGroupClauses,
:where :UsersInGroupWhere,
:sort :UsersInGroupSort,
:fields :UsersInGroupFields,
:aggregate :UsersInGroupAggregate,
:pks :UsersInGroupPks,
:pk-input :UsersInGroupPkColumns},
:lcn-qry-keys
{:queries :users_in_groups,
:aggregate :users_in_groups_aggregate},
:lcn-descs
{:rsc "UsersInGroups",
:query "Query UsersInGroups.",
:clauses
"Format for where clauses is {column: {operator: value}}. Multiple parameters are applied with `AND` operators. `AND`/`OR` conditions can be created as a list of clauses. It is possible to nest them to create sub groups of conditions.",
:sort "Sort format is {column: \"asc\" or \"desc\"}.",
:fields "UsersInGroupsfields for aggregation.",
:aggregate "Aggrecate UsersInGroups.",
:pks "Primary key fields.",
:pk-input "Primary key fields."},
:access
{:lcn-fields
{:rsc
{:can_read {:type Boolean},
:inherit {:type Boolean},
:can_edit {:type Boolean},
:group_id {:type Int},
:id {:type Int},
:user_id {:type String},
:role_id {:type Int},
:next_access {:type Int},
:owner {:type Boolean}},
:clauses
{:can_read {:type :BoolWhere},
:inherit {:type :BoolWhere},
:can_edit {:type :BoolWhere},
:or {:type (list :AccessClauses)},
:group_id {:type :IntWhere},
:id {:type :IntWhere},
:and {:type (list :AccessClauses)},
:user_id {:type :StrWhere},
:role_id {:type :IntWhere},
:next_access {:type :IntWhere},
:owner {:type :BoolWhere}},
:sort
{:can_read {:type :SortOperator},
:inherit {:type :SortOperator},
:can_edit {:type :SortOperator},
:group_id {:type :SortOperator},
:id {:type :SortOperator},
:user_id {:type :SortOperator},
:role_id {:type :SortOperator},
:next_access {:type :SortOperator},
:owner {:type :SortOperator}},
:fields
{:can_read {:type Boolean},
:inherit {:type Boolean},
:can_edit {:type Boolean},
:group_id {:type Int},
:id {:type Int},
:user_id {:type String},
:role_id {:type Int},
:next_access {:type Int},
:owner {:type Boolean}},
:aggregate
{:count {:type Int},
:sum {:type :AccessFields},
:avg {:type :AccessFields},
:max {:type :AccessFields},
:min {:type :AccessFields}},
:pks {:id {:type (non-null Int)}},
:pk-input {:id {:type (non-null Int)}},
:update
{:can_read {:type Boolean},
:inherit {:type Boolean},
:can_edit {:type Boolean},
:group_id {:type Int},
:user_id {:type String},
:role_id {:type Int},
:next_access {:type Int},
:owner {:type Boolean}}},
:fks
{:next_access
{:field-keys
{:to :Access,
:has-many :accesses,
:has-many-aggr :accesses_aggregate,
:has-one :next_access_access}},
:role_id
{:field-keys
{:to :Role,
:has-many :accesses,
:has-many-aggr :accesses_aggregate,
:has-one :role}},
:user_id
{:field-keys
{:to :User,
:has-many :accesses,
:has-many-aggr :accesses_aggregate,
:has-one :user}},
:group_id
{:field-keys
{:to :Group,
:has-many :accesses,
:has-many-aggr :accesses_aggregate,
:has-one :group}}},
:lcn-mut-keys
{:create :createAccess,
:update :updateAccess,
:delete :deleteAccess},
:roles
{:lcn-fields
{:rsc
{:id {:type Int},
:group_id {:type Int},
:title {:type String},
:color {:type String}},
:clauses
{:and {:type (list :RoleClauses)},
:or {:type (list :RoleClauses)},
:id {:type :IntWhere},
:group_id {:type :IntWhere},
:title {:type :StrWhere},
:color {:type :StrWhere}},
:sort
{:id {:type :SortOperator},
:group_id {:type :SortOperator},
:title {:type :SortOperator},
:color {:type :SortOperator}},
:fields
{:id {:type Int},
:group_id {:type Int},
:title {:type String},
:color {:type String}},
:aggregate
{:count {:type Int},
:sum {:type :RoleFields},
:avg {:type :RoleFields},
:max {:type :RoleFields},
:min {:type :RoleFields}},
:pks {:id {:type (non-null Int)}},
:pk-input {:id {:type (non-null Int)}},
:update
{:group_id {:type Int},
:title {:type String},
:color {:type String}}},
:fks
{:group_id
{:field-keys
{:to :Group,
:has-many :roles,
:has-many-aggr :roles_aggregate,
:has-one :group}}},
:lcn-mut-keys
{:create :createRole,
:update :updateRole,
:delete :deleteRole},
:lcn-obj-keys
{:rsc :Role,
:clauses :RoleClauses,
:where :RoleWhere,
:sort :RoleSort,
:fields :RoleFields,
:aggregate :RoleAggregate,
:pks :RolePks,
:pk-input :RolePkColumns},
:lcn-qry-keys {:queries :roles, :aggregate :roles_aggregate},
:lcn-descs
{:rsc "Roles",
:query "Query Roles.",
:clauses
"Format for where clauses is {column: {operator: value}}. Multiple parameters are applied with `AND` operators. `AND`/`OR` conditions can be created as a list of clauses. It is possible to nest them to create sub groups of conditions.",
:sort "Sort format is {column: \"asc\" or \"desc\"}.",
:fields "Rolesfields for aggregation.",
:aggregate "Aggrecate Roles.",
:pks "Primary key fields.",
:pk-input "Primary key fields."},
:groups
{:lcn-fields
{:rsc
{:access {:type Int},
:created_at {:type String},
:edited_at {:type String},
:id {:type Int},
:title {:type String},
:user_id {:type String},
:description {:type String}},
:clauses
{:description {:type :StrWhere},
:or {:type (list :GroupClauses)},
:title {:type :StrWhere},
:id {:type :IntWhere},
:and {:type (list :GroupClauses)},
:user_id {:type :StrWhere},
:access {:type :IntWhere},
:edited_at {:type :StrWhere},
:created_at {:type :StrWhere}},
:sort
{:access {:type :SortOperator},
:created_at {:type :SortOperator},
:edited_at {:type :SortOperator},
:id {:type :SortOperator},
:title {:type :SortOperator},
:user_id {:type :SortOperator},
:description {:type :SortOperator}},
:fields
{:access {:type Int},
:created_at {:type String},
:edited_at {:type String},
:id {:type Int},
:title {:type String},
:user_id {:type String},
:description {:type String}},
:aggregate
{:count {:type Int},
:sum {:type :GroupFields},
:avg {:type :GroupFields},
:max {:type :GroupFields},
:min {:type :GroupFields}},
:pks {:id {:type (non-null Int)}},
:pk-input {:id {:type (non-null Int)}},
:update
{:access {:type Int},
:created_at {:type String},
:edited_at {:type String},
:title {:type String},
:user_id {:type String},
:description {:type String}}},
:fks
{:access
{:field-keys
{:to :Access,
:has-many :groups,
:has-many-aggr :groups_aggregate,
:has-one :access_access}},
:user_id
{:field-keys
{:to :User,
:has-many :groups,
:has-many-aggr :groups_aggregate,
:has-one :user}}},
:lcn-mut-keys
{:create :createGroup,
:update :updateGroup,
:delete :deleteGroup},
:lcn-obj-keys
{:rsc :Group,
:clauses :GroupClauses,
:where :GroupWhere,
:sort :GroupSort,
:fields :GroupFields,
:aggregate :GroupAggregate,
:pks :GroupPks,
:pk-input :GroupPkColumns},
:lcn-qry-keys
{:queries :groups, :aggregate :groups_aggregate},
:lcn-descs
{:rsc "Groups",
:query "Query Groups.",
:clauses
"Format for where clauses is {column: {operator: value}}. Multiple parameters are applied with `AND` operators. `AND`/`OR` conditions can be created as a list of clauses. It is possible to nest them to create sub groups of conditions.",
:sort "Sort format is {column: \"asc\" or \"desc\"}.",
:fields "Groupsfields for aggregation.",
:aggregate "Aggrecate Groups.",
:pks "Primary key fields.",
:pk-input "Primary key fields."},
:signals
{:query {:pre (), :post ()},
:create {:pre (), :post ()},
:delete {:pre (), :post ()},
:update {:pre (), :post ()}},
:pk-keys (:id),
:col-keys
#{:description
:title
:id
:user_id
:access
:edited_at
:created_at}},
:signals
{:query {:pre (), :post ()},
:create {:pre (), :post ()},
:delete {:pre (), :post ()},
:update {:pre (), :post ()}},
:pk-keys (:id),
:col-keys #{:color :title :group_id :id}},
:lcn-obj-keys
{:rsc :Access,
:clauses :AccessClauses,
:where :AccessWhere,
:sort :AccessSort,
:fields :AccessFields,
:aggregate :AccessAggregate,
:pks :AccessPks,
:pk-input :AccessPkColumns},
:lcn-qry-keys
{:queries :accesses, :aggregate :accesses_aggregate},
:lcn-descs
{:rsc "Accesses",
:query "Query Accesses.",
:clauses
"Format for where clauses is {column: {operator: value}}. Multiple parameters are applied with `AND` operators. `AND`/`OR` conditions can be created as a list of clauses. It is possible to nest them to create sub groups of conditions.",
:sort "Sort format is {column: \"asc\" or \"desc\"}.",
:fields "Accessesfields for aggregation.",
:aggregate "Aggrecate Accesses.",
:pks "Primary key fields.",
:pk-input "Primary key fields."},
:groups
{:lcn-fields
{:rsc
{:access {:type Int},
:created_at {:type String},
:edited_at {:type String},
:id {:type Int},
:title {:type String},
:user_id {:type String},
:description {:type String}},
:clauses
{:description {:type :StrWhere},
:or {:type (list :GroupClauses)},
:title {:type :StrWhere},
:id {:type :IntWhere},
:and {:type (list :GroupClauses)},
:user_id {:type :StrWhere},
:access {:type :IntWhere},
:edited_at {:type :StrWhere},
:created_at {:type :StrWhere}},
:sort
{:access {:type :SortOperator},
:created_at {:type :SortOperator},
:edited_at {:type :SortOperator},
:id {:type :SortOperator},
:title {:type :SortOperator},
:user_id {:type :SortOperator},
:description {:type :SortOperator}},
:fields
{:access {:type Int},
:created_at {:type String},
:edited_at {:type String},
:id {:type Int},
:title {:type String},
:user_id {:type String},
:description {:type String}},
:aggregate
{:count {:type Int},
:sum {:type :GroupFields},
:avg {:type :GroupFields},
:max {:type :GroupFields},
:min {:type :GroupFields}},
:pks {:id {:type (non-null Int)}},
:pk-input {:id {:type (non-null Int)}},
:update
{:access {:type Int},
:created_at {:type String},
:edited_at {:type String},
:title {:type String},
:user_id {:type String},
:description {:type String}}},
:fks
{:access
{:field-keys
{:to :Access,
:has-many :groups,
:has-many-aggr :groups_aggregate,
:has-one :access_access}},
:user_id
{:field-keys
{:to :User,
:has-many :groups,
:has-many-aggr :groups_aggregate,
:has-one :user}}},
:lcn-mut-keys
{:create :createGroup,
:update :updateGroup,
:delete :deleteGroup},
:lcn-obj-keys
{:rsc :Group,
:clauses :GroupClauses,
:where :GroupWhere,
:sort :GroupSort,
:fields :GroupFields,
:aggregate :GroupAggregate,
:pks :GroupPks,
:pk-input :GroupPkColumns},
:lcn-qry-keys
{:queries :groups, :aggregate :groups_aggregate},
:lcn-descs
{:rsc "Groups",
:query "Query Groups.",
:clauses
"Format for where clauses is {column: {operator: value}}. Multiple parameters are applied with `AND` operators. `AND`/`OR` conditions can be created as a list of clauses. It is possible to nest them to create sub groups of conditions.",
:sort "Sort format is {column: \"asc\" or \"desc\"}.",
:fields "Groupsfields for aggregation.",
:aggregate "Aggrecate Groups.",
:pks "Primary key fields.",
:pk-input "Primary key fields."},
:signals
{:query {:pre (), :post ()},
:create {:pre (), :post ()},
:delete {:pre (), :post ()},
:update {:pre (), :post ()}},
:pk-keys (:id),
:col-keys
#{:description
:title
:id
:user_id
:access
:edited_at
:created_at}},
:signals
{:query {:pre (), :post ()},
:create {:pre (), :post ()},
:delete {:pre (), :post ()},
:update {:pre (), :post ()}},
:pk-keys (:id),
:col-keys
#{:can_read
:inherit
:can_edit
:group_id
:id
:user_id
:role_id
:next_access
:owner}},
:groups
{:lcn-fields
{:rsc
{:access {:type Int},
:created_at {:type String},
:edited_at {:type String},
:id {:type Int},
:title {:type String},
:user_id {:type String},
:description {:type String}},
:clauses
{:description {:type :StrWhere},
:or {:type (list :GroupClauses)},
:title {:type :StrWhere},
:id {:type :IntWhere},
:and {:type (list :GroupClauses)},
:user_id {:type :StrWhere},
:access {:type :IntWhere},
:edited_at {:type :StrWhere},
:created_at {:type :StrWhere}},
:sort
{:access {:type :SortOperator},
:created_at {:type :SortOperator},
:edited_at {:type :SortOperator},
:id {:type :SortOperator},
:title {:type :SortOperator},
:user_id {:type :SortOperator},
:description {:type :SortOperator}},
:fields
{:access {:type Int},
:created_at {:type String},
:edited_at {:type String},
:id {:type Int},
:title {:type String},
:user_id {:type String},
:description {:type String}},
:aggregate
{:count {:type Int},
:sum {:type :GroupFields},
:avg {:type :GroupFields},
:max {:type :GroupFields},
:min {:type :GroupFields}},
:pks {:id {:type (non-null Int)}},
:pk-input {:id {:type (non-null Int)}},
:update
{:access {:type Int},
:created_at {:type String},
:edited_at {:type String},
:title {:type String},
:user_id {:type String},
:description {:type String}}},
:fks
{:access
{:field-keys
{:to :Access,
:has-many :groups,
:has-many-aggr :groups_aggregate,
:has-one :access_access}},
:user_id
{:field-keys
{:to :User,
:has-many :groups,
:has-many-aggr :groups_aggregate,
:has-one :user}}},
:lcn-mut-keys
{:create :createGroup,
:update :updateGroup,
:delete :deleteGroup},
:lcn-obj-keys
{:rsc :Group,
:clauses :GroupClauses,
:where :GroupWhere,
:sort :GroupSort,
:fields :GroupFields,
:aggregate :GroupAggregate,
:pks :GroupPks,
:pk-input :GroupPkColumns},
:lcn-qry-keys {:queries :groups, :aggregate :groups_aggregate},
:lcn-descs
{:rsc "Groups",
:query "Query Groups.",
:clauses
"Format for where clauses is {column: {operator: value}}. Multiple parameters are applied with `AND` operators. `AND`/`OR` conditions can be created as a list of clauses. It is possible to nest them to create sub groups of conditions.",
:sort "Sort format is {column: \"asc\" or \"desc\"}.",
:fields "Groupsfields for aggregation.",
:aggregate "Aggrecate Groups.",
:pks "Primary key fields.",
:pk-input "Primary key fields."},
:signals
{:query {:pre (), :post ()},
:create {:pre (), :post ()},
:delete {:pre (), :post ()},
:update {:pre (), :post ()}},
:pk-keys (:id),
:col-keys
#{:description
:title
:id
:user_id
:access
:edited_at
:created_at}},
:signals
{:query {:pre (), :post ()},
:create {:pre (), :post ()},
:delete {:pre (), :post ()},
:update {:pre (), :post ()}},
:pk-keys (:user_id :group_id :role_id),
:col-keys #{:group_id :user_id :role_id}}},
:signals
{:query {:pre (), :post ()},
:create {:pre (), :post ()},
:delete {:pre (), :post ()},
:update {:pre (), :post ()}},
:pk-keys (:id),
:col-keys
#{:attribute
:magnitude
:domain_pk_namespace
:id
:access
:edited_at
:right_item_id
:created_at
:left_item_id},
:users_in_groups
{:lcn-fields
{:rsc
{:group_id {:type Int},
:role_id {:type Int},
:user_id {:type String}},
:clauses
{:and {:type (list :UsersInGroupClauses)},
:or {:type (list :UsersInGroupClauses)},
:group_id {:type :IntWhere},
:role_id {:type :IntWhere},
:user_id {:type :StrWhere}},
:sort
{:group_id {:type :SortOperator},
:role_id {:type :SortOperator},
:user_id {:type :SortOperator}},
:fields
{:group_id {:type Int},
:role_id {:type Int},
:user_id {:type String}},
:aggregate
{:count {:type Int},
:sum {:type :UsersInGroupFields},
:avg {:type :UsersInGroupFields},
:max {:type :UsersInGroupFields},
:min {:type :UsersInGroupFields}},
:pks
{:user_id {:type (non-null String)},
:group_id {:type (non-null Int)},
:role_id {:type (non-null Int)}},
:pk-input
{:user_id {:type (non-null String)},
:group_id {:type (non-null Int)},
:role_id {:type (non-null Int)}},
:update {}},
:fks
{:user_id
{:field-keys
{:to :User,
:has-many :users_in_groups,
:has-many-aggr :users_in_groups_aggregate,
:has-one :user}},
:group_id
{:field-keys
{:to :Group,
:has-many :users_in_groups,
:has-many-aggr :users_in_groups_aggregate,
:has-one :group}},
:role_id
{:field-keys
{:to :Role,
:has-many :users_in_groups,
:has-many-aggr :users_in_groups_aggregate,
:has-one :role}}},
:lcn-mut-keys
{:create :createUsersInGroup,
:update :updateUsersInGroup,
:delete :deleteUsersInGroup},
:roles
{:lcn-fields
{:rsc
{:id {:type Int},
:group_id {:type Int},
:title {:type String},
:color {:type String}},
:clauses
{:and {:type (list :RoleClauses)},
:or {:type (list :RoleClauses)},
:id {:type :IntWhere},
:group_id {:type :IntWhere},
:title {:type :StrWhere},
:color {:type :StrWhere}},
:sort
{:id {:type :SortOperator},
:group_id {:type :SortOperator},
:title {:type :SortOperator},
:color {:type :SortOperator}},
:fields
{:id {:type Int},
:group_id {:type Int},
:title {:type String},
:color {:type String}},
:aggregate
{:count {:type Int},
:sum {:type :RoleFields},
:avg {:type :RoleFields},
:max {:type :RoleFields},
:min {:type :RoleFields}},
:pks {:id {:type (non-null Int)}},
:pk-input {:id {:type (non-null Int)}},
:update
{:group_id {:type Int},
:title {:type String},
:color {:type String}}},
:fks
{:group_id
{:field-keys
{:to :Group,
:has-many :roles,
:has-many-aggr :roles_aggregate,
:has-one :group}}},
:lcn-mut-keys
{:create :createRole, :update :updateRole, :delete :deleteRole},
:lcn-obj-keys
{:rsc :Role,
:clauses :RoleClauses,
:where :RoleWhere,
:sort :RoleSort,
:fields :RoleFields,
:aggregate :RoleAggregate,
:pks :RolePks,
:pk-input :RolePkColumns},
:lcn-qry-keys {:queries :roles, :aggregate :roles_aggregate},
:lcn-descs
{:rsc "Roles",
:query "Query Roles.",
:clauses
"Format for where clauses is {column: {operator: value}}. Multiple parameters are applied with `AND` operators. `AND`/`OR` conditions can be created as a list of clauses. It is possible to nest them to create sub groups of conditions.",
:sort "Sort format is {column: \"asc\" or \"desc\"}.",
:fields "Rolesfields for aggregation.",
:aggregate "Aggrecate Roles.",
:pks "Primary key fields.",
:pk-input "Primary key fields."},
:groups
{:lcn-fields
{:rsc
{:access {:type Int},
:created_at {:type String},
:edited_at {:type String},
:id {:type Int},
:title {:type String},
:user_id {:type String},
:description {:type String}},
:clauses
{:description {:type :StrWhere},
:or {:type (list :GroupClauses)},
:title {:type :StrWhere},
:id {:type :IntWhere},
:and {:type (list :GroupClauses)},
:user_id {:type :StrWhere},
:access {:type :IntWhere},
:edited_at {:type :StrWhere},
:created_at {:type :StrWhere}},
:sort
{:access {:type :SortOperator},
:created_at {:type :SortOperator},
:edited_at {:type :SortOperator},
:id {:type :SortOperator},
:title {:type :SortOperator},
:user_id {:type :SortOperator},
:description {:type :SortOperator}},
:fields
{:access {:type Int},
:created_at {:type String},
:edited_at {:type String},
:id {:type Int},
:title {:type String},
:user_id {:type String},
:description {:type String}},
:aggregate
{:count {:type Int},
:sum {:type :GroupFields},
:avg {:type :GroupFields},
:max {:type :GroupFields},
:min {:type :GroupFields}},
:pks {:id {:type (non-null Int)}},
:pk-input {:id {:type (non-null Int)}},
:update
{:access {:type Int},
:created_at {:type String},
:edited_at {:type String},
:title {:type String},
:user_id {:type String},
:description {:type String}}},
:fks
{:access
{:field-keys
{:to :Access,
:has-many :groups,
:has-many-aggr :groups_aggregate,
:has-one :access_access}},
:user_id
{:field-keys
{:to :User,
:has-many :groups,
:has-many-aggr :groups_aggregate,
:has-one :user}}},
:lcn-mut-keys
{:create :createGroup,
:update :updateGroup,
:delete :deleteGroup},
:lcn-obj-keys
{:rsc :Group,
:clauses :GroupClauses,
:where :GroupWhere,
:sort :GroupSort,
:fields :GroupFields,
:aggregate :GroupAggregate,
:pks :GroupPks,
:pk-input :GroupPkColumns},
:lcn-qry-keys {:queries :groups, :aggregate :groups_aggregate},
:lcn-descs
{:rsc "Groups",
:query "Query Groups.",
:clauses
"Format for where clauses is {column: {operator: value}}. Multiple parameters are applied with `AND` operators. `AND`/`OR` conditions can be created as a list of clauses. It is possible to nest them to create sub groups of conditions.",
:sort "Sort format is {column: \"asc\" or \"desc\"}.",
:fields "Groupsfields for aggregation.",
:aggregate "Aggrecate Groups.",
:pks "Primary key fields.",
:pk-input "Primary key fields."},
:signals
{:query {:pre (), :post ()},
:create {:pre (), :post ()},
:delete {:pre (), :post ()},
:update {:pre (), :post ()}},
:pk-keys (:id),
:col-keys
#{:description
:title
:id
:user_id
:access
:edited_at
:created_at}},
:signals
{:query {:pre (), :post ()},
:create {:pre (), :post ()},
:delete {:pre (), :post ()},
:update {:pre (), :post ()}},
:pk-keys (:id),
:col-keys #{:color :title :group_id :id}},
:lcn-obj-keys
{:rsc :UsersInGroup,
:clauses :UsersInGroupClauses,
:where :UsersInGroupWhere,
:sort :UsersInGroupSort,
:fields :UsersInGroupFields,
:aggregate :UsersInGroupAggregate,
:pks :UsersInGroupPks,
:pk-input :UsersInGroupPkColumns},
:lcn-qry-keys
{:queries :users_in_groups,
:aggregate :users_in_groups_aggregate},
:lcn-descs
{:rsc "UsersInGroups",
:query "Query UsersInGroups.",
:clauses
"Format for where clauses is {column: {operator: value}}. Multiple parameters are applied with `AND` operators. `AND`/`OR` conditions can be created as a list of clauses. It is possible to nest them to create sub groups of conditions.",
:sort "Sort format is {column: \"asc\" or \"desc\"}.",
:fields "UsersInGroupsfields for aggregation.",
:aggregate "Aggrecate UsersInGroups.",
:pks "Primary key fields.",
:pk-input "Primary key fields."},
:access
{:lcn-fields
{:rsc
{:can_read {:type Boolean},
:inherit {:type Boolean},
:can_edit {:type Boolean},
:group_id {:type Int},
:id {:type Int},
:user_id {:type String},
:role_id {:type Int},
:next_access {:type Int},
:owner {:type Boolean}},
:clauses
{:can_read {:type :BoolWhere},
:inherit {:type :BoolWhere},
:can_edit {:type :BoolWhere},
:or {:type (list :AccessClauses)},
:group_id {:type :IntWhere},
:id {:type :IntWhere},
:and {:type (list :AccessClauses)},
:user_id {:type :StrWhere},
:role_id {:type :IntWhere},
:next_access {:type :IntWhere},
:owner {:type :BoolWhere}},
:sort
{:can_read {:type :SortOperator},
:inherit {:type :SortOperator},
:can_edit {:type :SortOperator},
:group_id {:type :SortOperator},
:id {:type :SortOperator},
:user_id {:type :SortOperator},
:role_id {:type :SortOperator},
:next_access {:type :SortOperator},
:owner {:type :SortOperator}},
:fields
{:can_read {:type Boolean},
:inherit {:type Boolean},
:can_edit {:type Boolean},
:group_id {:type Int},
:id {:type Int},
:user_id {:type String},
:role_id {:type Int},
:next_access {:type Int},
:owner {:type Boolean}},
:aggregate
{:count {:type Int},
:sum {:type :AccessFields},
:avg {:type :AccessFields},
:max {:type :AccessFields},
:min {:type :AccessFields}},
:pks {:id {:type (non-null Int)}},
:pk-input {:id {:type (non-null Int)}},
:update
{:can_read {:type Boolean},
:inherit {:type Boolean},
:can_edit {:type Boolean},
:group_id {:type Int},
:user_id {:type String},
:role_id {:type Int},
:next_access {:type Int},
:owner {:type Boolean}}},
:fks
{:next_access
{:field-keys
{:to :Access,
:has-many :accesses,
:has-many-aggr :accesses_aggregate,
:has-one :next_access_access}},
:role_id
{:field-keys
{:to :Role,
:has-many :accesses,
:has-many-aggr :accesses_aggregate,
:has-one :role}},
:user_id
{:field-keys
{:to :User,
:has-many :accesses,
:has-many-aggr :accesses_aggregate,
:has-one :user}},
:group_id
{:field-keys
{:to :Group,
:has-many :accesses,
:has-many-aggr :accesses_aggregate,
:has-one :group}}},
:lcn-mut-keys
{:create :createAccess,
:update :updateAccess,
:delete :deleteAccess},
:roles
{:lcn-fields
{:rsc
{:id {:type Int},
:group_id {:type Int},
:title {:type String},
:color {:type String}},
:clauses
{:and {:type (list :RoleClauses)},
:or {:type (list :RoleClauses)},
:id {:type :IntWhere},
:group_id {:type :IntWhere},
:title {:type :StrWhere},
:color {:type :StrWhere}},
:sort
{:id {:type :SortOperator},
:group_id {:type :SortOperator},
:title {:type :SortOperator},
:color {:type :SortOperator}},
:fields
{:id {:type Int},
:group_id {:type Int},
:title {:type String},
:color {:type String}},
:aggregate
{:count {:type Int},
:sum {:type :RoleFields},
:avg {:type :RoleFields},
:max {:type :RoleFields},
:min {:type :RoleFields}},
:pks {:id {:type (non-null Int)}},
:pk-input {:id {:type (non-null Int)}},
:update
{:group_id {:type Int},
:title {:type String},
:color {:type String}}},
:fks
{:group_id
{:field-keys
{:to :Group,
:has-many :roles,
:has-many-aggr :roles_aggregate,
:has-one :group}}},
:lcn-mut-keys
{:create :createRole,
:update :updateRole,
:delete :deleteRole},
:lcn-obj-keys
{:rsc :Role,
:clauses :RoleClauses,
:where :RoleWhere,
:sort :RoleSort,
:fields :RoleFields,
:aggregate :RoleAggregate,
:pks :RolePks,
:pk-input :RolePkColumns},
:lcn-qry-keys {:queries :roles, :aggregate :roles_aggregate},
:lcn-descs
{:rsc "Roles",
:query "Query Roles.",
:clauses
"Format for where clauses is {column: {operator: value}}. Multiple parameters are applied with `AND` operators. `AND`/`OR` conditions can be created as a list of clauses. It is possible to nest them to create sub groups of conditions.",
:sort "Sort format is {column: \"asc\" or \"desc\"}.",
:fields "Rolesfields for aggregation.",
:aggregate "Aggrecate Roles.",
:pks "Primary key fields.",
:pk-input "Primary key fields."},
:groups
{:lcn-fields
{:rsc
{:access {:type Int},
:created_at {:type String},
:edited_at {:type String},
:id {:type Int},
:title {:type String},
:user_id {:type String},
:description {:type String}},
:clauses
{:description {:type :StrWhere},
:or {:type (list :GroupClauses)},
:title {:type :StrWhere},
:id {:type :IntWhere},
:and {:type (list :GroupClauses)},
:user_id {:type :StrWhere},
:access {:type :IntWhere},
:edited_at {:type :StrWhere},
:created_at {:type :StrWhere}},
:sort
{:access {:type :SortOperator},
:created_at {:type :SortOperator},
:edited_at {:type :SortOperator},
:id {:type :SortOperator},
:title {:type :SortOperator},
:user_id {:type :SortOperator},
:description {:type :SortOperator}},
:fields
{:access {:type Int},
:created_at {:type String},
:edited_at {:type String},
:id {:type Int},
:title {:type String},
:user_id {:type String},
:description {:type String}},
:aggregate
{:count {:type Int},
:sum {:type :GroupFields},
:avg {:type :GroupFields},
:max {:type :GroupFields},
:min {:type :GroupFields}},
:pks {:id {:type (non-null Int)}},
:pk-input {:id {:type (non-null Int)}},
:update
{:access {:type Int},
:created_at {:type String},
:edited_at {:type String},
:title {:type String},
:user_id {:type String},
:description {:type String}}},
:fks
{:access
{:field-keys
{:to :Access,
:has-many :groups,
:has-many-aggr :groups_aggregate,
:has-one :access_access}},
:user_id
{:field-keys
{:to :User,
:has-many :groups,
:has-many-aggr :groups_aggregate,
:has-one :user}}},
:lcn-mut-keys
{:create :createGroup,
:update :updateGroup,
:delete :deleteGroup},
:lcn-obj-keys
{:rsc :Group,
:clauses :GroupClauses,
:where :GroupWhere,
:sort :GroupSort,
:fields :GroupFields,
:aggregate :GroupAggregate,
:pks :GroupPks,
:pk-input :GroupPkColumns},
:lcn-qry-keys
{:queries :groups, :aggregate :groups_aggregate},
:lcn-descs
{:rsc "Groups",
:query "Query Groups.",
:clauses
"Format for where clauses is {column: {operator: value}}. Multiple parameters are applied with `AND` operators. `AND`/`OR` conditions can be created as a list of clauses. It is possible to nest them to create sub groups of conditions.",
:sort "Sort format is {column: \"asc\" or \"desc\"}.",
:fields "Groupsfields for aggregation.",
:aggregate "Aggrecate Groups.",
:pks "Primary key fields.",
:pk-input "Primary key fields."},
:signals
{:query {:pre (), :post ()},
:create {:pre (), :post ()},
:delete {:pre (), :post ()},
:update {:pre (), :post ()}},
:pk-keys (:id),
:col-keys
#{:description
:title
:id
:user_id
:access
:edited_at
:created_at}},
:signals
{:query {:pre (), :post ()},
:create {:pre (), :post ()},
:delete {:pre (), :post ()},
:update {:pre (), :post ()}},
:pk-keys (:id),
:col-keys #{:color :title :group_id :id}},
:lcn-obj-keys
{:rsc :Access,
:clauses :AccessClauses,
:where :AccessWhere,
:sort :AccessSort,
:fields :AccessFields,
:aggregate :AccessAggregate,
:pks :AccessPks,
:pk-input :AccessPkColumns},
:lcn-qry-keys
{:queries :accesses, :aggregate :accesses_aggregate},
:lcn-descs
{:rsc "Accesses",
:query "Query Accesses.",
:clauses
"Format for where clauses is {column: {operator: value}}. Multiple parameters are applied with `AND` operators. `AND`/`OR` conditions can be created as a list of clauses. It is possible to nest them to create sub groups of conditions.",
:sort "Sort format is {column: \"asc\" or \"desc\"}.",
:fields "Accessesfields for aggregation.",
:aggregate "Aggrecate Accesses.",
:pks "Primary key fields.",
:pk-input "Primary key fields."},
:groups
{:lcn-fields
{:rsc
{:access {:type Int},
:created_at {:type String},
:edited_at {:type String},
:id {:type Int},
:title {:type String},
:user_id {:type String},
:description {:type String}},
:clauses
{:description {:type :StrWhere},
:or {:type (list :GroupClauses)},
:title {:type :StrWhere},
:id {:type :IntWhere},
:and {:type (list :GroupClauses)},
:user_id {:type :StrWhere},
:access {:type :IntWhere},
:edited_at {:type :StrWhere},
:created_at {:type :StrWhere}},
:sort
{:access {:type :SortOperator},
:created_at {:type :SortOperator},
:edited_at {:type :SortOperator},
:id {:type :SortOperator},
:title {:type :SortOperator},
:user_id {:type :SortOperator},
:description {:type :SortOperator}},
:fields
{:access {:type Int},
:created_at {:type String},
:edited_at {:type String},
:id {:type Int},
:title {:type String},
:user_id {:type String},
:description {:type String}},
:aggregate
{:count {:type Int},
:sum {:type :GroupFields},
:avg {:type :GroupFields},
:max {:type :GroupFields},
:min {:type :GroupFields}},
:pks {:id {:type (non-null Int)}},
:pk-input {:id {:type (non-null Int)}},
:update
{:access {:type Int},
:created_at {:type String},
:edited_at {:type String},
:title {:type String},
:user_id {:type String},
:description {:type String}}},
:fks
{:access
{:field-keys
{:to :Access,
:has-many :groups,
:has-many-aggr :groups_aggregate,
:has-one :access_access}},
:user_id
{:field-keys
{:to :User,
:has-many :groups,
:has-many-aggr :groups_aggregate,
:has-one :user}}},
:lcn-mut-keys
{:create :createGroup,
:update :updateGroup,
:delete :deleteGroup},
:lcn-obj-keys
{:rsc :Group,
:clauses :GroupClauses,
:where :GroupWhere,
:sort :GroupSort,
:fields :GroupFields,
:aggregate :GroupAggregate,
:pks :GroupPks,
:pk-input :GroupPkColumns},
:lcn-qry-keys {:queries :groups, :aggregate :groups_aggregate},
:lcn-descs
{:rsc "Groups",
:query "Query Groups.",
:clauses
"Format for where clauses is {column: {operator: value}}. Multiple parameters are applied with `AND` operators. `AND`/`OR` conditions can be created as a list of clauses. It is possible to nest them to create sub groups of conditions.",
:sort "Sort format is {column: \"asc\" or \"desc\"}.",
:fields "Groupsfields for aggregation.",
:aggregate "Aggrecate Groups.",
:pks "Primary key fields.",
:pk-input "Primary key fields."},
:signals
{:query {:pre (), :post ()},
:create {:pre (), :post ()},
:delete {:pre (), :post ()},
:update {:pre (), :post ()}},
:pk-keys (:id),
:col-keys
#{:description
:title
:id
:user_id
:access
:edited_at
:created_at}},
:signals
{:query {:pre (), :post ()},
:create {:pre (), :post ()},
:delete {:pre (), :post ()},
:update {:pre (), :post ()}},
:pk-keys (:id),
:col-keys
#{:can_read
:inherit
:can_edit
:group_id
:id
:user_id
:role_id
:next_access
:owner}},
:groups
{:lcn-fields
{:rsc
{:access {:type Int},
:created_at {:type String},
:edited_at {:type String},
:id {:type Int},
:title {:type String},
:user_id {:type String},
:description {:type String}},
:clauses
{:description {:type :StrWhere},
:or {:type (list :GroupClauses)},
:title {:type :StrWhere},
:id {:type :IntWhere},
:and {:type (list :GroupClauses)},
:user_id {:type :StrWhere},
:access {:type :IntWhere},
:edited_at {:type :StrWhere},
:created_at {:type :StrWhere}},
:sort
{:access {:type :SortOperator},
:created_at {:type :SortOperator},
:edited_at {:type :SortOperator},
:id {:type :SortOperator},
:title {:type :SortOperator},
:user_id {:type :SortOperator},
:description {:type :SortOperator}},
:fields
{:access {:type Int},
:created_at {:type String},
:edited_at {:type String},
:id {:type Int},
:title {:type String},
:user_id {:type String},
:description {:type String}},
:aggregate
{:count {:type Int},
:sum {:type :GroupFields},
:avg {:type :GroupFields},
:max {:type :GroupFields},
:min {:type :GroupFields}},
:pks {:id {:type (non-null Int)}},
:pk-input {:id {:type (non-null Int)}},
:update
{:access {:type Int},
:created_at {:type String},
:edited_at {:type String},
:title {:type String},
:user_id {:type String},
:description {:type String}}},
:fks
{:access
{:field-keys
{:to :Access,
:has-many :groups,
:has-many-aggr :groups_aggregate,
:has-one :access_access}},
:user_id
{:field-keys
{:to :User,
:has-many :groups,
:has-many-aggr :groups_aggregate,
:has-one :user}}},
:lcn-mut-keys
{:create :createGroup,
:update :updateGroup,
:delete :deleteGroup},
:lcn-obj-keys
{:rsc :Group,
:clauses :GroupClauses,
:where :GroupWhere,
:sort :GroupSort,
:fields :GroupFields,
:aggregate :GroupAggregate,
:pks :GroupPks,
:pk-input :GroupPkColumns},
:lcn-qry-keys {:queries :groups, :aggregate :groups_aggregate},
:lcn-descs
{:rsc "Groups",
:query "Query Groups.",
:clauses
"Format for where clauses is {column: {operator: value}}. Multiple parameters are applied with `AND` operators. `AND`/`OR` conditions can be created as a list of clauses. It is possible to nest them to create sub groups of conditions.",
:sort "Sort format is {column: \"asc\" or \"desc\"}.",
:fields "Groupsfields for aggregation.",
:aggregate "Aggrecate Groups.",
:pks "Primary key fields.",
:pk-input "Primary key fields."},
:signals
{:query {:pre (), :post ()},
:create {:pre (), :post ()},
:delete {:pre (), :post ()},
:update {:pre (), :post ()}},
:pk-keys (:id),
:col-keys
#{:description
:title
:id
:user_id
:access
:edited_at
:created_at}},
:signals
{:query {:pre (), :post ()},
:create {:pre (), :post ()},
:delete {:pre (), :post ()},
:update {:pre (), :post ()}},
:pk-keys (:user_id :group_id :role_id),
:col-keys #{:group_id :user_id :role_id}}},
:fks {},
:lcn-mut-keys
{:create :createUser, :update :updateUser, :delete :deleteUser},
:roles
{:lcn-fields
{:rsc
{:id {:type Int},
:group_id {:type Int},
:title {:type String},
:color {:type String}},
:clauses
{:and {:type (list :RoleClauses)},
:or {:type (list :RoleClauses)},
:id {:type :IntWhere},
:group_id {:type :IntWhere},
:title {:type :StrWhere},
:color {:type :StrWhere}},
:sort
{:id {:type :SortOperator},
:group_id {:type :SortOperator},
:title {:type :SortOperator},
:color {:type :SortOperator}},
:fields
{:id {:type Int},
:group_id {:type Int},
:title {:type String},
:color {:type String}},
:aggregate
{:count {:type Int},
:sum {:type :RoleFields},
:avg {:type :RoleFields},
:max {:type :RoleFields},
:min {:type :RoleFields}},
:pks {:id {:type (non-null Int)}},
:pk-input {:id {:type (non-null Int)}},
:update
{:group_id {:type Int},
:title {:type String},
:color {:type String}}},
:fks
{:group_id
{:field-keys
{:to :Group,
:has-many :roles,
:has-many-aggr :roles_aggregate,
:has-one :group}}},
:lcn-mut-keys
{:create :createRole, :update :updateRole, :delete :deleteRole},
:lcn-obj-keys
{:rsc :Role,
:clauses :RoleClauses,
:where :RoleWhere,
:sort :RoleSort,
:fields :RoleFields,
:aggregate :RoleAggregate,
:pks :RolePks,
:pk-input :RolePkColumns},
:lcn-qry-keys {:queries :roles, :aggregate :roles_aggregate},
:lcn-descs
{:rsc "Roles",
:query "Query Roles.",
:clauses
"Format for where clauses is {column: {operator: value}}. Multiple parameters are applied with `AND` operators. `AND`/`OR` conditions can be created as a list of clauses. It is possible to nest them to create sub groups of conditions.",
:sort "Sort format is {column: \"asc\" or \"desc\"}.",
:fields "Rolesfields for aggregation.",
:aggregate "Aggrecate Roles.",
:pks "Primary key fields.",
:pk-input "Primary key fields."},
:groups
{:lcn-fields
{:rsc
{:access {:type Int},
:created_at {:type String},
:edited_at {:type String},
:id {:type Int},
:title {:type String},
:user_id {:type String},
:description {:type String}},
:clauses
{:description {:type :StrWhere},
:or {:type (list :GroupClauses)},
:title {:type :StrWhere},
:id {:type :IntWhere},
:and {:type (list :GroupClauses)},
:user_id {:type :StrWhere},
:access {:type :IntWhere},
:edited_at {:type :StrWhere},
:created_at {:type :StrWhere}},
:sort
{:access {:type :SortOperator},
:created_at {:type :SortOperator},
:edited_at {:type :SortOperator},
:id {:type :SortOperator},
:title {:type :SortOperator},
:user_id {:type :SortOperator},
:description {:type :SortOperator}},
:fields
{:access {:type Int},
:created_at {:type String},
:edited_at {:type String},
:id {:type Int},
:title {:type String},
:user_id {:type String},
:description {:type String}},
:aggregate
{:count {:type Int},
:sum {:type :GroupFields},
:avg {:type :GroupFields},
:max {:type :GroupFields},
:min {:type :GroupFields}},
:pks {:id {:type (non-null Int)}},
:pk-input {:id {:type (non-null Int)}},
:update
{:access {:type Int},
:created_at {:type String},
:edited_at {:type String},
:title {:type String},
:user_id {:type String},
:description {:type String}}},
:fks
{:access
{:field-keys
{:to :Access,
:has-many :groups,
:has-many-aggr :groups_aggregate,
:has-one :access_access}},
:user_id
{:field-keys
{:to :User,
:has-many :groups,
:has-many-aggr :groups_aggregate,
:has-one :user}}},
:lcn-mut-keys
{:create :createGroup,
:update :updateGroup,
:delete :deleteGroup},
:lcn-obj-keys
{:rsc :Group,
:clauses :GroupClauses,
:where :GroupWhere,
:sort :GroupSort,
:fields :GroupFields,
:aggregate :GroupAggregate,
:pks :GroupPks,
:pk-input :GroupPkColumns},
:lcn-qry-keys {:queries :groups, :aggregate :groups_aggregate},
:lcn-descs
{:rsc "Groups",
:query "Query Groups.",
:clauses
"Format for where clauses is {column: {operator: value}}. Multiple parameters are applied with `AND` operators. `AND`/`OR` conditions can be created as a list of clauses. It is possible to nest them to create sub groups of conditions.",
:sort "Sort format is {column: \"asc\" or \"desc\"}.",
:fields "Groupsfields for aggregation.",
:aggregate "Aggrecate Groups.",
:pks "Primary key fields.",
:pk-input "Primary key fields."},
:signals
{:query {:pre (), :post ()},
:create {:pre (), :post ()},
:delete {:pre (), :post ()},
:update {:pre (), :post ()}},
:pk-keys (:id),
:col-keys
#{:description
:title
:id
:user_id
:access
:edited_at
:created_at}},
:signals
{:query {:pre (), :post ()},
:create {:pre (), :post ()},
:delete {:pre (), :post ()},
:update {:pre (), :post ()}},
:pk-keys (:id),
:col-keys #{:color :title :group_id :id}},
:lcn-obj-keys
{:rsc :User,
:clauses :UserClauses,
:where :UserWhere,
:sort :UserSort,
:fields :UserFields,
:aggregate :UserAggregate,
:pks :UserPks,
:pk-input :UserPkColumns},
:lcn-qry-keys {:queries :users, :aggregate :users_aggregate},
:lcn-descs
{:rsc "Users",
:query "Query Users.",
:clauses
"Format for where clauses is {column: {operator: value}}. Multiple parameters are applied with `AND` operators. `AND`/`OR` conditions can be created as a list of clauses. It is possible to nest them to create sub groups of conditions.",
:sort "Sort format is {column: \"asc\" or \"desc\"}.",
:fields "Usersfields for aggregation.",
:aggregate "Aggrecate Users.",
:pks "Primary key fields.",
:pk-input "Primary key fields."},
:access
{:lcn-fields
{:rsc
{:can_read {:type Boolean},
:inherit {:type Boolean},
:can_edit {:type Boolean},
:group_id {:type Int},
:id {:type Int},
:user_id {:type String},
:role_id {:type Int},
:next_access {:type Int},
:owner {:type Boolean}},
:clauses
{:can_read {:type :BoolWhere},
:inherit {:type :BoolWhere},
:can_edit {:type :BoolWhere},
:or {:type (list :AccessClauses)},
:group_id {:type :IntWhere},
:id {:type :IntWhere},
:and {:type (list :AccessClauses)},
:user_id {:type :StrWhere},
:role_id {:type :IntWhere},
:next_access {:type :IntWhere},
:owner {:type :BoolWhere}},
:sort
{:can_read {:type :SortOperator},
:inherit {:type :SortOperator},
:can_edit {:type :SortOperator},
:group_id {:type :SortOperator},
:id {:type :SortOperator},
:user_id {:type :SortOperator},
:role_id {:type :SortOperator},
:next_access {:type :SortOperator},
:owner {:type :SortOperator}},
:fields
{:can_read {:type Boolean},
:inherit {:type Boolean},
:can_edit {:type Boolean},
:group_id {:type Int},
:id {:type Int},
:user_id {:type String},
:role_id {:type Int},
:next_access {:type Int},
:owner {:type Boolean}},
:aggregate
{:count {:type Int},
:sum {:type :AccessFields},
:avg {:type :AccessFields},
:max {:type :AccessFields},
:min {:type :AccessFields}},
:pks {:id {:type (non-null Int)}},
:pk-input {:id {:type (non-null Int)}},
:update
{:can_read {:type Boolean},
:inherit {:type Boolean},
:can_edit {:type Boolean},
:group_id {:type Int},
:user_id {:type String},
:role_id {:type Int},
:next_access {:type Int},
:owner {:type Boolean}}},
:fks
{:next_access
{:field-keys
{:to :Access,
:has-many :accesses,
:has-many-aggr :accesses_aggregate,
:has-one :next_access_access}},
:role_id
{:field-keys
{:to :Role,
:has-many :accesses,
:has-many-aggr :accesses_aggregate,
:has-one :role}},
:user_id
{:field-keys
{:to :User,
:has-many :accesses,
:has-many-aggr :accesses_aggregate,
:has-one :user}},
:group_id
{:field-keys
{:to :Group,
:has-many :accesses,
:has-many-aggr :accesses_aggregate,
:has-one :group}}},
:lcn-mut-keys
{:create :createAccess,
:update :updateAccess,
:delete :deleteAccess},
:roles
{:lcn-fields
{:rsc
{:id {:type Int},
:group_id {:type Int},
:title {:type String},
:color {:type String}},
:clauses
{:and {:type (list :RoleClauses)},
:or {:type (list :RoleClauses)},
:id {:type :IntWhere},
:group_id {:type :IntWhere},
:title {:type :StrWhere},
:color {:type :StrWhere}},
:sort
{:id {:type :SortOperator},
:group_id {:type :SortOperator},
:title {:type :SortOperator},
:color {:type :SortOperator}},
:fields
{:id {:type Int},
:group_id {:type Int},
:title {:type String},
:color {:type String}},
:aggregate
{:count {:type Int},
:sum {:type :RoleFields},
:avg {:type :RoleFields},
:max {:type :RoleFields},
:min {:type :RoleFields}},
:pks {:id {:type (non-null Int)}},
:pk-input {:id {:type (non-null Int)}},
:update
{:group_id {:type Int},
:title {:type String},
:color {:type String}}},
:fks
{:group_id
{:field-keys
{:to :Group,
:has-many :roles,
:has-many-aggr :roles_aggregate,
:has-one :group}}},
:lcn-mut-keys
{:create :createRole, :update :updateRole, :delete :deleteRole},
:lcn-obj-keys
{:rsc :Role,
:clauses :RoleClauses,
:where :RoleWhere,
:sort :RoleSort,
:fields :RoleFields,
:aggregate :RoleAggregate,
:pks :RolePks,
:pk-input :RolePkColumns},
:lcn-qry-keys {:queries :roles, :aggregate :roles_aggregate},
:lcn-descs
{:rsc "Roles",
:query "Query Roles.",
:clauses
"Format for where clauses is {column: {operator: value}}. Multiple parameters are applied with `AND` operators. `AND`/`OR` conditions can be created as a list of clauses. It is possible to nest them to create sub groups of conditions.",
:sort "Sort format is {column: \"asc\" or \"desc\"}.",
:fields "Rolesfields for aggregation.",
:aggregate "Aggrecate Roles.",
:pks "Primary key fields.",
:pk-input "Primary key fields."},
:groups
{:lcn-fields
{:rsc
{:access {:type Int},
:created_at {:type String},
:edited_at {:type String},
:id {:type Int},
:title {:type String},
:user_id {:type String},
:description {:type String}},
:clauses
{:description {:type :StrWhere},
:or {:type (list :GroupClauses)},
:title {:type :StrWhere},
:id {:type :IntWhere},
:and {:type (list :GroupClauses)},
:user_id {:type :StrWhere},
:access {:type :IntWhere},
:edited_at {:type :StrWhere},
:created_at {:type :StrWhere}},
:sort
{:access {:type :SortOperator},
:created_at {:type :SortOperator},
:edited_at {:type :SortOperator},
:id {:type :SortOperator},
:title {:type :SortOperator},
:user_id {:type :SortOperator},
:description {:type :SortOperator}},
:fields
{:access {:type Int},
:created_at {:type String},
:edited_at {:type String},
:id {:type Int},
:title {:type String},
:user_id {:type String},
:description {:type String}},
:aggregate
{:count {:type Int},
:sum {:type :GroupFields},
:avg {:type :GroupFields},
:max {:type :GroupFields},
:min {:type :GroupFields}},
:pks {:id {:type (non-null Int)}},
:pk-input {:id {:type (non-null Int)}},
:update
{:access {:type Int},
:created_at {:type String},
:edited_at {:type String},
:title {:type String},
:user_id {:type String},
:description {:type String}}},
:fks
{:access
{:field-keys
{:to :Access,
:has-many :groups,
:has-many-aggr :groups_aggregate,
:has-one :access_access}},
:user_id
{:field-keys
{:to :User,
:has-many :groups,
:has-many-aggr :groups_aggregate,
:has-one :user}}},
:lcn-mut-keys
{:create :createGroup,
:update :updateGroup,
:delete :deleteGroup},
:lcn-obj-keys
{:rsc :Group,
:clauses :GroupClauses,
:where :GroupWhere,
:sort :GroupSort,
:fields :GroupFields,
:aggregate :GroupAggregate,
:pks :GroupPks,
:pk-input :GroupPkColumns},
:lcn-qry-keys {:queries :groups, :aggregate :groups_aggregate},
:lcn-descs
{:rsc "Groups",
:query "Query Groups.",
:clauses
"Format for where clauses is {column: {operator: value}}. Multiple parameters are applied with `AND` operators. `AND`/`OR` conditions can be created as a list of clauses. It is possible to nest them to create sub groups of conditions.",
:sort "Sort format is {column: \"asc\" or \"desc\"}.",
:fields "Groupsfields for aggregation.",
:aggregate "Aggrecate Groups.",
:pks "Primary key fields.",
:pk-input "Primary key fields."},
:signals
{:query {:pre (), :post ()},
:create {:pre (), :post ()},
:delete {:pre (), :post ()},
:update {:pre (), :post ()}},
:pk-keys (:id),
:col-keys
#{:description
:title
:id
:user_id
:access
:edited_at
:created_at}},
:signals
{:query {:pre (), :post ()},
:create {:pre (), :post ()},
:delete {:pre (), :post ()},
:update {:pre (), :post ()}},
:pk-keys (:id),
:col-keys #{:color :title :group_id :id}},
:lcn-obj-keys
{:rsc :Access,
:clauses :AccessClauses,
:where :AccessWhere,
:sort :AccessSort,
:fields :AccessFields,
:aggregate :AccessAggregate,
:pks :AccessPks,
:pk-input :AccessPkColumns},
:lcn-qry-keys
{:queries :accesses, :aggregate :accesses_aggregate},
:lcn-descs
{:rsc "Accesses",
:query "Query Accesses.",
:clauses
"Format for where clauses is {column: {operator: value}}. Multiple parameters are applied with `AND` operators. `AND`/`OR` conditions can be created as a list of clauses. It is possible to nest them to create sub groups of conditions.",
:sort "Sort format is {column: \"asc\" or \"desc\"}.",
:fields "Accessesfields for aggregation.",
:aggregate "Aggrecate Accesses.",
:pks "Primary key fields.",
:pk-input "Primary key fields."},
:groups
{:lcn-fields
{:rsc
{:access {:type Int},
:created_at {:type String},
:edited_at {:type String},
:id {:type Int},
:title {:type String},
:user_id {:type String},
:description {:type String}},
:clauses
{:description {:type :StrWhere},
:or {:type (list :GroupClauses)},
:title {:type :StrWhere},
:id {:type :IntWhere},
:and {:type (list :GroupClauses)},
:user_id {:type :StrWhere},
:access {:type :IntWhere},
:edited_at {:type :StrWhere},
:created_at {:type :StrWhere}},
:sort
{:access {:type :SortOperator},
:created_at {:type :SortOperator},
:edited_at {:type :SortOperator},
:id {:type :SortOperator},
:title {:type :SortOperator},
:user_id {:type :SortOperator},
:description {:type :SortOperator}},
:fields
{:access {:type Int},
:created_at {:type String},
:edited_at {:type String},
:id {:type Int},
:title {:type String},
:user_id {:type String},
:description {:type String}},
:aggregate
{:count {:type Int},
:sum {:type :GroupFields},
:avg {:type :GroupFields},
:max {:type :GroupFields},
:min {:type :GroupFields}},
:pks {:id {:type (non-null Int)}},
:pk-input {:id {:type (non-null Int)}},
:update
{:access {:type Int},
:created_at {:type String},
:edited_at {:type String},
:title {:type String},
:user_id {:type String},
:description {:type String}}},
:fks
{:access
{:field-keys
{:to :Access,
:has-many :groups,
:has-many-aggr :groups_aggregate,
:has-one :access_access}},
:user_id
{:field-keys
{:to :User,
:has-many :groups,
:has-many-aggr :groups_aggregate,
:has-one :user}}},
:lcn-mut-keys
{:create :createGroup,
:update :updateGroup,
:delete :deleteGroup},
:lcn-obj-keys
{:rsc :Group,
:clauses :GroupClauses,
:where :GroupWhere,
:sort :GroupSort,
:fields :GroupFields,
:aggregate :GroupAggregate,
:pks :GroupPks,
:pk-input :GroupPkColumns},
:lcn-qry-keys {:queries :groups, :aggregate :groups_aggregate},
:lcn-descs
{:rsc "Groups",
:query "Query Groups.",
:clauses
"Format for where clauses is {column: {operator: value}}. Multiple parameters are applied with `AND` operators. `AND`/`OR` conditions can be created as a list of clauses. It is possible to nest them to create sub groups of conditions.",
:sort "Sort format is {column: \"asc\" or \"desc\"}.",
:fields "Groupsfields for aggregation.",
:aggregate "Aggrecate Groups.",
:pks "Primary key fields.",
:pk-input "Primary key fields."},
:signals
{:query {:pre (), :post ()},
:create {:pre (), :post ()},
:delete {:pre (), :post ()},
:update {:pre (), :post ()}},
:pk-keys (:id),
:col-keys
#{:description
:title
:id
:user_id
:access
:edited_at
:created_at}},
:signals
{:query {:pre (), :post ()},
:create {:pre (), :post ()},
:delete {:pre (), :post ()},
:update {:pre (), :post ()}},
:pk-keys (:id),
:col-keys
#{:can_read
:inherit
:can_edit
:group_id
:id
:user_id
:role_id
:next_access
:owner}},
:groups
{:lcn-fields
{:rsc
{:access {:type Int},
:created_at {:type String},
:edited_at {:type String},
:id {:type Int},
:title {:type String},
:user_id {:type String},
:description {:type String}},
:clauses
{:description {:type :StrWhere},
:or {:type (list :GroupClauses)},
:title {:type :StrWhere},
:id {:type :IntWhere},
:and {:type (list :GroupClauses)},
:user_id {:type :StrWhere},
:access {:type :IntWhere},
:edited_at {:type :StrWhere},
:created_at {:type :StrWhere}},
:sort
{:access {:type :SortOperator},
:created_at {:type :SortOperator},
:edited_at {:type :SortOperator},
:id {:type :SortOperator},
:title {:type :SortOperator},
:user_id {:type :SortOperator},
:description {:type :SortOperator}},
:fields
{:access {:type Int},
:created_at {:type String},
:edited_at {:type String},
:id {:type Int},
:title {:type String},
:user_id {:type String},
:description {:type String}},
:aggregate
{:count {:type Int},
:sum {:type :GroupFields},
:avg {:type :GroupFields},
:max {:type :GroupFields},
:min {:type :GroupFields}},
:pks {:id {:type (non-null Int)}},
:pk-input {:id {:type (non-null Int)}},
:update
{:access {:type Int},
:created_at {:type String},
:edited_at {:type String},
:title {:type String},
:user_id {:type String},
:description {:type String}}},
:fks
{:access
{:field-keys
{:to :Access,
:has-many :groups,
:has-many-aggr :groups_aggregate,
:has-one :access_access}},
:user_id
{:field-keys
{:to :User,
:has-many :groups,
:has-many-aggr :groups_aggregate,
:has-one :user}}},
:lcn-mut-keys
{:create :createGroup,
:update :updateGroup,
:delete :deleteGroup},
:lcn-obj-keys
{:rsc :Group,
:clauses :GroupClauses,
:where :GroupWhere,
:sort :GroupSort,
:fields :GroupFields,
:aggregate :GroupAggregate,
:pks :GroupPks,
:pk-input :GroupPkColumns},
:lcn-qry-keys {:queries :groups, :aggregate :groups_aggregate},
:lcn-descs
{:rsc "Groups",
:query "Query Groups.",
:clauses
"Format for where clauses is {column: {operator: value}}. Multiple parameters are applied with `AND` operators. `AND`/`OR` conditions can be created as a list of clauses. It is possible to nest them to create sub groups of conditions.",
:sort "Sort format is {column: \"asc\" or \"desc\"}.",
:fields "Groupsfields for aggregation.",
:aggregate "Aggrecate Groups.",
:pks "Primary key fields.",
:pk-input "Primary key fields."},
:signals
{:query {:pre (), :post ()},
:create {:pre (), :post ()},
:delete {:pre (), :post ()},
:update {:pre (), :post ()}},
:pk-keys (:id),
:col-keys
#{:description
:title
:id
:user_id
:access
:edited_at
:created_at}},
:items
{:lcn-fields
{:rsc
{:slug {:type String},
:domain_pk {:type String},
:title {:type String},
:domain_pk_namespace {:type String},
:id {:type Int},
:url {:type String},
:access {:type Int},
:edited_at {:type String},
:body {:type String},
:created_at {:type String}},
:clauses
{:slug {:type :StrWhere},
:domain_pk {:type :StrWhere},
:or {:type (list :ItemClauses)},
:title {:type :StrWhere},
:domain_pk_namespace {:type :StrWhere},
:id {:type :IntWhere},
:url {:type :StrWhere},
:and {:type (list :ItemClauses)},
:access {:type :IntWhere},
:edited_at {:type :StrWhere},
:body {:type :StrWhere},
:created_at {:type :StrWhere}},
:sort
{:slug {:type :SortOperator},
:domain_pk {:type :SortOperator},
:title {:type :SortOperator},
:domain_pk_namespace {:type :SortOperator},
:id {:type :SortOperator},
:url {:type :SortOperator},
:access {:type :SortOperator},
:edited_at {:type :SortOperator},
:body {:type :SortOperator},
:created_at {:type :SortOperator}},
:fields
{:slug {:type String},
:domain_pk {:type String},
:title {:type String},
:domain_pk_namespace {:type String},
:id {:type Int},
:url {:type String},
:access {:type Int},
:edited_at {:type String},
:body {:type String},
:created_at {:type String}},
:aggregate
{:count {:type Int},
:sum {:type :ItemFields},
:avg {:type :ItemFields},
:max {:type :ItemFields},
:min {:type :ItemFields}},
:pks {:id {:type (non-null Int)}},
:pk-input {:id {:type (non-null Int)}},
:update
{:slug {:type String},
:domain_pk {:type String},
:title {:type String},
:domain_pk_namespace {:type String},
:url {:type String},
:access {:type Int},
:edited_at {:type String},
:body {:type String},
:created_at {:type String}}},
:fks
{:access
{:field-keys
{:to :Access,
:has-many :items,
:has-many-aggr :items_aggregate,
:has-one :access_access}}},
:lcn-mut-keys
{:create :createItem, :update :updateItem, :delete :deleteItem},
:roles
{:lcn-fields
{:rsc
{:id {:type Int},
:group_id {:type Int},
:title {:type String},
:color {:type String}},
:clauses
{:and {:type (list :RoleClauses)},
:or {:type (list :RoleClauses)},
:id {:type :IntWhere},
:group_id {:type :IntWhere},
:title {:type :StrWhere},
:color {:type :StrWhere}},
:sort
{:id {:type :SortOperator},
:group_id {:type :SortOperator},
:title {:type :SortOperator},
:color {:type :SortOperator}},
:fields
{:id {:type Int},
:group_id {:type Int},
:title {:type String},
:color {:type String}},
:aggregate
{:count {:type Int},
:sum {:type :RoleFields},
:avg {:type :RoleFields},
:max {:type :RoleFields},
:min {:type :RoleFields}},
:pks {:id {:type (non-null Int)}},
:pk-input {:id {:type (non-null Int)}},
:update
{:group_id {:type Int},
:title {:type String},
:color {:type String}}},
:fks
{:group_id
{:field-keys
{:to :Group,
:has-many :roles,
:has-many-aggr :roles_aggregate,
:has-one :group}}},
:lcn-mut-keys
{:create :createRole, :update :updateRole, :delete :deleteRole},
:lcn-obj-keys
{:rsc :Role,
:clauses :RoleClauses,
:where :RoleWhere,
:sort :RoleSort,
:fields :RoleFields,
:aggregate :RoleAggregate,
:pks :RolePks,
:pk-input :RolePkColumns},
:lcn-qry-keys {:queries :roles, :aggregate :roles_aggregate},
:lcn-descs
{:rsc "Roles",
:query "Query Roles.",
:clauses
"Format for where clauses is {column: {operator: value}}. Multiple parameters are applied with `AND` operators. `AND`/`OR` conditions can be created as a list of clauses. It is possible to nest them to create sub groups of conditions.",
:sort "Sort format is {column: \"asc\" or \"desc\"}.",
:fields "Rolesfields for aggregation.",
:aggregate "Aggrecate Roles.",
:pks "Primary key fields.",
:pk-input "Primary key fields."},
:groups
{:lcn-fields
{:rsc
{:access {:type Int},
:created_at {:type String},
:edited_at {:type String},
:id {:type Int},
:title {:type String},
:user_id {:type String},
:description {:type String}},
:clauses
{:description {:type :StrWhere},
:or {:type (list :GroupClauses)},
:title {:type :StrWhere},
:id {:type :IntWhere},
:and {:type (list :GroupClauses)},
:user_id {:type :StrWhere},
:access {:type :IntWhere},
:edited_at {:type :StrWhere},
:created_at {:type :StrWhere}},
:sort
{:access {:type :SortOperator},
:created_at {:type :SortOperator},
:edited_at {:type :SortOperator},
:id {:type :SortOperator},
:title {:type :SortOperator},
:user_id {:type :SortOperator},
:description {:type :SortOperator}},
:fields
{:access {:type Int},
:created_at {:type String},
:edited_at {:type String},
:id {:type Int},
:title {:type String},
:user_id {:type String},
:description {:type String}},
:aggregate
{:count {:type Int},
:sum {:type :GroupFields},
:avg {:type :GroupFields},
:max {:type :GroupFields},
:min {:type :GroupFields}},
:pks {:id {:type (non-null Int)}},
:pk-input {:id {:type (non-null Int)}},
:update
{:access {:type Int},
:created_at {:type String},
:edited_at {:type String},
:title {:type String},
:user_id {:type String},
:description {:type String}}},
:fks
{:access
{:field-keys
{:to :Access,
:has-many :groups,
:has-many-aggr :groups_aggregate,
:has-one :access_access}},
:user_id
{:field-keys
{:to :User,
:has-many :groups,
:has-many-aggr :groups_aggregate,
:has-one :user}}},
:lcn-mut-keys
{:create :createGroup,
:update :updateGroup,
:delete :deleteGroup},
:lcn-obj-keys
{:rsc :Group,
:clauses :GroupClauses,
:where :GroupWhere,
:sort :GroupSort,
:fields :GroupFields,
:aggregate :GroupAggregate,
:pks :GroupPks,
:pk-input :GroupPkColumns},
:lcn-qry-keys {:queries :groups, :aggregate :groups_aggregate},
:lcn-descs
{:rsc "Groups",
:query "Query Groups.",
:clauses
"Format for where clauses is {column: {operator: value}}. Multiple parameters are applied with `AND` operators. `AND`/`OR` conditions can be created as a list of clauses. It is possible to nest them to create sub groups of conditions.",
:sort "Sort format is {column: \"asc\" or \"desc\"}.",
:fields "Groupsfields for aggregation.",
:aggregate "Aggrecate Groups.",
:pks "Primary key fields.",
:pk-input "Primary key fields."},
:signals
{:query {:pre (), :post ()},
:create {:pre (), :post ()},
:delete {:pre (), :post ()},
:update {:pre (), :post ()}},
:pk-keys (:id),
:col-keys
#{:description
:title
:id
:user_id
:access
:edited_at
:created_at}},
:signals
{:query {:pre (), :post ()},
:create {:pre (), :post ()},
:delete {:pre (), :post ()},
:update {:pre (), :post ()}},
:pk-keys (:id),
:col-keys #{:color :title :group_id :id}},
:lcn-obj-keys
{:rsc :Item,
:clauses :ItemClauses,
:where :ItemWhere,
:sort :ItemSort,
:fields :ItemFields,
:aggregate :ItemAggregate,
:pks :ItemPks,
:pk-input :ItemPkColumns},
:lcn-qry-keys {:queries :items, :aggregate :items_aggregate},
:lcn-descs
{:rsc "Items",
:query "Query Items.",
:clauses
"Format for where clauses is {column: {operator: value}}. Multiple parameters are applied with `AND` operators. `AND`/`OR` conditions can be created as a list of clauses. It is possible to nest them to create sub groups of conditions.",
:sort "Sort format is {column: \"asc\" or \"desc\"}.",
:fields "Itemsfields for aggregation.",
:aggregate "Aggrecate Items.",
:pks "Primary key fields.",
:pk-input "Primary key fields."},
:access
{:lcn-fields
{:rsc
{:can_read {:type Boolean},
:inherit {:type Boolean},
:can_edit {:type Boolean},
:group_id {:type Int},
:id {:type Int},
:user_id {:type String},
:role_id {:type Int},
:next_access {:type Int},
:owner {:type Boolean}},
:clauses
{:can_read {:type :BoolWhere},
:inherit {:type :BoolWhere},
:can_edit {:type :BoolWhere},
:or {:type (list :AccessClauses)},
:group_id {:type :IntWhere},
:id {:type :IntWhere},
:and {:type (list :AccessClauses)},
:user_id {:type :StrWhere},
:role_id {:type :IntWhere},
:next_access {:type :IntWhere},
:owner {:type :BoolWhere}},
:sort
{:can_read {:type :SortOperator},
:inherit {:type :SortOperator},
:can_edit {:type :SortOperator},
:group_id {:type :SortOperator},
:id {:type :SortOperator},
:user_id {:type :SortOperator},
:role_id {:type :SortOperator},
:next_access {:type :SortOperator},
:owner {:type :SortOperator}},
:fields
{:can_read {:type Boolean},
:inherit {:type Boolean},
:can_edit {:type Boolean},
:group_id {:type Int},
:id {:type Int},
:user_id {:type String},
:role_id {:type Int},
:next_access {:type Int},
:owner {:type Boolean}},
:aggregate
{:count {:type Int},
:sum {:type :AccessFields},
:avg {:type :AccessFields},
:max {:type :AccessFields},
:min {:type :AccessFields}},
:pks {:id {:type (non-null Int)}},
:pk-input {:id {:type (non-null Int)}},
:update
{:can_read {:type Boolean},
:inherit {:type Boolean},
:can_edit {:type Boolean},
:group_id {:type Int},
:user_id {:type String},
:role_id {:type Int},
:next_access {:type Int},
:owner {:type Boolean}}},
:fks
{:next_access
{:field-keys
{:to :Access,
:has-many :accesses,
:has-many-aggr :accesses_aggregate,
:has-one :next_access_access}},
:role_id
{:field-keys
{:to :Role,
:has-many :accesses,
:has-many-aggr :accesses_aggregate,
:has-one :role}},
:user_id
{:field-keys
{:to :User,
:has-many :accesses,
:has-many-aggr :accesses_aggregate,
:has-one :user}},
:group_id
{:field-keys
{:to :Group,
:has-many :accesses,
:has-many-aggr :accesses_aggregate,
:has-one :group}}},
:lcn-mut-keys
{:create :createAccess,
:update :updateAccess,
:delete :deleteAccess},
:roles
{:lcn-fields
{:rsc
{:id {:type Int},
:group_id {:type Int},
:title {:type String},
:color {:type String}},
:clauses
{:and {:type (list :RoleClauses)},
:or {:type (list :RoleClauses)},
:id {:type :IntWhere},
:group_id {:type :IntWhere},
:title {:type :StrWhere},
:color {:type :StrWhere}},
:sort
{:id {:type :SortOperator},
:group_id {:type :SortOperator},
:title {:type :SortOperator},
:color {:type :SortOperator}},
:fields
{:id {:type Int},
:group_id {:type Int},
:title {:type String},
:color {:type String}},
:aggregate
{:count {:type Int},
:sum {:type :RoleFields},
:avg {:type :RoleFields},
:max {:type :RoleFields},
:min {:type :RoleFields}},
:pks {:id {:type (non-null Int)}},
:pk-input {:id {:type (non-null Int)}},
:update
{:group_id {:type Int},
:title {:type String},
:color {:type String}}},
:fks
{:group_id
{:field-keys
{:to :Group,
:has-many :roles,
:has-many-aggr :roles_aggregate,
:has-one :group}}},
:lcn-mut-keys
{:create :createRole, :update :updateRole, :delete :deleteRole},
:lcn-obj-keys
{:rsc :Role,
:clauses :RoleClauses,
:where :RoleWhere,
:sort :RoleSort,
:fields :RoleFields,
:aggregate :RoleAggregate,
:pks :RolePks,
:pk-input :RolePkColumns},
:lcn-qry-keys {:queries :roles, :aggregate :roles_aggregate},
:lcn-descs
{:rsc "Roles",
:query "Query Roles.",
:clauses
"Format for where clauses is {column: {operator: value}}. Multiple parameters are applied with `AND` operators. `AND`/`OR` conditions can be created as a list of clauses. It is possible to nest them to create sub groups of conditions.",
:sort "Sort format is {column: \"asc\" or \"desc\"}.",
:fields "Rolesfields for aggregation.",
:aggregate "Aggrecate Roles.",
:pks "Primary key fields.",
:pk-input "Primary key fields."},
:groups
{:lcn-fields
{:rsc
{:access {:type Int},
:created_at {:type String},
:edited_at {:type String},
:id {:type Int},
:title {:type String},
:user_id {:type String},
:description {:type String}},
:clauses
{:description {:type :StrWhere},
:or {:type (list :GroupClauses)},
:title {:type :StrWhere},
:id {:type :IntWhere},
:and {:type (list :GroupClauses)},
:user_id {:type :StrWhere},
:access {:type :IntWhere},
:edited_at {:type :StrWhere},
:created_at {:type :StrWhere}},
:sort
{:access {:type :SortOperator},
:created_at {:type :SortOperator},
:edited_at {:type :SortOperator},
:id {:type :SortOperator},
:title {:type :SortOperator},
:user_id {:type :SortOperator},
:description {:type :SortOperator}},
:fields
{:access {:type Int},
:created_at {:type String},
:edited_at {:type String},
:id {:type Int},
:title {:type String},
:user_id {:type String},
:description {:type String}},
:aggregate
{:count {:type Int},
:sum {:type :GroupFields},
:avg {:type :GroupFields},
:max {:type :GroupFields},
:min {:type :GroupFields}},
:pks {:id {:type (non-null Int)}},
:pk-input {:id {:type (non-null Int)}},
:update
{:access {:type Int},
:created_at {:type String},
:edited_at {:type String},
:title {:type String},
:user_id {:type String},
:description {:type String}}},
:fks
{:access
{:field-keys
{:to :Access,
:has-many :groups,
:has-many-aggr :groups_aggregate,
:has-one :access_access}},
:user_id
{:field-keys
{:to :User,
:has-many :groups,
:has-many-aggr :groups_aggregate,
:has-one :user}}},
:lcn-mut-keys
{:create :createGroup,
:update :updateGroup,
:delete :deleteGroup},
:lcn-obj-keys
{:rsc :Group,
:clauses :GroupClauses,
:where :GroupWhere,
:sort :GroupSort,
:fields :GroupFields,
:aggregate :GroupAggregate,
:pks :GroupPks,
:pk-input :GroupPkColumns},
:lcn-qry-keys {:queries :groups, :aggregate :groups_aggregate},
:lcn-descs
{:rsc "Groups",
:query "Query Groups.",
:clauses
"Format for where clauses is {column: {operator: value}}. Multiple parameters are applied with `AND` operators. `AND`/`OR` conditions can be created as a list of clauses. It is possible to nest them to create sub groups of conditions.",
:sort "Sort format is {column: \"asc\" or \"desc\"}.",
:fields "Groupsfields for aggregation.",
:aggregate "Aggrecate Groups.",
:pks "Primary key fields.",
:pk-input "Primary key fields."},
:signals
{:query {:pre (), :post ()},
:create {:pre (), :post ()},
:delete {:pre (), :post ()},
:update {:pre (), :post ()}},
:pk-keys (:id),
:col-keys
#{:description
:title
:id
:user_id
:access
:edited_at
:created_at}},
:signals
{:query {:pre (), :post ()},
:create {:pre (), :post ()},
:delete {:pre (), :post ()},
:update {:pre (), :post ()}},
:pk-keys (:id),
:col-keys #{:color :title :group_id :id}},
:lcn-obj-keys
{:rsc :Access,
:clauses :AccessClauses,
:where :AccessWhere,
:sort :AccessSort,
:fields :AccessFields,
:aggregate :AccessAggregate,
:pks :AccessPks,
:pk-input :AccessPkColumns},
:lcn-qry-keys
{:queries :accesses, :aggregate :accesses_aggregate},
:lcn-descs
{:rsc "Accesses",
:query "Query Accesses.",
:clauses
"Format for where clauses is {column: {operator: value}}. Multiple parameters are applied with `AND` operators. `AND`/`OR` conditions can be created as a list of clauses. It is possible to nest them to create sub groups of conditions.",
:sort "Sort format is {column: \"asc\" or \"desc\"}.",
:fields "Accessesfields for aggregation.",
:aggregate "Aggrecate Accesses.",
:pks "Primary key fields.",
:pk-input "Primary key fields."},
:groups
{:lcn-fields
{:rsc
{:access {:type Int},
:created_at {:type String},
:edited_at {:type String},
:id {:type Int},
:title {:type String},
:user_id {:type String},
:description {:type String}},
:clauses
{:description {:type :StrWhere},
:or {:type (list :GroupClauses)},
:title {:type :StrWhere},
:id {:type :IntWhere},
:and {:type (list :GroupClauses)},
:user_id {:type :StrWhere},
:access {:type :IntWhere},
:edited_at {:type :StrWhere},
:created_at {:type :StrWhere}},
:sort
{:access {:type :SortOperator},
:created_at {:type :SortOperator},
:edited_at {:type :SortOperator},
:id {:type :SortOperator},
:title {:type :SortOperator},
:user_id {:type :SortOperator},
:description {:type :SortOperator}},
:fields
{:access {:type Int},
:created_at {:type String},
:edited_at {:type String},
:id {:type Int},
:title {:type String},
:user_id {:type String},
:description {:type String}},
:aggregate
{:count {:type Int},
:sum {:type :GroupFields},
:avg {:type :GroupFields},
:max {:type :GroupFields},
:min {:type :GroupFields}},
:pks {:id {:type (non-null Int)}},
:pk-input {:id {:type (non-null Int)}},
:update
{:access {:type Int},
:created_at {:type String},
:edited_at {:type String},
:title {:type String},
:user_id {:type String},
:description {:type String}}},
:fks
{:access
{:field-keys
{:to :Access,
:has-many :groups,
:has-many-aggr :groups_aggregate,
:has-one :access_access}},
:user_id
{:field-keys
{:to :User,
:has-many :groups,
:has-many-aggr :groups_aggregate,
:has-one :user}}},
:lcn-mut-keys
{:create :createGroup,
:update :updateGroup,
:delete :deleteGroup},
:lcn-obj-keys
{:rsc :Group,
:clauses :GroupClauses,
:where :GroupWhere,
:sort :GroupSort,
:fields :GroupFields,
:aggregate :GroupAggregate,
:pks :GroupPks,
:pk-input :GroupPkColumns},
:lcn-qry-keys {:queries :groups, :aggregate :groups_aggregate},
:lcn-descs
{:rsc "Groups",
:query "Query Groups.",
:clauses
"Format for where clauses is {column: {operator: value}}. Multiple parameters are applied with `AND` operators. `AND`/`OR` conditions can be created as a list of clauses. It is possible to nest them to create sub groups of conditions.",
:sort "Sort format is {column: \"asc\" or \"desc\"}.",
:fields "Groupsfields for aggregation.",
:aggregate "Aggrecate Groups.",
:pks "Primary key fields.",
:pk-input "Primary key fields."},
:signals
{:query {:pre (), :post ()},
:create {:pre (), :post ()},
:delete {:pre (), :post ()},
:update {:pre (), :post ()}},
:pk-keys (:id),
:col-keys
#{:description
:title
:id
:user_id
:access
:edited_at
:created_at}},
:signals
{:query {:pre (), :post ()},
:create {:pre (), :post ()},
:delete {:pre (), :post ()},
:update {:pre (), :post ()}},
:pk-keys (:id),
:col-keys
#{:can_read
:inherit
:can_edit
:group_id
:id
:user_id
:role_id
:next_access
:owner}},
:groups
{:lcn-fields
{:rsc
{:access {:type Int},
:created_at {:type String},
:edited_at {:type String},
:id {:type Int},
:title {:type String},
:user_id {:type String},
:description {:type String}},
:clauses
{:description {:type :StrWhere},
:or {:type (list :GroupClauses)},
:title {:type :StrWhere},
:id {:type :IntWhere},
:and {:type (list :GroupClauses)},
:user_id {:type :StrWhere},
:access {:type :IntWhere},
:edited_at {:type :StrWhere},
:created_at {:type :StrWhere}},
:sort
{:access {:type :SortOperator},
:created_at {:type :SortOperator},
:edited_at {:type :SortOperator},
:id {:type :SortOperator},
:title {:type :SortOperator},
:user_id {:type :SortOperator},
:description {:type :SortOperator}},
:fields
{:access {:type Int},
:created_at {:type String},
:edited_at {:type String},
:id {:type Int},
:title {:type String},
:user_id {:type String},
:description {:type String}},
:aggregate
{:count {:type Int},
:sum {:type :GroupFields},
:avg {:type :GroupFields},
:max {:type :GroupFields},
:min {:type :GroupFields}},
:pks {:id {:type (non-null Int)}},
:pk-input {:id {:type (non-null Int)}},
:update
{:access {:type Int},
:created_at {:type String},
:edited_at {:type String},
:title {:type String},
:user_id {:type String},
:description {:type String}}},
:fks
{:access
{:field-keys
{:to :Access,
:has-many :groups,
:has-many-aggr :groups_aggregate,
:has-one :access_access}},
:user_id
{:field-keys
{:to :User,
:has-many :groups,
:has-many-aggr :groups_aggregate,
:has-one :user}}},
:lcn-mut-keys
{:create :createGroup,
:update :updateGroup,
:delete :deleteGroup},
:lcn-obj-keys
{:rsc :Group,
:clauses :GroupClauses,
:where :GroupWhere,
:sort :GroupSort,
:fields :GroupFields,
:aggregate :GroupAggregate,
:pks :GroupPks,
:pk-input :GroupPkColumns},
:lcn-qry-keys {:queries :groups, :aggregate :groups_aggregate},
:lcn-descs
{:rsc "Groups",
:query "Query Groups.",
:clauses
"Format for where clauses is {column: {operator: value}}. Multiple parameters are applied with `AND` operators. `AND`/`OR` conditions can be created as a list of clauses. It is possible to nest them to create sub groups of conditions.",
:sort "Sort format is {column: \"asc\" or \"desc\"}.",
:fields "Groupsfields for aggregation.",
:aggregate "Aggrecate Groups.",
:pks "Primary key fields.",
:pk-input "Primary key fields."},
:signals
{:query {:pre (), :post ()},
:create {:pre (), :post ()},
:delete {:pre (), :post ()},
:update {:pre (), :post ()}},
:pk-keys (:id),
:col-keys
#{:description
:title
:id
:user_id
:access
:edited_at
:created_at}},
:signals
{:query {:pre (), :post ()},
:create {:pre (), :post ()},
:delete {:pre (), :post ()},
:update {:pre (), :post ()}},
:pk-keys (:id),
:col-keys
#{:slug
:domain_pk
:title
:domain_pk_namespace
:id
:url
:access
:edited_at
:body
:created_at},
:users_in_groups
{:lcn-fields
{:rsc
{:group_id {:type Int},
:role_id {:type Int},
:user_id {:type String}},
:clauses
{:and {:type (list :UsersInGroupClauses)},
:or {:type (list :UsersInGroupClauses)},
:group_id {:type :IntWhere},
:role_id {:type :IntWhere},
:user_id {:type :StrWhere}},
:sort
{:group_id {:type :SortOperator},
:role_id {:type :SortOperator},
:user_id {:type :SortOperator}},
:fields
{:group_id {:type Int},
:role_id {:type Int},
:user_id {:type String}},
:aggregate
{:count {:type Int},
:sum {:type :UsersInGroupFields},
:avg {:type :UsersInGroupFields},
:max {:type :UsersInGroupFields},
:min {:type :UsersInGroupFields}},
:pks
{:user_id {:type (non-null String)},
:group_id {:type (non-null Int)},
:role_id {:type (non-null Int)}},
:pk-input
{:user_id {:type (non-null String)},
:group_id {:type (non-null Int)},
:role_id {:type (non-null Int)}},
:update {}},
:fks
{:user_id
{:field-keys
{:to :User,
:has-many :users_in_groups,
:has-many-aggr :users_in_groups_aggregate,
:has-one :user}},
:group_id
{:field-keys
{:to :Group,
:has-many :users_in_groups,
:has-many-aggr :users_in_groups_aggregate,
:has-one :group}},
:role_id
{:field-keys
{:to :Role,
:has-many :users_in_groups,
:has-many-aggr :users_in_groups_aggregate,
:has-one :role}}},
:lcn-mut-keys
{:create :createUsersInGroup,
:update :updateUsersInGroup,
:delete :deleteUsersInGroup},
:roles
{:lcn-fields
{:rsc
{:id {:type Int},
:group_id {:type Int},
:title {:type String},
:color {:type String}},
:clauses
{:and {:type (list :RoleClauses)},
:or {:type (list :RoleClauses)},
:id {:type :IntWhere},
:group_id {:type :IntWhere},
:title {:type :StrWhere},
:color {:type :StrWhere}},
:sort
{:id {:type :SortOperator},
:group_id {:type :SortOperator},
:title {:type :SortOperator},
:color {:type :SortOperator}},
:fields
{:id {:type Int},
:group_id {:type Int},
:title {:type String},
:color {:type String}},
:aggregate
{:count {:type Int},
:sum {:type :RoleFields},
:avg {:type :RoleFields},
:max {:type :RoleFields},
:min {:type :RoleFields}},
:pks {:id {:type (non-null Int)}},
:pk-input {:id {:type (non-null Int)}},
:update
{:group_id {:type Int},
:title {:type String},
:color {:type String}}},
:fks
{:group_id
{:field-keys
{:to :Group,
:has-many :roles,
:has-many-aggr :roles_aggregate,
:has-one :group}}},
:lcn-mut-keys
{:create :createRole, :update :updateRole, :delete :deleteRole},
:lcn-obj-keys
{:rsc :Role,
:clauses :RoleClauses,
:where :RoleWhere,
:sort :RoleSort,
:fields :RoleFields,
:aggregate :RoleAggregate,
:pks :RolePks,
:pk-input :RolePkColumns},
:lcn-qry-keys {:queries :roles, :aggregate :roles_aggregate},
:lcn-descs
{:rsc "Roles",
:query "Query Roles.",
:clauses
"Format for where clauses is {column: {operator: value}}. Multiple parameters are applied with `AND` operators. `AND`/`OR` conditions can be created as a list of clauses. It is possible to nest them to create sub groups of conditions.",
:sort "Sort format is {column: \"asc\" or \"desc\"}.",
:fields "Rolesfields for aggregation.",
:aggregate "Aggrecate Roles.",
:pks "Primary key fields.",
:pk-input "Primary key fields."},
:groups
{:lcn-fields
{:rsc
{:access {:type Int},
:created_at {:type String},
:edited_at {:type String},
:id {:type Int},
:title {:type String},
:user_id {:type String},
:description {:type String}},
:clauses
{:description {:type :StrWhere},
:or {:type (list :GroupClauses)},
:title {:type :StrWhere},
:id {:type :IntWhere},
:and {:type (list :GroupClauses)},
:user_id {:type :StrWhere},
:access {:type :IntWhere},
:edited_at {:type :StrWhere},
:created_at {:type :StrWhere}},
:sort
{:access {:type :SortOperator},
:created_at {:type :SortOperator},
:edited_at {:type :SortOperator},
:id {:type :SortOperator},
:title {:type :SortOperator},
:user_id {:type :SortOperator},
:description {:type :SortOperator}},
:fields
{:access {:type Int},
:created_at {:type String},
:edited_at {:type String},
:id {:type Int},
:title {:type String},
:user_id {:type String},
:description {:type String}},
:aggregate
{:count {:type Int},
:sum {:type :GroupFields},
:avg {:type :GroupFields},
:max {:type :GroupFields},
:min {:type :GroupFields}},
:pks {:id {:type (non-null Int)}},
:pk-input {:id {:type (non-null Int)}},
:update
{:access {:type Int},
:created_at {:type String},
:edited_at {:type String},
:title {:type String},
:user_id {:type String},
:description {:type String}}},
:fks
{:access
{:field-keys
{:to :Access,
:has-many :groups,
:has-many-aggr :groups_aggregate,
:has-one :access_access}},
:user_id
{:field-keys
{:to :User,
:has-many :groups,
:has-many-aggr :groups_aggregate,
:has-one :user}}},
:lcn-mut-keys
{:create :createGroup,
:update :updateGroup,
:delete :deleteGroup},
:lcn-obj-keys
{:rsc :Group,
:clauses :GroupClauses,
:where :GroupWhere,
:sort :GroupSort,
:fields :GroupFields,
:aggregate :GroupAggregate,
:pks :GroupPks,
:pk-input :GroupPkColumns},
:lcn-qry-keys {:queries :groups, :aggregate :groups_aggregate},
:lcn-descs
{:rsc "Groups",
:query "Query Groups.",
:clauses
"Format for where clauses is {column: {operator: value}}. Multiple parameters are applied with `AND` operators. `AND`/`OR` conditions can be created as a list of clauses. It is possible to nest them to create sub groups of conditions.",
:sort "Sort format is {column: \"asc\" or \"desc\"}.",
:fields "Groupsfields for aggregation.",
:aggregate "Aggrecate Groups.",
:pks "Primary key fields.",
:pk-input "Primary key fields."},
:signals
{:query {:pre (), :post ()},
:create {:pre (), :post ()},
:delete {:pre (), :post ()},
:update {:pre (), :post ()}},
:pk-keys (:id),
:col-keys
#{:description
:title
:id
:user_id
:access
:edited_at
:created_at}},
:signals
{:query {:pre (), :post ()},
:create {:pre (), :post ()},
:delete {:pre (), :post ()},
:update {:pre (), :post ()}},
:pk-keys (:id),
:col-keys #{:color :title :group_id :id}},
:lcn-obj-keys
{:rsc :UsersInGroup,
:clauses :UsersInGroupClauses,
:where :UsersInGroupWhere,
:sort :UsersInGroupSort,
:fields :UsersInGroupFields,
:aggregate :UsersInGroupAggregate,
:pks :UsersInGroupPks,
:pk-input :UsersInGroupPkColumns},
:lcn-qry-keys
{:queries :users_in_groups,
:aggregate :users_in_groups_aggregate},
:lcn-descs
{:rsc "UsersInGroups",
:query "Query UsersInGroups.",
:clauses
"Format for where clauses is {column: {operator: value}}. Multiple parameters are applied with `AND` operators. `AND`/`OR` conditions can be created as a list of clauses. It is possible to nest them to create sub groups of conditions.",
:sort "Sort format is {column: \"asc\" or \"desc\"}.",
:fields "UsersInGroupsfields for aggregation.",
:aggregate "Aggrecate UsersInGroups.",
:pks "Primary key fields.",
:pk-input "Primary key fields."},
:access
{:lcn-fields
{:rsc
{:can_read {:type Boolean},
:inherit {:type Boolean},
:can_edit {:type Boolean},
:group_id {:type Int},
:id {:type Int},
:user_id {:type String},
:role_id {:type Int},
:next_access {:type Int},
:owner {:type Boolean}},
:clauses
{:can_read {:type :BoolWhere},
:inherit {:type :BoolWhere},
:can_edit {:type :BoolWhere},
:or {:type (list :AccessClauses)},
:group_id {:type :IntWhere},
:id {:type :IntWhere},
:and {:type (list :AccessClauses)},
:user_id {:type :StrWhere},
:role_id {:type :IntWhere},
:next_access {:type :IntWhere},
:owner {:type :BoolWhere}},
:sort
{:can_read {:type :SortOperator},
:inherit {:type :SortOperator},
:can_edit {:type :SortOperator},
:group_id {:type :SortOperator},
:id {:type :SortOperator},
:user_id {:type :SortOperator},
:role_id {:type :SortOperator},
:next_access {:type :SortOperator},
:owner {:type :SortOperator}},
:fields
{:can_read {:type Boolean},
:inherit {:type Boolean},
:can_edit {:type Boolean},
:group_id {:type Int},
:id {:type Int},
:user_id {:type String},
:role_id {:type Int},
:next_access {:type Int},
:owner {:type Boolean}},
:aggregate
{:count {:type Int},
:sum {:type :AccessFields},
:avg {:type :AccessFields},
:max {:type :AccessFields},
:min {:type :AccessFields}},
:pks {:id {:type (non-null Int)}},
:pk-input {:id {:type (non-null Int)}},
:update
{:can_read {:type Boolean},
:inherit {:type Boolean},
:can_edit {:type Boolean},
:group_id {:type Int},
:user_id {:type String},
:role_id {:type Int},
:next_access {:type Int},
:owner {:type Boolean}}},
:fks
{:next_access
{:field-keys
{:to :Access,
:has-many :accesses,
:has-many-aggr :accesses_aggregate,
:has-one :next_access_access}},
:role_id
{:field-keys
{:to :Role,
:has-many :accesses,
:has-many-aggr :accesses_aggregate,
:has-one :role}},
:user_id
{:field-keys
{:to :User,
:has-many :accesses,
:has-many-aggr :accesses_aggregate,
:has-one :user}},
:group_id
{:field-keys
{:to :Group,
:has-many :accesses,
:has-many-aggr :accesses_aggregate,
:has-one :group}}},
:lcn-mut-keys
{:create :createAccess,
:update :updateAccess,
:delete :deleteAccess},
:roles
{:lcn-fields
{:rsc
{:id {:type Int},
:group_id {:type Int},
:title {:type String},
:color {:type String}},
:clauses
{:and {:type (list :RoleClauses)},
:or {:type (list :RoleClauses)},
:id {:type :IntWhere},
:group_id {:type :IntWhere},
:title {:type :StrWhere},
:color {:type :StrWhere}},
:sort
{:id {:type :SortOperator},
:group_id {:type :SortOperator},
:title {:type :SortOperator},
:color {:type :SortOperator}},
:fields
{:id {:type Int},
:group_id {:type Int},
:title {:type String},
:color {:type String}},
:aggregate
{:count {:type Int},
:sum {:type :RoleFields},
:avg {:type :RoleFields},
:max {:type :RoleFields},
:min {:type :RoleFields}},
:pks {:id {:type (non-null Int)}},
:pk-input {:id {:type (non-null Int)}},
:update
{:group_id {:type Int},
:title {:type String},
:color {:type String}}},
:fks
{:group_id
{:field-keys
{:to :Group,
:has-many :roles,
:has-many-aggr :roles_aggregate,
:has-one :group}}},
:lcn-mut-keys
{:create :createRole,
:update :updateRole,
:delete :deleteRole},
:lcn-obj-keys
{:rsc :Role,
:clauses :RoleClauses,
:where :RoleWhere,
:sort :RoleSort,
:fields :RoleFields,
:aggregate :RoleAggregate,
:pks :RolePks,
:pk-input :RolePkColumns},
:lcn-qry-keys {:queries :roles, :aggregate :roles_aggregate},
:lcn-descs
{:rsc "Roles",
:query "Query Roles.",
:clauses
"Format for where clauses is {column: {operator: value}}. Multiple parameters are applied with `AND` operators. `AND`/`OR` conditions can be created as a list of clauses. It is possible to nest them to create sub groups of conditions.",
:sort "Sort format is {column: \"asc\" or \"desc\"}.",
:fields "Rolesfields for aggregation.",
:aggregate "Aggrecate Roles.",
:pks "Primary key fields.",
:pk-input "Primary key fields."},
:groups
{:lcn-fields
{:rsc
{:access {:type Int},
:created_at {:type String},
:edited_at {:type String},
:id {:type Int},
:title {:type String},
:user_id {:type String},
:description {:type String}},
:clauses
{:description {:type :StrWhere},
:or {:type (list :GroupClauses)},
:title {:type :StrWhere},
:id {:type :IntWhere},
:and {:type (list :GroupClauses)},
:user_id {:type :StrWhere},
:access {:type :IntWhere},
:edited_at {:type :StrWhere},
:created_at {:type :StrWhere}},
:sort
{:access {:type :SortOperator},
:created_at {:type :SortOperator},
:edited_at {:type :SortOperator},
:id {:type :SortOperator},
:title {:type :SortOperator},
:user_id {:type :SortOperator},
:description {:type :SortOperator}},
:fields
{:access {:type Int},
:created_at {:type String},
:edited_at {:type String},
:id {:type Int},
:title {:type String},
:user_id {:type String},
:description {:type String}},
:aggregate
{:count {:type Int},
:sum {:type :GroupFields},
:avg {:type :GroupFields},
:max {:type :GroupFields},
:min {:type :GroupFields}},
:pks {:id {:type (non-null Int)}},
:pk-input {:id {:type (non-null Int)}},
:update
{:access {:type Int},
:created_at {:type String},
:edited_at {:type String},
:title {:type String},
:user_id {:type String},
:description {:type String}}},
:fks
{:access
{:field-keys
{:to :Access,
:has-many :groups,
:has-many-aggr :groups_aggregate,
:has-one :access_access}},
:user_id
{:field-keys
{:to :User,
:has-many :groups,
:has-many-aggr :groups_aggregate,
:has-one :user}}},
:lcn-mut-keys
{:create :createGroup,
:update :updateGroup,
:delete :deleteGroup},
:lcn-obj-keys
{:rsc :Group,
:clauses :GroupClauses,
:where :GroupWhere,
:sort :GroupSort,
:fields :GroupFields,
:aggregate :GroupAggregate,
:pks :GroupPks,
:pk-input :GroupPkColumns},
:lcn-qry-keys
{:queries :groups, :aggregate :groups_aggregate},
:lcn-descs
{:rsc "Groups",
:query "Query Groups.",
:clauses
"Format for where clauses is {column: {operator: value}}. Multiple parameters are applied with `AND` operators. `AND`/`OR` conditions can be created as a list of clauses. It is possible to nest them to create sub groups of conditions.",
:sort "Sort format is {column: \"asc\" or \"desc\"}.",
:fields "Groupsfields for aggregation.",
:aggregate "Aggrecate Groups.",
:pks "Primary key fields.",
:pk-input "Primary key fields."},
:signals
{:query {:pre (), :post ()},
:create {:pre (), :post ()},
:delete {:pre (), :post ()},
:update {:pre (), :post ()}},
:pk-keys (:id),
:col-keys
#{:description
:title
:id
:user_id
:access
:edited_at
:created_at}},
:signals
{:query {:pre (), :post ()},
:create {:pre (), :post ()},
:delete {:pre (), :post ()},
:update {:pre (), :post ()}},
:pk-keys (:id),
:col-keys #{:color :title :group_id :id}},
:lcn-obj-keys
{:rsc :Access,
:clauses :AccessClauses,
:where :AccessWhere,
:sort :AccessSort,
:fields :AccessFields,
:aggregate :AccessAggregate,
:pks :AccessPks,
:pk-input :AccessPkColumns},
:lcn-qry-keys
{:queries :accesses, :aggregate :accesses_aggregate},
:lcn-descs
{:rsc "Accesses",
:query "Query Accesses.",
:clauses
"Format for where clauses is {column: {operator: value}}. Multiple parameters are applied with `AND` operators. `AND`/`OR` conditions can be created as a list of clauses. It is possible to nest them to create sub groups of conditions.",
:sort "Sort format is {column: \"asc\" or \"desc\"}.",
:fields "Accessesfields for aggregation.",
:aggregate "Aggrecate Accesses.",
:pks "Primary key fields.",
:pk-input "Primary key fields."},
:groups
{:lcn-fields
{:rsc
{:access {:type Int},
:created_at {:type String},
:edited_at {:type String},
:id {:type Int},
:title {:type String},
:user_id {:type String},
:description {:type String}},
:clauses
{:description {:type :StrWhere},
:or {:type (list :GroupClauses)},
:title {:type :StrWhere},
:id {:type :IntWhere},
:and {:type (list :GroupClauses)},
:user_id {:type :StrWhere},
:access {:type :IntWhere},
:edited_at {:type :StrWhere},
:created_at {:type :StrWhere}},
:sort
{:access {:type :SortOperator},
:created_at {:type :SortOperator},
:edited_at {:type :SortOperator},
:id {:type :SortOperator},
:title {:type :SortOperator},
:user_id {:type :SortOperator},
:description {:type :SortOperator}},
:fields
{:access {:type Int},
:created_at {:type String},
:edited_at {:type String},
:id {:type Int},
:title {:type String},
:user_id {:type String},
:description {:type String}},
:aggregate
{:count {:type Int},
:sum {:type :GroupFields},
:avg {:type :GroupFields},
:max {:type :GroupFields},
:min {:type :GroupFields}},
:pks {:id {:type (non-null Int)}},
:pk-input {:id {:type (non-null Int)}},
:update
{:access {:type Int},
:created_at {:type String},
:edited_at {:type String},
:title {:type String},
:user_id {:type String},
:description {:type String}}},
:fks
{:access
{:field-keys
{:to :Access,
:has-many :groups,
:has-many-aggr :groups_aggregate,
:has-one :access_access}},
:user_id
{:field-keys
{:to :User,
:has-many :groups,
:has-many-aggr :groups_aggregate,
:has-one :user}}},
:lcn-mut-keys
{:create :createGroup,
:update :updateGroup,
:delete :deleteGroup},
:lcn-obj-keys
{:rsc :Group,
:clauses :GroupClauses,
:where :GroupWhere,
:sort :GroupSort,
:fields :GroupFields,
:aggregate :GroupAggregate,
:pks :GroupPks,
:pk-input :GroupPkColumns},
:lcn-qry-keys {:queries :groups, :aggregate :groups_aggregate},
:lcn-descs
{:rsc "Groups",
:query "Query Groups.",
:clauses
"Format for where clauses is {column: {operator: value}}. Multiple parameters are applied with `AND` operators. `AND`/`OR` conditions can be created as a list of clauses. It is possible to nest them to create sub groups of conditions.",
:sort "Sort format is {column: \"asc\" or \"desc\"}.",
:fields "Groupsfields for aggregation.",
:aggregate "Aggrecate Groups.",
:pks "Primary key fields.",
:pk-input "Primary key fields."},
:signals
{:query {:pre (), :post ()},
:create {:pre (), :post ()},
:delete {:pre (), :post ()},
:update {:pre (), :post ()}},
:pk-keys (:id),
:col-keys
#{:description
:title
:id
:user_id
:access
:edited_at
:created_at}},
:signals
{:query {:pre (), :post ()},
:create {:pre (), :post ()},
:delete {:pre (), :post ()},
:update {:pre (), :post ()}},
:pk-keys (:id),
:col-keys
#{:can_read
:inherit
:can_edit
:group_id
:id
:user_id
:role_id
:next_access
:owner}},
:groups
{:lcn-fields
{:rsc
{:access {:type Int},
:created_at {:type String},
:edited_at {:type String},
:id {:type Int},
:title {:type String},
:user_id {:type String},
:description {:type String}},
:clauses
{:description {:type :StrWhere},
:or {:type (list :GroupClauses)},
:title {:type :StrWhere},
:id {:type :IntWhere},
:and {:type (list :GroupClauses)},
:user_id {:type :StrWhere},
:access {:type :IntWhere},
:edited_at {:type :StrWhere},
:created_at {:type :StrWhere}},
:sort
{:access {:type :SortOperator},
:created_at {:type :SortOperator},
:edited_at {:type :SortOperator},
:id {:type :SortOperator},
:title {:type :SortOperator},
:user_id {:type :SortOperator},
:description {:type :SortOperator}},
:fields
{:access {:type Int},
:created_at {:type String},
:edited_at {:type String},
:id {:type Int},
:title {:type String},
:user_id {:type String},
:description {:type String}},
:aggregate
{:count {:type Int},
:sum {:type :GroupFields},
:avg {:type :GroupFields},
:max {:type :GroupFields},
:min {:type :GroupFields}},
:pks {:id {:type (non-null Int)}},
:pk-input {:id {:type (non-null Int)}},
:update
{:access {:type Int},
:created_at {:type String},
:edited_at {:type String},
:title {:type String},
:user_id {:type String},
:description {:type String}}},
:fks
{:access
{:field-keys
{:to :Access,
:has-many :groups,
:has-many-aggr :groups_aggregate,
:has-one :access_access}},
:user_id
{:field-keys
{:to :User,
:has-many :groups,
:has-many-aggr :groups_aggregate,
:has-one :user}}},
:lcn-mut-keys
{:create :createGroup,
:update :updateGroup,
:delete :deleteGroup},
:lcn-obj-keys
{:rsc :Group,
:clauses :GroupClauses,
:where :GroupWhere,
:sort :GroupSort,
:fields :GroupFields,
:aggregate :GroupAggregate,
:pks :GroupPks,
:pk-input :GroupPkColumns},
:lcn-qry-keys {:queries :groups, :aggregate :groups_aggregate},
:lcn-descs
{:rsc "Groups",
:query "Query Groups.",
:clauses
"Format for where clauses is {column: {operator: value}}. Multiple parameters are applied with `AND` operators. `AND`/`OR` conditions can be created as a list of clauses. It is possible to nest them to create sub groups of conditions.",
:sort "Sort format is {column: \"asc\" or \"desc\"}.",
:fields "Groupsfields for aggregation.",
:aggregate "Aggrecate Groups.",
:pks "Primary key fields.",
:pk-input "Primary key fields."},
:signals
{:query {:pre (), :post ()},
:create {:pre (), :post ()},
:delete {:pre (), :post ()},
:update {:pre (), :post ()}},
:pk-keys (:id),
:col-keys
#{:description
:title
:id
:user_id
:access
:edited_at
:created_at}},
:signals
{:query {:pre (), :post ()},
:create {:pre (), :post ()},
:delete {:pre (), :post ()},
:update {:pre (), :post ()}},
:pk-keys (:user_id :group_id :role_id),
:col-keys #{:group_id :user_id :role_id}}},
:attributes
{:lcn-fields
{:rsc
{:attribute_name {:type nil},
:description {:type String},
:udt_schema {:type nil},
:collation_schema {:type nil},
:numeric_scale {:type Int},
:character_set_schema {:type nil},
:dtd_identifier {:type nil},
:maximum_cardinality {:type Int},
:is_derived_reference_attribute {:type String},
:character_octet_length {:type Int},
:datetime_precision {:type Int},
:scope_catalog {:type nil},
:collation_catalog {:type nil},
:character_maximum_length {:type Int},
:is_nullable {:type String},
:character_set_catalog {:type nil},
:numeric_precision {:type Int},
:interval_type {:type String},
:udt_catalog {:type nil},
:title {:type String},
:scope_schema {:type nil},
:attribute_default {:type String},
:numeric_precision_radix {:type Int},
:interval_precision {:type Int},
:character_set_name {:type nil},
:attribute_udt_catalog {:type nil},
:id {:type Int},
:collation_name {:type nil},
:data_type {:type String},
:attribute_udt_schema {:type nil},
:access {:type Int},
:edited_at {:type String},
:scope_name {:type nil},
:udt_name {:type nil},
:created_at {:type String},
:ordinal_position {:type Int},
:attribute_udt_name {:type nil}},
:clauses
{:attribute_name {:type nil},
:description {:type :StrWhere},
:udt_schema {:type nil},
:collation_schema {:type nil},
:numeric_scale {:type :IntWhere},
:character_set_schema {:type nil},
:dtd_identifier {:type nil},
:maximum_cardinality {:type :IntWhere},
:is_derived_reference_attribute {:type :StrWhere},
:character_octet_length {:type :IntWhere},
:datetime_precision {:type :IntWhere},
:or {:type (list :AttributeClauses)},
:scope_catalog {:type nil},
:collation_catalog {:type nil},
:character_maximum_length {:type :IntWhere},
:is_nullable {:type :StrWhere},
:character_set_catalog {:type nil},
:numeric_precision {:type :IntWhere},
:interval_type {:type :StrWhere},
:udt_catalog {:type nil},
:title {:type :StrWhere},
:scope_schema {:type nil},
:attribute_default {:type :StrWhere},
:numeric_precision_radix {:type :IntWhere},
:interval_precision {:type :IntWhere},
:character_set_name {:type nil},
:attribute_udt_catalog {:type nil},
:id {:type :IntWhere},
:collation_name {:type nil},
:data_type {:type :StrWhere},
:attribute_udt_schema {:type nil},
:and {:type (list :AttributeClauses)},
:access {:type :IntWhere},
:edited_at {:type :StrWhere},
:scope_name {:type nil},
:udt_name {:type nil},
:created_at {:type :StrWhere},
:ordinal_position {:type :IntWhere},
:attribute_udt_name {:type nil}},
:sort
{:attribute_name {:type :SortOperator},
:description {:type :SortOperator},
:udt_schema {:type :SortOperator},
:collation_schema {:type :SortOperator},
:numeric_scale {:type :SortOperator},
:character_set_schema {:type :SortOperator},
:dtd_identifier {:type :SortOperator},
:maximum_cardinality {:type :SortOperator},
:is_derived_reference_attribute {:type :SortOperator},
:character_octet_length {:type :SortOperator},
:datetime_precision {:type :SortOperator},
:scope_catalog {:type :SortOperator},
:collation_catalog {:type :SortOperator},
:character_maximum_length {:type :SortOperator},
:is_nullable {:type :SortOperator},
:character_set_catalog {:type :SortOperator},
:numeric_precision {:type :SortOperator},
:interval_type {:type :SortOperator},
:udt_catalog {:type :SortOperator},
:title {:type :SortOperator},
:scope_schema {:type :SortOperator},
:attribute_default {:type :SortOperator},
:numeric_precision_radix {:type :SortOperator},
:interval_precision {:type :SortOperator},
:character_set_name {:type :SortOperator},
:attribute_udt_catalog {:type :SortOperator},
:id {:type :SortOperator},
:collation_name {:type :SortOperator},
:data_type {:type :SortOperator},
:attribute_udt_schema {:type :SortOperator},
:access {:type :SortOperator},
:edited_at {:type :SortOperator},
:scope_name {:type :SortOperator},
:udt_name {:type :SortOperator},
:created_at {:type :SortOperator},
:ordinal_position {:type :SortOperator},
:attribute_udt_name {:type :SortOperator}},
:fields
{:attribute_name {:type nil},
:description {:type String},
:udt_schema {:type nil},
:collation_schema {:type nil},
:numeric_scale {:type Int},
:character_set_schema {:type nil},
:dtd_identifier {:type nil},
:maximum_cardinality {:type Int},
:is_derived_reference_attribute {:type String},
:character_octet_length {:type Int},
:datetime_precision {:type Int},
:scope_catalog {:type nil},
:collation_catalog {:type nil},
:character_maximum_length {:type Int},
:is_nullable {:type String},
:character_set_catalog {:type nil},
:numeric_precision {:type Int},
:interval_type {:type String},
:udt_catalog {:type nil},
:title {:type String},
:scope_schema {:type nil},
:attribute_default {:type String},
:numeric_precision_radix {:type Int},
:interval_precision {:type Int},
:character_set_name {:type nil},
:attribute_udt_catalog {:type nil},
:id {:type Int},
:collation_name {:type nil},
:data_type {:type String},
:attribute_udt_schema {:type nil},
:access {:type Int},
:edited_at {:type String},
:scope_name {:type nil},
:udt_name {:type nil},
:created_at {:type String},
:ordinal_position {:type Int},
:attribute_udt_name {:type nil}},
:aggregate
{:count {:type Int},
:sum {:type :AttributeFields},
:avg {:type :AttributeFields},
:max {:type :AttributeFields},
:min {:type :AttributeFields}},
:pks {:id {:type (non-null Int)}},
:pk-input {:id {:type (non-null Int)}},
:update
{:attribute_name {:type nil},
:description {:type String},
:udt_schema {:type nil},
:collation_schema {:type nil},
:numeric_scale {:type Int},
:character_set_schema {:type nil},
:dtd_identifier {:type nil},
:maximum_cardinality {:type Int},
:is_derived_reference_attribute {:type String},
:character_octet_length {:type Int},
:datetime_precision {:type Int},
:scope_catalog {:type nil},
:collation_catalog {:type nil},
:character_maximum_length {:type Int},
:is_nullable {:type String},
:character_set_catalog {:type nil},
:numeric_precision {:type Int},
:interval_type {:type String},
:udt_catalog {:type nil},
:title {:type String},
:scope_schema {:type nil},
:attribute_default {:type String},
:numeric_precision_radix {:type Int},
:interval_precision {:type Int},
:character_set_name {:type nil},
:attribute_udt_catalog {:type nil},
:collation_name {:type nil},
:data_type {:type String},
:attribute_udt_schema {:type nil},
:access {:type Int},
:edited_at {:type String},
:scope_name {:type nil},
:udt_name {:type nil},
:created_at {:type String},
:ordinal_position {:type Int},
:attribute_udt_name {:type nil}}},
:fks
{:access
{:field-keys
{:to :Access,
:has-many :attributes,
:has-many-aggr :attributes_aggregate,
:has-one :access_access}}},
:lcn-mut-keys
{:create :createAttribute,
:update :updateAttribute,
:delete :deleteAttribute},
:roles
{:lcn-fields
{:rsc
{:id {:type Int},
:group_id {:type Int},
:title {:type String},
:color {:type String}},
:clauses
{:and {:type (list :RoleClauses)},
:or {:type (list :RoleClauses)},
:id {:type :IntWhere},
:group_id {:type :IntWhere},
:title {:type :StrWhere},
:color {:type :StrWhere}},
:sort
{:id {:type :SortOperator},
:group_id {:type :SortOperator},
:title {:type :SortOperator},
:color {:type :SortOperator}},
:fields
{:id {:type Int},
:group_id {:type Int},
:title {:type String},
:color {:type String}},
:aggregate
{:count {:type Int},
:sum {:type :RoleFields},
:avg {:type :RoleFields},
:max {:type :RoleFields},
:min {:type :RoleFields}},
:pks {:id {:type (non-null Int)}},
:pk-input {:id {:type (non-null Int)}},
:update
{:group_id {:type Int},
:title {:type String},
:color {:type String}}},
:fks
{:group_id
{:field-keys
{:to :Group,
:has-many :roles,
:has-many-aggr :roles_aggregate,
:has-one :group}}},
:lcn-mut-keys
{:create :createRole, :update :updateRole, :delete :deleteRole},
:lcn-obj-keys
{:rsc :Role,
:clauses :RoleClauses,
:where :RoleWhere,
:sort :RoleSort,
:fields :RoleFields,
:aggregate :RoleAggregate,
:pks :RolePks,
:pk-input :RolePkColumns},
:lcn-qry-keys {:queries :roles, :aggregate :roles_aggregate},
:lcn-descs
{:rsc "Roles",
:query "Query Roles.",
:clauses
"Format for where clauses is {column: {operator: value}}. Multiple parameters are applied with `AND` operators. `AND`/`OR` conditions can be created as a list of clauses. It is possible to nest them to create sub groups of conditions.",
:sort "Sort format is {column: \"asc\" or \"desc\"}.",
:fields "Rolesfields for aggregation.",
:aggregate "Aggrecate Roles.",
:pks "Primary key fields.",
:pk-input "Primary key fields."},
:groups
{:lcn-fields
{:rsc
{:access {:type Int},
:created_at {:type String},
:edited_at {:type String},
:id {:type Int},
:title {:type String},
:user_id {:type String},
:description {:type String}},
:clauses
{:description {:type :StrWhere},
:or {:type (list :GroupClauses)},
:title {:type :StrWhere},
:id {:type :IntWhere},
:and {:type (list :GroupClauses)},
:user_id {:type :StrWhere},
:access {:type :IntWhere},
:edited_at {:type :StrWhere},
:created_at {:type :StrWhere}},
:sort
{:access {:type :SortOperator},
:created_at {:type :SortOperator},
:edited_at {:type :SortOperator},
:id {:type :SortOperator},
:title {:type :SortOperator},
:user_id {:type :SortOperator},
:description {:type :SortOperator}},
:fields
{:access {:type Int},
:created_at {:type String},
:edited_at {:type String},
:id {:type Int},
:title {:type String},
:user_id {:type String},
:description {:type String}},
:aggregate
{:count {:type Int},
:sum {:type :GroupFields},
:avg {:type :GroupFields},
:max {:type :GroupFields},
:min {:type :GroupFields}},
:pks {:id {:type (non-null Int)}},
:pk-input {:id {:type (non-null Int)}},
:update
{:access {:type Int},
:created_at {:type String},
:edited_at {:type String},
:title {:type String},
:user_id {:type String},
:description {:type String}}},
:fks
{:access
{:field-keys
{:to :Access,
:has-many :groups,
:has-many-aggr :groups_aggregate,
:has-one :access_access}},
:user_id
{:field-keys
{:to :User,
:has-many :groups,
:has-many-aggr :groups_aggregate,
:has-one :user}}},
:lcn-mut-keys
{:create :createGroup,
:update :updateGroup,
:delete :deleteGroup},
:lcn-obj-keys
{:rsc :Group,
:clauses :GroupClauses,
:where :GroupWhere,
:sort :GroupSort,
:fields :GroupFields,
:aggregate :GroupAggregate,
:pks :GroupPks,
:pk-input :GroupPkColumns},
:lcn-qry-keys {:queries :groups, :aggregate :groups_aggregate},
:lcn-descs
{:rsc "Groups",
:query "Query Groups.",
:clauses
"Format for where clauses is {column: {operator: value}}. Multiple parameters are applied with `AND` operators. `AND`/`OR` conditions can be created as a list of clauses. It is possible to nest them to create sub groups of conditions.",
:sort "Sort format is {column: \"asc\" or \"desc\"}.",
:fields "Groupsfields for aggregation.",
:aggregate "Aggrecate Groups.",
:pks "Primary key fields.",
:pk-input "Primary key fields."},
:signals
{:query {:pre (), :post ()},
:create {:pre (), :post ()},
:delete {:pre (), :post ()},
:update {:pre (), :post ()}},
:pk-keys (:id),
:col-keys
#{:description
:title
:id
:user_id
:access
:edited_at
:created_at}},
:signals
{:query {:pre (), :post ()},
:create {:pre (), :post ()},
:delete {:pre (), :post ()},
:update {:pre (), :post ()}},
:pk-keys (:id),
:col-keys #{:color :title :group_id :id}},
:lcn-obj-keys
{:rsc :Attribute,
:clauses :AttributeClauses,
:where :AttributeWhere,
:sort :AttributeSort,
:fields :AttributeFields,
:aggregate :AttributeAggregate,
:pks :AttributePks,
:pk-input :AttributePkColumns},
:lcn-qry-keys
{:queries :attributes, :aggregate :attributes_aggregate},
:lcn-descs
{:rsc "Attributes",
:query "Query Attributes.",
:clauses
"Format for where clauses is {column: {operator: value}}. Multiple parameters are applied with `AND` operators. `AND`/`OR` conditions can be created as a list of clauses. It is possible to nest them to create sub groups of conditions.",
:sort "Sort format is {column: \"asc\" or \"desc\"}.",
:fields "Attributesfields for aggregation.",
:aggregate "Aggrecate Attributes.",
:pks "Primary key fields.",
:pk-input "Primary key fields."},
:access
{:lcn-fields
{:rsc
{:can_read {:type Boolean},
:inherit {:type Boolean},
:can_edit {:type Boolean},
:group_id {:type Int},
:id {:type Int},
:user_id {:type String},
:role_id {:type Int},
:next_access {:type Int},
:owner {:type Boolean}},
:clauses
{:can_read {:type :BoolWhere},
:inherit {:type :BoolWhere},
:can_edit {:type :BoolWhere},
:or {:type (list :AccessClauses)},
:group_id {:type :IntWhere},
:id {:type :IntWhere},
:and {:type (list :AccessClauses)},
:user_id {:type :StrWhere},
:role_id {:type :IntWhere},
:next_access {:type :IntWhere},
:owner {:type :BoolWhere}},
:sort
{:can_read {:type :SortOperator},
:inherit {:type :SortOperator},
:can_edit {:type :SortOperator},
:group_id {:type :SortOperator},
:id {:type :SortOperator},
:user_id {:type :SortOperator},
:role_id {:type :SortOperator},
:next_access {:type :SortOperator},
:owner {:type :SortOperator}},
:fields
{:can_read {:type Boolean},
:inherit {:type Boolean},
:can_edit {:type Boolean},
:group_id {:type Int},
:id {:type Int},
:user_id {:type String},
:role_id {:type Int},
:next_access {:type Int},
:owner {:type Boolean}},
:aggregate
{:count {:type Int},
:sum {:type :AccessFields},
:avg {:type :AccessFields},
:max {:type :AccessFields},
:min {:type :AccessFields}},
:pks {:id {:type (non-null Int)}},
:pk-input {:id {:type (non-null Int)}},
:update
{:can_read {:type Boolean},
:inherit {:type Boolean},
:can_edit {:type Boolean},
:group_id {:type Int},
:user_id {:type String},
:role_id {:type Int},
:next_access {:type Int},
:owner {:type Boolean}}},
:fks
{:next_access
{:field-keys
{:to :Access,
:has-many :accesses,
:has-many-aggr :accesses_aggregate,
:has-one :next_access_access}},
:role_id
{:field-keys
{:to :Role,
:has-many :accesses,
:has-many-aggr :accesses_aggregate,
:has-one :role}},
:user_id
{:field-keys
{:to :User,
:has-many :accesses,
:has-many-aggr :accesses_aggregate,
:has-one :user}},
:group_id
{:field-keys
{:to :Group,
:has-many :accesses,
:has-many-aggr :accesses_aggregate,
:has-one :group}}},
:lcn-mut-keys
{:create :createAccess,
:update :updateAccess,
:delete :deleteAccess},
:roles
{:lcn-fields
{:rsc
{:id {:type Int},
:group_id {:type Int},
:title {:type String},
:color {:type String}},
:clauses
{:and {:type (list :RoleClauses)},
:or {:type (list :RoleClauses)},
:id {:type :IntWhere},
:group_id {:type :IntWhere},
:title {:type :StrWhere},
:color {:type :StrWhere}},
:sort
{:id {:type :SortOperator},
:group_id {:type :SortOperator},
:title {:type :SortOperator},
:color {:type :SortOperator}},
:fields
{:id {:type Int},
:group_id {:type Int},
:title {:type String},
:color {:type String}},
:aggregate
{:count {:type Int},
:sum {:type :RoleFields},
:avg {:type :RoleFields},
:max {:type :RoleFields},
:min {:type :RoleFields}},
:pks {:id {:type (non-null Int)}},
:pk-input {:id {:type (non-null Int)}},
:update
{:group_id {:type Int},
:title {:type String},
:color {:type String}}},
:fks
{:group_id
{:field-keys
{:to :Group,
:has-many :roles,
:has-many-aggr :roles_aggregate,
:has-one :group}}},
:lcn-mut-keys
{:create :createRole, :update :updateRole, :delete :deleteRole},
:lcn-obj-keys
{:rsc :Role,
:clauses :RoleClauses,
:where :RoleWhere,
:sort :RoleSort,
:fields :RoleFields,
:aggregate :RoleAggregate,
:pks :RolePks,
:pk-input :RolePkColumns},
:lcn-qry-keys {:queries :roles, :aggregate :roles_aggregate},
:lcn-descs
{:rsc "Roles",
:query "Query Roles.",
:clauses
"Format for where clauses is {column: {operator: value}}. Multiple parameters are applied with `AND` operators. `AND`/`OR` conditions can be created as a list of clauses. It is possible to nest them to create sub groups of conditions.",
:sort "Sort format is {column: \"asc\" or \"desc\"}.",
:fields "Rolesfields for aggregation.",
:aggregate "Aggrecate Roles.",
:pks "Primary key fields.",
:pk-input "Primary key fields."},
:groups
{:lcn-fields
{:rsc
{:access {:type Int},
:created_at {:type String},
:edited_at {:type String},
:id {:type Int},
:title {:type String},
:user_id {:type String},
:description {:type String}},
:clauses
{:description {:type :StrWhere},
:or {:type (list :GroupClauses)},
:title {:type :StrWhere},
:id {:type :IntWhere},
:and {:type (list :GroupClauses)},
:user_id {:type :StrWhere},
:access {:type :IntWhere},
:edited_at {:type :StrWhere},
:created_at {:type :StrWhere}},
:sort
{:access {:type :SortOperator},
:created_at {:type :SortOperator},
:edited_at {:type :SortOperator},
:id {:type :SortOperator},
:title {:type :SortOperator},
:user_id {:type :SortOperator},
:description {:type :SortOperator}},
:fields
{:access {:type Int},
:created_at {:type String},
:edited_at {:type String},
:id {:type Int},
:title {:type String},
:user_id {:type String},
:description {:type String}},
:aggregate
{:count {:type Int},
:sum {:type :GroupFields},
:avg {:type :GroupFields},
:max {:type :GroupFields},
:min {:type :GroupFields}},
:pks {:id {:type (non-null Int)}},
:pk-input {:id {:type (non-null Int)}},
:update
{:access {:type Int},
:created_at {:type String},
:edited_at {:type String},
:title {:type String},
:user_id {:type String},
:description {:type String}}},
:fks
{:access
{:field-keys
{:to :Access,
:has-many :groups,
:has-many-aggr :groups_aggregate,
:has-one :access_access}},
:user_id
{:field-keys
{:to :User,
:has-many :groups,
:has-many-aggr :groups_aggregate,
:has-one :user}}},
:lcn-mut-keys
{:create :createGroup,
:update :updateGroup,
:delete :deleteGroup},
:lcn-obj-keys
{:rsc :Group,
:clauses :GroupClauses,
:where :GroupWhere,
:sort :GroupSort,
:fields :GroupFields,
:aggregate :GroupAggregate,
:pks :GroupPks,
:pk-input :GroupPkColumns},
:lcn-qry-keys {:queries :groups, :aggregate :groups_aggregate},
:lcn-descs
{:rsc "Groups",
:query "Query Groups.",
:clauses
"Format for where clauses is {column: {operator: value}}. Multiple parameters are applied with `AND` operators. `AND`/`OR` conditions can be created as a list of clauses. It is possible to nest them to create sub groups of conditions.",
:sort "Sort format is {column: \"asc\" or \"desc\"}.",
:fields "Groupsfields for aggregation.",
:aggregate "Aggrecate Groups.",
:pks "Primary key fields.",
:pk-input "Primary key fields."},
:signals
{:query {:pre (), :post ()},
:create {:pre (), :post ()},
:delete {:pre (), :post ()},
:update {:pre (), :post ()}},
:pk-keys (:id),
:col-keys
#{:description
:title
:id
:user_id
:access
:edited_at
:created_at}},
:signals
{:query {:pre (), :post ()},
:create {:pre (), :post ()},
:delete {:pre (), :post ()},
:update {:pre (), :post ()}},
:pk-keys (:id),
:col-keys #{:color :title :group_id :id}},
:lcn-obj-keys
{:rsc :Access,
:clauses :AccessClauses,
:where :AccessWhere,
:sort :AccessSort,
:fields :AccessFields,
:aggregate :AccessAggregate,
:pks :AccessPks,
:pk-input :AccessPkColumns},
:lcn-qry-keys
{:queries :accesses, :aggregate :accesses_aggregate},
:lcn-descs
{:rsc "Accesses",
:query "Query Accesses.",
:clauses
"Format for where clauses is {column: {operator: value}}. Multiple parameters are applied with `AND` operators. `AND`/`OR` conditions can be created as a list of clauses. It is possible to nest them to create sub groups of conditions.",
:sort "Sort format is {column: \"asc\" or \"desc\"}.",
:fields "Accessesfields for aggregation.",
:aggregate "Aggrecate Accesses.",
:pks "Primary key fields.",
:pk-input "Primary key fields."},
:groups
{:lcn-fields
{:rsc
{:access {:type Int},
:created_at {:type String},
:edited_at {:type String},
:id {:type Int},
:title {:type String},
:user_id {:type String},
:description {:type String}},
:clauses
{:description {:type :StrWhere},
:or {:type (list :GroupClauses)},
:title {:type :StrWhere},
:id {:type :IntWhere},
:and {:type (list :GroupClauses)},
:user_id {:type :StrWhere},
:access {:type :IntWhere},
:edited_at {:type :StrWhere},
:created_at {:type :StrWhere}},
:sort
{:access {:type :SortOperator},
:created_at {:type :SortOperator},
:edited_at {:type :SortOperator},
:id {:type :SortOperator},
:title {:type :SortOperator},
:user_id {:type :SortOperator},
:description {:type :SortOperator}},
:fields
{:access {:type Int},
:created_at {:type String},
:edited_at {:type String},
:id {:type Int},
:title {:type String},
:user_id {:type String},
:description {:type String}},
:aggregate
{:count {:type Int},
:sum {:type :GroupFields},
:avg {:type :GroupFields},
:max {:type :GroupFields},
:min {:type :GroupFields}},
:pks {:id {:type (non-null Int)}},
:pk-input {:id {:type (non-null Int)}},
:update
{:access {:type Int},
:created_at {:type String},
:edited_at {:type String},
:title {:type String},
:user_id {:type String},
:description {:type String}}},
:fks
{:access
{:field-keys
{:to :Access,
:has-many :groups,
:has-many-aggr :groups_aggregate,
:has-one :access_access}},
:user_id
{:field-keys
{:to :User,
:has-many :groups,
:has-many-aggr :groups_aggregate,
:has-one :user}}},
:lcn-mut-keys
{:create :createGroup,
:update :updateGroup,
:delete :deleteGroup},
:lcn-obj-keys
{:rsc :Group,
:clauses :GroupClauses,
:where :GroupWhere,
:sort :GroupSort,
:fields :GroupFields,
:aggregate :GroupAggregate,
:pks :GroupPks,
:pk-input :GroupPkColumns},
:lcn-qry-keys {:queries :groups, :aggregate :groups_aggregate},
:lcn-descs
{:rsc "Groups",
:query "Query Groups.",
:clauses
"Format for where clauses is {column: {operator: value}}. Multiple parameters are applied with `AND` operators. `AND`/`OR` conditions can be created as a list of clauses. It is possible to nest them to create sub groups of conditions.",
:sort "Sort format is {column: \"asc\" or \"desc\"}.",
:fields "Groupsfields for aggregation.",
:aggregate "Aggrecate Groups.",
:pks "Primary key fields.",
:pk-input "Primary key fields."},
:signals
{:query {:pre (), :post ()},
:create {:pre (), :post ()},
:delete {:pre (), :post ()},
:update {:pre (), :post ()}},
:pk-keys (:id),
:col-keys
#{:description
:title
:id
:user_id
:access
:edited_at
:created_at}},
:signals
{:query {:pre (), :post ()},
:create {:pre (), :post ()},
:delete {:pre (), :post ()},
:update {:pre (), :post ()}},
:pk-keys (:id),
:col-keys
#{:can_read
:inherit
:can_edit
:group_id
:id
:user_id
:role_id
:next_access
:owner}},
:groups
{:lcn-fields
{:rsc
{:access {:type Int},
:created_at {:type String},
:edited_at {:type String},
:id {:type Int},
:title {:type String},
:user_id {:type String},
:description {:type String}},
:clauses
{:description {:type :StrWhere},
:or {:type (list :GroupClauses)},
:title {:type :StrWhere},
:id {:type :IntWhere},
:and {:type (list :GroupClauses)},
:user_id {:type :StrWhere},
:access {:type :IntWhere},
:edited_at {:type :StrWhere},
:created_at {:type :StrWhere}},
:sort
{:access {:type :SortOperator},
:created_at {:type :SortOperator},
:edited_at {:type :SortOperator},
:id {:type :SortOperator},
:title {:type :SortOperator},
:user_id {:type :SortOperator},
:description {:type :SortOperator}},
:fields
{:access {:type Int},
:created_at {:type String},
:edited_at {:type String},
:id {:type Int},
:title {:type String},
:user_id {:type String},
:description {:type String}},
:aggregate
{:count {:type Int},
:sum {:type :GroupFields},
:avg {:type :GroupFields},
:max {:type :GroupFields},
:min {:type :GroupFields}},
:pks {:id {:type (non-null Int)}},
:pk-input {:id {:type (non-null Int)}},
:update
{:access {:type Int},
:created_at {:type String},
:edited_at {:type String},
:title {:type String},
:user_id {:type String},
:description {:type String}}},
:fks
{:access
{:field-keys
{:to :Access,
:has-many :groups,
:has-many-aggr :groups_aggregate,
:has-one :access_access}},
:user_id
{:field-keys
{:to :User,
:has-many :groups,
:has-many-aggr :groups_aggregate,
:has-one :user}}},
:lcn-mut-keys
{:create :createGroup,
:update :updateGroup,
:delete :deleteGroup},
:lcn-obj-keys
{:rsc :Group,
:clauses :GroupClauses,
:where :GroupWhere,
:sort :GroupSort,
:fields :GroupFields,
:aggregate :GroupAggregate,
:pks :GroupPks,
:pk-input :GroupPkColumns},
:lcn-qry-keys {:queries :groups, :aggregate :groups_aggregate},
:lcn-descs
{:rsc "Groups",
:query "Query Groups.",
:clauses
"Format for where clauses is {column: {operator: value}}. Multiple parameters are applied with `AND` operators. `AND`/`OR` conditions can be created as a list of clauses. It is possible to nest them to create sub groups of conditions.",
:sort "Sort format is {column: \"asc\" or \"desc\"}.",
:fields "Groupsfields for aggregation.",
:aggregate "Aggrecate Groups.",
:pks "Primary key fields.",
:pk-input "Primary key fields."},
:signals
{:query {:pre (), :post ()},
:create {:pre (), :post ()},
:delete {:pre (), :post ()},
:update {:pre (), :post ()}},
:pk-keys (:id),
:col-keys
#{:description
:title
:id
:user_id
:access
:edited_at
:created_at}},
:items
{:lcn-fields
{:rsc
{:slug {:type String},
:domain_pk {:type String},
:title {:type String},
:domain_pk_namespace {:type String},
:id {:type Int},
:url {:type String},
:access {:type Int},
:edited_at {:type String},
:body {:type String},
:created_at {:type String}},
:clauses
{:slug {:type :StrWhere},
:domain_pk {:type :StrWhere},
:or {:type (list :ItemClauses)},
:title {:type :StrWhere},
:domain_pk_namespace {:type :StrWhere},
:id {:type :IntWhere},
:url {:type :StrWhere},
:and {:type (list :ItemClauses)},
:access {:type :IntWhere},
:edited_at {:type :StrWhere},
:body {:type :StrWhere},
:created_at {:type :StrWhere}},
:sort
{:slug {:type :SortOperator},
:domain_pk {:type :SortOperator},
:title {:type :SortOperator},
:domain_pk_namespace {:type :SortOperator},
:id {:type :SortOperator},
:url {:type :SortOperator},
:access {:type :SortOperator},
:edited_at {:type :SortOperator},
:body {:type :SortOperator},
:created_at {:type :SortOperator}},
:fields
{:slug {:type String},
:domain_pk {:type String},
:title {:type String},
:domain_pk_namespace {:type String},
:id {:type Int},
:url {:type String},
:access {:type Int},
:edited_at {:type String},
:body {:type String},
:created_at {:type String}},
:aggregate
{:count {:type Int},
:sum {:type :ItemFields},
:avg {:type :ItemFields},
:max {:type :ItemFields},
:min {:type :ItemFields}},
:pks {:id {:type (non-null Int)}},
:pk-input {:id {:type (non-null Int)}},
:update
{:slug {:type String},
:domain_pk {:type String},
:title {:type String},
:domain_pk_namespace {:type String},
:url {:type String},
:access {:type Int},
:edited_at {:type String},
:body {:type String},
:created_at {:type String}}},
:fks
{:access
{:field-keys
{:to :Access,
:has-many :items,
:has-many-aggr :items_aggregate,
:has-one :access_access}}},
:lcn-mut-keys
{:create :createItem, :update :updateItem, :delete :deleteItem},
:roles
{:lcn-fields
{:rsc
{:id {:type Int},
:group_id {:type Int},
:title {:type String},
:color {:type String}},
:clauses
{:and {:type (list :RoleClauses)},
:or {:type (list :RoleClauses)},
:id {:type :IntWhere},
:group_id {:type :IntWhere},
:title {:type :StrWhere},
:color {:type :StrWhere}},
:sort
{:id {:type :SortOperator},
:group_id {:type :SortOperator},
:title {:type :SortOperator},
:color {:type :SortOperator}},
:fields
{:id {:type Int},
:group_id {:type Int},
:title {:type String},
:color {:type String}},
:aggregate
{:count {:type Int},
:sum {:type :RoleFields},
:avg {:type :RoleFields},
:max {:type :RoleFields},
:min {:type :RoleFields}},
:pks {:id {:type (non-null Int)}},
:pk-input {:id {:type (non-null Int)}},
:update
{:group_id {:type Int},
:title {:type String},
:color {:type String}}},
:fks
{:group_id
{:field-keys
{:to :Group,
:has-many :roles,
:has-many-aggr :roles_aggregate,
:has-one :group}}},
:lcn-mut-keys
{:create :createRole, :update :updateRole, :delete :deleteRole},
:lcn-obj-keys
{:rsc :Role,
:clauses :RoleClauses,
:where :RoleWhere,
:sort :RoleSort,
:fields :RoleFields,
:aggregate :RoleAggregate,
:pks :RolePks,
:pk-input :RolePkColumns},
:lcn-qry-keys {:queries :roles, :aggregate :roles_aggregate},
:lcn-descs
{:rsc "Roles",
:query "Query Roles.",
:clauses
"Format for where clauses is {column: {operator: value}}. Multiple parameters are applied with `AND` operators. `AND`/`OR` conditions can be created as a list of clauses. It is possible to nest them to create sub groups of conditions.",
:sort "Sort format is {column: \"asc\" or \"desc\"}.",
:fields "Rolesfields for aggregation.",
:aggregate "Aggrecate Roles.",
:pks "Primary key fields.",
:pk-input "Primary key fields."},
:groups
{:lcn-fields
{:rsc
{:access {:type Int},
:created_at {:type String},
:edited_at {:type String},
:id {:type Int},
:title {:type String},
:user_id {:type String},
:description {:type String}},
:clauses
{:description {:type :StrWhere},
:or {:type (list :GroupClauses)},
:title {:type :StrWhere},
:id {:type :IntWhere},
:and {:type (list :GroupClauses)},
:user_id {:type :StrWhere},
:access {:type :IntWhere},
:edited_at {:type :StrWhere},
:created_at {:type :StrWhere}},
:sort
{:access {:type :SortOperator},
:created_at {:type :SortOperator},
:edited_at {:type :SortOperator},
:id {:type :SortOperator},
:title {:type :SortOperator},
:user_id {:type :SortOperator},
:description {:type :SortOperator}},
:fields
{:access {:type Int},
:created_at {:type String},
:edited_at {:type String},
:id {:type Int},
:title {:type String},
:user_id {:type String},
:description {:type String}},
:aggregate
{:count {:type Int},
:sum {:type :GroupFields},
:avg {:type :GroupFields},
:max {:type :GroupFields},
:min {:type :GroupFields}},
:pks {:id {:type (non-null Int)}},
:pk-input {:id {:type (non-null Int)}},
:update
{:access {:type Int},
:created_at {:type String},
:edited_at {:type String},
:title {:type String},
:user_id {:type String},
:description {:type String}}},
:fks
{:access
{:field-keys
{:to :Access,
:has-many :groups,
:has-many-aggr :groups_aggregate,
:has-one :access_access}},
:user_id
{:field-keys
{:to :User,
:has-many :groups,
:has-many-aggr :groups_aggregate,
:has-one :user}}},
:lcn-mut-keys
{:create :createGroup,
:update :updateGroup,
:delete :deleteGroup},
:lcn-obj-keys
{:rsc :Group,
:clauses :GroupClauses,
:where :GroupWhere,
:sort :GroupSort,
:fields :GroupFields,
:aggregate :GroupAggregate,
:pks :GroupPks,
:pk-input :GroupPkColumns},
:lcn-qry-keys {:queries :groups, :aggregate :groups_aggregate},
:lcn-descs
{:rsc "Groups",
:query "Query Groups.",
:clauses
"Format for where clauses is {column: {operator: value}}. Multiple parameters are applied with `AND` operators. `AND`/`OR` conditions can be created as a list of clauses. It is possible to nest them to create sub groups of conditions.",
:sort "Sort format is {column: \"asc\" or \"desc\"}.",
:fields "Groupsfields for aggregation.",
:aggregate "Aggrecate Groups.",
:pks "Primary key fields.",
:pk-input "Primary key fields."},
:signals
{:query {:pre (), :post ()},
:create {:pre (), :post ()},
:delete {:pre (), :post ()},
:update {:pre (), :post ()}},
:pk-keys (:id),
:col-keys
#{:description
:title
:id
:user_id
:access
:edited_at
:created_at}},
:signals
{:query {:pre (), :post ()},
:create {:pre (), :post ()},
:delete {:pre (), :post ()},
:update {:pre (), :post ()}},
:pk-keys (:id),
:col-keys #{:color :title :group_id :id}},
:lcn-obj-keys
{:rsc :Item,
:clauses :ItemClauses,
:where :ItemWhere,
:sort :ItemSort,
:fields :ItemFields,
:aggregate :ItemAggregate,
:pks :ItemPks,
:pk-input :ItemPkColumns},
:lcn-qry-keys {:queries :items, :aggregate :items_aggregate},
:lcn-descs
{:rsc "Items",
:query "Query Items.",
:clauses
"Format for where clauses is {column: {operator: value}}. Multiple parameters are applied with `AND` operators. `AND`/`OR` conditions can be created as a list of clauses. It is possible to nest them to create sub groups of conditions.",
:sort "Sort format is {column: \"asc\" or \"desc\"}.",
:fields "Itemsfields for aggregation.",
:aggregate "Aggrecate Items.",
:pks "Primary key fields.",
:pk-input "Primary key fields."},
:access
{:lcn-fields
{:rsc
{:can_read {:type Boolean},
:inherit {:type Boolean},
:can_edit {:type Boolean},
:group_id {:type Int},
:id {:type Int},
:user_id {:type String},
:role_id {:type Int},
:next_access {:type Int},
:owner {:type Boolean}},
:clauses
{:can_read {:type :BoolWhere},
:inherit {:type :BoolWhere},
:can_edit {:type :BoolWhere},
:or {:type (list :AccessClauses)},
:group_id {:type :IntWhere},
:id {:type :IntWhere},
:and {:type (list :AccessClauses)},
:user_id {:type :StrWhere},
:role_id {:type :IntWhere},
:next_access {:type :IntWhere},
:owner {:type :BoolWhere}},
:sort
{:can_read {:type :SortOperator},
:inherit {:type :SortOperator},
:can_edit {:type :SortOperator},
:group_id {:type :SortOperator},
:id {:type :SortOperator},
:user_id {:type :SortOperator},
:role_id {:type :SortOperator},
:next_access {:type :SortOperator},
:owner {:type :SortOperator}},
:fields
{:can_read {:type Boolean},
:inherit {:type Boolean},
:can_edit {:type Boolean},
:group_id {:type Int},
:id {:type Int},
:user_id {:type String},
:role_id {:type Int},
:next_access {:type Int},
:owner {:type Boolean}},
:aggregate
{:count {:type Int},
:sum {:type :AccessFields},
:avg {:type :AccessFields},
:max {:type :AccessFields},
:min {:type :AccessFields}},
:pks {:id {:type (non-null Int)}},
:pk-input {:id {:type (non-null Int)}},
:update
{:can_read {:type Boolean},
:inherit {:type Boolean},
:can_edit {:type Boolean},
:group_id {:type Int},
:user_id {:type String},
:role_id {:type Int},
:next_access {:type Int},
:owner {:type Boolean}}},
:fks
{:next_access
{:field-keys
{:to :Access,
:has-many :accesses,
:has-many-aggr :accesses_aggregate,
:has-one :next_access_access}},
:role_id
{:field-keys
{:to :Role,
:has-many :accesses,
:has-many-aggr :accesses_aggregate,
:has-one :role}},
:user_id
{:field-keys
{:to :User,
:has-many :accesses,
:has-many-aggr :accesses_aggregate,
:has-one :user}},
:group_id
{:field-keys
{:to :Group,
:has-many :accesses,
:has-many-aggr :accesses_aggregate,
:has-one :group}}},
:lcn-mut-keys
{:create :createAccess,
:update :updateAccess,
:delete :deleteAccess},
:roles
{:lcn-fields
{:rsc
{:id {:type Int},
:group_id {:type Int},
:title {:type String},
:color {:type String}},
:clauses
{:and {:type (list :RoleClauses)},
:or {:type (list :RoleClauses)},
:id {:type :IntWhere},
:group_id {:type :IntWhere},
:title {:type :StrWhere},
:color {:type :StrWhere}},
:sort
{:id {:type :SortOperator},
:group_id {:type :SortOperator},
:title {:type :SortOperator},
:color {:type :SortOperator}},
:fields
{:id {:type Int},
:group_id {:type Int},
:title {:type String},
:color {:type String}},
:aggregate
{:count {:type Int},
:sum {:type :RoleFields},
:avg {:type :RoleFields},
:max {:type :RoleFields},
:min {:type :RoleFields}},
:pks {:id {:type (non-null Int)}},
:pk-input {:id {:type (non-null Int)}},
:update
{:group_id {:type Int},
:title {:type String},
:color {:type String}}},
:fks
{:group_id
{:field-keys
{:to :Group,
:has-many :roles,
:has-many-aggr :roles_aggregate,
:has-one :group}}},
:lcn-mut-keys
{:create :createRole,
:update :updateRole,
:delete :deleteRole},
:lcn-obj-keys
{:rsc :Role,
:clauses :RoleClauses,
:where :RoleWhere,
:sort :RoleSort,
:fields :RoleFields,
:aggregate :RoleAggregate,
:pks :RolePks,
:pk-input :RolePkColumns},
:lcn-qry-keys {:queries :roles, :aggregate :roles_aggregate},
:lcn-descs
{:rsc "Roles",
:query "Query Roles.",
:clauses
"Format for where clauses is {column: {operator: value}}. Multiple parameters are applied with `AND` operators. `AND`/`OR` conditions can be created as a list of clauses. It is possible to nest them to create sub groups of conditions.",
:sort "Sort format is {column: \"asc\" or \"desc\"}.",
:fields "Rolesfields for aggregation.",
:aggregate "Aggrecate Roles.",
:pks "Primary key fields.",
:pk-input "Primary key fields."},
:groups
{:lcn-fields
{:rsc
{:access {:type Int},
:created_at {:type String},
:edited_at {:type String},
:id {:type Int},
:title {:type String},
:user_id {:type String},
:description {:type String}},
:clauses
{:description {:type :StrWhere},
:or {:type (list :GroupClauses)},
:title {:type :StrWhere},
:id {:type :IntWhere},
:and {:type (list :GroupClauses)},
:user_id {:type :StrWhere},
:access {:type :IntWhere},
:edited_at {:type :StrWhere},
:created_at {:type :StrWhere}},
:sort
{:access {:type :SortOperator},
:created_at {:type :SortOperator},
:edited_at {:type :SortOperator},
:id {:type :SortOperator},
:title {:type :SortOperator},
:user_id {:type :SortOperator},
:description {:type :SortOperator}},
:fields
{:access {:type Int},
:created_at {:type String},
:edited_at {:type String},
:id {:type Int},
:title {:type String},
:user_id {:type String},
:description {:type String}},
:aggregate
{:count {:type Int},
:sum {:type :GroupFields},
:avg {:type :GroupFields},
:max {:type :GroupFields},
:min {:type :GroupFields}},
:pks {:id {:type (non-null Int)}},
:pk-input {:id {:type (non-null Int)}},
:update
{:access {:type Int},
:created_at {:type String},
:edited_at {:type String},
:title {:type String},
:user_id {:type String},
:description {:type String}}},
:fks
{:access
{:field-keys
{:to :Access,
:has-many :groups,
:has-many-aggr :groups_aggregate,
:has-one :access_access}},
:user_id
{:field-keys
{:to :User,
:has-many :groups,
:has-many-aggr :groups_aggregate,
:has-one :user}}},
:lcn-mut-keys
{:create :createGroup,
:update :updateGroup,
:delete :deleteGroup},
:lcn-obj-keys
{:rsc :Group,
:clauses :GroupClauses,
:where :GroupWhere,
:sort :GroupSort,
:fields :GroupFields,
:aggregate :GroupAggregate,
:pks :GroupPks,
:pk-input :GroupPkColumns},
:lcn-qry-keys
{:queries :groups, :aggregate :groups_aggregate},
:lcn-descs
{:rsc "Groups",
:query "Query Groups.",
:clauses
"Format for where clauses is {column: {operator: value}}. Multiple parameters are applied with `AND` operators. `AND`/`OR` conditions can be created as a list of clauses. It is possible to nest them to create sub groups of conditions.",
:sort "Sort format is {column: \"asc\" or \"desc\"}.",
:fields "Groupsfields for aggregation.",
:aggregate "Aggrecate Groups.",
:pks "Primary key fields.",
:pk-input "Primary key fields."},
:signals
{:query {:pre (), :post ()},
:create {:pre (), :post ()},
:delete {:pre (), :post ()},
:update {:pre (), :post ()}},
:pk-keys (:id),
:col-keys
#{:description
:title
:id
:user_id
:access
:edited_at
:created_at}},
:signals
{:query {:pre (), :post ()},
:create {:pre (), :post ()},
:delete {:pre (), :post ()},
:update {:pre (), :post ()}},
:pk-keys (:id),
:col-keys #{:color :title :group_id :id}},
:lcn-obj-keys
{:rsc :Access,
:clauses :AccessClauses,
:where :AccessWhere,
:sort :AccessSort,
:fields :AccessFields,
:aggregate :AccessAggregate,
:pks :AccessPks,
:pk-input :AccessPkColumns},
:lcn-qry-keys
{:queries :accesses, :aggregate :accesses_aggregate},
:lcn-descs
{:rsc "Accesses",
:query "Query Accesses.",
:clauses
"Format for where clauses is {column: {operator: value}}. Multiple parameters are applied with `AND` operators. `AND`/`OR` conditions can be created as a list of clauses. It is possible to nest them to create sub groups of conditions.",
:sort "Sort format is {column: \"asc\" or \"desc\"}.",
:fields "Accessesfields for aggregation.",
:aggregate "Aggrecate Accesses.",
:pks "Primary key fields.",
:pk-input "Primary key fields."},
:groups
{:lcn-fields
{:rsc
{:access {:type Int},
:created_at {:type String},
:edited_at {:type String},
:id {:type Int},
:title {:type String},
:user_id {:type String},
:description {:type String}},
:clauses
{:description {:type :StrWhere},
:or {:type (list :GroupClauses)},
:title {:type :StrWhere},
:id {:type :IntWhere},
:and {:type (list :GroupClauses)},
:user_id {:type :StrWhere},
:access {:type :IntWhere},
:edited_at {:type :StrWhere},
:created_at {:type :StrWhere}},
:sort
{:access {:type :SortOperator},
:created_at {:type :SortOperator},
:edited_at {:type :SortOperator},
:id {:type :SortOperator},
:title {:type :SortOperator},
:user_id {:type :SortOperator},
:description {:type :SortOperator}},
:fields
{:access {:type Int},
:created_at {:type String},
:edited_at {:type String},
:id {:type Int},
:title {:type String},
:user_id {:type String},
:description {:type String}},
:aggregate
{:count {:type Int},
:sum {:type :GroupFields},
:avg {:type :GroupFields},
:max {:type :GroupFields},
:min {:type :GroupFields}},
:pks {:id {:type (non-null Int)}},
:pk-input {:id {:type (non-null Int)}},
:update
{:access {:type Int},
:created_at {:type String},
:edited_at {:type String},
:title {:type String},
:user_id {:type String},
:description {:type String}}},
:fks
{:access
{:field-keys
{:to :Access,
:has-many :groups,
:has-many-aggr :groups_aggregate,
:has-one :access_access}},
:user_id
{:field-keys
{:to :User,
:has-many :groups,
:has-many-aggr :groups_aggregate,
:has-one :user}}},
:lcn-mut-keys
{:create :createGroup,
:update :updateGroup,
:delete :deleteGroup},
:lcn-obj-keys
{:rsc :Group,
:clauses :GroupClauses,
:where :GroupWhere,
:sort :GroupSort,
:fields :GroupFields,
:aggregate :GroupAggregate,
:pks :GroupPks,
:pk-input :GroupPkColumns},
:lcn-qry-keys {:queries :groups, :aggregate :groups_aggregate},
:lcn-descs
{:rsc "Groups",
:query "Query Groups.",
:clauses
"Format for where clauses is {column: {operator: value}}. Multiple parameters are applied with `AND` operators. `AND`/`OR` conditions can be created as a list of clauses. It is possible to nest them to create sub groups of conditions.",
:sort "Sort format is {column: \"asc\" or \"desc\"}.",
:fields "Groupsfields for aggregation.",
:aggregate "Aggrecate Groups.",
:pks "Primary key fields.",
:pk-input "Primary key fields."},
:signals
{:query {:pre (), :post ()},
:create {:pre (), :post ()},
:delete {:pre (), :post ()},
:update {:pre (), :post ()}},
:pk-keys (:id),
:col-keys
#{:description
:title
:id
:user_id
:access
:edited_at
:created_at}},
:signals
{:query {:pre (), :post ()},
:create {:pre (), :post ()},
:delete {:pre (), :post ()},
:update {:pre (), :post ()}},
:pk-keys (:id),
:col-keys
#{:can_read
:inherit
:can_edit
:group_id
:id
:user_id
:role_id
:next_access
:owner}},
:groups
{:lcn-fields
{:rsc
{:access {:type Int},
:created_at {:type String},
:edited_at {:type String},
:id {:type Int},
:title {:type String},
:user_id {:type String},
:description {:type String}},
:clauses
{:description {:type :StrWhere},
:or {:type (list :GroupClauses)},
:title {:type :StrWhere},
:id {:type :IntWhere},
:and {:type (list :GroupClauses)},
:user_id {:type :StrWhere},
:access {:type :IntWhere},
:edited_at {:type :StrWhere},
:created_at {:type :StrWhere}},
:sort
{:access {:type :SortOperator},
:created_at {:type :SortOperator},
:edited_at {:type :SortOperator},
:id {:type :SortOperator},
:title {:type :SortOperator},
:user_id {:type :SortOperator},
:description {:type :SortOperator}},
:fields
{:access {:type Int},
:created_at {:type String},
:edited_at {:type String},
:id {:type Int},
:title {:type String},
:user_id {:type String},
:description {:type String}},
:aggregate
{:count {:type Int},
:sum {:type :GroupFields},
:avg {:type :GroupFields},
:max {:type :GroupFields},
:min {:type :GroupFields}},
:pks {:id {:type (non-null Int)}},
:pk-input {:id {:type (non-null Int)}},
:update
{:access {:type Int},
:created_at {:type String},
:edited_at {:type String},
:title {:type String},
:user_id {:type String},
:description {:type String}}},
:fks
{:access
{:field-keys
{:to :Access,
:has-many :groups,
:has-many-aggr :groups_aggregate,
:has-one :access_access}},
:user_id
{:field-keys
{:to :User,
:has-many :groups,
:has-many-aggr :groups_aggregate,
:has-one :user}}},
:lcn-mut-keys
{:create :createGroup,
:update :updateGroup,
:delete :deleteGroup},
:lcn-obj-keys
{:rsc :Group,
:clauses :GroupClauses,
:where :GroupWhere,
:sort :GroupSort,
:fields :GroupFields,
:aggregate :GroupAggregate,
:pks :GroupPks,
:pk-input :GroupPkColumns},
:lcn-qry-keys {:queries :groups, :aggregate :groups_aggregate},
:lcn-descs
{:rsc "Groups",
:query "Query Groups.",
:clauses
"Format for where clauses is {column: {operator: value}}. Multiple parameters are applied with `AND` operators. `AND`/`OR` conditions can be created as a list of clauses. It is possible to nest them to create sub groups of conditions.",
:sort "Sort format is {column: \"asc\" or \"desc\"}.",
:fields "Groupsfields for aggregation.",
:aggregate "Aggrecate Groups.",
:pks "Primary key fields.",
:pk-input "Primary key fields."},
:signals
{:query {:pre (), :post ()},
:create {:pre (), :post ()},
:delete {:pre (), :post ()},
:update {:pre (), :post ()}},
:pk-keys (:id),
:col-keys
#{:description
:title
:id
:user_id
:access
:edited_at
:created_at}},
:signals
{:query {:pre (), :post ()},
:create {:pre (), :post ()},
:delete {:pre (), :post ()},
:update {:pre (), :post ()}},
:pk-keys (:id),
:col-keys
#{:slug
:domain_pk
:title
:domain_pk_namespace
:id
:url
:access
:edited_at
:body
:created_at},
:users_in_groups
{:lcn-fields
{:rsc
{:group_id {:type Int},
:role_id {:type Int},
:user_id {:type String}},
:clauses
{:and {:type (list :UsersInGroupClauses)},
:or {:type (list :UsersInGroupClauses)},
:group_id {:type :IntWhere},
:role_id {:type :IntWhere},
:user_id {:type :StrWhere}},
:sort
{:group_id {:type :SortOperator},
:role_id {:type :SortOperator},
:user_id {:type :SortOperator}},
:fields
{:group_id {:type Int},
:role_id {:type Int},
:user_id {:type String}},
:aggregate
{:count {:type Int},
:sum {:type :UsersInGroupFields},
:avg {:type :UsersInGroupFields},
:max {:type :UsersInGroupFields},
:min {:type :UsersInGroupFields}},
:pks
{:user_id {:type (non-null String)},
:group_id {:type (non-null Int)},
:role_id {:type (non-null Int)}},
:pk-input
{:user_id {:type (non-null String)},
:group_id {:type (non-null Int)},
:role_id {:type (non-null Int)}},
:update {}},
:fks
{:user_id
{:field-keys
{:to :User,
:has-many :users_in_groups,
:has-many-aggr :users_in_groups_aggregate,
:has-one :user}},
:group_id
{:field-keys
{:to :Group,
:has-many :users_in_groups,
:has-many-aggr :users_in_groups_aggregate,
:has-one :group}},
:role_id
{:field-keys
{:to :Role,
:has-many :users_in_groups,
:has-many-aggr :users_in_groups_aggregate,
:has-one :role}}},
:lcn-mut-keys
{:create :createUsersInGroup,
:update :updateUsersInGroup,
:delete :deleteUsersInGroup},
:roles
{:lcn-fields
{:rsc
{:id {:type Int},
:group_id {:type Int},
:title {:type String},
:color {:type String}},
:clauses
{:and {:type (list :RoleClauses)},
:or {:type (list :RoleClauses)},
:id {:type :IntWhere},
:group_id {:type :IntWhere},
:title {:type :StrWhere},
:color {:type :StrWhere}},
:sort
{:id {:type :SortOperator},
:group_id {:type :SortOperator},
:title {:type :SortOperator},
:color {:type :SortOperator}},
:fields
{:id {:type Int},
:group_id {:type Int},
:title {:type String},
:color {:type String}},
:aggregate
{:count {:type Int},
:sum {:type :RoleFields},
:avg {:type :RoleFields},
:max {:type :RoleFields},
:min {:type :RoleFields}},
:pks {:id {:type (non-null Int)}},
:pk-input {:id {:type (non-null Int)}},
:update
{:group_id {:type Int},
:title {:type String},
:color {:type String}}},
:fks
{:group_id
{:field-keys
{:to :Group,
:has-many :roles,
:has-many-aggr :roles_aggregate,
:has-one :group}}},
:lcn-mut-keys
{:create :createRole,
:update :updateRole,
:delete :deleteRole},
:lcn-obj-keys
{:rsc :Role,
:clauses :RoleClauses,
:where :RoleWhere,
:sort :RoleSort,
:fields :RoleFields,
:aggregate :RoleAggregate,
:pks :RolePks,
:pk-input :RolePkColumns},
:lcn-qry-keys {:queries :roles, :aggregate :roles_aggregate},
:lcn-descs
{:rsc "Roles",
:query "Query Roles.",
:clauses
"Format for where clauses is {column: {operator: value}}. Multiple parameters are applied with `AND` operators. `AND`/`OR` conditions can be created as a list of clauses. It is possible to nest them to create sub groups of conditions.",
:sort "Sort format is {column: \"asc\" or \"desc\"}.",
:fields "Rolesfields for aggregation.",
:aggregate "Aggrecate Roles.",
:pks "Primary key fields.",
:pk-input "Primary key fields."},
:groups
{:lcn-fields
{:rsc
{:access {:type Int},
:created_at {:type String},
:edited_at {:type String},
:id {:type Int},
:title {:type String},
:user_id {:type String},
:description {:type String}},
:clauses
{:description {:type :StrWhere},
:or {:type (list :GroupClauses)},
:title {:type :StrWhere},
:id {:type :IntWhere},
:and {:type (list :GroupClauses)},
:user_id {:type :StrWhere},
:access {:type :IntWhere},
:edited_at {:type :StrWhere},
:created_at {:type :StrWhere}},
:sort
{:access {:type :SortOperator},
:created_at {:type :SortOperator},
:edited_at {:type :SortOperator},
:id {:type :SortOperator},
:title {:type :SortOperator},
:user_id {:type :SortOperator},
:description {:type :SortOperator}},
:fields
{:access {:type Int},
:created_at {:type String},
:edited_at {:type String},
:id {:type Int},
:title {:type String},
:user_id {:type String},
:description {:type String}},
:aggregate
{:count {:type Int},
:sum {:type :GroupFields},
:avg {:type :GroupFields},
:max {:type :GroupFields},
:min {:type :GroupFields}},
:pks {:id {:type (non-null Int)}},
:pk-input {:id {:type (non-null Int)}},
:update
{:access {:type Int},
:created_at {:type String},
:edited_at {:type String},
:title {:type String},
:user_id {:type String},
:description {:type String}}},
:fks
{:access
{:field-keys
{:to :Access,
:has-many :groups,
:has-many-aggr :groups_aggregate,
:has-one :access_access}},
:user_id
{:field-keys
{:to :User,
:has-many :groups,
:has-many-aggr :groups_aggregate,
:has-one :user}}},
:lcn-mut-keys
{:create :createGroup,
:update :updateGroup,
:delete :deleteGroup},
:lcn-obj-keys
{:rsc :Group,
:clauses :GroupClauses,
:where :GroupWhere,
:sort :GroupSort,
:fields :GroupFields,
:aggregate :GroupAggregate,
:pks :GroupPks,
:pk-input :GroupPkColumns},
:lcn-qry-keys
{:queries :groups, :aggregate :groups_aggregate},
:lcn-descs
{:rsc "Groups",
:query "Query Groups.",
:clauses
"Format for where clauses is {column: {operator: value}}. Multiple parameters are applied with `AND` operators. `AND`/`OR` conditions can be created as a list of clauses. It is possible to nest them to create sub groups of conditions.",
:sort "Sort format is {column: \"asc\" or \"desc\"}.",
:fields "Groupsfields for aggregation.",
:aggregate "Aggrecate Groups.",
:pks "Primary key fields.",
:pk-input "Primary key fields."},
:signals
{:query {:pre (), :post ()},
:create {:pre (), :post ()},
:delete {:pre (), :post ()},
:update {:pre (), :post ()}},
:pk-keys (:id),
:col-keys
#{:description
:title
:id
:user_id
:access
:edited_at
:created_at}},
:signals
{:query {:pre (), :post ()},
:create {:pre (), :post ()},
:delete {:pre (), :post ()},
:update {:pre (), :post ()}},
:pk-keys (:id),
:col-keys #{:color :title :group_id :id}},
:lcn-obj-keys
{:rsc :UsersInGroup,
:clauses :UsersInGroupClauses,
:where :UsersInGroupWhere,
:sort :UsersInGroupSort,
:fields :UsersInGroupFields,
:aggregate :UsersInGroupAggregate,
:pks :UsersInGroupPks,
:pk-input :UsersInGroupPkColumns},
:lcn-qry-keys
{:queries :users_in_groups,
:aggregate :users_in_groups_aggregate},
:lcn-descs
{:rsc "UsersInGroups",
:query "Query UsersInGroups.",
:clauses
"Format for where clauses is {column: {operator: value}}. Multiple parameters are applied with `AND` operators. `AND`/`OR` conditions can be created as a list of clauses. It is possible to nest them to create sub groups of conditions.",
:sort "Sort format is {column: \"asc\" or \"desc\"}.",
:fields "UsersInGroupsfields for aggregation.",
:aggregate "Aggrecate UsersInGroups.",
:pks "Primary key fields.",
:pk-input "Primary key fields."},
:access
{:lcn-fields
{:rsc
{:can_read {:type Boolean},
:inherit {:type Boolean},
:can_edit {:type Boolean},
:group_id {:type Int},
:id {:type Int},
:user_id {:type String},
:role_id {:type Int},
:next_access {:type Int},
:owner {:type Boolean}},
:clauses
{:can_read {:type :BoolWhere},
:inherit {:type :BoolWhere},
:can_edit {:type :BoolWhere},
:or {:type (list :AccessClauses)},
:group_id {:type :IntWhere},
:id {:type :IntWhere},
:and {:type (list :AccessClauses)},
:user_id {:type :StrWhere},
:role_id {:type :IntWhere},
:next_access {:type :IntWhere},
:owner {:type :BoolWhere}},
:sort
{:can_read {:type :SortOperator},
:inherit {:type :SortOperator},
:can_edit {:type :SortOperator},
:group_id {:type :SortOperator},
:id {:type :SortOperator},
:user_id {:type :SortOperator},
:role_id {:type :SortOperator},
:next_access {:type :SortOperator},
:owner {:type :SortOperator}},
:fields
{:can_read {:type Boolean},
:inherit {:type Boolean},
:can_edit {:type Boolean},
:group_id {:type Int},
:id {:type Int},
:user_id {:type String},
:role_id {:type Int},
:next_access {:type Int},
:owner {:type Boolean}},
:aggregate
{:count {:type Int},
:sum {:type :AccessFields},
:avg {:type :AccessFields},
:max {:type :AccessFields},
:min {:type :AccessFields}},
:pks {:id {:type (non-null Int)}},
:pk-input {:id {:type (non-null Int)}},
:update
{:can_read {:type Boolean},
:inherit {:type Boolean},
:can_edit {:type Boolean},
:group_id {:type Int},
:user_id {:type String},
:role_id {:type Int},
:next_access {:type Int},
:owner {:type Boolean}}},
:fks
{:next_access
{:field-keys
{:to :Access,
:has-many :accesses,
:has-many-aggr :accesses_aggregate,
:has-one :next_access_access}},
:role_id
{:field-keys
{:to :Role,
:has-many :accesses,
:has-many-aggr :accesses_aggregate,
:has-one :role}},
:user_id
{:field-keys
{:to :User,
:has-many :accesses,
:has-many-aggr :accesses_aggregate,
:has-one :user}},
:group_id
{:field-keys
{:to :Group,
:has-many :accesses,
:has-many-aggr :accesses_aggregate,
:has-one :group}}},
:lcn-mut-keys
{:create :createAccess,
:update :updateAccess,
:delete :deleteAccess},
:roles
{:lcn-fields
{:rsc
{:id {:type Int},
:group_id {:type Int},
:title {:type String},
:color {:type String}},
:clauses
{:and {:type (list :RoleClauses)},
:or {:type (list :RoleClauses)},
:id {:type :IntWhere},
:group_id {:type :IntWhere},
:title {:type :StrWhere},
:color {:type :StrWhere}},
:sort
{:id {:type :SortOperator},
:group_id {:type :SortOperator},
:title {:type :SortOperator},
:color {:type :SortOperator}},
:fields
{:id {:type Int},
:group_id {:type Int},
:title {:type String},
:color {:type String}},
:aggregate
{:count {:type Int},
:sum {:type :RoleFields},
:avg {:type :RoleFields},
:max {:type :RoleFields},
:min {:type :RoleFields}},
:pks {:id {:type (non-null Int)}},
:pk-input {:id {:type (non-null Int)}},
:update
{:group_id {:type Int},
:title {:type String},
:color {:type String}}},
:fks
{:group_id
{:field-keys
{:to :Group,
:has-many :roles,
:has-many-aggr :roles_aggregate,
:has-one :group}}},
:lcn-mut-keys
{:create :createRole,
:update :updateRole,
:delete :deleteRole},
:lcn-obj-keys
{:rsc :Role,
:clauses :RoleClauses,
:where :RoleWhere,
:sort :RoleSort,
:fields :RoleFields,
:aggregate :RoleAggregate,
:pks :RolePks,
:pk-input :RolePkColumns},
:lcn-qry-keys {:queries :roles, :aggregate :roles_aggregate},
:lcn-descs
{:rsc "Roles",
:query "Query Roles.",
:clauses
"Format for where clauses is {column: {operator: value}}. Multiple parameters are applied with `AND` operators. `AND`/`OR` conditions can be created as a list of clauses. It is possible to nest them to create sub groups of conditions.",
:sort "Sort format is {column: \"asc\" or \"desc\"}.",
:fields "Rolesfields for aggregation.",
:aggregate "Aggrecate Roles.",
:pks "Primary key fields.",
:pk-input "Primary key fields."},
:groups
{:lcn-fields
{:rsc
{:access {:type Int},
:created_at {:type String},
:edited_at {:type String},
:id {:type Int},
:title {:type String},
:user_id {:type String},
:description {:type String}},
:clauses
{:description {:type :StrWhere},
:or {:type (list :GroupClauses)},
:title {:type :StrWhere},
:id {:type :IntWhere},
:and {:type (list :GroupClauses)},
:user_id {:type :StrWhere},
:access {:type :IntWhere},
:edited_at {:type :StrWhere},
:created_at {:type :StrWhere}},
:sort
{:access {:type :SortOperator},
:created_at {:type :SortOperator},
:edited_at {:type :SortOperator},
:id {:type :SortOperator},
:title {:type :SortOperator},
:user_id {:type :SortOperator},
:description {:type :SortOperator}},
:fields
{:access {:type Int},
:created_at {:type String},
:edited_at {:type String},
:id {:type Int},
:title {:type String},
:user_id {:type String},
:description {:type String}},
:aggregate
{:count {:type Int},
:sum {:type :GroupFields},
:avg {:type :GroupFields},
:max {:type :GroupFields},
:min {:type :GroupFields}},
:pks {:id {:type (non-null Int)}},
:pk-input {:id {:type (non-null Int)}},
:update
{:access {:type Int},
:created_at {:type String},
:edited_at {:type String},
:title {:type String},
:user_id {:type String},
:description {:type String}}},
:fks
{:access
{:field-keys
{:to :Access,
:has-many :groups,
:has-many-aggr :groups_aggregate,
:has-one :access_access}},
:user_id
{:field-keys
{:to :User,
:has-many :groups,
:has-many-aggr :groups_aggregate,
:has-one :user}}},
:lcn-mut-keys
{:create :createGroup,
:update :updateGroup,
:delete :deleteGroup},
:lcn-obj-keys
{:rsc :Group,
:clauses :GroupClauses,
:where :GroupWhere,
:sort :GroupSort,
:fields :GroupFields,
:aggregate :GroupAggregate,
:pks :GroupPks,
:pk-input :GroupPkColumns},
:lcn-qry-keys
{:queries :groups, :aggregate :groups_aggregate},
:lcn-descs
{:rsc "Groups",
:query "Query Groups.",
:clauses
"Format for where clauses is {column: {operator: value}}. Multiple parameters are applied with `AND` operators. `AND`/`OR` conditions can be created as a list of clauses. It is possible to nest them to create sub groups of conditions.",
:sort "Sort format is {column: \"asc\" or \"desc\"}.",
:fields "Groupsfields for aggregation.",
:aggregate "Aggrecate Groups.",
:pks "Primary key fields.",
:pk-input "Primary key fields."},
:signals
{:query {:pre (), :post ()},
:create {:pre (), :post ()},
:delete {:pre (), :post ()},
:update {:pre (), :post ()}},
:pk-keys (:id),
:col-keys
#{:description
:title
:id
:user_id
:access
:edited_at
:created_at}},
:signals
{:query {:pre (), :post ()},
:create {:pre (), :post ()},
:delete {:pre (), :post ()},
:update {:pre (), :post ()}},
:pk-keys (:id),
:col-keys #{:color :title :group_id :id}},
:lcn-obj-keys
{:rsc :Access,
:clauses :AccessClauses,
:where :AccessWhere,
:sort :AccessSort,
:fields :AccessFields,
:aggregate :AccessAggregate,
:pks :AccessPks,
:pk-input :AccessPkColumns},
:lcn-qry-keys
{:queries :accesses, :aggregate :accesses_aggregate},
:lcn-descs
{:rsc "Accesses",
:query "Query Accesses.",
:clauses
"Format for where clauses is {column: {operator: value}}. Multiple parameters are applied with `AND` operators. `AND`/`OR` conditions can be created as a list of clauses. It is possible to nest them to create sub groups of conditions.",
:sort "Sort format is {column: \"asc\" or \"desc\"}.",
:fields "Accessesfields for aggregation.",
:aggregate "Aggrecate Accesses.",
:pks "Primary key fields.",
:pk-input "Primary key fields."},
:groups
{:lcn-fields
{:rsc
{:access {:type Int},
:created_at {:type String},
:edited_at {:type String},
:id {:type Int},
:title {:type String},
:user_id {:type String},
:description {:type String}},
:clauses
{:description {:type :StrWhere},
:or {:type (list :GroupClauses)},
:title {:type :StrWhere},
:id {:type :IntWhere},
:and {:type (list :GroupClauses)},
:user_id {:type :StrWhere},
:access {:type :IntWhere},
:edited_at {:type :StrWhere},
:created_at {:type :StrWhere}},
:sort
{:access {:type :SortOperator},
:created_at {:type :SortOperator},
:edited_at {:type :SortOperator},
:id {:type :SortOperator},
:title {:type :SortOperator},
:user_id {:type :SortOperator},
:description {:type :SortOperator}},
:fields
{:access {:type Int},
:created_at {:type String},
:edited_at {:type String},
:id {:type Int},
:title {:type String},
:user_id {:type String},
:description {:type String}},
:aggregate
{:count {:type Int},
:sum {:type :GroupFields},
:avg {:type :GroupFields},
:max {:type :GroupFields},
:min {:type :GroupFields}},
:pks {:id {:type (non-null Int)}},
:pk-input {:id {:type (non-null Int)}},
:update
{:access {:type Int},
:created_at {:type String},
:edited_at {:type String},
:title {:type String},
:user_id {:type String},
:description {:type String}}},
:fks
{:access
{:field-keys
{:to :Access,
:has-many :groups,
:has-many-aggr :groups_aggregate,
:has-one :access_access}},
:user_id
{:field-keys
{:to :User,
:has-many :groups,
:has-many-aggr :groups_aggregate,
:has-one :user}}},
:lcn-mut-keys
{:create :createGroup,
:update :updateGroup,
:delete :deleteGroup},
:lcn-obj-keys
{:rsc :Group,
:clauses :GroupClauses,
:where :GroupWhere,
:sort :GroupSort,
:fields :GroupFields,
:aggregate :GroupAggregate,
:pks :GroupPks,
:pk-input :GroupPkColumns},
:lcn-qry-keys
{:queries :groups, :aggregate :groups_aggregate},
:lcn-descs
{:rsc "Groups",
:query "Query Groups.",
:clauses
"Format for where clauses is {column: {operator: value}}. Multiple parameters are applied with `AND` operators. `AND`/`OR` conditions can be created as a list of clauses. It is possible to nest them to create sub groups of conditions.",
:sort "Sort format is {column: \"asc\" or \"desc\"}.",
:fields "Groupsfields for aggregation.",
:aggregate "Aggrecate Groups.",
:pks "Primary key fields.",
:pk-input "Primary key fields."},
:signals
{:query {:pre (), :post ()},
:create {:pre (), :post ()},
:delete {:pre (), :post ()},
:update {:pre (), :post ()}},
:pk-keys (:id),
:col-keys
#{:description
:title
:id
:user_id
:access
:edited_at
:created_at}},
:signals
{:query {:pre (), :post ()},
:create {:pre (), :post ()},
:delete {:pre (), :post ()},
:update {:pre (), :post ()}},
:pk-keys (:id),
:col-keys
#{:can_read
:inherit
:can_edit
:group_id
:id
:user_id
:role_id
:next_access
:owner}},
:groups
{:lcn-fields
{:rsc
{:access {:type Int},
:created_at {:type String},
:edited_at {:type String},
:id {:type Int},
:title {:type String},
:user_id {:type String},
:description {:type String}},
:clauses
{:description {:type :StrWhere},
:or {:type (list :GroupClauses)},
:title {:type :StrWhere},
:id {:type :IntWhere},
:and {:type (list :GroupClauses)},
:user_id {:type :StrWhere},
:access {:type :IntWhere},
:edited_at {:type :StrWhere},
:created_at {:type :StrWhere}},
:sort
{:access {:type :SortOperator},
:created_at {:type :SortOperator},
:edited_at {:type :SortOperator},
:id {:type :SortOperator},
:title {:type :SortOperator},
:user_id {:type :SortOperator},
:description {:type :SortOperator}},
:fields
{:access {:type Int},
:created_at {:type String},
:edited_at {:type String},
:id {:type Int},
:title {:type String},
:user_id {:type String},
:description {:type String}},
:aggregate
{:count {:type Int},
:sum {:type :GroupFields},
:avg {:type :GroupFields},
:max {:type :GroupFields},
:min {:type :GroupFields}},
:pks {:id {:type (non-null Int)}},
:pk-input {:id {:type (non-null Int)}},
:update
{:access {:type Int},
:created_at {:type String},
:edited_at {:type String},
:title {:type String},
:user_id {:type String},
:description {:type String}}},
:fks
{:access
{:field-keys
{:to :Access,
:has-many :groups,
:has-many-aggr :groups_aggregate,
:has-one :access_access}},
:user_id
{:field-keys
{:to :User,
:has-many :groups,
:has-many-aggr :groups_aggregate,
:has-one :user}}},
:lcn-mut-keys
{:create :createGroup,
:update :updateGroup,
:delete :deleteGroup},
:lcn-obj-keys
{:rsc :Group,
:clauses :GroupClauses,
:where :GroupWhere,
:sort :GroupSort,
:fields :GroupFields,
:aggregate :GroupAggregate,
:pks :GroupPks,
:pk-input :GroupPkColumns},
:lcn-qry-keys {:queries :groups, :aggregate :groups_aggregate},
:lcn-descs
{:rsc "Groups",
:query "Query Groups.",
:clauses
"Format for where clauses is {column: {operator: value}}. Multiple parameters are applied with `AND` operators. `AND`/`OR` conditions can be created as a list of clauses. It is possible to nest them to create sub groups of conditions.",
:sort "Sort format is {column: \"asc\" or \"desc\"}.",
:fields "Groupsfields for aggregation.",
:aggregate "Aggrecate Groups.",
:pks "Primary key fields.",
:pk-input "Primary key fields."},
:signals
{:query {:pre (), :post ()},
:create {:pre (), :post ()},
:delete {:pre (), :post ()},
:update {:pre (), :post ()}},
:pk-keys (:id),
:col-keys
#{:description
:title
:id
:user_id
:access
:edited_at
:created_at}},
:signals
{:query {:pre (), :post ()},
:create {:pre (), :post ()},
:delete {:pre (), :post ()},
:update {:pre (), :post ()}},
:pk-keys (:user_id :group_id :role_id),
:col-keys #{:group_id :user_id :role_id}}},
:signals
{:query {:pre (), :post ()},
:create {:pre (), :post ()},
:delete {:pre (), :post ()},
:update {:pre (), :post ()}},
:pk-keys (:id),
:col-keys
#{:attribute_name
:description
:udt_schema
:collation_schema
:numeric_scale
:character_set_schema
:dtd_identifier
:maximum_cardinality
:is_derived_reference_attribute
:character_octet_length
:datetime_precision
:scope_catalog
:collation_catalog
:character_maximum_length
:is_nullable
:character_set_catalog
:numeric_precision
:interval_type
:udt_catalog
:title
:scope_schema
:attribute_default
:numeric_precision_radix
:interval_precision
:character_set_name
:attribute_udt_catalog
:id
:collation_name
:data_type
:attribute_udt_schema
:access
:edited_at
:scope_name
:udt_name
:created_at
:ordinal_position
:attribute_udt_name},
:users_in_groups
{:lcn-fields
{:rsc
{:group_id {:type Int},
:role_id {:type Int},
:user_id {:type String}},
:clauses
{:and {:type (list :UsersInGroupClauses)},
:or {:type (list :UsersInGroupClauses)},
:group_id {:type :IntWhere},
:role_id {:type :IntWhere},
:user_id {:type :StrWhere}},
:sort
{:group_id {:type :SortOperator},
:role_id {:type :SortOperator},
:user_id {:type :SortOperator}},
:fields
{:group_id {:type Int},
:role_id {:type Int},
:user_id {:type String}},
:aggregate
{:count {:type Int},
:sum {:type :UsersInGroupFields},
:avg {:type :UsersInGroupFields},
:max {:type :UsersInGroupFields},
:min {:type :UsersInGroupFields}},
:pks
{:user_id {:type (non-null String)},
:group_id {:type (non-null Int)},
:role_id {:type (non-null Int)}},
:pk-input
{:user_id {:type (non-null String)},
:group_id {:type (non-null Int)},
:role_id {:type (non-null Int)}},
:update {}},
:fks
{:user_id
{:field-keys
{:to :User,
:has-many :users_in_groups,
:has-many-aggr :users_in_groups_aggregate,
:has-one :user}},
:group_id
{:field-keys
{:to :Group,
:has-many :users_in_groups,
:has-many-aggr :users_in_groups_aggregate,
:has-one :group}},
:role_id
{:field-keys
{:to :Role,
:has-many :users_in_groups,
:has-many-aggr :users_in_groups_aggregate,
:has-one :role}}},
:lcn-mut-keys
{:create :createUsersInGroup,
:update :updateUsersInGroup,
:delete :deleteUsersInGroup},
:roles
{:lcn-fields
{:rsc
{:id {:type Int},
:group_id {:type Int},
:title {:type String},
:color {:type String}},
:clauses
{:and {:type (list :RoleClauses)},
:or {:type (list :RoleClauses)},
:id {:type :IntWhere},
:group_id {:type :IntWhere},
:title {:type :StrWhere},
:color {:type :StrWhere}},
:sort
{:id {:type :SortOperator},
:group_id {:type :SortOperator},
:title {:type :SortOperator},
:color {:type :SortOperator}},
:fields
{:id {:type Int},
:group_id {:type Int},
:title {:type String},
:color {:type String}},
:aggregate
{:count {:type Int},
:sum {:type :RoleFields},
:avg {:type :RoleFields},
:max {:type :RoleFields},
:min {:type :RoleFields}},
:pks {:id {:type (non-null Int)}},
:pk-input {:id {:type (non-null Int)}},
:update
{:group_id {:type Int},
:title {:type String},
:color {:type String}}},
:fks
{:group_id
{:field-keys
{:to :Group,
:has-many :roles,
:has-many-aggr :roles_aggregate,
:has-one :group}}},
:lcn-mut-keys
{:create :createRole, :update :updateRole, :delete :deleteRole},
:lcn-obj-keys
{:rsc :Role,
:clauses :RoleClauses,
:where :RoleWhere,
:sort :RoleSort,
:fields :RoleFields,
:aggregate :RoleAggregate,
:pks :RolePks,
:pk-input :RolePkColumns},
:lcn-qry-keys {:queries :roles, :aggregate :roles_aggregate},
:lcn-descs
{:rsc "Roles",
:query "Query Roles.",
:clauses
"Format for where clauses is {column: {operator: value}}. Multiple parameters are applied with `AND` operators. `AND`/`OR` conditions can be created as a list of clauses. It is possible to nest them to create sub groups of conditions.",
:sort "Sort format is {column: \"asc\" or \"desc\"}.",
:fields "Rolesfields for aggregation.",
:aggregate "Aggrecate Roles.",
:pks "Primary key fields.",
:pk-input "Primary key fields."},
:groups
{:lcn-fields
{:rsc
{:access {:type Int},
:created_at {:type String},
:edited_at {:type String},
:id {:type Int},
:title {:type String},
:user_id {:type String},
:description {:type String}},
:clauses
{:description {:type :StrWhere},
:or {:type (list :GroupClauses)},
:title {:type :StrWhere},
:id {:type :IntWhere},
:and {:type (list :GroupClauses)},
:user_id {:type :StrWhere},
:access {:type :IntWhere},
:edited_at {:type :StrWhere},
:created_at {:type :StrWhere}},
:sort
{:access {:type :SortOperator},
:created_at {:type :SortOperator},
:edited_at {:type :SortOperator},
:id {:type :SortOperator},
:title {:type :SortOperator},
:user_id {:type :SortOperator},
:description {:type :SortOperator}},
:fields
{:access {:type Int},
:created_at {:type String},
:edited_at {:type String},
:id {:type Int},
:title {:type String},
:user_id {:type String},
:description {:type String}},
:aggregate
{:count {:type Int},
:sum {:type :GroupFields},
:avg {:type :GroupFields},
:max {:type :GroupFields},
:min {:type :GroupFields}},
:pks {:id {:type (non-null Int)}},
:pk-input {:id {:type (non-null Int)}},
:update
{:access {:type Int},
:created_at {:type String},
:edited_at {:type String},
:title {:type String},
:user_id {:type String},
:description {:type String}}},
:fks
{:access
{:field-keys
{:to :Access,
:has-many :groups,
:has-many-aggr :groups_aggregate,
:has-one :access_access}},
:user_id
{:field-keys
{:to :User,
:has-many :groups,
:has-many-aggr :groups_aggregate,
:has-one :user}}},
:lcn-mut-keys
{:create :createGroup,
:update :updateGroup,
:delete :deleteGroup},
:lcn-obj-keys
{:rsc :Group,
:clauses :GroupClauses,
:where :GroupWhere,
:sort :GroupSort,
:fields :GroupFields,
:aggregate :GroupAggregate,
:pks :GroupPks,
:pk-input :GroupPkColumns},
:lcn-qry-keys {:queries :groups, :aggregate :groups_aggregate},
:lcn-descs
{:rsc "Groups",
:query "Query Groups.",
:clauses
"Format for where clauses is {column: {operator: value}}. Multiple parameters are applied with `AND` operators. `AND`/`OR` conditions can be created as a list of clauses. It is possible to nest them to create sub groups of conditions.",
:sort "Sort format is {column: \"asc\" or \"desc\"}.",
:fields "Groupsfields for aggregation.",
:aggregate "Aggrecate Groups.",
:pks "Primary key fields.",
:pk-input "Primary key fields."},
:signals
{:query {:pre (), :post ()},
:create {:pre (), :post ()},
:delete {:pre (), :post ()},
:update {:pre (), :post ()}},
:pk-keys (:id),
:col-keys
#{:description
:title
:id
:user_id
:access
:edited_at
:created_at}},
:signals
{:query {:pre (), :post ()},
:create {:pre (), :post ()},
:delete {:pre (), :post ()},
:update {:pre (), :post ()}},
:pk-keys (:id),
:col-keys #{:color :title :group_id :id}},
:lcn-obj-keys
{:rsc :UsersInGroup,
:clauses :UsersInGroupClauses,
:where :UsersInGroupWhere,
:sort :UsersInGroupSort,
:fields :UsersInGroupFields,
:aggregate :UsersInGroupAggregate,
:pks :UsersInGroupPks,
:pk-input :UsersInGroupPkColumns},
:lcn-qry-keys
{:queries :users_in_groups,
:aggregate :users_in_groups_aggregate},
:lcn-descs
{:rsc "UsersInGroups",
:query "Query UsersInGroups.",
:clauses
"Format for where clauses is {column: {operator: value}}. Multiple parameters are applied with `AND` operators. `AND`/`OR` conditions can be created as a list of clauses. It is possible to nest them to create sub groups of conditions.",
:sort "Sort format is {column: \"asc\" or \"desc\"}.",
:fields "UsersInGroupsfields for aggregation.",
:aggregate "Aggrecate UsersInGroups.",
:pks "Primary key fields.",
:pk-input "Primary key fields."},
:access
{:lcn-fields
{:rsc
{:can_read {:type Boolean},
:inherit {:type Boolean},
:can_edit {:type Boolean},
:group_id {:type Int},
:id {:type Int},
:user_id {:type String},
:role_id {:type Int},
:next_access {:type Int},
:owner {:type Boolean}},
:clauses
{:can_read {:type :BoolWhere},
:inherit {:type :BoolWhere},
:can_edit {:type :BoolWhere},
:or {:type (list :AccessClauses)},
:group_id {:type :IntWhere},
:id {:type :IntWhere},
:and {:type (list :AccessClauses)},
:user_id {:type :StrWhere},
:role_id {:type :IntWhere},
:next_access {:type :IntWhere},
:owner {:type :BoolWhere}},
:sort
{:can_read {:type :SortOperator},
:inherit {:type :SortOperator},
:can_edit {:type :SortOperator},
:group_id {:type :SortOperator},
:id {:type :SortOperator},
:user_id {:type :SortOperator},
:role_id {:type :SortOperator},
:next_access {:type :SortOperator},
:owner {:type :SortOperator}},
:fields
{:can_read {:type Boolean},
:inherit {:type Boolean},
:can_edit {:type Boolean},
:group_id {:type Int},
:id {:type Int},
:user_id {:type String},
:role_id {:type Int},
:next_access {:type Int},
:owner {:type Boolean}},
:aggregate
{:count {:type Int},
:sum {:type :AccessFields},
:avg {:type :AccessFields},
:max {:type :AccessFields},
:min {:type :AccessFields}},
:pks {:id {:type (non-null Int)}},
:pk-input {:id {:type (non-null Int)}},
:update
{:can_read {:type Boolean},
:inherit {:type Boolean},
:can_edit {:type Boolean},
:group_id {:type Int},
:user_id {:type String},
:role_id {:type Int},
:next_access {:type Int},
:owner {:type Boolean}}},
:fks
{:next_access
{:field-keys
{:to :Access,
:has-many :accesses,
:has-many-aggr :accesses_aggregate,
:has-one :next_access_access}},
:role_id
{:field-keys
{:to :Role,
:has-many :accesses,
:has-many-aggr :accesses_aggregate,
:has-one :role}},
:user_id
{:field-keys
{:to :User,
:has-many :accesses,
:has-many-aggr :accesses_aggregate,
:has-one :user}},
:group_id
{:field-keys
{:to :Group,
:has-many :accesses,
:has-many-aggr :accesses_aggregate,
:has-one :group}}},
:lcn-mut-keys
{:create :createAccess,
:update :updateAccess,
:delete :deleteAccess},
:roles
{:lcn-fields
{:rsc
{:id {:type Int},
:group_id {:type Int},
:title {:type String},
:color {:type String}},
:clauses
{:and {:type (list :RoleClauses)},
:or {:type (list :RoleClauses)},
:id {:type :IntWhere},
:group_id {:type :IntWhere},
:title {:type :StrWhere},
:color {:type :StrWhere}},
:sort
{:id {:type :SortOperator},
:group_id {:type :SortOperator},
:title {:type :SortOperator},
:color {:type :SortOperator}},
:fields
{:id {:type Int},
:group_id {:type Int},
:title {:type String},
:color {:type String}},
:aggregate
{:count {:type Int},
:sum {:type :RoleFields},
:avg {:type :RoleFields},
:max {:type :RoleFields},
:min {:type :RoleFields}},
:pks {:id {:type (non-null Int)}},
:pk-input {:id {:type (non-null Int)}},
:update
{:group_id {:type Int},
:title {:type String},
:color {:type String}}},
:fks
{:group_id
{:field-keys
{:to :Group,
:has-many :roles,
:has-many-aggr :roles_aggregate,
:has-one :group}}},
:lcn-mut-keys
{:create :createRole,
:update :updateRole,
:delete :deleteRole},
:lcn-obj-keys
{:rsc :Role,
:clauses :RoleClauses,
:where :RoleWhere,
:sort :RoleSort,
:fields :RoleFields,
:aggregate :RoleAggregate,
:pks :RolePks,
:pk-input :RolePkColumns},
:lcn-qry-keys {:queries :roles, :aggregate :roles_aggregate},
:lcn-descs
{:rsc "Roles",
:query "Query Roles.",
:clauses
"Format for where clauses is {column: {operator: value}}. Multiple parameters are applied with `AND` operators. `AND`/`OR` conditions can be created as a list of clauses. It is possible to nest them to create sub groups of conditions.",
:sort "Sort format is {column: \"asc\" or \"desc\"}.",
:fields "Rolesfields for aggregation.",
:aggregate "Aggrecate Roles.",
:pks "Primary key fields.",
:pk-input "Primary key fields."},
:groups
{:lcn-fields
{:rsc
{:access {:type Int},
:created_at {:type String},
:edited_at {:type String},
:id {:type Int},
:title {:type String},
:user_id {:type String},
:description {:type String}},
:clauses
{:description {:type :StrWhere},
:or {:type (list :GroupClauses)},
:title {:type :StrWhere},
:id {:type :IntWhere},
:and {:type (list :GroupClauses)},
:user_id {:type :StrWhere},
:access {:type :IntWhere},
:edited_at {:type :StrWhere},
:created_at {:type :StrWhere}},
:sort
{:access {:type :SortOperator},
:created_at {:type :SortOperator},
:edited_at {:type :SortOperator},
:id {:type :SortOperator},
:title {:type :SortOperator},
:user_id {:type :SortOperator},
:description {:type :SortOperator}},
:fields
{:access {:type Int},
:created_at {:type String},
:edited_at {:type String},
:id {:type Int},
:title {:type String},
:user_id {:type String},
:description {:type String}},
:aggregate
{:count {:type Int},
:sum {:type :GroupFields},
:avg {:type :GroupFields},
:max {:type :GroupFields},
:min {:type :GroupFields}},
:pks {:id {:type (non-null Int)}},
:pk-input {:id {:type (non-null Int)}},
:update
{:access {:type Int},
:created_at {:type String},
:edited_at {:type String},
:title {:type String},
:user_id {:type String},
:description {:type String}}},
:fks
{:access
{:field-keys
{:to :Access,
:has-many :groups,
:has-many-aggr :groups_aggregate,
:has-one :access_access}},
:user_id
{:field-keys
{:to :User,
:has-many :groups,
:has-many-aggr :groups_aggregate,
:has-one :user}}},
:lcn-mut-keys
{:create :createGroup,
:update :updateGroup,
:delete :deleteGroup},
:lcn-obj-keys
{:rsc :Group,
:clauses :GroupClauses,
:where :GroupWhere,
:sort :GroupSort,
:fields :GroupFields,
:aggregate :GroupAggregate,
:pks :GroupPks,
:pk-input :GroupPkColumns},
:lcn-qry-keys
{:queries :groups, :aggregate :groups_aggregate},
:lcn-descs
{:rsc "Groups",
:query "Query Groups.",
:clauses
"Format for where clauses is {column: {operator: value}}. Multiple parameters are applied with `AND` operators. `AND`/`OR` conditions can be created as a list of clauses. It is possible to nest them to create sub groups of conditions.",
:sort "Sort format is {column: \"asc\" or \"desc\"}.",
:fields "Groupsfields for aggregation.",
:aggregate "Aggrecate Groups.",
:pks "Primary key fields.",
:pk-input "Primary key fields."},
:signals
{:query {:pre (), :post ()},
:create {:pre (), :post ()},
:delete {:pre (), :post ()},
:update {:pre (), :post ()}},
:pk-keys (:id),
:col-keys
#{:description
:title
:id
:user_id
:access
:edited_at
:created_at}},
:signals
{:query {:pre (), :post ()},
:create {:pre (), :post ()},
:delete {:pre (), :post ()},
:update {:pre (), :post ()}},
:pk-keys (:id),
:col-keys #{:color :title :group_id :id}},
:lcn-obj-keys
{:rsc :Access,
:clauses :AccessClauses,
:where :AccessWhere,
:sort :AccessSort,
:fields :AccessFields,
:aggregate :AccessAggregate,
:pks :AccessPks,
:pk-input :AccessPkColumns},
:lcn-qry-keys
{:queries :accesses, :aggregate :accesses_aggregate},
:lcn-descs
{:rsc "Accesses",
:query "Query Accesses.",
:clauses
"Format for where clauses is {column: {operator: value}}. Multiple parameters are applied with `AND` operators. `AND`/`OR` conditions can be created as a list of clauses. It is possible to nest them to create sub groups of conditions.",
:sort "Sort format is {column: \"asc\" or \"desc\"}.",
:fields "Accessesfields for aggregation.",
:aggregate "Aggrecate Accesses.",
:pks "Primary key fields.",
:pk-input "Primary key fields."},
:groups
{:lcn-fields
{:rsc
{:access {:type Int},
:created_at {:type String},
:edited_at {:type String},
:id {:type Int},
:title {:type String},
:user_id {:type String},
:description {:type String}},
:clauses
{:description {:type :StrWhere},
:or {:type (list :GroupClauses)},
:title {:type :StrWhere},
:id {:type :IntWhere},
:and {:type (list :GroupClauses)},
:user_id {:type :StrWhere},
:access {:type :IntWhere},
:edited_at {:type :StrWhere},
:created_at {:type :StrWhere}},
:sort
{:access {:type :SortOperator},
:created_at {:type :SortOperator},
:edited_at {:type :SortOperator},
:id {:type :SortOperator},
:title {:type :SortOperator},
:user_id {:type :SortOperator},
:description {:type :SortOperator}},
:fields
{:access {:type Int},
:created_at {:type String},
:edited_at {:type String},
:id {:type Int},
:title {:type String},
:user_id {:type String},
:description {:type String}},
:aggregate
{:count {:type Int},
:sum {:type :GroupFields},
:avg {:type :GroupFields},
:max {:type :GroupFields},
:min {:type :GroupFields}},
:pks {:id {:type (non-null Int)}},
:pk-input {:id {:type (non-null Int)}},
:update
{:access {:type Int},
:created_at {:type String},
:edited_at {:type String},
:title {:type String},
:user_id {:type String},
:description {:type String}}},
:fks
{:access
{:field-keys
{:to :Access,
:has-many :groups,
:has-many-aggr :groups_aggregate,
:has-one :access_access}},
:user_id
{:field-keys
{:to :User,
:has-many :groups,
:has-many-aggr :groups_aggregate,
:has-one :user}}},
:lcn-mut-keys
{:create :createGroup,
:update :updateGroup,
:delete :deleteGroup},
:lcn-obj-keys
{:rsc :Group,
:clauses :GroupClauses,
:where :GroupWhere,
:sort :GroupSort,
:fields :GroupFields,
:aggregate :GroupAggregate,
:pks :GroupPks,
:pk-input :GroupPkColumns},
:lcn-qry-keys {:queries :groups, :aggregate :groups_aggregate},
:lcn-descs
{:rsc "Groups",
:query "Query Groups.",
:clauses
"Format for where clauses is {column: {operator: value}}. Multiple parameters are applied with `AND` operators. `AND`/`OR` conditions can be created as a list of clauses. It is possible to nest them to create sub groups of conditions.",
:sort "Sort format is {column: \"asc\" or \"desc\"}.",
:fields "Groupsfields for aggregation.",
:aggregate "Aggrecate Groups.",
:pks "Primary key fields.",
:pk-input "Primary key fields."},
:signals
{:query {:pre (), :post ()},
:create {:pre (), :post ()},
:delete {:pre (), :post ()},
:update {:pre (), :post ()}},
:pk-keys (:id),
:col-keys
#{:description
:title
:id
:user_id
:access
:edited_at
:created_at}},
:signals
{:query {:pre (), :post ()},
:create {:pre (), :post ()},
:delete {:pre (), :post ()},
:update {:pre (), :post ()}},
:pk-keys (:id),
:col-keys
#{:can_read
:inherit
:can_edit
:group_id
:id
:user_id
:role_id
:next_access
:owner}},
:groups
{:lcn-fields
{:rsc
{:access {:type Int},
:created_at {:type String},
:edited_at {:type String},
:id {:type Int},
:title {:type String},
:user_id {:type String},
:description {:type String}},
:clauses
{:description {:type :StrWhere},
:or {:type (list :GroupClauses)},
:title {:type :StrWhere},
:id {:type :IntWhere},
:and {:type (list :GroupClauses)},
:user_id {:type :StrWhere},
:access {:type :IntWhere},
:edited_at {:type :StrWhere},
:created_at {:type :StrWhere}},
:sort
{:access {:type :SortOperator},
:created_at {:type :SortOperator},
:edited_at {:type :SortOperator},
:id {:type :SortOperator},
:title {:type :SortOperator},
:user_id {:type :SortOperator},
:description {:type :SortOperator}},
:fields
{:access {:type Int},
:created_at {:type String},
:edited_at {:type String},
:id {:type Int},
:title {:type String},
:user_id {:type String},
:description {:type String}},
:aggregate
{:count {:type Int},
:sum {:type :GroupFields},
:avg {:type :GroupFields},
:max {:type :GroupFields},
:min {:type :GroupFields}},
:pks {:id {:type (non-null Int)}},
:pk-input {:id {:type (non-null Int)}},
:update
{:access {:type Int},
:created_at {:type String},
:edited_at {:type String},
:title {:type String},
:user_id {:type String},
:description {:type String}}},
:fks
{:access
{:field-keys
{:to :Access,
:has-many :groups,
:has-many-aggr :groups_aggregate,
:has-one :access_access}},
:user_id
{:field-keys
{:to :User,
:has-many :groups,
:has-many-aggr :groups_aggregate,
:has-one :user}}},
:lcn-mut-keys
{:create :createGroup,
:update :updateGroup,
:delete :deleteGroup},
:lcn-obj-keys
{:rsc :Group,
:clauses :GroupClauses,
:where :GroupWhere,
:sort :GroupSort,
:fields :GroupFields,
:aggregate :GroupAggregate,
:pks :GroupPks,
:pk-input :GroupPkColumns},
:lcn-qry-keys {:queries :groups, :aggregate :groups_aggregate},
:lcn-descs
{:rsc "Groups",
:query "Query Groups.",
:clauses
"Format for where clauses is {column: {operator: value}}. Multiple parameters are applied with `AND` operators. `AND`/`OR` conditions can be created as a list of clauses. It is possible to nest them to create sub groups of conditions.",
:sort "Sort format is {column: \"asc\" or \"desc\"}.",
:fields "Groupsfields for aggregation.",
:aggregate "Aggrecate Groups.",
:pks "Primary key fields.",
:pk-input "Primary key fields."},
:signals
{:query {:pre (), :post ()},
:create {:pre (), :post ()},
:delete {:pre (), :post ()},
:update {:pre (), :post ()}},
:pk-keys (:id),
:col-keys
#{:description
:title
:id
:user_id
:access
:edited_at
:created_at}},
:signals
{:query {:pre (), :post ()},
:create {:pre (), :post ()},
:delete {:pre (), :post ()},
:update {:pre (), :post ()}},
:pk-keys (:user_id :group_id :role_id),
:col-keys #{:group_id :user_id :role_id}}},
:signals
{:query {:pre (), :post ()},
:create {:pre (), :post ()},
:delete {:pre (), :post ()},
:update {:pre (), :post ()}},
:pk-keys (:user_name),
:col-keys #{:email :password_hash :user_name :created_at},
:users_in_groups
{:lcn-fields
{:rsc
{:group_id {:type Int},
:role_id {:type Int},
:user_id {:type String}},
:clauses
{:and {:type (list :UsersInGroupClauses)},
:or {:type (list :UsersInGroupClauses)},
:group_id {:type :IntWhere},
:role_id {:type :IntWhere},
:user_id {:type :StrWhere}},
:sort
{:group_id {:type :SortOperator},
:role_id {:type :SortOperator},
:user_id {:type :SortOperator}},
:fields
{:group_id {:type Int},
:role_id {:type Int},
:user_id {:type String}},
:aggregate
{:count {:type Int},
:sum {:type :UsersInGroupFields},
:avg {:type :UsersInGroupFields},
:max {:type :UsersInGroupFields},
:min {:type :UsersInGroupFields}},
:pks
{:user_id {:type (non-null String)},
:group_id {:type (non-null Int)},
:role_id {:type (non-null Int)}},
:pk-input
{:user_id {:type (non-null String)},
:group_id {:type (non-null Int)},
:role_id {:type (non-null Int)}},
:update {}},
:fks
{:user_id
{:field-keys
{:to :User,
:has-many :users_in_groups,
:has-many-aggr :users_in_groups_aggregate,
:has-one :user}},
:group_id
{:field-keys
{:to :Group,
:has-many :users_in_groups,
:has-many-aggr :users_in_groups_aggregate,
:has-one :group}},
:role_id
{:field-keys
{:to :Role,
:has-many :users_in_groups,
:has-many-aggr :users_in_groups_aggregate,
:has-one :role}}},
:lcn-mut-keys
{:create :createUsersInGroup,
:update :updateUsersInGroup,
:delete :deleteUsersInGroup},
:roles
{:lcn-fields
{:rsc
{:id {:type Int},
:group_id {:type Int},
:title {:type String},
:color {:type String}},
:clauses
{:and {:type (list :RoleClauses)},
:or {:type (list :RoleClauses)},
:id {:type :IntWhere},
:group_id {:type :IntWhere},
:title {:type :StrWhere},
:color {:type :StrWhere}},
:sort
{:id {:type :SortOperator},
:group_id {:type :SortOperator},
:title {:type :SortOperator},
:color {:type :SortOperator}},
:fields
{:id {:type Int},
:group_id {:type Int},
:title {:type String},
:color {:type String}},
:aggregate
{:count {:type Int},
:sum {:type :RoleFields},
:avg {:type :RoleFields},
:max {:type :RoleFields},
:min {:type :RoleFields}},
:pks {:id {:type (non-null Int)}},
:pk-input {:id {:type (non-null Int)}},
:update
{:group_id {:type Int},
:title {:type String},
:color {:type String}}},
:fks
{:group_id
{:field-keys
{:to :Group,
:has-many :roles,
:has-many-aggr :roles_aggregate,
:has-one :group}}},
:lcn-mut-keys
{:create :createRole, :update :updateRole, :delete :deleteRole},
:lcn-obj-keys
{:rsc :Role,
:clauses :RoleClauses,
:where :RoleWhere,
:sort :RoleSort,
:fields :RoleFields,
:aggregate :RoleAggregate,
:pks :RolePks,
:pk-input :RolePkColumns},
:lcn-qry-keys {:queries :roles, :aggregate :roles_aggregate},
:lcn-descs
{:rsc "Roles",
:query "Query Roles.",
:clauses
"Format for where clauses is {column: {operator: value}}. Multiple parameters are applied with `AND` operators. `AND`/`OR` conditions can be created as a list of clauses. It is possible to nest them to create sub groups of conditions.",
:sort "Sort format is {column: \"asc\" or \"desc\"}.",
:fields "Rolesfields for aggregation.",
:aggregate "Aggrecate Roles.",
:pks "Primary key fields.",
:pk-input "Primary key fields."},
:groups
{:lcn-fields
{:rsc
{:access {:type Int},
:created_at {:type String},
:edited_at {:type String},
:id {:type Int},
:title {:type String},
:user_id {:type String},
:description {:type String}},
:clauses
{:description {:type :StrWhere},
:or {:type (list :GroupClauses)},
:title {:type :StrWhere},
:id {:type :IntWhere},
:and {:type (list :GroupClauses)},
:user_id {:type :StrWhere},
:access {:type :IntWhere},
:edited_at {:type :StrWhere},
:created_at {:type :StrWhere}},
:sort
{:access {:type :SortOperator},
:created_at {:type :SortOperator},
:edited_at {:type :SortOperator},
:id {:type :SortOperator},
:title {:type :SortOperator},
:user_id {:type :SortOperator},
:description {:type :SortOperator}},
:fields
{:access {:type Int},
:created_at {:type String},
:edited_at {:type String},
:id {:type Int},
:title {:type String},
:user_id {:type String},
:description {:type String}},
:aggregate
{:count {:type Int},
:sum {:type :GroupFields},
:avg {:type :GroupFields},
:max {:type :GroupFields},
:min {:type :GroupFields}},
:pks {:id {:type (non-null Int)}},
:pk-input {:id {:type (non-null Int)}},
:update
{:access {:type Int},
:created_at {:type String},
:edited_at {:type String},
:title {:type String},
:user_id {:type String},
:description {:type String}}},
:fks
{:access
{:field-keys
{:to :Access,
:has-many :groups,
:has-many-aggr :groups_aggregate,
:has-one :access_access}},
:user_id
{:field-keys
{:to :User,
:has-many :groups,
:has-many-aggr :groups_aggregate,
:has-one :user}}},
:lcn-mut-keys
{:create :createGroup,
:update :updateGroup,
:delete :deleteGroup},
:lcn-obj-keys
{:rsc :Group,
:clauses :GroupClauses,
:where :GroupWhere,
:sort :GroupSort,
:fields :GroupFields,
:aggregate :GroupAggregate,
:pks :GroupPks,
:pk-input :GroupPkColumns},
:lcn-qry-keys {:queries :groups, :aggregate :groups_aggregate},
:lcn-descs
{:rsc "Groups",
:query "Query Groups.",
:clauses
"Format for where clauses is {column: {operator: value}}. Multiple parameters are applied with `AND` operators. `AND`/`OR` conditions can be created as a list of clauses. It is possible to nest them to create sub groups of conditions.",
:sort "Sort format is {column: \"asc\" or \"desc\"}.",
:fields "Groupsfields for aggregation.",
:aggregate "Aggrecate Groups.",
:pks "Primary key fields.",
:pk-input "Primary key fields."},
:signals
{:query {:pre (), :post ()},
:create {:pre (), :post ()},
:delete {:pre (), :post ()},
:update {:pre (), :post ()}},
:pk-keys (:id),
:col-keys
#{:description
:title
:id
:user_id
:access
:edited_at
:created_at}},
:signals
{:query {:pre (), :post ()},
:create {:pre (), :post ()},
:delete {:pre (), :post ()},
:update {:pre (), :post ()}},
:pk-keys (:id),
:col-keys #{:color :title :group_id :id}},
:lcn-obj-keys
{:rsc :UsersInGroup,
:clauses :UsersInGroupClauses,
:where :UsersInGroupWhere,
:sort :UsersInGroupSort,
:fields :UsersInGroupFields,
:aggregate :UsersInGroupAggregate,
:pks :UsersInGroupPks,
:pk-input :UsersInGroupPkColumns},
:lcn-qry-keys
{:queries :users_in_groups,
:aggregate :users_in_groups_aggregate},
:lcn-descs
{:rsc "UsersInGroups",
:query "Query UsersInGroups.",
:clauses
"Format for where clauses is {column: {operator: value}}. Multiple parameters are applied with `AND` operators. `AND`/`OR` conditions can be created as a list of clauses. It is possible to nest them to create sub groups of conditions.",
:sort "Sort format is {column: \"asc\" or \"desc\"}.",
:fields "UsersInGroupsfields for aggregation.",
:aggregate "Aggrecate UsersInGroups.",
:pks "Primary key fields.",
:pk-input "Primary key fields."},
:access
{:lcn-fields
{:rsc
{:can_read {:type Boolean},
:inherit {:type Boolean},
:can_edit {:type Boolean},
:group_id {:type Int},
:id {:type Int},
:user_id {:type String},
:role_id {:type Int},
:next_access {:type Int},
:owner {:type Boolean}},
:clauses
{:can_read {:type :BoolWhere},
:inherit {:type :BoolWhere},
:can_edit {:type :BoolWhere},
:or {:type (list :AccessClauses)},
:group_id {:type :IntWhere},
:id {:type :IntWhere},
:and {:type (list :AccessClauses)},
:user_id {:type :StrWhere},
:role_id {:type :IntWhere},
:next_access {:type :IntWhere},
:owner {:type :BoolWhere}},
:sort
{:can_read {:type :SortOperator},
:inherit {:type :SortOperator},
:can_edit {:type :SortOperator},
:group_id {:type :SortOperator},
:id {:type :SortOperator},
:user_id {:type :SortOperator},
:role_id {:type :SortOperator},
:next_access {:type :SortOperator},
:owner {:type :SortOperator}},
:fields
{:can_read {:type Boolean},
:inherit {:type Boolean},
:can_edit {:type Boolean},
:group_id {:type Int},
:id {:type Int},
:user_id {:type String},
:role_id {:type Int},
:next_access {:type Int},
:owner {:type Boolean}},
:aggregate
{:count {:type Int},
:sum {:type :AccessFields},
:avg {:type :AccessFields},
:max {:type :AccessFields},
:min {:type :AccessFields}},
:pks {:id {:type (non-null Int)}},
:pk-input {:id {:type (non-null Int)}},
:update
{:can_read {:type Boolean},
:inherit {:type Boolean},
:can_edit {:type Boolean},
:group_id {:type Int},
:user_id {:type String},
:role_id {:type Int},
:next_access {:type Int},
:owner {:type Boolean}}},
:fks
{:next_access
{:field-keys
{:to :Access,
:has-many :accesses,
:has-many-aggr :accesses_aggregate,
:has-one :next_access_access}},
:role_id
{:field-keys
{:to :Role,
:has-many :accesses,
:has-many-aggr :accesses_aggregate,
:has-one :role}},
:user_id
{:field-keys
{:to :User,
:has-many :accesses,
:has-many-aggr :accesses_aggregate,
:has-one :user}},
:group_id
{:field-keys
{:to :Group,
:has-many :accesses,
:has-many-aggr :accesses_aggregate,
:has-one :group}}},
:lcn-mut-keys
{:create :createAccess,
:update :updateAccess,
:delete :deleteAccess},
:roles
{:lcn-fields
{:rsc
{:id {:type Int},
:group_id {:type Int},
:title {:type String},
:color {:type String}},
:clauses
{:and {:type (list :RoleClauses)},
:or {:type (list :RoleClauses)},
:id {:type :IntWhere},
:group_id {:type :IntWhere},
:title {:type :StrWhere},
:color {:type :StrWhere}},
:sort
{:id {:type :SortOperator},
:group_id {:type :SortOperator},
:title {:type :SortOperator},
:color {:type :SortOperator}},
:fields
{:id {:type Int},
:group_id {:type Int},
:title {:type String},
:color {:type String}},
:aggregate
{:count {:type Int},
:sum {:type :RoleFields},
:avg {:type :RoleFields},
:max {:type :RoleFields},
:min {:type :RoleFields}},
:pks {:id {:type (non-null Int)}},
:pk-input {:id {:type (non-null Int)}},
:update
{:group_id {:type Int},
:title {:type String},
:color {:type String}}},
:fks
{:group_id
{:field-keys
{:to :Group,
:has-many :roles,
:has-many-aggr :roles_aggregate,
:has-one :group}}},
:lcn-mut-keys
{:create :createRole, :update :updateRole, :delete :deleteRole},
:lcn-obj-keys
{:rsc :Role,
:clauses :RoleClauses,
:where :RoleWhere,
:sort :RoleSort,
:fields :RoleFields,
:aggregate :RoleAggregate,
:pks :RolePks,
:pk-input :RolePkColumns},
:lcn-qry-keys {:queries :roles, :aggregate :roles_aggregate},
:lcn-descs
{:rsc "Roles",
:query "Query Roles.",
:clauses
"Format for where clauses is {column: {operator: value}}. Multiple parameters are applied with `AND` operators. `AND`/`OR` conditions can be created as a list of clauses. It is possible to nest them to create sub groups of conditions.",
:sort "Sort format is {column: \"asc\" or \"desc\"}.",
:fields "Rolesfields for aggregation.",
:aggregate "Aggrecate Roles.",
:pks "Primary key fields.",
:pk-input "Primary key fields."},
:groups
{:lcn-fields
{:rsc
{:access {:type Int},
:created_at {:type String},
:edited_at {:type String},
:id {:type Int},
:title {:type String},
:user_id {:type String},
:description {:type String}},
:clauses
{:description {:type :StrWhere},
:or {:type (list :GroupClauses)},
:title {:type :StrWhere},
:id {:type :IntWhere},
:and {:type (list :GroupClauses)},
:user_id {:type :StrWhere},
:access {:type :IntWhere},
:edited_at {:type :StrWhere},
:created_at {:type :StrWhere}},
:sort
{:access {:type :SortOperator},
:created_at {:type :SortOperator},
:edited_at {:type :SortOperator},
:id {:type :SortOperator},
:title {:type :SortOperator},
:user_id {:type :SortOperator},
:description {:type :SortOperator}},
:fields
{:access {:type Int},
:created_at {:type String},
:edited_at {:type String},
:id {:type Int},
:title {:type String},
:user_id {:type String},
:description {:type String}},
:aggregate
{:count {:type Int},
:sum {:type :GroupFields},
:avg {:type :GroupFields},
:max {:type :GroupFields},
:min {:type :GroupFields}},
:pks {:id {:type (non-null Int)}},
:pk-input {:id {:type (non-null Int)}},
:update
{:access {:type Int},
:created_at {:type String},
:edited_at {:type String},
:title {:type String},
:user_id {:type String},
:description {:type String}}},
:fks
{:access
{:field-keys
{:to :Access,
:has-many :groups,
:has-many-aggr :groups_aggregate,
:has-one :access_access}},
:user_id
{:field-keys
{:to :User,
:has-many :groups,
:has-many-aggr :groups_aggregate,
:has-one :user}}},
:lcn-mut-keys
{:create :createGroup,
:update :updateGroup,
:delete :deleteGroup},
:lcn-obj-keys
{:rsc :Group,
:clauses :GroupClauses,
:where :GroupWhere,
:sort :GroupSort,
:fields :GroupFields,
:aggregate :GroupAggregate,
:pks :GroupPks,
:pk-input :GroupPkColumns},
:lcn-qry-keys {:queries :groups, :aggregate :groups_aggregate},
:lcn-descs
{:rsc "Groups",
:query "Query Groups.",
:clauses
"Format for where clauses is {column: {operator: value}}. Multiple parameters are applied with `AND` operators. `AND`/`OR` conditions can be created as a list of clauses. It is possible to nest them to create sub groups of conditions.",
:sort "Sort format is {column: \"asc\" or \"desc\"}.",
:fields "Groupsfields for aggregation.",
:aggregate "Aggrecate Groups.",
:pks "Primary key fields.",
:pk-input "Primary key fields."},
:signals
{:query {:pre (), :post ()},
:create {:pre (), :post ()},
:delete {:pre (), :post ()},
:update {:pre (), :post ()}},
:pk-keys (:id),
:col-keys
#{:description
:title
:id
:user_id
:access
:edited_at
:created_at}},
:signals
{:query {:pre (), :post ()},
:create {:pre (), :post ()},
:delete {:pre (), :post ()},
:update {:pre (), :post ()}},
:pk-keys (:id),
:col-keys #{:color :title :group_id :id}},
:lcn-obj-keys
{:rsc :Access,
:clauses :AccessClauses,
:where :AccessWhere,
:sort :AccessSort,
:fields :AccessFields,
:aggregate :AccessAggregate,
:pks :AccessPks,
:pk-input :AccessPkColumns},
:lcn-qry-keys
{:queries :accesses, :aggregate :accesses_aggregate},
:lcn-descs
{:rsc "Accesses",
:query "Query Accesses.",
:clauses
"Format for where clauses is {column: {operator: value}}. Multiple parameters are applied with `AND` operators. `AND`/`OR` conditions can be created as a list of clauses. It is possible to nest them to create sub groups of conditions.",
:sort "Sort format is {column: \"asc\" or \"desc\"}.",
:fields "Accessesfields for aggregation.",
:aggregate "Aggrecate Accesses.",
:pks "Primary key fields.",
:pk-input "Primary key fields."},
:groups
{:lcn-fields
{:rsc
{:access {:type Int},
:created_at {:type String},
:edited_at {:type String},
:id {:type Int},
:title {:type String},
:user_id {:type String},
:description {:type String}},
:clauses
{:description {:type :StrWhere},
:or {:type (list :GroupClauses)},
:title {:type :StrWhere},
:id {:type :IntWhere},
:and {:type (list :GroupClauses)},
:user_id {:type :StrWhere},
:access {:type :IntWhere},
:edited_at {:type :StrWhere},
:created_at {:type :StrWhere}},
:sort
{:access {:type :SortOperator},
:created_at {:type :SortOperator},
:edited_at {:type :SortOperator},
:id {:type :SortOperator},
:title {:type :SortOperator},
:user_id {:type :SortOperator},
:description {:type :SortOperator}},
:fields
{:access {:type Int},
:created_at {:type String},
:edited_at {:type String},
:id {:type Int},
:title {:type String},
:user_id {:type String},
:description {:type String}},
:aggregate
{:count {:type Int},
:sum {:type :GroupFields},
:avg {:type :GroupFields},
:max {:type :GroupFields},
:min {:type :GroupFields}},
:pks {:id {:type (non-null Int)}},
:pk-input {:id {:type (non-null Int)}},
:update
{:access {:type Int},
:created_at {:type String},
:edited_at {:type String},
:title {:type String},
:user_id {:type String},
:description {:type String}}},
:fks
{:access
{:field-keys
{:to :Access,
:has-many :groups,
:has-many-aggr :groups_aggregate,
:has-one :access_access}},
:user_id
{:field-keys
{:to :User,
:has-many :groups,
:has-many-aggr :groups_aggregate,
:has-one :user}}},
:lcn-mut-keys
{:create :createGroup,
:update :updateGroup,
:delete :deleteGroup},
:lcn-obj-keys
{:rsc :Group,
:clauses :GroupClauses,
:where :GroupWhere,
:sort :GroupSort,
:fields :GroupFields,
:aggregate :GroupAggregate,
:pks :GroupPks,
:pk-input :GroupPkColumns},
:lcn-qry-keys {:queries :groups, :aggregate :groups_aggregate},
:lcn-descs
{:rsc "Groups",
:query "Query Groups.",
:clauses
"Format for where clauses is {column: {operator: value}}. Multiple parameters are applied with `AND` operators. `AND`/`OR` conditions can be created as a list of clauses. It is possible to nest them to create sub groups of conditions.",
:sort "Sort format is {column: \"asc\" or \"desc\"}.",
:fields "Groupsfields for aggregation.",
:aggregate "Aggrecate Groups.",
:pks "Primary key fields.",
:pk-input "Primary key fields."},
:signals
{:query {:pre (), :post ()},
:create {:pre (), :post ()},
:delete {:pre (), :post ()},
:update {:pre (), :post ()}},
:pk-keys (:id),
:col-keys
#{:description
:title
:id
:user_id
:access
:edited_at
:created_at}},
:signals
{:query {:pre (), :post ()},
:create {:pre (), :post ()},
:delete {:pre (), :post ()},
:update {:pre (), :post ()}},
:pk-keys (:id),
:col-keys
#{:can_read
:inherit
:can_edit
:group_id
:id
:user_id
:role_id
:next_access
:owner}},
:groups
{:lcn-fields
{:rsc
{:access {:type Int},
:created_at {:type String},
:edited_at {:type String},
:id {:type Int},
:title {:type String},
:user_id {:type String},
:description {:type String}},
:clauses
{:description {:type :StrWhere},
:or {:type (list :GroupClauses)},
:title {:type :StrWhere},
:id {:type :IntWhere},
:and {:type (list :GroupClauses)},
:user_id {:type :StrWhere},
:access {:type :IntWhere},
:edited_at {:type :StrWhere},
:created_at {:type :StrWhere}},
:sort
{:access {:type :SortOperator},
:created_at {:type :SortOperator},
:edited_at {:type :SortOperator},
:id {:type :SortOperator},
:title {:type :SortOperator},
:user_id {:type :SortOperator},
:description {:type :SortOperator}},
:fields
{:access {:type Int},
:created_at {:type String},
:edited_at {:type String},
:id {:type Int},
:title {:type String},
:user_id {:type String},
:description {:type String}},
:aggregate
{:count {:type Int},
:sum {:type :GroupFields},
:avg {:type :GroupFields},
:max {:type :GroupFields},
:min {:type :GroupFields}},
:pks {:id {:type (non-null Int)}},
:pk-input {:id {:type (non-null Int)}},
:update
{:access {:type Int},
:created_at {:type String},
:edited_at {:type String},
:title {:type String},
:user_id {:type String},
:description {:type String}}},
:fks
{:access
{:field-keys
{:to :Access,
:has-many :groups,
:has-many-aggr :groups_aggregate,
:has-one :access_access}},
:user_id
{:field-keys
{:to :User,
:has-many :groups,
:has-many-aggr :groups_aggregate,
:has-one :user}}},
:lcn-mut-keys
{:create :createGroup,
:update :updateGroup,
:delete :deleteGroup},
:lcn-obj-keys
{:rsc :Group,
:clauses :GroupClauses,
:where :GroupWhere,
:sort :GroupSort,
:fields :GroupFields,
:aggregate :GroupAggregate,
:pks :GroupPks,
:pk-input :GroupPkColumns},
:lcn-qry-keys {:queries :groups, :aggregate :groups_aggregate},
:lcn-descs
{:rsc "Groups",
:query "Query Groups.",
:clauses
"Format for where clauses is {column: {operator: value}}. Multiple parameters are applied with `AND` operators. `AND`/`OR` conditions can be created as a list of clauses. It is possible to nest them to create sub groups of conditions.",
:sort "Sort format is {column: \"asc\" or \"desc\"}.",
:fields "Groupsfields for aggregation.",
:aggregate "Aggrecate Groups.",
:pks "Primary key fields.",
:pk-input "Primary key fields."},
:signals
{:query {:pre (), :post ()},
:create {:pre (), :post ()},
:delete {:pre (), :post ()},
:update {:pre (), :post ()}},
:pk-keys (:id),
:col-keys
#{:description
:title
:id
:user_id
:access
:edited_at
:created_at}},
:signals
{:query {:pre (), :post ()},
:create {:pre (), :post ()},
:delete {:pre (), :post ()},
:update {:pre (), :post ()}},
:pk-keys (:user_id :group_id :role_id),
:col-keys #{:group_id :user_id :role_id}}}},
:use-aggregation true,
:middleware nil,
:scan-views true,
:max-nest-level nil,
:signal-ctx nil,
:relation-ctx
{:nest-fks
{:groups
{:access_access
{:from :access,
:table :access,
:to :id,
:from-table :groups,
:type :has-one},
:user
{:from :user_id,
:table :users,
:to :user_name,
:from-table :groups,
:type :has-one},
:roles
{:from :group_id,
:table :groups,
:to :id,
:from-table :roles,
:type :has-many},
:roles_aggregate
{:from :group_id,
:table :groups,
:to :id,
:from-table :roles,
:type :has-many-aggr},
:accesses
{:from :group_id,
:table :groups,
:to :id,
:from-table :access,
:type :has-many},
:accesses_aggregate
{:from :group_id,
:table :groups,
:to :id,
:from-table :access,
:type :has-many-aggr},
:users_in_groups
{:from :group_id,
:table :groups,
:to :id,
:from-table :users_in_groups,
:type :has-many},
:users_in_groups_aggregate
{:from :group_id,
:table :groups,
:to :id,
:from-table :users_in_groups,
:type :has-many-aggr}},
:access
{:role
{:from :role_id,
:table :roles,
:to :id,
:from-table :access,
:type :has-one},
:groups_aggregate
{:from :access,
:table :access,
:to :id,
:from-table :groups,
:type :has-many-aggr},
:votes
{:from :access,
:table :access,
:to :id,
:from-table :votes,
:type :has-many},
:attributes_aggregate
{:from :access,
:table :access,
:to :id,
:from-table :attributes,
:type :has-many-aggr},
:group
{:from :group_id,
:table :groups,
:to :id,
:from-table :access,
:type :has-one},
:accesses_aggregate
{:from :next_access,
:table :access,
:to :id,
:from-table :access,
:type :has-many-aggr},
:next_access_access
{:from :next_access,
:table :access,
:to :id,
:from-table :access,
:type :has-one},
:votes_aggregate
{:from :access,
:table :access,
:to :id,
:from-table :votes,
:type :has-many-aggr},
:items_aggregate
{:from :access,
:table :access,
:to :id,
:from-table :items,
:type :has-many-aggr},
:groups
{:from :access,
:table :access,
:to :id,
:from-table :groups,
:type :has-many},
:items
{:from :access,
:table :access,
:to :id,
:from-table :items,
:type :has-many},
:attributes
{:from :access,
:table :access,
:to :id,
:from-table :attributes,
:type :has-many},
:user
{:from :user_id,
:table :users,
:to :user_name,
:from-table :access,
:type :has-one},
:accesses
{:from :next_access,
:table :access,
:to :id,
:from-table :access,
:type :has-many}},
:users
{:groups
{:from :user_id,
:table :users,
:to :user_name,
:from-table :groups,
:type :has-many},
:groups_aggregate
{:from :user_id,
:table :users,
:to :user_name,
:from-table :groups,
:type :has-many-aggr},
:accesses
{:from :user_id,
:table :users,
:to :user_name,
:from-table :access,
:type :has-many},
:accesses_aggregate
{:from :user_id,
:table :users,
:to :user_name,
:from-table :access,
:type :has-many-aggr},
:users_in_groups
{:from :user_id,
:table :users,
:to :user_name,
:from-table :users_in_groups,
:type :has-many},
:users_in_groups_aggregate
{:from :user_id,
:table :users,
:to :user_name,
:from-table :users_in_groups,
:type :has-many-aggr}},
:roles
{:group
{:from :group_id,
:table :groups,
:to :id,
:from-table :roles,
:type :has-one},
:accesses
{:from :role_id,
:table :roles,
:to :id,
:from-table :access,
:type :has-many},
:accesses_aggregate
{:from :role_id,
:table :roles,
:to :id,
:from-table :access,
:type :has-many-aggr},
:users_in_groups
{:from :role_id,
:table :roles,
:to :id,
:from-table :users_in_groups,
:type :has-many},
:users_in_groups_aggregate
{:from :role_id,
:table :roles,
:to :id,
:from-table :users_in_groups,
:type :has-many-aggr}},
:users_in_groups
{:user
{:from :user_id,
:table :users,
:to :user_name,
:from-table :users_in_groups,
:type :has-one},
:group
{:from :group_id,
:table :groups,
:to :id,
:from-table :users_in_groups,
:type :has-one},
:role
{:from :role_id,
:table :roles,
:to :id,
:from-table :users_in_groups,
:type :has-one}},
:items
{:access_access
{:from :access,
:table :access,
:to :id,
:from-table :items,
:type :has-one},
:votes_on_left_item_id
{:from :left_item_id,
:table :items,
:to :id,
:from-table :votes,
:type :has-many},
:votes_on_left_item_id_aggregate
{:from :left_item_id,
:table :items,
:to :id,
:from-table :votes,
:type :has-many-aggr},
:votes_on_right_item_id
{:from :right_item_id,
:table :items,
:to :id,
:from-table :votes,
:type :has-many},
:votes_on_right_item_id_aggregate
{:from :right_item_id,
:table :items,
:to :id,
:from-table :votes,
:type :has-many-aggr}},
:attributes
{:access_access
{:from :access,
:table :access,
:to :id,
:from-table :attributes,
:type :has-one},
:votes
{:from :attribute,
:table :attributes,
:to :id,
:from-table :votes,
:type :has-many},
:votes_aggregate
{:from :attribute,
:table :attributes,
:to :id,
:from-table :votes,
:type :has-many-aggr}},
:votes
{:access_access
{:from :access,
:table :access,
:to :id,
:from-table :votes,
:type :has-one},
:left_item
{:from :left_item_id,
:table :items,
:to :id,
:from-table :votes,
:type :has-one},
:right_item
{:from :right_item_id,
:table :items,
:to :id,
:from-table :votes,
:type :has-one},
:attribute_attribute
{:from :attribute,
:table :attributes,
:to :id,
:from-table :votes,
:type :has-one}}}},
:default-limit nil,
:views {},
:db-adapter
#phrag.db.postgres.PostgresAdapter {:db {:connection #object [org.postgresql.jdbc.PgConnection 302381606 "org.postgresql.jdbc.PgConnection@1205fa26"]}}})
Raw
error.txt
This file has been truncated, but you can view the full file.
Show: Project-Only All
Hide: Clojure Java REPL Tooling Duplicates (13 frames hidden)
1. Unhandled clojure.lang.ExceptionInfo
Arguments to compile do not conform to spec: nil - failed:
simple-keyword? in: [0 :input-objects :AttributeClauses 1 :fields
:attribute_name 1 :type] at: [:schema :input-objects 1 :fields 1
:type :base-type :keyword] spec:
:com.walmartlabs.lacinia.schema/type-name nil - failed:
simple-symbol? in: [0 :input-objects :AttributeClauses 1 :fields
:attribute_name 1 :type] at: [:schema :input-objects 1 :fields 1
:type :base-type :symbol] spec:
:com.walmartlabs.lacinia.schema/type-name () - failed: Insufficient
input in: [0 :input-objects :AttributeClauses 1 :fields
:attribute_name 1 :type] at: [:schema :input-objects 1 :fields 1
:type :wrapped-type :modifier] spec:
:com.walmartlabs.lacinia.schema/wrapped-type-modifier nil - failed:
simple-keyword? in: [0 :input-objects :AttributeClauses 1 :fields
:udt_schema 1 :type] at: [:schema :input-objects 1 :fields 1 :type
:base-type :keyword] spec:
:com.walmartlabs.lacinia.schema/type-name nil - failed:
simple-symbol? in: [0 :input-objects :AttributeClauses 1 :fields
:udt_schema 1 :type] at: [:schema :input-objects 1 :fields 1 :type
:base-type :symbol] spec: :com.walmartlabs.lacinia.schema/type-name
() - failed: Insufficient input in: [0 :input-objects
:AttributeClauses 1 :fields :udt_schema 1 :type] at: [:schema
:input-objects 1 :fields 1 :type :wrapped-type :modifier] spec:
:com.walmartlabs.lacinia.schema/wrapped-type-modifier nil - failed:
simple-keyword? in: [0 :input-objects :AttributeClauses 1 :fields
:collation_schema 1 :type] at: [:schema :input-objects 1 :fields 1
:type :base-type :keyword] spec:
:com.walmartlabs.lacinia.schema/type-name nil - failed:
simple-symbol? in: [0 :input-objects :AttributeClauses 1 :fields
:collation_schema 1 :type] at: [:schema :input-objects 1 :fields 1
:type :base-type :symbol] spec:
:com.walmartlabs.lacinia.schema/type-name () - failed: Insufficient
input in: [0 :input-objects :AttributeClauses 1 :fields
:collation_schema 1 :type] at: [:schema :input-objects 1 :fields 1
:type :wrapped-type :modifier] spec:
:com.walmartlabs.lacinia.schema/wrapped-type-modifier nil - failed:
simple-keyword? in: [0 :input-objects :AttributeClauses 1 :fields
:character_set_schema 1 :type] at: [:schema :input-objects 1
:fields 1 :type :base-type :keyword] spec:
:com.walmartlabs.lacinia.schema/type-name nil - failed:
simple-symbol? in: [0 :input-objects :AttributeClauses 1 :fields
:character_set_schema 1 :type] at: [:schema :input-objects 1
:fields 1 :type :base-type :symbol] spec:
:com.walmartlabs.lacinia.schema/type-name () - failed: Insufficient
input in: [0 :input-objects :AttributeClauses 1 :fields
:character_set_schema 1 :type] at: [:schema :input-objects 1
:fields 1 :type :wrapped-type :modifier] spec:
:com.walmartlabs.lacinia.schema/wrapped-type-modifier nil - failed:
simple-keyword? in: [0 :input-objects :AttributeClauses 1 :fields
:dtd_identifier 1 :type] at: [:schema :input-objects 1 :fields 1
:type :base-type :keyword] spec:
:com.walmartlabs.lacinia.schema/type-name nil - failed:
simple-symbol? in: [0 :input-objects :AttributeClauses 1 :fields
:dtd_identifier 1 :type] at: [:schema :input-objects 1 :fields 1
:type :base-type :symbol] spec:
:com.walmartlabs.lacinia.schema/type-name () - failed: Insufficient
input in: [0 :input-objects :AttributeClauses 1 :fields
:dtd_identifier 1 :type] at: [:schema :input-objects 1 :fields 1
:type :wrapped-type :modifier] spec:
:com.walmartlabs.lacinia.schema/wrapped-type-modifier nil - failed:
simple-keyword? in: [0 :input-objects :AttributeClauses 1 :fields
:scope_catalog 1 :type] at: [:schema :input-objects 1 :fields 1
:type :base-type :keyword] spec:
:com.walmartlabs.lacinia.schema/type-name nil - failed:
simple-symbol? in: [0 :input-objects :AttributeClauses 1 :fields
:scope_catalog 1 :type] at: [:schema :input-objects 1 :fields 1
:type :base-type :symbol] spec:
:com.walmartlabs.lacinia.schema/type-name () - failed: Insufficient
input in: [0 :input-objects :AttributeClauses 1 :fields
:scope_catalog 1 :type] at: [:schema :input-objects 1 :fields 1
:type :wrapped-type :modifier] spec:
:com.walmartlabs.lacinia.schema/wrapped-type-modifier nil - failed:
simple-keyword? in: [0 :input-objects :AttributeClauses 1 :fields
:collation_catalog 1 :type] at: [:schema :input-objects 1 :fields 1
:type :base-type :keyword] spec:
:com.walmartlabs.lacinia.schema/type-name nil - failed:
simple-symbol? in: [0 :input-objects :AttributeClauses 1 :fields
:collation_catalog 1 :type] at: [:schema :input-objects 1 :fields 1
:type :base-type :symbol] spec:
:com.walmartlabs.lacinia.schema/type-name () - failed: Insufficient
input in: [0 :input-objects :AttributeClauses 1 :fields
:collation_catalog 1 :type] at: [:schema :input-objects 1 :fields 1
:type :wrapped-type :modifier] spec:
:com.walmartlabs.lacinia.schema/wrapped-type-modifier nil - failed:
simple-keyword? in: [0 :input-objects :AttributeClauses 1 :fields
:character_set_catalog 1 :type] at: [:schema :input-objects 1
:fields 1 :type :base-type :keyword] spec:
:com.walmartlabs.lacinia.schema/type-name nil - failed:
simple-symbol? in: [0 :input-objects :AttributeClauses 1 :fields
:character_set_catalog 1 :type] at: [:schema :input-objects 1
:fields 1 :type :base-type :symbol] spec:
:com.walmartlabs.lacinia.schema/type-name () - failed: Insufficient
input in: [0 :input-objects :AttributeClauses 1 :fields
:character_set_catalog 1 :type] at: [:schema :input-objects 1
:fields 1 :type :wrapped-type :modifier] spec:
:com.walmartlabs.lacinia.schema/wrapped-type-modifier nil - failed:
simple-keyword? in: [0 :input-objects :AttributeClauses 1 :fields
:udt_catalog 1 :type] at: [:schema :input-objects 1 :fields 1 :type
:base-type :keyword] spec:
:com.walmartlabs.lacinia.schema/type-name nil - failed:
simple-symbol? in: [0 :input-objects :AttributeClauses 1 :fields
:udt_catalog 1 :type] at: [:schema :input-objects 1 :fields 1 :type
:base-type :symbol] spec: :com.walmartlabs.lacinia.schema/type-name
() - failed: Insufficient input in: [0 :input-objects
:AttributeClauses 1 :fields :udt_catalog 1 :type] at: [:schema
:input-objects 1 :fields 1 :type :wrapped-type :modifier] spec:
:com.walmartlabs.lacinia.schema/wrapped-type-modifier nil - failed:
simple-keyword? in: [0 :input-objects :AttributeClauses 1 :fields
:scope_schema 1 :type] at: [:schema :input-objects 1 :fields 1
:type :base-type :keyword] spec:
:com.walmartlabs.lacinia.schema/type-name nil - failed:
simple-symbol? in: [0 :input-objects :AttributeClauses 1 :fields
:scope_schema 1 :type] at: [:schema :input-objects 1 :fields 1
:type :base-type :symbol] spec:
:com.walmartlabs.lacinia.schema/type-name () - failed: Insufficient
input in: [0 :input-objects :AttributeClauses 1 :fields
:scope_schema 1 :type] at: [:schema :input-objects 1 :fields 1
:type :wrapped-type :modifier] spec:
:com.walmartlabs.lacinia.schema/wrapped-type-modifier nil - failed:
simple-keyword? in: [0 :input-objects :AttributeClauses 1 :fields
:character_set_name 1 :type] at: [:schema :input-objects 1 :fields
1 :type :base-type :keyword] spec:
:com.walmartlabs.lacinia.schema/type-name nil - failed:
simple-symbol? in: [0 :input-objects :AttributeClauses 1 :fields
:character_set_name 1 :type] at: [:schema :input-objects 1 :fields
1 :type :base-type :symbol] spec:
:com.walmartlabs.lacinia.schema/type-name () - failed: Insufficient
input in: [0 :input-objects :AttributeClauses 1 :fields
:character_set_name 1 :type] at: [:schema :input-objects 1 :fields
1 :type :wrapped-type :modifier] spec:
:com.walmartlabs.lacinia.schema/wrapped-type-modifier nil - failed:
simple-keyword? in: [0 :input-objects :AttributeClauses 1 :fields
:attribute_udt_catalog 1 :type] at: [:schema :input-objects 1
:fields 1 :type :base-type :keyword] spec:
:com.walmartlabs.lacinia.schema/type-name nil - failed:
simple-symbol? in: [0 :input-objects :AttributeClauses 1 :fields
:attribute_udt_catalog 1 :type] at: [:schema :input-objects 1
:fields 1 :type :base-type :symbol] spec:
:com.walmartlabs.lacinia.schema/type-name () - failed: Insufficient
input in: [0 :input-objects :AttributeClauses 1 :fields
:attribute_udt_catalog 1 :type] at: [:schema :input-objects 1
:fields 1 :type :wrapped-type :modifier] spec:
:com.walmartlabs.lacinia.schema/wrapped-type-modifier nil - failed:
simple-keyword? in: [0 :input-objects :AttributeClauses 1 :fields
:collation_name 1 :type] at: [:schema :input-objects 1 :fields 1
:type :base-type :keyword] spec:
:com.walmartlabs.lacinia.schema/type-name nil - failed:
simple-symbol? in: [0 :input-objects :AttributeClauses 1 :fields
:collation_name 1 :type] at: [:schema :input-objects 1 :fields 1
:type :base-type :symbol] spec:
:com.walmartlabs.lacinia.schema/type-name () - failed: Insufficient
input in: [0 :input-objects :AttributeClauses 1 :fields
:collation_name 1 :type] at: [:schema :input-objects 1 :fields 1
:type :wrapped-type :modifier] spec:
:com.walmartlabs.lacinia.schema/wrapped-type-modifier nil - failed:
simple-keyword? in: [0 :input-objects :AttributeClauses 1 :fields
:attribute_udt_schema 1 :type] at: [:schema :input-objects 1
:fields 1 :type :base-type :keyword] spec:
:com.walmartlabs.lacinia.schema/type-name nil - failed:
simple-symbol? in: [0 :input-objects :AttributeClauses 1 :fields
:attribute_udt_schema 1 :type] at: [:schema :input-objects 1
:fields 1 :type :base-type :symbol] spec:
:com.walmartlabs.lacinia.schema/type-name () - failed: Insufficient
input in: [0 :input-objects :AttributeClauses 1 :fields
:attribute_udt_schema 1 :type] at: [:schema :input-objects 1
:fields 1 :type :wrapped-type :modifier] spec:
:com.walmartlabs.lacinia.schema/wrapped-type-modifier nil - failed:
simple-keyword? in: [0 :input-objects :AttributeClauses 1 :fields
:scope_name 1 :type] at: [:schema :input-objects 1 :fields 1 :type
:base-type :keyword] spec:
:com.walmartlabs.lacinia.schema/type-name nil - failed:
simple-symbol? in: [0 :input-objects :AttributeClauses 1 :fields
:scope_name 1 :type] at: [:schema :input-objects 1 :fields 1 :type
:base-type :symbol] spec: :com.walmartlabs.lacinia.schema/type-name
() - failed: Insufficient input in: [0 :input-objects
:AttributeClauses 1 :fields :scope_name 1 :type] at: [:schema
:input-objects 1 :fields 1 :type :wrapped-type :modifier] spec:
:com.walmartlabs.lacinia.schema/wrapped-type-modifier nil - failed:
simple-keyword? in: [0 :input-objects :AttributeClauses 1 :fields
:udt_name 1 :type] at: [:schema :input-objects 1 :fields 1 :type
:base-type :keyword] spec:
:com.walmartlabs.lacinia.schema/type-name nil - failed:
simple-symbol? in: [0 :input-objects :AttributeClauses 1 :fields
:udt_name 1 :type] at: [:schema :input-objects 1 :fields 1 :type
:base-type :symbol] spec: :com.walmartlabs.lacinia.schema/type-name
() - failed: Insufficient input in: [0 :input-objects
:AttributeClauses 1 :fields :udt_name 1 :type] at: [:schema
:input-objects 1 :fields 1 :type :wrapped-type :modifier] spec:
:com.walmartlabs.lacinia.schema/wrapped-type-modifier nil - failed:
simple-keyword? in: [0 :input-objects :AttributeClauses 1 :fields
:attribute_udt_name 1 :type] at: [:schema :input-objects 1 :fields
1 :type :base-type :keyword] spec:
:com.walmartlabs.lacinia.schema/type-name nil - failed:
simple-symbol? in: [0 :input-objects :AttributeClauses 1 :fields
:attribute_udt_name 1 :type] at: [:schema :input-objects 1 :fields
1 :type :base-type :symbol] spec:
:com.walmartlabs.lacinia.schema/type-name () - failed: Insufficient
input in: [0 :input-objects :AttributeClauses 1 :fields
:attribute_udt_name 1 :type] at: [:schema :input-objects 1 :fields
1 :type :wrapped-type :modifier] spec:
:com.walmartlabs.lacinia.schema/wrapped-type-modifier nil - failed:
simple-keyword? in: [0 :objects :AttributeFields 1 :fields
:attribute_name 1 :type] at: [:schema :objects 1 :fields 1 :type
:base-type :keyword] spec:
:com.walmartlabs.lacinia.schema/type-name nil - failed:
simple-symbol? in: [0 :objects :AttributeFields 1 :fields
:attribute_name 1 :type] at: [:schema :objects 1 :fields 1 :type
:base-type :symbol] spec: :com.walmartlabs.lacinia.schema/type-name
() - failed: Insufficient input in: [0 :objects :AttributeFields 1
:fields :attribute_name 1 :type] at: [:schema :objects 1 :fields 1
:type :wrapped-type :modifier] spec:
:com.walmartlabs.lacinia.schema/wrapped-type-modifier nil - failed:
simple-keyword? in: [0 :objects :AttributeFields 1 :fields
:udt_schema 1 :type] at: [:schema :objects 1 :fields 1 :type
:base-type :keyword] spec:
:com.walmartlabs.lacinia.schema/type-name nil - failed:
simple-symbol? in: [0 :objects :AttributeFields 1 :fields
:udt_schema 1 :type] at: [:schema :objects 1 :fields 1 :type
:base-type :symbol] spec: :com.walmartlabs.lacinia.schema/type-name
() - failed: Insufficient input in: [0 :objects :AttributeFields 1
:fields :udt_schema 1 :type] at: [:schema :objects 1 :fields 1
:type :wrapped-type :modifier] spec:
:com.walmartlabs.lacinia.schema/wrapped-type-modifier nil - failed:
simple-keyword? in: [0 :objects :AttributeFields 1 :fields
:collation_schema 1 :type] at: [:schema :objects 1 :fields 1 :type
:base-type :keyword] spec:
:com.walmartlabs.lacinia.schema/type-name nil - failed:
simple-symbol? in: [0 :objects :AttributeFields 1 :fields
:collation_schema 1 :type] at: [:schema :objects 1 :fields 1 :type
:base-type :symbol] spec: :com.walmartlabs.lacinia.schema/type-name
() - failed: Insufficient input in: [0 :objects :AttributeFields 1
:fields :collation_schema 1 :type] at: [:schema :objects 1 :fields
1 :type :wrapped-type :modifier] spec:
:com.walmartlabs.lacinia.schema/wrapped-type-modifier nil - failed:
simple-keyword? in: [0 :objects :AttributeFields 1 :fields
:character_set_schema 1 :type] at: [:schema :objects 1 :fields 1
:type :base-type :keyword] spec:
:com.walmartlabs.lacinia.schema/type-name nil - failed:
simple-symbol? in: [0 :objects :AttributeFields 1 :fields
:character_set_schema 1 :type] at: [:schema :objects 1 :fields 1
:type :base-type :symbol] spec:
:com.walmartlabs.lacinia.schema/type-name () - failed: Insufficient
input in: [0 :objects :AttributeFields 1 :fields
:character_set_schema 1 :type] at: [:schema :objects 1 :fields 1
:type :wrapped-type :modifier] spec:
:com.walmartlabs.lacinia.schema/wrapped-type-modifier nil - failed:
simple-keyword? in: [0 :objects :AttributeFields 1 :fields
:dtd_identifier 1 :type] at: [:schema :objects 1 :fields 1 :type
:base-type :keyword] spec:
:com.walmartlabs.lacinia.schema/type-name nil - failed:
simple-symbol? in: [0 :objects :AttributeFields 1 :fields
:dtd_identifier 1 :type] at: [:schema :objects 1 :fields 1 :type
:base-type :symbol] spec: :com.walmartlabs.lacinia.schema/type-name
() - failed: Insufficient input in: [0 :objects :AttributeFields 1
:fields :dtd_identifier 1 :type] at: [:schema :objects 1 :fields 1
:type :wrapped-type :modifier] spec:
:com.walmartlabs.lacinia.schema/wrapped-type-modifier nil - failed:
simple-keyword? in: [0 :objects :AttributeFields 1 :fields
:scope_catalog 1 :type] at: [:schema :objects 1 :fields 1 :type
:base-type :keyword] spec:
:com.walmartlabs.lacinia.schema/type-name nil - failed:
simple-symbol? in: [0 :objects :AttributeFields 1 :fields
:scope_catalog 1 :type] at: [:schema :objects 1 :fields 1 :type
:base-type :symbol] spec: :com.walmartlabs.lacinia.schema/type-name
() - failed: Insufficient input in: [0 :objects :AttributeFields 1
:fields :scope_catalog 1 :type] at: [:schema :objects 1 :fields 1
:type :wrapped-type :modifier] spec:
:com.walmartlabs.lacinia.schema/wrapped-type-modifier nil - failed:
simple-keyword? in: [0 :objects :AttributeFields 1 :fields
:collation_catalog 1 :type] at: [:schema :objects 1 :fields 1 :type
:base-type :keyword] spec:
:com.walmartlabs.lacinia.schema/type-name nil - failed:
simple-symbol? in: [0 :objects :AttributeFields 1 :fields
:collation_catalog 1 :type] at: [:schema :objects 1 :fields 1 :type
:base-type :symbol] spec: :com.walmartlabs.lacinia.schema/type-name
() - failed: Insufficient input in: [0 :objects :AttributeFields 1
:fields :collation_catalog 1 :type] at: [:schema :objects 1 :fields
1 :type :wrapped-type :modifier] spec:
:com.walmartlabs.lacinia.schema/wrapped-type-modifier nil - failed:
simple-keyword? in: [0 :objects :AttributeFields 1 :fields
:character_set_catalog 1 :type] at: [:schema :objects 1 :fields 1
:type :base-type :keyword] spec:
:com.walmartlabs.lacinia.schema/type-name nil - failed:
simple-symbol? in: [0 :objects :AttributeFields 1 :fields
:character_set_catalog 1 :type] at: [:schema :objects 1 :fields 1
:type :base-type :symbol] spec:
:com.walmartlabs.lacinia.schema/type-name () - failed: Insufficient
input in: [0 :objects :AttributeFields 1 :fields
:character_set_catalog 1 :type] at: [:schema :objects 1 :fields 1
:type :wrapped-type :modifier] spec:
:com.walmartlabs.lacinia.schema/wrapped-type-modifier nil - failed:
simple-keyword? in: [0 :objects :AttributeFields 1 :fields
:udt_catalog 1 :type] at: [:schema :objects 1 :fields 1 :type
:base-type :keyword] spec:
:com.walmartlabs.lacinia.schema/type-name nil - failed:
simple-symbol? in: [0 :objects :AttributeFields 1 :fields
:udt_catalog 1 :type] at: [:schema :objects 1 :fields 1 :type
:base-type :symbol] spec: :com.walmartlabs.lacinia.schema/type-name
() - failed: Insufficient input in: [0 :objects :AttributeFields 1
:fields :udt_catalog 1 :type] at: [:schema :objects 1 :fields 1
:type :wrapped-type :modifier] spec:
:com.walmartlabs.lacinia.schema/wrapped-type-modifier nil - failed:
simple-keyword? in: [0 :objects :AttributeFields 1 :fields
:scope_schema 1 :type] at: [:schema :objects 1 :fields 1 :type
:base-type :keyword] spec:
:com.walmartlabs.lacinia.schema/type-name nil - failed:
simple-symbol? in: [0 :objects :AttributeFields 1 :fields
:scope_schema 1 :type] at: [:schema :objects 1 :fields 1 :type
:base-type :symbol] spec: :com.walmartlabs.lacinia.schema/type-name
() - failed: Insufficient input in: [0 :objects :AttributeFields 1
:fields :scope_schema 1 :type] at: [:schema :objects 1 :fields 1
:type :wrapped-type :modifier] spec:
:com.walmartlabs.lacinia.schema/wrapped-type-modifier nil - failed:
simple-keyword? in: [0 :objects :AttributeFields 1 :fields
:character_set_name 1 :type] at: [:schema :objects 1 :fields 1
:type :base-type :keyword] spec:
:com.walmartlabs.lacinia.schema/type-name nil - failed:
simple-symbol? in: [0 :objects :AttributeFields 1 :fields
:character_set_name 1 :type] at: [:schema :objects 1 :fields 1
:type :base-type :symbol] spec:
:com.walmartlabs.lacinia.schema/type-name () - failed: Insufficient
input in: [0 :objects :AttributeFields 1 :fields
:character_set_name 1 :type] at: [:schema :objects 1 :fields 1
:type :wrapped-type :modifier] spec:
:com.walmartlabs.lacinia.schema/wrapped-type-modifier nil - failed:
simple-keyword? in: [0 :objects :AttributeFields 1 :fields
:attribute_udt_catalog 1 :type] at: [:schema :objects 1 :fields 1
:type :base-type :keyword] spec:
:com.walmartlabs.lacinia.schema/type-name nil - failed:
simple-symbol? in: [0 :objects :AttributeFields 1 :fields
:attribute_udt_catalog 1 :type] at: [:schema :objects 1 :fields 1
:type :base-type :symbol] spec:
:com.walmartlabs.lacinia.schema/type-name () - failed: Insufficient
input in: [0 :objects :AttributeFields 1 :fields
:attribute_udt_catalog 1 :type] at: [:schema :objects 1 :fields 1
:type :wrapped-type :modifier] spec:
:com.walmartlabs.lacinia.schema/wrapped-type-modifier nil - failed:
simple-keyword? in: [0 :objects :AttributeFields 1 :fields
:collation_name 1 :type] at: [:schema :objects 1 :fields 1 :type
:base-type :keyword] spec:
:com.walmartlabs.lacinia.schema/type-name nil - failed:
simple-symbol? in: [0 :objects :AttributeFields 1 :fields
:collation_name 1 :type] at: [:schema :objects 1 :fields 1 :type
:base-type :symbol] spec: :com.walmartlabs.lacinia.schema/type-name
() - failed: Insufficient input in: [0 :objects :AttributeFields 1
:fields :collation_name 1 :type] at: [:schema :objects 1 :fields 1
:type :wrapped-type :modifier] spec:
:com.walmartlabs.lacinia.schema/wrapped-type-modifier nil - failed:
simple-keyword? in: [0 :objects :AttributeFields 1 :fields
:attribute_udt_schema 1 :type] at: [:schema :objects 1 :fields 1
:type :base-type :keyword] spec:
:com.walmartlabs.lacinia.schema/type-name nil - failed:
simple-symbol? in: [0 :objects :AttributeFields 1 :fields
:attribute_udt_schema 1 :type] at: [:schema :objects 1 :fields 1
:type :base-type :symbol] spec:
:com.walmartlabs.lacinia.schema/type-name () - failed: Insufficient
input in: [0 :objects :AttributeFields 1 :fields
:attribute_udt_schema 1 :type] at: [:schema :objects 1 :fields 1
:type :wrapped-type :modifier] spec:
:com.walmartlabs.lacinia.schema/wrapped-type-modifier nil - failed:
simple-keyword? in: [0 :objects :AttributeFields 1 :fields
:scope_name 1 :type] at: [:schema :objects 1 :fields 1 :type
:base-type :keyword] spec:
:com.walmartlabs.lacinia.schema/type-name nil - failed:
simple-symbol? in: [0 :objects :AttributeFields 1 :fields
:scope_name 1 :type] at: [:schema :objects 1 :fields 1 :type
:base-type :symbol] spec: :com.walmartlabs.lacinia.schema/type-name
() - failed: Insufficient input in: [0 :objects :AttributeFields 1
:fields :scope_name 1 :type] at: [:schema :objects 1 :fields 1
:type :wrapped-type :modifier] spec:
:com.walmartlabs.lacinia.schema/wrapped-type-modifier nil - failed:
simple-keyword? in: [0 :objects :AttributeFields 1 :fields
:udt_name 1 :type] at: [:schema :objects 1 :fields 1 :type
:base-type :keyword] spec:
:com.walmartlabs.lacinia.schema/type-name nil - failed:
simple-symbol? in: [0 :objects :AttributeFields 1 :fields :udt_name
1 :type] at: [:schema :objects 1 :fields 1 :type :base-type
:symbol] spec: :com.walmartlabs.lacinia.schema/type-name () -
failed: Insufficient input in: [0 :objects :AttributeFields 1
:fields :udt_name 1 :type] at: [:schema :objects 1 :fields 1 :type
:wrapped-type :modifier] spec:
:com.walmartlabs.lacinia.schema/wrapped-type-modifier nil - failed:
simple-keyword? in: [0 :objects :AttributeFields 1 :fields
:attribute_udt_name 1 :type] at: [:schema :objects 1 :fields 1
:type :base-type :keyword] spec:
:com.walmartlabs.lacinia.schema/type-name nil - failed:
simple-symbol? in: [0 :objects :AttributeFields 1 :fields
:attribute_udt_name 1 :type] at: [:schema :objects 1 :fields 1
:type :base-type :symbol] spec:
:com.walmartlabs.lacinia.schema/type-name () - failed: Insufficient
input in: [0 :objects :AttributeFields 1 :fields
:attribute_udt_name 1 :type] at: [:schema :objects 1 :fields 1
:type :wrapped-type :modifier] spec:
:com.walmartlabs.lacinia.schema/wrapped-type-modifier nil - failed:
simple-keyword? in: [0 :objects :Attribute 1 :fields
:attribute_name 1 :type] at: [:schema :objects 1 :fields 1 :type
:base-type :keyword] spec:
:com.walmartlabs.lacinia.schema/type-name nil - failed:
simple-symbol? in: [0 :objects :Attribute 1 :fields :attribute_name
1 :type] at: [:schema :objects 1 :fields 1 :type :base-type
:symbol] spec: :com.walmartlabs.lacinia.schema/type-name () -
failed: Insufficient input in: [0 :objects :Attribute 1 :fields
:attribute_name 1 :type] at: [:schema :objects 1 :fields 1 :type
:wrapped-type :modifier] spec:
:com.walmartlabs.lacinia.schema/wrapped-type-modifier nil - failed:
simple-keyword? in: [0 :objects :Attribute 1 :fields :udt_schema 1
:type] at: [:schema :objects 1 :fields 1 :type :base-type :keyword]
spec: :com.walmartlabs.lacinia.schema/type-name nil - failed:
simple-symbol? in: [0 :objects :Attribute 1 :fields :udt_schema 1
:type] at: [:schema :objects 1 :fields 1 :type :base-type :symbol]
spec: :com.walmartlabs.lacinia.schema/type-name () - failed:
Insufficient input in: [0 :objects :Attribute 1 :fields :udt_schema
1 :type] at: [:schema :objects 1 :fields 1 :type :wrapped-type
:modifier] spec:
:com.walmartlabs.lacinia.schema/wrapped-type-modifier nil - failed:
simple-keyword? in: [0 :objects :Attribute 1 :fields
:collation_schema 1 :type] at: [:schema :objects 1 :fields 1 :type
:base-type :keyword] spec:
:com.walmartlabs.lacinia.schema/type-name nil - failed:
simple-symbol? in: [0 :objects :Attribute 1 :fields
:collation_schema 1 :type] at: [:schema :objects 1 :fields 1 :type
:base-type :symbol] spec: :com.walmartlabs.lacinia.schema/type-name
() - failed: Insufficient input in: [0 :objects :Attribute 1
:fields :collation_schema 1 :type] at: [:schema :objects 1 :fields
1 :type :wrapped-type :modifier] spec:
:com.walmartlabs.lacinia.schema/wrapped-type-modifier nil - failed:
simple-keyword? in: [0 :objects :Attribute 1 :fields
:character_set_schema 1 :type] at: [:schema :objects 1 :fields 1
:type :base-type :keyword] spec:
:com.walmartlabs.lacinia.schema/type-name nil - failed:
simple-symbol? in: [0 :objects :Attribute 1 :fields
:character_set_schema 1 :type] at: [:schema :objects 1 :fields 1
:type :base-type :symbol] spec:
:com.walmartlabs.lacinia.schema/type-name () - failed: Insufficient
input in: [0 :objects :Attribute 1 :fields :character_set_schema 1
:type] at: [:schema :objects 1 :fields 1 :type :wrapped-type
:modifier] spec:
:com.walmartlabs.lacinia.schema/wrapped-type-modifier nil - failed:
simple-keyword? in: [0 :objects :Attribute 1 :fields
:dtd_identifier 1 :type] at: [:schema :objects 1 :fields 1 :type
:base-type :keyword] spec:
:com.walmartlabs.lacinia.schema/type-name nil - failed:
simple-symbol? in: [0 :objects :Attribute 1 :fields :dtd_identifier
1 :type] at: [:schema :objects 1 :fields 1 :type :base-type
:symbol] spec: :com.walmartlabs.lacinia.schema/type-name () -
failed: Insufficient input in: [0 :objects :Attribute 1 :fields
:dtd_identifier 1 :type] at: [:schema :objects 1 :fields 1 :type
:wrapped-type :modifier] spec:
:com.walmartlabs.lacinia.schema/wrapped-type-modifier nil - failed:
simple-keyword? in: [0 :objects :Attribute 1 :fields :scope_catalog
1 :type] at: [:schema :objects 1 :fields 1 :type :base-type
:keyword] spec: :com.walmartlabs.lacinia.schema/type-name nil -
failed: simple-symbol? in: [0 :objects :Attribute 1 :fields
:scope_catalog 1 :type] at: [:schema :objects 1 :fields 1 :type
:base-type :symbol] spec: :com.walmartlabs.lacinia.schema/type-name
() - failed: Insufficient input in: [0 :objects :Attribute 1
:fields :scope_catalog 1 :type] at: [:schema :objects 1 :fields 1
:type :wrapped-type :modifier] spec:
:com.walmartlabs.lacinia.schema/wrapped-type-modifier nil - failed:
simple-keyword? in: [0 :objects :Attribute 1 :fields
:collation_catalog 1 :type] at: [:schema :objects 1 :fields 1 :type
:base-type :keyword] spec:
:com.walmartlabs.lacinia.schema/type-name nil - failed:
simple-symbol? in: [0 :objects :Attribute 1 :fields
:collation_catalog 1 :type] at: [:schema :objects 1 :fields 1 :type
:base-type :symbol] spec: :com.walmartlabs.lacinia.schema/type-name
() - failed: Insufficient input in: [0 :objects :Attribute 1
:fields :collation_catalog 1 :type] at: [:schema :objects 1 :fields
1 :type :wrapped-type :modifier] spec:
:com.walmartlabs.lacinia.schema/wrapped-type-modifier nil - failed:
simple-keyword? in: [0 :objects :Attribute 1 :fields
:character_set_catalog 1 :type] at: [:schema :objects 1 :fields 1
:type :base-type :keyword] spec:
:com.walmartlabs.lacinia.schema/type-name nil - failed:
simple-symbol? in: [0 :objects :Attribute 1 :fields
:character_set_catalog 1 :type] at: [:schema :objects 1 :fields 1
:type :base-type :symbol] spec:
:com.walmartlabs.lacinia.schema/type-name () - failed: Insufficient
input in: [0 :objects :Attribute 1 :fields :character_set_catalog 1
:type] at: [:schema :objects 1 :fields 1 :type :wrapped-type
:modifier] spec:
:com.walmartlabs.lacinia.schema/wrapped-type-modifier nil - failed:
simple-keyword? in: [0 :objects :Attribute 1 :fields :udt_catalog 1
:type] at: [:schema :objects 1 :fields 1 :type :base-type :keyword]
spec: :com.walmartlabs.lacinia.schema/type-name nil - failed:
simple-symbol? in: [0 :objects :Attribute 1 :fields :udt_catalog 1
:type] at: [:schema :objects 1 :fields 1 :type :base-type :symbol]
spec: :com.walmartlabs.lacinia.schema/type-name () - failed:
Insufficient input in: [0 :objects :Attribute 1 :fields
:udt_catalog 1 :type] at: [:schema :objects 1 :fields 1 :type
:wrapped-type :modifier] spec:
:com.walmartlabs.lacinia.schema/wrapped-type-modifier nil - failed:
simple-keyword? in: [0 :objects :Attribute 1 :fields :scope_schema
1 :type] at: [:schema :objects 1 :fields 1 :type :base-type
:keyword] spec: :com.walmartlabs.lacinia.schema/type-name nil -
failed: simple-symbol? in: [0 :objects :Attribute 1 :fields
:scope_schema 1 :type] at: [:schema :objects 1 :fields 1 :type
:base-type :symbol] spec: :com.walmartlabs.lacinia.schema/type-name
() - failed: Insufficient input in: [0 :objects :Attribute 1
:fields :scope_schema 1 :type] at: [:schema :objects 1 :fields 1
:type :wrapped-type :modifier] spec:
:com.walmartlabs.lacinia.schema/wrapped-type-modifier nil - failed:
simple-keyword? in: [0 :objects :Attribute 1 :fields
:character_set_name 1 :type] at: [:schema :objects 1 :fields 1
:type :base-type :keyword] spec:
:com.walmartlabs.lacinia.schema/type-name nil - failed:
simple-symbol? in: [0 :objects :Attribute 1 :fields
:character_set_name 1 :type] at: [:schema :objects 1 :fields 1
:type :base-type :symbol] spec:
:com.walmartlabs.lacinia.schema/type-name () - failed: Insufficient
input in: [0 :objects :Attribute 1 :fields :character_set_name 1
:type] at: [:schema :objects 1 :fields 1 :type :wrapped-type
:modifier] spec:
:com.walmartlabs.lacinia.schema/wrapped-type-modifier nil - failed:
simple-keyword? in: [0 :objects :Attribute 1 :fields
:attribute_udt_catalog 1 :type] at: [:schema :objects 1 :fields 1
:type :base-type :keyword] spec:
:com.walmartlabs.lacinia.schema/type-name nil - failed:
simple-symbol? in: [0 :objects :Attribute 1 :fields
:attribute_udt_catalog 1 :type] at: [:schema :objects 1 :fields 1
:type :base-type :symbol] spec:
:com.walmartlabs.lacinia.schema/type-name () - failed: Insufficient
input in: [0 :objects :Attribute 1 :fields :attribute_udt_catalog 1
:type] at: [:schema :objects 1 :fields 1 :type :wrapped-type
:modifier] spec:
:com.walmartlabs.lacinia.schema/wrapped-type-modifier nil - failed:
simple-keyword? in: [0 :objects :Attribute 1 :fields
:collation_name 1 :type] at: [:schema :objects 1 :fields 1 :type
:base-type :keyword] spec:
:com.walmartlabs.lacinia.schema/type-name nil - failed:
simple-symbol? in: [0 :objects :Attribute 1 :fields :collation_name
1 :type] at: [:schema :objects 1 :fields 1 :type :base-type
:symbol] spec: :com.walmartlabs.lacinia.schema/type-name () -
failed: Insufficient input in: [0 :objects :Attribute 1 :fields
:collation_name 1 :type] at: [:schema :objects 1 :fields 1 :type
:wrapped-type :modifier] spec:
:com.walmartlabs.lacinia.schema/wrapped-type-modifier nil - failed:
simple-keyword? in: [0 :objects :Attribute 1 :fields
:attribute_udt_schema 1 :type] at: [:schema :objects 1 :fields 1
:type :base-type :keyword] spec:
:com.walmartlabs.lacinia.schema/type-name nil - failed:
simple-symbol? in: [0 :objects :Attribute 1 :fields
:attribute_udt_schema 1 :type] at: [:schema :objects 1 :fields 1
:type :base-type :symbol] spec:
:com.walmartlabs.lacinia.schema/type-name () - failed: Insufficient
input in: [0 :objects :Attribute 1 :fields :attribute_udt_schema 1
:type] at: [:schema :objects 1 :fields 1 :type :wrapped-type
:modifier] spec:
:com.walmartlabs.lacinia.schema/wrapped-type-modifier nil - failed:
simple-keyword? in: [0 :objects :Attribute 1 :fields :scope_name 1
:type] at: [:schema :objects 1 :fields 1 :type :base-type :keyword]
spec: :com.walmartlabs.lacinia.schema/type-name nil - failed:
simple-symbol? in: [0 :objects :Attribute 1 :fields :scope_name 1
:type] at: [:schema :objects 1 :fields 1 :type :base-type :symbol]
spec: :com.walmartlabs.lacinia.schema/type-name () - failed:
Insufficient input in: [0 :objects :Attribute 1 :fields :scope_name
1 :type] at: [:schema :objects 1 :fields 1 :type :wrapped-type
:modifier] spec:
:com.walmartlabs.lacinia.schema/wrapped-type-modifier nil - failed:
simple-keyword? in: [0 :objects :Attribute 1 :fields :udt_name 1
:type] at: [:schema :objects 1 :fields 1 :type :base-type :keyword]
spec: :com.walmartlabs.lacinia.schema/type-name nil - failed:
simple-symbol? in: [0 :objects :Attribute 1 :fields :udt_name 1
:type] at: [:schema :objects 1 :fields 1 :type :base-type :symbol]
spec: :com.walmartlabs.lacinia.schema/type-name () - failed:
Insufficient input in: [0 :objects :Attribute 1 :fields :udt_name 1
:type] at: [:schema :objects 1 :fields 1 :type :wrapped-type
:modifier] spec:
:com.walmartlabs.lacinia.schema/wrapped-type-modifier nil - failed:
simple-keyword? in: [0 :objects :Attribute 1 :fields
:attribute_udt_name 1 :type] at: [:schema :objects 1 :fields 1
:type :base-type :keyword] spec:
:com.walmartlabs.lacinia.schema/type-name nil - failed:
simple-symbol? in: [0 :objects :Attribute 1 :fields
:attribute_udt_name 1 :type] at: [:schema :objects 1 :fields 1
:type :base-type :symbol] spec:
:com.walmartlabs.lacinia.schema/type-name () - failed: Insufficient
input in: [0 :objects :Attribute 1 :fields :attribute_udt_name 1
:type] at: [:schema :objects 1 :fields 1 :type :wrapped-type
:modifier] spec:
:com.walmartlabs.lacinia.schema/wrapped-type-modifier nil - failed:
simple-keyword? in: [0 :mutations :createAttribute 1 :args
:attribute_name 1 :type] at: [:schema :mutations 1 :args 1 :type
:base-type :keyword] spec:
:com.walmartlabs.lacinia.schema/type-name nil - failed:
simple-symbol? in: [0 :mutations :createAttribute 1 :args
:attribute_name 1 :type] at: [:schema :mutations 1 :args 1 :type
:base-type :symbol] spec: :com.walmartlabs.lacinia.schema/type-name
() - failed: Insufficient input in: [0 :mutations :createAttribute
1 :args :attribute_name 1 :type] at: [:schema :mutations 1 :args 1
:type :wrapped-type :modifier] spec:
:com.walmartlabs.lacinia.schema/wrapped-type-modifier nil - failed:
simple-keyword? in: [0 :mutations :createAttribute 1 :args
:udt_schema 1 :type] at: [:schema :mutations 1 :args 1 :type
:base-type :keyword] spec:
:com.walmartlabs.lacinia.schema/type-name nil - failed:
simple-symbol? in: [0 :mutations :createAttribute 1 :args
:udt_schema 1 :type] at: [:schema :mutations 1 :args 1 :type
:base-type :symbol] spec: :com.walmartlabs.lacinia.schema/type-name
() - failed: Insufficient input in: [0 :mutations :createAttribute
1 :args :udt_schema 1 :type] at: [:schema :mutations 1 :args 1
:type :wrapped-type :modifier] spec:
:com.walmartlabs.lacinia.schema/wrapped-type-modifier nil - failed:
simple-keyword? in: [0 :mutations :createAttribute 1 :args
:collation_schema 1 :type] at: [:schema :mutations 1 :args 1 :type
:base-type :keyword] spec:
:com.walmartlabs.lacinia.schema/type-name nil - failed:
simple-symbol? in: [0 :mutations :createAttribute 1 :args
:collation_schema 1 :type] at: [:schema :mutations 1 :args 1 :type
:base-type :symbol] spec: :com.walmartlabs.lacinia.schema/type-name
() - failed: Insufficient input in: [0 :mutations :createAttribute
1 :args :collation_schema 1 :type] at: [:schema :mutations 1 :args
1 :type :wrapped-type :modifier] spec:
:com.walmartlabs.lacinia.schema/wrapped-type-modifier nil - failed:
simple-keyword? in: [0 :mutations :createAttribute 1 :args
:character_set_schema 1 :type] at: [:schema :mutations 1 :args 1
:type :base-type :keyword] spec:
:com.walmartlabs.lacinia.schema/type-name nil - failed:
simple-symbol? in: [0 :mutations :createAttribute 1 :args
:character_set_schema 1 :type] at: [:schema :mutations 1 :args 1
:type :base-type :symbol] spec:
:com.walmartlabs.lacinia.schema/type-name () - failed: Insufficient
input in: [0 :mutations :createAttribute 1 :args
:character_set_schema 1 :type] at: [:schema :mutations 1 :args 1
:type :wrapped-type :modifier] spec:
:com.walmartlabs.lacinia.schema/wrapped-type-modifier nil - failed:
simple-keyword? in: [0 :mutations :createAttribute 1 :args
:dtd_identifier 1 :type] at: [:schema :mutations 1 :args 1 :type
:base-type :keyword] spec:
:com.walmartlabs.lacinia.schema/type-name nil - failed:
simple-symbol? in: [0 :mutations :createAttribute 1 :args
:dtd_identifier 1 :type] at: [:schema :mutations 1 :args 1 :type
:base-type :symbol] spec: :com.walmartlabs.lacinia.schema/type-name
() - failed: Insufficient input in: [0 :mutations :createAttribute
1 :args :dtd_identifier 1 :type] at: [:schema :mutations 1 :args 1
:type :wrapped-type :modifier] spec:
:com.walmartlabs.lacinia.schema/wrapped-type-modifier nil - failed:
simple-keyword? in: [0 :mutations :createAttribute 1 :args
:scope_catalog 1 :type] at: [:schema :mutations 1 :args 1 :type
:base-type :keyword] spec:
:com.walmartlabs.lacinia.schema/type-name nil - failed:
simple-symbol? in: [0 :mutations :createAttribute 1 :args
:scope_catalog 1 :type] at: [:schema :mutations 1 :args 1 :type
:base-type :symbol] spec: :com.walmartlabs.lacinia.schema/type-name
() - failed: Insufficient input in: [0 :mutations :createAttribute
1 :args :scope_catalog 1 :type] at: [:schema :mutations 1 :args 1
:type :wrapped-type :modifier] spec:
:com.walmartlabs.lacinia.schema/wrapped-type-modifier nil - failed:
simple-keyword? in: [0 :mutations :createAttribute 1 :args
:collation_catalog 1 :type] at: [:schema :mutations 1 :args 1 :type
:base-type :keyword] spec:
:com.walmartlabs.lacinia.schema/type-name nil - failed:
simple-symbol? in: [0 :mutations :createAttribute 1 :args
:collation_catalog 1 :type] at: [:schema :mutations 1 :args 1 :type
:base-type :symbol] spec: :com.walmartlabs.lacinia.schema/type-name
() - failed: Insufficient input in: [0 :mutations :createAttribute
1 :args :collation_catalog 1 :type] at: [:schema :mutations 1 :args
1 :type :wrapped-type :modifier] spec:
:com.walmartlabs.lacinia.schema/wrapped-type-modifier nil - failed:
simple-keyword? in: [0 :mutations :createAttribute 1 :args
:character_set_catalog 1 :type] at: [:schema :mutations 1 :args 1
:type :base-type :keyword] spec:
:com.walmartlabs.lacinia.schema/type-name nil - failed:
simple-symbol? in: [0 :mutations :createAttribute 1 :args
:character_set_catalog 1 :type] at: [:schema :mutations 1 :args 1
:type :base-type :symbol] spec:
:com.walmartlabs.lacinia.schema/type-name () - failed: Insufficient
input in: [0 :mutations :createAttribute 1 :args
:character_set_catalog 1 :type] at: [:schema :mutations 1 :args 1
:type :wrapped-type :modifier] spec:
:com.walmartlabs.lacinia.schema/wrapped-type-modifier nil - failed:
simple-keyword? in: [0 :mutations :createAttribute 1 :args
:udt_catalog 1 :type] at: [:schema :mutations 1 :args 1 :type
:base-type :keyword] spec:
:com.walmartlabs.lacinia.schema/type-name nil - failed:
simple-symbol? in: [0 :mutations :createAttribute 1 :args
:udt_catalog 1 :type] at: [:schema :mutations 1 :args 1 :type
:base-type :symbol] spec: :com.walmartlabs.lacinia.schema/type-name
() - failed: Insufficient input in: [0 :mutations :createAttribute
1 :args :udt_catalog 1 :type] at: [:schema :mutations 1 :args 1
:type :wrapped-type :modifier] spec:
:com.walmartlabs.lacinia.schema/wrapped-type-modifier nil - failed:
simple-keyword? in: [0 :mutations :createAttribute 1 :args
:scope_schema 1 :type] at: [:schema :mutations 1 :args 1 :type
:base-type :keyword] spec:
:com.walmartlabs.lacinia.schema/type-name nil - failed:
simple-symbol? in: [0 :mutations :createAttribute 1 :args
:scope_schema 1 :type] at: [:schema :mutations 1 :args 1 :type
:base-type :symbol] spec: :com.walmartlabs.lacinia.schema/type-name
() - failed: Insufficient input in: [0 :mutations :createAttribute
1 :args :scope_schema 1 :type] at: [:schema :mutations 1 :args 1
:type :wrapped-type :modifier] spec:
:com.walmartlabs.lacinia.schema/wrapped-type-modifier nil - failed:
simple-keyword? in: [0 :mutations :createAttribute 1 :args
:character_set_name 1 :type] at: [:schema :mutations 1 :args 1
:type :base-type :keyword] spec:
:com.walmartlabs.lacinia.schema/type-name nil - failed:
simple-symbol? in: [0 :mutations :createAttribute 1 :args
:character_set_name 1 :type] at: [:schema :mutations 1 :args 1
:type :base-type :symbol] spec:
:com.walmartlabs.lacinia.schema/type-name () - failed: Insufficient
input in: [0 :mutations :createAttribute 1 :args
:character_set_name 1 :type] at: [:schema :mutations 1 :args 1
:type :wrapped-type :modifier] spec:
:com.walmartlabs.lacinia.schema/wrapped-type-modifier nil - failed:
simple-keyword? in: [0 :mutations :createAttribute 1 :args
:attribute_udt_catalog 1 :type] at: [:schema :mutations 1 :args 1
:type :base-type :keyword] spec:
:com.walmartlabs.lacinia.schema/type-name nil - failed:
simple-symbol? in: [0 :mutations :createAttribute 1 :args
:attribute_udt_catalog 1 :type] at: [:schema :mutations 1 :args 1
:type :base-type :symbol] spec:
:com.walmartlabs.lacinia.schema/type-name () - failed: Insufficient
input in: [0 :mutations :createAttribute 1 :args
:attribute_udt_catalog 1 :type] at: [:schema :mutations 1 :args 1
:type :wrapped-type :modifier] spec:
:com.walmartlabs.lacinia.schema/wrapped-type-modifier nil - failed:
simple-keyword? in: [0 :mutations :createAttribute 1 :args
:collation_name 1 :type] at: [:schema :mutations 1 :args 1 :type
:base-type :keyword] spec:
:com.walmartlabs.lacinia.schema/type-name nil - failed:
simple-symbol? in: [0 :mutations :createAttribute 1 :args
:collation_name 1 :type] at: [:schema :mutations 1 :args 1 :type
:base-type :symbol] spec: :com.walmartlabs.lacinia.schema/type-name
() - failed: Insufficient input in: [0 :mutations :createAttribute
1 :args :collation_name 1 :type] at: [:schema :mutations 1 :args 1
:type :wrapped-type :modifier] spec:
:com.walmartlabs.lacinia.schema/wrapped-type-modifier nil - failed:
simple-keyword? in: [0 :mutations :createAttribute 1 :args
:attribute_udt_schema 1 :type] at: [:schema :mutations 1 :args 1
:type :base-type :keyword] spec:
:com.walmartlabs.lacinia.schema/type-name nil - failed:
simple-symbol? in: [0 :mutations :createAttribute 1 :args
:attribute_udt_schema 1 :type] at: [:schema :mutations 1 :args 1
:type :base-type :symbol] spec:
:com.walmartlabs.lacinia.schema/type-name () - failed: Insufficient
input in: [0 :mutations :createAttribute 1 :args
:attribute_udt_schema 1 :type] at: [:schema :mutations 1 :args 1
:type :wrapped-type :modifier] spec:
:com.walmartlabs.lacinia.schema/wrapped-type-modifier nil - failed:
simple-keyword? in: [0 :mutations :createAttribute 1 :args
:scope_name 1 :type] at: [:schema :mutations 1 :args 1 :type
:base-type :keyword] spec:
:com.walmartlabs.lacinia.schema/type-name nil - failed:
simple-symbol? in: [0 :mutations :createAttribute 1 :args
:scope_name 1 :type] at: [:schema :mutations 1 :args 1 :type
:base-type :symbol] spec: :com.walmartlabs.lacinia.schema/type-name
() - failed: Insufficient input in: [0 :mutations :createAttribute
1 :args :scope_name 1 :type] at: [:schema :mutations 1 :args 1
:type :wrapped-type :modifier] spec:
:com.walmartlabs.lacinia.schema/wrapped-type-modifier nil - failed:
simple-keyword? in: [0 :mutations :createAttribute 1 :args
:udt_name 1 :type] at: [:schema :mutations 1 :args 1 :type
:base-type :keyword] spec:
:com.walmartlabs.lacinia.schema/type-name nil - failed:
simple-symbol? in: [0 :mutations :createAttribute 1 :args :udt_name
1 :type] at: [:schema :mutations 1 :args 1 :type :base-type
:symbol] spec: :com.walmartlabs.lacinia.schema/type-name () -
failed: Insufficient input in: [0 :mutations :createAttribute 1
:args :udt_name 1 :type] at: [:schema :mutations 1 :args 1 :type
:wrapped-type :modifier] spec:
:com.walmartlabs.lacinia.schema/wrapped-type-modifier nil - failed:
simple-keyword? in: [0 :mutations :createAttribute 1 :args
:attribute_udt_name 1 :type] at: [:schema :mutations 1 :args 1
:type :base-type :keyword] spec:
:com.walmartlabs.lacinia.schema/type-name nil - failed:
simple-symbol? in: [0 :mutations :createAttribute 1 :args
:attribute_udt_name 1 :type] at: [:schema :mutations 1 :args 1
:type :base-type :symbol] spec:
:com.walmartlabs.lacinia.schema/type-name () - failed: Insufficient
input in: [0 :mutations :createAttribute 1 :args
:attribute_udt_name 1 :type] at: [:schema :mutations 1 :args 1
:type :wrapped-type :modifier] spec:
:com.walmartlabs.lacinia.schema/wrapped-type-modifier nil - failed:
simple-keyword? in: [0 :mutations :updateAttribute 1 :args
:attribute_name 1 :type] at: [:schema :mutations 1 :args 1 :type
:base-type :keyword] spec:
:com.walmartlabs.lacinia.schema/type-name nil - failed:
simple-symbol? in: [0 :mutations :updateAttribute 1 :args
:attribute_name 1 :type] at: [:schema :mutations 1 :args 1 :type
:base-type :symbol] spec: :com.walmartlabs.lacinia.schema/type-name
() - failed: Insufficient input in: [0 :mutations :updateAttribute
1 :args :attribute_name 1 :type] at: [:schema :mutations 1 :args 1
:type :wrapped-type :modifier] spec:
:com.walmartlabs.lacinia.schema/wrapped-type-modifier nil - failed:
simple-keyword? in: [0 :mutations :updateAttribute 1 :args
:udt_schema 1 :type] at: [:schema :mutations 1 :args 1 :type
:base-type :keyword] spec:
:com.walmartlabs.lacinia.schema/type-name nil - failed:
simple-symbol? in: [0 :mutations :updateAttribute 1 :args
:udt_schema 1 :type] at: [:schema :mutations 1 :args 1 :type
:base-type :symbol] spec: :com.walmartlabs.lacinia.schema/type-name
() - failed: Insufficient input in: [0 :mutations :updateAttribute
1 :args :udt_schema 1 :type] at: [:schema :mutations 1 :args 1
:type :wrapped-type :modifier] spec:
:com.walmartlabs.lacinia.schema/wrapped-type-modifier nil - failed:
simple-keyword? in: [0 :mutations :updateAttribute 1 :args
:collation_schema 1 :type] at: [:schema :mutations 1 :args 1 :type
:base-type :keyword] spec:
:com.walmartlabs.lacinia.schema/type-name nil - failed:
simple-symbol? in: [0 :mutations :updateAttribute 1 :args
:collation_schema 1 :type] at: [:schema :mutations 1 :args 1 :type
:base-type :symbol] spec: :com.walmartlabs.lacinia.schema/type-name
() - failed: Insufficient input in: [0 :mutations :updateAttribute
1 :args :collation_schema 1 :type] at: [:schema :mutations 1 :args
1 :type :wrapped-type :modifier] spec:
:com.walmartlabs.lacinia.schema/wrapped-type-modifier nil - failed:
simple-keyword? in: [0 :mutations :updateAttribute 1 :args
:character_set_schema 1 :type] at: [:schema :mutations 1 :args 1
:type :base-type :keyword] spec:
:com.walmartlabs.lacinia.schema/type-name nil - failed:
simple-symbol? in: [0 :mutations :updateAttribute 1 :args
:character_set_schema 1 :type] at: [:schema :mutations 1 :args 1
:type :base-type :symbol] spec:
:com.walmartlabs.lacinia.schema/type-name () - failed: Insufficient
input in: [0 :mutations :updateAttribute 1 :args
:character_set_schema 1 :type] at: [:schema :mutations 1 :args 1
:type :wrapped-type :modifier] spec:
:com.walmartlabs.lacinia.schema/wrapped-type-modifier nil - failed:
simple-keyword? in: [0 :mutations :updateAttribute 1 :args
:dtd_identifier 1 :type] at: [:schema :mutations 1 :args 1 :type
:base-type :keyword] spec:
:com.walmartlabs.lacinia.schema/type-name nil - failed:
simple-symbol? in: [0 :mutations :updateAttribute 1 :args
:dtd_identifier 1 :type] at: [:schema :mutations 1 :args 1 :type
:base-type :symbol] spec: :com.walmartlabs.lacinia.schema/type-name
() - failed: Insufficient input in: [0 :mutations :updateAttribute
1 :args :dtd_identifier 1 :type] at: [:schema :mutations 1 :args 1
:type :wrapped-type :modifier] spec:
:com.walmartlabs.lacinia.schema/wrapped-type-modifier nil - failed:
simple-keyword? in: [0 :mutations :updateAttribute 1 :args
:scope_catalog 1 :type] at: [:schema :mutations 1 :args 1 :type
:base-type :keyword] spec:
:com.walmartlabs.lacinia.schema/type-name nil - failed:
simple-symbol? in: [0 :mutations :updateAttribute 1 :args
:scope_catalog 1 :type] at: [:schema :mutations 1 :args 1 :type
:base-type :symbol] spec: :com.walmartlabs.lacinia.schema/type-name
() - failed: Insufficient input in: [0 :mutations :updateAttribute
1 :args :scope_catalog 1 :type] at: [:schema :mutations 1 :args 1
:type :wrapped-type :modifier] spec:
:com.walmartlabs.lacinia.schema/wrapped-type-modifier nil - failed:
simple-keyword? in: [0 :mutations :updateAttribute 1 :args
:collation_catalog 1 :type] at: [:schema :mutations 1 :args 1 :type
:base-type :keyword] spec:
:com.walmartlabs.lacinia.schema/type-name nil - failed:
simple-symbol? in: [0 :mutations :updateAttribute 1 :args
:collation_catalog 1 :type] at: [:schema :mutations 1 :args 1 :type
:base-type :symbol] spec: :com.walmartlabs.lacinia.schema/type-name
() - failed: Insufficient input in: [0 :mutations :updateAttribute
1 :args :collation_catalog 1 :type] at: [:schema :mutations 1 :args
1 :type :wrapped-type :modifier] spec:
:com.walmartlabs.lacinia.schema/wrapped-type-modifier nil - failed:
simple-keyword? in: [0 :mutations :updateAttribute 1 :args
:character_set_catalog 1 :type] at: [:schema :mutations 1 :args 1
:type :base-type :keyword] spec:
:com.walmartlabs.lacinia.schema/type-name nil - failed:
simple-symbol? in: [0 :mutations :updateAttribute 1 :args
:character_set_catalog 1 :type] at: [:schema :mutations 1 :args 1
:type :base-type :symbol] spec:
:com.walmartlabs.lacinia.schema/type-name () - failed: Insufficient
input in: [0 :mutations :updateAttribute 1 :args
:character_set_catalog 1 :type] at: [:schema :mutations 1 :args 1
:type :wrapped-type :modifier] spec:
:com.walmartlabs.lacinia.schema/wrapped-type-modifier nil - failed:
simple-keyword? in: [0 :mutations :updateAttribute 1 :args
:udt_catalog 1 :type] at: [:schema :mutations 1 :args 1 :type
:base-type :keyword] spec:
:com.walmartlabs.lacinia.schema/type-name nil - failed:
simple-symbol? in: [0 :mutations :updateAttribute 1 :args
:udt_catalog 1 :type] at: [:schema :mutations 1 :args 1 :type
:base-type :symbol] spec: :com.walmartlabs.lacinia.schema/type-name
() - failed: Insufficient input in: [0 :mutations :updateAttribute
1 :args :udt_catalog 1 :type] at: [:schema :mutations 1 :args 1
:type :wrapped-type :modifier] spec:
:com.walmartlabs.lacinia.schema/wrapped-type-modifier nil - failed:
simple-keyword? in: [0 :mutations :updateAttribute 1 :args
:scope_schema 1 :type] at: [:schema :mutations 1 :args 1 :type
:base-type :keyword] spec:
:com.walmartlabs.lacinia.schema/type-name nil - failed:
simple-symbol? in: [0 :mutations :updateAttribute 1 :args
:scope_schema 1 :type] at: [:schema :mutations 1 :args 1 :type
:base-type :symbol] spec: :com.walmartlabs.lacinia.schema/type-name
() - failed: Insufficient input in: [0 :mutations :updateAttribute
1 :args :scope_schema 1 :type] at: [:schema :mutations 1 :args 1
:type :wrapped-type :modifier] spec:
:com.walmartlabs.lacinia.schema/wrapped-type-modifier nil - failed:
simple-keyword? in: [0 :mutations :updateAttribute 1 :args
:character_set_name 1 :type] at: [:schema :mutations 1 :args 1
:type :base-type :keyword] spec:
:com.walmartlabs.lacinia.schema/type-name nil - failed:
simple-symbol? in: [0 :mutations :updateAttribute 1 :args
:character_set_name 1 :type] at: [:schema :mutations 1 :args 1
:type :base-type :symbol] spec:
:com.walmartlabs.lacinia.schema/type-name () - failed: Insufficient
input in: [0 :mutations :updateAttribute 1 :args
:character_set_name 1 :type] at: [:schema :mutations 1 :args 1
:type :wrapped-type :modifier] spec:
:com.walmartlabs.lacinia.schema/wrapped-type-modifier nil - failed:
simple-keyword? in: [0 :mutations :updateAttribute 1 :args
:attribute_udt_catalog 1 :type] at: [:schema :mutations 1 :args 1
:type :base-type :keyword] spec:
:com.walmartlabs.lacinia.schema/type-name nil - failed:
simple-symbol? in: [0 :mutations :updateAttribute 1 :args
:attribute_udt_catalog 1 :type] at: [:schema :mutations 1 :args 1
:type :base-type :symbol] spec:
:com.walmartlabs.lacinia.schema/type-name () - failed: Insufficient
input in: [0 :mutations :updateAttribute 1 :args
:attribute_udt_catalog 1 :type] at: [:schema :mutations 1 :args 1
:type :wrapped-type :modifier] spec:
:com.walmartlabs.lacinia.schema/wrapped-type-modifier nil - failed:
simple-keyword? in: [0 :mutations :updateAttribute 1 :args
:collation_name 1 :type] at: [:schema :mutations 1 :args 1 :type
:base-type :keyword] spec:
:com.walmartlabs.lacinia.schema/type-name nil - failed:
simple-symbol? in: [0 :mutations :updateAttribute 1 :args
:collation_name 1 :type] at: [:schema :mutations 1 :args 1 :type
:base-type :symbol] spec: :com.walm
Sign up for free to join this conversation on GitHub. Already have an account? Sign in to comment