parser

type Constant struct {
	// The name of this constant from the spec (not normalized)
	Name string

	// Whether this constant is a common type
	Common bool

	// The accepted values for this constant
	Enum []string

	// The data type for this constant (currently only supports strings)
	Type *DataType
}

type Constants map[string]*Constant

type DataType uint8

type Header struct {
	Name string
	Type *DataType
}

type Model struct {
	// The type name of this model from the spec (not normalized)
	Name string

	// Fields that comprise this model
	Fields map[string]*ModelField

	// Whether this model is a common type
	Common bool

	// Whether this model has known child models
	Parent bool

	// For parent models, the field name containing the discriminated type value
	TypeField *string

	// For child models, the type value that specifies this model
	TypeValue *string

	// For child models, the name of the parent model
	ParentModel *string
}

type ModelField struct {
	// The name of this field
	Name string

	// The internal type for this field
	Type *DataType

	// The internal type for items, when this field type is DataTypeArray
	ItemType *DataType

	// Optional description which can be added to the generated SDK model as a comment
	Description string

	// The default value for this field
	Default any

	// Whether the field is required
	Required bool

	// Read-only fields should be omitted during marshalling in the generated SDK
	ReadOnly bool

	// Whether the field value can be a JSON null
	Nullable bool

	// Whether this field contains the discriminated type for a child model
	DiscriminatedValue bool

	// The name of a referenced model or constant, noting that this should be the full type name from the spec prior to normalizing
	ReferenceName *string

	// This is parsed from the spec but otherwise currently unused
	WriteOnly       bool
	AllowEmptyValue bool
}

type Models map[string]*Model

type Operation struct {
	// The full name of this operation, which should be unique across resources (at least in the same category) so
	// prevent clobbering when resources/operations are grouped into an SDK package
	Name string

	// Optional description which can be added to the generated SDK model as a comment
	Description string

	// The type of this operation, initially determined from the HTTP method
	Type OperationType

	// The HTTP method for this operation
	Method string

	// The resource ID that comprises the first part of the URI for this operation
	ResourceId *ResourceId

	// The remainder of the URI after the resource ID
	UriSuffix *string

	// When the content type is JSON or XML, and this is a List operation, the name of the field
	// that specifies a URL to retrieve the next page of results
	PaginationField *string

	// The content-type of the request body
	RequestContentType *string

	// The name of the model that describes the request body, can reference either a common model or describe the ad-hoc request model
	RequestModelName *string

	// The optional ad-hoc request model, if present
	RequestModel *Model

	// Any user-specified HTTP headers supported for the request
	RequestHeaders *[]Header

	// Any user-specified query string parameters support for the request
	RequestParams *[]Param

	// The internal data type for the request, used when the content type is JSON or XML,
	// and the request is not described by a model
	RequestType *DataType

	// The HTTP status codes associated with this expected response
	ResponseStatusCodes []int

	// The expected content type for this resource
	ResponseContentType *string

	// Specifies a referenced model or constant for the response, noting that this
	// should be the full type name from the spec prior to normalizing
	ResponseReferenceName *string

	// The internal data type for the response, used when the content type is JSON or XML,
	// and the response is not described by a model
	ResponseType *DataType

	// Model and Constant are used internally for ad-hoc response models
	ResponseModel    *Model
	ResponseConstant *Constant

	// OpenAPI3 tags for this operation, used to reconcile operations to services
	Tags []string
}

type OperationType uint8

type Param struct {
	Name     string
	Type     *DataType
	ItemType *DataType
}

type Resource struct {
	// The name of this resource
	Name string

	// The category for this resource, used to group resources together in the same SDK package
	Category string

	// The API version for this resource
	Version string

	// The name of the service associated with this resource
	Service string

	// All known paths for this resource, used for category matching between different resources
	Paths []ResourceId

	// Supported operations for this resource
	Operations []Operation
}

type ResourceId struct {
	Name     string
	Service  string
	Segments []ResourceIdSegment
}

type ResourceIdMatch struct {
	Id        *ResourceId
	Remainder *ResourceId
}

type ResourceIdSegment struct {
	Type  ResourceIdSegmentType
	Value string
	// contains filtered or unexported fields
}

type ResourceIdSegmentType string

type ResourceIds map[string]*ResourceId

type Resources map[string]*Resource