openapistackql

type Addressable interface {
	ConditionIsValid(lhs string, rhs interface{}) bool
	GetLocation() string
	GetName() string
	GetSchema() (Schema, bool)
	GetType() string
	IsRequired() bool
}

type AuthDTO struct {
	Scopes      []string `json:"scopes,omitempty" yaml:"scopes,omitempty"`
	Type        string   `json:"type" yaml:"type"`
	ValuePrefix string   `json:"valuePrefix" yaml:"valuePrefix"`
	KeyID       string   `json:"keyID" yaml:"keyID"`
	KeyIDEnvVar string   `json:"keyIDenvvar" yaml:"keyIDenvvar"`
	KeyFilePath string   `json:"credentialsfilepath" yaml:"credentialsfilepath"`
	KeyEnvVar   string   `json:"credentialsenvvar" yaml:"credentialsenvvar"`
}

type AuthMetadata struct {
	Principal string `json:"principal"`
	Type      string `json:"type"`
	Source    string `json:"source"`
}

type BodyMap map[string]interface{}

type BodyParamPair struct {
	Key string
	Val interface{}
}

type ColumnDescriptor struct {
	Alias        string
	Name         string
	Qualifier    string
	Schema       Schema
	DecoratedCol string
	Val          *sqlparser.SQLVal
	Node         sqlparser.SQLNode
}

type DiscoveryDoc interface {
	// contains filtered or unexported methods
}

type EncodableString string

type ExpectedRequest struct {
	BodyMediaType string `json:"mediaType,omitempty" yaml:"mediaType,omitempty"`
	Schema        Schema
	Required      []string `json:"required,omitempty" yaml:"required,omitempty"`
}

type ExpectedResponse struct {
	BodyMediaType string `json:"mediaType,omitempty" yaml:"mediaType,omitempty"`
	OpenAPIDocKey string `json:"openAPIDocKey,omitempty" yaml:"openAPIDocKey,omitempty"`
	ObjectKey     string `json:"objectKey,omitempty" yaml:"objectKey,omitempty"`
	Schema        Schema
}

type GraphQL struct {
	ID               string         `json:"id" yaml:"id"`
	Query            string         `json:"query,omitempty" yaml:"query,omitempty"` // Required
	Cursor           GraphQLElement `json:"cursor,omitempty" yaml:"cursor,omitempty"`
	ReponseSelection GraphQLElement `json:"responseSelection,omitempty" yaml:"responseSelection,omitempty"`
	URL              string         `json:"url" yaml:"url"`
	HTTPVerb         string         `json:"httpVerb" yaml:"httpVerb"`
}

type GraphQLElement map[string]interface{}

type HttpParameters struct {
	CookieParams ParamMap
	HeaderParams ParamMap
	PathParams   ParamMap
	QueryParams  ParamMap
	RequestBody  BodyMap
	ResponseBody BodyMap
	ServerParams ParamMap
	Unassigned   ParamMap
	Region       EncodableString
	// contains filtered or unexported fields
}

type ITable interface {
	GetName() string
	KeyExists(string) bool
	GetKey(string) (interface{}, error)
	GetKeyAsSqlVal(string) (sqltypes.Value, error)
	GetRequiredParameters() map[string]Addressable
	FilterBy(func(interface{}) (ITable, error)) (ITable, error)
}

type Loader struct {
	*openapi3.Loader
	// contains filtered or unexported fields
}

type MetadataStore struct {
	Store map[string]*Service
}

type MethodSet []*OperationStore

type Methods map[string]OperationStore

type NamedSchema struct {
	// contains filtered or unexported fields
}

type OperationRef struct {
	Ref   string `json:"$ref" yaml:"$ref"`
	Value *openapi3.Operation
}

type OperationSelector struct {
	SQLVerb string `json:"sqlVerb" yaml:"sqlVerb"` // Required
	// Optional parameters.
	Parameters map[string]interface{} `json:"parameters,omitempty" yaml:"parameters,omitempty"`
}

type OperationStore struct {
	MethodKey     string         `json:"-" yaml:"-"`
	SQLVerb       string         `json:"-" yaml:"-"`
	GraphQL       *GraphQL       `json:"-" yaml:"-"`
	StackQLConfig *StackQLConfig `json:"-" yaml:"-"`
	// Optional parameters.
	Parameters   map[string]interface{} `json:"parameters,omitempty" yaml:"parameters,omitempty"`
	PathItem     *openapi3.PathItem     `json:"-" yaml:"-"`                 // Required
	APIMethod    string                 `json:"apiMethod" yaml:"apiMethod"` // Required
	OperationRef *OperationRef          `json:"operation" yaml:"operation"` // Required
	PathRef      *PathItemRef           `json:"path" yaml:"path"`           // Deprecated
	Request      *ExpectedRequest       `json:"request" yaml:"request"`
	Response     *ExpectedResponse      `json:"response" yaml:"response"`
	Servers      *openapi3.Servers      `json:"servers" yaml:"servers"`

	ProviderService *ProviderService `json:"-" yaml:"-"` // upwards traversal
	Provider        *Provider        `json:"-" yaml:"-"` // upwards traversal
	Service         *Service         `json:"-" yaml:"-"` // upwards traversal
	Resource        *Resource        `json:"-" yaml:"-"` // upwards traversal
	// contains filtered or unexported fields
}

type OperationStoreRef struct {
	Ref   string `json:"$ref" yaml:"$ref"`
	Value *OperationStore
}

type Pagination struct {
	RequestToken  *TokenSemantic `json:"requestToken,omitempty" yaml:"requestToken,omitempty"`
	ResponseToken *TokenSemantic `json:"responseToken,omitempty" yaml:"responseToken,omitempty"`
}

type ParamMap map[string]ParameterBinding

type ParamPair struct {
	Key   string
	Param ParameterBinding
}

type Parameter struct {
	openapi3.Parameter
	// contains filtered or unexported fields
}

type ParameterBinding struct {
	Param Addressable // may originally be *openapi3.Parameter or *openapi3.ServerVariable, latter will be co-opted
	Val   interface{}
}

type ParameterSuffixMap struct {
	// contains filtered or unexported fields
}

type Parameters struct {
	openapi3.Parameters
	// contains filtered or unexported fields
}

type PathItemRef struct {
	Ref   string `json:"$ref" yaml:"$ref"`
	Value *openapi3.PathItem
}

type Provider struct {
	openapi3.ExtensionProps
	ResponseKeys
	FilePath         string                      `json:"-" yaml:"-"`
	ID               string                      `json:"id" yaml:"id"`
	Name             string                      `json:"name" yaml:"name"`
	Title            string                      `json:"title" yaml:"title"`
	Version          string                      `json:"version" yaml:"version"`
	Description      string                      `json:"description,omitempty" yaml:"desription,omitempty"`
	ProviderServices map[string]*ProviderService `json:"providerServices,omitempty" yaml:"providerServices,omitempty"`
	StackQLConfig    *StackQLConfig              `json:"config,omitempty" yaml:"config,omitempty"`
}

type ProviderDescription struct {
	Versions []string `json:"versions" yaml: "versions"`
	// contains filtered or unexported fields
}

type ProviderInfo struct {
	Name    string
	Version string
}

type ProviderService struct {
	openapi3.ExtensionProps
	ID            string         `json:"id" yaml:"id"`           // Required
	Name          string         `json:"name" yaml:"name"`       // Required
	Title         string         `json:"title" yaml:"title"`     // Required
	Version       string         `json:"version" yaml:"version"` // Required
	Description   string         `json:"description" yaml:"description"`
	Preferred     bool           `json:"preferred" yaml:"preferred"`
	ServiceRef    *ServiceRef    `json:"service,omitempty" yaml:"service,omitempty"`     // will be lazy evaluated
	ResourcesRef  *ResourcesRef  `json:"resources,omitempty" yaml:"resources,omitempty"` // will be lazy evaluated
	Provider      *Provider      `json:"-" yaml:"-"`                                     // upwards traversal
	StackQLConfig *StackQLConfig `json:"config,omitempty" yaml:"config,omitempty"`
}

type ProvidersList struct {
	Providers map[string]ProviderDescription `json:"providers" yaml: "providers"`
	// contains filtered or unexported fields
}

type Registry struct {
	// contains filtered or unexported fields
}

type RegistryAPI interface {
	PullAndPersistProviderArchive(string, string) error
	PullProviderArchive(string, string) (io.ReadCloser, error)
	ListAllAvailableProviders() (map[string]ProviderDescription, error)
	ListAllProviderVersions(string) (map[string]ProviderDescription, error)
	ListLocallyAvailableProviders() map[string]ProviderDescription
	GetDocBytes(string) ([]byte, error)
	GetLatestAvailableVersion(string) (string, error)
	GetLatestPublishedVersion(string) (string, error)
	GetResourcesShallowFromProvider(*Provider, string) (*ResourceRegister, error)
	GetResourcesShallowFromProviderService(*ProviderService) (*ResourceRegister, error)
	GetResourcesShallowFromURL(ps *ProviderService) (*ResourceRegister, error)
	GetService(ps *ProviderService) (*Service, error)
	GetServiceFragment(*ProviderService, string) (*Service, error)
	GetServiceFromProviderService(*ProviderService) (*Service, error)
	GetServiceDocBytes(string) ([]byte, error)
	GetResourcesRegisterDocBytes(string) ([]byte, error)
	LoadProviderByName(string, string) (*Provider, error)
}

type RegistryConfig struct {
	RegistryURL      string                   `json:"url" yaml:"url"`
	SrcPrefix        *string                  `json:"srcPrefix" yaml:"srcPrefix"`
	DistPrefix       *string                  `json:"distPrefix" yaml:"distPrefix"`
	AllowSrcDownload bool                     `json:"allowSrcDownload" yaml:"allowSrcDownload"`
	LocalDocRoot     string                   `json:"localDocRoot" yaml:"localDocRoot"`
	VerfifyConfig    *edcrypto.VerifierConfig `json:"verifyConfig" yaml:"verifyConfig"`
}

type Resource struct {
	ID                string                         `json:"id" yaml:"id"`       // Required
	Name              string                         `json:"name" yaml:"name"`   // Required
	Title             string                         `json:"title" yaml:"title"` // Required
	Description       string                         `json:"description,omitempty" yaml:"desription,omitempty"`
	SelectorAlgorithm string                         `json:"selectorAlgorithm,omitempty" yaml:"selectorAlgorithm,omitempty"`
	Methods           Methods                        `json:"methods" yaml:"methods"`
	ServiceDocPath    *ServiceRef                    `json:"serviceDoc,omitempty" yaml:"serviceDoc,omitempty"`
	SQLVerbs          map[string][]OperationStoreRef `json:"sqlVerbs" yaml:"sqlVerbs"`
	BaseUrl           string                         `json:"baseUrl,omitempty" yaml:"baseUrl,omitempty"` // hack
	StackQLConfig     *StackQLConfig                 `json:"config,omitempty" yaml:"config,omitempty"`
	Service           *Service                       `json:"-" yaml:"-"` // upwards traversal
	ProviderService   *ProviderService               `json:"-" yaml:"-"` // upwards traversal
	Provider          *Provider                      `json:"-" yaml:"-"` // upwards traversal
}

type ResourceRegister struct {
	ServiceDocPath  *ServiceRef          `json:"serviceDoc,omitempty" yaml:"serviceDoc,omitempty"`
	Resources       map[string]*Resource `json:"resources,omitempty" yaml:"resources,omitempty"`
	ProviderService *ProviderService     `json:"-" yaml:"-"` // upwards traversal
	Provider        *Provider            `json:"-" yaml:"-"` // upwards traversal
}

type ResourcesRef struct {
	Ref   string `json:"$ref" yaml:"$ref"`
	Value *ResourceRegister
}

type ResponseKeys struct {
	SelectItemsKey string `json:"selectItemsKey,omitempty" yaml:"selectItemsKey,omitempty"`
	DeleteItemsKey string `json:"deleteItemsKey,omitempty" yaml:"deleteItemsKey,omitempty"`
}

type SQLExternalColumn struct {
	Name      string `json:"name" yaml:"name"`
	Type      string `json:"type" yaml:"type"`
	Oid       uint32 `json:"oid" yaml:"oid"`
	Width     int    `json:"width" yaml:"width"`
	Precision int    `json:"precision" yaml:"precision"`
}

type SQLExternalConnection struct {
	ConnectionName string                      `json:"alias" yaml:"alias"`
	Tables         map[string]SQLExternalTable `json:"tables" yaml:"tables"`
}

type SQLExternalTable struct {
	CatalogName string              `json:"catalogName" yaml:"catalogName"`
	SchemaName  string              `json:"schemaName" yaml:"schemaName"`
	Name        string              `json:"name" yaml:"name"`
	Columns     []SQLExternalColumn `json:"columns" yaml:"columns"`
}

type Schema interface {
	ConditionIsValid(lhs string, rhs interface{}) bool
	DeprecatedProcessHttpResponse(response *http.Response, path string) (map[string]interface{}, error)
	FindByPath(path string, visited map[string]bool) Schema
	GetAdditionalProperties() (Schema, bool)
	GetAllColumns() []string
	GetItemProperty(k string) (Schema, bool)
	GetItems() (Schema, error)
	GetItemsSchema() (Schema, error)
	GetName() string
	GetPath() string
	GetProperties() (Schemas, error)
	GetProperty(propertyKey string) (Schema, bool)
	GetSelectionName() string
	GetSelectListItems(key string) (Schema, string)
	GetTitle() string
	GetType() string
	GetPropertySchema(key string) (Schema, error)
	GetRequired() []string
	GetSelectSchema(itemsKey, mediaType string) (Schema, string, error)
	IsArrayRef() bool
	IsBoolean() bool
	IsFloat() bool
	IsIntegral() bool
	IsReadOnly() bool
	IsRequired(key string) bool
	ProcessHttpResponseTesting(r *http.Response, path string, defaultMediaType string) (*response.Response, error)
	SetProperties(openapi3.Schemas)
	SetType(string)
	SetKey(string)
	Tabulate(omitColumns bool) *Tabulation
	ToDescriptionMap(extended bool) map[string]interface{}
	// contains filtered or unexported methods
}

type Schemas map[string]Schema

type Service struct {
	*openapi3.T

	StackQLConfig   *StackQLConfig   `json:"-" yaml:"-"`
	ProviderService *ProviderService `json:"-" yaml:"-"` // upwards traversal
	Provider        *Provider        `json:"-" yaml:"-"` // upwards traversal
	// contains filtered or unexported fields
}

type ServiceRef struct {
	Ref   string `json:"$ref" yaml:"$ref"`
	Value *Service
}

type SimpleMockRegistryRoundTripper struct {
	// contains filtered or unexported fields
}

type StackQLConfig struct {
	QueryTranspose   *Transform                  `json:"queryParamTranspose,omitempty" yaml:"queryParamTranspose,omitempty"`
	RequestTranslate *Transform                  `json:"requestTranslate,omitempty" yaml:"requestTranslate,omitempty"`
	Pagination       *Pagination                 `json:"pagination,omitempty" yaml:"pagination,omitempty"`
	Variations       *Variations                 `json:"variations,omitempty" yaml:"variations,omitempty"`
	Views            map[string]*View            `json:"views" yaml:"views"`
	ExternalTables   map[string]SQLExternalTable `json:"sqlExternalTables" yaml:"sqlExternalTables"`
	Auth             *AuthDTO                    `json:"auth,omitempty" yaml:"auth,omitempty"`
}

type StandardTransformerLocator struct{}

type Tabulation struct {
	// contains filtered or unexported fields
}

type TokenSemantic struct {
	Algorithm string            `json:"algorithm,omitempty" yaml:"algorithm,omitempty"`
	Args      TokenSemanticArgs `json:"args,omitempty" yaml:"args,omitempty"`
	Key       string            `json:"key,omitempty" yaml:"key,omitempty"`
	Location  string            `json:"location,omitempty" yaml:"location,omitempty"`
}

type TokenSemanticArgs map[string]interface{}

type TokenTransformer func(interface{}) (interface{}, error)

type Transform struct {
	Algorithm string `json:"algorithm,omitempty" yaml:"algorithm,omitempty"`
}

type TransformerLocator interface {
	GetTransformer(tokenSemantic *TokenSemantic) (TokenTransformer, error)
}

type Variations struct {
	IsObjectSchemaImplicitlyUnioned bool `json:"isObjectSchemaImplicitlyUnioned,omitempty" yaml:"isObjectSchemaImplicitlyUnioned,omitempty"`
}

type View struct {
	Predicate string `json:"predicate" yaml:"predicate"`
	DDL       string `json:"ddl" yaml:"ddl"`
	Fallback  *View  `json:"fallback" yaml:"fallback"` // Future proofing for predicate failover
}