forms

var ActorKeyForm = forms.Form{
	Name:   "actorKey",
	Fields: SignedDataFields(nil),
}

var AddCodesForm = forms.Form{
	Name:   "addCodes",
	Fields: SignedDataFields(&CodesDataForm),
}

var AddMediatorPublicKeysDataForm = forms.Form{
	Name: "addMediatorPublicKeysData",
	Fields: []forms.Field{
		{
			Name:        "signedKeyData",
			Description: "Signed mediator key data.",
			Validators: []forms.Validator{
				forms.IsStringMap{
					Form: SignedKeyDataForm(&MediatorKeyDataForm, "mediatorSignedKeyData"),
				},
			},
		},
		TimestampField,
	},
}

var AddMediatorPublicKeysForm = forms.Form{
	Name:   "addMediatorPublicKeys",
	Fields: SignedDataFields(&AddMediatorPublicKeysDataForm),
}

var AdminForm = forms.Form{
	Name: "admin",
	Fields: []forms.Field{
		{
			Name: "signing",
			Validators: []forms.Validator{
				forms.IsStringMap{
					Form: &SigningForm,
				},
			},
		},
		{
			Name: "client",
			Validators: []forms.Validator{
				forms.IsStringMap{
					Form: &ClientForm,
				},
			},
		},
	},
}

var AggregatedProviderAppointmentsForm = forms.Form{
	Name: "providerAppointments",
	Fields: []forms.Field{
		{
			Name:        "provider",
			Description: "Signed public provider data.",
			Validators: []forms.Validator{
				forms.IsStringMap{
					Form: &ProviderDataForm,
				},
			},
		},
		{
			Name:        "appointments",
			Description: "Appointments offered by the provider.",
			Validators: []forms.Validator{
				forms.IsList{
					Validators: []forms.Validator{
						forms.IsStringMap{
							Form: &AppointmentDataForm,
						},
					},
				},
			},
		},
	},
}

var AppointmentDataForm = forms.Form{
	Name: "appointmentData",
	Fields: []forms.Field{
		IDField,
		{
			Name:        "duration",
			Description: "Duration of the appointment.",
			Validators: []forms.Validator{
				forms.IsInteger{},
				IsValidAppointmentDuration{},
			},
		},
		{
			Name:        "properties",
			Description: "Properties of the appointment.",
			Validators: []forms.Validator{
				forms.IsStringMap{
					Form: &AppointmentPropertiesForm,
				},
			},
		},
		{
			Name:        "slotData",
			Description: "Appointment slots.",
			Validators: []forms.Validator{
				forms.IsList{
					Validators: []forms.Validator{
						forms.IsStringMap{
							Form: &SlotForm,
						},
					},
				},
			},
		},
		TimestampField,
		{
			Name:        "vaccine",
			Description: "The vaccine type used.",
			Validators: []forms.Validator{
				forms.IsString{},
				IsValidVaccine{},
			},
		},
		PublicKeyField,
	},
}

var AppointmentPropertiesForm = forms.Form{
	Name: "appointmentProperties",
	Fields: []forms.Field{
		{
			Name:        "*",
			Description: "all other properties",
			Validators: []forms.Validator{
				forms.IsString{},
			},
		},
	},
}

var AppointmentsForm = forms.Form{
	Name: "appointments",
	Fields: []forms.Field{
		{
			Name: "keys",
			Validators: []forms.Validator{
				forms.IsList{
					Validators: []forms.Validator{
						forms.IsStringMap{
							Form: &KeyForm,
						},
					},
				},
			},
		},
		{
			Name: "validate",
			Validators: []forms.Validator{
				forms.IsStringMap{
					Form: &ValidateForm,
				},
			},
		},

		{
			Name: "data_ttl_days",
			Validators: []forms.Validator{
				forms.IsOptional{Default: 30},
				forms.IsInteger{
					HasMin: true,
					Min:    1,
					HasMax: true,
					Max:    60,
				},
			},
		},
		{
			Name: "provider_codes_enabled",
			Validators: []forms.Validator{
				forms.IsOptional{Default: true},
				forms.IsBoolean{},
			},
		},
		{
			Name: "user_codes_enabled",
			Validators: []forms.Validator{
				forms.IsOptional{Default: true},
				forms.IsBoolean{},
			},
		},
		{
			Name: "user_codes_reuse_limit",
			Validators: []forms.Validator{
				forms.IsOptional{Default: 0},
				forms.IsInteger{
					HasMin: true,
					Min:    0,
					HasMax: true,
					Max:    1000,
				},
			},
		},
		{
			Name: "provider_codes_reuse_limit",
			Validators: []forms.Validator{
				forms.IsOptional{Default: 0},
				forms.IsInteger{
					HasMin: true,
					Min:    0,
					HasMax: true,
					Max:    1000,
				},
			},
		},
		{
			Name: "response_max_provider",
			Validators: []forms.Validator{
				forms.IsOptional{Default: 10},
				forms.IsInteger{
					HasMin: true,
					Min:    1,
				},
			},
		},
		{
			Name: "response_max_appointment",
			Validators: []forms.Validator{
				forms.IsOptional{Default: 10},
				forms.IsInteger{
					HasMin: true,
					Min:    1,
				},
			},
		},
		{
			Name: "response_min_n_aggregated",
			Validators: []forms.Validator{
				forms.IsOptional{Default: 1000},
				forms.IsInteger{
					HasMin: true,
					Min:    1,
				},
			},
		},
		{
			Name: "response_max_days_aggregated",
			Validators: []forms.Validator{
				forms.IsOptional{Default: 7},
				forms.IsInteger{
					HasMin: true,
					Min:    1,
				},
			},
		},
		{
			Name: "max_tokens_per_user",
			Validators: []forms.Validator{
				forms.IsOptional{Default: 1},
				forms.IsInteger{
					HasMin: true,
					Min:    1,
				},
			},
		},
		{
			Name: "secret",
			Validators: []forms.Validator{
				forms.IsOptional{},
				forms.IsBytes{
					Encoding:  "base64",
					MinLength: 16,
					MaxLength: 64,
				},
			},
		},
		{
			Name: "rest",
			Validators: []forms.Validator{
				forms.IsOptional{},
				forms.IsStringMap{
					Form: &RESTServerSettingsForm,
				},
			},
		},
		{
			Name: "jsonrpc",
			Validators: []forms.Validator{
				forms.IsOptional{},
				forms.IsStringMap{
					Form: &JSONRPCServerSettingsForm,
				},
			},
		},
		{
			Name: "http",
			Validators: []forms.Validator{
				forms.IsStringMap{
					Form: &HTTPServerSettingsForm,
				},
			},
		},
	},
}

var BookAppointmentDataForm = forms.Form{
	Name: "bookAppointmentData",
	Fields: []forms.Field{
		ProviderIDField,
		IDField,
		TimestampField,
		{
			Name:        "signedTokenData",
			Description: "Signed token data of the user.",
			Validators: []forms.Validator{
				forms.IsStringMap{
					Form: &SignedTokenDataForm,
				},
			},
		},
		{
			Name:        "encryptedData",
			Description: "Encrypted data for the provider.",
			Validators: []forms.Validator{
				forms.IsStringMap{
					Form: &ECDHEncryptedDataForm,
				},
			},
		},
	},
}

var BookAppointmentForm = forms.Form{
	Name:   "bookAppointment",
	Fields: SignedDataFields(&BookAppointmentDataForm),
}

var BookAppointmentRVV = []forms.Validator{
	forms.IsStringMap{
		Form: &BookingForm,
	},
}

var BookingForm = forms.Form{
	Name: "booking",
	Fields: []forms.Field{
		IDField,
		PublicKeyField,
		{
			Name:        "token",
			Description: "The token used for this booking.",
			Validators: []forms.Validator{
				ID,
			},
		},
		{
			Name:        "encryptedData",
			Description: "Encrypted data for the provider.",
			Validators: []forms.Validator{
				forms.IsStringMap{
					Form: &ECDHEncryptedDataForm,
				},
			},
		},
	},
}

var CancelAppointmentDataForm = forms.Form{
	Name: "cancelAppointmentData",
	Fields: []forms.Field{
		IDField,
		ProviderIDField,
		TimestampField,
		{
			Name:        "signedTokenData",
			Description: "Signed token data of the user.",
			Validators: []forms.Validator{
				forms.IsStringMap{
					Form: &SignedTokenDataForm,
				},
			},
		},
	},
}

var CancelAppointmentForm = forms.Form{
	Name:   "cancelAppointment",
	Fields: SignedDataFields(&CancelAppointmentDataForm),
}

var CheckProviderDataRVV = []forms.Validator{
	forms.IsStringMap{
		Form: &ConfirmedProviderDataForm,
	},
}

var ClientForm = forms.Form{
	Name: "client",
	Fields: []forms.Field{
		{
			Name: "storage_endpoint",
			Validators: []forms.Validator{
				forms.IsString{},
			},
		},
		{
			Name: "appointments_endpoint",
			Validators: []forms.Validator{
				forms.IsString{},
			},
		},
	},
}

var CodesDataForm = forms.Form{
	Name: "codesData",
	Fields: []forms.Field{
		TimestampField,
		{
			Name:        "actor",
			Description: "The actor for which to store signup codes.",
			Validators: []forms.Validator{
				forms.IsString{},
				forms.IsIn{Choices: []interface{}{"provider", "user"}},
			},
		},
		{
			Name:        "codes",
			Description: "The signup codes to store.",
			Validators: []forms.Validator{
				forms.IsList{
					Validators: []forms.Validator{
						forms.IsBytes{
							Encoding:  "hex",
							MaxLength: 32,
							MinLength: 16,
						},
					},
				},
			},
		},
	},
}

var ConfirmProviderDataForm = forms.Form{
	Name: "confirmProviderData",
	Fields: []forms.Field{
		TimestampField,
		{
			Name:        "confirmedProviderData",
			Description: "Confirmed provider data for review by the provider.",
			Validators: []forms.Validator{
				forms.IsStringMap{
					Form: &ConfirmedProviderDataForm,
				},
			},
		},
		{
			Name:        "publicProviderData",
			Description: "Publicly visible provider data.",
			Validators: []forms.Validator{
				forms.IsOptional{},
				forms.IsStringMap{
					Form: &SignedProviderDataForm,
				},
			},
		},
		{
			Name:        "signedKeyData",
			Description: "Publicly visible signed key data.",
			Validators: []forms.Validator{
				forms.IsStringMap{
					Form: SignedKeyDataForm(&ProviderKeyDataForm, "providerSignedKeyData"),
				},
			},
		},
	},
}

var ConfirmProviderForm = forms.Form{
	Name:   "confirmProvider",
	Fields: SignedDataFields(&ConfirmProviderDataForm),
}

var ConfirmedProviderDataForm = forms.Form{
	Name:   "confirmedProviderData",
	Fields: SignedDataFields(&ECDHEncryptedDataForm),
}

var CorsSettingsForm = forms.Form{
	Name:     "corsSettings",
	ErrorMsg: "invalid data encountered in the CORS settings form",
	Fields: []forms.Field{
		{
			Name: "allowed_hosts",
			Validators: []forms.Validator{
				forms.IsOptional{Default: []string{}},
				forms.IsStringList{
					Validators: []forms.Validator{
						IsValidRegexp{},
					},
				},
			},
		},
		{
			Name: "allowed_headers",
			Validators: []forms.Validator{
				forms.IsOptional{Default: []string{}},
				forms.IsStringList{},
			},
		},
		{
			Name: "allowed_methods",
			Validators: []forms.Validator{
				forms.IsOptional{Default: []string{"GET", "POST", "PATCH", "PUT", "DELETE", "OPTIONS"}},
				forms.IsList{
					Validators: []forms.Validator{
						forms.IsIn{
							Choices: []interface{}{"GET", "POST", "PATCH", "PUT", "DELETE", "OPTIONS"},
						},
					},
				},
				forms.IsStringList{},
			},
		},
	},
}

var DatabaseForm = forms.Form{
	Name: "database",
	Fields: []forms.Field{
		{
			Name: "name",
			Validators: []forms.Validator{
				forms.IsString{},
			},
		},
		{
			Name: "type",
			Validators: []forms.Validator{
				forms.IsString{},
				IsValidDatabaseType{},
			},
		},
		{
			Name: "settings",
			Validators: []forms.Validator{
				forms.IsStringMap{},
				AreValidDatabaseSettings{},
			},
		},
	},
}

var DeleteSettingsForm = forms.Form{
	Name: "deleteSettings",
	Fields: []forms.Field{
		{
			Name:        "id",
			Description: "ID for which to delete settings.",
			Validators: []forms.Validator{
				ID,
			},
		},
	},
}

var DistanceForm = forms.Form{
	Name: "distance",
	Fields: []forms.Field{
		{
			Name:        "from",
			Description: "The origin.",
			Validators: []forms.Validator{
				forms.IsString{},
			},
		},
		{
			Name:        "to",
			Description: "The destination.",
			Validators: []forms.Validator{
				forms.IsString{},
			},
		},
		{
			Name:        "distance",
			Description: "The distance between origin and destination.",
			Validators: []forms.Validator{
				forms.IsFloat{
					HasMin: true,
					Min:    0.0,
					HasMax: true,
					Max:    200.0,
				},
			},
		},
	},
}

var DistancesDataForm = forms.Form{
	Name: "distancesData",
	Fields: []forms.Field{
		TimestampField,
		{
			Name:        "type",
			Description: "The type of distance information to store.",
			Validators: []forms.Validator{
				forms.IsIn{Choices: []interface{}{"zipCode", "zipArea"}},
			},
		},
		{
			Name:        "distances",
			Description: "The distances to store.",
			Validators: []forms.Validator{
				forms.IsList{
					Validators: []forms.Validator{
						forms.IsStringMap{
							Form: &DistanceForm,
						},
					},
				},
			},
		},
	},
}

var ECDHEncryptedDataForm = forms.Form{
	Name: "ecdhEncryptedData",
	Fields: []forms.Field{
		{
			Name:        "iv",
			Description: "IV value associated with the encrypted data.",
			Validators: []forms.Validator{
				forms.IsBytes{
					Encoding:  "base64",
					MinLength: 10,
					MaxLength: 20,
				},
			},
		},
		{
			Name:        "data",
			Description: "The encrypted data.",
			Validators: []forms.Validator{
				forms.IsBytes{
					Encoding:  "base64",
					MinLength: 1,
					MaxLength: 200000,
				},
			},
		},
		PublicKeyField,
	},
}

var ECDSAParamsForm = forms.Form{
	Name: "ecdsaParams",
	Fields: []forms.Field{
		{
			Name: "curve",
			Validators: []forms.Validator{
				forms.IsIn{Choices: []interface{}{"p-256", "P-256"}},
			},
		},
	},
}

var GetAppointmentForm = forms.Form{
	Name: "getAppointment",
	Fields: []forms.Field{
		IDField,
		ProviderIDField,
	},
}

var GetAppointmentRVV = []forms.Validator{
	forms.IsStringMap{
		Form: &SignedAppointmentForm,
	},
}

var GetAppointmentsAggregatedForm = forms.Form{
	Name: "getAppointmentsAggregated",
	Fields: []forms.Field{
		{
			Name:        "zipFrom",
			Description: "The zip code to use as the user location.",
			Validators: []forms.Validator{
				forms.IsString{
					MaxLength: 5,
					MinLength: 5,
				},
			},
		},
		{
			Name:        "zipTo",
			Description: "The zip code to use as the user location.",
			Validators: []forms.Validator{
				forms.IsString{
					MaxLength: 5,
					MinLength: 5,
				},
			},
		},
		{
			Name:        "date",
			Description: "The earliest date of appointments to return.",
			Validators: []forms.Validator{
				forms.IsTime{Format: "rfc3339-date"},
			},
		},
	},
}

var GetAppointmentsAggregatedRVV = []forms.Validator{
	forms.IsList{
		Validators: []forms.Validator{
			forms.IsStringMap{
				Form: &AggregatedProviderAppointmentsForm,
			},
		},
	},
}

var GetAppointmentsByZipCodeForm = forms.Form{
	Name: "getAppointmentsByZipCode",
	Fields: []forms.Field{
		{
			Name:        "radius",
			Description: "The radius around the given zip code for which to show appointments.",
			Validators: []forms.Validator{
				forms.IsOptional{Default: 50},
				forms.IsInteger{
					HasMin:  true,
					HasMax:  true,
					Min:     5,
					Max:     80,
					Convert: true,
				},
			},
		},
		{
			Name:        "zipCode",
			Description: "The zip code to use as the user location.",
			Validators: []forms.Validator{
				forms.IsString{
					MaxLength: 5,
					MinLength: 5,
				},
			},
		},
		{
			Name:        "from",
			Description: "The earliest date of appointments to return.",
			Validators: []forms.Validator{
				forms.IsTime{Format: "rfc3339"},
			},
		},
		{
			Name:        "to",
			Description: "The latest date of appointments to return.",
			Validators: []forms.Validator{
				forms.IsTime{Format: "rfc3339"},
				IsValidAnonTimeWindow{},
			},
		},
	},
}

var GetAppointmentsByZipCodeRVV = []forms.Validator{
	forms.IsList{
		Validators: []forms.Validator{
			forms.IsStringMap{
				Form: &ProviderAppointmentsForm,
			},
		},
	},
}

var GetBookedAppointmentsDataForm = forms.Form{
	Name: "getBookedAppointmentsData",
	Fields: []forms.Field{
		TimestampField,
	},
}

var GetBookedAppointmentsForm = forms.Form{
	Name:   "getBookedAppointments",
	Fields: SignedDataFields(&GetBookedAppointmentsDataForm),
}

var GetConfigurablesForm = forms.Form{
	Name:   "getConfigurables",
	Fields: []forms.Field{},
}

var GetConfigurablesRVV = []forms.Validator{
	forms.IsStringMap{
		Form: &ValidateForm,
	},
}

var GetKeysForm = forms.Form{
	Name:   "getKeys",
	Fields: []forms.Field{},
}

var GetKeysRVV = []forms.Validator{
	forms.IsStringMap{
		Form: &KeysForm,
	},
}

var GetProviderAppointmentsByPropertyDataForm = forms.Form{
	Name: "getProviderAppointmentsByPropertyData",
	Fields: []forms.Field{
		TimestampField,
		{
			Name:        "key",
			Description: "The earliest date of appointments to return.",
			Validators: []forms.Validator{
				forms.IsString{},
			},
		},
		{
			Name:        "value",
			Description: "The latest date of appointments to return.",
			Validators: []forms.Validator{
				forms.IsString{},
			},
		},
	},
}

var GetProviderAppointmentsByPropertyForm = forms.Form{
	Name:   "getProviderAppointmentsByProperty",
	Fields: SignedDataFields(&GetProviderAppointmentsByPropertyDataForm),
}

var GetProviderAppointmentsByPropertyRVV = []forms.Validator{
	forms.IsStringMap{
		Form: &ProviderAppointmentsForm,
	},
}

var GetProviderAppointmentsDataForm = forms.Form{
	Name: "getProviderAppointmentsData",
	Fields: []forms.Field{
		TimestampField,
		{
			Name:        "from",
			Description: "The earliest date of appointments to return.",
			Validators: []forms.Validator{
				forms.IsTime{Format: "rfc3339"},
			},
		},
		{
			Name:        "to",
			Description: "The latest date of appointments to return.",
			Validators: []forms.Validator{
				forms.IsTime{Format: "rfc3339"},
				IsValidProviderTimeWindow{},
			},
		},
		{
			Name:        "updatedSince",
			Description: "The minimum 'updatedAt' value of appointments to return.",
			Validators: []forms.Validator{
				forms.IsOptional{},
				forms.IsTime{Format: "rfc3339"},
			},
		},
	},
}

var GetProviderAppointmentsForm = forms.Form{
	Name:   "getProviderAppointments",
	Fields: SignedDataFields(&GetProviderAppointmentsDataForm),
}

var GetProviderAppointmentsRVV = []forms.Validator{
	forms.IsStringMap{
		Form: &ProviderAppointmentsForm,
	},
}

var GetProviderDataDataForm = forms.Form{
	Name: "getProviderDataData",
	Fields: []forms.Field{
		TimestampField,
		ProviderIDField,
	},
}

var GetProviderDataForm = forms.Form{
	Name:   "getProviderData",
	Fields: SignedDataFields(&GetProviderDataDataForm),
}

var GetProviderDataRVV = []forms.Validator{
	forms.IsList{
		Validators: GetSingleProviderDataRVV,
	},
}

var GetProvidersByZipCodeForm = forms.Form{
	Name: "getProvidersByZipCode",
	Fields: []forms.Field{
		{
			Name:        "zipFrom",
			Description: "provider zip code min",
			Validators: []forms.Validator{
				forms.IsString{
					MaxLength: 5,
					MinLength: 5,
				},
			},
		},
		{
			Name:        "zipTo",
			Description: "provider zip code max",
			Validators: []forms.Validator{
				forms.IsString{
					MaxLength: 5,
					MinLength: 5,
				},
			},
		},
	},
}

var GetProvidersByZipCodeRVV = []forms.Validator{
	forms.IsList{
		Validators: []forms.Validator{
			forms.IsStringMap{
				Form: &SignedProviderDataForm,
			},
		},
	},
}

var GetProvidersDataDataForm = forms.Form{
	Name: "getProvidersDataData",
	Fields: []forms.Field{
		TimestampField,
		{
			Name:        "limit",
			Description: "Number of entries to return at most.",
			Validators: []forms.Validator{
				forms.IsOptional{Default: 1000},
				forms.IsInteger{
					HasMin: true,
					HasMax: true,
					Min:    1,
					Max:    10000,
				},
			},
		},
	},
}

var GetProvidersDataForm = forms.Form{
	Name:   "getProvidersData",
	Fields: SignedDataFields(&GetProvidersDataDataForm),
}

var GetSettingsForm = forms.Form{
	Name: "getSettings",
	Fields: []forms.Field{
		{
			Name:        "id",
			Description: "ID for which to retrieve settings.",
			Validators: []forms.Validator{
				ID,
			},
		},
	},
}

var GetSingleProviderDataRVV = []forms.Validator{
	forms.IsStringMap{
		Form: &forms.Form{
			Name: "getSingleProviderData",
			Fields: []forms.Field{
				{
					Name:        "unverifiedData",
					Description: "the unverified provider data",
					Validators: []forms.Validator{
						forms.IsStringMap{
							Form: &RawProviderDataForm,
						},
					},
				},
				{
					Name:        "verifiedData",
					Description: "the verified provider data",
					Validators: []forms.Validator{
						forms.IsStringMap{
							Form: &RawProviderDataForm,
						},
					},
				},
			},
		},
	},
}

var GetStatsForm = forms.Form{
	Name: "getStats",
	Fields: []forms.Field{
		{
			Name:        "id",
			Description: "ID of the statistics to return.",
			Validators: []forms.Validator{
				forms.IsIn{Choices: []interface{}{"queues", "tokens"}},
			},
		},
		{
			Name:        "type",
			Description: "Time window type of the statistics to return.",
			Validators: []forms.Validator{
				forms.IsIn{Choices: []interface{}{"minute", "hour", "day", "quarterHour", "week", "month"}},
			},
		},
		{
			Name:        "name",
			Description: "Optional name of the statistics to return.",
			Validators: []forms.Validator{
				forms.IsOptional{Default: ""},
				forms.MatchesRegex{Regexp: regexp.MustCompile(`^[\w\d\-]{0,50}$`)},
			},
		},
		{
			Name:        "metric",
			Description: "Optional sub-metric to return.",
			Validators: []forms.Validator{
				forms.IsOptional{Default: ""},
				forms.MatchesRegex{Regexp: regexp.MustCompile(`^[\w\d\-]{0,50}$`)},
			},
		},
		{
			Name:        "filter",
			Description: "Optional additional filter criteria to apply.",
			Validators: []forms.Validator{
				forms.IsOptional{},
				forms.IsStringMap{},
			},
		},
		{
			Name:        "from",
			Description: "Earliest date for which to return statistics. Only applicable if 'n' is not set.",
			Validators: []forms.Validator{
				forms.IsOptional{},
				forms.IsTime{Format: "rfc3339", ToUTC: true},
			},
		},
		{
			Name:        "to",
			Description: "Latest date for which to return statistics. Only applicable if 'n' is not set.",
			Validators: []forms.Validator{
				forms.IsOptional{},
				forms.IsTime{Format: "rfc3339", ToUTC: true},
			},
		},
		{
			Name:        "n",
			Description: "Maximum number of statistics values to return.",
			Validators: []forms.Validator{
				forms.IsOptional{},
				forms.IsInteger{HasMin: true, Min: 1, HasMax: true, Max: 500, Convert: true},
			},
		},
	},
	Transforms: []forms.Transform{},
	Validator:  UsageValidator,
}

var GetStatsRVV = []forms.Validator{
	forms.IsList{
		Validators: []forms.Validator{
			forms.IsStringMap{
				Form: &StatsValueForm,
			},
		},
	},
}

var GetTokenForm = forms.Form{
	Name: "getToken",
	Fields: []forms.Field{
		{
			Name:        "hash",
			Description: "The user-generated hash to store with the token.",
			Validators: []forms.Validator{
				ID,
			},
		},
		{
			Name:        "code",
			Description: "The optional signup code to use.",
			Validators: []forms.Validator{
				forms.IsOptional{},
				forms.IsBytes{
					Encoding:  "hex",
					MinLength: 16,
					MaxLength: 32,
				},
			},
		},
		PublicKeyField,
	},
}

var GetTokenRVV = []forms.Validator{
	forms.IsStringMap{
		Form: &SignedTokenDataForm,
	},
}

var HTTPServerSettingsForm = forms.Form{
	Name: "httpServerSettings",
	Fields: []forms.Field{
		{
			Name: "bind_address",
			Validators: []forms.Validator{
				forms.IsString{},
			},
		},
		{
			Name: "tls",
			Validators: []forms.Validator{
				forms.IsOptional{},
				forms.IsStringMap{
					Form: &tls.TLSSettingsForm,
				},
			},
		},
	},
}

var ID = forms.IsBytes{
	Encoding:  "base64",
	MinLength: 32,
	MaxLength: 32,
}

var IDField = forms.Field{
	Name:        "id",
	Global:      true,
	Description: "An ID.",
	Validators: []forms.Validator{
		ID,
	},
}

var IsAcknowledgeRVV = []forms.Validator{
	forms.IsIn{Choices: []interface{}{"ok"}},
}

var IsBooleanRVV = []forms.Validator{
	forms.IsBoolean{},
}

var IsStringRVV = []forms.Validator{
	forms.IsString{},
}

var JSONRPCClientSettingsForm = forms.Form{
	Fields: []forms.Field{
		{
			Name: "endpoint",
			Validators: []forms.Validator{
				forms.IsString{},
			},
		},
		{
			Name: "local",
			Validators: []forms.Validator{
				forms.IsOptional{Default: true},
				forms.IsBoolean{},
			},
		},
		{
			Name: "tls",
			Validators: []forms.Validator{
				forms.IsOptional{},
				forms.IsStringMap{
					Form: &tls.TLSSettingsForm,
				},
			},
		},
	},
}

var JSONRPCServerSettingsForm = forms.Form{
	Fields: []forms.Field{
		{
			Name: "cors",
			Validators: []forms.Validator{
				forms.IsOptional{},
				forms.IsStringMap{
					Form: &CorsSettingsForm,
				},
			},
		},
	},
}

var KeyChainForm = forms.Form{
	Name: "keyChain",
	Fields: []forms.Field{
		{
			Name:        "provider",
			Description: "Public provider key data.",
			Validators: []forms.Validator{
				forms.IsStringMap{
					Form: &ActorKeyForm,
				},
			},
		},
		{
			Name:        "mediator",
			Description: "Public mediator key data.",
			Validators: []forms.Validator{
				forms.IsStringMap{
					Form: &ActorKeyForm,
				},
			},
		},
	},
}

var KeyForm = forms.Form{
	Name: "key",
	Fields: []forms.Field{
		{
			Name: "type",
			Validators: []forms.Validator{
				forms.IsIn{Choices: []interface{}{"ecdsa", "ecdh"}},
			},
		},
		{
			Name: "format",
			Validators: []forms.Validator{
				forms.IsIn{Choices: []interface{}{"spki-pkcs8"}},
			},
		},
		{
			Name: "name",
			Validators: []forms.Validator{
				forms.IsString{},
			},
		},
		{
			Name: "purposes",
			Validators: []forms.Validator{
				forms.IsList{
					Validators: []forms.Validator{
						forms.IsString{},
						forms.IsIn{Choices: []interface{}{"sign", "verify", "deriveKey", "encrypt", "decrypt"}},
					},
				},
			},
		},
		{
			Name: "publicKey",
			Validators: []forms.Validator{
				forms.IsBytes{
					Encoding: "base64",
				},
			},
		},
		{
			Name: "privateKey",
			Validators: []forms.Validator{
				forms.IsOptional{},
				forms.IsBytes{
					Encoding: "base64",
				},
			},
		},
		{
			Name: "params",
			Validators: []forms.Validator{
				forms.Switch{
					Key: "type",
					Cases: map[string][]forms.Validator{
						"ecdsa": []forms.Validator{
							forms.IsStringMap{
								Form: &ECDSAParamsForm,
							},
						},
					},
				},
			},
		},
	},
}

var KeysForm = forms.Form{
	Name: "keys",
	Fields: []forms.Field{
		{
			Name:        "providerData",
			Description: "Public provider data key.",
			Validators:  PublicKeyValidators,
		},
		{
			Name:        "rootKey",
			Description: "Public root key.",
			Validators:  PublicKeyValidators,
		},
		{
			Name:        "tokenKey",
			Description: "Public token key.",
			Validators:  PublicKeyValidators,
		},
	},
}

var MailForm = forms.Form{
	Name: "mail",
	Fields: []forms.Field{
		{
			Name: "smtp_host",
			Validators: []forms.Validator{
				forms.IsString{},
			},
		},
		{
			Name: "smtp_port",
			Validators: []forms.Validator{
				forms.IsInteger{},
			},
		},
		{
			Name: "smtp_user",
			Validators: []forms.Validator{
				forms.IsString{},
			},
		},
		{
			Name: "smtp_password",
			Validators: []forms.Validator{
				forms.IsString{},
			},
		},
		{
			Name: "sender",
			Validators: []forms.Validator{
				forms.IsString{},
			},
		},
		{
			Name: "mail_subject",
			Validators: []forms.Validator{
				forms.IsString{},
			},
		},
		{
			Name: "mail_template",
			Validators: []forms.Validator{
				forms.IsString{},
			},
		},
		{
			Name: "mail_delay",
			Validators: []forms.Validator{
				forms.IsInteger{},
			},
		},
	},
}

var MediatorKeyDataForm = forms.Form{
	Name: "mediatorKeyData",
	Fields: []forms.Field{
		{
			Name:        "signing",
			Description: "Public signing key of the mediator.",
			Validators:  PublicKeyValidators,
		},
		{
			Name:        "encryption",
			Description: "Public encryption key of the mediator.",
			Validators:  PublicKeyValidators,
		},
	},
}

var MeterForm = forms.Form{
	Name: "meter",
	Fields: []forms.Field{
		{
			Name: "name",
			Validators: []forms.Validator{
				forms.IsString{},
			},
		},
		{
			Name: "type",
			Validators: []forms.Validator{
				forms.IsString{},
				IsValidMeterType{},
			},
		},
		{
			Name: "settings",
			Validators: []forms.Validator{
				forms.IsStringMap{},
				AreValidMeterSettings{},
			},
		},
	},
}

var MetricsForm = forms.Form{
	Name: "metrics",
	Fields: []forms.Field{
		{
			Name: "bind_address",
			Validators: []forms.Validator{
				forms.IsString{},
			},
		},
	},
}

var OptionalIDField = forms.Field{
	Name:        "id",
	Global:      true,
	Description: "An ID.",
	Validators: []forms.Validator{
		forms.IsOptional{},
		ID,
	},
}

var PriorityTokenForm = forms.Form{
	Name: "priorityToken",
	Fields: []forms.Field{
		{
			Name: "n",
			Validators: []forms.Validator{
				forms.IsInteger{HasMin: true, Min: 0},
			},
		},
	},
}

var ProviderAppointmentsForm = forms.Form{
	Name: "providerAppointments",
	Fields: []forms.Field{
		{
			Name:        "provider",
			Description: "Signed public provider data.",
			Validators: []forms.Validator{
				forms.IsStringMap{
					Form: &SignedProviderDataForm,
				},
			},
		},
		{
			Name:        "appointments",
			Description: "Appointments offered by the provider.",
			Validators: []forms.Validator{
				forms.IsList{
					Validators: []forms.Validator{
						forms.IsStringMap{
							Form: &SignedAppointmentForm,
						},
					},
				},
			},
		},
	},
}

var ProviderDataForm = forms.Form{
	Name: "providerData",
	Fields: []forms.Field{
		{
			Name:        "name",
			Description: "Name of the provider.",
			Validators: []forms.Validator{
				forms.IsString{},
			},
		},
		{
			Name:        "street",
			Description: "Street address of the provider.",
			Validators: []forms.Validator{
				forms.IsString{},
			},
		},
		{
			Name:        "city",
			Description: "City of the provider.",
			Validators: []forms.Validator{
				forms.IsString{},
			},
		},
		{
			Name:        "zipCode",
			Description: "Zip code of the provider.",
			Validators: []forms.Validator{
				forms.IsString{},
			},
		},
		{
			Name:        "description",
			Description: "Additional information about the provider.",
			Validators: []forms.Validator{
				forms.IsString{},
			},
		},
		{
			Name:        "accessible",
			Description: "Is the location accessible.",
			Validators: []forms.Validator{
				forms.IsBoolean{},
			},
		},
	},
}

var ProviderIDField = forms.Field{
	Name:        "providerID",
	Global:      true,
	Description: "A provider ID.",
	Validators: []forms.Validator{
		ID,
	},
}

var ProviderKeyDataForm = forms.Form{
	Name: "providerKeyData",
	Fields: []forms.Field{
		{
			Name:        "signing",
			Description: "Public signing key of the provider.",
			Validators:  PublicKeyValidators,
		},
		{
			Name:        "encryption",
			Description: "Public encryption key of the provider.",
			Validators:  PublicKeyValidators,
		},
		{
			Name:        "queueData",
			Description: "Public information of the provider.",
			Validators: []forms.Validator{
				forms.IsStringMap{
					Form: &ProviderQueueDataForm,
				},
			},
		},
	},
}

var ProviderQueueDataForm = forms.Form{
	Name: "providerQueueData",
	Fields: []forms.Field{
		{
			Name:        "zipCode",
			Description: "Zip code of the provider.",
			Validators: []forms.Validator{
				forms.IsString{
					MaxLength: 5,
					MinLength: 5,
				},
			},
		},
		{
			Name:        "accessible",
			Description: "Whether the provider location is accessible.",
			Validators: []forms.Validator{
				forms.IsOptional{Default: false},
				forms.IsBoolean{},
			},
		},
	},
}

var PublicKeyField = forms.Field{
	Name:        "publicKey",
	Global:      true,
	Description: "An ECDSA or ECDH public key.",
	Validators:  PublicKeyValidators,
}

var PublicKeyValidators = []forms.Validator{
	forms.IsBytes{
		Encoding:  "base64",
		MaxLength: 128,
		MinLength: 64,
	},
}

var PublishAppointmentsDataForm = forms.Form{
	Name: "publishAppointmentsData",
	Fields: []forms.Field{
		TimestampField,
		{
			Name:        "appointments",
			Description: "The appointments to publish.",
			Validators: []forms.Validator{
				forms.IsList{
					Validators: []forms.Validator{
						forms.IsStringMap{
							Form: &SignedAppointmentForm,
						},
					},
				},
			},
		},
	},
}

var PublishAppointmentsForm = forms.Form{
	Name:   "publishAppointments",
	Fields: SignedDataFields(&PublishAppointmentsDataForm),
}

var RESTServerSettingsForm = forms.Form{
	Name: "restServerSettings",
	Fields: []forms.Field{
		{
			Name: "cors",
			Validators: []forms.Validator{
				forms.IsOptional{},
				forms.IsStringMap{
					Form: &CorsSettingsForm,
				},
			},
		},
	},
}

var RawProviderDataForm = forms.Form{
	Name: "rawProviderData",
	Fields: []forms.Field{
		IDField,
		{
			Name:        "encryptedData",
			Description: "Encrypted data submitted by the provider.",
			Validators: []forms.Validator{
				forms.IsStringMap{
					Form: &ECDHEncryptedDataForm,
				},
			},
		},
	},
}

var ResetDBDataForm = forms.Form{
	Name: "resetDBData",
	Fields: []forms.Field{
		TimestampField,
	},
}

var ResetDBForm = forms.Form{
	Name:   "resetDB",
	Fields: SignedDataFields(&ResetDBDataForm),
}

var SettingsForm = forms.Form{
	Name: "settings",
	Fields: []forms.Field{
		{
			Name: "test",
			Validators: []forms.Validator{
				forms.IsOptional{Default: false},
				forms.IsBoolean{},
			},
		},
		{
			Name: "admin",
			Validators: []forms.Validator{
				forms.IsOptional{},
				forms.IsStringMap{
					Form: &AdminForm,
				},
			},
		},
		{
			Name: "name",
			Validators: []forms.Validator{
				forms.IsString{},
			},
		},
		{
			Name: "database",
			Validators: []forms.Validator{
				forms.IsOptional{},
				forms.IsStringMap{
					Form: &DatabaseForm,
				},
			},
		},
		{
			Name: "meter",
			Validators: []forms.Validator{
				forms.IsOptional{},
				forms.IsStringMap{
					Form: &MeterForm,
				},
			},
		},
		{
			Name: "storage",
			Validators: []forms.Validator{
				forms.IsOptional{},
				forms.IsStringMap{
					Form: &StorageForm,
				},
			},
		},
		{
			Name: "appointments",
			Validators: []forms.Validator{
				forms.IsOptional{},
				forms.IsStringMap{
					Form: &AppointmentsForm,
				},
			},
		},
		{
			Name: "metrics",
			Validators: []forms.Validator{
				forms.IsOptional{},
				forms.IsStringMap{
					Form: &MetricsForm,
				},
			},
		},
	},
}

var SignatureField = forms.Field{
	Name:        "signature",
	Global:      true,
	Description: "An ECDSA signature.",
	Validators:  PublicKeyValidators,
}

var SignedAppointmentForm = forms.Form{
	Name: "signedAppointment",
	Fields: append(SignedDataFields(&AppointmentDataForm), []forms.Field{
		{
			Name:        "updatedAt",
			Description: "Time the appointment has last been updated.",
			Validators: []forms.Validator{
				forms.IsOptional{},
				forms.IsTime{
					Format: "rfc3339",
				},
			},
		},
		{
			Name:        "bookedSlots",
			Description: "Booked slots associated with the appointment (visible to users).",
			Validators: []forms.Validator{
				forms.IsOptional{},
				forms.IsList{
					Validators: []forms.Validator{
						forms.IsStringMap{
							Form: &SlotForm,
						},
					},
				},
			},
		},
		{
			Name:        "bookings",
			Description: "Bookings associated with the appointment (only visible to providers).",
			Validators: []forms.Validator{
				forms.IsOptional{},
				forms.IsList{
					Validators: []forms.Validator{
						forms.IsStringMap{
							Form: &BookingForm,
						},
					},
				},
			},
		},
	}...),
}

var SignedDataFields = func(form *forms.Form) []forms.Field {
	return []forms.Field{
		forms.Field{
			Name:        "data",
			Global:      true,
			Description: "A JSON data field.",
			Validators: []forms.Validator{
				forms.IsString{},
				JSON{
					Key: "json",
				},
				forms.IsStringMap{
					Form: form,
				},
			},
		},
		SignatureField,
		PublicKeyField,
	}
}

var SignedKeyDataForm = func(form *forms.Form, name string) *forms.Form {
	return &forms.Form{
		Name:   name,
		Fields: SignedDataFields(form),
	}
}

var SignedProviderDataForm = forms.Form{
	Name:   "signedProviderData",
	Fields: append(SignedDataFields(&ProviderDataForm), OptionalIDField),
}

var SignedTimestampForm = forms.Form{
	Name:   "signedTimestamp",
	Fields: SignedDataFields(&TimestampForm),
}

var SignedTokenDataForm = forms.Form{
	Name:   "signedTokenData",
	Fields: SignedDataFields(&TokenDataForm),
}

var SigningForm = forms.Form{
	Name: "signing",
	Fields: []forms.Field{
		{
			Name: "keys",
			Validators: []forms.Validator{
				forms.IsList{
					Validators: []forms.Validator{
						forms.IsStringMap{
							Form: &KeyForm,
						},
					},
				},
			},
		},
	},
}

var SlotForm = forms.Form{
	Name: "slot",
	Fields: []forms.Field{
		IDField,
	},
}

var StatsValueForm = forms.Form{
	Name: "statsValue",
	Fields: []forms.Field{
		{
			Name:        "name",
			Description: "Name of the statistics value.",
			Validators: []forms.Validator{
				forms.IsString{},
			},
		},
		{
			Name:        "from",
			Description: "Beginning of the time window of the statistics value.",
			Validators: []forms.Validator{
				forms.IsTime{
					Format: "rfc3339",
				},
			},
		},
		{
			Name:        "to",
			Description: "End of the time window of the statistics value.",
			Validators: []forms.Validator{
				forms.IsTime{
					Format: "rfc3339",
				},
			},
		},
		{
			Name:        "data",
			Description: "Data associate with the statistics value.",
			Validators: []forms.Validator{
				forms.IsOptional{},
				forms.IsStringMap{},
			},
		},
		{
			Name:        "value",
			Description: "The statistics value itself.",
			Validators: []forms.Validator{
				forms.IsInteger{},
			},
		},
	},
}

var StorageForm = forms.Form{
	Name: "storage",
	Fields: []forms.Field{
		{
			Name: "keys",
			Validators: []forms.Validator{
				forms.IsList{
					Validators: []forms.Validator{
						forms.IsStringMap{
							Form: &KeyForm,
						},
					},
				},
			},
		},
		{
			Name: "rest",
			Validators: []forms.Validator{
				forms.IsOptional{},
				forms.IsStringMap{
					Form: &RESTServerSettingsForm,
				},
			},
		},
		{
			Name: "jsonrpc",
			Validators: []forms.Validator{
				forms.IsOptional{},
				forms.IsStringMap{
					Form: &JSONRPCServerSettingsForm,
				},
			},
		},
		{
			Name: "http",
			Validators: []forms.Validator{
				forms.IsStringMap{
					Form: &HTTPServerSettingsForm,
				},
			},
		},

		{
			Name: "settings_ttl_days",
			Validators: []forms.Validator{
				forms.IsInteger{
					HasMin: true,
					Min:    1,
					HasMax: true,
					Max:    60,
				},
			},
		},
	},
}

var StoreProviderDataDataForm = forms.Form{
	Name: "storeProviderDataData",
	Fields: []forms.Field{
		TimestampField,
		{
			Name:        "code",
			Description: "Optional signup code.",
			Validators: []forms.Validator{
				forms.IsOptional{},
				forms.IsBytes{
					Encoding:  "hex",
					MinLength: 16,
					MaxLength: 32,
				},
			},
		},
		{
			Name:        "encryptedData",
			Description: "Encrypted data for mediators to review.",
			Validators: []forms.Validator{
				forms.IsStringMap{
					Form: &ECDHEncryptedDataForm,
				},
			},
		},
	},
}

var StoreProviderDataForm = forms.Form{
	Name:   "storeProviderData",
	Fields: SignedDataFields(&StoreProviderDataDataForm),
}

var StoreSettingsForm = forms.Form{
	Name: "storeSettings",
	Fields: []forms.Field{
		{
			Name:        "id",
			Description: "ID under which to store settings.",
			Validators: []forms.Validator{
				ID,
			},
		},
		{
			Name:        "data",
			Description: "Settings to store under the given ID.",
			Validators: []forms.Validator{
				IsAnything{},
			},
		},
	},
}

var TimestampField = forms.Field{
	Name:        "timestamp",
	Global:      true,
	Description: "A timestamp.",
	Validators: []forms.Validator{
		forms.IsTime{
			Format: "rfc3339",
		},
	},
}

var TimestampForm = forms.Form{
	Name: "timestamp",
	Fields: []forms.Field{
		TimestampField,
	},
}

var TokenDataForm = forms.Form{
	Name: "tokenData",
	Fields: []forms.Field{
		{
			Name:        "hash",
			Description: "The user-generated hash belonging to the token.",
			Validators: []forms.Validator{
				ID,
			},
		},
		{
			Name:        "token",
			Description: "The server-generated token.",
			Validators: []forms.Validator{
				ID,
			},
		},
		PublicKeyField,
		{
			Name:        "data",
			Description: "Optional data associated with the token.",
			Validators: []forms.Validator{
				forms.IsOptional{},
				forms.IsString{},
				JSON{
					Key: "json",
				},
				forms.IsStringMap{
					Form: &PriorityTokenForm,
				},
			},
		},
	},
}

var UploadDistancesForm = forms.Form{
	Name:   "uploadDistances",
	Fields: SignedDataFields(&DistancesDataForm),
}

var ValidateForm = forms.Form{
	Name: "validate",
	Fields: []forms.Field{
		{
			Name: "appointment_duration_max",
			Validators: []forms.Validator{
				forms.IsInteger{
					HasMin: true,
					Min:    1,
				},
			},
		},
		{
			Name: "appointment_duration_min",
			Validators: []forms.Validator{
				forms.IsInteger{
					HasMin: true,
					Min:    1,
				},
			},
		},
		{
			Name: "anon_max_time_window",
			Validators: []forms.Validator{
				forms.IsInteger{
					HasMin: true,
					Min:    1,
				},
			},
		},
		{
			Name: "anon_aggregated_max_time_window",
			Validators: []forms.Validator{
				forms.IsInteger{
					HasMin: true,
					Min:    1,
				},
			},
		},
		{
			Name: "provider_max_time_window",
			Validators: []forms.Validator{
				forms.IsInteger{
					HasMin: true,
					Min:    1,
				},
			},
		},
		{
			Name: "vaccines",
			Validators: []forms.Validator{
				forms.IsStringList{},
			},
		},
	},
}

var ValidateUserDataForm = forms.Form{
	Name: "validateUserData",
	Fields: []forms.Field{
		TimestampField,
		{
			Name:        "signedTokenData",
			Description: "Signed token data of the user.",
			Validators: []forms.Validator{
				forms.IsStringMap{
					Form: &SignedTokenDataForm,
				},
			},
		},
	},
}

var ValidateUserForm = forms.Form{
	Name:   "validateUser",
	Fields: SignedDataFields(&ValidateUserDataForm),
}