integrationtest

type CreateForecastCreateForecast struct {
	Id          string    `json:"id"`
	Title       string    `json:"title"`
	Description string    `json:"description"`
	Created     time.Time `json:"created"`
	// The point in time at which you predict you will be able to resolve whether
	// how the forecast resolved.
	Resolves time.Time `json:"resolves"`
	// The point in time at which you no longer want to update your probability
	// estimates for the forecast. In most cases you won't need this. One example
	// where you might is when you want to predict the outcome of an exam. You may
	// want to set 'closes' to the time right before the exam starts, even though
	// 'resolves' is several weeks later (when the exam results are published). This
	// way your prediction history will only reflect your estimations before you
	// took the exam, which is something you may want (or not, in which case you
	// could simply not set 'closes').
	Closes    *time.Time                                       `json:"closes"`
	Estimates []*CreateForecastCreateForecastEstimatesEstimate `json:"estimates"`
}

type CreateForecastCreateForecastEstimatesEstimate struct {
	Id            string                                                                   `json:"id"`
	Created       time.Time                                                                `json:"created"`
	Reason        string                                                                   `json:"reason"`
	Probabilities []*CreateForecastCreateForecastEstimatesEstimateProbabilitiesProbability `json:"probabilities"`
}

type CreateForecastCreateForecastEstimatesEstimateProbabilitiesProbability struct {
	Id      string                                                                       `json:"id"`
	Value   int                                                                          `json:"value"`
	Outcome CreateForecastCreateForecastEstimatesEstimateProbabilitiesProbabilityOutcome `json:"outcome"`
}

type CreateForecastCreateForecastEstimatesEstimateProbabilitiesProbabilityOutcome struct {
	Id      string `json:"id"`
	Text    string `json:"text"`
	Correct bool   `json:"correct"`
}

type CreateForecastResponse struct {
	CreateForecast CreateForecastCreateForecast `json:"createForecast"`
}

type GetForecastsForecastsForecast struct {
	Id         string     `json:"id"`
	Created    time.Time  `json:"created"`
	Title      string     `json:"title"`
	Resolution Resolution `json:"resolution"`
	// The point in time at which you predict you will be able to resolve whether
	// how the forecast resolved.
	Resolves time.Time `json:"resolves"`
	// The point in time at which you no longer want to update your probability
	// estimates for the forecast. In most cases you won't need this. One example
	// where you might is when you want to predict the outcome of an exam. You may
	// want to set 'closes' to the time right before the exam starts, even though
	// 'resolves' is several weeks later (when the exam results are published). This
	// way your prediction history will only reflect your estimations before you
	// took the exam, which is something you may want (or not, in which case you
	// could simply not set 'closes').
	Closes    *time.Time                                        `json:"closes"`
	Estimates []*GetForecastsForecastsForecastEstimatesEstimate `json:"estimates"`
}

type GetForecastsForecastsForecastEstimatesEstimate struct {
	Id            string                                                                    `json:"id"`
	Created       time.Time                                                                 `json:"created"`
	BrierScore    *float64                                                                  `json:"brierScore"`
	Probabilities []*GetForecastsForecastsForecastEstimatesEstimateProbabilitiesProbability `json:"probabilities"`
}

type GetForecastsForecastsForecastEstimatesEstimateProbabilitiesProbability struct {
	Id      string                                                                        `json:"id"`
	Outcome GetForecastsForecastsForecastEstimatesEstimateProbabilitiesProbabilityOutcome `json:"outcome"`
}

type GetForecastsForecastsForecastEstimatesEstimateProbabilitiesProbabilityOutcome struct {
	Id      string `json:"id"`
	Text    string `json:"text"`
	Correct bool   `json:"correct"`
}

type GetForecastsResponse struct {
	Forecasts []GetForecastsForecastsForecast `json:"forecasts"`
}

type GetMetadataMetadata struct {
	Version string `json:"version"`
}

type GetMetadataResponse struct {
	Metadata GetMetadataMetadata `json:"metadata"`
}

type NewEstimate struct {
	Reason        string           `json:"reason"`
	Probabilities []NewProbability `json:"probabilities"`
	// An optional date in the past when you created this estimate. This can be
	// useful for cases when you wrote it down on a piece of paper or when importing
	// from other software. When creating a new Forecast this value will be for
	// the first Estimate (which will get the same timestamp as the
	// Forecast.Created).
	Created *time.Time `json:"created"`
}

type NewForecast struct {
	Title       string     `json:"title"`
	Description string     `json:"description"`
	Resolves    time.Time  `json:"resolves"`
	Closes      *time.Time `json:"closes"`
	// An optional date in the past when you created this forecast. This can be
	// useful for cases when you wrote it down on a piece of paper or when importing
	// from other software.
	Created *time.Time `json:"created"`
}

type NewOutcome struct {
	Text string `json:"text"`
}

type NewProbability struct {
	Value   int        `json:"value"`
	Outcome NewOutcome `json:"outcome"`
}

type Resolution string

type ResolveForecastResolveForecast struct {
	Id         string     `json:"id"`
	Title      string     `json:"title"`
	Resolution Resolution `json:"resolution"`
	// The point in time at which you predict you will be able to resolve whether
	// how the forecast resolved.
	Resolves time.Time `json:"resolves"`
	// The point in time at which you no longer want to update your probability
	// estimates for the forecast. In most cases you won't need this. One example
	// where you might is when you want to predict the outcome of an exam. You may
	// want to set 'closes' to the time right before the exam starts, even though
	// 'resolves' is several weeks later (when the exam results are published). This
	// way your prediction history will only reflect your estimations before you
	// took the exam, which is something you may want (or not, in which case you
	// could simply not set 'closes').
	Closes    *time.Time                                         `json:"closes"`
	Estimates []*ResolveForecastResolveForecastEstimatesEstimate `json:"estimates"`
}

type ResolveForecastResolveForecastEstimatesEstimate struct {
	Id            string                                                                     `json:"id"`
	Created       time.Time                                                                  `json:"created"`
	Reason        string                                                                     `json:"reason"`
	BrierScore    *float64                                                                   `json:"brierScore"`
	Probabilities []*ResolveForecastResolveForecastEstimatesEstimateProbabilitiesProbability `json:"probabilities"`
}

type ResolveForecastResolveForecastEstimatesEstimateProbabilitiesProbability struct {
	Id      string                                                                         `json:"id"`
	Outcome ResolveForecastResolveForecastEstimatesEstimateProbabilitiesProbabilityOutcome `json:"outcome"`
}

type ResolveForecastResolveForecastEstimatesEstimateProbabilitiesProbabilityOutcome struct {
	Id      string `json:"id"`
	Text    string `json:"text"`
	Correct bool   `json:"correct"`
}

type ResolveForecastResponse struct {
	ResolveForecast *ResolveForecastResolveForecast `json:"resolveForecast"`
}