openrpc_document

package module
v0.0.0-...-ee339fd Latest Latest
Warning

This package is not in the latest version of its module.

 Go to latest Published: May 8, 2024 License: Apache-2.0 Imports: 2 Imported by: 11

README

OpenRPC Meta JSON Schema

CircleCI branch npm GitHub release GitHub commits since latest release

This is the JSON Schema file for the OpenRPC Specification. You may use it to validate your open rpc documents.

This repo also contains the code which takes the schema, and generates typings for various languages. Currently supported languages:

  • Typescript
  • Rust
  • Go
  • Python

Need help or have a question? Join us on Discord!

License

Apache-2.0

Contributing

How to contribute, build and release are outlined in CONTRIBUTING.md, BUILDING.md and RELEASING.md respectively. Commits in this repository follow the CONVENTIONAL_COMMITS.md specification.

Documentation

Index

Constants

View Source 
const RawOpenrpc_document = "" /* 12211-byte string literal not displayed */

Variables

This section is empty.

Functions

This section is empty.

Types

type AlwaysFalse 

type AlwaysFalse interface{}

type AlwaysTrue 

type AlwaysTrue interface{}

type ArrayOfSimpleTypes 

type ArrayOfSimpleTypes []SimpleTypes

type Comment 

type Comment string

type Components 

type Components struct {
	Schemas            *SchemaComponents            `json:"schemas,omitempty"`
	Links              *LinkComponents              `json:"links,omitempty"`
	Errors             *ErrorComponents             `json:"errors,omitempty"`
	Examples           *ExampleComponents           `json:"examples,omitempty"`
	ExamplePairings    *ExamplePairingComponents    `json:"examplePairings,omitempty"`
	ContentDescriptors *ContentDescriptorComponents `json:"contentDescriptors,omitempty"`
	Tags               *TagComponents               `json:"tags,omitempty"`
}

type ContactObject 

type ContactObject struct {
	Name  *ContactObjectName  `json:"name,omitempty"`
	Email *ContactObjectEmail `json:"email,omitempty"`
	Url   *ContactObjectUrl   `json:"url,omitempty"`
}

type ContactObjectEmail 

type ContactObjectEmail string

type ContactObjectName 

type ContactObjectName string

type ContactObjectUrl 

type ContactObjectUrl string

type ContentDescriptorComponents 

type ContentDescriptorComponents map[string]interface{}

type ContentDescriptorObject 

type ContentDescriptorObject struct {
	Name        *ContentDescriptorObjectName        `json:"name"`
	Description *ContentDescriptorObjectDescription `json:"description,omitempty"`
	Summary     *ContentDescriptorObjectSummary     `json:"summary,omitempty"`
	Schema      *JSONSchema                         `json:"schema"`
	Required    *ContentDescriptorObjectRequired    `json:"required,omitempty"`
	Deprecated  *ContentDescriptorObjectDeprecated  `json:"deprecated,omitempty"`
}

type ContentDescriptorObjectDeprecated 

type ContentDescriptorObjectDeprecated bool

type ContentDescriptorObjectDescription 

type ContentDescriptorObjectDescription string

type ContentDescriptorObjectName 

type ContentDescriptorObjectName string

type ContentDescriptorObjectRequired 

type ContentDescriptorObjectRequired bool

type ContentDescriptorObjectSummary 

type ContentDescriptorObjectSummary string

type ContentDescriptorOrReference 

type ContentDescriptorOrReference struct {
	ContentDescriptorObject *ContentDescriptorObject
	ReferenceObject         *ReferenceObject
}

func (ContentDescriptorOrReference) MarshalJSON 

func (o ContentDescriptorOrReference) MarshalJSON() ([]byte, error)

func (*ContentDescriptorOrReference) UnmarshalJSON 

func (o *ContentDescriptorOrReference) UnmarshalJSON(bytes []byte) error

UnmarshalJSON implements the json Unmarshaler interface. This implementation DOES NOT assert that ONE AND ONLY ONE of the simple properties is satisfied; it lazily uses the first one that is satisfied. Ergo, it will not return an error if more than one property is valid.

type ContentEncoding 

type ContentEncoding string

type ContentMediaType 

type ContentMediaType string

type Definitions 

type Definitions map[string]interface{}

--- Default ---

{}

type Dependencies 

type Dependencies map[string]interface{}

type DependenciesSet 

type DependenciesSet struct {
	JSONSchema  *JSONSchema
	StringArray *StringArray
}

func (DependenciesSet) MarshalJSON 

func (o DependenciesSet) MarshalJSON() ([]byte, error)

func (*DependenciesSet) UnmarshalJSON 

func (a *DependenciesSet) UnmarshalJSON(bytes []byte) error

type Description 

type Description string

type Enum 

type Enum []AlwaysTrue

type ErrorComponents 

type ErrorComponents map[string]interface{}

type ErrorObject 

type ErrorObject struct {
	Code    *ErrorObjectCode    `json:"code"`
	Message *ErrorObjectMessage `json:"message"`
	Data    *ErrorObjectData    `json:"data,omitempty"`
}

Defines an application level error.

type ErrorObjectCode 

type ErrorObjectCode int64

A Number that indicates the error type that occurred. This MUST be an integer. The error codes from and including -32768 to -32000 are reserved for pre-defined errors. These pre-defined errors SHOULD be assumed to be returned from any JSON-RPC api.

type ErrorObjectData 

type ErrorObjectData interface{}

A Primitive or Structured value that contains additional information about the error. This may be omitted. The value of this member is defined by the Server (e.g. detailed error information, nested errors etc.).

type ErrorObjectMessage 

type ErrorObjectMessage string

A String providing a short description of the error. The message SHOULD be limited to a concise single sentence.

type ErrorOrReference 

type ErrorOrReference struct {
	ErrorObject     *ErrorObject
	ReferenceObject *ReferenceObject
}

func (ErrorOrReference) MarshalJSON 

func (o ErrorOrReference) MarshalJSON() ([]byte, error)

func (*ErrorOrReference) UnmarshalJSON 

func (o *ErrorOrReference) UnmarshalJSON(bytes []byte) error

UnmarshalJSON implements the json Unmarshaler interface. This implementation DOES NOT assert that ONE AND ONLY ONE of the simple properties is satisfied; it lazily uses the first one that is satisfied. Ergo, it will not return an error if more than one property is valid.

type ExampleComponents 

type ExampleComponents map[string]interface{}

type ExampleObject 

type ExampleObject struct {
	Summary     *ExampleObjectSummary     `json:"summary,omitempty"`
	Value       *ExampleObjectValue       `json:"value"`
	Description *ExampleObjectDescription `json:"description,omitempty"`
	Name        *ExampleObjectName        `json:"name"`
}

type ExampleObjectDescription 

type ExampleObjectDescription string

type ExampleObjectName 

type ExampleObjectName string

type ExampleObjectSummary 

type ExampleObjectSummary string

type ExampleObjectValue 

type ExampleObjectValue interface{}

type ExampleOrReference 

type ExampleOrReference struct {
	ExampleObject   *ExampleObject
	ReferenceObject *ReferenceObject
}

func (ExampleOrReference) MarshalJSON 

func (o ExampleOrReference) MarshalJSON() ([]byte, error)

func (*ExampleOrReference) UnmarshalJSON 

func (o *ExampleOrReference) UnmarshalJSON(bytes []byte) error

UnmarshalJSON implements the json Unmarshaler interface. This implementation DOES NOT assert that ONE AND ONLY ONE of the simple properties is satisfied; it lazily uses the first one that is satisfied. Ergo, it will not return an error if more than one property is valid.

type ExamplePairingComponents 

type ExamplePairingComponents map[string]interface{}

type ExamplePairingObject 

type ExamplePairingObject struct {
	Name        *ExamplePairingObjectName        `json:"name"`
	Description *ExamplePairingObjectDescription `json:"description,omitempty"`
	Params      *ExamplePairingObjectParams      `json:"params"`
	Result      *ExamplePairingObjectResult      `json:"result,omitempty"`
}

type ExamplePairingObjectDescription 

type ExamplePairingObjectDescription string

type ExamplePairingObjectName 

type ExamplePairingObjectName string

type ExamplePairingObjectParams 

type ExamplePairingObjectParams []ExampleOrReference

type ExamplePairingObjectResult 

type ExamplePairingObjectResult struct {
	ExampleObject   *ExampleObject
	ReferenceObject *ReferenceObject
}

func (ExamplePairingObjectResult) MarshalJSON 

func (o ExamplePairingObjectResult) MarshalJSON() ([]byte, error)

func (*ExamplePairingObjectResult) UnmarshalJSON 

func (o *ExamplePairingObjectResult) UnmarshalJSON(bytes []byte) error

UnmarshalJSON implements the json Unmarshaler interface. This implementation DOES NOT assert that ONE AND ONLY ONE of the simple properties is satisfied; it lazily uses the first one that is satisfied. Ergo, it will not return an error if more than one property is valid.

type ExamplePairingOrReference 

type ExamplePairingOrReference struct {
	ExamplePairingObject *ExamplePairingObject
	ReferenceObject      *ReferenceObject
}

func (ExamplePairingOrReference) MarshalJSON 

func (o ExamplePairingOrReference) MarshalJSON() ([]byte, error)

func (*ExamplePairingOrReference) UnmarshalJSON 

func (o *ExamplePairingOrReference) UnmarshalJSON(bytes []byte) error

UnmarshalJSON implements the json Unmarshaler interface. This implementation DOES NOT assert that ONE AND ONLY ONE of the simple properties is satisfied; it lazily uses the first one that is satisfied. Ergo, it will not return an error if more than one property is valid.

type Examples 

type Examples []AlwaysTrue

type ExclusiveMaximum 

type ExclusiveMaximum float64

type ExclusiveMinimum 

type ExclusiveMinimum float64

type ExternalDocumentationObject 

type ExternalDocumentationObject struct {
	Description *ExternalDocumentationObjectDescription `json:"description,omitempty"`
	Url         *ExternalDocumentationObjectUrl         `json:"url"`
}

information about external documentation

type ExternalDocumentationObjectDescription 

type ExternalDocumentationObjectDescription string

type ExternalDocumentationObjectUrl 

type ExternalDocumentationObjectUrl string

type Format 

type Format string

type Id 

type Id string

type InfoObject 

type InfoObject struct {
	Title          *InfoObjectProperties     `json:"title"`
	Description    *InfoObjectDescription    `json:"description,omitempty"`
	TermsOfService *InfoObjectTermsOfService `json:"termsOfService,omitempty"`
	Version        *InfoObjectVersion        `json:"version"`
	Contact        *ContactObject            `json:"contact,omitempty"`
	License        *LicenseObject            `json:"license,omitempty"`
}

type InfoObjectDescription 

type InfoObjectDescription string

type InfoObjectProperties 

type InfoObjectProperties string

type InfoObjectTermsOfService 

type InfoObjectTermsOfService string

type InfoObjectVersion 

type InfoObjectVersion string

type Items 

type Items struct {
	JSONSchema  *JSONSchema
	SchemaArray *SchemaArray
}

--- Default ---

true

func (Items) MarshalJSON 

func (o Items) MarshalJSON() ([]byte, error)

func (*Items) UnmarshalJSON 

func (a *Items) UnmarshalJSON(bytes []byte) error

type JSONSchema 

type JSONSchema struct {
	JSONSchemaObject  *JSONSchemaObject
	JSONSchemaBoolean *JSONSchemaBoolean
}

--- Default ---

{}

func (JSONSchema) MarshalJSON 

func (o JSONSchema) MarshalJSON() ([]byte, error)

func (*JSONSchema) UnmarshalJSON 

func (o *JSONSchema) UnmarshalJSON(bytes []byte) error

UnmarshalJSON implements the json Unmarshaler interface. This implementation DOES NOT assert that ONE AND ONLY ONE of the simple properties is satisfied; it lazily uses the first one that is satisfied. Ergo, it will not return an error if more than one property is valid.

type JSONSchemaBoolean 

type JSONSchemaBoolean bool

Always valid if true. Never valid if false. Is constant.

type JSONSchemaObject 

type JSONSchemaObject struct {
	Id                   *Id                            `json:"$id,omitempty"`
	Schema               *Schema                        `json:"$schema,omitempty"`
	Ref                  *Ref                           `json:"$ref,omitempty"`
	Comment              *Comment                       `json:"$comment,omitempty"`
	Title                *Title                         `json:"title,omitempty"`
	Description          *Description                   `json:"description,omitempty"`
	Default              *AlwaysTrue                    `json:"default,omitempty"`
	ReadOnly             *ReadOnly                      `json:"readOnly,omitempty"`
	Examples             *Examples                      `json:"examples,omitempty"`
	MultipleOf           *MultipleOf                    `json:"multipleOf,omitempty"`
	Maximum              *Maximum                       `json:"maximum,omitempty"`
	ExclusiveMaximum     *ExclusiveMaximum              `json:"exclusiveMaximum,omitempty"`
	Minimum              *Minimum                       `json:"minimum,omitempty"`
	ExclusiveMinimum     *ExclusiveMinimum              `json:"exclusiveMinimum,omitempty"`
	MaxLength            *NonNegativeInteger            `json:"maxLength,omitempty"`
	MinLength            *NonNegativeIntegerDefaultZero `json:"minLength,omitempty"`
	Pattern              *Pattern                       `json:"pattern,omitempty"`
	AdditionalItems      *JSONSchema                    `json:"additionalItems,omitempty"`
	Items                *Items                         `json:"items,omitempty"`
	MaxItems             *NonNegativeInteger            `json:"maxItems,omitempty"`
	MinItems             *NonNegativeIntegerDefaultZero `json:"minItems,omitempty"`
	UniqueItems          *UniqueItems                   `json:"uniqueItems,omitempty"`
	Contains             *JSONSchema                    `json:"contains,omitempty"`
	MaxProperties        *NonNegativeInteger            `json:"maxProperties,omitempty"`
	MinProperties        *NonNegativeIntegerDefaultZero `json:"minProperties,omitempty"`
	Required             *StringArray                   `json:"required,omitempty"`
	AdditionalProperties *JSONSchema                    `json:"additionalProperties,omitempty"`
	Definitions          *Definitions                   `json:"definitions,omitempty"`
	Properties           *Properties                    `json:"properties,omitempty"`
	PatternProperties    *PatternProperties             `json:"patternProperties,omitempty"`
	Dependencies         *Dependencies                  `json:"dependencies,omitempty"`
	PropertyNames        *JSONSchema                    `json:"propertyNames,omitempty"`
	Const                *AlwaysTrue                    `json:"const,omitempty"`
	Enum                 *Enum                          `json:"enum,omitempty"`
	Type                 *Type                          `json:"type,omitempty"`
	Format               *Format                        `json:"format,omitempty"`
	ContentMediaType     *ContentMediaType              `json:"contentMediaType,omitempty"`
	ContentEncoding      *ContentEncoding               `json:"contentEncoding,omitempty"`
	If                   *JSONSchema                    `json:"if,omitempty"`
	Then                 *JSONSchema                    `json:"then,omitempty"`
	Else                 *JSONSchema                    `json:"else,omitempty"`
	AllOf                *SchemaArray                   `json:"allOf,omitempty"`
	AnyOf                *SchemaArray                   `json:"anyOf,omitempty"`
	OneOf                *SchemaArray                   `json:"oneOf,omitempty"`
	Not                  *JSONSchema                    `json:"not,omitempty"`
}

type LicenseObject 

type LicenseObject struct {
	Name *LicenseObjectName `json:"name,omitempty"`
	Url  *LicenseObjectUrl  `json:"url,omitempty"`
}

type LicenseObjectName 

type LicenseObjectName string

type LicenseObjectUrl 

type LicenseObjectUrl string

type LinkComponents 

type LinkComponents map[string]interface{}

type LinkObject 

type LinkObject struct {
	Name        *LinkObjectName        `json:"name,omitempty"`
	Summary     *LinkObjectSummary     `json:"summary,omitempty"`
	Method      *LinkObjectMethod      `json:"method,omitempty"`
	Description *LinkObjectDescription `json:"description,omitempty"`
	Params      *LinkObjectParams      `json:"params,omitempty"`
	Server      *LinkObjectServer      `json:"server,omitempty"`
}

type LinkObjectDescription 

type LinkObjectDescription string

type LinkObjectMethod 

type LinkObjectMethod string

type LinkObjectName 

type LinkObjectName string

type LinkObjectParams 

type LinkObjectParams interface{}

type LinkObjectServer 

type LinkObjectServer struct {
	Url         *ServerObjectUrl         `json:"url"`
	Name        *ServerObjectName        `json:"name,omitempty"`
	Description *ServerObjectDescription `json:"description,omitempty"`
	Summary     *ServerObjectSummary     `json:"summary,omitempty"`
	Variables   *ServerObjectVariables   `json:"variables,omitempty"`
}

type LinkObjectSummary 

type LinkObjectSummary string

type LinkOrReference 

type LinkOrReference struct {
	LinkObject      *LinkObject
	ReferenceObject *ReferenceObject
}

func (LinkOrReference) MarshalJSON 

func (o LinkOrReference) MarshalJSON() ([]byte, error)

func (*LinkOrReference) UnmarshalJSON 

func (o *LinkOrReference) UnmarshalJSON(bytes []byte) error

UnmarshalJSON implements the json Unmarshaler interface. This implementation DOES NOT assert that ONE AND ONLY ONE of the simple properties is satisfied; it lazily uses the first one that is satisfied. Ergo, it will not return an error if more than one property is valid.

type Maximum 

type Maximum float64

type MetaSchema 

type MetaSchema string

JSON Schema URI (used by some editors)

--- Default ---

https://meta.open-rpc.org/

type MethodObject 

type MethodObject struct {
	Name           *MethodObjectName            `json:"name"`
	Description    *MethodObjectDescription     `json:"description,omitempty"`
	Summary        *MethodObjectSummary         `json:"summary,omitempty"`
	Servers        *Servers                     `json:"servers,omitempty"`
	Tags           *MethodObjectTags            `json:"tags,omitempty"`
	ParamStructure *MethodObjectParamStructure  `json:"paramStructure,omitempty"`
	Params         *MethodObjectParams          `json:"params"`
	Result         *MethodObjectResult          `json:"result,omitempty"`
	Errors         *MethodObjectErrors          `json:"errors,omitempty"`
	Links          *MethodObjectLinks           `json:"links,omitempty"`
	Examples       *MethodObjectExamples        `json:"examples,omitempty"`
	Deprecated     *MethodObjectDeprecated      `json:"deprecated,omitempty"`
	ExternalDocs   *ExternalDocumentationObject `json:"externalDocs,omitempty"`
}

type MethodObjectDeprecated 

type MethodObjectDeprecated bool

type MethodObjectDescription 

type MethodObjectDescription string

A verbose explanation of the method behavior. GitHub Flavored Markdown syntax MAY be used for rich text representation.

type MethodObjectErrors 

type MethodObjectErrors []ErrorOrReference

Defines an application level error.

type MethodObjectExamples 

type MethodObjectExamples []ExamplePairingOrReference
type MethodObjectLinks []LinkOrReference

type MethodObjectName 

type MethodObjectName string

The cannonical name for the method. The name MUST be unique within the methods array.

type MethodObjectParamStructure 

type MethodObjectParamStructure string

Format the server expects the params. Defaults to 'either'.

--- Default ---

either 

const (
	MethodObjectParamStructureEnum0 MethodObjectParamStructure = "by-position"
	MethodObjectParamStructureEnum1 MethodObjectParamStructure = "by-name"
	MethodObjectParamStructureEnum2 MethodObjectParamStructure = "either"
)

type MethodObjectParams 

type MethodObjectParams []ContentDescriptorOrReference

type MethodObjectResult 

type MethodObjectResult struct {
	ContentDescriptorObject *ContentDescriptorObject
	ReferenceObject         *ReferenceObject
}

func (MethodObjectResult) MarshalJSON 

func (o MethodObjectResult) MarshalJSON() ([]byte, error)

func (*MethodObjectResult) UnmarshalJSON 

func (o *MethodObjectResult) UnmarshalJSON(bytes []byte) error

UnmarshalJSON implements the json Unmarshaler interface. This implementation DOES NOT assert that ONE AND ONLY ONE of the simple properties is satisfied; it lazily uses the first one that is satisfied. Ergo, it will not return an error if more than one property is valid.

type MethodObjectSummary 

type MethodObjectSummary string

A short summary of what the method does.

type MethodObjectTags 

type MethodObjectTags []TagOrReference

type MethodOrReference 

type MethodOrReference struct {
	MethodObject    *MethodObject
	ReferenceObject *ReferenceObject
}

func (MethodOrReference) MarshalJSON 

func (o MethodOrReference) MarshalJSON() ([]byte, error)

func (*MethodOrReference) UnmarshalJSON 

func (o *MethodOrReference) UnmarshalJSON(bytes []byte) error

UnmarshalJSON implements the json Unmarshaler interface. This implementation DOES NOT assert that ONE AND ONLY ONE of the simple properties is satisfied; it lazily uses the first one that is satisfied. Ergo, it will not return an error if more than one property is valid.

type Methods 

type Methods []MethodOrReference

type Minimum 

type Minimum float64

type MultipleOf 

type MultipleOf float64

type NonNegativeInteger 

type NonNegativeInteger int64

type NonNegativeIntegerDefaultZero 

type NonNegativeIntegerDefaultZero int64

type Openrpc 

type Openrpc string
const (
	OpenrpcEnum0  Openrpc = "1.3.2"
	OpenrpcEnum1  Openrpc = "1.3.1"
	OpenrpcEnum2  Openrpc = "1.3.0"
	OpenrpcEnum3  Openrpc = "1.2.6"
	OpenrpcEnum4  Openrpc = "1.2.5"
	OpenrpcEnum5  Openrpc = "1.2.4"
	OpenrpcEnum6  Openrpc = "1.2.3"
	OpenrpcEnum7  Openrpc = "1.2.2"
	OpenrpcEnum8  Openrpc = "1.2.1"
	OpenrpcEnum9  Openrpc = "1.2.0"
	OpenrpcEnum10 Openrpc = "1.1.12"
	OpenrpcEnum11 Openrpc = "1.1.11"
	OpenrpcEnum12 Openrpc = "1.1.10"
	OpenrpcEnum13 Openrpc = "1.1.9"
	OpenrpcEnum14 Openrpc = "1.1.8"
	OpenrpcEnum15 Openrpc = "1.1.7"
	OpenrpcEnum16 Openrpc = "1.1.6"
	OpenrpcEnum17 Openrpc = "1.1.5"
	OpenrpcEnum18 Openrpc = "1.1.4"
	OpenrpcEnum19 Openrpc = "1.1.3"
	OpenrpcEnum20 Openrpc = "1.1.2"
	OpenrpcEnum21 Openrpc = "1.1.1"
	OpenrpcEnum22 Openrpc = "1.1.0"
	OpenrpcEnum23 Openrpc = "1.0.0"
	OpenrpcEnum24 Openrpc = "1.0.0-rc1"
	OpenrpcEnum25 Openrpc = "1.0.0-rc0"
)

type OpenrpcDocument 

type OpenrpcDocument struct {
	Openrpc      *Openrpc                     `json:"openrpc"`
	Info         *InfoObject                  `json:"info"`
	ExternalDocs *ExternalDocumentationObject `json:"externalDocs,omitempty"`
	Servers      *Servers                     `json:"servers,omitempty"`
	Methods      *Methods                     `json:"methods"`
	Components   *Components                  `json:"components,omitempty"`
	Schema       *MetaSchema                  `json:"$schema,omitempty"`
}

type Pattern 

type Pattern string

type PatternProperties 

type PatternProperties map[string]interface{}

--- Default ---

{}

type Properties 

type Properties map[string]interface{}

--- Default ---

{}

type ReadOnly 

type ReadOnly bool

type Ref 

type Ref string

type ReferenceObject 

type ReferenceObject struct {
	Ref *Ref `json:"$ref"`
}

type Schema 

type Schema string

type SchemaArray 

type SchemaArray []JSONSchema

type SchemaComponents 

type SchemaComponents map[string]interface{}

type ServerObject 

type ServerObject struct {
	Url         *ServerObjectUrl         `json:"url"`
	Name        *ServerObjectName        `json:"name,omitempty"`
	Description *ServerObjectDescription `json:"description,omitempty"`
	Summary     *ServerObjectSummary     `json:"summary,omitempty"`
	Variables   *ServerObjectVariables   `json:"variables,omitempty"`
}

type ServerObjectDescription 

type ServerObjectDescription string

type ServerObjectName 

type ServerObjectName string

type ServerObjectSummary 

type ServerObjectSummary string

type ServerObjectUrl 

type ServerObjectUrl string

type ServerObjectVariable 

type ServerObjectVariable struct {
	Default     *ServerObjectVariableDefault     `json:"default"`
	Description *ServerObjectVariableDescription `json:"description,omitempty"`
	Enum        *ServerObjectVariableEnum        `json:"enum,omitempty"`
}

type ServerObjectVariableDefault 

type ServerObjectVariableDefault string

type ServerObjectVariableDescription 

type ServerObjectVariableDescription string

type ServerObjectVariableEnum 

type ServerObjectVariableEnum []ServerObjectVariableEnumItem

type ServerObjectVariableEnumItem 

type ServerObjectVariableEnumItem string

type ServerObjectVariables 

type ServerObjectVariables map[string]interface{}

type Servers 

type Servers []ServerObject

type SimpleTypes 

type SimpleTypes string
const (
	SimpleTypesEnum0 SimpleTypes = "array"
	SimpleTypesEnum1 SimpleTypes = "boolean"
	SimpleTypesEnum2 SimpleTypes = "integer"
	SimpleTypesEnum3 SimpleTypes = "null"
	SimpleTypesEnum4 SimpleTypes = "number"
	SimpleTypesEnum5 SimpleTypes = "object"
	SimpleTypesEnum6 SimpleTypes = "string"
)

type SpecificationExtension 

type SpecificationExtension interface{}

type StringArray 

type StringArray []StringDoaGddGA

--- Default ---

[]

type StringDoaGddGA 

type StringDoaGddGA string

type TagComponents 

type TagComponents map[string]interface{}

type TagObject 

type TagObject struct {
	Name         *TagObjectName               `json:"name"`
	Description  *TagObjectDescription        `json:"description,omitempty"`
	ExternalDocs *ExternalDocumentationObject `json:"externalDocs,omitempty"`
}

type TagObjectDescription 

type TagObjectDescription string

type TagObjectName 

type TagObjectName string

type TagOrReference 

type TagOrReference struct {
	TagObject       *TagObject
	ReferenceObject *ReferenceObject
}

func (TagOrReference) MarshalJSON 

func (o TagOrReference) MarshalJSON() ([]byte, error)

func (*TagOrReference) UnmarshalJSON 

func (o *TagOrReference) UnmarshalJSON(bytes []byte) error

UnmarshalJSON implements the json Unmarshaler interface. This implementation DOES NOT assert that ONE AND ONLY ONE of the simple properties is satisfied; it lazily uses the first one that is satisfied. Ergo, it will not return an error if more than one property is valid.

type Title 

type Title string

type Type 

type Type struct {
	SimpleTypes        *SimpleTypes
	ArrayOfSimpleTypes *ArrayOfSimpleTypes
}

func (Type) MarshalJSON 

func (o Type) MarshalJSON() ([]byte, error)

func (*Type) UnmarshalJSON 

func (a *Type) UnmarshalJSON(bytes []byte) error

type UniqueItems 

type UniqueItems bool

Source Files

View all Source files

Jump to

Keyboard shortcuts

? : This menu
/ : Search site
f or F : Jump to
y or Y : Canonical URL
go.dev uses cookies from Google to deliver and enhance the quality of its services and to analyze traffic. Learn more.