api

type Action struct {
	// Combine Combination method
	Combine *string `json:"combine"`

	// Conditions Conditional logic
	Conditions *[]Condition `json:"conditions,omitempty"`

	// Operation Operation to perform
	Operation *string `json:"operation"`

	// Output Action output
	Output string `json:"output"`

	// Subject Subject of the action
	Subject *string `json:"subject"`

	// Unit Unit for the action
	Unit *string `json:"unit"`

	// Value Represents a value in an operation (can be a primitive value or nested action)
	Value *ActionValue `json:"value,omitempty"`

	// Values Represents multiple values or a single value
	Values *ActionValues `json:"values,omitempty"`
}

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

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

type ActionValue1 = interface{}

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

type ActionValues0 = []ActionValue

type ActionValues1 = interface{}

type Apply struct {
	// Aggregate Aggregate identifier
	Aggregate string `json:"aggregate"`

	// Events Associated events
	Events []ApplyEvent `json:"events"`

	// Name Name of the application rule
	Name string `json:"name"`

	// Update Update rules
	Update []Update `json:"update"`
}

type ApplyEvent struct {
	// Filter Event filter criteria
	Filter map[string]interface{} `json:"filter"`

	// Type Event type
	Type string `json:"type"`
}

type BadRequestErrorResponse struct {
	Errors []Error `json:"errors"`
}

type BaseField struct {
	// Description Field description
	Description string `json:"description"`

	// Name Field name
	Name string `json:"name"`

	// Required Whether the field is required
	Required *bool     `json:"required"`
	Temporal *Temporal `json:"temporal,omitempty"`

	// Type Field type
	Type     string    `json:"type"`
	TypeSpec *TypeSpec `json:"type_spec,omitempty"`
}

type Bsn = string

type Case struct {
	// AppealStatus Parameters to set the objection status
	AppealStatus       *CaseAppealStatus `json:"appealStatus,omitempty"`
	Approved           *bool             `json:"approved,omitempty"`
	ApprovedClaimsOnly bool              `json:"approvedClaimsOnly"`

	// Bsn Burgerservicenummer of a Dutch citizen
	Bsn           Bsn                    `json:"bsn"`
	ClaimIds      *[]openapi_types.UUID  `json:"claim_ids,omitempty"`
	ClaimedResult map[string]interface{} `json:"claimedResult"`

	// Id Identifier of a case
	Id CaseID `json:"id"`

	// Law Specify the law that needs to be executed
	Law string `json:"law"`

	// ObjectionStatus Parameters to set the objection status
	ObjectionStatus *CaseObjectionStatus   `json:"objectionStatus,omitempty"`
	Parameters      map[string]interface{} `json:"parameters"`

	// RulespecId Identifier of the rulespec
	RulespecId openapi_types.UUID `json:"rulespecId"`

	// Service Specify the service that needs to be executed
	Service        string                 `json:"service"`
	Status         CaseStatus             `json:"status"`
	VerifiedResult map[string]interface{} `json:"verifiedResult"`
}

type CaseAppealStatus struct {
	AppealPeriod       *int    `json:"appealPeriod,omitempty"`
	CompetentCourt     *string `json:"competentCourt,omitempty"`
	CourtType          *string `json:"courtType,omitempty"`
	DirectAppeal       *bool   `json:"directAppeal,omitempty"`
	DirectAppealReason *string `json:"directAppealReason,omitempty"`
	NotPossibleReason  *string `json:"notPossibleReason,omitempty"`
	Possible           *bool   `json:"possible,omitempty"`
}

type CaseBasedOnBSNServiceLawResponse struct {
	Body         []byte
	HTTPResponse *http.Response
	JSON200      *ResponseCase
	JSON400      *BadRequestErrorResponse
	JSON404      *ResourceNotFoundErrorResponse
	JSON500      *InternalServerErrorResponse
}

type CaseGetResponse struct {
	Body         []byte
	HTTPResponse *http.Response
	JSON200      *ResponseCase
	JSON400      *BadRequestErrorResponse
	JSON404      *ResourceNotFoundErrorResponse
	JSON500      *InternalServerErrorResponse
}

type CaseID = openapi_types.UUID

type CaseList = []Case

type CaseListBasedOnBSNResponse struct {
	Body         []byte
	HTTPResponse *http.Response
	JSON200      *ResponseCaseList
	JSON400      *BadRequestErrorResponse
	JSON404      *ResourceNotFoundErrorResponse
	JSON500      *InternalServerErrorResponse
}

type CaseListBasedOnServiceLawResponse struct {
	Body         []byte
	HTTPResponse *http.Response
	JSON200      *ResponseCaseList
	JSON400      *BadRequestErrorResponse
	JSON500      *InternalServerErrorResponse
}

type CaseObject struct {
	// Reason Explanation for the objection
	Reason string `json:"reason"`
}

type CaseObjectJSONBody struct {
	Data CaseObject `json:"data"`
}

type CaseObjectJSONRequestBody CaseObjectJSONBody

type CaseObjectRequest struct {
	Data CaseObject `json:"data"`
}

type CaseObjectResponse struct {
	Body         []byte
	HTTPResponse *http.Response
	JSON200      *ResponseCaseObject
	JSON400      *BadRequestErrorResponse
	JSON404      *ResourceNotFoundErrorResponse
	JSON500      *InternalServerErrorResponse
}

type CaseObjectionStatus struct {
	Admissable        *bool   `json:"admissable,omitempty"`
	DecisionPeriod    *int    `json:"decisionPeriod,omitempty"`
	ExtensionPeriod   *int    `json:"extensionPeriod,omitempty"`
	NotPossibleReason *string `json:"notPossibleReason,omitempty"`
	ObjectionPeriod   *int    `json:"objectionPeriod,omitempty"`
	Possible          *bool   `json:"possible,omitempty"`
}

type CaseReview struct {
	// Approved Decision outcome - true for approval, false for rejection
	Approved bool `json:"approved"`

	// Reason Explanation for the decision
	Reason string `json:"reason"`

	// VerifierId ID of the verifier making the decision
	VerifierId string `json:"verifierId"`
}

type CaseReviewJSONBody struct {
	Data CaseReview `json:"data"`
}

type CaseReviewJSONRequestBody CaseReviewJSONBody

type CaseReviewRequest struct {
	Data CaseReview `json:"data"`
}

type CaseReviewResponse struct {
	Body         []byte
	HTTPResponse *http.Response
	JSON200      *ResponseCaseReview
	JSON400      *BadRequestErrorResponse
	JSON404      *ResourceNotFoundErrorResponse
	JSON500      *InternalServerErrorResponse
}

type CaseStatus string

type CaseSubmit struct {
	ApprovedClaimsOnly bool `json:"approvedClaimsOnly"`

	// Bsn Burgerservicenummer of a Dutch citizen
	Bsn           Bsn                    `json:"bsn"`
	ClaimedResult map[string]interface{} `json:"claimedResult"`

	// EffectiveDate The date on which the case, when accepted, should become effective. Defaults to the moment of acceptance.
	EffectiveDate *openapi_types.Date `json:"effective_date,omitempty"`

	// Law Specify the law that needs to be executed
	Law        string                 `json:"law"`
	Parameters map[string]interface{} `json:"parameters"`

	// Service Specify the service that needs to be executed
	Service string `json:"service"`
}

type CaseSubmitJSONBody struct {
	// Data Case
	Data CaseSubmit `json:"data"`
}

type CaseSubmitJSONRequestBody CaseSubmitJSONBody

type CaseSubmitRequest struct {
	// Data Case
	Data CaseSubmit `json:"data"`
}

type CaseSubmitResponse struct {
	Body         []byte
	HTTPResponse *http.Response
	JSON201      *ResponseCaseSubmit
	JSON400      *BadRequestErrorResponse
	JSON500      *InternalServerErrorResponse
}

type Claim struct {
	// Bsn Burgerservicenummer of a Dutch citizen
	Bsn Bsn `json:"bsn"`

	// CaseId Identifier of a case
	CaseId       *CaseID `json:"caseId,omitempty"`
	Claimant     string  `json:"claimant"`
	EvidencePath *string `json:"evidencePath,omitempty"`

	// Id Identifier of a claim
	Id  ClaimID `json:"id"`
	Key string  `json:"key"`

	// Law Specify the law that needs to be executed
	Law      string      `json:"law"`
	NewValue interface{} `json:"newValue"`
	OldValue interface{} `json:"oldValue,omitempty"`
	Reason   string      `json:"reason"`

	// Service Specify the service that needs to be executed
	Service string      `json:"service"`
	Status  ClaimStatus `json:"status"`
}

type ClaimApprove struct {
	// VerifiedBy User that verified the claim
	VerifiedBy string `json:"verifiedBy"`

	// VerifiedValue Verified value for the claim
	VerifiedValue string `json:"verifiedValue"`
}

type ClaimApproveJSONBody struct {
	// Data Approve a claim
	Data ClaimApprove `json:"data"`
}

type ClaimApproveJSONRequestBody ClaimApproveJSONBody

type ClaimApproveRequest struct {
	// Data Approve a claim
	Data ClaimApprove `json:"data"`
}

type ClaimApproveResponse struct {
	Body         []byte
	HTTPResponse *http.Response
	JSON200      *ResponseClaimApprove
	JSON400      *BadRequestErrorResponse
	JSON404      *ResourceNotFoundErrorResponse
	JSON500      *InternalServerErrorResponse
}

type ClaimID = openapi_types.UUID

type ClaimList = []Claim

type ClaimListBasedOnBSNParams struct {
	// Approved If added to URI only approved claims will be returned.
	Approved *QueryOnlyApproved `form:"approved,omitempty" json:"approved,omitempty"`

	// IncludeRejected If added to URI rejected claims will be added to the return
	IncludeRejected *QueryIncludeRejected `form:"includeRejected,omitempty" json:"includeRejected,omitempty"`
}

type ClaimListBasedOnBSNResponse struct {
	Body         []byte
	HTTPResponse *http.Response
	JSON200      *ClaimListResponse
	JSON400      *BadRequestErrorResponse
	JSON500      *InternalServerErrorResponse
}

type ClaimListBasedOnBSNServiceLawParams struct {
	// Approved If added to URI only approved claims will be returned.
	Approved *QueryOnlyApproved `form:"approved,omitempty" json:"approved,omitempty"`

	// IncludeRejected If added to URI rejected claims will be added to the return
	IncludeRejected *QueryIncludeRejected `form:"includeRejected,omitempty" json:"includeRejected,omitempty"`
}

type ClaimListBasedOnBSNServiceLawResponse struct {
	Body         []byte
	HTTPResponse *http.Response
	JSON200      *ClaimListWithKeyResponse
	JSON400      *BadRequestErrorResponse
	JSON500      *InternalServerErrorResponse
}

type ClaimListResponse struct {
	// Data List of all claims
	Data ClaimList `json:"data"`
}

type ClaimListWithKeyResponse struct {
	Data map[string]Claim `json:"data"`
}

type ClaimReject struct {
	// RejectedBy User that rejected the claim
	RejectedBy string `json:"rejectedBy"`

	// RejectionReason Reason of the rejection
	RejectionReason string `json:"rejectionReason"`
}

type ClaimRejectJSONBody struct {
	// Data Reject a claim
	Data ClaimReject `json:"data"`
}

type ClaimRejectJSONRequestBody ClaimRejectJSONBody

type ClaimRejectRequest struct {
	// Data Reject a claim
	Data ClaimReject `json:"data"`
}

type ClaimRejectResponse struct {
	Body         []byte
	HTTPResponse *http.Response
	JSON200      *ResponseClaimReject
	JSON400      *BadRequestErrorResponse
	JSON404      *ResourceNotFoundErrorResponse
	JSON500      *InternalServerErrorResponse
}

type ClaimStatus string

type ClaimSubmit struct {
	// AutoApprove Whether to automatically approve the claim
	AutoApprove *bool `json:"autoApprove,omitempty"`

	// Bsn Burgerservicenummer of a Dutch citizen
	Bsn Bsn `json:"bsn"`

	// CaseId Optional identifier of the related case
	CaseId *openapi_types.UUID `json:"caseId"`

	// Claimant Identity of the claimant
	Claimant string `json:"claimant"`

	// EvidencePath Path to evidence supporting the claim
	EvidencePath *string `json:"evidencePath"`

	// Key Key to be claimed
	Key string `json:"key"`

	// Law Legal basis for the claim
	Law      string      `json:"law"`
	NewValue interface{} `json:"newValue"`
	OldValue interface{} `json:"oldValue,omitempty"`

	// Reason Reason for the claim
	Reason string `json:"reason"`

	// Service Service identifier
	Service string `json:"service"`
}

type ClaimSubmitJSONBody struct {
	// Data Submit a new claim
	Data ClaimSubmit `json:"data"`
}

type ClaimSubmitJSONRequestBody ClaimSubmitJSONBody

type ClaimSubmitRequest struct {
	// Data Submit a new claim
	Data ClaimSubmit `json:"data"`
}

type ClaimSubmitResponse struct {
	Body         []byte
	HTTPResponse *http.Response
	JSON201      *ResponseClaimSubmit
	JSON400      *BadRequestErrorResponse
	JSON500      *InternalServerErrorResponse
}

type Client struct {
	// The endpoint of the server conforming to this interface, with scheme,
	// https://api.deepmap.com for example. This can contain a path relative
	// to the server, such as https://api.deepmap.com/dev-test, and all the
	// paths in the swagger spec will be appended to the server.
	Server string

	// Doer for performing requests, typically a *http.Client with any
	// customized settings, such as certificate chains.
	Client HttpRequestDoer

	// A list of callbacks for modifying requests which are generated before sending over
	// the network.
	RequestEditors []RequestEditorFn
}

type ClientInterface interface {
	// CaseSubmitWithBody request with any body
	CaseSubmitWithBody(ctx context.Context, contentType string, body io.Reader, reqEditors ...RequestEditorFn) (*http.Response, error)

	CaseSubmit(ctx context.Context, body CaseSubmitJSONRequestBody, reqEditors ...RequestEditorFn) (*http.Response, error)

	// CaseGet request
	CaseGet(ctx context.Context, caseID PathCaseID, reqEditors ...RequestEditorFn) (*http.Response, error)

	// EventListBasedOnCaseID request
	EventListBasedOnCaseID(ctx context.Context, caseID PathCaseID, reqEditors ...RequestEditorFn) (*http.Response, error)

	// CaseListBasedOnBSN request
	CaseListBasedOnBSN(ctx context.Context, bsn PathBSN, reqEditors ...RequestEditorFn) (*http.Response, error)

	// CaseBasedOnBSNServiceLaw request
	CaseBasedOnBSNServiceLaw(ctx context.Context, bsn PathBSN, service PathService, law PathLaw, reqEditors ...RequestEditorFn) (*http.Response, error)

	// CaseObjectWithBody request with any body
	CaseObjectWithBody(ctx context.Context, caseID PathCaseID, contentType string, body io.Reader, reqEditors ...RequestEditorFn) (*http.Response, error)

	CaseObject(ctx context.Context, caseID PathCaseID, body CaseObjectJSONRequestBody, reqEditors ...RequestEditorFn) (*http.Response, error)

	// CaseReviewWithBody request with any body
	CaseReviewWithBody(ctx context.Context, caseID PathCaseID, contentType string, body io.Reader, reqEditors ...RequestEditorFn) (*http.Response, error)

	CaseReview(ctx context.Context, caseID PathCaseID, body CaseReviewJSONRequestBody, reqEditors ...RequestEditorFn) (*http.Response, error)

	// CaseListBasedOnServiceLaw request
	CaseListBasedOnServiceLaw(ctx context.Context, service PathService, law PathLaw, reqEditors ...RequestEditorFn) (*http.Response, error)

	// ClaimSubmitWithBody request with any body
	ClaimSubmitWithBody(ctx context.Context, contentType string, body io.Reader, reqEditors ...RequestEditorFn) (*http.Response, error)

	ClaimSubmit(ctx context.Context, body ClaimSubmitJSONRequestBody, reqEditors ...RequestEditorFn) (*http.Response, error)

	// ClaimListBasedOnBSN request
	ClaimListBasedOnBSN(ctx context.Context, bsn PathBSN, params *ClaimListBasedOnBSNParams, reqEditors ...RequestEditorFn) (*http.Response, error)

	// ClaimListBasedOnBSNServiceLaw request
	ClaimListBasedOnBSNServiceLaw(ctx context.Context, bsn PathBSN, service PathService, law PathLaw, params *ClaimListBasedOnBSNServiceLawParams, reqEditors ...RequestEditorFn) (*http.Response, error)

	// ClaimApproveWithBody request with any body
	ClaimApproveWithBody(ctx context.Context, claimId PathClaimID, contentType string, body io.Reader, reqEditors ...RequestEditorFn) (*http.Response, error)

	ClaimApprove(ctx context.Context, claimId PathClaimID, body ClaimApproveJSONRequestBody, reqEditors ...RequestEditorFn) (*http.Response, error)

	// ClaimRejectWithBody request with any body
	ClaimRejectWithBody(ctx context.Context, claimId PathClaimID, contentType string, body io.Reader, reqEditors ...RequestEditorFn) (*http.Response, error)

	ClaimReject(ctx context.Context, claimId PathClaimID, body ClaimRejectJSONRequestBody, reqEditors ...RequestEditorFn) (*http.Response, error)

	// ServiceLawsDiscoverableList request
	ServiceLawsDiscoverableList(ctx context.Context, params *ServiceLawsDiscoverableListParams, reqEditors ...RequestEditorFn) (*http.Response, error)

	// ResetEngine request
	ResetEngine(ctx context.Context, reqEditors ...RequestEditorFn) (*http.Response, error)

	// EvaluateWithBody request with any body
	EvaluateWithBody(ctx context.Context, contentType string, body io.Reader, reqEditors ...RequestEditorFn) (*http.Response, error)

	Evaluate(ctx context.Context, body EvaluateJSONRequestBody, reqEditors ...RequestEditorFn) (*http.Response, error)

	// EventList request
	EventList(ctx context.Context, reqEditors ...RequestEditorFn) (*http.Response, error)

	// ProfileList request
	ProfileList(ctx context.Context, params *ProfileListParams, reqEditors ...RequestEditorFn) (*http.Response, error)

	// ProfileGet request
	ProfileGet(ctx context.Context, bsn PathBSN, params *ProfileGetParams, reqEditors ...RequestEditorFn) (*http.Response, error)

	// RuleSpecGet request
	RuleSpecGet(ctx context.Context, params *RuleSpecGetParams, reqEditors ...RequestEditorFn) (*http.Response, error)

	// SetSourceDataFrameWithBody request with any body
	SetSourceDataFrameWithBody(ctx context.Context, contentType string, body io.Reader, reqEditors ...RequestEditorFn) (*http.Response, error)

	SetSourceDataFrame(ctx context.Context, body SetSourceDataFrameJSONRequestBody, reqEditors ...RequestEditorFn) (*http.Response, error)
}

type ClientOption func(*Client) error

type ClientWithResponses struct {
	ClientInterface
}

type ClientWithResponsesInterface interface {
	// CaseSubmitWithBodyWithResponse request with any body
	CaseSubmitWithBodyWithResponse(ctx context.Context, contentType string, body io.Reader, reqEditors ...RequestEditorFn) (*CaseSubmitResponse, error)

	CaseSubmitWithResponse(ctx context.Context, body CaseSubmitJSONRequestBody, reqEditors ...RequestEditorFn) (*CaseSubmitResponse, error)

	// CaseGetWithResponse request
	CaseGetWithResponse(ctx context.Context, caseID PathCaseID, reqEditors ...RequestEditorFn) (*CaseGetResponse, error)

	// EventListBasedOnCaseIDWithResponse request
	EventListBasedOnCaseIDWithResponse(ctx context.Context, caseID PathCaseID, reqEditors ...RequestEditorFn) (*EventListBasedOnCaseIDResponse, error)

	// CaseListBasedOnBSNWithResponse request
	CaseListBasedOnBSNWithResponse(ctx context.Context, bsn PathBSN, reqEditors ...RequestEditorFn) (*CaseListBasedOnBSNResponse, error)

	// CaseBasedOnBSNServiceLawWithResponse request
	CaseBasedOnBSNServiceLawWithResponse(ctx context.Context, bsn PathBSN, service PathService, law PathLaw, reqEditors ...RequestEditorFn) (*CaseBasedOnBSNServiceLawResponse, error)

	// CaseObjectWithBodyWithResponse request with any body
	CaseObjectWithBodyWithResponse(ctx context.Context, caseID PathCaseID, contentType string, body io.Reader, reqEditors ...RequestEditorFn) (*CaseObjectResponse, error)

	CaseObjectWithResponse(ctx context.Context, caseID PathCaseID, body CaseObjectJSONRequestBody, reqEditors ...RequestEditorFn) (*CaseObjectResponse, error)

	// CaseReviewWithBodyWithResponse request with any body
	CaseReviewWithBodyWithResponse(ctx context.Context, caseID PathCaseID, contentType string, body io.Reader, reqEditors ...RequestEditorFn) (*CaseReviewResponse, error)

	CaseReviewWithResponse(ctx context.Context, caseID PathCaseID, body CaseReviewJSONRequestBody, reqEditors ...RequestEditorFn) (*CaseReviewResponse, error)

	// CaseListBasedOnServiceLawWithResponse request
	CaseListBasedOnServiceLawWithResponse(ctx context.Context, service PathService, law PathLaw, reqEditors ...RequestEditorFn) (*CaseListBasedOnServiceLawResponse, error)

	// ClaimSubmitWithBodyWithResponse request with any body
	ClaimSubmitWithBodyWithResponse(ctx context.Context, contentType string, body io.Reader, reqEditors ...RequestEditorFn) (*ClaimSubmitResponse, error)

	ClaimSubmitWithResponse(ctx context.Context, body ClaimSubmitJSONRequestBody, reqEditors ...RequestEditorFn) (*ClaimSubmitResponse, error)

	// ClaimListBasedOnBSNWithResponse request
	ClaimListBasedOnBSNWithResponse(ctx context.Context, bsn PathBSN, params *ClaimListBasedOnBSNParams, reqEditors ...RequestEditorFn) (*ClaimListBasedOnBSNResponse, error)

	// ClaimListBasedOnBSNServiceLawWithResponse request
	ClaimListBasedOnBSNServiceLawWithResponse(ctx context.Context, bsn PathBSN, service PathService, law PathLaw, params *ClaimListBasedOnBSNServiceLawParams, reqEditors ...RequestEditorFn) (*ClaimListBasedOnBSNServiceLawResponse, error)

	// ClaimApproveWithBodyWithResponse request with any body
	ClaimApproveWithBodyWithResponse(ctx context.Context, claimId PathClaimID, contentType string, body io.Reader, reqEditors ...RequestEditorFn) (*ClaimApproveResponse, error)

	ClaimApproveWithResponse(ctx context.Context, claimId PathClaimID, body ClaimApproveJSONRequestBody, reqEditors ...RequestEditorFn) (*ClaimApproveResponse, error)

	// ClaimRejectWithBodyWithResponse request with any body
	ClaimRejectWithBodyWithResponse(ctx context.Context, claimId PathClaimID, contentType string, body io.Reader, reqEditors ...RequestEditorFn) (*ClaimRejectResponse, error)

	ClaimRejectWithResponse(ctx context.Context, claimId PathClaimID, body ClaimRejectJSONRequestBody, reqEditors ...RequestEditorFn) (*ClaimRejectResponse, error)

	// ServiceLawsDiscoverableListWithResponse request
	ServiceLawsDiscoverableListWithResponse(ctx context.Context, params *ServiceLawsDiscoverableListParams, reqEditors ...RequestEditorFn) (*ServiceLawsDiscoverableListResponse, error)

	// ResetEngineWithResponse request
	ResetEngineWithResponse(ctx context.Context, reqEditors ...RequestEditorFn) (*ResetEngineResponse, error)

	// EvaluateWithBodyWithResponse request with any body
	EvaluateWithBodyWithResponse(ctx context.Context, contentType string, body io.Reader, reqEditors ...RequestEditorFn) (*EvaluateResponse, error)

	EvaluateWithResponse(ctx context.Context, body EvaluateJSONRequestBody, reqEditors ...RequestEditorFn) (*EvaluateResponse, error)

	// EventListWithResponse request
	EventListWithResponse(ctx context.Context, reqEditors ...RequestEditorFn) (*EventListResponse, error)

	// ProfileListWithResponse request
	ProfileListWithResponse(ctx context.Context, params *ProfileListParams, reqEditors ...RequestEditorFn) (*ProfileListResponse, error)

	// ProfileGetWithResponse request
	ProfileGetWithResponse(ctx context.Context, bsn PathBSN, params *ProfileGetParams, reqEditors ...RequestEditorFn) (*ProfileGetResponse, error)

	// RuleSpecGetWithResponse request
	RuleSpecGetWithResponse(ctx context.Context, params *RuleSpecGetParams, reqEditors ...RequestEditorFn) (*RuleSpecGetResponse, error)

	// SetSourceDataFrameWithBodyWithResponse request with any body
	SetSourceDataFrameWithBodyWithResponse(ctx context.Context, contentType string, body io.Reader, reqEditors ...RequestEditorFn) (*SetSourceDataFrameResponse, error)

	SetSourceDataFrameWithResponse(ctx context.Context, body SetSourceDataFrameJSONRequestBody, reqEditors ...RequestEditorFn) (*SetSourceDataFrameResponse, error)
}

type Condition struct {
	// Else Represents a value in an operation (can be a primitive value or nested action)
	Else *ActionValue `json:"else,omitempty"`
	Test *Action      `json:"test,omitempty"`

	// Then Represents a value in an operation (can be a primitive value or nested action)
	Then *ActionValue `json:"then,omitempty"`
}

type DataFrame struct {
	// Data Column definitions for the data frame
	Data    []map[string]interface{} `json:"data"`
	Service string                   `json:"service"`
	Table   string                   `json:"table"`
}

type DataFrameRequest struct {
	Data DataFrame `json:"data"`
}

type DiscoverableBy = string

type Error struct {
	Message string `json:"message"`
}

type Evaluate struct {
	// Approved only use approved claims, default to true
	Approved *bool `json:"approved,omitempty"`

	// EffectiveDate Can be used to set the effective execution date
	EffectiveDate *openapi_types.Date     `json:"effectiveDate,omitempty"`
	Input         *map[string]interface{} `json:"input,omitempty"`

	// Law Specify the law that needs to be executed
	Law string `json:"law"`

	// Output specify a requested output value
	Output     *string                 `json:"output,omitempty"`
	Parameters *map[string]interface{} `json:"parameters,omitempty"`

	// ReferenceDate Can be used to set the reference date of data
	ReferenceDate *openapi_types.Date `json:"referenceDate,omitempty"`

	// Service Specify the service that needs to be executed
	Service string `json:"service"`
}

type EvaluateJSONBody struct {
	// Data Evaluate.
	Data Evaluate `json:"data"`
}

type EvaluateJSONRequestBody EvaluateJSONBody

type EvaluateRequest struct {
	// Data Evaluate.
	Data Evaluate `json:"data"`
}

type EvaluateResponse struct {
	Body         []byte
	HTTPResponse *http.Response
	JSON201      *ResponseEvaluate
	JSON400      *BadRequestErrorResponse
	JSON500      *InternalServerErrorResponse
}

type Event struct {
	Data map[string]interface{} `json:"data"`

	// EventType Type of the event
	EventType string    `json:"eventType"`
	Timestamp time.Time `json:"timestamp"`
}

type EventList = []Event

type EventListBasedOnCaseIDResponse struct {
	Body         []byte
	HTTPResponse *http.Response
	JSON200      *ResponseEventList
	JSON400      *BadRequestErrorResponse
	JSON404      *ResourceNotFoundErrorResponse
	JSON500      *InternalServerErrorResponse
}

type EventListResponse struct {
	Body         []byte
	HTTPResponse *http.Response
	JSON200      *ResponseEventList
	JSON400      *BadRequestErrorResponse
	JSON500      *InternalServerErrorResponse
}

type HttpRequestDoer interface {
	Do(req *http.Request) (*http.Response, error)
}

type InputField struct {
	// Description Field description
	Description string `json:"description"`

	// Name Field name
	Name string `json:"name"`

	// Required Whether the field is required
	Required         *bool            `json:"required"`
	ServiceReference ServiceReference `json:"service_reference"`
	Temporal         *Temporal        `json:"temporal,omitempty"`

	// Type Field type
	Type     string    `json:"type"`
	TypeSpec *TypeSpec `json:"type_spec,omitempty"`
}

type InternalServerErrorResponse struct {
	Errors []Error `json:"errors"`
}

type Law struct {
	// DiscoverableBy Who can discover this law
	DiscoverableBy []string `json:"discoverableBy"`

	// Name Name of the law
	Name string `json:"name"`
}

type OutputField struct {
	CitizenRelevance string `json:"citizen_relevance"`

	// Description Field description
	Description string `json:"description"`

	// Name Field name
	Name string `json:"name"`

	// Required Whether the field is required
	Required *bool     `json:"required"`
	Temporal *Temporal `json:"temporal,omitempty"`

	// Type Field type
	Type     string    `json:"type"`
	TypeSpec *TypeSpec `json:"type_spec,omitempty"`
}

type Parameter struct {
	// Name Parameter name
	Name string `json:"name"`

	// Reference Parameter reference
	Reference string `json:"reference"`
}

type ParameterField = BaseField

type PathBSN = Bsn

type PathCaseID = CaseID

type PathClaimID = ClaimID

type PathLaw = string

type PathNode struct {
	Children    *[]PathNode             `json:"children,omitempty"`
	Details     *map[string]interface{} `json:"details,omitempty"`
	Name        string                  `json:"name"`
	Required    *bool                   `json:"required,omitempty"`
	ResolveType *string                 `json:"resolveType,omitempty"`
	Result      interface{}             `json:"result,omitempty"`
	Type        string                  `json:"type"`
}

type PathService = string

type Profile struct {
	// Bsn Burgerservicenummer of a Dutch citizen
	Bsn Bsn `json:"bsn"`

	// Description Description of the burger
	Description string `json:"description"`

	// Name Name of the burger
	Name string `json:"name"`

	// Sources All sources for a certain profile
	Sources map[string]Source `json:"sources"`
}

type ProfileGetParams struct {
	// EffectiveDate Can be used to set the effective execution date
	EffectiveDate *QueryEffectiveDate `form:"effective_date,omitempty" json:"effective_date,omitempty"`
}

type ProfileGetResponse struct {
	Body         []byte
	HTTPResponse *http.Response
	JSON200      *ProfileResponse
	JSON400      *BadRequestErrorResponse
	JSON404      *ResourceNotFoundErrorResponse
	JSON500      *InternalServerErrorResponse
}

type ProfileList = []Profile

type ProfileListParams struct {
	// EffectiveDate Can be used to set the effective execution date
	EffectiveDate *QueryEffectiveDate `form:"effective_date,omitempty" json:"effective_date,omitempty"`
}

type ProfileListResponse struct {
	Body         []byte
	HTTPResponse *http.Response
	JSON200      *ResponseProfileList
	JSON400      *BadRequestErrorResponse
	JSON500      *InternalServerErrorResponse
}

type ProfileResponse struct {
	// Data Profile
	Data Profile `json:"data"`
}

type Properties struct {
	// Applies Application rules
	Applies *[]Apply `json:"applies,omitempty"`

	// Definitions Additional definitions
	Definitions *map[string]interface{} `json:"definitions,omitempty"`

	// Input Input fields
	Input *[]InputField `json:"input,omitempty"`

	// Output Output fields
	Output *[]OutputField `json:"output,omitempty"`

	// Parameters Parameter fields
	Parameters *[]ParameterField `json:"parameters,omitempty"`

	// Sources Source fields
	Sources *[]SourceField `json:"sources,omitempty"`
}

type QueryDiscoverableBy = DiscoverableBy

type QueryEffectiveDate = openapi_types.Date

type QueryIncludeRejected = bool

type QueryLaw = string

type QueryOnlyApproved = bool

type QueryReferenceDate = ReferenceDate

type QueryService = string

type Reference struct {
	// Article Article reference
	Article string `json:"article"`

	// Law Law reference
	Law string `json:"law"`

	// Url URL to the legal reference
	Url string `json:"url"`
}

type ReferenceDate = openapi_types.Date

type RequestEditorFn func(ctx context.Context, req *http.Request) error

type Requirement struct {
	// All All requirements must be met (AND logic)
	All *[]ActionRequirement `json:"all"`

	// Or Any requirement must be met (OR logic)
	Or *[]ActionRequirement `json:"or"`
}

type ResetEngineResponse struct {
	Body         []byte
	HTTPResponse *http.Response
	JSON400      *BadRequestErrorResponse
	JSON500      *InternalServerErrorResponse
}

type ResourceNotFoundErrorResponse struct {
	Errors *[]Error `json:"errors,omitempty"`
}

type ResponseCase struct {
	// Data Case
	Data Case `json:"data"`
}

type ResponseCaseList struct {
	// Data List of all cases
	Data CaseList `json:"data"`
}

type ResponseCaseObject struct {
	// Data Identifier of a case
	Data CaseID `json:"data"`
}

type ResponseCaseReview struct {
	// Data Identifier of a case
	Data CaseID `json:"data"`
}

type ResponseCaseSubmit struct {
	// Data Identifier of a case
	Data CaseID `json:"data"`
}

type ResponseClaimApprove struct {
	// Data Identifier of a claim
	Data ClaimID `json:"data"`
}

type ResponseClaimReject struct {
	// Data Identifier of a claim
	Data ClaimID `json:"data"`
}

type ResponseClaimSubmit struct {
	// Data Identifier of a claim
	Data ClaimID `json:"data"`
}

type ResponseEvaluate struct {
	// Data Evaluate response
	Data ResponseEvaluateSchema `json:"data"`
}

type ResponseEvaluateSchema struct {
	Input map[string]interface{} `json:"input"`

	// MissingRequired Will be true when a required value is missing
	MissingRequired bool                   `json:"missingRequired"`
	Output          map[string]interface{} `json:"output"`

	// Path path node
	Path PathNode `json:"path"`

	// RequirementsMet Will be true when all requirements where met
	RequirementsMet bool `json:"requirementsMet"`

	// RulespecId Identifier of the rulespec
	RulespecId openapi_types.UUID `json:"rulespecId"`
}

type ResponseEventList struct {
	// Data List of all events
	Data EventList `json:"data"`
}

type ResponseProfileList struct {
	// Data List of all burgers
	Data ProfileList `json:"data"`
}

type RuleSpec struct {
	// Actions Actions associated with the rule
	Actions *[]Action `json:"actions,omitempty"`

	// DecisionType Type of decision
	DecisionType *string `json:"decision_type"`

	// Description Description of the rule specification
	Description string `json:"description"`

	// Discoverable Discoverability setting
	Discoverable *string `json:"discoverable"`

	// Law Associated law reference
	Law string `json:"law"`

	// LawType Type of law
	LawType *string `json:"law_type"`

	// LegalCharacter Legal character of the rule
	LegalCharacter *string `json:"legal_character"`

	// Name Name of the rule specification
	Name       string     `json:"name"`
	Properties Properties `json:"properties"`

	// References Legal references
	References *[]Reference `json:"references,omitempty"`

	// Requirements Requirements for the rule
	Requirements *[]Requirement `json:"requirements,omitempty"`

	// Service Associated service identifier
	Service string `json:"service"`

	// Uuid Unique identifier for the rule specification
	Uuid openapi_types.UUID `json:"uuid"`

	// ValidFrom Date from which the rule is valid
	ValidFrom time.Time `json:"valid_from"`
}

type RuleSpecGetParams struct {
	// Service filter for service
	Service QueryService `form:"service" json:"service"`

	// Law filter for law
	Law QueryLaw `form:"law" json:"law"`

	// ReferenceDate reference date
	ReferenceDate QueryReferenceDate `form:"referenceDate" json:"referenceDate"`
}

type RuleSpecGetResponse struct {
	Body         []byte
	HTTPResponse *http.Response
	JSON200      *RuleSpecResponse
	JSON400      *BadRequestErrorResponse
	JSON500      *InternalServerErrorResponse
}

type RuleSpecResponse struct {
	Data RuleSpec `json:"data"`
}

type SelectField struct {
	// Description Field description
	Description string `json:"description"`

	// Name Field name
	Name string `json:"name"`

	// Type Field type
	Type string `json:"type"`

	// Value Represents a value in an operation (can be a primitive value or nested action)
	Value ActionValue `json:"value"`
}

type Service struct {
	Laws []Law `json:"laws"`

	// Name Service name
	Name string `json:"name"`
}

type ServiceLawsDiscoverableListParams struct {
	// DiscoverableBy Filter for discoverable by, defaults to 'CITIZEN'
	DiscoverableBy *QueryDiscoverableBy `form:"discoverableBy,omitempty" json:"discoverableBy,omitempty"`
}

type ServiceLawsDiscoverableListResponse struct {
	Body         []byte
	HTTPResponse *http.Response
	JSON200      *ServiceListResponse
	JSON400      *BadRequestErrorResponse
	JSON500      *InternalServerErrorResponse
}

type ServiceList = []Service

type ServiceListResponse struct {
	// Data List of all services
	Data ServiceList `json:"data"`
}

type ServiceReference struct {
	// Field Field in the referenced service
	Field string `json:"field"`

	// Law Associated law
	Law string `json:"law"`

	// Parameters Service parameters
	Parameters *[]Parameter `json:"parameters,omitempty"`

	// Service Referenced service identifier
	Service string `json:"service"`
}

type SetSourceDataFrameJSONBody struct {
	Data DataFrame `json:"data"`
}

type SetSourceDataFrameJSONRequestBody SetSourceDataFrameJSONBody

type SetSourceDataFrameResponse struct {
	Body         []byte
	HTTPResponse *http.Response
	JSON400      *BadRequestErrorResponse
	JSON500      *InternalServerErrorResponse
}

type Source map[string][]map[string]interface{}

type SourceField struct {
	// Description Field description
	Description string `json:"description"`

	// Name Field name
	Name string `json:"name"`

	// Required Whether the field is required
	Required         *bool             `json:"required"`
	ServiceReference *ServiceReference `json:"service_reference,omitempty"`
	SourceReference  *SourceReference  `json:"source_reference,omitempty"`
	Temporal         *Temporal         `json:"temporal,omitempty"`

	// Type Field type
	Type     string    `json:"type"`
	TypeSpec *TypeSpec `json:"type_spec,omitempty"`
}

type SourceReference struct {
	// Field Specific field to reference
	Field *string `json:"field"`

	// Fields Multiple fields to reference
	Fields *[]string `json:"fields"`

	// SelectOn Selection criteria
	SelectOn *[]SelectField `json:"select_on,omitempty"`

	// SourceType Type of the data source
	SourceType *string `json:"source_type,omitempty"`

	// Table Table name in the source
	Table *string `json:"table,omitempty"`
}

type Temporal struct {
	// ImmutableAfter Immutability rule
	ImmutableAfter *string `json:"immutable_after"`

	// PeriodType Period type specification
	PeriodType *string `json:"period_type"`

	// Reference Reference (can be string or VariableReference)
	Reference *string `json:"reference"`

	// Type Temporal type
	Type string `json:"type"`
}

type TypeSpec struct {
	// Max Maximum value
	Max *float64 `json:"max"`

	// Min Minimum value
	Min *float64 `json:"min"`

	// Precision Precision for numeric types
	Precision *int `json:"precision"`

	// Type Specific type definition
	Type string `json:"type"`

	// Unit Unit of measurement
	Unit *string `json:"unit"`
}

type Update struct {
	// Mapping Field mapping configuration
	Mapping map[string]string `json:"mapping"`

	// Method Update method
	Method string `json:"method"`
}