Moon-Lander

moonrockz/openrpc/schema

Types

Dependency

pub(all) enum Dependency {
  SchemaDependency(Schema)
  PropertyDependencies(Array[String])
} derive(@moonbitlang/core/debug.Debug)

Source

Dependency::to_repr

fn Dependency::to_repr(Dependency) -> @moonbitlang/core/debug.Repr

Source

Items

pub(all) enum Items {
  SingleItems(Schema)
  TupleItems(Array[Schema])
} derive(@moonbitlang/core/debug.Debug)

Source

Items::to_repr

fn Items::to_repr(Items) -> @moonbitlang/core/debug.Repr

Source

Keyword

pub(all) enum Keyword {
  Id(@moonrockz/openrpc/reference.UriReference)
  Dialect(@moonrockz/openrpc/reference.UriReference)
  Ref(@moonrockz/openrpc/reference.Reference)
  Comment(String)
  Title(String)
  Description(String)
  Default(@moonrockz/openrpc/json.Value)
  ReadOnly(Bool)
  WriteOnly(Bool)
  Examples(Array[@moonrockz/openrpc/json.Value])
  MultipleOf(PositiveNumber)
  Maximum(@moonrockz/openrpc/json.Number)
  ExclusiveMaximum(@moonrockz/openrpc/json.Number)
  Minimum(@moonrockz/openrpc/json.Number)
  ExclusiveMinimum(@moonrockz/openrpc/json.Number)
  MaxLength(NonNegativeInteger)
  MinLength(NonNegativeInteger)
  Pattern(String)
  AdditionalItems(Schema)
  Items(Items)
  MaxItems(NonNegativeInteger)
  MinItems(NonNegativeInteger)
  UniqueItems(Bool)
  Contains(Schema)
  MaxProperties(NonNegativeInteger)
  MinProperties(NonNegativeInteger)
  Required(Array[String])
  AdditionalProperties(Schema)
  Definitions(Array[(String, Schema)])
  Properties(Array[(String, Schema)])
  PatternProperties(Array[(String, Schema)])
  Dependencies(Array[(String, Dependency)])
  PropertyNames(Schema)
  Const(@moonrockz/openrpc/json.Value)
  Enum(Array[@moonrockz/openrpc/json.Value])
  Type(TypeConstraint)
  Format(String)
  ContentMediaType(String)
  ContentEncoding(String)
  If(Schema)
  Then(Schema)
  Else(Schema)
  AllOf(Array[Schema])
  AnyOf(Array[Schema])
  OneOf(Array[Schema])
  Not(Schema)
} derive(@moonbitlang/core/debug.Debug)

Source

Keyword::name

fn Keyword::name(self : Keyword) -> String

Source

Keyword::to_json

fn Keyword::to_json(self : Keyword) -> Result[@moonrockz/openrpc/json.Value, @moonrockz/openrpc/json.Diagnostic]

Source

Keyword::to_repr

fn Keyword::to_repr(Keyword) -> @moonbitlang/core/debug.Repr

Source

NonNegativeInteger

pub struct NonNegativeInteger {
  number : @moonrockz/openrpc/json.Number
} derive(Eq, @moonbitlang/core/debug.Debug)

Source

NonNegativeInteger::equal

fn NonNegativeInteger::equal(NonNegativeInteger, NonNegativeInteger) -> Bool

Source

NonNegativeInteger::from_number

fn NonNegativeInteger::from_number(number : @moonrockz/openrpc/json.Number) -> Result[NonNegativeInteger, @moonrockz/openrpc/json.Diagnostic]

Source

NonNegativeInteger::not_equal

fn NonNegativeInteger::not_equal(x : NonNegativeInteger, y : NonNegativeInteger) -> Bool

Source

NonNegativeInteger::number

fn NonNegativeInteger::number(self : NonNegativeInteger) -> @moonrockz/openrpc/json.Number

Source

NonNegativeInteger::parse

fn NonNegativeInteger::parse(token : String) -> Result[NonNegativeInteger, @moonrockz/openrpc/json.Diagnostic]

Source

NonNegativeInteger::to_repr

fn NonNegativeInteger::to_repr(NonNegativeInteger) -> @moonbitlang/core/debug.Repr

Source

PatternError

pub struct PatternError {
  code : @moonrockz/openrpc/json.Code
  message : String
  offset : Int
} derive(@moonbitlang/core/debug.Debug)

A syntax error offset refers to UTF-16 units in the decoded pattern string. It is not a span in the JSON source containing that string.

Source

PatternError::code

fn PatternError::code(self : PatternError) -> @moonrockz/openrpc/json.Code

Source

PatternError::message

fn PatternError::message(self : PatternError) -> String

Source

PatternError::offset

fn PatternError::offset(self : PatternError) -> Int

Source

PatternError::to_repr

fn PatternError::to_repr(PatternError) -> @moonbitlang/core/debug.Repr

Source

PositiveNumber

pub struct PositiveNumber {
  number : @moonrockz/openrpc/json.Number
} derive(Eq, @moonbitlang/core/debug.Debug)

Source

PositiveNumber::equal

fn PositiveNumber::equal(PositiveNumber, PositiveNumber) -> Bool

Source

PositiveNumber::from_number

fn PositiveNumber::from_number(number : @moonrockz/openrpc/json.Number) -> Result[PositiveNumber, @moonrockz/openrpc/json.Diagnostic]

Source

PositiveNumber::not_equal

fn PositiveNumber::not_equal(x : PositiveNumber, y : PositiveNumber) -> Bool

Source

PositiveNumber::number

fn PositiveNumber::number(self : PositiveNumber) -> @moonrockz/openrpc/json.Number

Source

PositiveNumber::parse

fn PositiveNumber::parse(token : String) -> Result[PositiveNumber, @moonrockz/openrpc/json.Diagnostic]

Source

PositiveNumber::to_repr

fn PositiveNumber::to_repr(PositiveNumber) -> @moonbitlang/core/debug.Repr

Source

ReferenceObject

pub struct ReferenceObject {
  reference : @moonrockz/openrpc/reference.Reference
  siblings : @moonrockz/openrpc/json.Value
} derive(@moonbitlang/core/debug.Debug)

Source

ReferenceObject::reference

fn ReferenceObject::reference(self : ReferenceObject) -> @moonrockz/openrpc/reference.Reference

Source

ReferenceObject::siblings

fn ReferenceObject::siblings(self : ReferenceObject) -> @moonrockz/openrpc/json.Value

Source

ReferenceObject::to_repr

fn ReferenceObject::to_repr(ReferenceObject) -> @moonbitlang/core/debug.Repr

Source

Report

pub struct Report {
  complete : Bool
  references_complete : Bool
  // private fields
} derive(@moonbitlang/core/debug.Debug)

Completeness means all requested schema-document checks were performed. It does not mean that the diagnostics contain no failures.

Source

Report::diagnostic_resources

fn Report::diagnostic_resources(self : Report) -> Array[@moonrockz/openrpc/reference.UriReference?]

One resolution per followed $ref edge, in traversal order.

Source

Report::diagnostics

fn Report::diagnostics(self : Report) -> Array[@moonrockz/openrpc/json.Diagnostic]

Source

Report::is_complete

fn Report::is_complete(self : Report) -> Bool

Source

Report::references_complete

fn Report::references_complete(self : Report) -> Bool

Whether every followed reference and every schema identifier was resolved or definitively failed. Local keyword and regex checks are reported separately through is_complete.

Source

Report::resolutions

fn Report::resolutions(self : Report) -> Array[@moonrockz/openrpc/reference.Resolution]

Source

Report::to_repr

fn Report::to_repr(Report) -> @moonbitlang/core/debug.Repr

Source

Schema

pub struct Schema {
  value : @moonrockz/openrpc/json.Value
} derive(@moonbitlang/core/debug.Debug)

A schema retains exact JSON with checked typed keyword forms.

Source

Schema::from_json

fn Schema::from_json(value : @moonrockz/openrpc/json.Value, limits? : @moonrockz/openrpc/json.Limits) -> Result[Schema, @moonrockz/openrpc/json.Diagnostic]

Source

Schema::from_keywords

fn Schema::from_keywords(keywords : Array[Keyword], additional_fields? : Array[(String, @moonrockz/openrpc/json.Value)], extensions? : @moonrockz/openrpc/domain.Extensions, limits? : @moonrockz/openrpc/json.Limits) -> Result[Schema, @moonrockz/openrpc/json.Diagnostic]

Source

Schema::kind

fn Schema::kind(self : Schema) -> SchemaKind

Source

Schema::to_json

fn Schema::to_json(self : Schema) -> @moonrockz/openrpc/json.Value

Source

Schema::to_repr

fn Schema::to_repr(Schema) -> @moonbitlang/core/debug.Repr

Source

SchemaKind

pub(all) enum SchemaKind {
  BooleanSchema(Bool)
  ObjectSchema(SchemaObject)
  ReferenceSchema(ReferenceObject)
  UnsupportedDialectSchema(@moonrockz/openrpc/reference.UriReference, @moonrockz/openrpc/json.Value)
} derive(@moonbitlang/core/debug.Debug)

Source

SchemaKind::to_repr

fn SchemaKind::to_repr(SchemaKind) -> @moonbitlang/core/debug.Repr

Source

SchemaObject

pub struct SchemaObject {
  value : @moonrockz/openrpc/json.Value
} derive(@moonbitlang/core/debug.Debug)

Source

SchemaObject::additional_fields

fn SchemaObject::additional_fields(self : SchemaObject) -> Array[(String, @moonrockz/openrpc/json.Value)]

Source

SchemaObject::extensions

fn SchemaObject::extensions(self : SchemaObject) -> @moonrockz/openrpc/domain.Extensions

Source

SchemaObject::keyword

fn SchemaObject::keyword(self : SchemaObject, name : String) -> Keyword?

Source

SchemaObject::keywords

fn SchemaObject::keywords(self : SchemaObject) -> Array[Keyword]

Source

SchemaObject::to_repr

fn SchemaObject::to_repr(SchemaObject) -> @moonbitlang/core/debug.Repr

Source

SimpleType

pub(all) enum SimpleType {
  ArrayType
  BooleanType
  IntegerType
  NullType
  NumberType
  ObjectType
  StringType
} derive(Eq, @moonbitlang/core/debug.Debug)

Source

SimpleType::equal

fn SimpleType::equal(SimpleType, SimpleType) -> Bool

Source

SimpleType::not_equal

fn SimpleType::not_equal(x : SimpleType, y : SimpleType) -> Bool

Source

SimpleType::to_repr

fn SimpleType::to_repr(SimpleType) -> @moonbitlang/core/debug.Repr

Source

SimpleType::to_string

fn SimpleType::to_string(self : SimpleType) -> String

Source

TypeConstraint

pub struct TypeConstraint {
  types : Array[SimpleType]
  union : Bool
} derive(@moonbitlang/core/debug.Debug)

Source

TypeConstraint::is_union

fn TypeConstraint::is_union(self : TypeConstraint) -> Bool

Source

TypeConstraint::many

fn TypeConstraint::many(types : Array[SimpleType]) -> Result[TypeConstraint, @moonrockz/openrpc/json.Diagnostic]

Source

TypeConstraint::one

fn TypeConstraint::one(type_ : SimpleType) -> TypeConstraint

Source

TypeConstraint::to_json

fn TypeConstraint::to_json(self : TypeConstraint) -> @moonrockz/openrpc/json.Value

Source

TypeConstraint::to_repr

fn TypeConstraint::to_repr(TypeConstraint) -> @moonbitlang/core/debug.Repr

Source

TypeConstraint::types

fn TypeConstraint::types(self : TypeConstraint) -> Array[SimpleType]

Source

Values

check_pattern

fn check_pattern(source : String, limits? : @moonrockz/openrpc/json.Limits) -> Result[Unit, PatternError]

Check ECMA-262 2018 pattern syntax with no flags and Annex B extensions. This performs no matching, fetching, compilation or instance evaluation.

Source

keyword_names

fn keyword_names() -> Array[String]

Source

validate

fn validate(schema : Schema, root~ : @moonrockz/openrpc/json.Value, path? : Array[String], base? : @moonrockz/openrpc/reference.UriReference?, resources? : @moonrockz/openrpc/reference.ResourceSet, max_nodes? : Int, max_edges? : Int, max_findings? : Int, max_comparison_work? : Int, limits? : @moonrockz/openrpc/json.Limits) -> Report

Validate a bounded schema-document graph without evaluating instances. References resolve through nested $id scopes and the explicit resources; nothing is fetched.

Source

validate_in

fn validate_in(schema : Schema, index~ : @moonrockz/openrpc/reference.SchemaIndex, resource? : @moonrockz/openrpc/reference.UriReference?, path? : Array[String], max_nodes? : Int, max_edges? : Int, max_findings? : Int, max_comparison_work? : Int, limits? : @moonrockz/openrpc/json.Limits) -> Report

Check one schema against an index the caller built once for a whole document. resource names the index document holding the schema (None for the unnamed input) and path is its location there. Index diagnostics are the caller's to report.

Source

validate_json

fn validate_json(value : @moonrockz/openrpc/json.Value, root~ : @moonrockz/openrpc/json.Value, path? : Array[String], base? : @moonrockz/openrpc/reference.UriReference?, resources? : @moonrockz/openrpc/reference.ResourceSet, max_nodes? : Int, max_edges? : Int, max_findings? : Int, max_comparison_work? : Int, limits? : @moonrockz/openrpc/json.Limits) -> Report

Report malformed schema documents without constructing an invalid typed AST.

Source