api

type Certificate struct {
	// Certificate The PEM encoded certificate with newlines replaced by `\n`
	Certificate string `json:"certificate"`
}

type ChargeStationAuth struct {
	// Base64SHA256Password The base64 encoded, SHA-256 hash of the charge station password
	Base64SHA256Password *string `json:"base64SHA256Password,omitempty"`

	// InvalidUsernameAllowed If set to true then an invalid username will not prevent the charge station connecting
	InvalidUsernameAllowed *bool `json:"invalidUsernameAllowed,omitempty"`

	// SecurityProfile The security profile to use for the charge station: * `0` - unsecured transport with basic auth * `1` - TLS with basic auth * `2` - TLS with client certificate
	SecurityProfile int `json:"securityProfile"`
}

type ChargeStationInstallCertificates struct {
	Certificates []struct {
		// Certificate The PEM encoded certificate with newlines replaced by `\n`
		Certificate string `json:"certificate"`

		// Status The status, defaults to Pending
		Status *ChargeStationInstallCertificatesCertificatesStatus `json:"status,omitempty"`
		Type   ChargeStationInstallCertificatesCertificatesType    `json:"type"`
	} `json:"certificates"`
}

type ChargeStationInstallCertificatesCertificatesStatus string

type ChargeStationInstallCertificatesCertificatesType string

type ChargeStationSettings map[string]string

type ChargeStationTrigger struct {
	Trigger ChargeStationTriggerTrigger `json:"trigger"`
}

type ChargeStationTriggerTrigger string

type ChiServerOptions struct {
	BaseURL          string
	BaseRouter       chi.Router
	Middlewares      []MiddlewareFunc
	ErrorHandlerFunc func(w http.ResponseWriter, r *http.Request, err error)
}

type Connector struct {
	Format      ConnectorFormat    `json:"format"`
	Id          string             `json:"id"`
	MaxAmperage int32              `json:"max_amperage"`
	MaxVoltage  int32              `json:"max_voltage"`
	PowerType   ConnectorPowerType `json:"power_type"`
	Standard    ConnectorStandard  `json:"standard"`
}

type ConnectorFormat string

type ConnectorPowerType string

type ConnectorStandard string

type ErrResponse struct {
	Err            error `json:"-"` // low-level runtime error
	HTTPStatusCode int   `json:"-"` // http response status code

	StatusText string `json:"status"`          // user-level status message
	AppCode    int64  `json:"code,omitempty"`  // application-specific error code
	ErrorText  string `json:"error,omitempty"` // application-level error message, for debugging
}

type Evse struct {
	Connectors []Connector `json:"connectors"`
	EvseId     *string     `json:"evse_id"`

	// Uid Uniquely identifies the EVSE within the CPOs platform (and
	// suboperator platforms).
	Uid string `json:"uid"`
}

type GeoLocation struct {
	Latitude  string `json:"latitude"`
	Longitude string `json:"longitude"`
}

type InstallChargeStationCertificatesJSONRequestBody = ChargeStationInstallCertificates

type InvalidParamFormatError struct {
	ParamName string
	Err       error
}

type ListTokensParams struct {
	Offset *int `form:"offset,omitempty" json:"offset,omitempty"`
	Limit  *int `form:"limit,omitempty" json:"limit,omitempty"`
}

type Location struct {
	Address     string               `json:"address"`
	City        string               `json:"city"`
	Coordinates GeoLocation          `json:"coordinates"`
	Country     string               `json:"country"`
	CountryCode string               `json:"country_code"`
	Evses       *[]Evse              `json:"evses"`
	Name        *string              `json:"name"`
	ParkingType *LocationParkingType `json:"parking_type"`
	PartyId     string               `json:"party_id"`
	PostalCode  *string              `json:"postal_code"`
}

type LocationParkingType string

type MiddlewareFunc func(http.Handler) http.Handler

type ReconfigureChargeStationJSONRequestBody = ChargeStationSettings

type RegisterChargeStationJSONRequestBody = ChargeStationAuth

type RegisterLocationJSONRequestBody = Location

type RegisterPartyJSONRequestBody = Registration

type Registration struct {
	// Status The status of the registration request. If the request is marked as `REGISTERED` then the token will be allowed to
	// be used to access all endpoints avoiding the need for the OCPI registration process. If the request is marked as
	// `PENDING` then the token will only be allowed to access the `/ocpi/versions`, `/ocpi/2.2` and `/ocpi/2.2/credentials`
	// endpoints.
	Status *RegistrationStatus `json:"status,omitempty"`

	// Token The token to use for communicating with the eMSP (CREDENTIALS_TOKEN_A).
	Token string `json:"token"`

	// Url The URL of the eMSP versions endpoint. If provided the CSMS will act as the sender of the versions request.
	Url *string `json:"url,omitempty"`
}

type RegistrationStatus string

type RequiredHeaderError struct {
	ParamName string
	Err       error
}

type RequiredParamError struct {
	ParamName string
}

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

type ServerInterface interface {
	// Upload a certificate
	// (POST /certificate)
	UploadCertificate(w http.ResponseWriter, r *http.Request)
	// Delete a certificate
	// (DELETE /certificate/{certificateHash})
	DeleteCertificate(w http.ResponseWriter, r *http.Request, certificateHash string)
	// Lookup a certificate
	// (GET /certificate/{certificateHash})
	LookupCertificate(w http.ResponseWriter, r *http.Request, certificateHash string)
	// Register a new charge station
	// (POST /cs/{csId})
	RegisterChargeStation(w http.ResponseWriter, r *http.Request, csId string)
	// Returns the authentication details
	// (GET /cs/{csId}/auth)
	LookupChargeStationAuth(w http.ResponseWriter, r *http.Request, csId string)
	// Install certificates on the charge station
	// (POST /cs/{csId}/certificates)
	InstallChargeStationCertificates(w http.ResponseWriter, r *http.Request, csId string)
	// Reconfigure the charge station
	// (POST /cs/{csId}/reconfigure)
	ReconfigureChargeStation(w http.ResponseWriter, r *http.Request, csId string)

	// (POST /cs/{csId}/trigger)
	TriggerChargeStation(w http.ResponseWriter, r *http.Request, csId string)
	// Registers a location with the CSMS
	// (POST /location/{locationId})
	RegisterLocation(w http.ResponseWriter, r *http.Request, locationId string)
	// Registers an OCPI party with the CSMS
	// (POST /register)
	RegisterParty(w http.ResponseWriter, r *http.Request)
	// List authorization tokens
	// (GET /token)
	ListTokens(w http.ResponseWriter, r *http.Request, params ListTokensParams)
	// Create/update an authorization token
	// (POST /token)
	SetToken(w http.ResponseWriter, r *http.Request)
	// Lookup an authorization token
	// (GET /token/{tokenUid})
	LookupToken(w http.ResponseWriter, r *http.Request, tokenUid string)
}

type ServerInterfaceWrapper struct {
	Handler            ServerInterface
	HandlerMiddlewares []MiddlewareFunc
	ErrorHandlerFunc   func(w http.ResponseWriter, r *http.Request, err error)
}

type SetTokenJSONRequestBody = Token

type Status struct {
	// Error The error details
	Error *string `json:"error,omitempty"`

	// Status The status description
	Status string `json:"status"`
}

type Token struct {
	// CacheMode Indicates what type of token caching is allowed
	CacheMode TokenCacheMode `json:"cacheMode"`

	// ContractId The contract ID (eMAID) associated with the token (with optional component separators)
	ContractId string `json:"contractId"`

	// CountryCode The country code of the issuing eMSP
	CountryCode string `json:"countryCode"`

	// GroupId This id groups a couple of tokens to make two or more tokens work as one
	GroupId *string `json:"groupId,omitempty"`

	// Issuer Issuing company, most of the times the name of the company printed on the RFID card, not necessarily the eMSP
	Issuer string `json:"issuer"`

	// LanguageCode The preferred language to use encoded as ISO 639-1 language code
	LanguageCode *string `json:"languageCode,omitempty"`

	// LastUpdated The date the record was last updated (ignored on create/update)
	LastUpdated *time.Time `json:"lastUpdated,omitempty"`

	// PartyId The party id of the issuing eMSP
	PartyId string `json:"partyId"`

	// Type The type of token
	Type TokenType `json:"type"`

	// Uid The unique token id
	Uid string `json:"uid"`

	// Valid Is this token valid
	Valid bool `json:"valid"`

	// VisualNumber The visual/readable number/identification printed on an RFID card
	VisualNumber *string `json:"visualNumber,omitempty"`
}

type TokenCacheMode string

type TokenType string

type TooManyValuesForParamError struct {
	ParamName string
	Count     int
}

type TriggerChargeStationJSONRequestBody = ChargeStationTrigger

type UnescapedCookieParamError struct {
	ParamName string
	Err       error
}

type UnmarshallingParamError struct {
	ParamName string
	Err       error
}

type UploadCertificateJSONRequestBody = Certificate