spec

type AliasDefinition struct {
	TypeName TypeName       `json:"typeName"`
	Alias    Type           `json:"alias"`
	Docs     *Documentation `json:"docs"`
	Safety   *LogSafety     `json:"safety"`
}

type ArgumentDefinition struct {
	ArgName   ArgumentName   `json:"argName"`
	Type      Type           `json:"type"`
	ParamType ParameterType  `json:"paramType"`
	Safety    *LogSafety     `json:"safety"`
	Docs      *Documentation `json:"docs"`
	Markers   []Type         `json:"markers"`
	Tags      []string       `json:"tags"`
}

type ArgumentName string

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

type AuthTypeVisitor interface {
	VisitHeader(v HeaderAuthType) error
	VisitCookie(v CookieAuthType) error
	VisitUnknown(typeName string) error
}

type AuthTypeVisitorWithContext interface {
	VisitHeaderWithContext(ctx context.Context, v HeaderAuthType) error
	VisitCookieWithContext(ctx context.Context, v CookieAuthType) error
	VisitUnknownWithContext(ctx context.Context, typeName string) error
}

type AuthTypeVisitorWithT[T any] interface {
	VisitHeader(ctx context.Context, v HeaderAuthType) (T, error)
	VisitCookie(ctx context.Context, v CookieAuthType) (T, error)
	VisitUnknown(ctx context.Context, typ string) (T, error)
}

type AuthTypeWithT[T any] AuthType

type BodyParameterType struct{}

type ConjureDefinition struct {
	Version    int                    `json:"version"`
	Errors     []ErrorDefinition      `json:"errors"`
	Types      []TypeDefinition       `json:"types"`
	Services   []ServiceDefinition    `json:"services"`
	Extensions map[string]interface{} `json:"extensions"`
}

type CookieAuthType struct {
	CookieName string `json:"cookieName"`
}

type Documentation string

type EndpointDefinition struct {
	EndpointName EndpointName         `json:"endpointName"`
	HttpMethod   HttpMethod           `json:"httpMethod"`
	HttpPath     HttpPath             `json:"httpPath"`
	Auth         *AuthType            `json:"auth"`
	Args         []ArgumentDefinition `json:"args"`
	Returns      *Type                `json:"returns"`
	Docs         *Documentation       `json:"docs"`
	Deprecated   *Documentation       `json:"deprecated"`
	Markers      []Type               `json:"markers"`
	Tags         []string             `json:"tags"`
}

type EndpointName string

type EnumDefinition struct {
	TypeName TypeName              `json:"typeName"`
	Values   []EnumValueDefinition `json:"values"`
	Docs     *Documentation        `json:"docs"`
}

type EnumValueDefinition struct {
	Value      string         `json:"value"`
	Docs       *Documentation `json:"docs"`
	Deprecated *Documentation `json:"deprecated"`
}

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

type ErrorCode_Value string

type ErrorDefinition struct {
	ErrorName  TypeName          `json:"errorName"`
	Docs       *Documentation    `json:"docs"`
	Namespace  ErrorNamespace    `json:"namespace"`
	Code       ErrorCode         `json:"code"`
	SafeArgs   []FieldDefinition `json:"safeArgs"`
	UnsafeArgs []FieldDefinition `json:"unsafeArgs"`
}

type ErrorNamespace string

type ExternalReference struct {
	// An identifier for a non-Conjure type which is already defined in a different language (e.g. Java).
	ExternalReference TypeName `` /* 138-byte string literal not displayed */
	// Other language generators may use the provided fallback if the non-Conjure type is not available. The ANY PrimitiveType is permissible for all external types, but a more specific definition is preferable.
	Fallback Type `` /* 235-byte string literal not displayed */
}

type FieldDefinition struct {
	FieldName  FieldName      `json:"fieldName"`
	Type       Type           `json:"type"`
	Docs       *Documentation `json:"docs"`
	Deprecated *Documentation `json:"deprecated"`
	Safety     *LogSafety     `json:"safety"`
}

type FieldName string

type HeaderAuthType struct{}

type HeaderParameterType struct {
	ParamId ParameterId `json:"paramId"`
}

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

type HttpMethod_Value string

type HttpPath string

type ListType struct {
	ItemType Type `json:"itemType"`
}

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

type LogSafety_Value string

type MapType struct {
	KeyType   Type `json:"keyType"`
	ValueType Type `json:"valueType"`
}

type ObjectDefinition struct {
	TypeName TypeName          `json:"typeName"`
	Fields   []FieldDefinition `json:"fields"`
	Docs     *Documentation    `json:"docs"`
}

type OptionalType struct {
	ItemType Type `json:"itemType"`
}

type ParameterId string

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

type ParameterTypeVisitor interface {
	VisitBody(v BodyParameterType) error
	VisitHeader(v HeaderParameterType) error
	VisitPath(v PathParameterType) error
	VisitQuery(v QueryParameterType) error
	VisitUnknown(typeName string) error
}

type ParameterTypeVisitorWithContext interface {
	VisitBodyWithContext(ctx context.Context, v BodyParameterType) error
	VisitHeaderWithContext(ctx context.Context, v HeaderParameterType) error
	VisitPathWithContext(ctx context.Context, v PathParameterType) error
	VisitQueryWithContext(ctx context.Context, v QueryParameterType) error
	VisitUnknownWithContext(ctx context.Context, typeName string) error
}

type ParameterTypeVisitorWithT[T any] interface {
	VisitBody(ctx context.Context, v BodyParameterType) (T, error)
	VisitHeader(ctx context.Context, v HeaderParameterType) (T, error)
	VisitPath(ctx context.Context, v PathParameterType) (T, error)
	VisitQuery(ctx context.Context, v QueryParameterType) (T, error)
	VisitUnknown(ctx context.Context, typ string) (T, error)
}

type ParameterTypeWithT[T any] ParameterType

type PathParameterType struct{}

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

type PrimitiveType_Value string

type QueryParameterType struct {
	ParamId ParameterId `json:"paramId"`
}

type ServiceDefinition struct {
	ServiceName TypeName             `json:"serviceName"`
	Endpoints   []EndpointDefinition `json:"endpoints"`
	Docs        *Documentation       `json:"docs"`
}

type SetType struct {
	ItemType Type `json:"itemType"`
}

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

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

type TypeDefinitionVisitor interface {
	VisitAlias(v AliasDefinition) error
	VisitEnum(v EnumDefinition) error
	VisitObject(v ObjectDefinition) error
	VisitUnion(v UnionDefinition) error
	VisitUnknown(typeName string) error
}

type TypeDefinitionVisitorWithContext interface {
	VisitAliasWithContext(ctx context.Context, v AliasDefinition) error
	VisitEnumWithContext(ctx context.Context, v EnumDefinition) error
	VisitObjectWithContext(ctx context.Context, v ObjectDefinition) error
	VisitUnionWithContext(ctx context.Context, v UnionDefinition) error
	VisitUnknownWithContext(ctx context.Context, typeName string) error
}

type TypeDefinitionVisitorWithT[T any] interface {
	VisitAlias(ctx context.Context, v AliasDefinition) (T, error)
	VisitEnum(ctx context.Context, v EnumDefinition) (T, error)
	VisitObject(ctx context.Context, v ObjectDefinition) (T, error)
	VisitUnion(ctx context.Context, v UnionDefinition) (T, error)
	VisitUnknown(ctx context.Context, typ string) (T, error)
}

type TypeDefinitionWithT[T any] TypeDefinition

type TypeName struct {
	// The name of the custom Conjure type or service. It must be in UpperCamelCase. Numbers are permitted, but not at the beginning of a word. Allowed names: "FooBar", "XYCoordinate", "Build2Request". Disallowed names: "fooBar", "2BuildRequest".
	Name string `` /* 276-byte string literal not displayed */
	// A period-delimited string of package names. The package names must be lowercase. Numbers are permitted, but not at the beginning of a package name. Allowed packages: "foo", "com.palantir.bar", "com.palantir.foo.thing2". Disallowed packages: "Foo", "com.palantir.foo.2thing".
	Package string `` /* 314-byte string literal not displayed */
}

type TypeVisitor interface {
	VisitPrimitive(v PrimitiveType) error
	VisitOptional(v OptionalType) error
	VisitList(v ListType) error
	VisitSet(v SetType) error
	VisitMap(v MapType) error
	VisitReference(v TypeName) error
	VisitExternal(v ExternalReference) error
	VisitUnknown(typeName string) error
}

type TypeVisitorWithContext interface {
	VisitPrimitiveWithContext(ctx context.Context, v PrimitiveType) error
	VisitOptionalWithContext(ctx context.Context, v OptionalType) error
	VisitListWithContext(ctx context.Context, v ListType) error
	VisitSetWithContext(ctx context.Context, v SetType) error
	VisitMapWithContext(ctx context.Context, v MapType) error
	VisitReferenceWithContext(ctx context.Context, v TypeName) error
	VisitExternalWithContext(ctx context.Context, v ExternalReference) error
	VisitUnknownWithContext(ctx context.Context, typeName string) error
}

type TypeVisitorWithT[T any] interface {
	VisitPrimitive(ctx context.Context, v PrimitiveType) (T, error)
	VisitOptional(ctx context.Context, v OptionalType) (T, error)
	VisitList(ctx context.Context, v ListType) (T, error)
	VisitSet(ctx context.Context, v SetType) (T, error)
	VisitMap(ctx context.Context, v MapType) (T, error)
	VisitReference(ctx context.Context, v TypeName) (T, error)
	VisitExternal(ctx context.Context, v ExternalReference) (T, error)
	VisitUnknown(ctx context.Context, typ string) (T, error)
}

type TypeWithT[T any] Type

type UnionDefinition struct {
	TypeName TypeName          `json:"typeName"`
	Union    []FieldDefinition `json:"union"`
	Docs     *Documentation    `json:"docs"`
}