camara

package module
v0.0.2 Latest Latest
Warning

This package is not in the latest version of its module.

 Go to latest Published: Jun 19, 2026 License: Apache-2.0 Imports: 17 Imported by: 0

README

Camara Go API Library

Go Reference

The Camara Go library provides convenient access to the Camara REST API from applications written in Go.

It is generated with Stainless.

API Reference: https://github.com/andreibesleaga/camara-api-reference

MCP Server

Use the Camara MCP Server to enable AI assistants to interact with this API, allowing them to explore endpoints, make test requests, and use documentation to help integrate this SDK into your application.

Add to Cursor Install in VS Code

Note: You may need to set environment variables in your MCP client.

Installation

import (
	"github.com/andreibesleaga/camara-go" // imported as camara
)

Or to pin the version:

go get -u 'github.com/andreibesleaga/camara-go@v0.0.2'

Requirements

This library requires Go 1.22+.

Usage

The full API of this library can be found in api.md.

package main

import (
	"context"
	"fmt"

	"github.com/andreibesleaga/camara-go"
	"github.com/andreibesleaga/camara-go/option"
)

func main() {
	client := camara.NewClient(
		option.WithBearerToken("My Bearer Token"), // defaults to os.LookupEnv("CAMARA_BEARER_TOKEN")
	)
	scoring, err := client.Customerinsights.Scoring.Get(context.TODO(), camara.CustomerinsightScoringGetParams{})
	if err != nil {
		panic(err.Error())
	}
	fmt.Printf("%+v\n", scoring.ScoringType)
}
Request fields

The camara library uses the omitzero semantics from the Go 1.24+ encoding/json release for request fields.

Required primitive fields (int64, string, etc.) feature the tag `api:"required"`. These fields are always serialized, even their zero values.

Optional primitive types are wrapped in a param.Opt[T]. These fields can be set with the provided constructors, camara.String(string), camara.Int(int64), etc.

Any param.Opt[T], map, slice, struct or string enum uses the tag `json:"...,omitzero"`. Its zero value is considered omitted.

The param.IsOmitted(any) function can confirm the presence of any omitzero field.

p := camara.ExampleParams{
	ID:   "id_xxx",             // required property
	Name: camara.String("..."), // optional property

	Point: camara.Point{
		X: 0,             // required field will serialize as 0
		Y: camara.Int(1), // optional field will serialize as 1
		// ... omitted non-required fields will not be serialized
	},

	Origin: camara.Origin{}, // the zero value of [Origin] is considered omitted
}

To send null instead of a param.Opt[T], use param.Null[T](). To send null instead of a struct T, use param.NullStruct[T]().

p.Name = param.Null[string]()       // 'null' instead of string
p.Point = param.NullStruct[Point]() // 'null' instead of struct

param.IsNull(p.Name)  // true
param.IsNull(p.Point) // true

Request structs contain a .SetExtraFields(map[string]any) method which can send non-conforming fields in the request body. Extra fields overwrite any struct fields with a matching key. For security reasons, only use SetExtraFields with trusted data.

To send a custom value instead of a struct, use param.Override[T](value).

// In cases where the API specifies a given type,
// but you want to send something else, use [SetExtraFields]:
p.SetExtraFields(map[string]any{
	"x": 0.01, // send "x" as a float instead of int
})

// Send a number instead of an object
custom := param.Override[camara.FooParams](12)
Request unions

Unions are represented as a struct with fields prefixed by "Of" for each of its variants, only one field can be non-zero. The non-zero field will be serialized.

Sub-properties of the union can be accessed via methods on the union struct. These methods return a mutable pointer to the underlying data, if present.

// Only one field can be non-zero, use param.IsOmitted() to check if a field is set
type AnimalUnionParam struct {
	OfCat *Cat `json:",omitzero,inline`
	OfDog *Dog `json:",omitzero,inline`
}

animal := AnimalUnionParam{
	OfCat: &Cat{
		Name: "Whiskers",
		Owner: PersonParam{
			Address: AddressParam{Street: "3333 Coyote Hill Rd", Zip: 0},
		},
	},
}

// Mutating a field
if address := animal.GetOwner().GetAddress(); address != nil {
	address.ZipCode = 94304
}
Response objects

All fields in response structs are ordinary value types (not pointers or wrappers). Response structs also include a special JSON field containing metadata about each property.

type Animal struct {
	Name   string `json:"name,nullable"`
	Owners int    `json:"owners"`
	Age    int    `json:"age"`
	JSON   struct {
		Name        respjson.Field
		Owner       respjson.Field
		Age         respjson.Field
		ExtraFields map[string]respjson.Field
	} `json:"-"`
}

To handle optional data, use the .Valid() method on the JSON field. .Valid() returns true if a field is not null, not present, or couldn't be marshaled.

If .Valid() is false, the corresponding field will simply be its zero value.

raw := `{"owners": 1, "name": null}`

var res Animal
json.Unmarshal([]byte(raw), &res)

// Accessing regular fields

res.Owners // 1
res.Name   // ""
res.Age    // 0

// Optional field checks

res.JSON.Owners.Valid() // true
res.JSON.Name.Valid()   // false
res.JSON.Age.Valid()    // false

// Raw JSON values

res.JSON.Owners.Raw()                  // "1"
res.JSON.Name.Raw() == "null"          // true
res.JSON.Name.Raw() == respjson.Null   // true
res.JSON.Age.Raw() == ""               // true
res.JSON.Age.Raw() == respjson.Omitted // true

These .JSON structs also include an ExtraFields map containing any properties in the json response that were not specified in the struct. This can be useful for API features not yet present in the SDK.

body := res.JSON.ExtraFields["my_unexpected_field"].Raw()
Response Unions

In responses, unions are represented by a flattened struct containing all possible fields from each of the object variants. To convert it to a variant use the .AsFooVariant() method or the .AsAny() method if present.

If a response value union contains primitive values, primitive fields will be alongside the properties but prefixed with Of and feature the tag json:"...,inline".

type AnimalUnion struct {
	// From variants [Dog], [Cat]
	Owner Person `json:"owner"`
	// From variant [Dog]
	DogBreed string `json:"dog_breed"`
	// From variant [Cat]
	CatBreed string `json:"cat_breed"`
	// ...

	JSON struct {
		Owner respjson.Field
		// ...
	} `json:"-"`
}

// If animal variant
if animal.Owner.Address.ZipCode == "" {
	panic("missing zip code")
}

// Switch on the variant
switch variant := animal.AsAny().(type) {
case Dog:
case Cat:
default:
	panic("unexpected type")
}
RequestOptions

This library uses the functional options pattern. Functions defined in the option package return a RequestOption, which is a closure that mutates a RequestConfig. These options can be supplied to the client or at individual requests. For example:

client := camara.NewClient(
	// Adds a header to every request made by the client
	option.WithHeader("X-Some-Header", "custom_header_info"),
)

client.Customerinsights.Scoring.Get(context.TODO(), ...,
	// Override the header
	option.WithHeader("X-Some-Header", "some_other_custom_header_info"),
	// Add an undocumented field to the request body, using sjson syntax
	option.WithJSONSet("some.json.path", map[string]string{"my": "object"}),
)

The request option option.WithDebugLog(nil) may be helpful while debugging.

See the full list of request options.

Pagination

This library provides some conveniences for working with paginated list endpoints.

You can use .ListAutoPaging() methods to iterate through items across all pages:

Or you can use simple .List() methods to fetch a single page and receive a standard response object with additional helper methods like .GetNextPage(), e.g.:

Errors

When the API returns a non-success status code, we return an error with type *camara.Error. This contains the StatusCode, *http.Request, and *http.Response values of the request, as well as the JSON of the error body (much like other response objects in the SDK).

To handle errors, we recommend that you use the errors.As pattern:

_, err := client.Customerinsights.Scoring.Get(context.TODO(), camara.CustomerinsightScoringGetParams{})
if err != nil {
	var apierr *camara.Error
	if errors.As(err, &apierr) {
		println(string(apierr.DumpRequest(true)))  // Prints the serialized HTTP request
		println(string(apierr.DumpResponse(true))) // Prints the serialized HTTP response
	}
	panic(err.Error()) // GET "/customerinsights/scoring/retrieve": 400 Bad Request { ... }
}

When other errors occur, they are returned unwrapped; for example, if HTTP transport fails, you might receive *url.Error wrapping *net.OpError.

Timeouts

Requests do not time out by default; use context to configure a timeout for a request lifecycle.

Note that if a request is retried, the context timeout does not start over. To set a per-retry timeout, use option.WithRequestTimeout().

// This sets the timeout for the request, including all the retries.
ctx, cancel := context.WithTimeout(context.Background(), 5*time.Minute)
defer cancel()
client.Customerinsights.Scoring.Get(
	ctx,
	camara.CustomerinsightScoringGetParams{},
	// This sets the per-retry timeout
	option.WithRequestTimeout(20*time.Second),
)
File uploads

Request parameters that correspond to file uploads in multipart requests are typed as io.Reader. The contents of the io.Reader will by default be sent as a multipart form part with the file name of "anonymous_file" and content-type of "application/octet-stream".

The file name and content-type can be customized by implementing Name() string or ContentType() string on the run-time type of io.Reader. Note that os.File implements Name() string, so a file returned by os.Open will be sent with the file name on disk.

We also provide a helper camara.File(reader io.Reader, filename string, contentType string) which can be used to wrap any io.Reader with the appropriate file name and content type.

Retries

Certain errors will be automatically retried 2 times by default, with a short exponential backoff. We retry by default all connection errors, 408 Request Timeout, 409 Conflict, 429 Rate Limit, and >=500 Internal errors.

You can use the WithMaxRetries option to configure or disable this:

// Configure the default for all requests:
client := camara.NewClient(
	option.WithMaxRetries(0), // default is 2
)

// Override per-request:
client.Customerinsights.Scoring.Get(
	context.TODO(),
	camara.CustomerinsightScoringGetParams{},
	option.WithMaxRetries(5),
)
Accessing raw response data (e.g. response headers)

You can access the raw HTTP response data by using the option.WithResponseInto() request option. This is useful when you need to examine response headers, status codes, or other details.

// Create a variable to store the HTTP response
var response *http.Response
scoring, err := client.Customerinsights.Scoring.Get(
	context.TODO(),
	camara.CustomerinsightScoringGetParams{},
	option.WithResponseInto(&response),
)
if err != nil {
	// handle error
}
fmt.Printf("%+v\n", scoring)

fmt.Printf("Status Code: %d\n", response.StatusCode)
fmt.Printf("Headers: %+#v\n", response.Header)
Making custom/undocumented requests

This library is typed for convenient access to the documented API. If you need to access undocumented endpoints, params, or response properties, the library can still be used.

Undocumented endpoints

To make requests to undocumented endpoints, you can use client.Get, client.Post, and other HTTP verbs. RequestOptions on the client, such as retries, will be respected when making these requests.

var (
    // params can be an io.Reader, a []byte, an encoding/json serializable object,
    // or a "…Params" struct defined in this library.
    params map[string]any

    // result can be an []byte, *http.Response, a encoding/json deserializable object,
    // or a model defined in this library.
    result *http.Response
)
err := client.Post(context.Background(), "/unspecified", params, &result)
if err != nil {
    …
}
Undocumented request params

To make requests using undocumented parameters, you may use either the option.WithQuerySet() or the option.WithJSONSet() methods.

params := FooNewParams{
    ID:   "id_xxxx",
    Data: FooNewParamsData{
        FirstName: camara.String("John"),
    },
}
client.Foo.New(context.Background(), params, option.WithJSONSet("data.last_name", "Doe"))
Undocumented response properties

To access undocumented response properties, you may either access the raw JSON of the response as a string with result.JSON.RawJSON(), or get the raw JSON of a particular field on the result with result.JSON.Foo.Raw().

Any fields that are not present on the response struct will be saved and can be accessed by result.JSON.ExtraFields() which returns the extra fields as a map[string]Field.

Middleware

We provide option.WithMiddleware which applies the given middleware to requests.

func Logger(req *http.Request, next option.MiddlewareNext) (res *http.Response, err error) {
	// Before the request
	start := time.Now()
	LogReq(req)

	// Forward the request to the next handler
	res, err = next(req)

	// Handle stuff after the request
	end := time.Now()
	LogRes(res, err, start - end)

    return res, err
}

client := camara.NewClient(
	option.WithMiddleware(Logger),
)

When multiple middlewares are provided as variadic arguments, the middlewares are applied left to right. If option.WithMiddleware is given multiple times, for example first in the client then the method, the middleware in the client will run first and the middleware given in the method will run next.

You may also replace the default http.Client with option.WithHTTPClient(client). Only one http client is accepted (this overwrites any previous client) and receives requests after any middleware has been applied.

Semantic versioning

This package generally follows SemVer conventions, though certain backwards-incompatible changes may be released as minor versions:

  1. Changes to library internals which are technically public but not intended or documented for external use. (Please open a GitHub issue to let us know if you are relying on such internals.)
  2. Changes that we do not expect to impact the vast majority of users in practice.

We take backwards-compatibility seriously and work hard to ensure you can rely on a smooth upgrade experience.

We are keen for your feedback; please open an issue with questions, bugs, or suggestions.

Contributing

See the contributing documentation.

Documentation

Index

Constants

This section is empty.

Variables

This section is empty.

Functions

func Bool 

func Bool(b bool) param.Opt[bool]

func BoolPtr 

func BoolPtr(v bool) *bool

func DefaultClientOptions 

func DefaultClientOptions() []option.RequestOption

DefaultClientOptions read from the environment (CAMARA_DEVICE_LOCATION_NOTIFICATIONS_API_KEY, CAMARA_NOTIFICATIONS_API_KEY, CAMARA_POPULATION_DENSITY_DATA_NOTIFICATIONS_API_KEY, CAMARA_REGION_DEVICE_COUNT_NOTIFICATIONS_API_KEY, CAMARA_CONNECTIVITY_INSIGHTS_NOTIFICATIONS_API_KEY, CAMARA_SIM_SWAP_NOTIFICATIONS_API_KEY, CAMARA_DEVICE_ROAMING_STATUS_NOTIFICATIONS_API_KEY, CAMARA_DEVICE_REACHABILITY_STATUS_NOTIFICATIONS_API_KEY, CAMARA_CONNECTED_NETWORK_TYPE_NOTIFICATIONS_API_KEY, CAMARA_BEARER_TOKEN, CAMARA_BEARER_TOKEN, CAMARA_BEARER_TOKEN, CAMARA_BEARER_TOKEN, CAMARA_BEARER_TOKEN, CAMARA_BEARER_TOKEN, CAMARA_BEARER_TOKEN, CAMARA_BEARER_TOKEN, CAMARA_BEARER_TOKEN, CAMARA_BEARER_TOKEN, CAMARA_BEARER_TOKEN, CAMARA_BEARER_TOKEN, CAMARA_BEARER_TOKEN, CAMARA_BEARER_TOKEN, CAMARA_BEARER_TOKEN, CAMARA_BEARER_TOKEN, CAMARA_BEARER_TOKEN, CAMARA_BEARER_TOKEN, CAMARA_BEARER_TOKEN, CAMARA_BEARER_TOKEN, CAMARA_BEARER_TOKEN, CAMARA_BASE_URL). This should be used to initialize new clients.

func File 

func File(rdr io.Reader, filename string, contentType string) file

func Float 

func Float(f float64) param.Opt[float64]

func FloatPtr 

func FloatPtr(v float64) *float64

func Int 

func Int(i int64) param.Opt[int64]

func IntPtr 

func IntPtr(v int64) *int64

func Opt 

func Opt[T comparable](v T) param.Opt[T]

func Ptr 

func Ptr[T any](v T) *T

func String 

func String(s string) param.Opt[string]

func StringPtr 

func StringPtr(v string) *string

func Time 

func Time(t time.Time) param.Opt[time.Time]

func TimePtr 

func TimePtr(v time.Time) *time.Time

Types

type CallforwardingsignalCheckActiveForwardingsParams 

type CallforwardingsignalCheckActiveForwardingsParams struct {
	// resource containing the phone number (PhoneNumber) regarding which the Call
	// Forwarding Service must be checked. To be provided/valued only in case of
	// two-legged authentication. If provided/valued with three-legged authentication a
	// 422-UNNECESSARY_IDENTIFIER error code is returned.
	CreateCallForwardingSignal CreateCallForwardingSignalParam
	XCorrelator                param.Opt[string] `header:"x-correlator,omitzero" json:"-"`
	// contains filtered or unexported fields
}

func (CallforwardingsignalCheckActiveForwardingsParams) MarshalJSON 

func (r CallforwardingsignalCheckActiveForwardingsParams) MarshalJSON() (data []byte, err error)

func (*CallforwardingsignalCheckActiveForwardingsParams) UnmarshalJSON 

func (r *CallforwardingsignalCheckActiveForwardingsParams) UnmarshalJSON(data []byte) error

type CallforwardingsignalCheckActiveForwardingsResponse 

type CallforwardingsignalCheckActiveForwardingsResponse string
const (
	CallforwardingsignalCheckActiveForwardingsResponseInactive                CallforwardingsignalCheckActiveForwardingsResponse = "inactive"
	CallforwardingsignalCheckActiveForwardingsResponseUnconditional           CallforwardingsignalCheckActiveForwardingsResponse = "unconditional"
	CallforwardingsignalCheckActiveForwardingsResponseConditionalBusy         CallforwardingsignalCheckActiveForwardingsResponse = "conditional_busy"
	CallforwardingsignalCheckActiveForwardingsResponseConditionalNotReachable CallforwardingsignalCheckActiveForwardingsResponse = "conditional_not_reachable"
	CallforwardingsignalCheckActiveForwardingsResponseConditionalNoAnswer     CallforwardingsignalCheckActiveForwardingsResponse = "conditional_no_answer"
)

type CallforwardingsignalCheckUnconditionalForwardingParams 

type CallforwardingsignalCheckUnconditionalForwardingParams struct {
	// resource containing the phone number (PhoneNumber) regarding which the Call
	// Forwarding Service must be checked. To be provided/valued only in case of
	// two-legged authentication. If provided/valued with three-legged authentication a
	// 422-UNNECESSARY_IDENTIFIER error code is returned.
	CreateCallForwardingSignal CreateCallForwardingSignalParam
	XCorrelator                param.Opt[string] `header:"x-correlator,omitzero" json:"-"`
	// contains filtered or unexported fields
}

func (CallforwardingsignalCheckUnconditionalForwardingParams) MarshalJSON 

func (r CallforwardingsignalCheckUnconditionalForwardingParams) MarshalJSON() (data []byte, err error)

func (*CallforwardingsignalCheckUnconditionalForwardingParams) UnmarshalJSON 

func (r *CallforwardingsignalCheckUnconditionalForwardingParams) UnmarshalJSON(data []byte) error

type CallforwardingsignalCheckUnconditionalForwardingResponse 

type CallforwardingsignalCheckUnconditionalForwardingResponse struct {
	// Indicates if the unconditional call forwarding service is active.
	Active bool `json:"active"`
	// JSON contains metadata for fields, check presence with [respjson.Field.Valid].
	JSON struct {
		Active      respjson.Field
		ExtraFields map[string]respjson.Field
		// contains filtered or unexported fields
	} `json:"-"`
}

resource containing the information about the Unconditional Call Forwarding Service for the given phone number (PhoneNumber)

func (CallforwardingsignalCheckUnconditionalForwardingResponse) RawJSON 

func (r CallforwardingsignalCheckUnconditionalForwardingResponse) RawJSON() string

Returns the unmodified JSON received from the API

func (*CallforwardingsignalCheckUnconditionalForwardingResponse) UnmarshalJSON 

func (r *CallforwardingsignalCheckUnconditionalForwardingResponse) UnmarshalJSON(data []byte) error

type CallforwardingsignalService 

type CallforwardingsignalService struct {
	Options []option.RequestOption
}

Call Forwarding Signal

CallforwardingsignalService contains methods and other services that help with interacting with the camara API.

Note, unlike clients, this service does not read variables from the environment automatically. You should not instantiate this service directly, and instead use the NewCallforwardingsignalService method instead.

func NewCallforwardingsignalService 

func NewCallforwardingsignalService(opts ...option.RequestOption) (r CallforwardingsignalService)

NewCallforwardingsignalService generates a new service that applies the given options to each request. These options are applied after the parent client's options (if there is one), and before any request-specific options.

func (*CallforwardingsignalService) CheckActiveForwardings 

func (r *CallforwardingsignalService) CheckActiveForwardings(ctx context.Context, params CallforwardingsignalCheckActiveForwardingsParams, opts ...option.RequestOption) (res *[]CallforwardingsignalCheckActiveForwardingsResponse, err error)

This endpoint provides information about which type of call forwarding service is active. More than one service can be active, e.g. conditional and unconditional. This endpoint exceeds the main scope of the Call Forwarding Signal API, for this reason an error code 501 can be returned.

func (*CallforwardingsignalService) CheckUnconditionalForwarding 

func (r *CallforwardingsignalService) CheckUnconditionalForwarding(ctx context.Context, params CallforwardingsignalCheckUnconditionalForwardingParams, opts ...option.RequestOption) (res *CallforwardingsignalCheckUnconditionalForwardingResponse, err error)

This endpoint provides information about the status of the unconditional call forwarding, being active or not.

type Client 

type Client struct {
	Options          []option.RequestOption
	Customerinsights CustomerinsightService
	// Device Swap
	Deviceswap DeviceswapService
	// Know Your Customer Age Verification
	Knowyourcustomerageverification KnowyourcustomerageverificationService
	// Know Your Customer Fill-in
	KnowyourcustomerfillIn KnowyourcustomerfillInService
	// Know Your Customer Match
	Knowyourcustomermatch KnowyourcustomermatchService
	// KYC Tenure
	Tenure TenureService
	// Number Recycling
	Numberrecycling NumberrecyclingService
	// One Time Password SMS
	Otpvalidation OtpvalidationService
	// Call Forwarding Signal
	Callforwardingsignal CallforwardingsignalService
	Devicelocation       DevicelocationService
	// Population Density Data
	Populationdensitydata PopulationdensitydataService
	// Region Device Count
	Regiondevicecount    RegiondevicecountService
	Webrtc               WebrtcService
	Connectivityinsights ConnectivityinsightService
	// QoS Profiles
	Qualityondemand QualityondemandService
	// Device Identifier
	Deviceidentifier         DeviceidentifierService
	Simswap                  SimswapService
	Deviceroamingstatus      DeviceroamingstatusService
	Devicereachabilitystatus DevicereachabilitystatusService
	Connectednetworktype     ConnectednetworktypeService
}

Client creates a struct with services and top level methods that help with interacting with the camara API. You should not instantiate this client directly, and instead use the NewClient method instead.

func NewClient 

func NewClient(opts ...option.RequestOption) (r Client)

NewClient generates a new client with the default option read from the environment (CAMARA_DEVICE_LOCATION_NOTIFICATIONS_API_KEY, CAMARA_NOTIFICATIONS_API_KEY, CAMARA_POPULATION_DENSITY_DATA_NOTIFICATIONS_API_KEY, CAMARA_REGION_DEVICE_COUNT_NOTIFICATIONS_API_KEY, CAMARA_CONNECTIVITY_INSIGHTS_NOTIFICATIONS_API_KEY, CAMARA_SIM_SWAP_NOTIFICATIONS_API_KEY, CAMARA_DEVICE_ROAMING_STATUS_NOTIFICATIONS_API_KEY, CAMARA_DEVICE_REACHABILITY_STATUS_NOTIFICATIONS_API_KEY, CAMARA_CONNECTED_NETWORK_TYPE_NOTIFICATIONS_API_KEY, CAMARA_BEARER_TOKEN, CAMARA_BEARER_TOKEN, CAMARA_BEARER_TOKEN, CAMARA_BEARER_TOKEN, CAMARA_BEARER_TOKEN, CAMARA_BEARER_TOKEN, CAMARA_BEARER_TOKEN, CAMARA_BEARER_TOKEN, CAMARA_BEARER_TOKEN, CAMARA_BEARER_TOKEN, CAMARA_BEARER_TOKEN, CAMARA_BEARER_TOKEN, CAMARA_BEARER_TOKEN, CAMARA_BEARER_TOKEN, CAMARA_BEARER_TOKEN, CAMARA_BEARER_TOKEN, CAMARA_BEARER_TOKEN, CAMARA_BEARER_TOKEN, CAMARA_BEARER_TOKEN, CAMARA_BEARER_TOKEN, CAMARA_BEARER_TOKEN, CAMARA_BASE_URL). The option passed in as arguments are applied after these default arguments, and all option will be passed down to the services and requests that this client makes.

func (*Client) Delete 

func (r *Client) Delete(ctx context.Context, path string, params any, res any, opts ...option.RequestOption) error

Delete makes a DELETE request with the given URL, params, and optionally deserializes to a response. See [Execute] documentation on the params and response.

func (*Client) Execute 

func (r *Client) Execute(ctx context.Context, method string, path string, params any, res any, opts ...option.RequestOption) error

Execute makes a request with the given context, method, URL, request params, response, and request options. This is useful for hitting undocumented endpoints while retaining the base URL, auth, retries, and other options from the client.

If a byte slice or an io.Reader is supplied to params, it will be used as-is for the request body.

The params is by default serialized into the body using encoding/json. If your type implements a MarshalJSON function, it will be used instead to serialize the request. If a URLQuery method is implemented, the returned [url.Values] will be used as query strings to the url.

If your params struct uses param.Field, you must provide either [MarshalJSON], [URLQuery], and/or [MarshalForm] functions. It is undefined behavior to use a struct uses param.Field without specifying how it is serialized.

Any "…Params" object defined in this library can be used as the request argument. Note that 'path' arguments will not be forwarded into the url.

The response body will be deserialized into the res variable, depending on its type:

  • A pointer to a *http.Response is populated by the raw response.
  • A pointer to a byte array will be populated with the contents of the request body.
  • A pointer to any other type uses this library's default JSON decoding, which respects UnmarshalJSON if it is defined on the type.
  • A nil value will not read the response body.

For even greater flexibility, see option.WithResponseInto and option.WithResponseBodyInto.

func (*Client) Get 

func (r *Client) Get(ctx context.Context, path string, params any, res any, opts ...option.RequestOption) error

Get makes a GET request with the given URL, params, and optionally deserializes to a response. See [Execute] documentation on the params and response.

func (*Client) Patch 

func (r *Client) Patch(ctx context.Context, path string, params any, res any, opts ...option.RequestOption) error

Patch makes a PATCH request with the given URL, params, and optionally deserializes to a response. See [Execute] documentation on the params and response.

func (*Client) Post 

func (r *Client) Post(ctx context.Context, path string, params any, res any, opts ...option.RequestOption) error

Post makes a POST request with the given URL, params, and optionally deserializes to a response. See [Execute] documentation on the params and response.

func (*Client) Put 

func (r *Client) Put(ctx context.Context, path string, params any, res any, opts ...option.RequestOption) error

Put makes a PUT request with the given URL, params, and optionally deserializes to a response. See [Execute] documentation on the params and response.

type Config 

type Config struct {
	// The detail of the requested event subscription
	SubscriptionDetail ConfigSubscriptionDetail `json:"subscriptionDetail" api:"required"`
	// Set to `true` by API consumer if consumer wants to get an event as soon as the
	// subscription is created and current situation reflects event request.
	InitialEvent bool `json:"initialEvent"`
	// The subscription expiration time (in date-time format) requested by the API
	// consumer. Up to API project decision to keep it. It must follow
	// [RFC 3339](https://datatracker.ietf.org/doc/html/rfc3339#section-5.6) and must
	// have time zone.
	SubscriptionExpireTime time.Time `json:"subscriptionExpireTime" format:"date-time"`
	// Identifies the maximum number of event reports to be generated (>=1) requested
	// by the API consumer - Once this number is reached, the subscription ends. Note
	// on combined usage of `initialEvent` and `subscriptionMaxEvents`: If an event is
	// triggered following `initialEvent` set to `true`, this event will be counted
	// towards `subscriptionMaxEvents`.
	SubscriptionMaxEvents int64 `json:"subscriptionMaxEvents"`
	// JSON contains metadata for fields, check presence with [respjson.Field.Valid].
	JSON struct {
		SubscriptionDetail     respjson.Field
		InitialEvent           respjson.Field
		SubscriptionExpireTime respjson.Field
		SubscriptionMaxEvents  respjson.Field
		ExtraFields            map[string]respjson.Field
		// contains filtered or unexported fields
	} `json:"-"`
}

Implementation-specific configuration parameters needed by the subscription manager for acquiring events. In CAMARA we have predefined attributes like `subscriptionExpireTime`, `subscriptionMaxEvents`, `initialEvent` Specific event type attributes must be defined in `subscriptionDetail` Note: if a request is performed for several event type, all subscribed event will use same `config` parameters.

func (Config) RawJSON 

func (r Config) RawJSON() string

Returns the unmodified JSON received from the API

func (Config) ToParam 

func (r Config) ToParam() ConfigParam

ToParam converts this Config to a ConfigParam.

Warning: the fields of the param type will not be present. ToParam should only be used at the last possible moment before sending a request. Test for this with ConfigParam.Overrides()

func (*Config) UnmarshalJSON 

func (r *Config) UnmarshalJSON(data []byte) error

type ConfigParam 

type ConfigParam struct {
	// The detail of the requested event subscription
	SubscriptionDetail ConfigSubscriptionDetailParam `json:"subscriptionDetail,omitzero" api:"required"`
	// Set to `true` by API consumer if consumer wants to get an event as soon as the
	// subscription is created and current situation reflects event request.
	InitialEvent param.Opt[bool] `json:"initialEvent,omitzero"`
	// The subscription expiration time (in date-time format) requested by the API
	// consumer. Up to API project decision to keep it. It must follow
	// [RFC 3339](https://datatracker.ietf.org/doc/html/rfc3339#section-5.6) and must
	// have time zone.
	SubscriptionExpireTime param.Opt[time.Time] `json:"subscriptionExpireTime,omitzero" format:"date-time"`
	// Identifies the maximum number of event reports to be generated (>=1) requested
	// by the API consumer - Once this number is reached, the subscription ends. Note
	// on combined usage of `initialEvent` and `subscriptionMaxEvents`: If an event is
	// triggered following `initialEvent` set to `true`, this event will be counted
	// towards `subscriptionMaxEvents`.
	SubscriptionMaxEvents param.Opt[int64] `json:"subscriptionMaxEvents,omitzero"`
	// contains filtered or unexported fields
}

Implementation-specific configuration parameters needed by the subscription manager for acquiring events. In CAMARA we have predefined attributes like `subscriptionExpireTime`, `subscriptionMaxEvents`, `initialEvent` Specific event type attributes must be defined in `subscriptionDetail` Note: if a request is performed for several event type, all subscribed event will use same `config` parameters.

The property SubscriptionDetail is required.

func (ConfigParam) MarshalJSON 

func (r ConfigParam) MarshalJSON() (data []byte, err error)

func (*ConfigParam) UnmarshalJSON 

func (r *ConfigParam) UnmarshalJSON(data []byte) error

type ConfigSubscriptionDetail 

type ConfigSubscriptionDetail struct {
	// Identifier for the Application Profile
	ApplicationProfileID string `json:"applicationProfileId" api:"required" format:"uuid"`
	// End-user equipment able to connect to a mobile network. Examples of devices
	// include smartphones or IoT sensors/actuators. The developer can choose to
	// provide the below specified device identifiers: _ `ipv4Address` _ `ipv6Address`
	// _ `phoneNumber` _ `networkAccessIdentifier` NOTE1: the network operator might
	// support only a subset of these options. The API invoker can provide multiple
	// identifiers to be compatible across different network operators. In this case
	// the identifiers MUST belong to the same device. NOTE2: as for this Commonalities
	// release, we are enforcing that the networkAccessIdentifier is only part of the
	// schema for future-proofing, and CAMARA does not currently allow its use. After
	// the CAMARA meta-release work is concluded and the relevant issues are resolved,
	// its use will need to be explicitly documented in the guidelines.
	Device ConfigSubscriptionDetailDevice `json:"device" api:"required"`
	// A server hosting backend applications to deliver some business logic to clients.
	//
	// The developer can choose to provide the below specified device identifiers:
	//
	// - `ipv4Address`
	// - `ipv6Address`
	//
	// The Operator will use this information to calculate the end to end network
	// performance in scenarios where its feasible.
	ApplicationServer ConfigSubscriptionDetailApplicationServer `json:"applicationServer"`
	// Specification of several TCP or UDP ports
	ApplicationServerPorts ConfigSubscriptionDetailApplicationServerPorts `json:"applicationServerPorts"`
	// JSON contains metadata for fields, check presence with [respjson.Field.Valid].
	JSON struct {
		ApplicationProfileID   respjson.Field
		Device                 respjson.Field
		ApplicationServer      respjson.Field
		ApplicationServerPorts respjson.Field
		ExtraFields            map[string]respjson.Field
		// contains filtered or unexported fields
	} `json:"-"`
}

The detail of the requested event subscription

func (ConfigSubscriptionDetail) RawJSON 

func (r ConfigSubscriptionDetail) RawJSON() string

Returns the unmodified JSON received from the API

func (*ConfigSubscriptionDetail) UnmarshalJSON 

func (r *ConfigSubscriptionDetail) UnmarshalJSON(data []byte) error

type ConfigSubscriptionDetailApplicationServer 

type ConfigSubscriptionDetailApplicationServer struct {
	// IPv4 address may be specified in form <address/mask> as:
	//
	//   - address - an IPv4 number in dotted-quad form 1.2.3.4. Only this exact IP
	//     number will match the flow control rule.
	//   - address/mask - an IP number as above with a mask width of the form 1.2.3.4/24.
	//     In this case, all IP numbers from 1.2.3.0 to 1.2.3.255 will match. The bit
	//     width MUST be valid for the IP version.
	Ipv4Address string `json:"ipv4Address"`
	// IPv6 address may be specified in form <address/mask> as:
	//
	// - address - The /128 subnet is optional for single addresses:
	//   - 2001:db8:85a3:8d3:1319:8a2e:370:7344
	//   - 2001:db8:85a3:8d3:1319:8a2e:370:7344/128
	//
	// - address/mask - an IP v6 number with a mask:
	//   - 2001:db8:85a3:8d3::0/64
	//   - 2001:db8:85a3:8d3::/64
	Ipv6Address string `json:"ipv6Address"`
	// JSON contains metadata for fields, check presence with [respjson.Field.Valid].
	JSON struct {
		Ipv4Address respjson.Field
		Ipv6Address respjson.Field
		ExtraFields map[string]respjson.Field
		// contains filtered or unexported fields
	} `json:"-"`
}

A server hosting backend applications to deliver some business logic to clients.

The developer can choose to provide the below specified device identifiers:

- `ipv4Address` - `ipv6Address`

The Operator will use this information to calculate the end to end network performance in scenarios where its feasible.

func (ConfigSubscriptionDetailApplicationServer) RawJSON 

func (r ConfigSubscriptionDetailApplicationServer) RawJSON() string

Returns the unmodified JSON received from the API

func (*ConfigSubscriptionDetailApplicationServer) UnmarshalJSON 

func (r *ConfigSubscriptionDetailApplicationServer) UnmarshalJSON(data []byte) error

type ConfigSubscriptionDetailApplicationServerParam 

type ConfigSubscriptionDetailApplicationServerParam struct {
	// IPv4 address may be specified in form <address/mask> as:
	//
	//   - address - an IPv4 number in dotted-quad form 1.2.3.4. Only this exact IP
	//     number will match the flow control rule.
	//   - address/mask - an IP number as above with a mask width of the form 1.2.3.4/24.
	//     In this case, all IP numbers from 1.2.3.0 to 1.2.3.255 will match. The bit
	//     width MUST be valid for the IP version.
	Ipv4Address param.Opt[string] `json:"ipv4Address,omitzero"`
	// IPv6 address may be specified in form <address/mask> as:
	//
	// - address - The /128 subnet is optional for single addresses:
	//   - 2001:db8:85a3:8d3:1319:8a2e:370:7344
	//   - 2001:db8:85a3:8d3:1319:8a2e:370:7344/128
	//
	// - address/mask - an IP v6 number with a mask:
	//   - 2001:db8:85a3:8d3::0/64
	//   - 2001:db8:85a3:8d3::/64
	Ipv6Address param.Opt[string] `json:"ipv6Address,omitzero"`
	// contains filtered or unexported fields
}

A server hosting backend applications to deliver some business logic to clients.

The developer can choose to provide the below specified device identifiers:

- `ipv4Address` - `ipv6Address`

The Operator will use this information to calculate the end to end network performance in scenarios where its feasible.

func (ConfigSubscriptionDetailApplicationServerParam) MarshalJSON 

func (r ConfigSubscriptionDetailApplicationServerParam) MarshalJSON() (data []byte, err error)

func (*ConfigSubscriptionDetailApplicationServerParam) UnmarshalJSON 

func (r *ConfigSubscriptionDetailApplicationServerParam) UnmarshalJSON(data []byte) error

type ConfigSubscriptionDetailApplicationServerPorts 

type ConfigSubscriptionDetailApplicationServerPorts struct {
	// Array of TCP or UDP ports
	Ports []int64 `json:"ports"`
	// Range of TCP or UDP ports
	Ranges []ConfigSubscriptionDetailApplicationServerPortsRange `json:"ranges"`
	// JSON contains metadata for fields, check presence with [respjson.Field.Valid].
	JSON struct {
		Ports       respjson.Field
		Ranges      respjson.Field
		ExtraFields map[string]respjson.Field
		// contains filtered or unexported fields
	} `json:"-"`
}

Specification of several TCP or UDP ports

func (ConfigSubscriptionDetailApplicationServerPorts) RawJSON 

func (r ConfigSubscriptionDetailApplicationServerPorts) RawJSON() string

Returns the unmodified JSON received from the API

func (*ConfigSubscriptionDetailApplicationServerPorts) UnmarshalJSON 

func (r *ConfigSubscriptionDetailApplicationServerPorts) UnmarshalJSON(data []byte) error

type ConfigSubscriptionDetailApplicationServerPortsParam 

type ConfigSubscriptionDetailApplicationServerPortsParam struct {
	// Array of TCP or UDP ports
	Ports []int64 `json:"ports,omitzero"`
	// Range of TCP or UDP ports
	Ranges []ConfigSubscriptionDetailApplicationServerPortsRangeParam `json:"ranges,omitzero"`
	// contains filtered or unexported fields
}

Specification of several TCP or UDP ports

func (ConfigSubscriptionDetailApplicationServerPortsParam) MarshalJSON 

func (r ConfigSubscriptionDetailApplicationServerPortsParam) MarshalJSON() (data []byte, err error)

func (*ConfigSubscriptionDetailApplicationServerPortsParam) UnmarshalJSON 

func (r *ConfigSubscriptionDetailApplicationServerPortsParam) UnmarshalJSON(data []byte) error

type ConfigSubscriptionDetailApplicationServerPortsRange 

type ConfigSubscriptionDetailApplicationServerPortsRange struct {
	// TCP or UDP port number
	From int64 `json:"from" api:"required"`
	// TCP or UDP port number
	To int64 `json:"to" api:"required"`
	// JSON contains metadata for fields, check presence with [respjson.Field.Valid].
	JSON struct {
		From        respjson.Field
		To          respjson.Field
		ExtraFields map[string]respjson.Field
		// contains filtered or unexported fields
	} `json:"-"`
}

func (ConfigSubscriptionDetailApplicationServerPortsRange) RawJSON 

func (r ConfigSubscriptionDetailApplicationServerPortsRange) RawJSON() string

Returns the unmodified JSON received from the API

func (*ConfigSubscriptionDetailApplicationServerPortsRange) UnmarshalJSON 

func (r *ConfigSubscriptionDetailApplicationServerPortsRange) UnmarshalJSON(data []byte) error

type ConfigSubscriptionDetailApplicationServerPortsRangeParam 

type ConfigSubscriptionDetailApplicationServerPortsRangeParam struct {
	// TCP or UDP port number
	From int64 `json:"from" api:"required"`
	// TCP or UDP port number
	To int64 `json:"to" api:"required"`
	// contains filtered or unexported fields
}

The properties From, To are required.

func (ConfigSubscriptionDetailApplicationServerPortsRangeParam) MarshalJSON 

func (r ConfigSubscriptionDetailApplicationServerPortsRangeParam) MarshalJSON() (data []byte, err error)

func (*ConfigSubscriptionDetailApplicationServerPortsRangeParam) UnmarshalJSON 

func (r *ConfigSubscriptionDetailApplicationServerPortsRangeParam) UnmarshalJSON(data []byte) error

type ConfigSubscriptionDetailDevice 

type ConfigSubscriptionDetailDevice struct {
	// The device should be identified by either the public (observed) IP address and
	// port as seen by the application server, or the private (local) and any public
	// (observed) IP addresses in use by the device (this information can be obtained
	// by various means, for example from some DNS servers).
	//
	// If the allocated and observed IP addresses are the same (i.e. NAT is not in use)
	// then the same address should be specified for both publicAddress and
	// privateAddress.
	//
	// If NAT64 is in use, the device should be identified by its publicAddress and
	// publicPort, or separately by its allocated IPv6 address (field ipv6Address of
	// the Device object)
	//
	// In all cases, publicAddress must be specified, along with at least one of either
	// privateAddress or publicPort, dependent upon which is known. In general, mobile
	// devices cannot be identified by their public IPv4 address alone.
	Ipv4Address ConfigSubscriptionDetailDeviceIpv4Address `json:"ipv4Address"`
	// The device should be identified by the observed IPv6 address, or by any single
	// IPv6 address from within the subnet allocated to the device (e.g. adding ::0 to
	// the /64 prefix).
	//
	// The session shall apply to all IP flows between the device subnet and the
	// specified application server, unless further restricted by the optional
	// parameters devicePorts or applicationServerPorts.
	Ipv6Address string `json:"ipv6Address" format:"ipv6"`
	// A public identifier addressing a subscription in a mobile network. In 3GPP
	// terminology, it corresponds to the GPSI formatted with the External Identifier
	// ({Local Identifier}@{Domain Identifier}). Unlike the telephone number, the
	// network access identifier is not subjected to portability ruling in force, and
	// is individually managed by each operator.
	NetworkAccessIdentifier string `json:"networkAccessIdentifier"`
	// A public identifier addressing a telephone subscription. In mobile networks it
	// corresponds to the MSISDN (Mobile Station International Subscriber Directory
	// Number). In order to be globally unique it has to be formatted in international
	// format, according to E.164 standard, prefixed with '+'.
	PhoneNumber string `json:"phoneNumber"`
	// JSON contains metadata for fields, check presence with [respjson.Field.Valid].
	JSON struct {
		Ipv4Address             respjson.Field
		Ipv6Address             respjson.Field
		NetworkAccessIdentifier respjson.Field
		PhoneNumber             respjson.Field
		ExtraFields             map[string]respjson.Field
		// contains filtered or unexported fields
	} `json:"-"`
}

End-user equipment able to connect to a mobile network. Examples of devices include smartphones or IoT sensors/actuators. The developer can choose to provide the below specified device identifiers: _ `ipv4Address` _ `ipv6Address` _ `phoneNumber` _ `networkAccessIdentifier` NOTE1: the network operator might support only a subset of these options. The API invoker can provide multiple identifiers to be compatible across different network operators. In this case the identifiers MUST belong to the same device. NOTE2: as for this Commonalities release, we are enforcing that the networkAccessIdentifier is only part of the schema for future-proofing, and CAMARA does not currently allow its use. After the CAMARA meta-release work is concluded and the relevant issues are resolved, its use will need to be explicitly documented in the guidelines.

func (ConfigSubscriptionDetailDevice) RawJSON 

func (r ConfigSubscriptionDetailDevice) RawJSON() string

Returns the unmodified JSON received from the API

func (*ConfigSubscriptionDetailDevice) UnmarshalJSON 

func (r *ConfigSubscriptionDetailDevice) UnmarshalJSON(data []byte) error

type ConfigSubscriptionDetailDeviceIpv4Address 

type ConfigSubscriptionDetailDeviceIpv4Address struct {
	// A single IPv4 address with no subnet mask
	PrivateAddress string `json:"privateAddress" format:"ipv4"`
	// A single IPv4 address with no subnet mask
	PublicAddress string `json:"publicAddress" format:"ipv4"`
	// TCP or UDP port number
	PublicPort int64 `json:"publicPort"`
	// JSON contains metadata for fields, check presence with [respjson.Field.Valid].
	JSON struct {
		PrivateAddress respjson.Field
		PublicAddress  respjson.Field
		PublicPort     respjson.Field
		ExtraFields    map[string]respjson.Field
		// contains filtered or unexported fields
	} `json:"-"`
}

The device should be identified by either the public (observed) IP address and port as seen by the application server, or the private (local) and any public (observed) IP addresses in use by the device (this information can be obtained by various means, for example from some DNS servers).

If the allocated and observed IP addresses are the same (i.e. NAT is not in use) then the same address should be specified for both publicAddress and privateAddress.

If NAT64 is in use, the device should be identified by its publicAddress and publicPort, or separately by its allocated IPv6 address (field ipv6Address of the Device object)

In all cases, publicAddress must be specified, along with at least one of either privateAddress or publicPort, dependent upon which is known. In general, mobile devices cannot be identified by their public IPv4 address alone.

func (ConfigSubscriptionDetailDeviceIpv4Address) RawJSON 

func (r ConfigSubscriptionDetailDeviceIpv4Address) RawJSON() string

Returns the unmodified JSON received from the API

func (*ConfigSubscriptionDetailDeviceIpv4Address) UnmarshalJSON 

func (r *ConfigSubscriptionDetailDeviceIpv4Address) UnmarshalJSON(data []byte) error

type ConfigSubscriptionDetailDeviceIpv4AddressParam 

type ConfigSubscriptionDetailDeviceIpv4AddressParam struct {
	// A single IPv4 address with no subnet mask
	PrivateAddress param.Opt[string] `json:"privateAddress,omitzero" format:"ipv4"`
	// A single IPv4 address with no subnet mask
	PublicAddress param.Opt[string] `json:"publicAddress,omitzero" format:"ipv4"`
	// TCP or UDP port number
	PublicPort param.Opt[int64] `json:"publicPort,omitzero"`
	// contains filtered or unexported fields
}

The device should be identified by either the public (observed) IP address and port as seen by the application server, or the private (local) and any public (observed) IP addresses in use by the device (this information can be obtained by various means, for example from some DNS servers).

If the allocated and observed IP addresses are the same (i.e. NAT is not in use) then the same address should be specified for both publicAddress and privateAddress.

If NAT64 is in use, the device should be identified by its publicAddress and publicPort, or separately by its allocated IPv6 address (field ipv6Address of the Device object)

In all cases, publicAddress must be specified, along with at least one of either privateAddress or publicPort, dependent upon which is known. In general, mobile devices cannot be identified by their public IPv4 address alone.

func (ConfigSubscriptionDetailDeviceIpv4AddressParam) MarshalJSON 

func (r ConfigSubscriptionDetailDeviceIpv4AddressParam) MarshalJSON() (data []byte, err error)

func (*ConfigSubscriptionDetailDeviceIpv4AddressParam) UnmarshalJSON 

func (r *ConfigSubscriptionDetailDeviceIpv4AddressParam) UnmarshalJSON(data []byte) error

type ConfigSubscriptionDetailDeviceParam 

type ConfigSubscriptionDetailDeviceParam struct {
	// The device should be identified by the observed IPv6 address, or by any single
	// IPv6 address from within the subnet allocated to the device (e.g. adding ::0 to
	// the /64 prefix).
	//
	// The session shall apply to all IP flows between the device subnet and the
	// specified application server, unless further restricted by the optional
	// parameters devicePorts or applicationServerPorts.
	Ipv6Address param.Opt[string] `json:"ipv6Address,omitzero" format:"ipv6"`
	// A public identifier addressing a subscription in a mobile network. In 3GPP
	// terminology, it corresponds to the GPSI formatted with the External Identifier
	// ({Local Identifier}@{Domain Identifier}). Unlike the telephone number, the
	// network access identifier is not subjected to portability ruling in force, and
	// is individually managed by each operator.
	NetworkAccessIdentifier param.Opt[string] `json:"networkAccessIdentifier,omitzero"`
	// A public identifier addressing a telephone subscription. In mobile networks it
	// corresponds to the MSISDN (Mobile Station International Subscriber Directory
	// Number). In order to be globally unique it has to be formatted in international
	// format, according to E.164 standard, prefixed with '+'.
	PhoneNumber param.Opt[string] `json:"phoneNumber,omitzero"`
	// The device should be identified by either the public (observed) IP address and
	// port as seen by the application server, or the private (local) and any public
	// (observed) IP addresses in use by the device (this information can be obtained
	// by various means, for example from some DNS servers).
	//
	// If the allocated and observed IP addresses are the same (i.e. NAT is not in use)
	// then the same address should be specified for both publicAddress and
	// privateAddress.
	//
	// If NAT64 is in use, the device should be identified by its publicAddress and
	// publicPort, or separately by its allocated IPv6 address (field ipv6Address of
	// the Device object)
	//
	// In all cases, publicAddress must be specified, along with at least one of either
	// privateAddress or publicPort, dependent upon which is known. In general, mobile
	// devices cannot be identified by their public IPv4 address alone.
	Ipv4Address ConfigSubscriptionDetailDeviceIpv4AddressParam `json:"ipv4Address,omitzero"`
	// contains filtered or unexported fields
}

End-user equipment able to connect to a mobile network. Examples of devices include smartphones or IoT sensors/actuators. The developer can choose to provide the below specified device identifiers: _ `ipv4Address` _ `ipv6Address` _ `phoneNumber` _ `networkAccessIdentifier` NOTE1: the network operator might support only a subset of these options. The API invoker can provide multiple identifiers to be compatible across different network operators. In this case the identifiers MUST belong to the same device. NOTE2: as for this Commonalities release, we are enforcing that the networkAccessIdentifier is only part of the schema for future-proofing, and CAMARA does not currently allow its use. After the CAMARA meta-release work is concluded and the relevant issues are resolved, its use will need to be explicitly documented in the guidelines.

func (ConfigSubscriptionDetailDeviceParam) MarshalJSON 

func (r ConfigSubscriptionDetailDeviceParam) MarshalJSON() (data []byte, err error)

func (*ConfigSubscriptionDetailDeviceParam) UnmarshalJSON 

func (r *ConfigSubscriptionDetailDeviceParam) UnmarshalJSON(data []byte) error

type ConfigSubscriptionDetailParam 

type ConfigSubscriptionDetailParam struct {
	// Identifier for the Application Profile
	ApplicationProfileID string `json:"applicationProfileId" api:"required" format:"uuid"`
	// End-user equipment able to connect to a mobile network. Examples of devices
	// include smartphones or IoT sensors/actuators. The developer can choose to
	// provide the below specified device identifiers: _ `ipv4Address` _ `ipv6Address`
	// _ `phoneNumber` _ `networkAccessIdentifier` NOTE1: the network operator might
	// support only a subset of these options. The API invoker can provide multiple
	// identifiers to be compatible across different network operators. In this case
	// the identifiers MUST belong to the same device. NOTE2: as for this Commonalities
	// release, we are enforcing that the networkAccessIdentifier is only part of the
	// schema for future-proofing, and CAMARA does not currently allow its use. After
	// the CAMARA meta-release work is concluded and the relevant issues are resolved,
	// its use will need to be explicitly documented in the guidelines.
	Device ConfigSubscriptionDetailDeviceParam `json:"device,omitzero" api:"required"`
	// A server hosting backend applications to deliver some business logic to clients.
	//
	// The developer can choose to provide the below specified device identifiers:
	//
	// - `ipv4Address`
	// - `ipv6Address`
	//
	// The Operator will use this information to calculate the end to end network
	// performance in scenarios where its feasible.
	ApplicationServer ConfigSubscriptionDetailApplicationServerParam `json:"applicationServer,omitzero"`
	// Specification of several TCP or UDP ports
	ApplicationServerPorts ConfigSubscriptionDetailApplicationServerPortsParam `json:"applicationServerPorts,omitzero"`
	// contains filtered or unexported fields
}

The detail of the requested event subscription

The properties ApplicationProfileID, Device are required.

func (ConfigSubscriptionDetailParam) MarshalJSON 

func (r ConfigSubscriptionDetailParam) MarshalJSON() (data []byte, err error)

func (*ConfigSubscriptionDetailParam) UnmarshalJSON 

func (r *ConfigSubscriptionDetailParam) UnmarshalJSON(data []byte) error

type ConnectedNetworkTypeConfig 

type ConnectedNetworkTypeConfig struct {
	// The detail of the requested event subscription.
	SubscriptionDetail ConnectedNetworkTypeConfigSubscriptionDetail `json:"subscriptionDetail" api:"required"`
	// Set to `true` by API consumer if consumer wants to get an event as soon as the
	// subscription is created and current situation reflects event request. Example:
	// Consumer request area entered event. If consumer sets initialEvent to true and
	// device is already in the geofence, an event is triggered
	InitialEvent bool `json:"initialEvent"`
	// The subscription expiration time (in date-time format) requested by the API
	// consumer.
	SubscriptionExpireTime time.Time `json:"subscriptionExpireTime" format:"date-time"`
	// Identifies the maximum number of event reports to be generated (>=1) requested
	// by the API consumer - Once this number is reached, the subscription ends.
	SubscriptionMaxEvents int64 `json:"subscriptionMaxEvents"`
	// JSON contains metadata for fields, check presence with [respjson.Field.Valid].
	JSON struct {
		SubscriptionDetail     respjson.Field
		InitialEvent           respjson.Field
		SubscriptionExpireTime respjson.Field
		SubscriptionMaxEvents  respjson.Field
		ExtraFields            map[string]respjson.Field
		// contains filtered or unexported fields
	} `json:"-"`
}

Implementation-specific configuration parameters needed by the subscription manager for acquiring events. In CAMARA we have predefined attributes like `subscriptionExpireTime`, `subscriptionMaxEvents`, `initialEvent` Specific event type attributes must be defined in `subscriptionDetail` Note: if a request is performed for several event type, all subscribed event will use same `config` parameters.

func (ConnectedNetworkTypeConfig) RawJSON 

func (r ConnectedNetworkTypeConfig) RawJSON() string

Returns the unmodified JSON received from the API

func (ConnectedNetworkTypeConfig) ToParam 

func (r ConnectedNetworkTypeConfig) ToParam() ConnectedNetworkTypeConfigParam

ToParam converts this ConnectedNetworkTypeConfig to a ConnectedNetworkTypeConfigParam.

Warning: the fields of the param type will not be present. ToParam should only be used at the last possible moment before sending a request. Test for this with ConnectedNetworkTypeConfigParam.Overrides()

func (*ConnectedNetworkTypeConfig) UnmarshalJSON 

func (r *ConnectedNetworkTypeConfig) UnmarshalJSON(data []byte) error

type ConnectedNetworkTypeConfigParam 

type ConnectedNetworkTypeConfigParam struct {
	// The detail of the requested event subscription.
	SubscriptionDetail ConnectedNetworkTypeConfigSubscriptionDetailParam `json:"subscriptionDetail,omitzero" api:"required"`
	// Set to `true` by API consumer if consumer wants to get an event as soon as the
	// subscription is created and current situation reflects event request. Example:
	// Consumer request area entered event. If consumer sets initialEvent to true and
	// device is already in the geofence, an event is triggered
	InitialEvent param.Opt[bool] `json:"initialEvent,omitzero"`
	// The subscription expiration time (in date-time format) requested by the API
	// consumer.
	SubscriptionExpireTime param.Opt[time.Time] `json:"subscriptionExpireTime,omitzero" format:"date-time"`
	// Identifies the maximum number of event reports to be generated (>=1) requested
	// by the API consumer - Once this number is reached, the subscription ends.
	SubscriptionMaxEvents param.Opt[int64] `json:"subscriptionMaxEvents,omitzero"`
	// contains filtered or unexported fields
}

Implementation-specific configuration parameters needed by the subscription manager for acquiring events. In CAMARA we have predefined attributes like `subscriptionExpireTime`, `subscriptionMaxEvents`, `initialEvent` Specific event type attributes must be defined in `subscriptionDetail` Note: if a request is performed for several event type, all subscribed event will use same `config` parameters.

The property SubscriptionDetail is required.

func (ConnectedNetworkTypeConfigParam) MarshalJSON 

func (r ConnectedNetworkTypeConfigParam) MarshalJSON() (data []byte, err error)

func (*ConnectedNetworkTypeConfigParam) UnmarshalJSON 

func (r *ConnectedNetworkTypeConfigParam) UnmarshalJSON(data []byte) error

type ConnectedNetworkTypeConfigSubscriptionDetail 

type ConnectedNetworkTypeConfigSubscriptionDetail struct {
	// End-user equipment able to connect to a mobile network. Examples of devices
	// include smartphones or IoT sensors/actuators.
	//
	// The developer can choose to provide the below specified device identifiers:
	//
	// - `ipv4Address`
	// - `ipv6Address`
	// - `phoneNumber`
	// - `networkAccessIdentifier`
	//
	// NOTE: the MNO might support only a subset of these options. The API invoker can
	// provide multiple identifiers to be compatible across different MNOs. In this
	// case the identifiers MUST belong to the same device.
	Device ConnectedNetworkTypeConfigSubscriptionDetailDevice `json:"device"`
	// JSON contains metadata for fields, check presence with [respjson.Field.Valid].
	JSON struct {
		Device      respjson.Field
		ExtraFields map[string]respjson.Field
		// contains filtered or unexported fields
	} `json:"-"`
}

The detail of the requested event subscription.

func (ConnectedNetworkTypeConfigSubscriptionDetail) RawJSON 

func (r ConnectedNetworkTypeConfigSubscriptionDetail) RawJSON() string

Returns the unmodified JSON received from the API

func (*ConnectedNetworkTypeConfigSubscriptionDetail) UnmarshalJSON 

func (r *ConnectedNetworkTypeConfigSubscriptionDetail) UnmarshalJSON(data []byte) error

type ConnectedNetworkTypeConfigSubscriptionDetailDevice 

type ConnectedNetworkTypeConfigSubscriptionDetailDevice struct {
	// The device should be identified by either the public (observed) IP address and
	// port as seen by the application server, or the private (local) and any public
	// (observed) IP addresses in use by the device (this information can be obtained
	// by various means, for example from some DNS servers).
	//
	// If the allocated and observed IP addresses are the same (i.e. NAT is not in use)
	// then the same address should be specified for both publicAddress and
	// privateAddress.
	//
	// If NAT64 is in use, the device should be identified by its publicAddress and
	// publicPort, or separately by its allocated IPv6 address (field ipv6Address of
	// the Device object)
	//
	// In all cases, publicAddress must be specified, along with at least one of either
	// privateAddress or publicPort, dependent upon which is known. In general, mobile
	// devices cannot be identified by their public IPv4 address alone.
	Ipv4Address ConnectedNetworkTypeConfigSubscriptionDetailDeviceIpv4Address `json:"ipv4Address"`
	// The device should be identified by the observed IPv6 address, or by any single
	// IPv6 address from within the subnet allocated to the device (e.g. adding ::0 to
	// the /64 prefix).
	Ipv6Address string `json:"ipv6Address" format:"ipv6"`
	// A public identifier addressing a subscription in a mobile network. In 3GPP
	// terminology, it corresponds to the GPSI formatted with the External Identifier
	// ({Local Identifier}@{Domain Identifier}). Unlike the telephone number, the
	// network access identifier is not subjected to portability ruling in force, and
	// is individually managed by each operator.
	NetworkAccessIdentifier string `json:"networkAccessIdentifier"`
	// A public identifier addressing a telephone subscription. In mobile networks it
	// corresponds to the MSISDN (Mobile Station International Subscriber Directory
	// Number). In order to be globally unique it has to be formatted in international
	// format, according to E.164 standard, prefixed with '+'.
	PhoneNumber string `json:"phoneNumber"`
	// JSON contains metadata for fields, check presence with [respjson.Field.Valid].
	JSON struct {
		Ipv4Address             respjson.Field
		Ipv6Address             respjson.Field
		NetworkAccessIdentifier respjson.Field
		PhoneNumber             respjson.Field
		ExtraFields             map[string]respjson.Field
		// contains filtered or unexported fields
	} `json:"-"`
}

End-user equipment able to connect to a mobile network. Examples of devices include smartphones or IoT sensors/actuators.

The developer can choose to provide the below specified device identifiers:

- `ipv4Address` - `ipv6Address` - `phoneNumber` - `networkAccessIdentifier`

NOTE: the MNO might support only a subset of these options. The API invoker can provide multiple identifiers to be compatible across different MNOs. In this case the identifiers MUST belong to the same device.

func (ConnectedNetworkTypeConfigSubscriptionDetailDevice) RawJSON 

func (r ConnectedNetworkTypeConfigSubscriptionDetailDevice) RawJSON() string

Returns the unmodified JSON received from the API

func (*ConnectedNetworkTypeConfigSubscriptionDetailDevice) UnmarshalJSON 

func (r *ConnectedNetworkTypeConfigSubscriptionDetailDevice) UnmarshalJSON(data []byte) error

type ConnectedNetworkTypeConfigSubscriptionDetailDeviceIpv4Address 

type ConnectedNetworkTypeConfigSubscriptionDetailDeviceIpv4Address struct {
	// A single IPv4 address with no subnet mask
	PrivateAddress string `json:"privateAddress" format:"ipv4"`
	// A single IPv4 address with no subnet mask
	PublicAddress string `json:"publicAddress" format:"ipv4"`
	// TCP or UDP port number
	PublicPort int64 `json:"publicPort"`
	// JSON contains metadata for fields, check presence with [respjson.Field.Valid].
	JSON struct {
		PrivateAddress respjson.Field
		PublicAddress  respjson.Field
		PublicPort     respjson.Field
		ExtraFields    map[string]respjson.Field
		// contains filtered or unexported fields
	} `json:"-"`
}

The device should be identified by either the public (observed) IP address and port as seen by the application server, or the private (local) and any public (observed) IP addresses in use by the device (this information can be obtained by various means, for example from some DNS servers).

If the allocated and observed IP addresses are the same (i.e. NAT is not in use) then the same address should be specified for both publicAddress and privateAddress.

If NAT64 is in use, the device should be identified by its publicAddress and publicPort, or separately by its allocated IPv6 address (field ipv6Address of the Device object)

In all cases, publicAddress must be specified, along with at least one of either privateAddress or publicPort, dependent upon which is known. In general, mobile devices cannot be identified by their public IPv4 address alone.

func (ConnectedNetworkTypeConfigSubscriptionDetailDeviceIpv4Address) RawJSON 

func (r ConnectedNetworkTypeConfigSubscriptionDetailDeviceIpv4Address) RawJSON() string

Returns the unmodified JSON received from the API

func (*ConnectedNetworkTypeConfigSubscriptionDetailDeviceIpv4Address) UnmarshalJSON 

func (r *ConnectedNetworkTypeConfigSubscriptionDetailDeviceIpv4Address) UnmarshalJSON(data []byte) error

type ConnectedNetworkTypeConfigSubscriptionDetailDeviceIpv4AddressParam 

type ConnectedNetworkTypeConfigSubscriptionDetailDeviceIpv4AddressParam struct {
	// A single IPv4 address with no subnet mask
	PrivateAddress param.Opt[string] `json:"privateAddress,omitzero" format:"ipv4"`
	// A single IPv4 address with no subnet mask
	PublicAddress param.Opt[string] `json:"publicAddress,omitzero" format:"ipv4"`
	// TCP or UDP port number
	PublicPort param.Opt[int64] `json:"publicPort,omitzero"`
	// contains filtered or unexported fields
}

The device should be identified by either the public (observed) IP address and port as seen by the application server, or the private (local) and any public (observed) IP addresses in use by the device (this information can be obtained by various means, for example from some DNS servers).

If the allocated and observed IP addresses are the same (i.e. NAT is not in use) then the same address should be specified for both publicAddress and privateAddress.

If NAT64 is in use, the device should be identified by its publicAddress and publicPort, or separately by its allocated IPv6 address (field ipv6Address of the Device object)

In all cases, publicAddress must be specified, along with at least one of either privateAddress or publicPort, dependent upon which is known. In general, mobile devices cannot be identified by their public IPv4 address alone.

func (ConnectedNetworkTypeConfigSubscriptionDetailDeviceIpv4AddressParam) MarshalJSON 

func (r ConnectedNetworkTypeConfigSubscriptionDetailDeviceIpv4AddressParam) MarshalJSON() (data []byte, err error)

func (*ConnectedNetworkTypeConfigSubscriptionDetailDeviceIpv4AddressParam) UnmarshalJSON 

func (r *ConnectedNetworkTypeConfigSubscriptionDetailDeviceIpv4AddressParam) UnmarshalJSON(data []byte) error

type ConnectedNetworkTypeConfigSubscriptionDetailDeviceParam 

type ConnectedNetworkTypeConfigSubscriptionDetailDeviceParam struct {
	// The device should be identified by the observed IPv6 address, or by any single
	// IPv6 address from within the subnet allocated to the device (e.g. adding ::0 to
	// the /64 prefix).
	Ipv6Address param.Opt[string] `json:"ipv6Address,omitzero" format:"ipv6"`
	// A public identifier addressing a subscription in a mobile network. In 3GPP
	// terminology, it corresponds to the GPSI formatted with the External Identifier
	// ({Local Identifier}@{Domain Identifier}). Unlike the telephone number, the
	// network access identifier is not subjected to portability ruling in force, and
	// is individually managed by each operator.
	NetworkAccessIdentifier param.Opt[string] `json:"networkAccessIdentifier,omitzero"`
	// A public identifier addressing a telephone subscription. In mobile networks it
	// corresponds to the MSISDN (Mobile Station International Subscriber Directory
	// Number). In order to be globally unique it has to be formatted in international
	// format, according to E.164 standard, prefixed with '+'.
	PhoneNumber param.Opt[string] `json:"phoneNumber,omitzero"`
	// The device should be identified by either the public (observed) IP address and
	// port as seen by the application server, or the private (local) and any public
	// (observed) IP addresses in use by the device (this information can be obtained
	// by various means, for example from some DNS servers).
	//
	// If the allocated and observed IP addresses are the same (i.e. NAT is not in use)
	// then the same address should be specified for both publicAddress and
	// privateAddress.
	//
	// If NAT64 is in use, the device should be identified by its publicAddress and
	// publicPort, or separately by its allocated IPv6 address (field ipv6Address of
	// the Device object)
	//
	// In all cases, publicAddress must be specified, along with at least one of either
	// privateAddress or publicPort, dependent upon which is known. In general, mobile
	// devices cannot be identified by their public IPv4 address alone.
	Ipv4Address ConnectedNetworkTypeConfigSubscriptionDetailDeviceIpv4AddressParam `json:"ipv4Address,omitzero"`
	// contains filtered or unexported fields
}

End-user equipment able to connect to a mobile network. Examples of devices include smartphones or IoT sensors/actuators.

The developer can choose to provide the below specified device identifiers:

- `ipv4Address` - `ipv6Address` - `phoneNumber` - `networkAccessIdentifier`

NOTE: the MNO might support only a subset of these options. The API invoker can provide multiple identifiers to be compatible across different MNOs. In this case the identifiers MUST belong to the same device.

func (ConnectedNetworkTypeConfigSubscriptionDetailDeviceParam) MarshalJSON 

func (r ConnectedNetworkTypeConfigSubscriptionDetailDeviceParam) MarshalJSON() (data []byte, err error)

func (*ConnectedNetworkTypeConfigSubscriptionDetailDeviceParam) UnmarshalJSON 

func (r *ConnectedNetworkTypeConfigSubscriptionDetailDeviceParam) UnmarshalJSON(data []byte) error

type ConnectedNetworkTypeConfigSubscriptionDetailParam 

type ConnectedNetworkTypeConfigSubscriptionDetailParam struct {
	// End-user equipment able to connect to a mobile network. Examples of devices
	// include smartphones or IoT sensors/actuators.
	//
	// The developer can choose to provide the below specified device identifiers:
	//
	// - `ipv4Address`
	// - `ipv6Address`
	// - `phoneNumber`
	// - `networkAccessIdentifier`
	//
	// NOTE: the MNO might support only a subset of these options. The API invoker can
	// provide multiple identifiers to be compatible across different MNOs. In this
	// case the identifiers MUST belong to the same device.
	Device ConnectedNetworkTypeConfigSubscriptionDetailDeviceParam `json:"device,omitzero"`
	// contains filtered or unexported fields
}

The detail of the requested event subscription.

func (ConnectedNetworkTypeConfigSubscriptionDetailParam) MarshalJSON 

func (r ConnectedNetworkTypeConfigSubscriptionDetailParam) MarshalJSON() (data []byte, err error)

func (*ConnectedNetworkTypeConfigSubscriptionDetailParam) UnmarshalJSON 

func (r *ConnectedNetworkTypeConfigSubscriptionDetailParam) UnmarshalJSON(data []byte) error

type ConnectedNetworkTypeProtocol 

type ConnectedNetworkTypeProtocol string

Identifier of a delivery protocol. Only HTTP is allowed for now 

const (
	ConnectedNetworkTypeProtocolHTTP  ConnectedNetworkTypeProtocol = "HTTP"
	ConnectedNetworkTypeProtocolMqtt3 ConnectedNetworkTypeProtocol = "MQTT3"
	ConnectedNetworkTypeProtocolMqtt5 ConnectedNetworkTypeProtocol = "MQTT5"
	ConnectedNetworkTypeProtocolAmqp  ConnectedNetworkTypeProtocol = "AMQP"
	ConnectedNetworkTypeProtocolNats  ConnectedNetworkTypeProtocol = "NATS"
	ConnectedNetworkTypeProtocolKafka ConnectedNetworkTypeProtocol = "KAFKA"
)

type ConnectedNetworkTypeSubscription 

type ConnectedNetworkTypeSubscription struct {
	// The unique identifier of the subscription in the scope of the subscription
	// manager. When this information is contained within an event notification, this
	// concept SHALL be referred as subscriptionId as per Commonalities Event
	// Notification Model.
	ID string `json:"id" api:"required"`
	// Implementation-specific configuration parameters needed by the subscription
	// manager for acquiring events. In CAMARA we have predefined attributes like
	// `subscriptionExpireTime`, `subscriptionMaxEvents`, `initialEvent` Specific event
	// type attributes must be defined in `subscriptionDetail` Note: if a request is
	// performed for several event type, all subscribed event will use same `config`
	// parameters.
	Config ConnectedNetworkTypeConfig `json:"config" api:"required"`
	// Identifier of a delivery protocol. Only HTTP is allowed for now
	//
	// Any of "HTTP", "MQTT3", "MQTT5", "AMQP", "NATS", "KAFKA".
	Protocol ConnectedNetworkTypeProtocol `json:"protocol" api:"required"`
	// The address to which events shall be delivered using the selected protocol.
	Sink string `json:"sink" api:"required" format:"uri"`
	// Camara Event types eligible to be delivered by this subscription. Note: For the
	// current Commonalities API design guidelines, only one event type per
	// subscription is allowed
	Types []ConnectedNetworkTypeSubscriptionEventType `json:"types" api:"required"`
	// Date when the event subscription will expire. Only provided when
	// `subscriptionExpireTime` is indicated by API client or Telco Operator has
	// specific policy about that. It must follow
	// [RFC 3339](https://datatracker.ietf.org/doc/html/rfc3339#section-5.6) and must
	// have time zone. Recommended format is yyyy-MM-dd'T'HH:mm:ss.SSSZ (i.e. which
	// allows 2023-07-03T14:27:08.312+02:00 or 2023-07-03T12:27:08.312Z)
	ExpiresAt time.Time `json:"expiresAt" format:"date-time"`
	// Date when the event subscription will begin/began It must follow
	// [RFC 3339](https://datatracker.ietf.org/doc/html/rfc3339#section-5.6) and must
	// have time zone. Recommended format is yyyy-MM-dd'T'HH:mm:ss.SSSZ (i.e. which
	// allows 2023-07-03T14:27:08.312+02:00 or 2023-07-03T12:27:08.312Z)
	StartsAt time.Time `json:"startsAt" format:"date-time"`
	// Current status of the subscription - Management of Subscription State engine is
	// not mandatory for now. Note not all statuses may be considered to be
	// implemented. Details:
	//
	//   - `ACTIVATION_REQUESTED`: Subscription creation (POST) is triggered but
	//     subscription creation process is not finished yet.
	//   - `ACTIVE`: Subscription creation process is completed. Subscription is fully
	//     operative.
	//   - `INACTIVE`: Subscription is temporarily inactive, but its workflow logic is
	//     not deleted.
	//   - `EXPIRED`: Subscription is ended (no longer active). This status applies when
	//     subscription is ended due to `SUBSCRIPTION_EXPIRED` or `ACCESS_TOKEN_EXPIRED`
	//     event.
	//   - `DELETED`: Subscription is ended as deleted (no longer active). This status
	//     applies when subscription information is kept (i.e. subscription workflow is
	//     no longer active but its meta-information is kept).
	//
	// Any of "ACTIVATION_REQUESTED", "ACTIVE", "EXPIRED", "INACTIVE", "DELETED".
	Status ConnectedNetworkTypeSubscriptionStatus `json:"status"`
	// JSON contains metadata for fields, check presence with [respjson.Field.Valid].
	JSON struct {
		ID          respjson.Field
		Config      respjson.Field
		Protocol    respjson.Field
		Sink        respjson.Field
		Types       respjson.Field
		ExpiresAt   respjson.Field
		StartsAt    respjson.Field
		Status      respjson.Field
		ExtraFields map[string]respjson.Field
		// contains filtered or unexported fields
	} `json:"-"`
}

Represents a event-type subscription.

func (ConnectedNetworkTypeSubscription) RawJSON 

func (r ConnectedNetworkTypeSubscription) RawJSON() string

Returns the unmodified JSON received from the API

func (*ConnectedNetworkTypeSubscription) UnmarshalJSON 

func (r *ConnectedNetworkTypeSubscription) UnmarshalJSON(data []byte) error

type ConnectedNetworkTypeSubscriptionEventType 

type ConnectedNetworkTypeSubscriptionEventType string

network-type-changed - Event triggered when the connected network type of the device changes. 

const (
	ConnectedNetworkTypeSubscriptionEventTypeOrgCamaraprojectConnectedNetworkTypeSubscriptionsV0NetworkTypeChanged ConnectedNetworkTypeSubscriptionEventType = "org.camaraproject.connected-network-type-subscriptions.v0.network-type-changed"
)

type ConnectedNetworkTypeSubscriptionStatus 

type ConnectedNetworkTypeSubscriptionStatus string

Current status of the subscription - Management of Subscription State engine is not mandatory for now. Note not all statuses may be considered to be implemented. Details:

  • `ACTIVATION_REQUESTED`: Subscription creation (POST) is triggered but subscription creation process is not finished yet.
  • `ACTIVE`: Subscription creation process is completed. Subscription is fully operative.
  • `INACTIVE`: Subscription is temporarily inactive, but its workflow logic is not deleted.
  • `EXPIRED`: Subscription is ended (no longer active). This status applies when subscription is ended due to `SUBSCRIPTION_EXPIRED` or `ACCESS_TOKEN_EXPIRED` event.
  • `DELETED`: Subscription is ended as deleted (no longer active). This status applies when subscription information is kept (i.e. subscription workflow is no longer active but its meta-information is kept).
const (
	ConnectedNetworkTypeSubscriptionStatusActivationRequested ConnectedNetworkTypeSubscriptionStatus = "ACTIVATION_REQUESTED"
	ConnectedNetworkTypeSubscriptionStatusActive              ConnectedNetworkTypeSubscriptionStatus = "ACTIVE"
	ConnectedNetworkTypeSubscriptionStatusExpired             ConnectedNetworkTypeSubscriptionStatus = "EXPIRED"
	ConnectedNetworkTypeSubscriptionStatusInactive            ConnectedNetworkTypeSubscriptionStatus = "INACTIVE"
	ConnectedNetworkTypeSubscriptionStatusDeleted             ConnectedNetworkTypeSubscriptionStatus = "DELETED"
)

type ConnectednetworktypeService 

type ConnectednetworktypeService struct {
	Options []option.RequestOption
	// Connected Network Type Subscriptions
	Subscriptions ConnectednetworktypeSubscriptionService
}

ConnectednetworktypeService contains methods and other services that help with interacting with the camara API.

Note, unlike clients, this service does not read variables from the environment automatically. You should not instantiate this service directly, and instead use the NewConnectednetworktypeService method instead.

func NewConnectednetworktypeService 

func NewConnectednetworktypeService(opts ...option.RequestOption) (r ConnectednetworktypeService)

NewConnectednetworktypeService generates a new service that applies the given options to each request. These options are applied after the parent client's options (if there is one), and before any request-specific options.

type ConnectednetworktypeSubscriptionDeleteParams 

type ConnectednetworktypeSubscriptionDeleteParams struct {
	XCorrelator param.Opt[string] `header:"x-correlator,omitzero" json:"-"`
	// contains filtered or unexported fields
}

type ConnectednetworktypeSubscriptionDeleteResponse 

type ConnectednetworktypeSubscriptionDeleteResponse struct {
	// The unique identifier of the subscription in the scope of the subscription
	// manager. When this information is contained within an event notification, this
	// concept SHALL be referred as subscriptionId as per Commonalities Event
	// Notification Model.
	ID string `json:"id" api:"required"`
	// JSON contains metadata for fields, check presence with [respjson.Field.Valid].
	JSON struct {
		ID          respjson.Field
		ExtraFields map[string]respjson.Field
		// contains filtered or unexported fields
	} `json:"-"`
}

Response for a event-type subscription request managed asynchronously (Creation or Deletion)

func (ConnectednetworktypeSubscriptionDeleteResponse) RawJSON 

func (r ConnectednetworktypeSubscriptionDeleteResponse) RawJSON() string

Returns the unmodified JSON received from the API

func (*ConnectednetworktypeSubscriptionDeleteResponse) UnmarshalJSON 

func (r *ConnectednetworktypeSubscriptionDeleteResponse) UnmarshalJSON(data []byte) error

type ConnectednetworktypeSubscriptionGetParams 

type ConnectednetworktypeSubscriptionGetParams struct {
	XCorrelator param.Opt[string] `header:"x-correlator,omitzero" json:"-"`
	// contains filtered or unexported fields
}

type ConnectednetworktypeSubscriptionListParams 

type ConnectednetworktypeSubscriptionListParams struct {
	XCorrelator param.Opt[string] `header:"x-correlator,omitzero" json:"-"`
	// contains filtered or unexported fields
}

type ConnectednetworktypeSubscriptionNewParams 

type ConnectednetworktypeSubscriptionNewParams struct {
	// Implementation-specific configuration parameters needed by the subscription
	// manager for acquiring events. In CAMARA we have predefined attributes like
	// `subscriptionExpireTime`, `subscriptionMaxEvents`, `initialEvent` Specific event
	// type attributes must be defined in `subscriptionDetail` Note: if a request is
	// performed for several event type, all subscribed event will use same `config`
	// parameters.
	Config ConnectedNetworkTypeConfigParam `json:"config,omitzero" api:"required"`
	// Identifier of a delivery protocol. Only HTTP is allowed for now
	//
	// Any of "HTTP", "MQTT3", "MQTT5", "AMQP", "NATS", "KAFKA".
	Protocol ConnectedNetworkTypeProtocol `json:"protocol,omitzero" api:"required"`
	// The address to which events shall be delivered using the selected protocol.
	Sink string `json:"sink" api:"required" format:"uri"`
	// Camara Event types eligible to be delivered by this subscription. Note: As of
	// now we enforce to have only event type per subscription.
	Types       []ConnectedNetworkTypeSubscriptionEventType `json:"types,omitzero" api:"required"`
	XCorrelator param.Opt[string]                           `header:"x-correlator,omitzero" json:"-"`
	// A sink credential provides authentication or authorization information necessary
	// to enable delivery of events to a target.
	SinkCredential ConnectednetworktypeSubscriptionNewParamsSinkCredential `json:"sinkCredential,omitzero"`
	// contains filtered or unexported fields
}

func (ConnectednetworktypeSubscriptionNewParams) MarshalJSON 

func (r ConnectednetworktypeSubscriptionNewParams) MarshalJSON() (data []byte, err error)

func (*ConnectednetworktypeSubscriptionNewParams) UnmarshalJSON 

func (r *ConnectednetworktypeSubscriptionNewParams) UnmarshalJSON(data []byte) error

type ConnectednetworktypeSubscriptionNewParamsSinkCredential 

type ConnectednetworktypeSubscriptionNewParamsSinkCredential struct {
	// The type of the credential. Note: Type of the credential - MUST be set to
	// ACCESSTOKEN for now
	//
	// Any of "PLAIN", "ACCESSTOKEN", "REFRESHTOKEN".
	CredentialType string `json:"credentialType,omitzero" api:"required"`
	// contains filtered or unexported fields
}

A sink credential provides authentication or authorization information necessary to enable delivery of events to a target.

The property CredentialType is required.

func (ConnectednetworktypeSubscriptionNewParamsSinkCredential) MarshalJSON 

func (r ConnectednetworktypeSubscriptionNewParamsSinkCredential) MarshalJSON() (data []byte, err error)

func (*ConnectednetworktypeSubscriptionNewParamsSinkCredential) UnmarshalJSON 

func (r *ConnectednetworktypeSubscriptionNewParamsSinkCredential) UnmarshalJSON(data []byte) error

type ConnectednetworktypeSubscriptionService 

type ConnectednetworktypeSubscriptionService struct {
	Options []option.RequestOption
}

Connected Network Type Subscriptions

ConnectednetworktypeSubscriptionService contains methods and other services that help with interacting with the camara API.

Note, unlike clients, this service does not read variables from the environment automatically. You should not instantiate this service directly, and instead use the NewConnectednetworktypeSubscriptionService method instead.

func NewConnectednetworktypeSubscriptionService 

func NewConnectednetworktypeSubscriptionService(opts ...option.RequestOption) (r ConnectednetworktypeSubscriptionService)

NewConnectednetworktypeSubscriptionService generates a new service that applies the given options to each request. These options are applied after the parent client's options (if there is one), and before any request-specific options.

func (*ConnectednetworktypeSubscriptionService) Delete 

func (r *ConnectednetworktypeSubscriptionService) Delete(ctx context.Context, subscriptionID string, body ConnectednetworktypeSubscriptionDeleteParams, opts ...option.RequestOption) (res *ConnectednetworktypeSubscriptionDeleteResponse, err error)

delete a given ConnectedNetworkType subscription.

func (*ConnectednetworktypeSubscriptionService) Get 

func (r *ConnectednetworktypeSubscriptionService) Get(ctx context.Context, subscriptionID string, query ConnectednetworktypeSubscriptionGetParams, opts ...option.RequestOption) (res *ConnectedNetworkTypeSubscription, err error)

retrieve ConnectedNetworkType subscription information for a given subscription ID.

func (*ConnectednetworktypeSubscriptionService) List 

func (r *ConnectednetworktypeSubscriptionService) List(ctx context.Context, query ConnectednetworktypeSubscriptionListParams, opts ...option.RequestOption) (res *[]ConnectedNetworkTypeSubscription, err error)

Retrieve a list of device connected network type event subscription(s)

func (*ConnectednetworktypeSubscriptionService) New 

func (r *ConnectednetworktypeSubscriptionService) New(ctx context.Context, params ConnectednetworktypeSubscriptionNewParams, opts ...option.RequestOption) (res *ConnectedNetworkTypeSubscription, err error)

Create a subscription for receiving notifications on changes to the connected network type of a device.

type ConnectivityinsightService 

type ConnectivityinsightService struct {
	Options []option.RequestOption
	// Connectivity Insights Subscriptions
	Subscriptions ConnectivityinsightSubscriptionService
}

ConnectivityinsightService contains methods and other services that help with interacting with the camara API.

Note, unlike clients, this service does not read variables from the environment automatically. You should not instantiate this service directly, and instead use the NewConnectivityinsightService method instead.

func NewConnectivityinsightService 

func NewConnectivityinsightService(opts ...option.RequestOption) (r ConnectivityinsightService)

NewConnectivityinsightService generates a new service that applies the given options to each request. These options are applied after the parent client's options (if there is one), and before any request-specific options.

type ConnectivityinsightSubscriptionDeleteParams 

type ConnectivityinsightSubscriptionDeleteParams struct {
	XCorrelator param.Opt[string] `header:"x-correlator,omitzero" json:"-"`
	// contains filtered or unexported fields
}

type ConnectivityinsightSubscriptionDeleteResponse 

type ConnectivityinsightSubscriptionDeleteResponse struct {
	// When this information is contained within an event notification, it SHALL be
	// referred to as `subscriptionId` as per the Commonalities Event Notification
	// Model.
	SubscriptionID string `json:"subscriptionId"`
	// JSON contains metadata for fields, check presence with [respjson.Field.Valid].
	JSON struct {
		SubscriptionID respjson.Field
		ExtraFields    map[string]respjson.Field
		// contains filtered or unexported fields
	} `json:"-"`
}

Response for a event-type subscription request managed asynchronously (Creation or Deletion)

func (ConnectivityinsightSubscriptionDeleteResponse) RawJSON 

func (r ConnectivityinsightSubscriptionDeleteResponse) RawJSON() string

Returns the unmodified JSON received from the API

func (*ConnectivityinsightSubscriptionDeleteResponse) UnmarshalJSON 

func (r *ConnectivityinsightSubscriptionDeleteResponse) UnmarshalJSON(data []byte) error

type ConnectivityinsightSubscriptionGetParams 

type ConnectivityinsightSubscriptionGetParams struct {
	XCorrelator param.Opt[string] `header:"x-correlator,omitzero" json:"-"`
	// contains filtered or unexported fields
}

type ConnectivityinsightSubscriptionListParams 

type ConnectivityinsightSubscriptionListParams struct {
	XCorrelator param.Opt[string] `header:"x-correlator,omitzero" json:"-"`
	// contains filtered or unexported fields
}

type ConnectivityinsightSubscriptionNewParams 

type ConnectivityinsightSubscriptionNewParams struct {
	// Implementation-specific configuration parameters needed by the subscription
	// manager for acquiring events. In CAMARA we have predefined attributes like
	// `subscriptionExpireTime`, `subscriptionMaxEvents`, `initialEvent` Specific event
	// type attributes must be defined in `subscriptionDetail` Note: if a request is
	// performed for several event type, all subscribed event will use same `config`
	// parameters.
	Config ConfigParam `json:"config,omitzero" api:"required"`
	// Identifier of a delivery protocol. Only HTTP is allowed for now
	//
	// Any of "HTTP", "MQTT3", "MQTT5", "AMQP", "NATS", "KAFKA".
	Protocol Protocol `json:"protocol,omitzero" api:"required"`
	// The address to which events shall be delivered using the selected protocol.
	Sink string `json:"sink" api:"required" format:"uri"`
	// Camara Event types eligible to be delivered by this subscription.
	Types       []EventType       `json:"types,omitzero" api:"required"`
	XCorrelator param.Opt[string] `header:"x-correlator,omitzero" json:"-"`
	// A sink credential provides authentication or authorization information
	SinkCredential ConnectivityinsightSubscriptionNewParamsSinkCredential `json:"sinkCredential,omitzero"`
	// contains filtered or unexported fields
}

func (ConnectivityinsightSubscriptionNewParams) MarshalJSON 

func (r ConnectivityinsightSubscriptionNewParams) MarshalJSON() (data []byte, err error)

func (*ConnectivityinsightSubscriptionNewParams) UnmarshalJSON 

func (r *ConnectivityinsightSubscriptionNewParams) UnmarshalJSON(data []byte) error

type ConnectivityinsightSubscriptionNewParamsSinkCredential 

type ConnectivityinsightSubscriptionNewParamsSinkCredential struct {
	// The type of the credential. Note: Type of the credential - MUST be set to
	// ACCESSTOKEN for now
	//
	// Any of "PLAIN", "ACCESSTOKEN", "REFRESHTOKEN".
	CredentialType string `json:"credentialType,omitzero" api:"required"`
	// contains filtered or unexported fields
}

A sink credential provides authentication or authorization information

The property CredentialType is required.

func (ConnectivityinsightSubscriptionNewParamsSinkCredential) MarshalJSON 

func (r ConnectivityinsightSubscriptionNewParamsSinkCredential) MarshalJSON() (data []byte, err error)

func (*ConnectivityinsightSubscriptionNewParamsSinkCredential) UnmarshalJSON 

func (r *ConnectivityinsightSubscriptionNewParamsSinkCredential) UnmarshalJSON(data []byte) error

type ConnectivityinsightSubscriptionService 

type ConnectivityinsightSubscriptionService struct {
	Options []option.RequestOption
}

Connectivity Insights Subscriptions

ConnectivityinsightSubscriptionService contains methods and other services that help with interacting with the camara API.

Note, unlike clients, this service does not read variables from the environment automatically. You should not instantiate this service directly, and instead use the NewConnectivityinsightSubscriptionService method instead.

func NewConnectivityinsightSubscriptionService 

func NewConnectivityinsightSubscriptionService(opts ...option.RequestOption) (r ConnectivityinsightSubscriptionService)

NewConnectivityinsightSubscriptionService generates a new service that applies the given options to each request. These options are applied after the parent client's options (if there is one), and before any request-specific options.

func (*ConnectivityinsightSubscriptionService) Delete 

func (r *ConnectivityinsightSubscriptionService) Delete(ctx context.Context, subscriptionID string, body ConnectivityinsightSubscriptionDeleteParams, opts ...option.RequestOption) (res *ConnectivityinsightSubscriptionDeleteResponse, err error)

Delete a given subscription by ID

func (*ConnectivityinsightSubscriptionService) Get 

func (r *ConnectivityinsightSubscriptionService) Get(ctx context.Context, subscriptionID string, query ConnectivityinsightSubscriptionGetParams, opts ...option.RequestOption) (res *Subscription, err error)

Retrieve a given subscription by ID

func (*ConnectivityinsightSubscriptionService) List 

func (r *ConnectivityinsightSubscriptionService) List(ctx context.Context, query ConnectivityinsightSubscriptionListParams, opts ...option.RequestOption) (res *[]Subscription, err error)

Operation to list subscriptions authorized to be retrieved by the provided access token.

func (*ConnectivityinsightSubscriptionService) New 

func (r *ConnectivityinsightSubscriptionService) New(ctx context.Context, params ConnectivityinsightSubscriptionNewParams, opts ...option.RequestOption) (res *Subscription, err error)

Create a Connectivity insights subscription for a device

type CreateCallForwardingSignalParam 

type CreateCallForwardingSignalParam struct {
	// A public identifier addressing a telephone subscription. In mobile networks it
	// corresponds to the MSISDN (Mobile Station International Subscriber Directory
	// Number). In order to be globally unique it has to be formatted in international
	// format, according to E.164 standard, prefixed with '+'.
	PhoneNumber param.Opt[string] `json:"phoneNumber,omitzero"`
	// contains filtered or unexported fields
}

resource containing the phone number (PhoneNumber) regarding which the Call Forwarding Service must be checked. To be provided/valued only in case of two-legged authentication. If provided/valued with three-legged authentication a 422-UNNECESSARY_IDENTIFIER error code is returned.

func (CreateCallForwardingSignalParam) MarshalJSON 

func (r CreateCallForwardingSignalParam) MarshalJSON() (data []byte, err error)

func (*CreateCallForwardingSignalParam) UnmarshalJSON 

func (r *CreateCallForwardingSignalParam) UnmarshalJSON(data []byte) error

type CustomerinsightScoringGetParams 

type CustomerinsightScoringGetParams struct {
	// Identification number associated to the official identity document in the
	// country. It may contain alphanumeric characters.
	IDDocument param.Opt[string] `json:"idDocument,omitzero"`
	// A public identifier addressing a telephone subscription. In mobile networks it
	// corresponds to the MSISDN (Mobile Station International Subscriber Directory
	// Number). In order to be globally unique it has to be formatted in international
	// format, according to E.164 standard, prefixed with '+'.
	PhoneNumber param.Opt[string] `json:"phoneNumber,omitzero"`
	XCorrelator param.Opt[string] `header:"x-correlator,omitzero" json:"-"`
	// Scoring type, i.e.: scale. API Client may use this field to indicate the Scoring
	// in one of the defined scales; if this field is not informed, the API will return
	// the Scoring in the scale configured by default in the system.
	//
	// Allowed values are:
	//
	// - `gaugeMetric`: ranges from index 850 (lowest risk) to index 300 (highest risk)
	// - `veritasIndex`: ranges from index 0 (lowest risk) to index 19 (highest risk)
	//
	// Any of "gaugeMetric", "veritasIndex".
	ScoringType CustomerinsightScoringGetParamsScoringType `json:"scoringType,omitzero"`
	// contains filtered or unexported fields
}

func (CustomerinsightScoringGetParams) MarshalJSON 

func (r CustomerinsightScoringGetParams) MarshalJSON() (data []byte, err error)

func (*CustomerinsightScoringGetParams) UnmarshalJSON 

func (r *CustomerinsightScoringGetParams) UnmarshalJSON(data []byte) error

type CustomerinsightScoringGetParamsScoringType 

type CustomerinsightScoringGetParamsScoringType string

Scoring type, i.e.: scale. API Client may use this field to indicate the Scoring in one of the defined scales; if this field is not informed, the API will return the Scoring in the scale configured by default in the system.

Allowed values are:

- `gaugeMetric`: ranges from index 850 (lowest risk) to index 300 (highest risk) - `veritasIndex`: ranges from index 0 (lowest risk) to index 19 (highest risk) 

const (
	CustomerinsightScoringGetParamsScoringTypeGaugeMetric  CustomerinsightScoringGetParamsScoringType = "gaugeMetric"
	CustomerinsightScoringGetParamsScoringTypeVeritasIndex CustomerinsightScoringGetParamsScoringType = "veritasIndex"
)

type CustomerinsightScoringGetResponse 

type CustomerinsightScoringGetResponse struct {
	// Scoring measurement system.
	//
	// Allowed values are:
	//
	// - `gaugeMetric`: ranges from index 850 (lowest risk) to index 300 (highest risk)
	// - `veritasIndex`: ranges from index 0 (lowest risk) to index 19 (highest risk)
	//
	// Any of "gaugeMetric", "veritasIndex".
	ScoringType CustomerinsightScoringGetResponseScoringType `json:"scoringType" api:"required"`
	// Result of the Scoring analysis expressed in the measure indicated in the
	// `scoringType` field.
	ScoringValue int64 `json:"scoringValue" api:"required"`
	// JSON contains metadata for fields, check presence with [respjson.Field.Valid].
	JSON struct {
		ScoringType  respjson.Field
		ScoringValue respjson.Field
		ExtraFields  map[string]respjson.Field
		// contains filtered or unexported fields
	} `json:"-"`
}

Scoring information based on the individual's profile owned by a Telco Operator.

func (CustomerinsightScoringGetResponse) RawJSON 

func (r CustomerinsightScoringGetResponse) RawJSON() string

Returns the unmodified JSON received from the API

func (*CustomerinsightScoringGetResponse) UnmarshalJSON 

func (r *CustomerinsightScoringGetResponse) UnmarshalJSON(data []byte) error

type CustomerinsightScoringGetResponseScoringType 

type CustomerinsightScoringGetResponseScoringType string

Scoring measurement system.

Allowed values are:

- `gaugeMetric`: ranges from index 850 (lowest risk) to index 300 (highest risk) - `veritasIndex`: ranges from index 0 (lowest risk) to index 19 (highest risk) 

const (
	CustomerinsightScoringGetResponseScoringTypeGaugeMetric  CustomerinsightScoringGetResponseScoringType = "gaugeMetric"
	CustomerinsightScoringGetResponseScoringTypeVeritasIndex CustomerinsightScoringGetResponseScoringType = "veritasIndex"
)

type CustomerinsightScoringService 

type CustomerinsightScoringService struct {
	Options []option.RequestOption
}

Customer Insights

CustomerinsightScoringService contains methods and other services that help with interacting with the camara API.

Note, unlike clients, this service does not read variables from the environment automatically. You should not instantiate this service directly, and instead use the NewCustomerinsightScoringService method instead.

func NewCustomerinsightScoringService 

func NewCustomerinsightScoringService(opts ...option.RequestOption) (r CustomerinsightScoringService)

NewCustomerinsightScoringService generates a new service that applies the given options to each request. These options are applied after the parent client's options (if there is one), and before any request-specific options.

func (*CustomerinsightScoringService) Get 

func (r *CustomerinsightScoringService) Get(ctx context.Context, params CustomerinsightScoringGetParams, opts ...option.RequestOption) (res *CustomerinsightScoringGetResponse, err error)

Retrieves Scoring information, for the user associated with the provided `idDocument`, `phoneNumber` or the combination of both parameters. It also allows to select the type of the Scoring scale measurement.

type CustomerinsightService 

type CustomerinsightService struct {
	Options []option.RequestOption
	// Customer Insights
	Scoring CustomerinsightScoringService
}

CustomerinsightService contains methods and other services that help with interacting with the camara API.

Note, unlike clients, this service does not read variables from the environment automatically. You should not instantiate this service directly, and instead use the NewCustomerinsightService method instead.

func NewCustomerinsightService 

func NewCustomerinsightService(opts ...option.RequestOption) (r CustomerinsightService)

NewCustomerinsightService generates a new service that applies the given options to each request. These options are applied after the parent client's options (if there is one), and before any request-specific options.

type DeviceIdentifierDevice 

type DeviceIdentifierDevice struct {
	// The device should be identified by either the public (observed) IP address and
	// port as seen by the application server, or the private (local) and any public
	// (observed) IP addresses in use by the device (this information can be obtained
	// by various means, for example from some DNS servers).
	//
	// If the allocated and observed IP addresses are the same (i.e. NAT is not in use)
	// then the same address should be specified for both publicAddress and
	// privateAddress.
	//
	// If NAT64 is in use, the device should be identified by its publicAddress and
	// publicPort, or separately by its allocated IPv6 address (field ipv6Address of
	// the Device object)
	//
	// In all cases, publicAddress must be specified, along with at least one of either
	// privateAddress or publicPort, dependent upon which is known. In general, mobile
	// devices cannot be identified by their public IPv4 address alone.
	Ipv4Address DeviceIdentifierDeviceIpv4Addr `json:"ipv4Address"`
	// The device should be identified by the observed IPv6 address, or by any single
	// IPv6 address from within the subnet allocated to the device (e.g. adding ::0 to
	// the /64 prefix).
	Ipv6Address string `json:"ipv6Address" format:"ipv6"`
	// A public identifier addressing a subscription in a mobile network. In 3GPP
	// terminology, it corresponds to the GPSI formatted with the External Identifier
	// ({Local Identifier}@{Domain Identifier}). Unlike the telephone number, the
	// network access identifier is not subjected to portability ruling in force, and
	// is individually managed by each operator.
	NetworkAccessIdentifier string `json:"networkAccessIdentifier"`
	// A public identifier addressing a telephone subscription. In mobile networks it
	// corresponds to the MSISDN (Mobile Station International Subscriber Directory
	// Number). In order to be globally unique it has to be formatted in international
	// format, according to E.164 standard, prefixed with '+'.
	PhoneNumber string `json:"phoneNumber"`
	// JSON contains metadata for fields, check presence with [respjson.Field.Valid].
	JSON struct {
		Ipv4Address             respjson.Field
		Ipv6Address             respjson.Field
		NetworkAccessIdentifier respjson.Field
		PhoneNumber             respjson.Field
		ExtraFields             map[string]respjson.Field
		// contains filtered or unexported fields
	} `json:"-"`
}

End-user equipment able to connect to a mobile network. Examples of devices include smartphones or IoT sensors/actuators. The developer can choose to provide the below specified device identifiers:

  • `ipv4Address`
  • `ipv6Address`
  • `phoneNumber`
  • `networkAccessIdentifier` NOTE 1: The MNO might support only a subset of these options. The API invoker can provide multiple identifiers to be compatible across different MNOs. In this case the identifiers MUST belong to the same device. NOTE 2: For the current Commonalities release, we are enforcing that the networkAccessIdentifier is only part of the schema for future-proofing, and CAMARA does not currently allow its use. After the CAMARA meta-release work is concluded and the relevant issues are resolved, its use will need to be explicitly documented in the guidelines.

func (DeviceIdentifierDevice) RawJSON 

func (r DeviceIdentifierDevice) RawJSON() string

Returns the unmodified JSON received from the API

func (DeviceIdentifierDevice) ToParam 

func (r DeviceIdentifierDevice) ToParam() DeviceIdentifierDeviceParam

ToParam converts this DeviceIdentifierDevice to a DeviceIdentifierDeviceParam.

Warning: the fields of the param type will not be present. ToParam should only be used at the last possible moment before sending a request. Test for this with DeviceIdentifierDeviceParam.Overrides()

func (*DeviceIdentifierDevice) UnmarshalJSON 

func (r *DeviceIdentifierDevice) UnmarshalJSON(data []byte) error

type DeviceIdentifierDeviceIpv4Addr 

type DeviceIdentifierDeviceIpv4Addr struct {
	// A single IPv4 address with no subnet mask
	PrivateAddress string `json:"privateAddress" format:"ipv4"`
	// A single IPv4 address with no subnet mask
	PublicAddress string `json:"publicAddress" format:"ipv4"`
	// TCP or UDP port number
	PublicPort int64 `json:"publicPort"`
	// JSON contains metadata for fields, check presence with [respjson.Field.Valid].
	JSON struct {
		PrivateAddress respjson.Field
		PublicAddress  respjson.Field
		PublicPort     respjson.Field
		ExtraFields    map[string]respjson.Field
		// contains filtered or unexported fields
	} `json:"-"`
}

The device should be identified by either the public (observed) IP address and port as seen by the application server, or the private (local) and any public (observed) IP addresses in use by the device (this information can be obtained by various means, for example from some DNS servers).

If the allocated and observed IP addresses are the same (i.e. NAT is not in use) then the same address should be specified for both publicAddress and privateAddress.

If NAT64 is in use, the device should be identified by its publicAddress and publicPort, or separately by its allocated IPv6 address (field ipv6Address of the Device object)

In all cases, publicAddress must be specified, along with at least one of either privateAddress or publicPort, dependent upon which is known. In general, mobile devices cannot be identified by their public IPv4 address alone.

func (DeviceIdentifierDeviceIpv4Addr) RawJSON 

func (r DeviceIdentifierDeviceIpv4Addr) RawJSON() string

Returns the unmodified JSON received from the API

func (DeviceIdentifierDeviceIpv4Addr) ToParam 

func (r DeviceIdentifierDeviceIpv4Addr) ToParam() DeviceIdentifierDeviceIpv4AddrParam

ToParam converts this DeviceIdentifierDeviceIpv4Addr to a DeviceIdentifierDeviceIpv4AddrParam.

Warning: the fields of the param type will not be present. ToParam should only be used at the last possible moment before sending a request. Test for this with DeviceIdentifierDeviceIpv4AddrParam.Overrides()

func (*DeviceIdentifierDeviceIpv4Addr) UnmarshalJSON 

func (r *DeviceIdentifierDeviceIpv4Addr) UnmarshalJSON(data []byte) error

type DeviceIdentifierDeviceIpv4AddrParam 

type DeviceIdentifierDeviceIpv4AddrParam struct {
	// A single IPv4 address with no subnet mask
	PrivateAddress param.Opt[string] `json:"privateAddress,omitzero" format:"ipv4"`
	// A single IPv4 address with no subnet mask
	PublicAddress param.Opt[string] `json:"publicAddress,omitzero" format:"ipv4"`
	// TCP or UDP port number
	PublicPort param.Opt[int64] `json:"publicPort,omitzero"`
	// contains filtered or unexported fields
}

The device should be identified by either the public (observed) IP address and port as seen by the application server, or the private (local) and any public (observed) IP addresses in use by the device (this information can be obtained by various means, for example from some DNS servers).

If the allocated and observed IP addresses are the same (i.e. NAT is not in use) then the same address should be specified for both publicAddress and privateAddress.

If NAT64 is in use, the device should be identified by its publicAddress and publicPort, or separately by its allocated IPv6 address (field ipv6Address of the Device object)

In all cases, publicAddress must be specified, along with at least one of either privateAddress or publicPort, dependent upon which is known. In general, mobile devices cannot be identified by their public IPv4 address alone.

func (DeviceIdentifierDeviceIpv4AddrParam) MarshalJSON 

func (r DeviceIdentifierDeviceIpv4AddrParam) MarshalJSON() (data []byte, err error)

func (*DeviceIdentifierDeviceIpv4AddrParam) UnmarshalJSON 

func (r *DeviceIdentifierDeviceIpv4AddrParam) UnmarshalJSON(data []byte) error

type DeviceIdentifierDeviceParam 

type DeviceIdentifierDeviceParam struct {
	// The device should be identified by the observed IPv6 address, or by any single
	// IPv6 address from within the subnet allocated to the device (e.g. adding ::0 to
	// the /64 prefix).
	Ipv6Address param.Opt[string] `json:"ipv6Address,omitzero" format:"ipv6"`
	// A public identifier addressing a subscription in a mobile network. In 3GPP
	// terminology, it corresponds to the GPSI formatted with the External Identifier
	// ({Local Identifier}@{Domain Identifier}). Unlike the telephone number, the
	// network access identifier is not subjected to portability ruling in force, and
	// is individually managed by each operator.
	NetworkAccessIdentifier param.Opt[string] `json:"networkAccessIdentifier,omitzero"`
	// A public identifier addressing a telephone subscription. In mobile networks it
	// corresponds to the MSISDN (Mobile Station International Subscriber Directory
	// Number). In order to be globally unique it has to be formatted in international
	// format, according to E.164 standard, prefixed with '+'.
	PhoneNumber param.Opt[string] `json:"phoneNumber,omitzero"`
	// The device should be identified by either the public (observed) IP address and
	// port as seen by the application server, or the private (local) and any public
	// (observed) IP addresses in use by the device (this information can be obtained
	// by various means, for example from some DNS servers).
	//
	// If the allocated and observed IP addresses are the same (i.e. NAT is not in use)
	// then the same address should be specified for both publicAddress and
	// privateAddress.
	//
	// If NAT64 is in use, the device should be identified by its publicAddress and
	// publicPort, or separately by its allocated IPv6 address (field ipv6Address of
	// the Device object)
	//
	// In all cases, publicAddress must be specified, along with at least one of either
	// privateAddress or publicPort, dependent upon which is known. In general, mobile
	// devices cannot be identified by their public IPv4 address alone.
	Ipv4Address DeviceIdentifierDeviceIpv4AddrParam `json:"ipv4Address,omitzero"`
	// contains filtered or unexported fields
}

End-user equipment able to connect to a mobile network. Examples of devices include smartphones or IoT sensors/actuators. The developer can choose to provide the below specified device identifiers:

  • `ipv4Address`
  • `ipv6Address`
  • `phoneNumber`
  • `networkAccessIdentifier` NOTE 1: The MNO might support only a subset of these options. The API invoker can provide multiple identifiers to be compatible across different MNOs. In this case the identifiers MUST belong to the same device. NOTE 2: For the current Commonalities release, we are enforcing that the networkAccessIdentifier is only part of the schema for future-proofing, and CAMARA does not currently allow its use. After the CAMARA meta-release work is concluded and the relevant issues are resolved, its use will need to be explicitly documented in the guidelines.

func (DeviceIdentifierDeviceParam) MarshalJSON 

func (r DeviceIdentifierDeviceParam) MarshalJSON() (data []byte, err error)

func (*DeviceIdentifierDeviceParam) UnmarshalJSON 

func (r *DeviceIdentifierDeviceParam) UnmarshalJSON(data []byte) error

type DeviceIdentifierRequestBodyParam 

type DeviceIdentifierRequestBodyParam struct {
	// End-user equipment able to connect to a mobile network. Examples of devices
	// include smartphones or IoT sensors/actuators. The developer can choose to
	// provide the below specified device identifiers:
	//
	//   - `ipv4Address`
	//   - `ipv6Address`
	//   - `phoneNumber`
	//   - `networkAccessIdentifier` NOTE 1: The MNO might support only a subset of these
	//     options. The API invoker can provide multiple identifiers to be compatible
	//     across different MNOs. In this case the identifiers MUST belong to the same
	//     device. NOTE 2: For the current Commonalities release, we are enforcing that
	//     the networkAccessIdentifier is only part of the schema for future-proofing,
	//     and CAMARA does not currently allow its use. After the CAMARA meta-release
	//     work is concluded and the relevant issues are resolved, its use will need to
	//     be explicitly documented in the guidelines.
	Device DeviceIdentifierDeviceParam `json:"device,omitzero"`
	// contains filtered or unexported fields
}

Common request body to allow optional Device object to be passed

func (DeviceIdentifierRequestBodyParam) MarshalJSON 

func (r DeviceIdentifierRequestBodyParam) MarshalJSON() (data []byte, err error)

func (*DeviceIdentifierRequestBodyParam) UnmarshalJSON 

func (r *DeviceIdentifierRequestBodyParam) UnmarshalJSON(data []byte) error

type DeviceLocationArea 

type DeviceLocationArea struct {
	// Type of this area. CIRCLE - The area is defined as a circle.
	//
	// Any of "CIRCLE".
	AreaType DeviceLocationAreaAreaType `json:"areaType" api:"required"`
	// JSON contains metadata for fields, check presence with [respjson.Field.Valid].
	JSON struct {
		AreaType    respjson.Field
		ExtraFields map[string]respjson.Field
		// contains filtered or unexported fields
	} `json:"-"`
}

The geofencing area where the monitor is active. This area is specified by API consumers in the subscription request. The same area definition is included in event notifications without any modifications.

func (DeviceLocationArea) RawJSON 

func (r DeviceLocationArea) RawJSON() string

Returns the unmodified JSON received from the API

func (DeviceLocationArea) ToParam 

func (r DeviceLocationArea) ToParam() DeviceLocationAreaParam

ToParam converts this DeviceLocationArea to a DeviceLocationAreaParam.

Warning: the fields of the param type will not be present. ToParam should only be used at the last possible moment before sending a request. Test for this with DeviceLocationAreaParam.Overrides()

func (*DeviceLocationArea) UnmarshalJSON 

func (r *DeviceLocationArea) UnmarshalJSON(data []byte) error

type DeviceLocationAreaAreaType 

type DeviceLocationAreaAreaType string

Type of this area. CIRCLE - The area is defined as a circle. 

const (
	DeviceLocationAreaAreaTypeCircle DeviceLocationAreaAreaType = "CIRCLE"
)

type DeviceLocationAreaParam 

type DeviceLocationAreaParam struct {
	// Type of this area. CIRCLE - The area is defined as a circle.
	//
	// Any of "CIRCLE".
	AreaType DeviceLocationAreaAreaType `json:"areaType,omitzero" api:"required"`
	// contains filtered or unexported fields
}

The geofencing area where the monitor is active. This area is specified by API consumers in the subscription request. The same area definition is included in event notifications without any modifications.

The property AreaType is required.

func (DeviceLocationAreaParam) MarshalJSON 

func (r DeviceLocationAreaParam) MarshalJSON() (data []byte, err error)

func (*DeviceLocationAreaParam) UnmarshalJSON 

func (r *DeviceLocationAreaParam) UnmarshalJSON(data []byte) error

type DeviceLocationConfig 

type DeviceLocationConfig struct {
	// Set to `true` by API consumer if consumer wants to get an event as soon as the
	// subscription is created and current situation reflects event request. Example:
	// Consumer request area entered event. If consumer sets initialEvent to true and
	// device is already in the geofence, an event is triggered.
	InitialEvent bool `json:"initialEvent"`
	// The subscription expiration time (in date-time format) requested by the API
	// consumer. It must follow
	// [RFC 3339](https://datatracker.ietf.org/doc/html/rfc3339#section-5.6) and must
	// have time zone.
	SubscriptionExpireTime time.Time `json:"subscriptionExpireTime" format:"date-time"`
	// Identifies the maximum number of event reports to be generated (>=1) requested
	// by the API consumer - Once this number is reached, the subscription ends. Note
	// on combined usage of `initialEvent` and `subscriptionMaxEvents`: If an event is
	// triggered following `initialEvent` set to `true`, this event will be counted
	// towards `subscriptionMaxEvents`.
	SubscriptionMaxEvents int64 `json:"subscriptionMaxEvents"`
	// JSON contains metadata for fields, check presence with [respjson.Field.Valid].
	JSON struct {
		InitialEvent           respjson.Field
		SubscriptionExpireTime respjson.Field
		SubscriptionMaxEvents  respjson.Field
		ExtraFields            map[string]respjson.Field
		// contains filtered or unexported fields
	} `json:"-"`
}

Implementation-specific configuration parameters are needed by the subscription manager for acquiring events. In CAMARA we have predefined attributes like `subscriptionExpireTime`, `subscriptionMaxEvents`, `initialEvent`.

func (DeviceLocationConfig) RawJSON 

func (r DeviceLocationConfig) RawJSON() string

Returns the unmodified JSON received from the API

func (DeviceLocationConfig) ToParam 

func (r DeviceLocationConfig) ToParam() DeviceLocationConfigParam

ToParam converts this DeviceLocationConfig to a DeviceLocationConfigParam.

Warning: the fields of the param type will not be present. ToParam should only be used at the last possible moment before sending a request. Test for this with DeviceLocationConfigParam.Overrides()

func (*DeviceLocationConfig) UnmarshalJSON 

func (r *DeviceLocationConfig) UnmarshalJSON(data []byte) error

type DeviceLocationConfigParam 

type DeviceLocationConfigParam struct {
	// Set to `true` by API consumer if consumer wants to get an event as soon as the
	// subscription is created and current situation reflects event request. Example:
	// Consumer request area entered event. If consumer sets initialEvent to true and
	// device is already in the geofence, an event is triggered.
	InitialEvent param.Opt[bool] `json:"initialEvent,omitzero"`
	// The subscription expiration time (in date-time format) requested by the API
	// consumer. It must follow
	// [RFC 3339](https://datatracker.ietf.org/doc/html/rfc3339#section-5.6) and must
	// have time zone.
	SubscriptionExpireTime param.Opt[time.Time] `json:"subscriptionExpireTime,omitzero" format:"date-time"`
	// Identifies the maximum number of event reports to be generated (>=1) requested
	// by the API consumer - Once this number is reached, the subscription ends. Note
	// on combined usage of `initialEvent` and `subscriptionMaxEvents`: If an event is
	// triggered following `initialEvent` set to `true`, this event will be counted
	// towards `subscriptionMaxEvents`.
	SubscriptionMaxEvents param.Opt[int64] `json:"subscriptionMaxEvents,omitzero"`
	// contains filtered or unexported fields
}

Implementation-specific configuration parameters are needed by the subscription manager for acquiring events. In CAMARA we have predefined attributes like `subscriptionExpireTime`, `subscriptionMaxEvents`, `initialEvent`.

func (DeviceLocationConfigParam) MarshalJSON 

func (r DeviceLocationConfigParam) MarshalJSON() (data []byte, err error)

func (*DeviceLocationConfigParam) UnmarshalJSON 

func (r *DeviceLocationConfigParam) UnmarshalJSON(data []byte) error

type DeviceLocationDevice 

type DeviceLocationDevice struct {
	// The device should be identified by either the public (observed) IP address and
	// port as seen by the application server, or the private (local) and any public
	// (observed) IP addresses in use by the device (this information can be obtained
	// by various means, for example from some DNS servers).
	//
	// If the allocated and observed IP addresses are the same (i.e. NAT is not in use)
	// then the same address should be specified for both publicAddress and
	// privateAddress.
	//
	// If NAT64 is in use, the device should be identified by its publicAddress and
	// publicPort, or separately by its allocated IPv6 address (field ipv6Address of
	// the Device object)
	//
	// In all cases, publicAddress must be specified, along with at least one of either
	// privateAddress or publicPort, dependent upon which is known. In general, mobile
	// devices cannot be identified by their public IPv4 address alone.
	Ipv4Address DeviceLocationDeviceIpv4Address `json:"ipv4Address"`
	// The device should be identified by the observed IPv6 address, or by any single
	// IPv6 address from within the subnet allocated to the device (e.g. adding ::0 to
	// the /64 prefix).
	Ipv6Address string `json:"ipv6Address" format:"ipv6"`
	// A public identifier addressing a subscription in a mobile network. In 3GPP
	// terminology, it corresponds to the GPSI formatted with the External Identifier
	// ({Local Identifier}@{Domain Identifier}). Unlike the telephone number, the
	// network access identifier is not subjected to portability ruling in force, and
	// is individually managed by each operator.
	NetworkAccessIdentifier string `json:"networkAccessIdentifier"`
	// A public identifier addressing a telephone subscription. In mobile networks, it
	// corresponds to the MSISDN (Mobile Station International Subscriber Directory
	// Number). In order to be globally unique it has to be formatted in international
	// format, according to E.164 standard, prefixed with '+'.
	PhoneNumber string `json:"phoneNumber"`
	// JSON contains metadata for fields, check presence with [respjson.Field.Valid].
	JSON struct {
		Ipv4Address             respjson.Field
		Ipv6Address             respjson.Field
		NetworkAccessIdentifier respjson.Field
		PhoneNumber             respjson.Field
		ExtraFields             map[string]respjson.Field
		// contains filtered or unexported fields
	} `json:"-"`
}

End-user device able to connect to a mobile network. Examples of devices include smartphones or IoT sensors/actuators.

The developer can choose to provide the below specified device identifiers:

- `ipv4Address` - `ipv6Address` - `phoneNumber` - `networkAccessIdentifier`

NOTE1: the API provider might support only a subset of these options. The API consumer can provide multiple identifiers to be compatible across different API providers. In this case the identifiers MUST belong to the same device. Where more than one device identifier is provided, only one identifier will be selected by the implementation and this choice indicated to the API consumer in the response or event. NOTE2: as for this Commonalities release, we are enforcing that the networkAccessIdentifier is only part of the schema for future-proofing, and CAMARA does not currently allow its use. After the CAMARA meta-release work is concluded and the relevant issues are resolved, its use will need to be explicitly documented in the guidelines.

func (DeviceLocationDevice) RawJSON 

func (r DeviceLocationDevice) RawJSON() string

Returns the unmodified JSON received from the API

func (DeviceLocationDevice) ToParam 

func (r DeviceLocationDevice) ToParam() DeviceLocationDeviceParam

ToParam converts this DeviceLocationDevice to a DeviceLocationDeviceParam.

Warning: the fields of the param type will not be present. ToParam should only be used at the last possible moment before sending a request. Test for this with DeviceLocationDeviceParam.Overrides()

func (*DeviceLocationDevice) UnmarshalJSON 

func (r *DeviceLocationDevice) UnmarshalJSON(data []byte) error

type DeviceLocationDeviceIpv4Address 

type DeviceLocationDeviceIpv4Address struct {
	// A single IPv4 address with no subnet mask.
	PrivateAddress string `json:"privateAddress" format:"ipv4"`
	// A single IPv4 address with no subnet mask.
	PublicAddress string `json:"publicAddress" format:"ipv4"`
	// TCP or UDP port number.
	PublicPort int64 `json:"publicPort"`
	// JSON contains metadata for fields, check presence with [respjson.Field.Valid].
	JSON struct {
		PrivateAddress respjson.Field
		PublicAddress  respjson.Field
		PublicPort     respjson.Field
		ExtraFields    map[string]respjson.Field
		// contains filtered or unexported fields
	} `json:"-"`
}

The device should be identified by either the public (observed) IP address and port as seen by the application server, or the private (local) and any public (observed) IP addresses in use by the device (this information can be obtained by various means, for example from some DNS servers).

If the allocated and observed IP addresses are the same (i.e. NAT is not in use) then the same address should be specified for both publicAddress and privateAddress.

If NAT64 is in use, the device should be identified by its publicAddress and publicPort, or separately by its allocated IPv6 address (field ipv6Address of the Device object)

In all cases, publicAddress must be specified, along with at least one of either privateAddress or publicPort, dependent upon which is known. In general, mobile devices cannot be identified by their public IPv4 address alone.

func (DeviceLocationDeviceIpv4Address) RawJSON 

func (r DeviceLocationDeviceIpv4Address) RawJSON() string

Returns the unmodified JSON received from the API

func (*DeviceLocationDeviceIpv4Address) UnmarshalJSON 

func (r *DeviceLocationDeviceIpv4Address) UnmarshalJSON(data []byte) error

type DeviceLocationDeviceIpv4AddressParam 

type DeviceLocationDeviceIpv4AddressParam struct {
	// A single IPv4 address with no subnet mask.
	PrivateAddress param.Opt[string] `json:"privateAddress,omitzero" format:"ipv4"`
	// A single IPv4 address with no subnet mask.
	PublicAddress param.Opt[string] `json:"publicAddress,omitzero" format:"ipv4"`
	// TCP or UDP port number.
	PublicPort param.Opt[int64] `json:"publicPort,omitzero"`
	// contains filtered or unexported fields
}

The device should be identified by either the public (observed) IP address and port as seen by the application server, or the private (local) and any public (observed) IP addresses in use by the device (this information can be obtained by various means, for example from some DNS servers).

If the allocated and observed IP addresses are the same (i.e. NAT is not in use) then the same address should be specified for both publicAddress and privateAddress.

If NAT64 is in use, the device should be identified by its publicAddress and publicPort, or separately by its allocated IPv6 address (field ipv6Address of the Device object)

In all cases, publicAddress must be specified, along with at least one of either privateAddress or publicPort, dependent upon which is known. In general, mobile devices cannot be identified by their public IPv4 address alone.

func (DeviceLocationDeviceIpv4AddressParam) MarshalJSON 

func (r DeviceLocationDeviceIpv4AddressParam) MarshalJSON() (data []byte, err error)

func (*DeviceLocationDeviceIpv4AddressParam) UnmarshalJSON 

func (r *DeviceLocationDeviceIpv4AddressParam) UnmarshalJSON(data []byte) error

type DeviceLocationDeviceParam 

type DeviceLocationDeviceParam struct {
	// The device should be identified by the observed IPv6 address, or by any single
	// IPv6 address from within the subnet allocated to the device (e.g. adding ::0 to
	// the /64 prefix).
	Ipv6Address param.Opt[string] `json:"ipv6Address,omitzero" format:"ipv6"`
	// A public identifier addressing a subscription in a mobile network. In 3GPP
	// terminology, it corresponds to the GPSI formatted with the External Identifier
	// ({Local Identifier}@{Domain Identifier}). Unlike the telephone number, the
	// network access identifier is not subjected to portability ruling in force, and
	// is individually managed by each operator.
	NetworkAccessIdentifier param.Opt[string] `json:"networkAccessIdentifier,omitzero"`
	// A public identifier addressing a telephone subscription. In mobile networks, it
	// corresponds to the MSISDN (Mobile Station International Subscriber Directory
	// Number). In order to be globally unique it has to be formatted in international
	// format, according to E.164 standard, prefixed with '+'.
	PhoneNumber param.Opt[string] `json:"phoneNumber,omitzero"`
	// The device should be identified by either the public (observed) IP address and
	// port as seen by the application server, or the private (local) and any public
	// (observed) IP addresses in use by the device (this information can be obtained
	// by various means, for example from some DNS servers).
	//
	// If the allocated and observed IP addresses are the same (i.e. NAT is not in use)
	// then the same address should be specified for both publicAddress and
	// privateAddress.
	//
	// If NAT64 is in use, the device should be identified by its publicAddress and
	// publicPort, or separately by its allocated IPv6 address (field ipv6Address of
	// the Device object)
	//
	// In all cases, publicAddress must be specified, along with at least one of either
	// privateAddress or publicPort, dependent upon which is known. In general, mobile
	// devices cannot be identified by their public IPv4 address alone.
	Ipv4Address DeviceLocationDeviceIpv4AddressParam `json:"ipv4Address,omitzero"`
	// contains filtered or unexported fields
}

End-user device able to connect to a mobile network. Examples of devices include smartphones or IoT sensors/actuators.

The developer can choose to provide the below specified device identifiers:

- `ipv4Address` - `ipv6Address` - `phoneNumber` - `networkAccessIdentifier`

NOTE1: the API provider might support only a subset of these options. The API consumer can provide multiple identifiers to be compatible across different API providers. In this case the identifiers MUST belong to the same device. Where more than one device identifier is provided, only one identifier will be selected by the implementation and this choice indicated to the API consumer in the response or event. NOTE2: as for this Commonalities release, we are enforcing that the networkAccessIdentifier is only part of the schema for future-proofing, and CAMARA does not currently allow its use. After the CAMARA meta-release work is concluded and the relevant issues are resolved, its use will need to be explicitly documented in the guidelines.

func (DeviceLocationDeviceParam) MarshalJSON 

func (r DeviceLocationDeviceParam) MarshalJSON() (data []byte, err error)

func (*DeviceLocationDeviceParam) UnmarshalJSON 

func (r *DeviceLocationDeviceParam) UnmarshalJSON(data []byte) error

type DeviceLocationProtocol 

type DeviceLocationProtocol string

Identifier of a delivery protocol. Only HTTP is allowed for now. 

const (
	DeviceLocationProtocolHTTP  DeviceLocationProtocol = "HTTP"
	DeviceLocationProtocolMqtt3 DeviceLocationProtocol = "MQTT3"
	DeviceLocationProtocolMqtt5 DeviceLocationProtocol = "MQTT5"
	DeviceLocationProtocolAmqp  DeviceLocationProtocol = "AMQP"
	DeviceLocationProtocolNats  DeviceLocationProtocol = "NATS"
	DeviceLocationProtocolKafka DeviceLocationProtocol = "KAFKA"
)

type DeviceLocationSubscription 

type DeviceLocationSubscription struct {
	// The unique identifier of the subscription in the scope of the subscription
	// manager. When this information is contained within an event notification, this
	// concept SHALL be referred as subscriptionId as per Commonalities Event
	// Notification Model.
	ID string `json:"id" api:"required"`
	// Implementation-specific configuration parameters are needed by the subscription
	// manager for acquiring events. In CAMARA we have predefined attributes like
	// `subscriptionExpireTime`, `subscriptionMaxEvents`, `initialEvent`.
	Config DeviceLocationSubscriptionConfig `json:"config" api:"required"`
	// Identifier of a delivery protocol. Only HTTP is allowed for now.
	//
	// Any of "HTTP", "MQTT3", "MQTT5", "AMQP", "NATS", "KAFKA".
	Protocol DeviceLocationProtocol `json:"protocol" api:"required"`
	// The address to which events shall be delivered using the selected protocol.
	Sink string `json:"sink" api:"required" format:"uri"`
	// Date when the event subscription will begin/began It must follow
	// [RFC 3339](https://datatracker.ietf.org/doc/html/rfc3339#section-5.6) and must
	// have time zone.
	StartsAt time.Time `json:"startsAt" api:"required" format:"date-time"`
	// Camara Event types eligible to be delivered by this subscription. Note: As of
	// now we enforce to have only event type per subscription.
	Types []DeviceLocationSubscriptionEventType `json:"types" api:"required"`
	// Date when the event subscription will expire. Only provided when
	// `subscriptionExpireTime` is indicated by API client or Telco Operator has
	// specific policy about that. It must follow
	// [RFC 3339](https://datatracker.ietf.org/doc/html/rfc3339#section-5.6) and must
	// have time zone.
	ExpiresAt time.Time `json:"expiresAt" format:"date-time"`
	// Current status of the subscription - Management of Subscription State engine is
	// not mandatory for now. Note not all statuses may be considered to be
	// implemented. Details:
	//
	//   - `ACTIVATION_REQUESTED`: Subscription creation (POST) is triggered but
	//     subscription creation process is not finished yet.
	//   - `ACTIVE`: Subscription creation process is completed. Subscription is fully
	//     operative.
	//   - `INACTIVE`: Subscription is temporarily inactive, but its workflow logic is
	//     not deleted.
	//   - `EXPIRED`: Subscription is ended (no longer active). This status applies when
	//     subscription is ended due to `SUBSCRIPTION_EXPIRED` or `ACCESS_TOKEN_EXPIRED`
	//     event.
	//   - `DELETED`: Subscription is ended as deleted (no longer active). This status
	//     applies when subscription information is kept (i.e. subscription workflow is
	//     no longer active but its meta-information is kept).
	//
	// Any of "ACTIVATION_REQUESTED", "ACTIVE", "EXPIRED", "INACTIVE", "DELETED".
	Status DeviceLocationSubscriptionStatus `json:"status"`
	// JSON contains metadata for fields, check presence with [respjson.Field.Valid].
	JSON struct {
		ID          respjson.Field
		Config      respjson.Field
		Protocol    respjson.Field
		Sink        respjson.Field
		StartsAt    respjson.Field
		Types       respjson.Field
		ExpiresAt   respjson.Field
		Status      respjson.Field
		ExtraFields map[string]respjson.Field
		// contains filtered or unexported fields
	} `json:"-"`
}

Represents a event-type subscription.

func (DeviceLocationSubscription) RawJSON 

func (r DeviceLocationSubscription) RawJSON() string

Returns the unmodified JSON received from the API

func (*DeviceLocationSubscription) UnmarshalJSON 

func (r *DeviceLocationSubscription) UnmarshalJSON(data []byte) error

type DeviceLocationSubscriptionConfig 

type DeviceLocationSubscriptionConfig struct {
	// The detail of the event subscription granted by the implementation.
	SubscriptionDetail DeviceLocationSubscriptionConfigSubscriptionDetail `json:"subscriptionDetail" api:"required"`
	// JSON contains metadata for fields, check presence with [respjson.Field.Valid].
	JSON struct {
		SubscriptionDetail respjson.Field
		ExtraFields        map[string]respjson.Field
		// contains filtered or unexported fields
	} `json:"-"`
	DeviceLocationConfig
}

Implementation-specific configuration parameters are needed by the subscription manager for acquiring events. In CAMARA we have predefined attributes like `subscriptionExpireTime`, `subscriptionMaxEvents`, `initialEvent`.

func (DeviceLocationSubscriptionConfig) RawJSON 

func (r DeviceLocationSubscriptionConfig) RawJSON() string

Returns the unmodified JSON received from the API

func (*DeviceLocationSubscriptionConfig) UnmarshalJSON 

func (r *DeviceLocationSubscriptionConfig) UnmarshalJSON(data []byte) error

type DeviceLocationSubscriptionConfigSubscriptionDetail 

type DeviceLocationSubscriptionConfigSubscriptionDetail struct {
	// The geofencing area where the monitor is active. This area is specified by API
	// consumers in the subscription request. The same area definition is included in
	// event notifications without any modifications.
	Area DeviceLocationArea `json:"area" api:"required"`
	// End-user device able to connect to a mobile network. Examples of devices include
	// smartphones or IoT sensors/actuators.
	//
	// The developer can choose to provide the below specified device identifiers:
	//
	// - `ipv4Address`
	// - `ipv6Address`
	// - `phoneNumber`
	// - `networkAccessIdentifier`
	//
	// NOTE1: the API provider might support only a subset of these options. The API
	// consumer can provide multiple identifiers to be compatible across different API
	// providers. In this case the identifiers MUST belong to the same device. Where
	// more than one device identifier is provided, only one identifier will be
	// selected by the implementation and this choice indicated to the API consumer in
	// the response or event. NOTE2: as for this Commonalities release, we are
	// enforcing that the networkAccessIdentifier is only part of the schema for
	// future-proofing, and CAMARA does not currently allow its use. After the CAMARA
	// meta-release work is concluded and the relevant issues are resolved, its use
	// will need to be explicitly documented in the guidelines.
	Device DeviceLocationDevice `json:"device"`
	// JSON contains metadata for fields, check presence with [respjson.Field.Valid].
	JSON struct {
		Area        respjson.Field
		Device      respjson.Field
		ExtraFields map[string]respjson.Field
		// contains filtered or unexported fields
	} `json:"-"`
}

The detail of the event subscription granted by the implementation.

func (DeviceLocationSubscriptionConfigSubscriptionDetail) RawJSON 

func (r DeviceLocationSubscriptionConfigSubscriptionDetail) RawJSON() string

Returns the unmodified JSON received from the API

func (*DeviceLocationSubscriptionConfigSubscriptionDetail) UnmarshalJSON 

func (r *DeviceLocationSubscriptionConfigSubscriptionDetail) UnmarshalJSON(data []byte) error

type DeviceLocationSubscriptionEventType 

type DeviceLocationSubscriptionEventType string

area-entered - Event triggered when the device enters the given area

area-left - Event triggered when the device leaves the given area 

const (
	DeviceLocationSubscriptionEventTypeOrgCamaraprojectGeofencingSubscriptionsV0AreaEntered DeviceLocationSubscriptionEventType = "org.camaraproject.geofencing-subscriptions.v0.area-entered"
	DeviceLocationSubscriptionEventTypeOrgCamaraprojectGeofencingSubscriptionsV0AreaLeft    DeviceLocationSubscriptionEventType = "org.camaraproject.geofencing-subscriptions.v0.area-left"
)

type DeviceLocationSubscriptionStatus 

type DeviceLocationSubscriptionStatus string

Current status of the subscription - Management of Subscription State engine is not mandatory for now. Note not all statuses may be considered to be implemented. Details:

  • `ACTIVATION_REQUESTED`: Subscription creation (POST) is triggered but subscription creation process is not finished yet.
  • `ACTIVE`: Subscription creation process is completed. Subscription is fully operative.
  • `INACTIVE`: Subscription is temporarily inactive, but its workflow logic is not deleted.
  • `EXPIRED`: Subscription is ended (no longer active). This status applies when subscription is ended due to `SUBSCRIPTION_EXPIRED` or `ACCESS_TOKEN_EXPIRED` event.
  • `DELETED`: Subscription is ended as deleted (no longer active). This status applies when subscription information is kept (i.e. subscription workflow is no longer active but its meta-information is kept).
const (
	DeviceLocationSubscriptionStatusActivationRequested DeviceLocationSubscriptionStatus = "ACTIVATION_REQUESTED"
	DeviceLocationSubscriptionStatusActive              DeviceLocationSubscriptionStatus = "ACTIVE"
	DeviceLocationSubscriptionStatusExpired             DeviceLocationSubscriptionStatus = "EXPIRED"
	DeviceLocationSubscriptionStatusInactive            DeviceLocationSubscriptionStatus = "INACTIVE"
	DeviceLocationSubscriptionStatusDeleted             DeviceLocationSubscriptionStatus = "DELETED"
)

type DeviceReachabilityStatusConfig 

type DeviceReachabilityStatusConfig struct {
	// The detail of the requested event subscription.
	SubscriptionDetail DeviceReachabilityStatusConfigSubscriptionDetail `json:"subscriptionDetail" api:"required"`
	// Set to `true` by API consumer if consumer wants to get an event as soon as the
	// subscription is created and current situation reflects event request. Example:
	// Consumer subscribes to reachability SMS. If consumer sets initialEvent to true
	// and device is already reachable by SMS, an event is triggered.
	InitialEvent bool `json:"initialEvent"`
	// The subscription expiration time (in date-time format) requested by the API
	// consumer.
	SubscriptionExpireTime time.Time `json:"subscriptionExpireTime" format:"date-time"`
	// Identifies the maximum number of event reports to be generated (>=1) requested
	// by the API consumer - Once this number is reached, the subscription ends.
	SubscriptionMaxEvents int64 `json:"subscriptionMaxEvents"`
	// JSON contains metadata for fields, check presence with [respjson.Field.Valid].
	JSON struct {
		SubscriptionDetail     respjson.Field
		InitialEvent           respjson.Field
		SubscriptionExpireTime respjson.Field
		SubscriptionMaxEvents  respjson.Field
		ExtraFields            map[string]respjson.Field
		// contains filtered or unexported fields
	} `json:"-"`
}

Implementation-specific configuration parameters needed by the subscription manager for acquiring events. In CAMARA we have predefined attributes like `subscriptionExpireTime`, `subscriptionMaxEvents`, `initialEvent` Specific event type attributes must be defined in `subscriptionDetail` Note: if a request is performed for several event type, all subscribed event will use same `config` parameters.

func (DeviceReachabilityStatusConfig) RawJSON 

func (r DeviceReachabilityStatusConfig) RawJSON() string

Returns the unmodified JSON received from the API

func (DeviceReachabilityStatusConfig) ToParam 

func (r DeviceReachabilityStatusConfig) ToParam() DeviceReachabilityStatusConfigParam

ToParam converts this DeviceReachabilityStatusConfig to a DeviceReachabilityStatusConfigParam.

Warning: the fields of the param type will not be present. ToParam should only be used at the last possible moment before sending a request. Test for this with DeviceReachabilityStatusConfigParam.Overrides()

func (*DeviceReachabilityStatusConfig) UnmarshalJSON 

func (r *DeviceReachabilityStatusConfig) UnmarshalJSON(data []byte) error

type DeviceReachabilityStatusConfigParam 

type DeviceReachabilityStatusConfigParam struct {
	// The detail of the requested event subscription.
	SubscriptionDetail DeviceReachabilityStatusConfigSubscriptionDetailParam `json:"subscriptionDetail,omitzero" api:"required"`
	// Set to `true` by API consumer if consumer wants to get an event as soon as the
	// subscription is created and current situation reflects event request. Example:
	// Consumer subscribes to reachability SMS. If consumer sets initialEvent to true
	// and device is already reachable by SMS, an event is triggered.
	InitialEvent param.Opt[bool] `json:"initialEvent,omitzero"`
	// The subscription expiration time (in date-time format) requested by the API
	// consumer.
	SubscriptionExpireTime param.Opt[time.Time] `json:"subscriptionExpireTime,omitzero" format:"date-time"`
	// Identifies the maximum number of event reports to be generated (>=1) requested
	// by the API consumer - Once this number is reached, the subscription ends.
	SubscriptionMaxEvents param.Opt[int64] `json:"subscriptionMaxEvents,omitzero"`
	// contains filtered or unexported fields
}

Implementation-specific configuration parameters needed by the subscription manager for acquiring events. In CAMARA we have predefined attributes like `subscriptionExpireTime`, `subscriptionMaxEvents`, `initialEvent` Specific event type attributes must be defined in `subscriptionDetail` Note: if a request is performed for several event type, all subscribed event will use same `config` parameters.

The property SubscriptionDetail is required.

func (DeviceReachabilityStatusConfigParam) MarshalJSON 

func (r DeviceReachabilityStatusConfigParam) MarshalJSON() (data []byte, err error)

func (*DeviceReachabilityStatusConfigParam) UnmarshalJSON 

func (r *DeviceReachabilityStatusConfigParam) UnmarshalJSON(data []byte) error

type DeviceReachabilityStatusConfigSubscriptionDetail 

type DeviceReachabilityStatusConfigSubscriptionDetail struct {
	// End-user equipment able to connect to a mobile network. Examples of devices
	// include smartphones or IoT sensors/actuators.
	//
	// The developer can choose to provide the below specified device identifiers:
	//
	// - `ipv4Address`
	// - `ipv6Address`
	// - `phoneNumber`
	// - `networkAccessIdentifier`
	//
	// NOTE: the MNO might support only a subset of these options. The API invoker can
	// provide multiple identifiers to be compatible across different MNOs. In this
	// case the identifiers MUST belong to the same device.
	Device DeviceReachabilityStatusConfigSubscriptionDetailDevice `json:"device"`
	// JSON contains metadata for fields, check presence with [respjson.Field.Valid].
	JSON struct {
		Device      respjson.Field
		ExtraFields map[string]respjson.Field
		// contains filtered or unexported fields
	} `json:"-"`
}

The detail of the requested event subscription.

func (DeviceReachabilityStatusConfigSubscriptionDetail) RawJSON 

func (r DeviceReachabilityStatusConfigSubscriptionDetail) RawJSON() string

Returns the unmodified JSON received from the API

func (*DeviceReachabilityStatusConfigSubscriptionDetail) UnmarshalJSON 

func (r *DeviceReachabilityStatusConfigSubscriptionDetail) UnmarshalJSON(data []byte) error

type DeviceReachabilityStatusConfigSubscriptionDetailDevice 

type DeviceReachabilityStatusConfigSubscriptionDetailDevice struct {
	// The device should be identified by either the public (observed) IP address and
	// port as seen by the application server, or the private (local) and any public
	// (observed) IP addresses in use by the device (this information can be obtained
	// by various means, for example from some DNS servers).
	//
	// If the allocated and observed IP addresses are the same (i.e. NAT is not in use)
	// then the same address should be specified for both publicAddress and
	// privateAddress.
	//
	// If NAT64 is in use, the device should be identified by its publicAddress and
	// publicPort, or separately by its allocated IPv6 address (field ipv6Address of
	// the Device object)
	//
	// In all cases, publicAddress must be specified, along with at least one of either
	// privateAddress or publicPort, dependent upon which is known. In general, mobile
	// devices cannot be identified by their public IPv4 address alone.
	Ipv4Address DeviceReachabilityStatusConfigSubscriptionDetailDeviceIpv4Address `json:"ipv4Address"`
	// The device should be identified by the observed IPv6 address, or by any single
	// IPv6 address from within the subnet allocated to the device (e.g. adding ::0 to
	// the /64 prefix).
	Ipv6Address string `json:"ipv6Address" format:"ipv6"`
	// A public identifier addressing a subscription in a mobile network. In 3GPP
	// terminology, it corresponds to the GPSI formatted with the External Identifier
	// ({Local Identifier}@{Domain Identifier}). Unlike the telephone number, the
	// network access identifier is not subjected to portability ruling in force, and
	// is individually managed by each operator.
	NetworkAccessIdentifier string `json:"networkAccessIdentifier"`
	// A public identifier addressing a telephone subscription. In mobile networks it
	// corresponds to the MSISDN (Mobile Station International Subscriber Directory
	// Number). In order to be globally unique it has to be formatted in international
	// format, according to E.164 standard, prefixed with '+'.
	PhoneNumber string `json:"phoneNumber"`
	// JSON contains metadata for fields, check presence with [respjson.Field.Valid].
	JSON struct {
		Ipv4Address             respjson.Field
		Ipv6Address             respjson.Field
		NetworkAccessIdentifier respjson.Field
		PhoneNumber             respjson.Field
		ExtraFields             map[string]respjson.Field
		// contains filtered or unexported fields
	} `json:"-"`
}

End-user equipment able to connect to a mobile network. Examples of devices include smartphones or IoT sensors/actuators.

The developer can choose to provide the below specified device identifiers:

- `ipv4Address` - `ipv6Address` - `phoneNumber` - `networkAccessIdentifier`

NOTE: the MNO might support only a subset of these options. The API invoker can provide multiple identifiers to be compatible across different MNOs. In this case the identifiers MUST belong to the same device.

func (DeviceReachabilityStatusConfigSubscriptionDetailDevice) RawJSON 

func (r DeviceReachabilityStatusConfigSubscriptionDetailDevice) RawJSON() string

Returns the unmodified JSON received from the API

func (*DeviceReachabilityStatusConfigSubscriptionDetailDevice) UnmarshalJSON 

func (r *DeviceReachabilityStatusConfigSubscriptionDetailDevice) UnmarshalJSON(data []byte) error

type DeviceReachabilityStatusConfigSubscriptionDetailDeviceIpv4Address 

type DeviceReachabilityStatusConfigSubscriptionDetailDeviceIpv4Address struct {
	// A single IPv4 address with no subnet mask
	PrivateAddress string `json:"privateAddress" format:"ipv4"`
	// A single IPv4 address with no subnet mask
	PublicAddress string `json:"publicAddress" format:"ipv4"`
	// TCP or UDP port number
	PublicPort int64 `json:"publicPort"`
	// JSON contains metadata for fields, check presence with [respjson.Field.Valid].
	JSON struct {
		PrivateAddress respjson.Field
		PublicAddress  respjson.Field
		PublicPort     respjson.Field
		ExtraFields    map[string]respjson.Field
		// contains filtered or unexported fields
	} `json:"-"`
}

The device should be identified by either the public (observed) IP address and port as seen by the application server, or the private (local) and any public (observed) IP addresses in use by the device (this information can be obtained by various means, for example from some DNS servers).

If the allocated and observed IP addresses are the same (i.e. NAT is not in use) then the same address should be specified for both publicAddress and privateAddress.

If NAT64 is in use, the device should be identified by its publicAddress and publicPort, or separately by its allocated IPv6 address (field ipv6Address of the Device object)

In all cases, publicAddress must be specified, along with at least one of either privateAddress or publicPort, dependent upon which is known. In general, mobile devices cannot be identified by their public IPv4 address alone.

func (DeviceReachabilityStatusConfigSubscriptionDetailDeviceIpv4Address) RawJSON 

func (r DeviceReachabilityStatusConfigSubscriptionDetailDeviceIpv4Address) RawJSON() string

Returns the unmodified JSON received from the API

func (*DeviceReachabilityStatusConfigSubscriptionDetailDeviceIpv4Address) UnmarshalJSON 

func (r *DeviceReachabilityStatusConfigSubscriptionDetailDeviceIpv4Address) UnmarshalJSON(data []byte) error

type DeviceReachabilityStatusConfigSubscriptionDetailDeviceIpv4AddressParam 

type DeviceReachabilityStatusConfigSubscriptionDetailDeviceIpv4AddressParam struct {
	// A single IPv4 address with no subnet mask
	PrivateAddress param.Opt[string] `json:"privateAddress,omitzero" format:"ipv4"`
	// A single IPv4 address with no subnet mask
	PublicAddress param.Opt[string] `json:"publicAddress,omitzero" format:"ipv4"`
	// TCP or UDP port number
	PublicPort param.Opt[int64] `json:"publicPort,omitzero"`
	// contains filtered or unexported fields
}

The device should be identified by either the public (observed) IP address and port as seen by the application server, or the private (local) and any public (observed) IP addresses in use by the device (this information can be obtained by various means, for example from some DNS servers).

If the allocated and observed IP addresses are the same (i.e. NAT is not in use) then the same address should be specified for both publicAddress and privateAddress.

If NAT64 is in use, the device should be identified by its publicAddress and publicPort, or separately by its allocated IPv6 address (field ipv6Address of the Device object)

In all cases, publicAddress must be specified, along with at least one of either privateAddress or publicPort, dependent upon which is known. In general, mobile devices cannot be identified by their public IPv4 address alone.

func (DeviceReachabilityStatusConfigSubscriptionDetailDeviceIpv4AddressParam) MarshalJSON 

func (r DeviceReachabilityStatusConfigSubscriptionDetailDeviceIpv4AddressParam) MarshalJSON() (data []byte, err error)

func (*DeviceReachabilityStatusConfigSubscriptionDetailDeviceIpv4AddressParam) UnmarshalJSON 

func (r *DeviceReachabilityStatusConfigSubscriptionDetailDeviceIpv4AddressParam) UnmarshalJSON(data []byte) error

type DeviceReachabilityStatusConfigSubscriptionDetailDeviceParam 

type DeviceReachabilityStatusConfigSubscriptionDetailDeviceParam struct {
	// The device should be identified by the observed IPv6 address, or by any single
	// IPv6 address from within the subnet allocated to the device (e.g. adding ::0 to
	// the /64 prefix).
	Ipv6Address param.Opt[string] `json:"ipv6Address,omitzero" format:"ipv6"`
	// A public identifier addressing a subscription in a mobile network. In 3GPP
	// terminology, it corresponds to the GPSI formatted with the External Identifier
	// ({Local Identifier}@{Domain Identifier}). Unlike the telephone number, the
	// network access identifier is not subjected to portability ruling in force, and
	// is individually managed by each operator.
	NetworkAccessIdentifier param.Opt[string] `json:"networkAccessIdentifier,omitzero"`
	// A public identifier addressing a telephone subscription. In mobile networks it
	// corresponds to the MSISDN (Mobile Station International Subscriber Directory
	// Number). In order to be globally unique it has to be formatted in international
	// format, according to E.164 standard, prefixed with '+'.
	PhoneNumber param.Opt[string] `json:"phoneNumber,omitzero"`
	// The device should be identified by either the public (observed) IP address and
	// port as seen by the application server, or the private (local) and any public
	// (observed) IP addresses in use by the device (this information can be obtained
	// by various means, for example from some DNS servers).
	//
	// If the allocated and observed IP addresses are the same (i.e. NAT is not in use)
	// then the same address should be specified for both publicAddress and
	// privateAddress.
	//
	// If NAT64 is in use, the device should be identified by its publicAddress and
	// publicPort, or separately by its allocated IPv6 address (field ipv6Address of
	// the Device object)
	//
	// In all cases, publicAddress must be specified, along with at least one of either
	// privateAddress or publicPort, dependent upon which is known. In general, mobile
	// devices cannot be identified by their public IPv4 address alone.
	Ipv4Address DeviceReachabilityStatusConfigSubscriptionDetailDeviceIpv4AddressParam `json:"ipv4Address,omitzero"`
	// contains filtered or unexported fields
}

End-user equipment able to connect to a mobile network. Examples of devices include smartphones or IoT sensors/actuators.

The developer can choose to provide the below specified device identifiers:

- `ipv4Address` - `ipv6Address` - `phoneNumber` - `networkAccessIdentifier`

NOTE: the MNO might support only a subset of these options. The API invoker can provide multiple identifiers to be compatible across different MNOs. In this case the identifiers MUST belong to the same device.

func (DeviceReachabilityStatusConfigSubscriptionDetailDeviceParam) MarshalJSON 

func (r DeviceReachabilityStatusConfigSubscriptionDetailDeviceParam) MarshalJSON() (data []byte, err error)

func (*DeviceReachabilityStatusConfigSubscriptionDetailDeviceParam) UnmarshalJSON 

func (r *DeviceReachabilityStatusConfigSubscriptionDetailDeviceParam) UnmarshalJSON(data []byte) error

type DeviceReachabilityStatusConfigSubscriptionDetailParam 

type DeviceReachabilityStatusConfigSubscriptionDetailParam struct {
	// End-user equipment able to connect to a mobile network. Examples of devices
	// include smartphones or IoT sensors/actuators.
	//
	// The developer can choose to provide the below specified device identifiers:
	//
	// - `ipv4Address`
	// - `ipv6Address`
	// - `phoneNumber`
	// - `networkAccessIdentifier`
	//
	// NOTE: the MNO might support only a subset of these options. The API invoker can
	// provide multiple identifiers to be compatible across different MNOs. In this
	// case the identifiers MUST belong to the same device.
	Device DeviceReachabilityStatusConfigSubscriptionDetailDeviceParam `json:"device,omitzero"`
	// contains filtered or unexported fields
}

The detail of the requested event subscription.

func (DeviceReachabilityStatusConfigSubscriptionDetailParam) MarshalJSON 

func (r DeviceReachabilityStatusConfigSubscriptionDetailParam) MarshalJSON() (data []byte, err error)

func (*DeviceReachabilityStatusConfigSubscriptionDetailParam) UnmarshalJSON 

func (r *DeviceReachabilityStatusConfigSubscriptionDetailParam) UnmarshalJSON(data []byte) error

type DeviceReachabilityStatusProtocol 

type DeviceReachabilityStatusProtocol string

Identifier of a delivery protocol. Only HTTP is allowed for now 

const (
	DeviceReachabilityStatusProtocolHTTP  DeviceReachabilityStatusProtocol = "HTTP"
	DeviceReachabilityStatusProtocolMqtt3 DeviceReachabilityStatusProtocol = "MQTT3"
	DeviceReachabilityStatusProtocolMqtt5 DeviceReachabilityStatusProtocol = "MQTT5"
	DeviceReachabilityStatusProtocolAmqp  DeviceReachabilityStatusProtocol = "AMQP"
	DeviceReachabilityStatusProtocolNats  DeviceReachabilityStatusProtocol = "NATS"
	DeviceReachabilityStatusProtocolKafka DeviceReachabilityStatusProtocol = "KAFKA"
)

type DeviceReachabilityStatusSubscription 

type DeviceReachabilityStatusSubscription struct {
	// The unique identifier of the subscription in the scope of the subscription
	// manager. When this information is contained within an event notification, this
	// concept SHALL be referred as subscriptionId as per Commonalities Event
	// Notification Model.
	ID string `json:"id" api:"required"`
	// Implementation-specific configuration parameters needed by the subscription
	// manager for acquiring events. In CAMARA we have predefined attributes like
	// `subscriptionExpireTime`, `subscriptionMaxEvents`, `initialEvent` Specific event
	// type attributes must be defined in `subscriptionDetail` Note: if a request is
	// performed for several event type, all subscribed event will use same `config`
	// parameters.
	Config DeviceReachabilityStatusConfig `json:"config" api:"required"`
	// Identifier of a delivery protocol. Only HTTP is allowed for now
	//
	// Any of "HTTP", "MQTT3", "MQTT5", "AMQP", "NATS", "KAFKA".
	Protocol DeviceReachabilityStatusProtocol `json:"protocol" api:"required"`
	// The address to which events shall be delivered using the selected protocol.
	Sink string `json:"sink" api:"required" format:"uri"`
	// Camara Event types eligible to be delivered by this subscription. Note: For the
	// current Commonalities API design guidelines, only one event type per
	// subscription is allowed
	Types []DeviceReachabilityStatusSubscriptionEventType `json:"types" api:"required"`
	// Date when the event subscription will expire. Only provided when
	// `subscriptionExpireTime` is indicated by API client or Telco Operator has
	// specific policy about that. It must follow
	// [RFC 3339](https://datatracker.ietf.org/doc/html/rfc3339#section-5.6) and must
	// have time zone. Recommended format is yyyy-MM-dd'T'HH:mm:ss.SSSZ (i.e. which
	// allows 2023-07-03T14:27:08.312+02:00 or 2023-07-03T12:27:08.312Z)
	ExpiresAt time.Time `json:"expiresAt" format:"date-time"`
	// Date when the event subscription will begin/began It must follow
	// [RFC 3339](https://datatracker.ietf.org/doc/html/rfc3339#section-5.6) and must
	// have time zone. Recommended format is yyyy-MM-dd'T'HH:mm:ss.SSSZ (i.e. which
	// allows 2023-07-03T14:27:08.312+02:00 or 2023-07-03T12:27:08.312Z)
	StartsAt time.Time `json:"startsAt" format:"date-time"`
	// Current status of the subscription - Management of Subscription State engine is
	// not mandatory for now. Note not all statuses may be considered to be
	// implemented. Details:
	//
	//   - `ACTIVATION_REQUESTED`: Subscription creation (POST) is triggered but
	//     subscription creation process is not finished yet.
	//   - `ACTIVE`: Subscription creation process is completed. Subscription is fully
	//     operative.
	//   - `INACTIVE`: Subscription is temporarily inactive, but its workflow logic is
	//     not deleted.
	//   - `EXPIRED`: Subscription is ended (no longer active). This status applies when
	//     subscription is ended due to `SUBSCRIPTION_EXPIRED` or `ACCESS_TOKEN_EXPIRED`
	//     event.
	//   - `DELETED`: Subscription is ended as deleted (no longer active). This status
	//     applies when subscription information is kept (i.e. subscription workflow is
	//     no longer active but its meta-information is kept).
	//
	// Any of "ACTIVATION_REQUESTED", "ACTIVE", "EXPIRED", "INACTIVE", "DELETED".
	Status DeviceReachabilityStatusSubscriptionStatus `json:"status"`
	// JSON contains metadata for fields, check presence with [respjson.Field.Valid].
	JSON struct {
		ID          respjson.Field
		Config      respjson.Field
		Protocol    respjson.Field
		Sink        respjson.Field
		Types       respjson.Field
		ExpiresAt   respjson.Field
		StartsAt    respjson.Field
		Status      respjson.Field
		ExtraFields map[string]respjson.Field
		// contains filtered or unexported fields
	} `json:"-"`
}

Represents a event-type subscription.

func (DeviceReachabilityStatusSubscription) RawJSON 

func (r DeviceReachabilityStatusSubscription) RawJSON() string

Returns the unmodified JSON received from the API

func (*DeviceReachabilityStatusSubscription) UnmarshalJSON 

func (r *DeviceReachabilityStatusSubscription) UnmarshalJSON(data []byte) error

type DeviceReachabilityStatusSubscriptionEventType 

type DeviceReachabilityStatusSubscriptionEventType string

reachability-data - Event triggered when the device is connected to the network for Data usage (regardless of the SMS reachability).

reachability-sms - Event triggered when the device is connected to the network only for SMS usage

reachability-disconnected - Event triggered when the device is not connected. 

const (
	DeviceReachabilityStatusSubscriptionEventTypeOrgCamaraprojectDeviceReachabilityStatusSubscriptionsV0ReachabilityData         DeviceReachabilityStatusSubscriptionEventType = "org.camaraproject.device-reachability-status-subscriptions.v0.reachability-data"
	DeviceReachabilityStatusSubscriptionEventTypeOrgCamaraprojectDeviceReachabilityStatusSubscriptionsV0ReachabilitySMS          DeviceReachabilityStatusSubscriptionEventType = "org.camaraproject.device-reachability-status-subscriptions.v0.reachability-sms"
	DeviceReachabilityStatusSubscriptionEventTypeOrgCamaraprojectDeviceReachabilityStatusSubscriptionsV0ReachabilityDisconnected DeviceReachabilityStatusSubscriptionEventType = "org.camaraproject.device-reachability-status-subscriptions.v0.reachability-disconnected"
)

type DeviceReachabilityStatusSubscriptionStatus 

type DeviceReachabilityStatusSubscriptionStatus string

Current status of the subscription - Management of Subscription State engine is not mandatory for now. Note not all statuses may be considered to be implemented. Details:

  • `ACTIVATION_REQUESTED`: Subscription creation (POST) is triggered but subscription creation process is not finished yet.
  • `ACTIVE`: Subscription creation process is completed. Subscription is fully operative.
  • `INACTIVE`: Subscription is temporarily inactive, but its workflow logic is not deleted.
  • `EXPIRED`: Subscription is ended (no longer active). This status applies when subscription is ended due to `SUBSCRIPTION_EXPIRED` or `ACCESS_TOKEN_EXPIRED` event.
  • `DELETED`: Subscription is ended as deleted (no longer active). This status applies when subscription information is kept (i.e. subscription workflow is no longer active but its meta-information is kept).
const (
	DeviceReachabilityStatusSubscriptionStatusActivationRequested DeviceReachabilityStatusSubscriptionStatus = "ACTIVATION_REQUESTED"
	DeviceReachabilityStatusSubscriptionStatusActive              DeviceReachabilityStatusSubscriptionStatus = "ACTIVE"
	DeviceReachabilityStatusSubscriptionStatusExpired             DeviceReachabilityStatusSubscriptionStatus = "EXPIRED"
	DeviceReachabilityStatusSubscriptionStatusInactive            DeviceReachabilityStatusSubscriptionStatus = "INACTIVE"
	DeviceReachabilityStatusSubscriptionStatusDeleted             DeviceReachabilityStatusSubscriptionStatus = "DELETED"
)

type DeviceRoamingStatusConfig 

type DeviceRoamingStatusConfig struct {
	// The detail of the requested event subscription.
	SubscriptionDetail DeviceRoamingStatusConfigSubscriptionDetail `json:"subscriptionDetail" api:"required"`
	// Set to `true` by API consumer if consumer wants to get an event as soon as the
	// subscription is created and current situation reflects event request. Example:
	// Consumer request Roaming event. If consumer sets initialEvent to true and device
	// is in roaming situation, an event is triggered.
	InitialEvent bool `json:"initialEvent"`
	// The subscription expiration time (in date-time format) requested by the API
	// consumer. It must follow
	// [RFC 3339](https://datatracker.ietf.org/doc/html/rfc3339#section-5.6) and must
	// have time zone.
	SubscriptionExpireTime time.Time `json:"subscriptionExpireTime" format:"date-time"`
	// Identifies the maximum number of event reports to be generated (>=1) requested
	// by the API consumer - Once this number is reached, the subscription ends.
	SubscriptionMaxEvents int64 `json:"subscriptionMaxEvents"`
	// JSON contains metadata for fields, check presence with [respjson.Field.Valid].
	JSON struct {
		SubscriptionDetail     respjson.Field
		InitialEvent           respjson.Field
		SubscriptionExpireTime respjson.Field
		SubscriptionMaxEvents  respjson.Field
		ExtraFields            map[string]respjson.Field
		// contains filtered or unexported fields
	} `json:"-"`
}

Implementation-specific configuration parameters needed by the subscription manager for acquiring events. In CAMARA we have predefined attributes like `subscriptionExpireTime`, `subscriptionMaxEvents`, `initialEvent` Specific event type attributes must be defined in `subscriptionDetail` Note: if a request is performed for several event type, all subscribed event will use same `config` parameters.

func (DeviceRoamingStatusConfig) RawJSON 

func (r DeviceRoamingStatusConfig) RawJSON() string

Returns the unmodified JSON received from the API

func (DeviceRoamingStatusConfig) ToParam 

func (r DeviceRoamingStatusConfig) ToParam() DeviceRoamingStatusConfigParam

ToParam converts this DeviceRoamingStatusConfig to a DeviceRoamingStatusConfigParam.

Warning: the fields of the param type will not be present. ToParam should only be used at the last possible moment before sending a request. Test for this with DeviceRoamingStatusConfigParam.Overrides()

func (*DeviceRoamingStatusConfig) UnmarshalJSON 

func (r *DeviceRoamingStatusConfig) UnmarshalJSON(data []byte) error

type DeviceRoamingStatusConfigParam 

type DeviceRoamingStatusConfigParam struct {
	// The detail of the requested event subscription.
	SubscriptionDetail DeviceRoamingStatusConfigSubscriptionDetailParam `json:"subscriptionDetail,omitzero" api:"required"`
	// Set to `true` by API consumer if consumer wants to get an event as soon as the
	// subscription is created and current situation reflects event request. Example:
	// Consumer request Roaming event. If consumer sets initialEvent to true and device
	// is in roaming situation, an event is triggered.
	InitialEvent param.Opt[bool] `json:"initialEvent,omitzero"`
	// The subscription expiration time (in date-time format) requested by the API
	// consumer. It must follow
	// [RFC 3339](https://datatracker.ietf.org/doc/html/rfc3339#section-5.6) and must
	// have time zone.
	SubscriptionExpireTime param.Opt[time.Time] `json:"subscriptionExpireTime,omitzero" format:"date-time"`
	// Identifies the maximum number of event reports to be generated (>=1) requested
	// by the API consumer - Once this number is reached, the subscription ends.
	SubscriptionMaxEvents param.Opt[int64] `json:"subscriptionMaxEvents,omitzero"`
	// contains filtered or unexported fields
}

Implementation-specific configuration parameters needed by the subscription manager for acquiring events. In CAMARA we have predefined attributes like `subscriptionExpireTime`, `subscriptionMaxEvents`, `initialEvent` Specific event type attributes must be defined in `subscriptionDetail` Note: if a request is performed for several event type, all subscribed event will use same `config` parameters.

The property SubscriptionDetail is required.

func (DeviceRoamingStatusConfigParam) MarshalJSON 

func (r DeviceRoamingStatusConfigParam) MarshalJSON() (data []byte, err error)

func (*DeviceRoamingStatusConfigParam) UnmarshalJSON 

func (r *DeviceRoamingStatusConfigParam) UnmarshalJSON(data []byte) error

type DeviceRoamingStatusConfigSubscriptionDetail 

type DeviceRoamingStatusConfigSubscriptionDetail struct {
	// End-user equipment able to connect to a mobile network. Examples of devices
	// include smartphones or IoT sensors/actuators.
	//
	// The developer can choose to provide the below specified device identifiers:
	//
	// - `ipv4Address`
	// - `ipv6Address`
	// - `phoneNumber`
	// - `networkAccessIdentifier`
	//
	// NOTE: the MNO might support only a subset of these options. The API invoker can
	// provide multiple identifiers to be compatible across different MNOs. In this
	// case the identifiers MUST belong to the same device.
	Device DeviceRoamingStatusConfigSubscriptionDetailDevice `json:"device"`
	// JSON contains metadata for fields, check presence with [respjson.Field.Valid].
	JSON struct {
		Device      respjson.Field
		ExtraFields map[string]respjson.Field
		// contains filtered or unexported fields
	} `json:"-"`
}

The detail of the requested event subscription.

func (DeviceRoamingStatusConfigSubscriptionDetail) RawJSON 

func (r DeviceRoamingStatusConfigSubscriptionDetail) RawJSON() string

Returns the unmodified JSON received from the API

func (*DeviceRoamingStatusConfigSubscriptionDetail) UnmarshalJSON 

func (r *DeviceRoamingStatusConfigSubscriptionDetail) UnmarshalJSON(data []byte) error

type DeviceRoamingStatusConfigSubscriptionDetailDevice 

type DeviceRoamingStatusConfigSubscriptionDetailDevice struct {
	// The device should be identified by either the public (observed) IP address and
	// port as seen by the application server, or the private (local) and any public
	// (observed) IP addresses in use by the device (this information can be obtained
	// by various means, for example from some DNS servers).
	//
	// If the allocated and observed IP addresses are the same (i.e. NAT is not in use)
	// then the same address should be specified for both publicAddress and
	// privateAddress.
	//
	// If NAT64 is in use, the device should be identified by its publicAddress and
	// publicPort, or separately by its allocated IPv6 address (field ipv6Address of
	// the Device object)
	//
	// In all cases, publicAddress must be specified, along with at least one of either
	// privateAddress or publicPort, dependent upon which is known. In general, mobile
	// devices cannot be identified by their public IPv4 address alone.
	Ipv4Address DeviceRoamingStatusConfigSubscriptionDetailDeviceIpv4Address `json:"ipv4Address"`
	// The device should be identified by the observed IPv6 address, or by any single
	// IPv6 address from within the subnet allocated to the device (e.g. adding ::0 to
	// the /64 prefix).
	Ipv6Address string `json:"ipv6Address" format:"ipv6"`
	// A public identifier addressing a subscription in a mobile network. In 3GPP
	// terminology, it corresponds to the GPSI formatted with the External Identifier
	// ({Local Identifier}@{Domain Identifier}). Unlike the telephone number, the
	// network access identifier is not subjected to portability ruling in force, and
	// is individually managed by each operator.
	NetworkAccessIdentifier string `json:"networkAccessIdentifier"`
	// A public identifier addressing a telephone subscription. In mobile networks it
	// corresponds to the MSISDN (Mobile Station International Subscriber Directory
	// Number). In order to be globally unique it has to be formatted in international
	// format, according to E.164 standard, prefixed with '+'.
	PhoneNumber string `json:"phoneNumber"`
	// JSON contains metadata for fields, check presence with [respjson.Field.Valid].
	JSON struct {
		Ipv4Address             respjson.Field
		Ipv6Address             respjson.Field
		NetworkAccessIdentifier respjson.Field
		PhoneNumber             respjson.Field
		ExtraFields             map[string]respjson.Field
		// contains filtered or unexported fields
	} `json:"-"`
}

End-user equipment able to connect to a mobile network. Examples of devices include smartphones or IoT sensors/actuators.

The developer can choose to provide the below specified device identifiers:

- `ipv4Address` - `ipv6Address` - `phoneNumber` - `networkAccessIdentifier`

NOTE: the MNO might support only a subset of these options. The API invoker can provide multiple identifiers to be compatible across different MNOs. In this case the identifiers MUST belong to the same device.

func (DeviceRoamingStatusConfigSubscriptionDetailDevice) RawJSON 

func (r DeviceRoamingStatusConfigSubscriptionDetailDevice) RawJSON() string

Returns the unmodified JSON received from the API

func (*DeviceRoamingStatusConfigSubscriptionDetailDevice) UnmarshalJSON 

func (r *DeviceRoamingStatusConfigSubscriptionDetailDevice) UnmarshalJSON(data []byte) error

type DeviceRoamingStatusConfigSubscriptionDetailDeviceIpv4Address 

type DeviceRoamingStatusConfigSubscriptionDetailDeviceIpv4Address struct {
	// A single IPv4 address with no subnet mask
	PrivateAddress string `json:"privateAddress" format:"ipv4"`
	// A single IPv4 address with no subnet mask
	PublicAddress string `json:"publicAddress" format:"ipv4"`
	// TCP or UDP port number
	PublicPort int64 `json:"publicPort"`
	// JSON contains metadata for fields, check presence with [respjson.Field.Valid].
	JSON struct {
		PrivateAddress respjson.Field
		PublicAddress  respjson.Field
		PublicPort     respjson.Field
		ExtraFields    map[string]respjson.Field
		// contains filtered or unexported fields
	} `json:"-"`
}

The device should be identified by either the public (observed) IP address and port as seen by the application server, or the private (local) and any public (observed) IP addresses in use by the device (this information can be obtained by various means, for example from some DNS servers).

If the allocated and observed IP addresses are the same (i.e. NAT is not in use) then the same address should be specified for both publicAddress and privateAddress.

If NAT64 is in use, the device should be identified by its publicAddress and publicPort, or separately by its allocated IPv6 address (field ipv6Address of the Device object)

In all cases, publicAddress must be specified, along with at least one of either privateAddress or publicPort, dependent upon which is known. In general, mobile devices cannot be identified by their public IPv4 address alone.

func (DeviceRoamingStatusConfigSubscriptionDetailDeviceIpv4Address) RawJSON 

func (r DeviceRoamingStatusConfigSubscriptionDetailDeviceIpv4Address) RawJSON() string

Returns the unmodified JSON received from the API

func (*DeviceRoamingStatusConfigSubscriptionDetailDeviceIpv4Address) UnmarshalJSON 

func (r *DeviceRoamingStatusConfigSubscriptionDetailDeviceIpv4Address) UnmarshalJSON(data []byte) error

type DeviceRoamingStatusConfigSubscriptionDetailDeviceIpv4AddressParam 

type DeviceRoamingStatusConfigSubscriptionDetailDeviceIpv4AddressParam struct {
	// A single IPv4 address with no subnet mask
	PrivateAddress param.Opt[string] `json:"privateAddress,omitzero" format:"ipv4"`
	// A single IPv4 address with no subnet mask
	PublicAddress param.Opt[string] `json:"publicAddress,omitzero" format:"ipv4"`
	// TCP or UDP port number
	PublicPort param.Opt[int64] `json:"publicPort,omitzero"`
	// contains filtered or unexported fields
}

The device should be identified by either the public (observed) IP address and port as seen by the application server, or the private (local) and any public (observed) IP addresses in use by the device (this information can be obtained by various means, for example from some DNS servers).

If the allocated and observed IP addresses are the same (i.e. NAT is not in use) then the same address should be specified for both publicAddress and privateAddress.

If NAT64 is in use, the device should be identified by its publicAddress and publicPort, or separately by its allocated IPv6 address (field ipv6Address of the Device object)

In all cases, publicAddress must be specified, along with at least one of either privateAddress or publicPort, dependent upon which is known. In general, mobile devices cannot be identified by their public IPv4 address alone.

func (DeviceRoamingStatusConfigSubscriptionDetailDeviceIpv4AddressParam) MarshalJSON 

func (r DeviceRoamingStatusConfigSubscriptionDetailDeviceIpv4AddressParam) MarshalJSON() (data []byte, err error)

func (*DeviceRoamingStatusConfigSubscriptionDetailDeviceIpv4AddressParam) UnmarshalJSON 

func (r *DeviceRoamingStatusConfigSubscriptionDetailDeviceIpv4AddressParam) UnmarshalJSON(data []byte) error

type DeviceRoamingStatusConfigSubscriptionDetailDeviceParam 

type DeviceRoamingStatusConfigSubscriptionDetailDeviceParam struct {
	// The device should be identified by the observed IPv6 address, or by any single
	// IPv6 address from within the subnet allocated to the device (e.g. adding ::0 to
	// the /64 prefix).
	Ipv6Address param.Opt[string] `json:"ipv6Address,omitzero" format:"ipv6"`
	// A public identifier addressing a subscription in a mobile network. In 3GPP
	// terminology, it corresponds to the GPSI formatted with the External Identifier
	// ({Local Identifier}@{Domain Identifier}). Unlike the telephone number, the
	// network access identifier is not subjected to portability ruling in force, and
	// is individually managed by each operator.
	NetworkAccessIdentifier param.Opt[string] `json:"networkAccessIdentifier,omitzero"`
	// A public identifier addressing a telephone subscription. In mobile networks it
	// corresponds to the MSISDN (Mobile Station International Subscriber Directory
	// Number). In order to be globally unique it has to be formatted in international
	// format, according to E.164 standard, prefixed with '+'.
	PhoneNumber param.Opt[string] `json:"phoneNumber,omitzero"`
	// The device should be identified by either the public (observed) IP address and
	// port as seen by the application server, or the private (local) and any public
	// (observed) IP addresses in use by the device (this information can be obtained
	// by various means, for example from some DNS servers).
	//
	// If the allocated and observed IP addresses are the same (i.e. NAT is not in use)
	// then the same address should be specified for both publicAddress and
	// privateAddress.
	//
	// If NAT64 is in use, the device should be identified by its publicAddress and
	// publicPort, or separately by its allocated IPv6 address (field ipv6Address of
	// the Device object)
	//
	// In all cases, publicAddress must be specified, along with at least one of either
	// privateAddress or publicPort, dependent upon which is known. In general, mobile
	// devices cannot be identified by their public IPv4 address alone.
	Ipv4Address DeviceRoamingStatusConfigSubscriptionDetailDeviceIpv4AddressParam `json:"ipv4Address,omitzero"`
	// contains filtered or unexported fields
}

End-user equipment able to connect to a mobile network. Examples of devices include smartphones or IoT sensors/actuators.

The developer can choose to provide the below specified device identifiers:

- `ipv4Address` - `ipv6Address` - `phoneNumber` - `networkAccessIdentifier`

NOTE: the MNO might support only a subset of these options. The API invoker can provide multiple identifiers to be compatible across different MNOs. In this case the identifiers MUST belong to the same device.

func (DeviceRoamingStatusConfigSubscriptionDetailDeviceParam) MarshalJSON 

func (r DeviceRoamingStatusConfigSubscriptionDetailDeviceParam) MarshalJSON() (data []byte, err error)

func (*DeviceRoamingStatusConfigSubscriptionDetailDeviceParam) UnmarshalJSON 

func (r *DeviceRoamingStatusConfigSubscriptionDetailDeviceParam) UnmarshalJSON(data []byte) error

type DeviceRoamingStatusConfigSubscriptionDetailParam 

type DeviceRoamingStatusConfigSubscriptionDetailParam struct {
	// End-user equipment able to connect to a mobile network. Examples of devices
	// include smartphones or IoT sensors/actuators.
	//
	// The developer can choose to provide the below specified device identifiers:
	//
	// - `ipv4Address`
	// - `ipv6Address`
	// - `phoneNumber`
	// - `networkAccessIdentifier`
	//
	// NOTE: the MNO might support only a subset of these options. The API invoker can
	// provide multiple identifiers to be compatible across different MNOs. In this
	// case the identifiers MUST belong to the same device.
	Device DeviceRoamingStatusConfigSubscriptionDetailDeviceParam `json:"device,omitzero"`
	// contains filtered or unexported fields
}

The detail of the requested event subscription.

func (DeviceRoamingStatusConfigSubscriptionDetailParam) MarshalJSON 

func (r DeviceRoamingStatusConfigSubscriptionDetailParam) MarshalJSON() (data []byte, err error)

func (*DeviceRoamingStatusConfigSubscriptionDetailParam) UnmarshalJSON 

func (r *DeviceRoamingStatusConfigSubscriptionDetailParam) UnmarshalJSON(data []byte) error

type DeviceRoamingStatusProtocol 

type DeviceRoamingStatusProtocol string

Identifier of a delivery protocol. Only HTTP is allowed for now 

const (
	DeviceRoamingStatusProtocolHTTP  DeviceRoamingStatusProtocol = "HTTP"
	DeviceRoamingStatusProtocolMqtt3 DeviceRoamingStatusProtocol = "MQTT3"
	DeviceRoamingStatusProtocolMqtt5 DeviceRoamingStatusProtocol = "MQTT5"
	DeviceRoamingStatusProtocolAmqp  DeviceRoamingStatusProtocol = "AMQP"
	DeviceRoamingStatusProtocolNats  DeviceRoamingStatusProtocol = "NATS"
	DeviceRoamingStatusProtocolKafka DeviceRoamingStatusProtocol = "KAFKA"
)

type DeviceRoamingStatusSubscription 

type DeviceRoamingStatusSubscription struct {
	// The unique identifier of the subscription in the scope of the subscription
	// manager. When this information is contained within an event notification, this
	// concept SHALL be referred as subscriptionId as per Commonalities Event
	// Notification Model.
	ID string `json:"id" api:"required"`
	// Implementation-specific configuration parameters needed by the subscription
	// manager for acquiring events. In CAMARA we have predefined attributes like
	// `subscriptionExpireTime`, `subscriptionMaxEvents`, `initialEvent` Specific event
	// type attributes must be defined in `subscriptionDetail` Note: if a request is
	// performed for several event type, all subscribed event will use same `config`
	// parameters.
	Config DeviceRoamingStatusConfig `json:"config" api:"required"`
	// Identifier of a delivery protocol. Only HTTP is allowed for now
	//
	// Any of "HTTP", "MQTT3", "MQTT5", "AMQP", "NATS", "KAFKA".
	Protocol DeviceRoamingStatusProtocol `json:"protocol" api:"required"`
	// The address to which events shall be delivered using the selected protocol.
	Sink string `json:"sink" api:"required" format:"uri"`
	// Camara Event types eligible to be delivered by this subscription. Note: for the
	// Commonalities meta-release v0.4 we enforce to have only event type per
	// subscription then for following meta-release use of array MUST be decided at API
	// project level.
	Types []DeviceRoamingStatusSubscriptionEventType `json:"types" api:"required"`
	// Date when the event subscription will expire. Only provided when
	// `subscriptionExpireTime` is indicated by API client or Telco Operator has
	// specific policy about that. It must follow
	// [RFC 3339](https://datatracker.ietf.org/doc/html/rfc3339#section-5.6) and must
	// have time zone.
	ExpiresAt time.Time `json:"expiresAt" format:"date-time"`
	// Date when the event subscription will begin/began It must follow
	// [RFC 3339](https://datatracker.ietf.org/doc/html/rfc3339#section-5.6) and must
	// have time zone.
	StartsAt time.Time `json:"startsAt" format:"date-time"`
	// Current status of the subscription - Management of Subscription State engine is
	// not mandatory for now. Note not all statuses may be considered to be
	// implemented. Details:
	//
	//   - `ACTIVATION_REQUESTED`: Subscription creation (POST) is triggered but
	//     subscription creation process is not finished yet.
	//   - `ACTIVE`: Subscription creation process is completed. Subscription is fully
	//     operative.
	//   - `INACTIVE`: Subscription is temporarily inactive, but its workflow logic is
	//     not deleted.
	//   - `EXPIRED`: Subscription is ended (no longer active). This status applies when
	//     subscription is ended due to `SUBSCRIPTION_EXPIRED` or `ACCESS_TOKEN_EXPIRED`
	//     event.
	//   - `DELETED`: Subscription is ended as deleted (no longer active). This status
	//     applies when subscription information is kept (i.e. subscription workflow is
	//     no longer active but its meta-information is kept).
	//
	// Any of "ACTIVATION_REQUESTED", "ACTIVE", "EXPIRED", "INACTIVE", "DELETED".
	Status DeviceRoamingStatusSubscriptionStatus `json:"status"`
	// JSON contains metadata for fields, check presence with [respjson.Field.Valid].
	JSON struct {
		ID          respjson.Field
		Config      respjson.Field
		Protocol    respjson.Field
		Sink        respjson.Field
		Types       respjson.Field
		ExpiresAt   respjson.Field
		StartsAt    respjson.Field
		Status      respjson.Field
		ExtraFields map[string]respjson.Field
		// contains filtered or unexported fields
	} `json:"-"`
}

Represents a event-type subscription.

func (DeviceRoamingStatusSubscription) RawJSON 

func (r DeviceRoamingStatusSubscription) RawJSON() string

Returns the unmodified JSON received from the API

func (*DeviceRoamingStatusSubscription) UnmarshalJSON 

func (r *DeviceRoamingStatusSubscription) UnmarshalJSON(data []byte) error

type DeviceRoamingStatusSubscriptionEventType 

type DeviceRoamingStatusSubscriptionEventType string

roaming-status - Event triggered when the device switch from roaming ON to roaming OFF and conversely

roaming-on - Event triggered when the device switch from roaming OFF to roaming ON

roaming-off - Event triggered when the device switch from roaming ON to roaming OFF

roaming-change-country - Event triggered when the device in roaming change country code 

const (
	DeviceRoamingStatusSubscriptionEventTypeOrgCamaraprojectDeviceRoamingStatusSubscriptionsV0RoamingStatus        DeviceRoamingStatusSubscriptionEventType = "org.camaraproject.device-roaming-status-subscriptions.v0.roaming-status"
	DeviceRoamingStatusSubscriptionEventTypeOrgCamaraprojectDeviceRoamingStatusSubscriptionsV0RoamingOn            DeviceRoamingStatusSubscriptionEventType = "org.camaraproject.device-roaming-status-subscriptions.v0.roaming-on"
	DeviceRoamingStatusSubscriptionEventTypeOrgCamaraprojectDeviceRoamingStatusSubscriptionsV0RoamingOff           DeviceRoamingStatusSubscriptionEventType = "org.camaraproject.device-roaming-status-subscriptions.v0.roaming-off"
	DeviceRoamingStatusSubscriptionEventTypeOrgCamaraprojectDeviceRoamingStatusSubscriptionsV0RoamingChangeCountry DeviceRoamingStatusSubscriptionEventType = "org.camaraproject.device-roaming-status-subscriptions.v0.roaming-change-country"
)

type DeviceRoamingStatusSubscriptionStatus 

type DeviceRoamingStatusSubscriptionStatus string

Current status of the subscription - Management of Subscription State engine is not mandatory for now. Note not all statuses may be considered to be implemented. Details:

  • `ACTIVATION_REQUESTED`: Subscription creation (POST) is triggered but subscription creation process is not finished yet.
  • `ACTIVE`: Subscription creation process is completed. Subscription is fully operative.
  • `INACTIVE`: Subscription is temporarily inactive, but its workflow logic is not deleted.
  • `EXPIRED`: Subscription is ended (no longer active). This status applies when subscription is ended due to `SUBSCRIPTION_EXPIRED` or `ACCESS_TOKEN_EXPIRED` event.
  • `DELETED`: Subscription is ended as deleted (no longer active). This status applies when subscription information is kept (i.e. subscription workflow is no longer active but its meta-information is kept).
const (
	DeviceRoamingStatusSubscriptionStatusActivationRequested DeviceRoamingStatusSubscriptionStatus = "ACTIVATION_REQUESTED"
	DeviceRoamingStatusSubscriptionStatusActive              DeviceRoamingStatusSubscriptionStatus = "ACTIVE"
	DeviceRoamingStatusSubscriptionStatusExpired             DeviceRoamingStatusSubscriptionStatus = "EXPIRED"
	DeviceRoamingStatusSubscriptionStatusInactive            DeviceRoamingStatusSubscriptionStatus = "INACTIVE"
	DeviceRoamingStatusSubscriptionStatusDeleted             DeviceRoamingStatusSubscriptionStatus = "DELETED"
)

type DeviceidentifierGetIdentifierParams 

type DeviceidentifierGetIdentifierParams struct {
	// Common request body to allow optional Device object to be passed
	DeviceIdentifierRequestBody DeviceIdentifierRequestBodyParam
	XCorrelator                 param.Opt[string] `header:"x-correlator,omitzero" json:"-"`
	// contains filtered or unexported fields
}

func (DeviceidentifierGetIdentifierParams) MarshalJSON 

func (r DeviceidentifierGetIdentifierParams) MarshalJSON() (data []byte, err error)

func (*DeviceidentifierGetIdentifierParams) UnmarshalJSON 

func (r *DeviceidentifierGetIdentifierParams) UnmarshalJSON(data []byte) error

type DeviceidentifierGetIdentifierResponse 

type DeviceidentifierGetIdentifierResponse struct {
	// The device subscription identifier that was used to identify the device whose
	// identifier is being returned. If this property is not present, then the device
	// subscription identifier specified in the request was used.
	Device DeviceidentifierGetIdentifierResponseDevice `json:"device"`
	// IMEI of the device
	Imei string `json:"imei"`
	// IMEISV of the device
	Imeisv string `json:"imeisv"`
	// Date and time that the information was last confirmed by the mobile operator to
	// be correct. It must follow
	// [RFC 3339](https://datatracker.ietf.org/doc/html/rfc3339#section-5.6) and must
	// have time zone.
	LastChecked time.Time `json:"lastChecked" format:"date-time"`
	// Manufacturer of the device
	Manufacturer string `json:"manufacturer"`
	// Model of the device
	Model string `json:"model"`
	// IMEI TAC of the device
	Tac string `json:"tac"`
	// JSON contains metadata for fields, check presence with [respjson.Field.Valid].
	JSON struct {
		Device       respjson.Field
		Imei         respjson.Field
		Imeisv       respjson.Field
		LastChecked  respjson.Field
		Manufacturer respjson.Field
		Model        respjson.Field
		Tac          respjson.Field
		ExtraFields  map[string]respjson.Field
		// contains filtered or unexported fields
	} `json:"-"`
}

func (DeviceidentifierGetIdentifierResponse) RawJSON 

func (r DeviceidentifierGetIdentifierResponse) RawJSON() string

Returns the unmodified JSON received from the API

func (*DeviceidentifierGetIdentifierResponse) UnmarshalJSON 

func (r *DeviceidentifierGetIdentifierResponse) UnmarshalJSON(data []byte) error

type DeviceidentifierGetIdentifierResponseDevice 

type DeviceidentifierGetIdentifierResponseDevice struct {
	// JSON contains metadata for fields, check presence with [respjson.Field.Valid].
	JSON struct {
		ExtraFields map[string]respjson.Field
		// contains filtered or unexported fields
	} `json:"-"`
	DeviceIdentifierDevice
}

The device subscription identifier that was used to identify the device whose identifier is being returned. If this property is not present, then the device subscription identifier specified in the request was used.

func (DeviceidentifierGetIdentifierResponseDevice) RawJSON 

func (r DeviceidentifierGetIdentifierResponseDevice) RawJSON() string

Returns the unmodified JSON received from the API

func (*DeviceidentifierGetIdentifierResponseDevice) UnmarshalJSON 

func (r *DeviceidentifierGetIdentifierResponseDevice) UnmarshalJSON(data []byte) error

type DeviceidentifierGetPpidParams 

type DeviceidentifierGetPpidParams struct {
	// Common request body to allow optional Device object to be passed
	DeviceIdentifierRequestBody DeviceIdentifierRequestBodyParam
	XCorrelator                 param.Opt[string] `header:"x-correlator,omitzero" json:"-"`
	// contains filtered or unexported fields
}

func (DeviceidentifierGetPpidParams) MarshalJSON 

func (r DeviceidentifierGetPpidParams) MarshalJSON() (data []byte, err error)

func (*DeviceidentifierGetPpidParams) UnmarshalJSON 

func (r *DeviceidentifierGetPpidParams) UnmarshalJSON(data []byte) error

type DeviceidentifierGetPpidResponse 

type DeviceidentifierGetPpidResponse struct {
	// The device subscription identifier that was used to identify the device whose
	// identifier is being returned. If this property is not present, then the device
	// subscription identifier specified in the request was used.
	Device DeviceidentifierGetPpidResponseDevice `json:"device"`
	// Date and time that the information was last confirmed by the mobile operator to
	// be correct. It must follow
	// [RFC 3339](https://datatracker.ietf.org/doc/html/rfc3339#section-5.6) and must
	// have time zone.
	LastChecked time.Time `json:"lastChecked" format:"date-time"`
	// A PPID for the identified physical device
	Ppid string `json:"ppid"`
	// JSON contains metadata for fields, check presence with [respjson.Field.Valid].
	JSON struct {
		Device      respjson.Field
		LastChecked respjson.Field
		Ppid        respjson.Field
		ExtraFields map[string]respjson.Field
		// contains filtered or unexported fields
	} `json:"-"`
}

func (DeviceidentifierGetPpidResponse) RawJSON 

func (r DeviceidentifierGetPpidResponse) RawJSON() string

Returns the unmodified JSON received from the API

func (*DeviceidentifierGetPpidResponse) UnmarshalJSON 

func (r *DeviceidentifierGetPpidResponse) UnmarshalJSON(data []byte) error

type DeviceidentifierGetPpidResponseDevice 

type DeviceidentifierGetPpidResponseDevice struct {
	// JSON contains metadata for fields, check presence with [respjson.Field.Valid].
	JSON struct {
		ExtraFields map[string]respjson.Field
		// contains filtered or unexported fields
	} `json:"-"`
	DeviceIdentifierDevice
}

The device subscription identifier that was used to identify the device whose identifier is being returned. If this property is not present, then the device subscription identifier specified in the request was used.

func (DeviceidentifierGetPpidResponseDevice) RawJSON 

func (r DeviceidentifierGetPpidResponseDevice) RawJSON() string

Returns the unmodified JSON received from the API

func (*DeviceidentifierGetPpidResponseDevice) UnmarshalJSON 

func (r *DeviceidentifierGetPpidResponseDevice) UnmarshalJSON(data []byte) error

type DeviceidentifierGetTypeParams 

type DeviceidentifierGetTypeParams struct {
	// Common request body to allow optional Device object to be passed
	DeviceIdentifierRequestBody DeviceIdentifierRequestBodyParam
	XCorrelator                 param.Opt[string] `header:"x-correlator,omitzero" json:"-"`
	// contains filtered or unexported fields
}

func (DeviceidentifierGetTypeParams) MarshalJSON 

func (r DeviceidentifierGetTypeParams) MarshalJSON() (data []byte, err error)

func (*DeviceidentifierGetTypeParams) UnmarshalJSON 

func (r *DeviceidentifierGetTypeParams) UnmarshalJSON(data []byte) error

type DeviceidentifierGetTypeResponse 

type DeviceidentifierGetTypeResponse struct {
	// The device subscription identifier that was used to identify the device whose
	// identifier is being returned. If this property is not present, then the device
	// subscription identifier specified in the request was used.
	Device DeviceidentifierGetTypeResponseDevice `json:"device"`
	// Date and time that the information was last confirmed by the mobile operator to
	// be correct. It must follow
	// [RFC 3339](https://datatracker.ietf.org/doc/html/rfc3339#section-5.6) and must
	// have time zone.
	LastChecked time.Time `json:"lastChecked" format:"date-time"`
	// Manufacturer of the device
	Manufacturer string `json:"manufacturer"`
	// Model of the device
	Model string `json:"model"`
	// IMEI TAC of the device
	Tac string `json:"tac"`
	// JSON contains metadata for fields, check presence with [respjson.Field.Valid].
	JSON struct {
		Device       respjson.Field
		LastChecked  respjson.Field
		Manufacturer respjson.Field
		Model        respjson.Field
		Tac          respjson.Field
		ExtraFields  map[string]respjson.Field
		// contains filtered or unexported fields
	} `json:"-"`
}

func (DeviceidentifierGetTypeResponse) RawJSON 

func (r DeviceidentifierGetTypeResponse) RawJSON() string

Returns the unmodified JSON received from the API

func (*DeviceidentifierGetTypeResponse) UnmarshalJSON 

func (r *DeviceidentifierGetTypeResponse) UnmarshalJSON(data []byte) error

type DeviceidentifierGetTypeResponseDevice 

type DeviceidentifierGetTypeResponseDevice struct {
	// JSON contains metadata for fields, check presence with [respjson.Field.Valid].
	JSON struct {
		ExtraFields map[string]respjson.Field
		// contains filtered or unexported fields
	} `json:"-"`
	DeviceIdentifierDevice
}

The device subscription identifier that was used to identify the device whose identifier is being returned. If this property is not present, then the device subscription identifier specified in the request was used.

func (DeviceidentifierGetTypeResponseDevice) RawJSON 

func (r DeviceidentifierGetTypeResponseDevice) RawJSON() string

Returns the unmodified JSON received from the API

func (*DeviceidentifierGetTypeResponseDevice) UnmarshalJSON 

func (r *DeviceidentifierGetTypeResponseDevice) UnmarshalJSON(data []byte) error

type DeviceidentifierService 

type DeviceidentifierService struct {
	Options []option.RequestOption
}

Device Identifier

DeviceidentifierService contains methods and other services that help with interacting with the camara API.

Note, unlike clients, this service does not read variables from the environment automatically. You should not instantiate this service directly, and instead use the NewDeviceidentifierService method instead.

func NewDeviceidentifierService 

func NewDeviceidentifierService(opts ...option.RequestOption) (r DeviceidentifierService)

NewDeviceidentifierService generates a new service that applies the given options to each request. These options are applied after the parent client's options (if there is one), and before any request-specific options.

func (*DeviceidentifierService) GetIdentifier 

func (r *DeviceidentifierService) GetIdentifier(ctx context.Context, params DeviceidentifierGetIdentifierParams, opts ...option.RequestOption) (res *DeviceidentifierGetIdentifierResponse, err error)

Get details about the specific device being used by a given mobile subscriber

func (*DeviceidentifierService) GetPpid 

func (r *DeviceidentifierService) GetPpid(ctx context.Context, params DeviceidentifierGetPpidParams, opts ...option.RequestOption) (res *DeviceidentifierGetPpidResponse, err error)

Get a pseudonymous identifier for device being used by a given mobile subscriber

func (*DeviceidentifierService) GetType 

func (r *DeviceidentifierService) GetType(ctx context.Context, params DeviceidentifierGetTypeParams, opts ...option.RequestOption) (res *DeviceidentifierGetTypeResponse, err error)

Get details about the type of device being used by a given mobile subscriber

type DevicelocationService 

type DevicelocationService struct {
	Options []option.RequestOption
	// Device Geofencing Subscriptions
	Subscriptions DevicelocationSubscriptionService
}

DevicelocationService contains methods and other services that help with interacting with the camara API.

Note, unlike clients, this service does not read variables from the environment automatically. You should not instantiate this service directly, and instead use the NewDevicelocationService method instead.

func NewDevicelocationService 

func NewDevicelocationService(opts ...option.RequestOption) (r DevicelocationService)

NewDevicelocationService generates a new service that applies the given options to each request. These options are applied after the parent client's options (if there is one), and before any request-specific options.

type DevicelocationSubscriptionDeleteParams 

type DevicelocationSubscriptionDeleteParams struct {
	XCorrelator param.Opt[string] `header:"x-correlator,omitzero" json:"-"`
	// contains filtered or unexported fields
}

type DevicelocationSubscriptionDeleteResponse 

type DevicelocationSubscriptionDeleteResponse struct {
	// The unique identifier of the subscription in the scope of the subscription
	// manager. When this information is contained within an event notification, this
	// concept SHALL be referred as subscriptionId as per Commonalities Event
	// Notification Model.
	ID string `json:"id" api:"required"`
	// JSON contains metadata for fields, check presence with [respjson.Field.Valid].
	JSON struct {
		ID          respjson.Field
		ExtraFields map[string]respjson.Field
		// contains filtered or unexported fields
	} `json:"-"`
}

Response for an event-type subscription request managed asynchronously (Creation or Deletion).

func (DevicelocationSubscriptionDeleteResponse) RawJSON 

func (r DevicelocationSubscriptionDeleteResponse) RawJSON() string

Returns the unmodified JSON received from the API

func (*DevicelocationSubscriptionDeleteResponse) UnmarshalJSON 

func (r *DevicelocationSubscriptionDeleteResponse) UnmarshalJSON(data []byte) error

type DevicelocationSubscriptionGetParams 

type DevicelocationSubscriptionGetParams struct {
	XCorrelator param.Opt[string] `header:"x-correlator,omitzero" json:"-"`
	// contains filtered or unexported fields
}

type DevicelocationSubscriptionListParams 

type DevicelocationSubscriptionListParams struct {
	XCorrelator param.Opt[string] `header:"x-correlator,omitzero" json:"-"`
	// contains filtered or unexported fields
}

type DevicelocationSubscriptionNewParams 

type DevicelocationSubscriptionNewParams struct {
	// Implementation-specific configuration parameters are needed by the subscription
	// manager for acquiring events. In CAMARA we have predefined attributes like
	// `subscriptionExpireTime`, `subscriptionMaxEvents`, `initialEvent`.
	Config DevicelocationSubscriptionNewParamsConfig `json:"config,omitzero" api:"required"`
	// Identifier of a delivery protocol. Only HTTP is allowed for now.
	//
	// Any of "HTTP", "MQTT3", "MQTT5", "AMQP", "NATS", "KAFKA".
	Protocol DeviceLocationProtocol `json:"protocol,omitzero" api:"required"`
	// The address to which events shall be delivered using the selected protocol.
	Sink string `json:"sink" api:"required" format:"uri"`
	// Camara Event types which are eligible to be delivered by this subscription.
	// Note: As of now we enforce to have only event type per subscription.
	Types       []DeviceLocationSubscriptionEventType `json:"types,omitzero" api:"required"`
	XCorrelator param.Opt[string]                     `header:"x-correlator,omitzero" json:"-"`
	// A sink credential provides authentication or authorization information necessary
	// to enable delivery of events to a target.
	SinkCredential DevicelocationSubscriptionNewParamsSinkCredential `json:"sinkCredential,omitzero"`
	// contains filtered or unexported fields
}

func (DevicelocationSubscriptionNewParams) MarshalJSON 

func (r DevicelocationSubscriptionNewParams) MarshalJSON() (data []byte, err error)

func (*DevicelocationSubscriptionNewParams) UnmarshalJSON 

func (r *DevicelocationSubscriptionNewParams) UnmarshalJSON(data []byte) error

type DevicelocationSubscriptionNewParamsConfig 

type DevicelocationSubscriptionNewParamsConfig struct {
	// The detail of the requested event subscription.
	SubscriptionDetail DevicelocationSubscriptionNewParamsConfigSubscriptionDetail `json:"subscriptionDetail,omitzero" api:"required"`
	DeviceLocationConfigParam
}

Implementation-specific configuration parameters are needed by the subscription manager for acquiring events. In CAMARA we have predefined attributes like `subscriptionExpireTime`, `subscriptionMaxEvents`, `initialEvent`.

func (DevicelocationSubscriptionNewParamsConfig) MarshalJSON 

func (r DevicelocationSubscriptionNewParamsConfig) MarshalJSON() (data []byte, err error)

type DevicelocationSubscriptionNewParamsConfigSubscriptionDetail 

type DevicelocationSubscriptionNewParamsConfigSubscriptionDetail struct {
	// The geofencing area where the monitor is active. This area is specified by API
	// consumers in the subscription request. The same area definition is included in
	// event notifications without any modifications.
	Area DeviceLocationAreaParam `json:"area,omitzero" api:"required"`
	// End-user device able to connect to a mobile network. Examples of devices include
	// smartphones or IoT sensors/actuators.
	//
	// The developer can choose to provide the below specified device identifiers:
	//
	// - `ipv4Address`
	// - `ipv6Address`
	// - `phoneNumber`
	// - `networkAccessIdentifier`
	//
	// NOTE1: the API provider might support only a subset of these options. The API
	// consumer can provide multiple identifiers to be compatible across different API
	// providers. In this case the identifiers MUST belong to the same device. Where
	// more than one device identifier is provided, only one identifier will be
	// selected by the implementation and this choice indicated to the API consumer in
	// the response or event. NOTE2: as for this Commonalities release, we are
	// enforcing that the networkAccessIdentifier is only part of the schema for
	// future-proofing, and CAMARA does not currently allow its use. After the CAMARA
	// meta-release work is concluded and the relevant issues are resolved, its use
	// will need to be explicitly documented in the guidelines.
	Device DeviceLocationDeviceParam `json:"device,omitzero"`
	// contains filtered or unexported fields
}

The detail of the requested event subscription.

The property Area is required.

func (DevicelocationSubscriptionNewParamsConfigSubscriptionDetail) MarshalJSON 

func (r DevicelocationSubscriptionNewParamsConfigSubscriptionDetail) MarshalJSON() (data []byte, err error)

func (*DevicelocationSubscriptionNewParamsConfigSubscriptionDetail) UnmarshalJSON 

func (r *DevicelocationSubscriptionNewParamsConfigSubscriptionDetail) UnmarshalJSON(data []byte) error

type DevicelocationSubscriptionNewParamsSinkCredential 

type DevicelocationSubscriptionNewParamsSinkCredential struct {
	// The type of the credential. Note: Type of the credential - MUST be set to
	// ACCESSTOKEN for now
	//
	// Any of "PLAIN", "ACCESSTOKEN", "REFRESHTOKEN".
	CredentialType string `json:"credentialType,omitzero" api:"required"`
	// contains filtered or unexported fields
}

A sink credential provides authentication or authorization information necessary to enable delivery of events to a target.

The property CredentialType is required.

func (DevicelocationSubscriptionNewParamsSinkCredential) MarshalJSON 

func (r DevicelocationSubscriptionNewParamsSinkCredential) MarshalJSON() (data []byte, err error)

func (*DevicelocationSubscriptionNewParamsSinkCredential) UnmarshalJSON 

func (r *DevicelocationSubscriptionNewParamsSinkCredential) UnmarshalJSON(data []byte) error

type DevicelocationSubscriptionService 

type DevicelocationSubscriptionService struct {
	Options []option.RequestOption
}

Device Geofencing Subscriptions

DevicelocationSubscriptionService contains methods and other services that help with interacting with the camara API.

Note, unlike clients, this service does not read variables from the environment automatically. You should not instantiate this service directly, and instead use the NewDevicelocationSubscriptionService method instead.

func NewDevicelocationSubscriptionService 

func NewDevicelocationSubscriptionService(opts ...option.RequestOption) (r DevicelocationSubscriptionService)

NewDevicelocationSubscriptionService generates a new service that applies the given options to each request. These options are applied after the parent client's options (if there is one), and before any request-specific options.

func (*DevicelocationSubscriptionService) Delete 

func (r *DevicelocationSubscriptionService) Delete(ctx context.Context, subscriptionID string, body DevicelocationSubscriptionDeleteParams, opts ...option.RequestOption) (res *DevicelocationSubscriptionDeleteResponse, err error)

Delete a given Geofencing subscription.

func (*DevicelocationSubscriptionService) Get 

func (r *DevicelocationSubscriptionService) Get(ctx context.Context, subscriptionID string, query DevicelocationSubscriptionGetParams, opts ...option.RequestOption) (res *DeviceLocationSubscription, err error)

Retrieve Geofencing subscription information for a given subscription ID.

func (*DevicelocationSubscriptionService) List 

func (r *DevicelocationSubscriptionService) List(ctx context.Context, query DevicelocationSubscriptionListParams, opts ...option.RequestOption) (res *[]DeviceLocationSubscription, err error)

Retrieve a list of geofencing event subscription(s).

func (*DevicelocationSubscriptionService) New 

func (r *DevicelocationSubscriptionService) New(ctx context.Context, params DevicelocationSubscriptionNewParams, opts ...option.RequestOption) (res *DeviceLocationSubscription, err error)

Create a subscription for a device to receive notifications when the device enters or exits a specified area.

type DevicereachabilitystatusService 

type DevicereachabilitystatusService struct {
	Options []option.RequestOption
	// Device Reachability Status Subscriptions
	Subscriptions DevicereachabilitystatusSubscriptionService
}

DevicereachabilitystatusService contains methods and other services that help with interacting with the camara API.

Note, unlike clients, this service does not read variables from the environment automatically. You should not instantiate this service directly, and instead use the NewDevicereachabilitystatusService method instead.

func NewDevicereachabilitystatusService 

func NewDevicereachabilitystatusService(opts ...option.RequestOption) (r DevicereachabilitystatusService)

NewDevicereachabilitystatusService generates a new service that applies the given options to each request. These options are applied after the parent client's options (if there is one), and before any request-specific options.

type DevicereachabilitystatusSubscriptionDeleteParams 

type DevicereachabilitystatusSubscriptionDeleteParams struct {
	XCorrelator param.Opt[string] `header:"x-correlator,omitzero" json:"-"`
	// contains filtered or unexported fields
}

type DevicereachabilitystatusSubscriptionDeleteResponse 

type DevicereachabilitystatusSubscriptionDeleteResponse struct {
	// The unique identifier of the subscription in the scope of the subscription
	// manager. When this information is contained within an event notification, this
	// concept SHALL be referred as subscriptionId as per Commonalities Event
	// Notification Model.
	ID string `json:"id" api:"required"`
	// JSON contains metadata for fields, check presence with [respjson.Field.Valid].
	JSON struct {
		ID          respjson.Field
		ExtraFields map[string]respjson.Field
		// contains filtered or unexported fields
	} `json:"-"`
}

Response for a device reachability status operation managed asynchronously (Creation or Deletion)

func (DevicereachabilitystatusSubscriptionDeleteResponse) RawJSON 

func (r DevicereachabilitystatusSubscriptionDeleteResponse) RawJSON() string

Returns the unmodified JSON received from the API

func (*DevicereachabilitystatusSubscriptionDeleteResponse) UnmarshalJSON 

func (r *DevicereachabilitystatusSubscriptionDeleteResponse) UnmarshalJSON(data []byte) error

type DevicereachabilitystatusSubscriptionGetParams 

type DevicereachabilitystatusSubscriptionGetParams struct {
	XCorrelator param.Opt[string] `header:"x-correlator,omitzero" json:"-"`
	// contains filtered or unexported fields
}

type DevicereachabilitystatusSubscriptionListParams 

type DevicereachabilitystatusSubscriptionListParams struct {
	XCorrelator param.Opt[string] `header:"x-correlator,omitzero" json:"-"`
	// contains filtered or unexported fields
}

type DevicereachabilitystatusSubscriptionNewParams 

type DevicereachabilitystatusSubscriptionNewParams struct {
	// Implementation-specific configuration parameters needed by the subscription
	// manager for acquiring events. In CAMARA we have predefined attributes like
	// `subscriptionExpireTime`, `subscriptionMaxEvents`, `initialEvent` Specific event
	// type attributes must be defined in `subscriptionDetail` Note: if a request is
	// performed for several event type, all subscribed event will use same `config`
	// parameters.
	Config DeviceReachabilityStatusConfigParam `json:"config,omitzero" api:"required"`
	// Identifier of a delivery protocol. Only HTTP is allowed for now
	//
	// Any of "HTTP", "MQTT3", "MQTT5", "AMQP", "NATS", "KAFKA".
	Protocol DeviceReachabilityStatusProtocol `json:"protocol,omitzero" api:"required"`
	// The address to which events shall be delivered using the selected protocol.
	Sink string `json:"sink" api:"required" format:"uri"`
	// Camara Event types eligible to be delivered by this subscription. Note: For the
	// current Commonalities API design guidelines, only one event type per
	// subscription is allowed, yet in the following releases use of array of event
	// types SHALL be specified without changing this definition.
	Types       []DeviceReachabilityStatusSubscriptionEventType `json:"types,omitzero" api:"required"`
	XCorrelator param.Opt[string]                               `header:"x-correlator,omitzero" json:"-"`
	// A sink credential provides authentication or authorization information necessary
	// to enable delivery of events to a target.
	SinkCredential DevicereachabilitystatusSubscriptionNewParamsSinkCredential `json:"sinkCredential,omitzero"`
	// contains filtered or unexported fields
}

func (DevicereachabilitystatusSubscriptionNewParams) MarshalJSON 

func (r DevicereachabilitystatusSubscriptionNewParams) MarshalJSON() (data []byte, err error)

func (*DevicereachabilitystatusSubscriptionNewParams) UnmarshalJSON 

func (r *DevicereachabilitystatusSubscriptionNewParams) UnmarshalJSON(data []byte) error

type DevicereachabilitystatusSubscriptionNewParamsSinkCredential 

type DevicereachabilitystatusSubscriptionNewParamsSinkCredential struct {
	// The type of the credential. Note: Type of the credential - MUST be set to
	// ACCESSTOKEN for now
	//
	// Any of "PLAIN", "ACCESSTOKEN", "REFRESHTOKEN".
	CredentialType string `json:"credentialType,omitzero" api:"required"`
	// contains filtered or unexported fields
}

A sink credential provides authentication or authorization information necessary to enable delivery of events to a target.

The property CredentialType is required.

func (DevicereachabilitystatusSubscriptionNewParamsSinkCredential) MarshalJSON 

func (r DevicereachabilitystatusSubscriptionNewParamsSinkCredential) MarshalJSON() (data []byte, err error)

func (*DevicereachabilitystatusSubscriptionNewParamsSinkCredential) UnmarshalJSON 

func (r *DevicereachabilitystatusSubscriptionNewParamsSinkCredential) UnmarshalJSON(data []byte) error

type DevicereachabilitystatusSubscriptionService 

type DevicereachabilitystatusSubscriptionService struct {
	Options []option.RequestOption
}

Device Reachability Status Subscriptions

DevicereachabilitystatusSubscriptionService contains methods and other services that help with interacting with the camara API.

Note, unlike clients, this service does not read variables from the environment automatically. You should not instantiate this service directly, and instead use the NewDevicereachabilitystatusSubscriptionService method instead.

func NewDevicereachabilitystatusSubscriptionService 

func NewDevicereachabilitystatusSubscriptionService(opts ...option.RequestOption) (r DevicereachabilitystatusSubscriptionService)

NewDevicereachabilitystatusSubscriptionService generates a new service that applies the given options to each request. These options are applied after the parent client's options (if there is one), and before any request-specific options.

func (*DevicereachabilitystatusSubscriptionService) Delete 

func (r *DevicereachabilitystatusSubscriptionService) Delete(ctx context.Context, subscriptionID string, body DevicereachabilitystatusSubscriptionDeleteParams, opts ...option.RequestOption) (res *DevicereachabilitystatusSubscriptionDeleteResponse, err error)

Delete a given subscription by ID

func (*DevicereachabilitystatusSubscriptionService) Get 

func (r *DevicereachabilitystatusSubscriptionService) Get(ctx context.Context, subscriptionID string, query DevicereachabilitystatusSubscriptionGetParams, opts ...option.RequestOption) (res *DeviceReachabilityStatusSubscription, err error)

Retrieve a given subscription by ID

func (*DevicereachabilitystatusSubscriptionService) List 

func (r *DevicereachabilitystatusSubscriptionService) List(ctx context.Context, query DevicereachabilitystatusSubscriptionListParams, opts ...option.RequestOption) (res *[]DeviceReachabilityStatusSubscription, err error)

Retrieve a list of device reachability status event subscription(s)

func (*DevicereachabilitystatusSubscriptionService) New 

func (r *DevicereachabilitystatusSubscriptionService) New(ctx context.Context, params DevicereachabilitystatusSubscriptionNewParams, opts ...option.RequestOption) (res *DeviceReachabilityStatusSubscription, err error)

Create a device reachability status event subscription for a device

type DeviceroamingstatusService 

type DeviceroamingstatusService struct {
	Options []option.RequestOption
	// Device Roaming Status Subscriptions
	Subscriptions DeviceroamingstatusSubscriptionService
}

DeviceroamingstatusService contains methods and other services that help with interacting with the camara API.

Note, unlike clients, this service does not read variables from the environment automatically. You should not instantiate this service directly, and instead use the NewDeviceroamingstatusService method instead.

func NewDeviceroamingstatusService 

func NewDeviceroamingstatusService(opts ...option.RequestOption) (r DeviceroamingstatusService)

NewDeviceroamingstatusService generates a new service that applies the given options to each request. These options are applied after the parent client's options (if there is one), and before any request-specific options.

type DeviceroamingstatusSubscriptionDeleteParams 

type DeviceroamingstatusSubscriptionDeleteParams struct {
	XCorrelator param.Opt[string] `header:"x-correlator,omitzero" json:"-"`
	// contains filtered or unexported fields
}

type DeviceroamingstatusSubscriptionDeleteResponse 

type DeviceroamingstatusSubscriptionDeleteResponse struct {
	// The unique identifier of the subscription in the scope of the subscription
	// manager. When this information is contained within an event notification, this
	// concept SHALL be referred as subscriptionId as per Commonalities Event
	// Notification Model.
	ID string `json:"id" api:"required"`
	// JSON contains metadata for fields, check presence with [respjson.Field.Valid].
	JSON struct {
		ID          respjson.Field
		ExtraFields map[string]respjson.Field
		// contains filtered or unexported fields
	} `json:"-"`
}

Response for a device reachability status operation managed asynchronously (Creation or Deletion)

func (DeviceroamingstatusSubscriptionDeleteResponse) RawJSON 

func (r DeviceroamingstatusSubscriptionDeleteResponse) RawJSON() string

Returns the unmodified JSON received from the API

func (*DeviceroamingstatusSubscriptionDeleteResponse) UnmarshalJSON 

func (r *DeviceroamingstatusSubscriptionDeleteResponse) UnmarshalJSON(data []byte) error

type DeviceroamingstatusSubscriptionGetParams 

type DeviceroamingstatusSubscriptionGetParams struct {
	XCorrelator param.Opt[string] `header:"x-correlator,omitzero" json:"-"`
	// contains filtered or unexported fields
}

type DeviceroamingstatusSubscriptionListParams 

type DeviceroamingstatusSubscriptionListParams struct {
	XCorrelator param.Opt[string] `header:"x-correlator,omitzero" json:"-"`
	// contains filtered or unexported fields
}

type DeviceroamingstatusSubscriptionNewParams 

type DeviceroamingstatusSubscriptionNewParams struct {
	// Implementation-specific configuration parameters needed by the subscription
	// manager for acquiring events. In CAMARA we have predefined attributes like
	// `subscriptionExpireTime`, `subscriptionMaxEvents`, `initialEvent` Specific event
	// type attributes must be defined in `subscriptionDetail` Note: if a request is
	// performed for several event type, all subscribed event will use same `config`
	// parameters.
	Config DeviceRoamingStatusConfigParam `json:"config,omitzero" api:"required"`
	// Identifier of a delivery protocol. Only HTTP is allowed for now
	//
	// Any of "HTTP", "MQTT3", "MQTT5", "AMQP", "NATS", "KAFKA".
	Protocol DeviceRoamingStatusProtocol `json:"protocol,omitzero" api:"required"`
	// The address to which events shall be delivered using the selected protocol.
	Sink string `json:"sink" api:"required" format:"uri"`
	// Camara Event types eligible to be delivered by this subscription. Note: for the
	// current Commonalities version (v0.5) only one event type per subscription is
	// allowed, yet in the following releases use of array of event types SHALL be
	// specified without changing this definition.
	Types       []DeviceRoamingStatusSubscriptionEventType `json:"types,omitzero" api:"required"`
	XCorrelator param.Opt[string]                          `header:"x-correlator,omitzero" json:"-"`
	// A sink credential provides authentication or authorization information necessary
	// to enable delivery of events to a target.
	SinkCredential DeviceroamingstatusSubscriptionNewParamsSinkCredential `json:"sinkCredential,omitzero"`
	// contains filtered or unexported fields
}

func (DeviceroamingstatusSubscriptionNewParams) MarshalJSON 

func (r DeviceroamingstatusSubscriptionNewParams) MarshalJSON() (data []byte, err error)

func (*DeviceroamingstatusSubscriptionNewParams) UnmarshalJSON 

func (r *DeviceroamingstatusSubscriptionNewParams) UnmarshalJSON(data []byte) error

type DeviceroamingstatusSubscriptionNewParamsSinkCredential 

type DeviceroamingstatusSubscriptionNewParamsSinkCredential struct {
	// The type of the credential. Note: Type of the credential - MUST be set to
	// ACCESSTOKEN for now
	//
	// Any of "PLAIN", "ACCESSTOKEN", "REFRESHTOKEN".
	CredentialType string `json:"credentialType,omitzero" api:"required"`
	// contains filtered or unexported fields
}

A sink credential provides authentication or authorization information necessary to enable delivery of events to a target.

The property CredentialType is required.

func (DeviceroamingstatusSubscriptionNewParamsSinkCredential) MarshalJSON 

func (r DeviceroamingstatusSubscriptionNewParamsSinkCredential) MarshalJSON() (data []byte, err error)

func (*DeviceroamingstatusSubscriptionNewParamsSinkCredential) UnmarshalJSON 

func (r *DeviceroamingstatusSubscriptionNewParamsSinkCredential) UnmarshalJSON(data []byte) error

type DeviceroamingstatusSubscriptionService 

type DeviceroamingstatusSubscriptionService struct {
	Options []option.RequestOption
}

Device Roaming Status Subscriptions

DeviceroamingstatusSubscriptionService contains methods and other services that help with interacting with the camara API.

Note, unlike clients, this service does not read variables from the environment automatically. You should not instantiate this service directly, and instead use the NewDeviceroamingstatusSubscriptionService method instead.

func NewDeviceroamingstatusSubscriptionService 

func NewDeviceroamingstatusSubscriptionService(opts ...option.RequestOption) (r DeviceroamingstatusSubscriptionService)

NewDeviceroamingstatusSubscriptionService generates a new service that applies the given options to each request. These options are applied after the parent client's options (if there is one), and before any request-specific options.

func (*DeviceroamingstatusSubscriptionService) Delete 

func (r *DeviceroamingstatusSubscriptionService) Delete(ctx context.Context, subscriptionID string, body DeviceroamingstatusSubscriptionDeleteParams, opts ...option.RequestOption) (res *DeviceroamingstatusSubscriptionDeleteResponse, err error)

Delete a given device-roaming-status subscription by ID

func (*DeviceroamingstatusSubscriptionService) Get 

func (r *DeviceroamingstatusSubscriptionService) Get(ctx context.Context, subscriptionID string, query DeviceroamingstatusSubscriptionGetParams, opts ...option.RequestOption) (res *DeviceRoamingStatusSubscription, err error)

retrieve device roaming status subscription information for a given subscription.

func (*DeviceroamingstatusSubscriptionService) List 

func (r *DeviceroamingstatusSubscriptionService) List(ctx context.Context, query DeviceroamingstatusSubscriptionListParams, opts ...option.RequestOption) (res *[]DeviceRoamingStatusSubscription, err error)

Retrieve a list of device roaming status event subscription(s)

func (*DeviceroamingstatusSubscriptionService) New 

func (r *DeviceroamingstatusSubscriptionService) New(ctx context.Context, params DeviceroamingstatusSubscriptionNewParams, opts ...option.RequestOption) (res *DeviceRoamingStatusSubscription, err error)

Create a device roaming status event subscription for a device

type DeviceswapCheckParams 

type DeviceswapCheckParams struct {
	// Period in hours to be checked for device swap.
	MaxAge param.Opt[int64] `json:"maxAge,omitzero"`
	// A public identifier addressing a telephone subscription. In mobile networks it
	// corresponds to the MSISDN (Mobile Station International Subscriber Directory
	// Number). In order to be globally unique it has to be formatted in international
	// format, according to E.164 standard, prefixed with '+'.
	PhoneNumber param.Opt[string] `json:"phoneNumber,omitzero"`
	XCorrelator param.Opt[string] `header:"x-correlator,omitzero" json:"-"`
	// contains filtered or unexported fields
}

func (DeviceswapCheckParams) MarshalJSON 

func (r DeviceswapCheckParams) MarshalJSON() (data []byte, err error)

func (*DeviceswapCheckParams) UnmarshalJSON 

func (r *DeviceswapCheckParams) UnmarshalJSON(data []byte) error

type DeviceswapCheckResponse 

type DeviceswapCheckResponse struct {
	// Indicates whether the device has been swapped during the period within the
	// provided age.
	Swapped bool `json:"swapped" api:"required"`
	// JSON contains metadata for fields, check presence with [respjson.Field.Valid].
	JSON struct {
		Swapped     respjson.Field
		ExtraFields map[string]respjson.Field
		// contains filtered or unexported fields
	} `json:"-"`
}

func (DeviceswapCheckResponse) RawJSON 

func (r DeviceswapCheckResponse) RawJSON() string

Returns the unmodified JSON received from the API

func (*DeviceswapCheckResponse) UnmarshalJSON 

func (r *DeviceswapCheckResponse) UnmarshalJSON(data []byte) error

type DeviceswapGetDateParams 

type DeviceswapGetDateParams struct {
	// A public identifier addressing a telephone subscription. In mobile networks it
	// corresponds to the MSISDN (Mobile Station International Subscriber Directory
	// Number). In order to be globally unique it has to be formatted in international
	// format, according to E.164 standard, prefixed with '+'.
	PhoneNumber param.Opt[string] `json:"phoneNumber,omitzero"`
	XCorrelator param.Opt[string] `header:"x-correlator,omitzero" json:"-"`
	// contains filtered or unexported fields
}

func (DeviceswapGetDateParams) MarshalJSON 

func (r DeviceswapGetDateParams) MarshalJSON() (data []byte, err error)

func (*DeviceswapGetDateParams) UnmarshalJSON 

func (r *DeviceswapGetDateParams) UnmarshalJSON(data []byte) error

type DeviceswapGetDateResponse 

type DeviceswapGetDateResponse struct {
	// Timestamp of latest device swap performed. It must follow
	// [RFC 3339](https://datatracker.ietf.org/doc/html/rfc3339#section-5.6) and must
	// have time zone.
	LatestDeviceChange time.Time `json:"latestDeviceChange" api:"required" format:"date-time"`
	// Timeframe in days for device change supervision for the phone number. It could
	// be valued in the response if the latest Device swap occurred before this
	// monitored period.
	MonitoredPeriod int64 `json:"monitoredPeriod"`
	// JSON contains metadata for fields, check presence with [respjson.Field.Valid].
	JSON struct {
		LatestDeviceChange respjson.Field
		MonitoredPeriod    respjson.Field
		ExtraFields        map[string]respjson.Field
		// contains filtered or unexported fields
	} `json:"-"`
}

func (DeviceswapGetDateResponse) RawJSON 

func (r DeviceswapGetDateResponse) RawJSON() string

Returns the unmodified JSON received from the API

func (*DeviceswapGetDateResponse) UnmarshalJSON 

func (r *DeviceswapGetDateResponse) UnmarshalJSON(data []byte) error

type DeviceswapService 

type DeviceswapService struct {
	Options []option.RequestOption
}

Device Swap

DeviceswapService contains methods and other services that help with interacting with the camara API.

Note, unlike clients, this service does not read variables from the environment automatically. You should not instantiate this service directly, and instead use the NewDeviceswapService method instead.

func NewDeviceswapService 

func NewDeviceswapService(opts ...option.RequestOption) (r DeviceswapService)

NewDeviceswapService generates a new service that applies the given options to each request. These options are applied after the parent client's options (if there is one), and before any request-specific options.

func (*DeviceswapService) Check 

func (r *DeviceswapService) Check(ctx context.Context, params DeviceswapCheckParams, opts ...option.RequestOption) (res *DeviceswapCheckResponse, err error)

Check if device swap has been performed during a past period

func (*DeviceswapService) GetDate 

func (r *DeviceswapService) GetDate(ctx context.Context, params DeviceswapGetDateParams, opts ...option.RequestOption) (res *DeviceswapGetDateResponse, err error)

Get timestamp of last device swap for a mobile user account provided with phone number.

type Duration 

type Duration struct {
	// Units of time
	//
	// Any of "Days", "Hours", "Minutes", "Seconds", "Milliseconds", "Microseconds",
	// "Nanoseconds".
	Unit DurationUnit `json:"unit"`
	// Quantity of duration
	Value int64 `json:"value"`
	// JSON contains metadata for fields, check presence with [respjson.Field.Valid].
	JSON struct {
		Unit        respjson.Field
		Value       respjson.Field
		ExtraFields map[string]respjson.Field
		// contains filtered or unexported fields
	} `json:"-"`
}

Specification of duration

func (Duration) RawJSON 

func (r Duration) RawJSON() string

Returns the unmodified JSON received from the API

func (*Duration) UnmarshalJSON 

func (r *Duration) UnmarshalJSON(data []byte) error

type DurationUnit 

type DurationUnit string

Units of time 

const (
	DurationUnitDays         DurationUnit = "Days"
	DurationUnitHours        DurationUnit = "Hours"
	DurationUnitMinutes      DurationUnit = "Minutes"
	DurationUnitSeconds      DurationUnit = "Seconds"
	DurationUnitMilliseconds DurationUnit = "Milliseconds"
	DurationUnitMicroseconds DurationUnit = "Microseconds"
	DurationUnitNanoseconds  DurationUnit = "Nanoseconds"
)

type Error 

type Error = apierror.Error

type EventType 

type EventType string

event-type - Event triggered when an event-type event occurred 

const (
	EventTypeOrgCamaraprojectConnectivityInsightsSubscriptionsV0NetworkQuality EventType = "org.camaraproject.connectivity-insights-subscriptions.v0.network-quality"
)

type KnowyourcustomerageverificationService 

type KnowyourcustomerageverificationService struct {
	Options []option.RequestOption
}

Know Your Customer Age Verification

KnowyourcustomerageverificationService contains methods and other services that help with interacting with the camara API.

Note, unlike clients, this service does not read variables from the environment automatically. You should not instantiate this service directly, and instead use the NewKnowyourcustomerageverificationService method instead.

func NewKnowyourcustomerageverificationService 

func NewKnowyourcustomerageverificationService(opts ...option.RequestOption) (r KnowyourcustomerageverificationService)

NewKnowyourcustomerageverificationService generates a new service that applies the given options to each request. These options are applied after the parent client's options (if there is one), and before any request-specific options.

func (*KnowyourcustomerageverificationService) Verify 

func (r *KnowyourcustomerageverificationService) Verify(ctx context.Context, params KnowyourcustomerageverificationVerifyParams, opts ...option.RequestOption) (res *KnowyourcustomerageverificationVerifyResponse, err error)

Verify that the age of the subscriber associated with a phone number is equal to or greater than the specified age threshold value.

As it is possible that the person holding the contract and the end-user of the subscription may not be the same, the endpoint also admits a list of optional properties to be included in the request to improve the identification. The response may optionally include the `identityMatchScore` property with a value that indicates how certain it is that the information returned relates to the person that the API Client is requesting. To increase the reliability of the information returned, the API Provider may include in the response the `verifiedStatus` property, indicating whether the identity information in its possession has been verified against an identification document legally accepted as an age verification document (Note). Note: Depending on the country, credit-check or other mechanism can be used instead of official identification for Age Verification. For details, please contact API Provider.

If the API Client indicates request properties `includeContentLock` or `includeParentalControl` with value `true` and the API Provider implements this functionality, then the response will also include `contentLock` and `parentalControl` properties to indicate if the subscription has any kind of content filtering enabled. On the other hand, if the request properties are not included or the API Client specifies value `false`, then the response properties will not be returned. If the API Provider doesn't implement this functionality, request properties will be ignored and response properties won't be returned in any case.

type KnowyourcustomerageverificationVerifyParams 

type KnowyourcustomerageverificationVerifyParams struct {
	// The age to be verified. The indicated range is a global definition of maximum
	// and minimum values allowed to be requested. It is important to note that this
	// range might be more restrictive in some implementations due to local regulations
	// of a country i.e. A country does not allow to request for an age under 18. This
	// limitation must be informed during the onboarding process.
	AgeThreshold int64 `json:"ageThreshold" api:"required"`
	// The birthdate of the customer, in RFC 3339 / ISO 8601 calendar date format
	// (YYYY-MM-DD).
	Birthdate param.Opt[time.Time] `json:"birthdate,omitzero" format:"date"`
	// Email address of the customer in the RFC specified format (local-part@domain).
	Email param.Opt[string] `json:"email,omitzero" format:"email"`
	// Last name, family name, or surname of the customer.
	FamilyName param.Opt[string] `json:"familyName,omitzero"`
	// Last/family/sur- name at birth of the customer.
	FamilyNameAtBirth param.Opt[string] `json:"familyNameAtBirth,omitzero"`
	// First/given name or compound first/given name of the customer.
	GivenName param.Opt[string] `json:"givenName,omitzero"`
	// Id number associated to the official identity document in the country. It may
	// contain alphanumeric characters.
	IDDocument param.Opt[string] `json:"idDocument,omitzero"`
	// If this parameter is included in the request with value `true`, the response
	// property `contentLock` will be returned. If it is not included or its value is
	// `false`, the response property will not be returned.
	IncludeContentLock param.Opt[bool] `json:"includeContentLock,omitzero"`
	// If this parameter is included in the request with value `true`, the response
	// property `parentalControl` will be returned. If it is not included or its value
	// is `false`, the response property will not be returned.
	IncludeParentalControl param.Opt[bool] `json:"includeParentalControl,omitzero"`
	// Middle name/s of the customer.
	MiddleNames param.Opt[string] `json:"middleNames,omitzero"`
	// Complete name of the customer, usually composed of first/given name and
	// last/family/sur- name in a country. Depending on the country, the order of
	// first/give name and last/family/sur- name varies, and middle name could be
	// included. It can use givenName, middleNames, familyName and/or
	// familyNameAtBirth. For example, in ESP, name+familyName; in NLD, it can be
	// name+middleNames+familyName or name+middleNames+familyNameAtBirth, etc.
	Name param.Opt[string] `json:"name,omitzero"`
	// A public identifier addressing a telephone subscription. In mobile networks it
	// corresponds to the MSISDN (Mobile Station International Subscriber Directory
	// Number). In order to be globally unique it has to be formatted in international
	// format, according to E.164 standard, prefixed with '+'.
	PhoneNumber param.Opt[string] `json:"phoneNumber,omitzero"`
	XCorrelator param.Opt[string] `header:"x-correlator,omitzero" json:"-"`
	// contains filtered or unexported fields
}

func (KnowyourcustomerageverificationVerifyParams) MarshalJSON 

func (r KnowyourcustomerageverificationVerifyParams) MarshalJSON() (data []byte, err error)

func (*KnowyourcustomerageverificationVerifyParams) UnmarshalJSON 

func (r *KnowyourcustomerageverificationVerifyParams) UnmarshalJSON(data []byte) error

type KnowyourcustomerageverificationVerifyResponse 

type KnowyourcustomerageverificationVerifyResponse struct {
	// Indicate `"true"` when the age of the user is the same age or older than the age
	// threshold (age >= age threshold), and `"false"` if not (age < age threshold). If
	// the API Provider doesn't have enough information to perform the validation, a
	// `not_available` can be returned.
	//
	// Any of "true", "false", "not_available".
	AgeCheck KnowyourcustomerageverificationVerifyResponseAgeCheck `json:"ageCheck" api:"required"`
	// Indicate `"true"` if the subscription associated with the phone number has any
	// kind of content lock (i.e certain web content blocked) and `"false"` if not. If
	// the information is not available the value `not_available` can be returned.
	//
	// Any of "true", "false", "not_available".
	ContentLock KnowyourcustomerageverificationVerifyResponseContentLock `json:"contentLock"`
	// The overall score of identity information available in the API Provider,
	// information either provided in the request body comparing it to the one that the
	// API Provider holds or directly using internal API Provider's information. It is
	// optional for the API Provider to return the Identity match score.
	IdentityMatchScore int64 `json:"identityMatchScore"`
	// Indicate `"true"` if the subscription associated with the phone number has any
	// kind of parental control activated and `"false"` if not. If the information is
	// not available the value `not_available` can be returned.
	//
	// Any of "true", "false", "not_available".
	ParentalControl KnowyourcustomerageverificationVerifyResponseParentalControl `json:"parentalControl"`
	// Indicate `true` if the information provided has been compared against
	// information based on an identification document legally accepted as an age
	// verification document (Note), otherwise indicate `false`. Note: Depending on the
	// country, credit-check or other mechanism can be used instead of official
	// identification for Age Verification. For details, please contact API Provider.
	VerifiedStatus bool `json:"verifiedStatus"`
	// JSON contains metadata for fields, check presence with [respjson.Field.Valid].
	JSON struct {
		AgeCheck           respjson.Field
		ContentLock        respjson.Field
		IdentityMatchScore respjson.Field
		ParentalControl    respjson.Field
		VerifiedStatus     respjson.Field
		ExtraFields        map[string]respjson.Field
		// contains filtered or unexported fields
	} `json:"-"`
}

Response to an age verification request

func (KnowyourcustomerageverificationVerifyResponse) RawJSON 

func (r KnowyourcustomerageverificationVerifyResponse) RawJSON() string

Returns the unmodified JSON received from the API

func (*KnowyourcustomerageverificationVerifyResponse) UnmarshalJSON 

func (r *KnowyourcustomerageverificationVerifyResponse) UnmarshalJSON(data []byte) error

type KnowyourcustomerageverificationVerifyResponseAgeCheck 

type KnowyourcustomerageverificationVerifyResponseAgeCheck string

Indicate `"true"` when the age of the user is the same age or older than the age threshold (age >= age threshold), and `"false"` if not (age < age threshold). If the API Provider doesn't have enough information to perform the validation, a `not_available` can be returned. 

const (
	KnowyourcustomerageverificationVerifyResponseAgeCheckTrue         KnowyourcustomerageverificationVerifyResponseAgeCheck = "true"
	KnowyourcustomerageverificationVerifyResponseAgeCheckFalse        KnowyourcustomerageverificationVerifyResponseAgeCheck = "false"
	KnowyourcustomerageverificationVerifyResponseAgeCheckNotAvailable KnowyourcustomerageverificationVerifyResponseAgeCheck = "not_available"
)

type KnowyourcustomerageverificationVerifyResponseContentLock 

type KnowyourcustomerageverificationVerifyResponseContentLock string

Indicate `"true"` if the subscription associated with the phone number has any kind of content lock (i.e certain web content blocked) and `"false"` if not. If the information is not available the value `not_available` can be returned. 

const (
	KnowyourcustomerageverificationVerifyResponseContentLockTrue         KnowyourcustomerageverificationVerifyResponseContentLock = "true"
	KnowyourcustomerageverificationVerifyResponseContentLockFalse        KnowyourcustomerageverificationVerifyResponseContentLock = "false"
	KnowyourcustomerageverificationVerifyResponseContentLockNotAvailable KnowyourcustomerageverificationVerifyResponseContentLock = "not_available"
)

type KnowyourcustomerageverificationVerifyResponseParentalControl 

type KnowyourcustomerageverificationVerifyResponseParentalControl string

Indicate `"true"` if the subscription associated with the phone number has any kind of parental control activated and `"false"` if not. If the information is not available the value `not_available` can be returned. 

const (
	KnowyourcustomerageverificationVerifyResponseParentalControlTrue         KnowyourcustomerageverificationVerifyResponseParentalControl = "true"
	KnowyourcustomerageverificationVerifyResponseParentalControlFalse        KnowyourcustomerageverificationVerifyResponseParentalControl = "false"
	KnowyourcustomerageverificationVerifyResponseParentalControlNotAvailable KnowyourcustomerageverificationVerifyResponseParentalControl = "not_available"
)

type KnowyourcustomerfillInNewParams 

type KnowyourcustomerfillInNewParams struct {
	// A public identifier addressing a telephone subscription. In mobile networks it
	// corresponds to the MSISDN (Mobile Station International Subscriber Directory
	// Number). In order to be globally unique it has to be formatted in international
	// format, according to E.164 standard, prefixed with '+'.
	PhoneNumber param.Opt[string] `json:"phoneNumber,omitzero"`
	XCorrelator param.Opt[string] `header:"x-correlator,omitzero" json:"-"`
	// contains filtered or unexported fields
}

func (KnowyourcustomerfillInNewParams) MarshalJSON 

func (r KnowyourcustomerfillInNewParams) MarshalJSON() (data []byte, err error)

func (*KnowyourcustomerfillInNewParams) UnmarshalJSON 

func (r *KnowyourcustomerfillInNewParams) UnmarshalJSON(data []byte) error

type KnowyourcustomerfillInNewResponse 

type KnowyourcustomerfillInNewResponse struct {
	// Complete address of the customer stored on the Operator's system. For some
	// countries, it is built following the usual concatenation of parameters in a
	// country, but for other countries, this is not the case. For some countries, it
	// can use streetName, streetNumber and/or houseNumberExtension. For example, in
	// ESP, streetName+streetNumber; in NLD, it can be streetName+streetNumber or
	// streetName+streetNumber+houseNumberExtension.
	Address string `json:"address"`
	// Birthdate of the customer, in ISO 8601 calendar date format (YYYY-MM-DD), stored
	// on the Operator's system.
	Birthdate time.Time `json:"birthdate" format:"date"`
	// City where the customer was born.
	CityOfBirth string `json:"cityOfBirth"`
	// Country of the customer's address stored on the Operator's system. Format ISO
	// 3166-1 alpha-2.
	Country string `json:"country"`
	// Country where the customer was born. Format ISO 3166-1 alpha-2.
	CountryOfBirth string `json:"countryOfBirth"`
	// Email address of the customer in the RFC specified format (local-part@domain),
	// stored on the Operator's system.
	Email string `json:"email" format:"email"`
	// Last name, family name, or surname of the customer stored on the Operator's
	// system.
	FamilyName string `json:"familyName"`
	// Last/family/sur- name at birth of the customer stored on the Operator's system.
	FamilyNameAtBirth string `json:"familyNameAtBirth"`
	// Gender of the customer stored on the Operator's system (Male/Female/Other).
	//
	// Any of "MALE", "FEMALE", "OTHER".
	Gender KnowyourcustomerfillInNewResponseGender `json:"gender"`
	// First/given name or compound first/given name of the customer on the Operator's
	// system.
	GivenName string `json:"givenName"`
	// House number extension of the customer stored on the Operator's system. Specific
	// identifier of the house needed depending on the property type. For example,
	// number of apartment in an apartment building.
	HouseNumberExtension string `json:"houseNumberExtension"`
	// Id number associated to the id_document of the customer stored on the Operator's
	// system.
	IDDocument string `json:"idDocument"`
	// Expiration date of the identity document (ISO 8601).
	IDDocumentExpiryDate time.Time `json:"idDocumentExpiryDate" format:"date"`
	// Type of the official identity document provided.
	//
	// Any of "passport", "national_id_card", "residence_permit", "diplomatic_id",
	// "driver_licence", "social_security_id", "other".
	IDDocumentType KnowyourcustomerfillInNewResponseIDDocumentType `json:"idDocumentType"`
	// Locality of the customer's address, stored on the Operator's system.
	Locality string `json:"locality"`
	// Middle name/s of the customer stored on the Operator's system.
	MiddleNames string `json:"middleNames"`
	// Complete name of the customer stored on the Operator's system. It is usually
	// composed of first/given name and last/family/sur- name in a country. Depending
	// on the country, the order of first/give name and last/family/sur- name varies,
	// and middle name could be included. It can use givenName, middleNames, familyName
	// and/or familyNameAtBirth. For example, in ESP, name+familyName; in NLD, it can
	// be name+middleNames+familyName or name+middleNames+familyNameAtBirth, etc.
	Name string `json:"name"`
	// Complete name of the customer in Hankaku-Kana format (reading of name) for
	// Japan, stored on the Operator's system.
	NameKanaHankaku string `json:"nameKanaHankaku"`
	// Complete name of the customer in Zenkaku-Kana format (reading of name) for
	// Japan, stored on the Operator's system.
	NameKanaZenkaku string `json:"nameKanaZenkaku"`
	// ISO 3166-1 alpha-2 code of the customer’s nationality. In the case a customer
	// has more than one nationality, it is supposed to be the nationality related to
	// the ID document provided in the match request.
	Nationality string `json:"nationality"`
	// A public identifier addressing a telephone subscription. In mobile networks it
	// corresponds to the MSISDN (Mobile Station International Subscriber Directory
	// Number). In order to be globally unique it has to be formatted in international
	// format, according to E.164 standard, prefixed with '+'.
	PhoneNumber string `json:"phoneNumber"`
	// The postal code or Zip code of the customer's address, stored on the Operator's
	// system.
	PostalCode string `json:"postalCode"`
	// Region/prefecture of the customer's address, stored on the Operator's system.
	Region string `json:"region"`
	// Name of the street of the customer's address on the Operator's system. It should
	// not include the type of the street.
	StreetName string `json:"streetName"`
	// The street number of the customer's address on the Operator's system. Number
	// identifying a specific property on the 'streetName'.
	StreetNumber string `json:"streetNumber"`
	// JSON contains metadata for fields, check presence with [respjson.Field.Valid].
	JSON struct {
		Address              respjson.Field
		Birthdate            respjson.Field
		CityOfBirth          respjson.Field
		Country              respjson.Field
		CountryOfBirth       respjson.Field
		Email                respjson.Field
		FamilyName           respjson.Field
		FamilyNameAtBirth    respjson.Field
		Gender               respjson.Field
		GivenName            respjson.Field
		HouseNumberExtension respjson.Field
		IDDocument           respjson.Field
		IDDocumentExpiryDate respjson.Field
		IDDocumentType       respjson.Field
		Locality             respjson.Field
		MiddleNames          respjson.Field
		Name                 respjson.Field
		NameKanaHankaku      respjson.Field
		NameKanaZenkaku      respjson.Field
		Nationality          respjson.Field
		PhoneNumber          respjson.Field
		PostalCode           respjson.Field
		Region               respjson.Field
		StreetName           respjson.Field
		StreetNumber         respjson.Field
		ExtraFields          map[string]respjson.Field
		// contains filtered or unexported fields
	} `json:"-"`
}

func (KnowyourcustomerfillInNewResponse) RawJSON 

func (r KnowyourcustomerfillInNewResponse) RawJSON() string

Returns the unmodified JSON received from the API

func (*KnowyourcustomerfillInNewResponse) UnmarshalJSON 

func (r *KnowyourcustomerfillInNewResponse) UnmarshalJSON(data []byte) error

type KnowyourcustomerfillInNewResponseGender 

type KnowyourcustomerfillInNewResponseGender string

Gender of the customer stored on the Operator's system (Male/Female/Other). 

const (
	KnowyourcustomerfillInNewResponseGenderMale   KnowyourcustomerfillInNewResponseGender = "MALE"
	KnowyourcustomerfillInNewResponseGenderFemale KnowyourcustomerfillInNewResponseGender = "FEMALE"
	KnowyourcustomerfillInNewResponseGenderOther  KnowyourcustomerfillInNewResponseGender = "OTHER"
)

type KnowyourcustomerfillInNewResponseIDDocumentType 

type KnowyourcustomerfillInNewResponseIDDocumentType string

Type of the official identity document provided. 

const (
	KnowyourcustomerfillInNewResponseIDDocumentTypePassport         KnowyourcustomerfillInNewResponseIDDocumentType = "passport"
	KnowyourcustomerfillInNewResponseIDDocumentTypeNationalIDCard   KnowyourcustomerfillInNewResponseIDDocumentType = "national_id_card"
	KnowyourcustomerfillInNewResponseIDDocumentTypeResidencePermit  KnowyourcustomerfillInNewResponseIDDocumentType = "residence_permit"
	KnowyourcustomerfillInNewResponseIDDocumentTypeDiplomaticID     KnowyourcustomerfillInNewResponseIDDocumentType = "diplomatic_id"
	KnowyourcustomerfillInNewResponseIDDocumentTypeDriverLicence    KnowyourcustomerfillInNewResponseIDDocumentType = "driver_licence"
	KnowyourcustomerfillInNewResponseIDDocumentTypeSocialSecurityID KnowyourcustomerfillInNewResponseIDDocumentType = "social_security_id"
	KnowyourcustomerfillInNewResponseIDDocumentTypeOther            KnowyourcustomerfillInNewResponseIDDocumentType = "other"
)

type KnowyourcustomerfillInService 

type KnowyourcustomerfillInService struct {
	Options []option.RequestOption
}

Know Your Customer Fill-in

KnowyourcustomerfillInService contains methods and other services that help with interacting with the camara API.

Note, unlike clients, this service does not read variables from the environment automatically. You should not instantiate this service directly, and instead use the NewKnowyourcustomerfillInService method instead.

func NewKnowyourcustomerfillInService 

func NewKnowyourcustomerfillInService(opts ...option.RequestOption) (r KnowyourcustomerfillInService)

NewKnowyourcustomerfillInService generates a new service that applies the given options to each request. These options are applied after the parent client's options (if there is one), and before any request-specific options.

func (*KnowyourcustomerfillInService) New 

func (r *KnowyourcustomerfillInService) New(ctx context.Context, params KnowyourcustomerfillInNewParams, opts ...option.RequestOption) (res *KnowyourcustomerfillInNewResponse, err error)

Providing information related to a customer identity stored the account data bound to the customer's phone number.

type KnowyourcustomermatchMatchParams 

type KnowyourcustomermatchMatchParams struct {
	// Complete address of the customer. For some countries, it is built following the
	// usual concatenation of parameters in a country, but for other countries, this is
	// not the case. For some countries, it can use streetName, streetNumber and/or
	// houseNumberExtension. For example, in ESP, streetName+streetNumber; in NLD, it
	// can be streetName+streetNumber or streetName+streetNumber+houseNumberExtension.
	Address param.Opt[string] `json:"address,omitzero"`
	// The birthdate of the customer, in RFC 3339 / ISO 8601 calendar date format
	// (YYYY-MM-DD).
	Birthdate param.Opt[time.Time] `json:"birthdate,omitzero" format:"date"`
	// City where the customer was born.
	CityOfBirth param.Opt[string] `json:"cityOfBirth,omitzero"`
	// Country of the customer's address. Format ISO 3166-1 alpha-2
	Country param.Opt[string] `json:"country,omitzero"`
	// Country where the customer was born. Format ISO 3166-1 alpha-2.
	CountryOfBirth param.Opt[string] `json:"countryOfBirth,omitzero"`
	// Email address of the customer in the RFC specified format (local-part@domain).
	Email param.Opt[string] `json:"email,omitzero" format:"email"`
	// Last name, family name, or surname of the customer.
	FamilyName param.Opt[string] `json:"familyName,omitzero"`
	// Last/family/sur- name at birth of the customer.
	FamilyNameAtBirth param.Opt[string] `json:"familyNameAtBirth,omitzero"`
	// First/given name or compound first/given name of the customer.
	GivenName param.Opt[string] `json:"givenName,omitzero"`
	// Specific identifier of the house needed depending on the property type. For
	// example, number of apartment in an apartment building.
	HouseNumberExtension param.Opt[string] `json:"houseNumberExtension,omitzero"`
	// Id number associated to the official identity document in the country. It may
	// contain alphanumeric characters.
	IDDocument param.Opt[string] `json:"idDocument,omitzero"`
	// Expiration date of the identity document (ISO 8601).
	IDDocumentExpiryDate param.Opt[time.Time] `json:"idDocumentExpiryDate,omitzero" format:"date"`
	// Locality of the customer's address
	Locality param.Opt[string] `json:"locality,omitzero"`
	// Middle name/s of the customer.
	MiddleNames param.Opt[string] `json:"middleNames,omitzero"`
	// Complete name of the customer, usually composed of first/given name and
	// last/family/sur- name in a country. Depending on the country, the order of
	// first/give name and last/family/sur- name varies, and middle name could be
	// included. It can use givenName, middleNames, familyName and/or
	// familyNameAtBirth. For example, in ESP, name+familyName; in NLD, it can be
	// name+middleNames+familyName or name+middleNames+familyNameAtBirth, etc.
	Name param.Opt[string] `json:"name,omitzero"`
	// Complete name of the customer in Hankaku-Kana format (reading of name) for
	// Japan.
	NameKanaHankaku param.Opt[string] `json:"nameKanaHankaku,omitzero"`
	// Complete name of the customer in Zenkaku-Kana format (reading of name) for
	// Japan.
	NameKanaZenkaku param.Opt[string] `json:"nameKanaZenkaku,omitzero"`
	// ISO 3166-1 alpha-2 code of the customer’s nationality. In the case a customer
	// has more than one nationality, it is supposed to be the nationality related to
	// the ID document provided in the match request.
	Nationality param.Opt[string] `json:"nationality,omitzero"`
	// A public identifier addressing a telephone subscription. In mobile networks it
	// corresponds to the MSISDN (Mobile Station International Subscriber Directory
	// Number). In order to be globally unique it has to be formatted in international
	// format, according to E.164 standard, prefixed with '+'.
	PhoneNumber param.Opt[string] `json:"phoneNumber,omitzero"`
	// Zip code or postal code
	PostalCode param.Opt[string] `json:"postalCode,omitzero"`
	// Region/prefecture of the customer's address
	Region param.Opt[string] `json:"region,omitzero"`
	// Name of the street of the customer's address. It should not include the type of
	// the street.
	StreetName param.Opt[string] `json:"streetName,omitzero"`
	// The street number of the customer's address. Number identifying a specific
	// property on the 'streetName'.
	StreetNumber param.Opt[string] `json:"streetNumber,omitzero"`
	XCorrelator  param.Opt[string] `header:"x-correlator,omitzero" json:"-"`
	// Gender of the customer (Male/Female/Other).
	//
	// Any of "MALE", "FEMALE", "OTHER".
	Gender KnowyourcustomermatchMatchParamsGender `json:"gender,omitzero"`
	// Type of the official identity document provided.
	//
	// Any of "passport", "national_id_card", "residence_permit", "diplomatic_id",
	// "driver_licence", "social_security_id", "other".
	IDDocumentType KnowyourcustomermatchMatchParamsIDDocumentType `json:"idDocumentType,omitzero"`
	// contains filtered or unexported fields
}

func (KnowyourcustomermatchMatchParams) MarshalJSON 

func (r KnowyourcustomermatchMatchParams) MarshalJSON() (data []byte, err error)

func (*KnowyourcustomermatchMatchParams) UnmarshalJSON 

func (r *KnowyourcustomermatchMatchParams) UnmarshalJSON(data []byte) error

type KnowyourcustomermatchMatchParamsGender 

type KnowyourcustomermatchMatchParamsGender string

Gender of the customer (Male/Female/Other). 

const (
	KnowyourcustomermatchMatchParamsGenderMale   KnowyourcustomermatchMatchParamsGender = "MALE"
	KnowyourcustomermatchMatchParamsGenderFemale KnowyourcustomermatchMatchParamsGender = "FEMALE"
	KnowyourcustomermatchMatchParamsGenderOther  KnowyourcustomermatchMatchParamsGender = "OTHER"
)

type KnowyourcustomermatchMatchParamsIDDocumentType 

type KnowyourcustomermatchMatchParamsIDDocumentType string

Type of the official identity document provided. 

const (
	KnowyourcustomermatchMatchParamsIDDocumentTypePassport         KnowyourcustomermatchMatchParamsIDDocumentType = "passport"
	KnowyourcustomermatchMatchParamsIDDocumentTypeNationalIDCard   KnowyourcustomermatchMatchParamsIDDocumentType = "national_id_card"
	KnowyourcustomermatchMatchParamsIDDocumentTypeResidencePermit  KnowyourcustomermatchMatchParamsIDDocumentType = "residence_permit"
	KnowyourcustomermatchMatchParamsIDDocumentTypeDiplomaticID     KnowyourcustomermatchMatchParamsIDDocumentType = "diplomatic_id"
	KnowyourcustomermatchMatchParamsIDDocumentTypeDriverLicence    KnowyourcustomermatchMatchParamsIDDocumentType = "driver_licence"
	KnowyourcustomermatchMatchParamsIDDocumentTypeSocialSecurityID KnowyourcustomermatchMatchParamsIDDocumentType = "social_security_id"
	KnowyourcustomermatchMatchParamsIDDocumentTypeOther            KnowyourcustomermatchMatchParamsIDDocumentType = "other"
)

type KnowyourcustomermatchMatchResponse 

type KnowyourcustomermatchMatchResponse struct {
	// true - the attribute provided matches with the one in the Operator systems,
	// which is equal to a `match_score` of 100. false - the attribute provided does
	// not match with the one in the Operator systems. not_available - the attribute is
	// not available to validate.
	//
	// Any of "true", "false", "not_available".
	AddressMatch MatchResult `json:"addressMatch"`
	// Indicates the similarity score assigned to the input value when it does not
	// exactly match the value stored in the operator's system. This property shall
	// only be returned when the value of the corresponding match field is `false`. A
	// perfect match with a score of 100 is indicated by `match` being 'true' and no
	// `matchScore` is returned in this case.
	AddressMatchScore int64 `json:"addressMatchScore"`
	// true - the attribute provided matches with the one in the Operator systems,
	// which is equal to a `match_score` of 100. false - the attribute provided does
	// not match with the one in the Operator systems. not_available - the attribute is
	// not available to validate.
	//
	// Any of "true", "false", "not_available".
	BirthdateMatch MatchResult `json:"birthdateMatch"`
	// true - the attribute provided matches with the one in the Operator systems,
	// which is equal to a `match_score` of 100. false - the attribute provided does
	// not match with the one in the Operator systems. not_available - the attribute is
	// not available to validate.
	//
	// Any of "true", "false", "not_available".
	CityOfBirthMatch MatchResult `json:"cityOfBirthMatch"`
	// Indicates the similarity score assigned to the input value when it does not
	// exactly match the value stored in the operator's system. This property shall
	// only be returned when the value of the corresponding match field is `false`. A
	// perfect match with a score of 100 is indicated by `match` being 'true' and no
	// `matchScore` is returned in this case.
	CityOfBirthMatchScore int64 `json:"cityOfBirthMatchScore"`
	// true - the attribute provided matches with the one in the Operator systems,
	// which is equal to a `match_score` of 100. false - the attribute provided does
	// not match with the one in the Operator systems. not_available - the attribute is
	// not available to validate.
	//
	// Any of "true", "false", "not_available".
	CountryMatch MatchResult `json:"countryMatch"`
	// true - the attribute provided matches with the one in the Operator systems,
	// which is equal to a `match_score` of 100. false - the attribute provided does
	// not match with the one in the Operator systems. not_available - the attribute is
	// not available to validate.
	//
	// Any of "true", "false", "not_available".
	CountryOfBirthMatch MatchResult `json:"countryOfBirthMatch"`
	// true - the attribute provided matches with the one in the Operator systems,
	// which is equal to a `match_score` of 100. false - the attribute provided does
	// not match with the one in the Operator systems. not_available - the attribute is
	// not available to validate.
	//
	// Any of "true", "false", "not_available".
	EmailMatch MatchResult `json:"emailMatch"`
	// Indicates the similarity score assigned to the input value when it does not
	// exactly match the value stored in the operator's system. This property shall
	// only be returned when the value of the corresponding match field is `false`. A
	// perfect match with a score of 100 is indicated by `match` being 'true' and no
	// `matchScore` is returned in this case.
	EmailMatchScore int64 `json:"emailMatchScore"`
	// true - the attribute provided matches with the one in the Operator systems,
	// which is equal to a `match_score` of 100. false - the attribute provided does
	// not match with the one in the Operator systems. not_available - the attribute is
	// not available to validate.
	//
	// Any of "true", "false", "not_available".
	FamilyNameAtBirthMatch MatchResult `json:"familyNameAtBirthMatch"`
	// Indicates the similarity score assigned to the input value when it does not
	// exactly match the value stored in the operator's system. This property shall
	// only be returned when the value of the corresponding match field is `false`. A
	// perfect match with a score of 100 is indicated by `match` being 'true' and no
	// `matchScore` is returned in this case.
	FamilyNameAtBirthMatchScore int64 `json:"familyNameAtBirthMatchScore"`
	// true - the attribute provided matches with the one in the Operator systems,
	// which is equal to a `match_score` of 100. false - the attribute provided does
	// not match with the one in the Operator systems. not_available - the attribute is
	// not available to validate.
	//
	// Any of "true", "false", "not_available".
	FamilyNameMatch MatchResult `json:"familyNameMatch"`
	// Indicates the similarity score assigned to the input value when it does not
	// exactly match the value stored in the operator's system. This property shall
	// only be returned when the value of the corresponding match field is `false`. A
	// perfect match with a score of 100 is indicated by `match` being 'true' and no
	// `matchScore` is returned in this case.
	FamilyNameMatchScore int64 `json:"familyNameMatchScore"`
	// true - the attribute provided matches with the one in the Operator systems,
	// which is equal to a `match_score` of 100. false - the attribute provided does
	// not match with the one in the Operator systems. not_available - the attribute is
	// not available to validate.
	//
	// Any of "true", "false", "not_available".
	GenderMatch MatchResult `json:"genderMatch"`
	// true - the attribute provided matches with the one in the Operator systems,
	// which is equal to a `match_score` of 100. false - the attribute provided does
	// not match with the one in the Operator systems. not_available - the attribute is
	// not available to validate.
	//
	// Any of "true", "false", "not_available".
	GivenNameMatch MatchResult `json:"givenNameMatch"`
	// Indicates the similarity score assigned to the input value when it does not
	// exactly match the value stored in the operator's system. This property shall
	// only be returned when the value of the corresponding match field is `false`. A
	// perfect match with a score of 100 is indicated by `match` being 'true' and no
	// `matchScore` is returned in this case.
	GivenNameMatchScore int64 `json:"givenNameMatchScore"`
	// true - the attribute provided matches with the one in the Operator systems,
	// which is equal to a `match_score` of 100. false - the attribute provided does
	// not match with the one in the Operator systems. not_available - the attribute is
	// not available to validate.
	//
	// Any of "true", "false", "not_available".
	HouseNumberExtensionMatch MatchResult `json:"houseNumberExtensionMatch"`
	// true - the attribute provided matches with the one in the Operator systems,
	// which is equal to a `match_score` of 100. false - the attribute provided does
	// not match with the one in the Operator systems. not_available - the attribute is
	// not available to validate.
	//
	// Any of "true", "false", "not_available".
	IDDocumentExpiryDateMatch MatchResult `json:"idDocumentExpiryDateMatch"`
	// true - the attribute provided matches with the one in the Operator systems,
	// which is equal to a `match_score` of 100. false - the attribute provided does
	// not match with the one in the Operator systems. not_available - the attribute is
	// not available to validate.
	//
	// Any of "true", "false", "not_available".
	IDDocumentMatch MatchResult `json:"idDocumentMatch"`
	// true - the attribute provided matches with the one in the Operator systems,
	// which is equal to a `match_score` of 100. false - the attribute provided does
	// not match with the one in the Operator systems. not_available - the attribute is
	// not available to validate.
	//
	// Any of "true", "false", "not_available".
	IDDocumentTypeMatch MatchResult `json:"idDocumentTypeMatch"`
	// true - the attribute provided matches with the one in the Operator systems,
	// which is equal to a `match_score` of 100. false - the attribute provided does
	// not match with the one in the Operator systems. not_available - the attribute is
	// not available to validate.
	//
	// Any of "true", "false", "not_available".
	LocalityMatch MatchResult `json:"localityMatch"`
	// Indicates the similarity score assigned to the input value when it does not
	// exactly match the value stored in the operator's system. This property shall
	// only be returned when the value of the corresponding match field is `false`. A
	// perfect match with a score of 100 is indicated by `match` being 'true' and no
	// `matchScore` is returned in this case.
	LocalityMatchScore int64 `json:"localityMatchScore"`
	// true - the attribute provided matches with the one in the Operator systems,
	// which is equal to a `match_score` of 100. false - the attribute provided does
	// not match with the one in the Operator systems. not_available - the attribute is
	// not available to validate.
	//
	// Any of "true", "false", "not_available".
	MiddleNamesMatch MatchResult `json:"middleNamesMatch"`
	// Indicates the similarity score assigned to the input value when it does not
	// exactly match the value stored in the operator's system. This property shall
	// only be returned when the value of the corresponding match field is `false`. A
	// perfect match with a score of 100 is indicated by `match` being 'true' and no
	// `matchScore` is returned in this case.
	MiddleNamesMatchScore int64 `json:"middleNamesMatchScore"`
	// true - the attribute provided matches with the one in the Operator systems,
	// which is equal to a `match_score` of 100. false - the attribute provided does
	// not match with the one in the Operator systems. not_available - the attribute is
	// not available to validate.
	//
	// Any of "true", "false", "not_available".
	NameKanaHankakuMatch MatchResult `json:"nameKanaHankakuMatch"`
	// Indicates the similarity score assigned to the input value when it does not
	// exactly match the value stored in the operator's system. This property shall
	// only be returned when the value of the corresponding match field is `false`. A
	// perfect match with a score of 100 is indicated by `match` being 'true' and no
	// `matchScore` is returned in this case.
	NameKanaHankakuMatchScore int64 `json:"nameKanaHankakuMatchScore"`
	// true - the attribute provided matches with the one in the Operator systems,
	// which is equal to a `match_score` of 100. false - the attribute provided does
	// not match with the one in the Operator systems. not_available - the attribute is
	// not available to validate.
	//
	// Any of "true", "false", "not_available".
	NameKanaZenkakuMatch MatchResult `json:"nameKanaZenkakuMatch"`
	// Indicates the similarity score assigned to the input value when it does not
	// exactly match the value stored in the operator's system. This property shall
	// only be returned when the value of the corresponding match field is `false`. A
	// perfect match with a score of 100 is indicated by `match` being 'true' and no
	// `matchScore` is returned in this case.
	NameKanaZenkakuMatchScore int64 `json:"nameKanaZenkakuMatchScore"`
	// true - the attribute provided matches with the one in the Operator systems,
	// which is equal to a `match_score` of 100. false - the attribute provided does
	// not match with the one in the Operator systems. not_available - the attribute is
	// not available to validate.
	//
	// Any of "true", "false", "not_available".
	NameMatch MatchResult `json:"nameMatch"`
	// Indicates the similarity score assigned to the input value when it does not
	// exactly match the value stored in the operator's system. This property shall
	// only be returned when the value of the corresponding match field is `false`. A
	// perfect match with a score of 100 is indicated by `match` being 'true' and no
	// `matchScore` is returned in this case.
	NameMatchScore int64 `json:"nameMatchScore"`
	// true - the attribute provided matches with the one in the Operator systems,
	// which is equal to a `match_score` of 100. false - the attribute provided does
	// not match with the one in the Operator systems. not_available - the attribute is
	// not available to validate.
	//
	// Any of "true", "false", "not_available".
	NationalityMatch MatchResult `json:"nationalityMatch"`
	// true - the attribute provided matches with the one in the Operator systems,
	// which is equal to a `match_score` of 100. false - the attribute provided does
	// not match with the one in the Operator systems. not_available - the attribute is
	// not available to validate.
	//
	// Any of "true", "false", "not_available".
	PostalCodeMatch MatchResult `json:"postalCodeMatch"`
	// true - the attribute provided matches with the one in the Operator systems,
	// which is equal to a `match_score` of 100. false - the attribute provided does
	// not match with the one in the Operator systems. not_available - the attribute is
	// not available to validate.
	//
	// Any of "true", "false", "not_available".
	RegionMatch MatchResult `json:"regionMatch"`
	// Indicates the similarity score assigned to the input value when it does not
	// exactly match the value stored in the operator's system. This property shall
	// only be returned when the value of the corresponding match field is `false`. A
	// perfect match with a score of 100 is indicated by `match` being 'true' and no
	// `matchScore` is returned in this case.
	RegionMatchScore int64 `json:"regionMatchScore"`
	// true - the attribute provided matches with the one in the Operator systems,
	// which is equal to a `match_score` of 100. false - the attribute provided does
	// not match with the one in the Operator systems. not_available - the attribute is
	// not available to validate.
	//
	// Any of "true", "false", "not_available".
	StreetNameMatch MatchResult `json:"streetNameMatch"`
	// Indicates the similarity score assigned to the input value when it does not
	// exactly match the value stored in the operator's system. This property shall
	// only be returned when the value of the corresponding match field is `false`. A
	// perfect match with a score of 100 is indicated by `match` being 'true' and no
	// `matchScore` is returned in this case.
	StreetNameMatchScore int64 `json:"streetNameMatchScore"`
	// true - the attribute provided matches with the one in the Operator systems,
	// which is equal to a `match_score` of 100. false - the attribute provided does
	// not match with the one in the Operator systems. not_available - the attribute is
	// not available to validate.
	//
	// Any of "true", "false", "not_available".
	StreetNumberMatch MatchResult `json:"streetNumberMatch"`
	// Indicates the similarity score assigned to the input value when it does not
	// exactly match the value stored in the operator's system. This property shall
	// only be returned when the value of the corresponding match field is `false`. A
	// perfect match with a score of 100 is indicated by `match` being 'true' and no
	// `matchScore` is returned in this case.
	StreetNumberMatchScore int64 `json:"streetNumberMatchScore"`
	// JSON contains metadata for fields, check presence with [respjson.Field.Valid].
	JSON struct {
		AddressMatch                respjson.Field
		AddressMatchScore           respjson.Field
		BirthdateMatch              respjson.Field
		CityOfBirthMatch            respjson.Field
		CityOfBirthMatchScore       respjson.Field
		CountryMatch                respjson.Field
		CountryOfBirthMatch         respjson.Field
		EmailMatch                  respjson.Field
		EmailMatchScore             respjson.Field
		FamilyNameAtBirthMatch      respjson.Field
		FamilyNameAtBirthMatchScore respjson.Field
		FamilyNameMatch             respjson.Field
		FamilyNameMatchScore        respjson.Field
		GenderMatch                 respjson.Field
		GivenNameMatch              respjson.Field
		GivenNameMatchScore         respjson.Field
		HouseNumberExtensionMatch   respjson.Field
		IDDocumentExpiryDateMatch   respjson.Field
		IDDocumentMatch             respjson.Field
		IDDocumentTypeMatch         respjson.Field
		LocalityMatch               respjson.Field
		LocalityMatchScore          respjson.Field
		MiddleNamesMatch            respjson.Field
		MiddleNamesMatchScore       respjson.Field
		NameKanaHankakuMatch        respjson.Field
		NameKanaHankakuMatchScore   respjson.Field
		NameKanaZenkakuMatch        respjson.Field
		NameKanaZenkakuMatchScore   respjson.Field
		NameMatch                   respjson.Field
		NameMatchScore              respjson.Field
		NationalityMatch            respjson.Field
		PostalCodeMatch             respjson.Field
		RegionMatch                 respjson.Field
		RegionMatchScore            respjson.Field
		StreetNameMatch             respjson.Field
		StreetNameMatchScore        respjson.Field
		StreetNumberMatch           respjson.Field
		StreetNumberMatchScore      respjson.Field
		ExtraFields                 map[string]respjson.Field
		// contains filtered or unexported fields
	} `json:"-"`
}

func (KnowyourcustomermatchMatchResponse) RawJSON 

func (r KnowyourcustomermatchMatchResponse) RawJSON() string

Returns the unmodified JSON received from the API

func (*KnowyourcustomermatchMatchResponse) UnmarshalJSON 

func (r *KnowyourcustomermatchMatchResponse) UnmarshalJSON(data []byte) error

type KnowyourcustomermatchService 

type KnowyourcustomermatchService struct {
	Options []option.RequestOption
}

Know Your Customer Match

KnowyourcustomermatchService contains methods and other services that help with interacting with the camara API.

Note, unlike clients, this service does not read variables from the environment automatically. You should not instantiate this service directly, and instead use the NewKnowyourcustomermatchService method instead.

func NewKnowyourcustomermatchService 

func NewKnowyourcustomermatchService(opts ...option.RequestOption) (r KnowyourcustomermatchService)

NewKnowyourcustomermatchService generates a new service that applies the given options to each request. These options are applied after the parent client's options (if there is one), and before any request-specific options.

func (*KnowyourcustomermatchService) Match 

func (r *KnowyourcustomermatchService) Match(ctx context.Context, params KnowyourcustomermatchMatchParams, opts ...option.RequestOption) (res *KnowyourcustomermatchMatchResponse, err error)

Verify matching of a number of attributes related to a customer identity against the verified data bound to their phone number in the Operator systems. Regardless of whether the `phoneNumber` is explicitly stated in the request body, at least one of the other fields must be provided, otherwise a `HTTP 400 - KNOW_YOUR_CUSTOMER.INVALID_PARAM_COMBINATION` error will be returned.

The API will return the result of the matching process for each requested attribute. This means that the response will **only** contain the attributes for which validation has been requested. Possible values are:

  • **true**: the attribute provided matches with the one in the Operator systems, which is equal to a `match_score` of 100.
  • **false**: the attribute provided does not match with the one in the Operator systems.
  • **not_available**: the attribute is not available to validate.

type MatchResult 

type MatchResult string

true - the attribute provided matches with the one in the Operator systems, which is equal to a `match_score` of 100. false - the attribute provided does not match with the one in the Operator systems. not_available - the attribute is not available to validate. 

const (
	MatchResultTrue         MatchResult = "true"
	MatchResultFalse        MatchResult = "false"
	MatchResultNotAvailable MatchResult = "not_available"
)

type MediaSessionInformation 

type MediaSessionInformation struct {
	// **OFFER**: An inlined session description in SDP format [RFC4566].If XML syntax
	// is used, the content of this element SHALL be embedded in a CDATA section.
	//
	// **ANSWER**: This type represents an answer in WebRTC Signaling. This element is
	// not present in case there is no answer yet, or the session invitation has been
	// declined by the Terminating Participant.This element MUST NOT be present in a
	// request from the application to the server to create a session.
	Answer SdpDescriptor `json:"answer"`
	// Type of call. When set to EMERGENCY, the client MAY provide locationDetails. If
	// omitted, treated as REGULAR.
	//
	// Any of "REGULAR", "EMERGENCY".
	CallType MediaSessionInformationCallType `json:"callType"`
	// Details about the caller's location and related information. This object adheres
	// to 3GPP TS 24.229, RFC 4119, RFC 5139, and RFC 5491 for PIDF-LO compatibility.
	LocationDetails WebRtcLocationDetails `json:"locationDetails"`
	// The media session ID created by the network. The mediaSessionId shall not be
	// included in POST requests by the client, but must be included in the
	// notifications from the network to the client device.
	MediaSessionID string `json:"mediaSessionId"`
	// **OFFER**: An inlined session description in SDP format [RFC4566].If XML syntax
	// is used, the content of this element SHALL be embedded in a CDATA section.
	//
	// **ANSWER**: This type represents an answer in WebRTC Signaling. This element is
	// not present in case there is no answer yet, or the session invitation has been
	// declined by the Terminating Participant.This element MUST NOT be present in a
	// request from the application to the server to create a session.
	Offer SdpDescriptor `json:"offer"`
	// Subscriber address (Sender or Receiver)
	OriginatorAddress string `json:"originatorAddress"`
	// Friendly name of the call originator
	OriginatorName string `json:"originatorName"`
	// Subscriber address (Sender or Receiver)
	ReceiverAddress string `json:"receiverAddress"`
	// Friendly name of the call terminator
	ReceiverName string `json:"receiverName"`
	// Provides the status of the media session. During the session creation, this
	// attribute SHALL NOT be included in the request.
	//
	// Any of "Initial", "InProgress", "Ringing", "Proceeding", "Connected",
	// "Terminated", "Hold", "Resume", "SessionCancelled", "Declined", "Failed",
	// "Waiting", "NoAnswer", "NotReachable", "Busy".
	Status MediaSessionInformationStatus `json:"status"`
	// JSON contains metadata for fields, check presence with [respjson.Field.Valid].
	JSON struct {
		Answer            respjson.Field
		CallType          respjson.Field
		LocationDetails   respjson.Field
		MediaSessionID    respjson.Field
		Offer             respjson.Field
		OriginatorAddress respjson.Field
		OriginatorName    respjson.Field
		ReceiverAddress   respjson.Field
		ReceiverName      respjson.Field
		Status            respjson.Field
		ExtraFields       map[string]respjson.Field
		// contains filtered or unexported fields
	} `json:"-"`
}

func (MediaSessionInformation) RawJSON 

func (r MediaSessionInformation) RawJSON() string

Returns the unmodified JSON received from the API

func (MediaSessionInformation) ToParam 

func (r MediaSessionInformation) ToParam() MediaSessionInformationParam

ToParam converts this MediaSessionInformation to a MediaSessionInformationParam.

Warning: the fields of the param type will not be present. ToParam should only be used at the last possible moment before sending a request. Test for this with MediaSessionInformationParam.Overrides()

func (*MediaSessionInformation) UnmarshalJSON 

func (r *MediaSessionInformation) UnmarshalJSON(data []byte) error

type MediaSessionInformationCallType 

type MediaSessionInformationCallType string

Type of call. When set to EMERGENCY, the client MAY provide locationDetails. If omitted, treated as REGULAR. 

const (
	MediaSessionInformationCallTypeRegular   MediaSessionInformationCallType = "REGULAR"
	MediaSessionInformationCallTypeEmergency MediaSessionInformationCallType = "EMERGENCY"
)

type MediaSessionInformationParam 

type MediaSessionInformationParam struct {
	// The media session ID created by the network. The mediaSessionId shall not be
	// included in POST requests by the client, but must be included in the
	// notifications from the network to the client device.
	MediaSessionID param.Opt[string] `json:"mediaSessionId,omitzero"`
	// Subscriber address (Sender or Receiver)
	OriginatorAddress param.Opt[string] `json:"originatorAddress,omitzero"`
	// Friendly name of the call originator
	OriginatorName param.Opt[string] `json:"originatorName,omitzero"`
	// Subscriber address (Sender or Receiver)
	ReceiverAddress param.Opt[string] `json:"receiverAddress,omitzero"`
	// Friendly name of the call terminator
	ReceiverName param.Opt[string] `json:"receiverName,omitzero"`
	// **OFFER**: An inlined session description in SDP format [RFC4566].If XML syntax
	// is used, the content of this element SHALL be embedded in a CDATA section.
	//
	// **ANSWER**: This type represents an answer in WebRTC Signaling. This element is
	// not present in case there is no answer yet, or the session invitation has been
	// declined by the Terminating Participant.This element MUST NOT be present in a
	// request from the application to the server to create a session.
	Answer SdpDescriptorParam `json:"answer,omitzero"`
	// Type of call. When set to EMERGENCY, the client MAY provide locationDetails. If
	// omitted, treated as REGULAR.
	//
	// Any of "REGULAR", "EMERGENCY".
	CallType MediaSessionInformationCallType `json:"callType,omitzero"`
	// Details about the caller's location and related information. This object adheres
	// to 3GPP TS 24.229, RFC 4119, RFC 5139, and RFC 5491 for PIDF-LO compatibility.
	LocationDetails WebRtcLocationDetailsParam `json:"locationDetails,omitzero"`
	// **OFFER**: An inlined session description in SDP format [RFC4566].If XML syntax
	// is used, the content of this element SHALL be embedded in a CDATA section.
	//
	// **ANSWER**: This type represents an answer in WebRTC Signaling. This element is
	// not present in case there is no answer yet, or the session invitation has been
	// declined by the Terminating Participant.This element MUST NOT be present in a
	// request from the application to the server to create a session.
	Offer SdpDescriptorParam `json:"offer,omitzero"`
	// Provides the status of the media session. During the session creation, this
	// attribute SHALL NOT be included in the request.
	//
	// Any of "Initial", "InProgress", "Ringing", "Proceeding", "Connected",
	// "Terminated", "Hold", "Resume", "SessionCancelled", "Declined", "Failed",
	// "Waiting", "NoAnswer", "NotReachable", "Busy".
	Status MediaSessionInformationStatus `json:"status,omitzero"`
	// contains filtered or unexported fields
}

func (MediaSessionInformationParam) MarshalJSON 

func (r MediaSessionInformationParam) MarshalJSON() (data []byte, err error)

func (*MediaSessionInformationParam) UnmarshalJSON 

func (r *MediaSessionInformationParam) UnmarshalJSON(data []byte) error

type MediaSessionInformationStatus 

type MediaSessionInformationStatus string

Provides the status of the media session. During the session creation, this attribute SHALL NOT be included in the request. 

const (
	MediaSessionInformationStatusInitial          MediaSessionInformationStatus = "Initial"
	MediaSessionInformationStatusInProgress       MediaSessionInformationStatus = "InProgress"
	MediaSessionInformationStatusRinging          MediaSessionInformationStatus = "Ringing"
	MediaSessionInformationStatusProceeding       MediaSessionInformationStatus = "Proceeding"
	MediaSessionInformationStatusConnected        MediaSessionInformationStatus = "Connected"
	MediaSessionInformationStatusTerminated       MediaSessionInformationStatus = "Terminated"
	MediaSessionInformationStatusHold             MediaSessionInformationStatus = "Hold"
	MediaSessionInformationStatusResume           MediaSessionInformationStatus = "Resume"
	MediaSessionInformationStatusSessionCancelled MediaSessionInformationStatus = "SessionCancelled"
	MediaSessionInformationStatusDeclined         MediaSessionInformationStatus = "Declined"
	MediaSessionInformationStatusFailed           MediaSessionInformationStatus = "Failed"
	MediaSessionInformationStatusWaiting          MediaSessionInformationStatus = "Waiting"
	MediaSessionInformationStatusNoAnswer         MediaSessionInformationStatus = "NoAnswer"
	MediaSessionInformationStatusNotReachable     MediaSessionInformationStatus = "NotReachable"
	MediaSessionInformationStatusBusy             MediaSessionInformationStatus = "Busy"
)

type NumberrecyclingCheckSubscriberChangeParams 

type NumberrecyclingCheckSubscriberChangeParams struct {
	// Specified date to check whether there has been a change in the subscriber
	// associated with the specific phone number, in RFC 3339 calendar date format
	// (YYYY-MM-DD).
	SpecifiedDate time.Time `json:"specifiedDate" api:"required" format:"date"`
	// A public identifier addressing a telephone subscription. In mobile networks it
	// corresponds to the MSISDN (Mobile Station International Subscriber Directory
	// Number). In order to be globally unique it has to be formatted in international
	// format, according to E.164 standard, prefixed with '+'.
	PhoneNumber param.Opt[string] `json:"phoneNumber,omitzero"`
	XCorrelator param.Opt[string] `header:"x-correlator,omitzero" json:"-"`
	// contains filtered or unexported fields
}

func (NumberrecyclingCheckSubscriberChangeParams) MarshalJSON 

func (r NumberrecyclingCheckSubscriberChangeParams) MarshalJSON() (data []byte, err error)

func (*NumberrecyclingCheckSubscriberChangeParams) UnmarshalJSON 

func (r *NumberrecyclingCheckSubscriberChangeParams) UnmarshalJSON(data []byte) error

type NumberrecyclingCheckSubscriberChangeResponse 

type NumberrecyclingCheckSubscriberChangeResponse struct {
	// Set to true (Boolean, not string) when there has been a change in the subscriber
	// associated with the specific phone number after “specifiedDate”.
	PhoneNumberRecycled bool `json:"phoneNumberRecycled" api:"required"`
	// JSON contains metadata for fields, check presence with [respjson.Field.Valid].
	JSON struct {
		PhoneNumberRecycled respjson.Field
		ExtraFields         map[string]respjson.Field
		// contains filtered or unexported fields
	} `json:"-"`
}

func (NumberrecyclingCheckSubscriberChangeResponse) RawJSON 

func (r NumberrecyclingCheckSubscriberChangeResponse) RawJSON() string

Returns the unmodified JSON received from the API

func (*NumberrecyclingCheckSubscriberChangeResponse) UnmarshalJSON 

func (r *NumberrecyclingCheckSubscriberChangeResponse) UnmarshalJSON(data []byte) error

type NumberrecyclingService 

type NumberrecyclingService struct {
	Options []option.RequestOption
}

Number Recycling

NumberrecyclingService contains methods and other services that help with interacting with the camara API.

Note, unlike clients, this service does not read variables from the environment automatically. You should not instantiate this service directly, and instead use the NewNumberrecyclingService method instead.

func NewNumberrecyclingService 

func NewNumberrecyclingService(opts ...option.RequestOption) (r NumberrecyclingService)

NewNumberrecyclingService generates a new service that applies the given options to each request. These options are applied after the parent client's options (if there is one), and before any request-specific options.

func (*NumberrecyclingService) CheckSubscriberChange 

func (r *NumberrecyclingService) CheckSubscriberChange(ctx context.Context, params NumberrecyclingCheckSubscriberChangeParams, opts ...option.RequestOption) (res *NumberrecyclingCheckSubscriberChangeResponse, err error)

Check whether the subscriber of the phone number has changed.

type OtpvalidationSendCodeParams 

type OtpvalidationSendCodeParams struct {
	// Message template used to compose the content of the SMS sent to the phone
	// number. It must include the following label indicating where to include the
	// short code `{{code}}`
	Message string `json:"message" api:"required"`
	// A public identifier addressing a telephone subscription. In mobile networks it
	// corresponds to the MSISDN (Mobile Station International Subscriber Directory
	// Number). In order to be globally unique it has to be formatted in international
	// format, according to E.164 standard, prefixed with '+'.
	PhoneNumber string            `json:"phoneNumber" api:"required"`
	XCorrelator param.Opt[string] `header:"x-correlator,omitzero" json:"-"`
	// contains filtered or unexported fields
}

func (OtpvalidationSendCodeParams) MarshalJSON 

func (r OtpvalidationSendCodeParams) MarshalJSON() (data []byte, err error)

func (*OtpvalidationSendCodeParams) UnmarshalJSON 

func (r *OtpvalidationSendCodeParams) UnmarshalJSON(data []byte) error

type OtpvalidationSendCodeResponse 

type OtpvalidationSendCodeResponse struct {
	// unique id of the verification attempt the code belongs to.
	AuthenticationID string `json:"authenticationId" api:"required"`
	// JSON contains metadata for fields, check presence with [respjson.Field.Valid].
	JSON struct {
		AuthenticationID respjson.Field
		ExtraFields      map[string]respjson.Field
		// contains filtered or unexported fields
	} `json:"-"`
}

Structure to provide authentication identifier

func (OtpvalidationSendCodeResponse) RawJSON 

func (r OtpvalidationSendCodeResponse) RawJSON() string

Returns the unmodified JSON received from the API

func (*OtpvalidationSendCodeResponse) UnmarshalJSON 

func (r *OtpvalidationSendCodeResponse) UnmarshalJSON(data []byte) error

type OtpvalidationService 

type OtpvalidationService struct {
	Options []option.RequestOption
}

One Time Password SMS

OtpvalidationService contains methods and other services that help with interacting with the camara API.

Note, unlike clients, this service does not read variables from the environment automatically. You should not instantiate this service directly, and instead use the NewOtpvalidationService method instead.

func NewOtpvalidationService 

func NewOtpvalidationService(opts ...option.RequestOption) (r OtpvalidationService)

NewOtpvalidationService generates a new service that applies the given options to each request. These options are applied after the parent client's options (if there is one), and before any request-specific options.

func (*OtpvalidationService) SendCode 

func (r *OtpvalidationService) SendCode(ctx context.Context, params OtpvalidationSendCodeParams, opts ...option.RequestOption) (res *OtpvalidationSendCodeResponse, err error)

Sends an SMS with the desired message and an OTP code to the received phone number.

func (*OtpvalidationService) ValidateCode 

func (r *OtpvalidationService) ValidateCode(ctx context.Context, params OtpvalidationValidateCodeParams, opts ...option.RequestOption) (err error)

Verifies the code is valid for the received authenticationId

type OtpvalidationValidateCodeParams 

type OtpvalidationValidateCodeParams struct {
	// unique id of the verification attempt the code belongs to.
	AuthenticationID string `json:"authenticationId" api:"required"`
	// temporal, short code to be validated
	Code        string            `json:"code" api:"required"`
	XCorrelator param.Opt[string] `header:"x-correlator,omitzero" json:"-"`
	// contains filtered or unexported fields
}

func (OtpvalidationValidateCodeParams) MarshalJSON 

func (r OtpvalidationValidateCodeParams) MarshalJSON() (data []byte, err error)

func (*OtpvalidationValidateCodeParams) UnmarshalJSON 

func (r *OtpvalidationValidateCodeParams) UnmarshalJSON(data []byte) error

type PopulationdensitydataGetParams 

type PopulationdensitydataGetParams struct {
	// Base schema for all areas
	Area PopulationdensitydataGetParamsArea `json:"area,omitzero" api:"required"`
	// End date time. It must follow
	// [RFC 3339](https://datatracker.ietf.org/doc/html/rfc3339#section-5.6) and must
	// have time zone. Recommended format is yyyy-MM-dd'T'HH:mm:ss.SSSZ (i.e. which
	// allows 2023-07-03T14:27:08.312+02:00 or 2023-07-03T12:27:08.312Z) The maximum
	// endTime allowed is 3 months from the time of the request.
	EndTime time.Time `json:"endTime" api:"required" format:"date-time"`
	// Start date time. It must follow
	// [RFC 3339](https://datatracker.ietf.org/doc/html/rfc3339#section-5.6) and must
	// have time zone. Recommended format is yyyy-MM-dd'T'HH:mm:ss.SSSZ
	StartTime time.Time `json:"startTime" api:"required" format:"date-time"`
	// Precision required of response cells. Precision defines a geohash level and
	// corresponds to the length of the geohash for each cell. More information at
	// [Geohash system](https://en.wikipedia.org/wiki/Geohash)" If not included the
	// default precision level 7 is used by default. In case of using a not supported
	// level by the MNO, the API returns the error response
	// `POPULATION_DENSITY_DATA.UNSUPPORTED_PRECISION`.
	Precision param.Opt[int64] `json:"precision,omitzero"`
	// The address where the API response will be asynchronously delivered, using the
	// HTTP protocol.
	Sink        param.Opt[string] `json:"sink,omitzero" format:"uri"`
	XCorrelator param.Opt[string] `header:"x-correlator,omitzero" json:"-"`
	// A sink credential provides authentication or authorization information necessary
	// to enable delivery of events to a target.
	SinkCredential PopulationdensitydataGetParamsSinkCredential `json:"sinkCredential,omitzero"`
	// contains filtered or unexported fields
}

func (PopulationdensitydataGetParams) MarshalJSON 

func (r PopulationdensitydataGetParams) MarshalJSON() (data []byte, err error)

func (*PopulationdensitydataGetParams) UnmarshalJSON 

func (r *PopulationdensitydataGetParams) UnmarshalJSON(data []byte) error

type PopulationdensitydataGetParamsArea 

type PopulationdensitydataGetParamsArea struct {
	// Type of this area. POLYGON - The area is defined as a polygon.
	//
	// Any of "POLYGON".
	AreaType string `json:"areaType,omitzero" api:"required"`
	// contains filtered or unexported fields
}

Base schema for all areas

The property AreaType is required.

func (PopulationdensitydataGetParamsArea) MarshalJSON 

func (r PopulationdensitydataGetParamsArea) MarshalJSON() (data []byte, err error)

func (*PopulationdensitydataGetParamsArea) UnmarshalJSON 

func (r *PopulationdensitydataGetParamsArea) UnmarshalJSON(data []byte) error

type PopulationdensitydataGetParamsSinkCredential 

type PopulationdensitydataGetParamsSinkCredential struct {
	// The type of the credential. Note: Type of the credential - MUST be set to
	// ACCESSTOKEN for now
	//
	// Any of "PLAIN", "ACCESSTOKEN", "REFRESHTOKEN".
	CredentialType string `json:"credentialType,omitzero" api:"required"`
	// contains filtered or unexported fields
}

A sink credential provides authentication or authorization information necessary to enable delivery of events to a target.

The property CredentialType is required.

func (PopulationdensitydataGetParamsSinkCredential) MarshalJSON 

func (r PopulationdensitydataGetParamsSinkCredential) MarshalJSON() (data []byte, err error)

func (*PopulationdensitydataGetParamsSinkCredential) UnmarshalJSON 

func (r *PopulationdensitydataGetParamsSinkCredential) UnmarshalJSON(data []byte) error

type PopulationdensitydataGetResponse 

type PopulationdensitydataGetResponse struct {
	// Represents the state of the response for the input polygon defined in the
	// request, the possible values are:
	//
	//   - `SUPPORTED_AREA`: The whole request area is supported. Population density data
	//     for the entire requested area is returned.
	//   - `PART_OF_AREA_NOT_SUPPORTED`: Part of the requested area is outside the MNOs
	//     coverage area, the cells outside the coverage area will have property
	//     `dataType` with value `NO_DATA`.
	//   - `AREA_NOT_SUPPORTED`: The whole requested area is outside the MNOs coverage
	//     area. No data will be returned.
	//   - `OPERATION_NOT_COMPLETED`: An error happened during asynchronous processing of
	//     the request. This status will only be returned in case the asynchronous API
	//     behaviour is used.
	//
	// Any of "SUPPORTED_AREA", "PART_OF_AREA_NOT_SUPPORTED", "AREA_NOT_SUPPORTED",
	// "OPERATION_NOT_COMPLETED".
	Status PopulationdensitydataGetResponseStatus `json:"status" api:"required"`
	// Time ranges along with the population density data for the cells within it. The
	// request startTime or the request endTime have to be fully covered by the
	// intervals. For example, if the intervals are 1-hour long and the input date
	// range were [2024-01-03T11:25:00Z to 2024-01-03T12:45:00Z] it would contain 2
	// intervals (Interval from 2024-01-03T11:00:00Z to 2024-01-03T12:00:00Z and
	// interval from 2024-01-03T12:00:00Z to 2024-01-03T13:00:00Z).
	TimedPopulationDensityData []PopulationdensitydataGetResponseTimedPopulationDensityData `json:"timedPopulationDensityData" api:"required"`
	// Information about the status, mandatory when property `status` is
	// `OPERATION_NOT_COMPLETED` for adding extra information about the error.
	StatusInfo string `json:"statusInfo"`
	// JSON contains metadata for fields, check presence with [respjson.Field.Valid].
	JSON struct {
		Status                     respjson.Field
		TimedPopulationDensityData respjson.Field
		StatusInfo                 respjson.Field
		ExtraFields                map[string]respjson.Field
		// contains filtered or unexported fields
	} `json:"-"`
}

Population density values is represented in time intervals for different cells of the requested area. Each element in `timedPopulationDensityData` array corresponds to a time interval, containing population density data for the grid cells. The intervals are 1 hour long.

func (PopulationdensitydataGetResponse) RawJSON 

func (r PopulationdensitydataGetResponse) RawJSON() string

Returns the unmodified JSON received from the API

func (*PopulationdensitydataGetResponse) UnmarshalJSON 

func (r *PopulationdensitydataGetResponse) UnmarshalJSON(data []byte) error

type PopulationdensitydataGetResponseStatus 

type PopulationdensitydataGetResponseStatus string

Represents the state of the response for the input polygon defined in the request, the possible values are:

  • `SUPPORTED_AREA`: The whole request area is supported. Population density data for the entire requested area is returned.
  • `PART_OF_AREA_NOT_SUPPORTED`: Part of the requested area is outside the MNOs coverage area, the cells outside the coverage area will have property `dataType` with value `NO_DATA`.
  • `AREA_NOT_SUPPORTED`: The whole requested area is outside the MNOs coverage area. No data will be returned.
  • `OPERATION_NOT_COMPLETED`: An error happened during asynchronous processing of the request. This status will only be returned in case the asynchronous API behaviour is used.
const (
	PopulationdensitydataGetResponseStatusSupportedArea          PopulationdensitydataGetResponseStatus = "SUPPORTED_AREA"
	PopulationdensitydataGetResponseStatusPartOfAreaNotSupported PopulationdensitydataGetResponseStatus = "PART_OF_AREA_NOT_SUPPORTED"
	PopulationdensitydataGetResponseStatusAreaNotSupported       PopulationdensitydataGetResponseStatus = "AREA_NOT_SUPPORTED"
	PopulationdensitydataGetResponseStatusOperationNotCompleted  PopulationdensitydataGetResponseStatus = "OPERATION_NOT_COMPLETED"
)

type PopulationdensitydataGetResponseTimedPopulationDensityData 

type PopulationdensitydataGetResponseTimedPopulationDensityData struct {
	// Population density data for the different cells in a concrete time range.
	CellPopulationDensityData []PopulationdensitydataGetResponseTimedPopulationDensityDataCellPopulationDensityData `json:"cellPopulationDensityData" api:"required"`
	// Interval end time. It must follow
	// [RFC 3339](https://datatracker.ietf.org/doc/html/rfc3339#section-5.6) and must
	// have time zone. Recommended format is yyyy-MM-dd'T'HH:mm:ss.SSSZ (i.e. which
	// allows 2023-07-03T14:27:08.312+02:00 or 2023-07-03T12:27:08.312Z)
	EndTime time.Time `json:"endTime" api:"required" format:"date-time"`
	// Interval start time. It must follow
	// [RFC 3339](https://datatracker.ietf.org/doc/html/rfc3339#section-5.6) and must
	// have time zone. Recommended format is yyyy-MM-dd'T'HH:mm:ss.SSSZ (i.e. which
	// allows 2023-07-03T14:27:08.312+02:00 or 2023-07-03T12:27:08.312Z)
	StartTime time.Time `json:"startTime" api:"required" format:"date-time"`
	// JSON contains metadata for fields, check presence with [respjson.Field.Valid].
	JSON struct {
		CellPopulationDensityData respjson.Field
		EndTime                   respjson.Field
		StartTime                 respjson.Field
		ExtraFields               map[string]respjson.Field
		// contains filtered or unexported fields
	} `json:"-"`
}

func (PopulationdensitydataGetResponseTimedPopulationDensityData) RawJSON 

func (r PopulationdensitydataGetResponseTimedPopulationDensityData) RawJSON() string

Returns the unmodified JSON received from the API

func (*PopulationdensitydataGetResponseTimedPopulationDensityData) UnmarshalJSON 

func (r *PopulationdensitydataGetResponseTimedPopulationDensityData) UnmarshalJSON(data []byte) error

type PopulationdensitydataGetResponseTimedPopulationDensityDataCellPopulationDensityData 

type PopulationdensitydataGetResponseTimedPopulationDensityDataCellPopulationDensityData struct {
	// Any of "NO_DATA", "LOW_DENSITY", "DENSITY_ESTIMATION".
	DataType string `json:"dataType" api:"required"`
	// Coordinates of the cell represented as a string using the
	// [Geohash system](https://en.wikipedia.org/wiki/Geohash). Encoding a geographic
	// location into a short string. The value length, and thus, the cell granularity,
	// is determined by the request body property `precision`.
	Geohash string `json:"geohash" api:"required"`
	// JSON contains metadata for fields, check presence with [respjson.Field.Valid].
	JSON struct {
		DataType    respjson.Field
		Geohash     respjson.Field
		ExtraFields map[string]respjson.Field
		// contains filtered or unexported fields
	} `json:"-"`
}

Population density data of a cell in a concrete time range. In case of insufficient data, to guarantee an anonymized prediction due to the k-anonymity within a specific cell and time range, no population density data is returned and the property `dataType` value is "LOW_DENSITY". In case of a cell not supported `dataType` value is "NO_DATA"

func (PopulationdensitydataGetResponseTimedPopulationDensityDataCellPopulationDensityData) RawJSON 

func (r PopulationdensitydataGetResponseTimedPopulationDensityDataCellPopulationDensityData) RawJSON() string

Returns the unmodified JSON received from the API

func (*PopulationdensitydataGetResponseTimedPopulationDensityDataCellPopulationDensityData) UnmarshalJSON 

func (r *PopulationdensitydataGetResponseTimedPopulationDensityDataCellPopulationDensityData) UnmarshalJSON(data []byte) error

type PopulationdensitydataService 

type PopulationdensitydataService struct {
	Options []option.RequestOption
}

Population Density Data

PopulationdensitydataService contains methods and other services that help with interacting with the camara API.

Note, unlike clients, this service does not read variables from the environment automatically. You should not instantiate this service directly, and instead use the NewPopulationdensitydataService method instead.

func NewPopulationdensitydataService 

func NewPopulationdensitydataService(opts ...option.RequestOption) (r PopulationdensitydataService)

NewPopulationdensitydataService generates a new service that applies the given options to each request. These options are applied after the parent client's options (if there is one), and before any request-specific options.

func (*PopulationdensitydataService) Get 

func (r *PopulationdensitydataService) Get(ctx context.Context, params PopulationdensitydataGetParams, opts ...option.RequestOption) (res *PopulationdensitydataGetResponse, err error)

Retrieves population density estimation together with the estimation range related for a time slot for a given area (described as a polygon) as a data set consisting of a sequence of equally-sized objects covering the input polygon area.

type Protocol 

type Protocol string

Identifier of a delivery protocol. Only HTTP is allowed for now 

const (
	ProtocolHTTP  Protocol = "HTTP"
	ProtocolMqtt3 Protocol = "MQTT3"
	ProtocolMqtt5 Protocol = "MQTT5"
	ProtocolAmqp  Protocol = "AMQP"
	ProtocolNats  Protocol = "NATS"
	ProtocolKafka Protocol = "KAFKA"
)

type QosProfile 

type QosProfile struct {
	// A unique name for identifying a specific QoS profile. This may follow different
	// formats depending on the service providers implementation. Some options
	// addresses:
	//
	//   - A UUID style string
	//   - Support for predefined profile names like `QOS_E`, `QOS_S`, `QOS_M`, and
	//     `QOS_L`
	//   - A searchable descriptive name
	Name string `json:"name" api:"required" format:"string"`
	// The current status of the QoS Profile
	//
	//   - `ACTIVE`- QoS Profile is available to be used
	//   - `INACTIVE`- QoS Profile is not currently available to be deployed
	//   - `DEPRECATED`- QoS profile is actively being used in a QoD session, but can not
	//     be deployed in new QoD sessions
	//
	// Any of "ACTIVE", "INACTIVE", "DEPRECATED".
	Status QosProfileStatus `json:"status" api:"required"`
	// A list of countries, and optionally networks, for which the API provider makes
	// the profile available
	CountryAvailability []QosProfileCountryAvailability `json:"countryAvailability"`
	// A description of the QoS profile.
	Description string `json:"description"`
	// Specification of duration
	Jitter Duration `json:"jitter"`
	// **NOTE**: l4sQueueType is experimental and could change or be removed in a
	// future release.
	//
	// Specifies the type of queue for L4S (Low Latency, Low Loss, Scalable Throughput)
	// traffic management. L4S is an advanced queue management approach designed to
	// provide ultra-low latency and high throughput for internet traffic, particularly
	// beneficial for interactive applications such as gaming, video conferencing, and
	// virtual reality.
	//
	// **Queue Type Descriptions:**
	//
	//   - **non-l4s-queue**: A traditional queue used for legacy internet traffic that
	//     does not utilize L4S enhancements. It provides standard latency and throughput
	//     levels.
	//
	//   - **l4s-queue**: A dedicated queue optimized for L4S traffic, delivering
	//     ultra-low latency, low loss, and scalable throughput to support
	//     latency-sensitive applications.
	//
	//   - **mixed-queue**: A shared queue that can handle both L4S and traditional
	//     traffic, offering a balance between ultra-low latency for L4S flows and
	//     compatibility with non-L4S flows.
	//
	// Any of "non-l4s-queue", "l4s-queue", "mixed-queue".
	L4sQueueType QosProfileL4sQueueType `json:"l4sQueueType"`
	// Specification of rate
	MaxDownstreamBurstRate Rate `json:"maxDownstreamBurstRate"`
	// Specification of rate
	MaxDownstreamRate Rate `json:"maxDownstreamRate"`
	// Specification of duration
	MaxDuration Duration `json:"maxDuration"`
	// Specification of rate
	MaxUpstreamBurstRate Rate `json:"maxUpstreamBurstRate"`
	// Specification of rate
	MaxUpstreamRate Rate `json:"maxUpstreamRate"`
	// Specification of duration
	MinDuration Duration `json:"minDuration"`
	// Specification of duration
	PacketDelayBudget Duration `json:"packetDelayBudget"`
	// This field specifies the acceptable level of data loss during transmission. The
	// value is an exponent of 10, so a value of 3 means that up to 10⁻³, or 0.1%, of
	// the data packets may be lost. This setting is part of a broader system that
	// categorizes different types of network traffic (like phone calls, video streams,
	// or data transfers) to ensure they perform reliably on the network.
	PacketErrorLossRate int64 `json:"packetErrorLossRate"`
	// Priority levels allow efficient resource allocation and ensure optimal
	// performance for various services in each technology, with the highest priority
	// traffic receiving preferential treatment. The lower value the higher priority.
	// Not all access networks use the same priority range, so this priority will be
	// scaled to the access network's priority range.
	Priority int64 `json:"priority"`
	// **NOTE**: serviceClass is experimental and could change or be removed in a
	// future release.
	//
	// The name of a Service Class, representing a QoS Profile designed to provide
	// optimized behavior for a specific application type. While DSCP values are
	// commonly associated with Service Classes, their use may vary across network
	// segments and may not be applied throughout the entire end-to-end QoS session.
	// This aligns with the serviceClass concept used in HomeDevicesQoQ for consistent
	// terminology.
	//
	// Service classes define specific QoS behaviors that map to DSCP (Differentiated
	// Services Code Point) values or Microsoft QoS traffic types.
	//
	// The supported mappings are:
	//
	//  1. Values aligned with the
	//     [RFC4594](https://datatracker.ietf.org/doc/html/rfc4594) guidelines for
	//     differentiated traffic classes.
	//  2. Microsoft
	//     [QOS_TRAFFIC_TYPE](https://learn.microsoft.com/en-us/windows/win32/api/qos2/ne-qos2-qos_traffic_type)
	//     values for Windows developers.
	//
	// **Supported Service Classes**:
	//
	// | Service Class Name    | DSCP Name | DSCP value (decimal) | DCSP value (binary) | Microsoft Value | Application Examples                                                 |
	// | --------------------- | --------- | -------------------- | ------------------- | --------------- | -------------------------------------------------------------------- |
	// | Microsoft Voice       | CS7       | 56                   | 111000              | 4,5             | Microsoft QOSTrafficTypeVoice and QOSTrafficTypeControl              |
	// | Microsoft Audio/Video | CS5       | 40                   | 101000              | 2,3             | Microsoft QOSTrafficTypeExcellentEffort and QOSTrafficTypeAudioVideo |
	// | Real-Time Interactive | CS4       | 32                   | 100000              |                 | Video conferencing and Interactive gaming                            |
	// | Multimedia Streaming  | AF31      | 26                   | 011010              |                 | Streaming video and audio on demand                                  |
	// | Broadcast Video       | CS3       | 24                   | 011000              |                 | Broadcast TV & live events                                           |
	// | Low-Latency Data      | AF21      | 18                   | 010010              |                 | Client/server transactions Web-based ordering                        |
	// | High-Throughput Data  | AF11      | 10                   | 001010              |                 | Store and forward applications                                       |
	// | Low-Priority Data     | CS1       | 8                    | 001000              | 1               | Any flow that has no BW assurance - also:                            |
	// |                       |           |                      |                     |                 | Microsoft QOSTrafficTypeBackground                                   |
	// | Standard              | DF(CS0)   | 0                    | 000000              | 0               | Undifferentiated applications - also:                                |
	// |                       |           |                      |                     |                 | Microsoft QOSTrafficTypeBestEffort                                   |
	//
	// Any of "microsoft_voice", "microsoft_audio_video", "real_time_interactive",
	// "multimedia_streaming", "broadcast_video", "low_latency_data",
	// "high_throughput_data", "low_priority_data", "standard".
	ServiceClass QosProfileServiceClass `json:"serviceClass"`
	// Specification of rate
	TargetMinDownstreamRate Rate `json:"targetMinDownstreamRate"`
	// Specification of rate
	TargetMinUpstreamRate Rate `json:"targetMinUpstreamRate"`
	// JSON contains metadata for fields, check presence with [respjson.Field.Valid].
	JSON struct {
		Name                    respjson.Field
		Status                  respjson.Field
		CountryAvailability     respjson.Field
		Description             respjson.Field
		Jitter                  respjson.Field
		L4sQueueType            respjson.Field
		MaxDownstreamBurstRate  respjson.Field
		MaxDownstreamRate       respjson.Field
		MaxDuration             respjson.Field
		MaxUpstreamBurstRate    respjson.Field
		MaxUpstreamRate         respjson.Field
		MinDuration             respjson.Field
		PacketDelayBudget       respjson.Field
		PacketErrorLossRate     respjson.Field
		Priority                respjson.Field
		ServiceClass            respjson.Field
		TargetMinDownstreamRate respjson.Field
		TargetMinUpstreamRate   respjson.Field
		ExtraFields             map[string]respjson.Field
		// contains filtered or unexported fields
	} `json:"-"`
}

Data type with attributes of a QosProfile

func (QosProfile) RawJSON 

func (r QosProfile) RawJSON() string

Returns the unmodified JSON received from the API

func (*QosProfile) UnmarshalJSON 

func (r *QosProfile) UnmarshalJSON(data []byte) error

type QosProfileCountryAvailability 

type QosProfileCountryAvailability struct {
	// The two letter ISO 3166-2 country code for the country in which the QoS profile
	// is available in at least one network
	CountryName string `json:"countryName" api:"required"`
	// A list of networks within the country for which the QoS profile is available
	// from the API provider
	Networks []string `json:"networks"`
	// JSON contains metadata for fields, check presence with [respjson.Field.Valid].
	JSON struct {
		CountryName respjson.Field
		Networks    respjson.Field
		ExtraFields map[string]respjson.Field
		// contains filtered or unexported fields
	} `json:"-"`
}

func (QosProfileCountryAvailability) RawJSON 

func (r QosProfileCountryAvailability) RawJSON() string

Returns the unmodified JSON received from the API

func (*QosProfileCountryAvailability) UnmarshalJSON 

func (r *QosProfileCountryAvailability) UnmarshalJSON(data []byte) error

type QosProfileL4sQueueType 

type QosProfileL4sQueueType string

**NOTE**: l4sQueueType is experimental and could change or be removed in a future release.

Specifies the type of queue for L4S (Low Latency, Low Loss, Scalable Throughput) traffic management. L4S is an advanced queue management approach designed to provide ultra-low latency and high throughput for internet traffic, particularly beneficial for interactive applications such as gaming, video conferencing, and virtual reality.

**Queue Type Descriptions:**

  • **non-l4s-queue**: A traditional queue used for legacy internet traffic that does not utilize L4S enhancements. It provides standard latency and throughput levels.

  • **l4s-queue**: A dedicated queue optimized for L4S traffic, delivering ultra-low latency, low loss, and scalable throughput to support latency-sensitive applications.

  • **mixed-queue**: A shared queue that can handle both L4S and traditional traffic, offering a balance between ultra-low latency for L4S flows and compatibility with non-L4S flows. 

const (
	QosProfileL4sQueueTypeNonL4sQueue QosProfileL4sQueueType = "non-l4s-queue"
	QosProfileL4sQueueTypeL4sQueue    QosProfileL4sQueueType = "l4s-queue"
	QosProfileL4sQueueTypeMixedQueue  QosProfileL4sQueueType = "mixed-queue"
)

type QosProfileServiceClass 

type QosProfileServiceClass string

**NOTE**: serviceClass is experimental and could change or be removed in a future release.

The name of a Service Class, representing a QoS Profile designed to provide optimized behavior for a specific application type. While DSCP values are commonly associated with Service Classes, their use may vary across network segments and may not be applied throughout the entire end-to-end QoS session. This aligns with the serviceClass concept used in HomeDevicesQoQ for consistent terminology.

Service classes define specific QoS behaviors that map to DSCP (Differentiated Services Code Point) values or Microsoft QoS traffic types.

The supported mappings are:

  1. Values aligned with the [RFC4594](https://datatracker.ietf.org/doc/html/rfc4594) guidelines for differentiated traffic classes.
  2. Microsoft [QOS_TRAFFIC_TYPE](https://learn.microsoft.com/en-us/windows/win32/api/qos2/ne-qos2-qos_traffic_type) values for Windows developers.

**Supported Service Classes**:

| Service Class Name | DSCP Name | DSCP value (decimal) | DCSP value (binary) | Microsoft Value | Application Examples | | --------------------- | --------- | -------------------- | ------------------- | --------------- | -------------------------------------------------------------------- | | Microsoft Voice | CS7 | 56 | 111000 | 4,5 | Microsoft QOSTrafficTypeVoice and QOSTrafficTypeControl | | Microsoft Audio/Video | CS5 | 40 | 101000 | 2,3 | Microsoft QOSTrafficTypeExcellentEffort and QOSTrafficTypeAudioVideo | | Real-Time Interactive | CS4 | 32 | 100000 | | Video conferencing and Interactive gaming | | Multimedia Streaming | AF31 | 26 | 011010 | | Streaming video and audio on demand | | Broadcast Video | CS3 | 24 | 011000 | | Broadcast TV & live events | | Low-Latency Data | AF21 | 18 | 010010 | | Client/server transactions Web-based ordering | | High-Throughput Data | AF11 | 10 | 001010 | | Store and forward applications | | Low-Priority Data | CS1 | 8 | 001000 | 1 | Any flow that has no BW assurance - also: | | | | | | | Microsoft QOSTrafficTypeBackground | | Standard | DF(CS0) | 0 | 000000 | 0 | Undifferentiated applications - also: | | | | | | | Microsoft QOSTrafficTypeBestEffort | 

const (
	QosProfileServiceClassMicrosoftVoice      QosProfileServiceClass = "microsoft_voice"
	QosProfileServiceClassMicrosoftAudioVideo QosProfileServiceClass = "microsoft_audio_video"
	QosProfileServiceClassRealTimeInteractive QosProfileServiceClass = "real_time_interactive"
	QosProfileServiceClassMultimediaStreaming QosProfileServiceClass = "multimedia_streaming"
	QosProfileServiceClassBroadcastVideo      QosProfileServiceClass = "broadcast_video"
	QosProfileServiceClassLowLatencyData      QosProfileServiceClass = "low_latency_data"
	QosProfileServiceClassHighThroughputData  QosProfileServiceClass = "high_throughput_data"
	QosProfileServiceClassLowPriorityData     QosProfileServiceClass = "low_priority_data"
	QosProfileServiceClassStandard            QosProfileServiceClass = "standard"
)

type QosProfileStatus 

type QosProfileStatus string

The current status of the QoS Profile

  • `ACTIVE`- QoS Profile is available to be used
  • `INACTIVE`- QoS Profile is not currently available to be deployed
  • `DEPRECATED`- QoS profile is actively being used in a QoD session, but can not be deployed in new QoD sessions
const (
	QosProfileStatusActive     QosProfileStatus = "ACTIVE"
	QosProfileStatusInactive   QosProfileStatus = "INACTIVE"
	QosProfileStatusDeprecated QosProfileStatus = "DEPRECATED"
)

type QualityondemandGetQosProfileParams 

type QualityondemandGetQosProfileParams struct {
	// Value for the x-correlator
	XCorrelator param.Opt[string] `header:"x-correlator,omitzero" json:"-"`
	// contains filtered or unexported fields
}

type QualityondemandGetQosProfilesParams 

type QualityondemandGetQosProfilesParams struct {
	// A unique name for identifying a specific QoS profile. This may follow different
	// formats depending on the service providers implementation. Some options
	// addresses:
	//
	//   - A UUID style string
	//   - Support for predefined profile names like `QOS_E`, `QOS_S`, `QOS_M`, and
	//     `QOS_L`
	//   - A searchable descriptive name
	Name param.Opt[string] `json:"name,omitzero" format:"string"`
	// Value for the x-correlator
	XCorrelator param.Opt[string] `header:"x-correlator,omitzero" json:"-"`
	// End-user equipment able to connect to a mobile network. Examples of devices
	// include smartphones or IoT sensors/actuators.
	//
	// The developer can choose to provide the below specified device identifiers:
	//
	//   - `ipv4Address`
	//   - `ipv6Address`
	//   - `phoneNumber` NOTE1: the network operator might support only a subset of these
	//     options. The API consumer can provide multiple identifiers to be compatible
	//     across different operators. In this case the identifiers MUST belong to the
	//     same device. NOTE2: as for this Commonalities release, we are enforcing that
	//     the networkAccessIdentifier is only part of the schema for future-proofing,
	//     and CAMARA does not currently allow its use. After the CAMARA meta-release
	//     work is concluded and the relevant issues are resolved, its use will need to
	//     be explicitly documented in the guidelines.
	Device QualityondemandGetQosProfilesParamsDevice `json:"device,omitzero"`
	// The current status of the QoS Profile
	//
	//   - `ACTIVE`- QoS Profile is available to be used
	//   - `INACTIVE`- QoS Profile is not currently available to be deployed
	//   - `DEPRECATED`- QoS profile is actively being used in a QoD session, but can not
	//     be deployed in new QoD sessions
	//
	// Any of "ACTIVE", "INACTIVE", "DEPRECATED".
	Status QosProfileStatus `json:"status,omitzero"`
	// contains filtered or unexported fields
}

func (QualityondemandGetQosProfilesParams) MarshalJSON 

func (r QualityondemandGetQosProfilesParams) MarshalJSON() (data []byte, err error)

func (*QualityondemandGetQosProfilesParams) UnmarshalJSON 

func (r *QualityondemandGetQosProfilesParams) UnmarshalJSON(data []byte) error

type QualityondemandGetQosProfilesParamsDevice 

type QualityondemandGetQosProfilesParamsDevice struct {
	// The device should be identified by the observed IPv6 address, or by any single
	// IPv6 address from within the subnet allocated to the device (e.g. adding ::0 to
	// the /64 prefix).
	//
	// The session shall apply to all IP flows between the device subnet and the
	// specified application server, unless further restricted by the optional
	// parameters devicePorts or applicationServerPorts.
	Ipv6Address param.Opt[string] `json:"ipv6Address,omitzero" format:"ipv6"`
	// A public identifier addressing a subscription in a mobile network. In 3GPP
	// terminology, it corresponds to the GPSI formatted with the External Identifier
	// ({Local Identifier}@{Domain Identifier}). Unlike the telephone number, the
	// network access identifier is not subjected to portability ruling in force, and
	// is individually managed by each operator.
	NetworkAccessIdentifier param.Opt[string] `json:"networkAccessIdentifier,omitzero"`
	// A public identifier addressing a telephone subscription. In mobile networks it
	// corresponds to the MSISDN (Mobile Station International Subscriber Directory
	// Number). In order to be globally unique it has to be formatted in international
	// format, according to E.164 standard, prefixed with '+'.
	PhoneNumber param.Opt[string] `json:"phoneNumber,omitzero"`
	// The device should be identified by either the public (observed) IP address and
	// port as seen by the application server, or the private (local) and any public
	// (observed) IP addresses in use by the device (this information can be obtained
	// by various means, for example from some DNS servers).
	//
	// If the allocated and observed IP addresses are the same (i.e. NAT is not in use)
	// then the same address should be specified for both publicAddress and
	// privateAddress.
	//
	// If NAT64 is in use, the device should be identified by its publicAddress and
	// publicPort, or separately by its allocated IPv6 address (field ipv6Address of
	// the Device object)
	//
	// In all cases, publicAddress must be specified, along with at least one of either
	// privateAddress or publicPort, dependent upon which is known. In general, mobile
	// devices cannot be identified by their public IPv4 address alone.
	Ipv4Address QualityondemandGetQosProfilesParamsDeviceIpv4Address `json:"ipv4Address,omitzero"`
	// contains filtered or unexported fields
}

End-user equipment able to connect to a mobile network. Examples of devices include smartphones or IoT sensors/actuators.

The developer can choose to provide the below specified device identifiers:

  • `ipv4Address`
  • `ipv6Address`
  • `phoneNumber` NOTE1: the network operator might support only a subset of these options. The API consumer can provide multiple identifiers to be compatible across different operators. In this case the identifiers MUST belong to the same device. NOTE2: as for this Commonalities release, we are enforcing that the networkAccessIdentifier is only part of the schema for future-proofing, and CAMARA does not currently allow its use. After the CAMARA meta-release work is concluded and the relevant issues are resolved, its use will need to be explicitly documented in the guidelines.

func (QualityondemandGetQosProfilesParamsDevice) MarshalJSON 

func (r QualityondemandGetQosProfilesParamsDevice) MarshalJSON() (data []byte, err error)

func (*QualityondemandGetQosProfilesParamsDevice) UnmarshalJSON 

func (r *QualityondemandGetQosProfilesParamsDevice) UnmarshalJSON(data []byte) error

type QualityondemandGetQosProfilesParamsDeviceIpv4Address 

type QualityondemandGetQosProfilesParamsDeviceIpv4Address struct {
	// A single IPv4 address with no subnet mask
	PrivateAddress param.Opt[string] `json:"privateAddress,omitzero" format:"ipv4"`
	// A single IPv4 address with no subnet mask
	PublicAddress param.Opt[string] `json:"publicAddress,omitzero" format:"ipv4"`
	// TCP or UDP port number
	PublicPort param.Opt[int64] `json:"publicPort,omitzero"`
	// contains filtered or unexported fields
}

The device should be identified by either the public (observed) IP address and port as seen by the application server, or the private (local) and any public (observed) IP addresses in use by the device (this information can be obtained by various means, for example from some DNS servers).

If the allocated and observed IP addresses are the same (i.e. NAT is not in use) then the same address should be specified for both publicAddress and privateAddress.

If NAT64 is in use, the device should be identified by its publicAddress and publicPort, or separately by its allocated IPv6 address (field ipv6Address of the Device object)

In all cases, publicAddress must be specified, along with at least one of either privateAddress or publicPort, dependent upon which is known. In general, mobile devices cannot be identified by their public IPv4 address alone.

func (QualityondemandGetQosProfilesParamsDeviceIpv4Address) MarshalJSON 

func (r QualityondemandGetQosProfilesParamsDeviceIpv4Address) MarshalJSON() (data []byte, err error)

func (*QualityondemandGetQosProfilesParamsDeviceIpv4Address) UnmarshalJSON 

func (r *QualityondemandGetQosProfilesParamsDeviceIpv4Address) UnmarshalJSON(data []byte) error

type QualityondemandService 

type QualityondemandService struct {
	Options []option.RequestOption
}

QoS Profiles

QualityondemandService contains methods and other services that help with interacting with the camara API.

Note, unlike clients, this service does not read variables from the environment automatically. You should not instantiate this service directly, and instead use the NewQualityondemandService method instead.

func NewQualityondemandService 

func NewQualityondemandService(opts ...option.RequestOption) (r QualityondemandService)

NewQualityondemandService generates a new service that applies the given options to each request. These options are applied after the parent client's options (if there is one), and before any request-specific options.

func (*QualityondemandService) GetQosProfile 

func (r *QualityondemandService) GetQosProfile(ctx context.Context, name string, query QualityondemandGetQosProfileParams, opts ...option.RequestOption) (res *QosProfile, err error)

Returns a QoS Profile that matches the given name.

The access token may be either a 2-legged or 3-legged access token. If the access token is 3-legged, a QoS Profile is only returned if available to all subjects associated with the access token.

func (*QualityondemandService) GetQosProfiles 

func (r *QualityondemandService) GetQosProfiles(ctx context.Context, params QualityondemandGetQosProfilesParams, opts ...option.RequestOption) (res *[]QosProfile, err error)

Returns all QoS Profiles that match the given criteria. **NOTES:**

  • The access token may be either a 2-legged or 3-legged access token.
  • If the access token is 3-legged, all returned QoS Profiles will be available to the subject (device) associated with the access token.
  • If the access token is 2-legged and a device filter is provided, all returned QoS Profiles will be available to that device. If multiple device identifiers are provided within the device property, only QoS Profiles available to the device identifier chosen by the implementation will be returned, even if the identifiers do not match the same device. API provider does not perform any logic to validate/correlate that the indicated device identifiers match the same device. No error should be returned if the identifiers are otherwise valid to prevent API consumers correlating different identifiers with a given end user.
  • This call uses the POST method instead of GET to comply with the CAMARA Commonalities guidelines for sending sensitive or complex data in API calls. Since the device field may contain personally identifiable information, it should not be sent via GET. Additionally, this call may include complex data structures. [CAMARA API Design Guidelines](https://github.com/camaraproject/Commonalities/blob/r3.3/documentation/API-design-guidelines.md#post-or-get-for-transferring-sensitive-or-complex-data)

type Rate 

type Rate struct {
	// Units of rate
	//
	// Any of "bps", "kbps", "Mbps", "Gbps", "Tbps".
	Unit RateUnit `json:"unit"`
	// Quantity of rate
	Value int64 `json:"value"`
	// JSON contains metadata for fields, check presence with [respjson.Field.Valid].
	JSON struct {
		Unit        respjson.Field
		Value       respjson.Field
		ExtraFields map[string]respjson.Field
		// contains filtered or unexported fields
	} `json:"-"`
}

Specification of rate

func (Rate) RawJSON 

func (r Rate) RawJSON() string

Returns the unmodified JSON received from the API

func (*Rate) UnmarshalJSON 

func (r *Rate) UnmarshalJSON(data []byte) error

type RateUnit 

type RateUnit string

Units of rate 

const (
	RateUnitBps  RateUnit = "bps"
	RateUnitKbps RateUnit = "kbps"
	RateUnitMbps RateUnit = "Mbps"
	RateUnitGbps RateUnit = "Gbps"
	RateUnitTbps RateUnit = "Tbps"
)

type RegiondevicecountGetCountParams 

type RegiondevicecountGetCountParams struct {
	// Ending timestamp for counting the number of devices in the area. It must follow
	// [RFC 3339](https://datatracker.ietf.org/doc/html/rfc3339#section-5.6) and must
	// have time zone.
	Endtime param.Opt[time.Time] `json:"endtime,omitzero" format:"date-time"`
	// Starting timestamp for counting the number of devices in the area. It must
	// follow [RFC 3339](https://datatracker.ietf.org/doc/html/rfc3339#section-5.6) and
	// must have time zone.
	Starttime param.Opt[time.Time] `json:"starttime,omitzero" format:"date-time"`
	// The URL where the API response will be asynchronously delivered, using the HTTP
	// protocol.
	Sink        param.Opt[string]                   `json:"sink,omitzero" format:"uri"`
	XCorrelator param.Opt[string]                   `header:"x-correlator,omitzero" json:"-"`
	Area        RegiondevicecountGetCountParamsArea `json:"area,omitzero"`
	// This parameter is used to filter devices. Currently, two filtering criteria are
	// defined, `roamingStatus` and `deviceType`, which can be expanded in the future.
	// `IN` logic is used used for multiple filtering items within a single filtering
	// criterion, `AND` logic is used between multiple filtering criteria.
	//
	//   - If a filtering critera is not provided, it means that there is no need to
	//     filter this item.
	//   - At least one of the criteria must be provided,a filter without any criteria is
	//     not allowed.
	//   - If no filtering is required, this parameter does not need to be provided. For
	//     example
	//     ,`"filter":{"roamingStatus": ["roaming"],"deviceType": ["human device","IoT device"]}`
	//     means the API need to return the count of human network devices and IoT
	//     devices that are in roaming mode.`"filter":{"roamingStatus": ["non-roaming"]}`
	//     means that the API need to return the count of all devices that are not in
	//     roaming mode.
	Filter RegiondevicecountGetCountParamsFilter `json:"filter,omitzero"`
	// A sink credential provides authentication or authorization information necessary
	// to enable delivery of events to a target.
	SinkCredential RegiondevicecountGetCountParamsSinkCredential `json:"sinkCredential,omitzero"`
	// contains filtered or unexported fields
}

func (RegiondevicecountGetCountParams) MarshalJSON 

func (r RegiondevicecountGetCountParams) MarshalJSON() (data []byte, err error)

func (*RegiondevicecountGetCountParams) UnmarshalJSON 

func (r *RegiondevicecountGetCountParams) UnmarshalJSON(data []byte) error

type RegiondevicecountGetCountParamsArea 

type RegiondevicecountGetCountParamsArea struct {
	// Type of this area. CIRCLE - The area is defined as a circle. POLYGON - The area
	// is defined as a polygon.
	//
	// Any of "CIRCLE", "POLYGON".
	AreaType string `json:"areaType,omitzero" api:"required"`
	// contains filtered or unexported fields
}

The property AreaType is required.

func (RegiondevicecountGetCountParamsArea) MarshalJSON 

func (r RegiondevicecountGetCountParamsArea) MarshalJSON() (data []byte, err error)

func (*RegiondevicecountGetCountParamsArea) UnmarshalJSON 

func (r *RegiondevicecountGetCountParamsArea) UnmarshalJSON(data []byte) error

type RegiondevicecountGetCountParamsFilter 

type RegiondevicecountGetCountParamsFilter struct {
	// Filtering by device type, 'human device' represents the need to filter for human
	// network devices, 'IoT device' represents the need to filter for IoT devices, and
	// 'other' represents the need to filter for other types of devices.
	//
	// Any of "human device", "IoT device", "other".
	DeviceType []string `json:"deviceType,omitzero"`
	// Filter whether the device is in roaming mode,'roaming' represents the need to
	// filter devices that are in roaming mode,'non-roaming' represents the need to
	// filter devices that are not roaming.
	//
	// Any of "roaming", "non-roaming".
	RoamingStatus []string `json:"roamingStatus,omitzero"`
	// contains filtered or unexported fields
}

This parameter is used to filter devices. Currently, two filtering criteria are defined, `roamingStatus` and `deviceType`, which can be expanded in the future. `IN` logic is used used for multiple filtering items within a single filtering criterion, `AND` logic is used between multiple filtering criteria.

  • If a filtering critera is not provided, it means that there is no need to filter this item.
  • At least one of the criteria must be provided,a filter without any criteria is not allowed.
  • If no filtering is required, this parameter does not need to be provided. For example ,`"filter":{"roamingStatus": ["roaming"],"deviceType": ["human device","IoT device"]}` means the API need to return the count of human network devices and IoT devices that are in roaming mode.`"filter":{"roamingStatus": ["non-roaming"]}` means that the API need to return the count of all devices that are not in roaming mode.

func (RegiondevicecountGetCountParamsFilter) MarshalJSON 

func (r RegiondevicecountGetCountParamsFilter) MarshalJSON() (data []byte, err error)

func (*RegiondevicecountGetCountParamsFilter) UnmarshalJSON 

func (r *RegiondevicecountGetCountParamsFilter) UnmarshalJSON(data []byte) error

type RegiondevicecountGetCountParamsSinkCredential 

type RegiondevicecountGetCountParamsSinkCredential struct {
	// The type of the credential. Note: Type of the credential - MUST be set to
	// ACCESSTOKEN for now
	//
	// Any of "PLAIN", "ACCESSTOKEN", "REFRESHTOKEN".
	CredentialType string `json:"credentialType,omitzero" api:"required"`
	// contains filtered or unexported fields
}

A sink credential provides authentication or authorization information necessary to enable delivery of events to a target.

The property CredentialType is required.

func (RegiondevicecountGetCountParamsSinkCredential) MarshalJSON 

func (r RegiondevicecountGetCountParamsSinkCredential) MarshalJSON() (data []byte, err error)

func (*RegiondevicecountGetCountParamsSinkCredential) UnmarshalJSON 

func (r *RegiondevicecountGetCountParamsSinkCredential) UnmarshalJSON(data []byte) error

type RegiondevicecountGetCountResponse 

type RegiondevicecountGetCountResponse struct {
	// Device Count
	Count float64 `json:"count"`
	// SUPPORTED_AREA: The whole requested area is supported Region Device Count for
	// the entire requested area is returned - Telco Coverage = 100 %
	//
	// PART_OF_AREA_NOT_SUPPORTED: Part of the requested area is outside the MNOs
	// coverage area, the area outside the coverage area are not returned - 100% >Telco
	// Coverage >=50%
	//
	// AREA_NOT_SUPPORTED: The whole requested area is outside the MNO coverage area No
	// data will be returned- Telco Coverage <50%
	//
	// DENSITY_BELOW_PRIVACY_THRESHOLD: The number of connected devices is below
	// privacy threshold of local regulation
	//
	// TIME_INTERVAL_NO_DATA_FOUND: Unable to find device count data within the
	// requested time interval
	//
	// Any of "SUPPORTED_AREA", "PART_OF_AREA_NOT_SUPPORTED", "AREA_NOT_SUPPORTED",
	// "DENSITY_BELOW_PRIVACY_THRESHOLD", "TIME_INTERVAL_NO_DATA_FOUND".
	Status RegiondevicecountGetCountResponseStatus `json:"status"`
	// JSON contains metadata for fields, check presence with [respjson.Field.Valid].
	JSON struct {
		Count       respjson.Field
		Status      respjson.Field
		ExtraFields map[string]respjson.Field
		// contains filtered or unexported fields
	} `json:"-"`
}

RegionDeviceCount result

func (RegiondevicecountGetCountResponse) RawJSON 

func (r RegiondevicecountGetCountResponse) RawJSON() string

Returns the unmodified JSON received from the API

func (*RegiondevicecountGetCountResponse) UnmarshalJSON 

func (r *RegiondevicecountGetCountResponse) UnmarshalJSON(data []byte) error

type RegiondevicecountGetCountResponseStatus 

type RegiondevicecountGetCountResponseStatus string

SUPPORTED_AREA: The whole requested area is supported Region Device Count for the entire requested area is returned - Telco Coverage = 100 %

PART_OF_AREA_NOT_SUPPORTED: Part of the requested area is outside the MNOs coverage area, the area outside the coverage area are not returned - 100% >Telco Coverage >=50%

AREA_NOT_SUPPORTED: The whole requested area is outside the MNO coverage area No data will be returned- Telco Coverage <50%

DENSITY_BELOW_PRIVACY_THRESHOLD: The number of connected devices is below privacy threshold of local regulation

TIME_INTERVAL_NO_DATA_FOUND: Unable to find device count data within the requested time interval 

const (
	RegiondevicecountGetCountResponseStatusSupportedArea                RegiondevicecountGetCountResponseStatus = "SUPPORTED_AREA"
	RegiondevicecountGetCountResponseStatusPartOfAreaNotSupported       RegiondevicecountGetCountResponseStatus = "PART_OF_AREA_NOT_SUPPORTED"
	RegiondevicecountGetCountResponseStatusAreaNotSupported             RegiondevicecountGetCountResponseStatus = "AREA_NOT_SUPPORTED"
	RegiondevicecountGetCountResponseStatusDensityBelowPrivacyThreshold RegiondevicecountGetCountResponseStatus = "DENSITY_BELOW_PRIVACY_THRESHOLD"
	RegiondevicecountGetCountResponseStatusTimeIntervalNoDataFound      RegiondevicecountGetCountResponseStatus = "TIME_INTERVAL_NO_DATA_FOUND"
)

type RegiondevicecountService 

type RegiondevicecountService struct {
	Options []option.RequestOption
}

Region Device Count

RegiondevicecountService contains methods and other services that help with interacting with the camara API.

Note, unlike clients, this service does not read variables from the environment automatically. You should not instantiate this service directly, and instead use the NewRegiondevicecountService method instead.

func NewRegiondevicecountService 

func NewRegiondevicecountService(opts ...option.RequestOption) (r RegiondevicecountService)

NewRegiondevicecountService generates a new service that applies the given options to each request. These options are applied after the parent client's options (if there is one), and before any request-specific options.

func (*RegiondevicecountService) GetCount 

func (r *RegiondevicecountService) GetCount(ctx context.Context, params RegiondevicecountGetCountParams, opts ...option.RequestOption) (res *RegiondevicecountGetCountResponse, err error)

Get the number of devices in the specified area during a certain time interval.

  • The query area can be a circle or a polygon composed of longitude and latitude points.
  • If the areaType is circle, the circleCenter and circleRadius must be provided; if the area is a polygon, the point list must be provided.
  • If starttime and endtime are not passed in,this api should return the current number of devices in the area.
  • If the device appears in the specified area at least once during the certain time interval, it should be counted.

type SdpDescriptor 

type SdpDescriptor struct {
	// An inlined session description in SDP format [RFC4566].If XML syntax is used,
	// the content of this element SHALL be embedded in a CDATA section
	Sdp string `json:"sdp"`
	// JSON contains metadata for fields, check presence with [respjson.Field.Valid].
	JSON struct {
		Sdp         respjson.Field
		ExtraFields map[string]respjson.Field
		// contains filtered or unexported fields
	} `json:"-"`
}

**OFFER**: An inlined session description in SDP format [RFC4566].If XML syntax is used, the content of this element SHALL be embedded in a CDATA section.

**ANSWER**: This type represents an answer in WebRTC Signaling. This element is not present in case there is no answer yet, or the session invitation has been declined by the Terminating Participant.This element MUST NOT be present in a request from the application to the server to create a session.

func (SdpDescriptor) RawJSON 

func (r SdpDescriptor) RawJSON() string

Returns the unmodified JSON received from the API

func (SdpDescriptor) ToParam 

func (r SdpDescriptor) ToParam() SdpDescriptorParam

ToParam converts this SdpDescriptor to a SdpDescriptorParam.

Warning: the fields of the param type will not be present. ToParam should only be used at the last possible moment before sending a request. Test for this with SdpDescriptorParam.Overrides()

func (*SdpDescriptor) UnmarshalJSON 

func (r *SdpDescriptor) UnmarshalJSON(data []byte) error

type SdpDescriptorParam 

type SdpDescriptorParam struct {
	// An inlined session description in SDP format [RFC4566].If XML syntax is used,
	// the content of this element SHALL be embedded in a CDATA section
	Sdp param.Opt[string] `json:"sdp,omitzero"`
	// contains filtered or unexported fields
}

**OFFER**: An inlined session description in SDP format [RFC4566].If XML syntax is used, the content of this element SHALL be embedded in a CDATA section.

**ANSWER**: This type represents an answer in WebRTC Signaling. This element is not present in case there is no answer yet, or the session invitation has been declined by the Terminating Participant.This element MUST NOT be present in a request from the application to the server to create a session.

func (SdpDescriptorParam) MarshalJSON 

func (r SdpDescriptorParam) MarshalJSON() (data []byte, err error)

func (*SdpDescriptorParam) UnmarshalJSON 

func (r *SdpDescriptorParam) UnmarshalJSON(data []byte) error

type SimSwapConfig 

type SimSwapConfig struct {
	// The detail of the requested event subscription
	SubscriptionDetail SimSwapConfigSubscriptionDetail `json:"subscriptionDetail" api:"required"`
	// The subscription expiration time (in date-time format) requested by the API
	// consumer. It must follow
	// [RFC 3339](https://datatracker.ietf.org/doc/html/rfc3339#section-5.6) and must
	// have time zone.
	SubscriptionExpireTime time.Time `json:"subscriptionExpireTime" format:"date-time"`
	// Identifies the maximum number of event reports to be generated (>=1) requested
	// by the API consumer - Once this number is reached, the subscription ends.
	SubscriptionMaxEvents int64 `json:"subscriptionMaxEvents"`
	// JSON contains metadata for fields, check presence with [respjson.Field.Valid].
	JSON struct {
		SubscriptionDetail     respjson.Field
		SubscriptionExpireTime respjson.Field
		SubscriptionMaxEvents  respjson.Field
		ExtraFields            map[string]respjson.Field
		// contains filtered or unexported fields
	} `json:"-"`
}

Implementation-specific configuration parameters needed by the subscription manager for acquiring events. In CAMARA we have predefined attributes like `subscriptionExpireTime` or `subscriptionMaxEvents` to limit subscription lifetime. Event type attributes must be defined in `subscriptionDetail`

func (SimSwapConfig) RawJSON 

func (r SimSwapConfig) RawJSON() string

Returns the unmodified JSON received from the API

func (SimSwapConfig) ToParam 

func (r SimSwapConfig) ToParam() SimSwapConfigParam

ToParam converts this SimSwapConfig to a SimSwapConfigParam.

Warning: the fields of the param type will not be present. ToParam should only be used at the last possible moment before sending a request. Test for this with SimSwapConfigParam.Overrides()

func (*SimSwapConfig) UnmarshalJSON 

func (r *SimSwapConfig) UnmarshalJSON(data []byte) error

type SimSwapConfigParam 

type SimSwapConfigParam struct {
	// The detail of the requested event subscription
	SubscriptionDetail SimSwapConfigSubscriptionDetailParam `json:"subscriptionDetail,omitzero" api:"required"`
	// The subscription expiration time (in date-time format) requested by the API
	// consumer. It must follow
	// [RFC 3339](https://datatracker.ietf.org/doc/html/rfc3339#section-5.6) and must
	// have time zone.
	SubscriptionExpireTime param.Opt[time.Time] `json:"subscriptionExpireTime,omitzero" format:"date-time"`
	// Identifies the maximum number of event reports to be generated (>=1) requested
	// by the API consumer - Once this number is reached, the subscription ends.
	SubscriptionMaxEvents param.Opt[int64] `json:"subscriptionMaxEvents,omitzero"`
	// contains filtered or unexported fields
}

Implementation-specific configuration parameters needed by the subscription manager for acquiring events. In CAMARA we have predefined attributes like `subscriptionExpireTime` or `subscriptionMaxEvents` to limit subscription lifetime. Event type attributes must be defined in `subscriptionDetail`

The property SubscriptionDetail is required.

func (SimSwapConfigParam) MarshalJSON 

func (r SimSwapConfigParam) MarshalJSON() (data []byte, err error)

func (*SimSwapConfigParam) UnmarshalJSON 

func (r *SimSwapConfigParam) UnmarshalJSON(data []byte) error

type SimSwapConfigSubscriptionDetail 

type SimSwapConfigSubscriptionDetail struct {
	// A public identifier addressing a telephone subscription. In mobile networks it
	// corresponds to the MSISDN (Mobile Station International Subscriber Directory
	// Number). In order to be globally unique it has to be formatted in international
	// format, according to E.164 standard, prefixed with '+'.
	PhoneNumber string `json:"phoneNumber"`
	// JSON contains metadata for fields, check presence with [respjson.Field.Valid].
	JSON struct {
		PhoneNumber respjson.Field
		ExtraFields map[string]respjson.Field
		// contains filtered or unexported fields
	} `json:"-"`
}

The detail of the requested event subscription

func (SimSwapConfigSubscriptionDetail) RawJSON 

func (r SimSwapConfigSubscriptionDetail) RawJSON() string

Returns the unmodified JSON received from the API

func (*SimSwapConfigSubscriptionDetail) UnmarshalJSON 

func (r *SimSwapConfigSubscriptionDetail) UnmarshalJSON(data []byte) error

type SimSwapConfigSubscriptionDetailParam 

type SimSwapConfigSubscriptionDetailParam struct {
	// A public identifier addressing a telephone subscription. In mobile networks it
	// corresponds to the MSISDN (Mobile Station International Subscriber Directory
	// Number). In order to be globally unique it has to be formatted in international
	// format, according to E.164 standard, prefixed with '+'.
	PhoneNumber param.Opt[string] `json:"phoneNumber,omitzero"`
	// contains filtered or unexported fields
}

The detail of the requested event subscription

func (SimSwapConfigSubscriptionDetailParam) MarshalJSON 

func (r SimSwapConfigSubscriptionDetailParam) MarshalJSON() (data []byte, err error)

func (*SimSwapConfigSubscriptionDetailParam) UnmarshalJSON 

func (r *SimSwapConfigSubscriptionDetailParam) UnmarshalJSON(data []byte) error

type SimSwapProtocol 

type SimSwapProtocol string

Identifier of a delivery protocol. Only HTTP is allowed for now 

const (
	SimSwapProtocolHTTP  SimSwapProtocol = "HTTP"
	SimSwapProtocolMqtt3 SimSwapProtocol = "MQTT3"
	SimSwapProtocolMqtt5 SimSwapProtocol = "MQTT5"
	SimSwapProtocolAmqp  SimSwapProtocol = "AMQP"
	SimSwapProtocolNats  SimSwapProtocol = "NATS"
	SimSwapProtocolKafka SimSwapProtocol = "KAFKA"
)

type SimSwapSubscription 

type SimSwapSubscription struct {
	// The unique identifier of the subscription in the scope of the subscription
	// manager. When this information is contained within an event notification, this
	// concept SHALL be referred as subscriptionId as per Commonalities Event
	// Notification Model.
	ID string `json:"id" api:"required"`
	// Implementation-specific configuration parameters needed by the subscription
	// manager for acquiring events. In CAMARA we have predefined attributes like
	// `subscriptionExpireTime` or `subscriptionMaxEvents` to limit subscription
	// lifetime. Event type attributes must be defined in `subscriptionDetail`
	Config SimSwapConfig `json:"config" api:"required"`
	// Identifier of a delivery protocol. Only HTTP is allowed for now
	//
	// Any of "HTTP", "MQTT3", "MQTT5", "AMQP", "NATS", "KAFKA".
	Protocol SimSwapProtocol `json:"protocol" api:"required"`
	// The address to which events shall be delivered using the selected protocol.
	Sink string `json:"sink" api:"required" format:"uri"`
	// Camara Event types eligible for subscription:
	//
	//   - org.camaraproject.sim-swap-subscriptions.v0.swapped: receive a notification
	//     when a sim swap is performed on the line. Note: for the Commonalities
	//     meta-release v0.4 we enforce to have only event type per subscription then for
	//     following meta-release use of array MUST be decided at API project level.
	Types []SimSwapSubscriptionEventType `json:"types" api:"required"`
	// Date when the event subscription will expire. Only provided when
	// `subscriptionExpireTime` is indicated by API client or Telco Operator has
	// specific policy about that. It must follow
	// [RFC 3339](https://datatracker.ietf.org/doc/html/rfc3339#section-5.6) and must
	// have time zone.
	ExpiresAt time.Time `json:"expiresAt" format:"date-time"`
	// Date when the event subscription will begin/began It must follow
	// [RFC 3339](https://datatracker.ietf.org/doc/html/rfc3339#section-5.6) and must
	// have time zone.
	StartsAt time.Time `json:"startsAt" format:"date-time"`
	// Current status of the subscription - Management of Subscription State engine is
	// not mandatory for now. Note not all statuses may be considered to be
	// implemented. Details:
	//
	//   - `ACTIVATION_REQUESTED`: Subscription creation (POST) is triggered but
	//     subscription creation process is not finished yet.
	//   - `ACTIVE`: Subscription creation process is completed. Subscription is fully
	//     operative.
	//   - `INACTIVE`: Subscription is temporarily inactive, but its workflow logic is
	//     not deleted.
	//   - `EXPIRED`: Subscription is ended (no longer active). This status applies when
	//     subscription is ended due to `SUBSCRIPTION_EXPIRED` event.
	//   - `DELETED`: Subscription is ended as deleted (no longer active). This status
	//     applies when subscription information is kept (i.e. subscription workflow is
	//     no longer active but its metainformation is kept).
	//
	// Any of "ACTIVATION_REQUESTED", "ACTIVE", "EXPIRED", "INACTIVE", "DELETED".
	Status SimSwapSubscriptionStatus `json:"status"`
	// JSON contains metadata for fields, check presence with [respjson.Field.Valid].
	JSON struct {
		ID          respjson.Field
		Config      respjson.Field
		Protocol    respjson.Field
		Sink        respjson.Field
		Types       respjson.Field
		ExpiresAt   respjson.Field
		StartsAt    respjson.Field
		Status      respjson.Field
		ExtraFields map[string]respjson.Field
		// contains filtered or unexported fields
	} `json:"-"`
}

Represents a event-type subscription.

func (SimSwapSubscription) RawJSON 

func (r SimSwapSubscription) RawJSON() string

Returns the unmodified JSON received from the API

func (*SimSwapSubscription) UnmarshalJSON 

func (r *SimSwapSubscription) UnmarshalJSON(data []byte) error

type SimSwapSubscriptionEventType 

type SimSwapSubscriptionEventType string

swapped - Event triggered when a sim swap occurs on the line 

const (
	SimSwapSubscriptionEventTypeOrgCamaraprojectSimSwapSubscriptionsV0Swapped SimSwapSubscriptionEventType = "org.camaraproject.sim-swap-subscriptions.v0.swapped"
)

type SimSwapSubscriptionStatus 

type SimSwapSubscriptionStatus string

Current status of the subscription - Management of Subscription State engine is not mandatory for now. Note not all statuses may be considered to be implemented. Details:

  • `ACTIVATION_REQUESTED`: Subscription creation (POST) is triggered but subscription creation process is not finished yet.
  • `ACTIVE`: Subscription creation process is completed. Subscription is fully operative.
  • `INACTIVE`: Subscription is temporarily inactive, but its workflow logic is not deleted.
  • `EXPIRED`: Subscription is ended (no longer active). This status applies when subscription is ended due to `SUBSCRIPTION_EXPIRED` event.
  • `DELETED`: Subscription is ended as deleted (no longer active). This status applies when subscription information is kept (i.e. subscription workflow is no longer active but its metainformation is kept).
const (
	SimSwapSubscriptionStatusActivationRequested SimSwapSubscriptionStatus = "ACTIVATION_REQUESTED"
	SimSwapSubscriptionStatusActive              SimSwapSubscriptionStatus = "ACTIVE"
	SimSwapSubscriptionStatusExpired             SimSwapSubscriptionStatus = "EXPIRED"
	SimSwapSubscriptionStatusInactive            SimSwapSubscriptionStatus = "INACTIVE"
	SimSwapSubscriptionStatusDeleted             SimSwapSubscriptionStatus = "DELETED"
)

type SimswapService 

type SimswapService struct {
	Options []option.RequestOption
	// Sim Swap Subscriptions
	Subscriptions SimswapSubscriptionService
}

SimswapService contains methods and other services that help with interacting with the camara API.

Note, unlike clients, this service does not read variables from the environment automatically. You should not instantiate this service directly, and instead use the NewSimswapService method instead.

func NewSimswapService 

func NewSimswapService(opts ...option.RequestOption) (r SimswapService)

NewSimswapService generates a new service that applies the given options to each request. These options are applied after the parent client's options (if there is one), and before any request-specific options.

type SimswapSubscriptionDeleteParams 

type SimswapSubscriptionDeleteParams struct {
	XCorrelator param.Opt[string] `header:"x-correlator,omitzero" json:"-"`
	// contains filtered or unexported fields
}

type SimswapSubscriptionDeleteResponse 

type SimswapSubscriptionDeleteResponse struct {
	// The unique identifier of the subscription in the scope of the subscription
	// manager. When this information is contained within an event notification, this
	// concept SHALL be referred as subscriptionId as per Commonalities Event
	// Notification Model.
	ID string `json:"id"`
	// JSON contains metadata for fields, check presence with [respjson.Field.Valid].
	JSON struct {
		ID          respjson.Field
		ExtraFields map[string]respjson.Field
		// contains filtered or unexported fields
	} `json:"-"`
}

Response for a event-type subscription request managed asynchronously (Creation or Deletion)

func (SimswapSubscriptionDeleteResponse) RawJSON 

func (r SimswapSubscriptionDeleteResponse) RawJSON() string

Returns the unmodified JSON received from the API

func (*SimswapSubscriptionDeleteResponse) UnmarshalJSON 

func (r *SimswapSubscriptionDeleteResponse) UnmarshalJSON(data []byte) error

type SimswapSubscriptionGetParams 

type SimswapSubscriptionGetParams struct {
	XCorrelator param.Opt[string] `header:"x-correlator,omitzero" json:"-"`
	// contains filtered or unexported fields
}

type SimswapSubscriptionListParams 

type SimswapSubscriptionListParams struct {
	XCorrelator param.Opt[string] `header:"x-correlator,omitzero" json:"-"`
	// contains filtered or unexported fields
}

type SimswapSubscriptionNewParams 

type SimswapSubscriptionNewParams struct {
	// Implementation-specific configuration parameters needed by the subscription
	// manager for acquiring events. In CAMARA we have predefined attributes like
	// `subscriptionExpireTime` or `subscriptionMaxEvents` to limit subscription
	// lifetime. Event type attributes must be defined in `subscriptionDetail`
	Config SimSwapConfigParam `json:"config,omitzero" api:"required"`
	// Identifier of a delivery protocol. Only HTTP is allowed for now
	//
	// Any of "HTTP", "MQTT3", "MQTT5", "AMQP", "NATS", "KAFKA".
	Protocol SimSwapProtocol `json:"protocol,omitzero" api:"required"`
	// The address to which events shall be delivered using the selected protocol.
	Sink string `json:"sink" api:"required" format:"uri"`
	// Camara Event types eligible for subscription:
	//
	//   - org.camaraproject.sim-swap-subscriptions.v0.swapped: receive a notification
	//     when a sim swap is performed on the line.
	Types       []SimSwapSubscriptionEventType `json:"types,omitzero" api:"required"`
	XCorrelator param.Opt[string]              `header:"x-correlator,omitzero" json:"-"`
	// A sink credential provides authentication or authorization information necessary
	// to enable delivery of events to a target.
	SinkCredential SimswapSubscriptionNewParamsSinkCredential `json:"sinkCredential,omitzero"`
	// contains filtered or unexported fields
}

func (SimswapSubscriptionNewParams) MarshalJSON 

func (r SimswapSubscriptionNewParams) MarshalJSON() (data []byte, err error)

func (*SimswapSubscriptionNewParams) UnmarshalJSON 

func (r *SimswapSubscriptionNewParams) UnmarshalJSON(data []byte) error

type SimswapSubscriptionNewParamsSinkCredential 

type SimswapSubscriptionNewParamsSinkCredential struct {
	// The type of the credential. With the current API version the type MUST be set to
	// ACCESSTOKEN.
	//
	// Any of "PLAIN", "ACCESSTOKEN", "REFRESHTOKEN".
	CredentialType string `json:"credentialType,omitzero" api:"required"`
	// contains filtered or unexported fields
}

A sink credential provides authentication or authorization information necessary to enable delivery of events to a target.

The property CredentialType is required.

func (SimswapSubscriptionNewParamsSinkCredential) MarshalJSON 

func (r SimswapSubscriptionNewParamsSinkCredential) MarshalJSON() (data []byte, err error)

func (*SimswapSubscriptionNewParamsSinkCredential) UnmarshalJSON 

func (r *SimswapSubscriptionNewParamsSinkCredential) UnmarshalJSON(data []byte) error

type SimswapSubscriptionService 

type SimswapSubscriptionService struct {
	Options []option.RequestOption
}

Sim Swap Subscriptions

SimswapSubscriptionService contains methods and other services that help with interacting with the camara API.

Note, unlike clients, this service does not read variables from the environment automatically. You should not instantiate this service directly, and instead use the NewSimswapSubscriptionService method instead.

func NewSimswapSubscriptionService 

func NewSimswapSubscriptionService(opts ...option.RequestOption) (r SimswapSubscriptionService)

NewSimswapSubscriptionService generates a new service that applies the given options to each request. These options are applied after the parent client's options (if there is one), and before any request-specific options.

func (*SimswapSubscriptionService) Delete 

func (r *SimswapSubscriptionService) Delete(ctx context.Context, subscriptionID string, body SimswapSubscriptionDeleteParams, opts ...option.RequestOption) (res *SimswapSubscriptionDeleteResponse, err error)

delete a given event subscription.

func (*SimswapSubscriptionService) Get 

func (r *SimswapSubscriptionService) Get(ctx context.Context, subscriptionID string, query SimswapSubscriptionGetParams, opts ...option.RequestOption) (res *SimSwapSubscription, err error)

retrieve event subscription information for a given subscription.

func (*SimswapSubscriptionService) List 

func (r *SimswapSubscriptionService) List(ctx context.Context, query SimswapSubscriptionListParams, opts ...option.RequestOption) (res *[]SimSwapSubscription, err error)

Retrieve a list of sim swap event subscription(s)

func (*SimswapSubscriptionService) New 

func (r *SimswapSubscriptionService) New(ctx context.Context, params SimswapSubscriptionNewParams, opts ...option.RequestOption) (res *SimSwapSubscription, err error)

Create a sim swap event subscription for a phone number

type Subscription 

type Subscription struct {
	// Implementation-specific configuration parameters needed by the subscription
	// manager for acquiring events. In CAMARA we have predefined attributes like
	// `subscriptionExpireTime`, `subscriptionMaxEvents`, `initialEvent` Specific event
	// type attributes must be defined in `subscriptionDetail` Note: if a request is
	// performed for several event type, all subscribed event will use same `config`
	// parameters.
	Config Config `json:"config" api:"required"`
	// Identifier of a delivery protocol. Only HTTP is allowed for now
	//
	// Any of "HTTP", "MQTT3", "MQTT5", "AMQP", "NATS", "KAFKA".
	Protocol Protocol `json:"protocol" api:"required"`
	// The address to which events shall be delivered using the selected protocol.
	Sink string `json:"sink" api:"required" format:"uri"`
	// Date when the event subscription will begin/began It must follow
	// [RFC 3339](https://datatracker.ietf.org/doc/html/rfc3339#section-5.6) and must
	// have time zone.
	StartsAt time.Time `json:"startsAt" api:"required" format:"date-time"`
	// Camara Event types eligible to be delivered by this subscription.
	Types []EventType `json:"types" api:"required"`
	// Date when the event subscription will expire. Only provided when
	// `subscriptionExpireTime` is indicated by API client or Telco Operator has
	// specific policy about that. It must follow
	// [RFC 3339](https://datatracker.ietf.org/doc/html/rfc3339#section-5.6) and must
	// have time zone.
	ExpiresAt time.Time `json:"expiresAt" format:"date-time"`
	// Current status of the subscription - Management of Subscription State engine is
	// not mandatory for now. Note not all statuses may be considered to be
	// implemented. Details:
	//
	//   - `ACTIVATION_REQUESTED`: Subscription creation (POST) is triggered but
	//     subscription creation process is not finished yet.
	//   - `ACTIVE`: Subscription creation process is completed. Subscription is fully
	//     operative.
	//   - `DEACTIVE`: Subscription is temporarily inactive, but its workflow logic is
	//     not deleted.
	//   - `EXPIRED`: Subscription is ended (no longer active). This status applies when
	//     subscription is ended due to `SUBSCRIPTION_EXPIRED` or `ACCESS_TOKEN_EXPIRED`
	//     event.
	//   - `DELETED`: Subscription is ended as deleted (no longer active). This status
	//     applies when subscription information is kept (i.e. subscription workflow is
	//     no longer active but its metainformation is kept).
	//
	// Any of "ACTIVATION_REQUESTED", "ACTIVE", "EXPIRED", "DEACTIVE", "DELETED".
	Status SubscriptionStatus `json:"status"`
	// When this information is contained within an event notification, it SHALL be
	// referred to as `subscriptionId` as per the Commonalities Event Notification
	// Model.
	SubscriptionID string `json:"subscriptionId"`
	// JSON contains metadata for fields, check presence with [respjson.Field.Valid].
	JSON struct {
		Config         respjson.Field
		Protocol       respjson.Field
		Sink           respjson.Field
		StartsAt       respjson.Field
		Types          respjson.Field
		ExpiresAt      respjson.Field
		Status         respjson.Field
		SubscriptionID respjson.Field
		ExtraFields    map[string]respjson.Field
		// contains filtered or unexported fields
	} `json:"-"`
}

Represents a event-type subscription.

func (Subscription) RawJSON 

func (r Subscription) RawJSON() string

Returns the unmodified JSON received from the API

func (*Subscription) UnmarshalJSON 

func (r *Subscription) UnmarshalJSON(data []byte) error

type SubscriptionStatus 

type SubscriptionStatus string

Current status of the subscription - Management of Subscription State engine is not mandatory for now. Note not all statuses may be considered to be implemented. Details:

  • `ACTIVATION_REQUESTED`: Subscription creation (POST) is triggered but subscription creation process is not finished yet.
  • `ACTIVE`: Subscription creation process is completed. Subscription is fully operative.
  • `DEACTIVE`: Subscription is temporarily inactive, but its workflow logic is not deleted.
  • `EXPIRED`: Subscription is ended (no longer active). This status applies when subscription is ended due to `SUBSCRIPTION_EXPIRED` or `ACCESS_TOKEN_EXPIRED` event.
  • `DELETED`: Subscription is ended as deleted (no longer active). This status applies when subscription information is kept (i.e. subscription workflow is no longer active but its metainformation is kept).
const (
	SubscriptionStatusActivationRequested SubscriptionStatus = "ACTIVATION_REQUESTED"
	SubscriptionStatusActive              SubscriptionStatus = "ACTIVE"
	SubscriptionStatusExpired             SubscriptionStatus = "EXPIRED"
	SubscriptionStatusDeactive            SubscriptionStatus = "DEACTIVE"
	SubscriptionStatusDeleted             SubscriptionStatus = "DELETED"
)

type TenureService 

type TenureService struct {
	Options []option.RequestOption
}

KYC Tenure

TenureService contains methods and other services that help with interacting with the camara API.

Note, unlike clients, this service does not read variables from the environment automatically. You should not instantiate this service directly, and instead use the NewTenureService method instead.

func NewTenureService 

func NewTenureService(opts ...option.RequestOption) (r TenureService)

NewTenureService generates a new service that applies the given options to each request. These options are applied after the parent client's options (if there is one), and before any request-specific options.

func (*TenureService) Verify 

func (r *TenureService) Verify(ctx context.Context, params TenureVerifyParams, opts ...option.RequestOption) (res *TenureVerifyResponse, err error)

Verifies a specified length of tenure, based on a provided date, for a network subscriber to establish a level of trust for the network subscription identifier.

type TenureVerifyParams 

type TenureVerifyParams struct {
	// The date, in RFC 3339 / ISO 8601 compliant format "YYYY-MM-DD", from which
	// continuous tenure of the identified network subscriber is required to be
	// confirmed
	TenureDate time.Time `json:"tenureDate" api:"required" format:"date"`
	// A public identifier addressing a telephone subscription. In mobile networks it
	// corresponds to the MSISDN (Mobile Station International Subscriber Directory
	// Number). In order to be globally unique it has to be formatted in international
	// format, according to E.164 standard, prefixed with '+'.
	PhoneNumber param.Opt[string] `json:"phoneNumber,omitzero"`
	XCorrelator param.Opt[string] `header:"x-correlator,omitzero" json:"-"`
	// contains filtered or unexported fields
}

func (TenureVerifyParams) MarshalJSON 

func (r TenureVerifyParams) MarshalJSON() (data []byte, err error)

func (*TenureVerifyParams) UnmarshalJSON 

func (r *TenureVerifyParams) UnmarshalJSON(data []byte) error

type TenureVerifyResponse 

type TenureVerifyResponse struct {
	// `true` when the identified mobile subscription has had valid tenure since
	// `tenureDate`, otherwise `false`
	TenureDateCheck bool `json:"tenureDateCheck" api:"required"`
	// If exists, populated with:
	//
	// - `PAYG` - prepaid (pay-as-you-go) account
	// - `PAYM` - contract account
	// - `Business` - Business (enterprise) account
	//
	// This attribute may be omitted from the response set if the information is not
	// available
	//
	// Any of "PAYG", "PAYM", "Business".
	ContractType TenureVerifyResponseContractType `json:"contractType"`
	// JSON contains metadata for fields, check presence with [respjson.Field.Valid].
	JSON struct {
		TenureDateCheck respjson.Field
		ContractType    respjson.Field
		ExtraFields     map[string]respjson.Field
		// contains filtered or unexported fields
	} `json:"-"`
}

func (TenureVerifyResponse) RawJSON 

func (r TenureVerifyResponse) RawJSON() string

Returns the unmodified JSON received from the API

func (*TenureVerifyResponse) UnmarshalJSON 

func (r *TenureVerifyResponse) UnmarshalJSON(data []byte) error

type TenureVerifyResponseContractType 

type TenureVerifyResponseContractType string

If exists, populated with:

- `PAYG` - prepaid (pay-as-you-go) account - `PAYM` - contract account - `Business` - Business (enterprise) account

This attribute may be omitted from the response set if the information is not available 

const (
	TenureVerifyResponseContractTypePayg     TenureVerifyResponseContractType = "PAYG"
	TenureVerifyResponseContractTypePaym     TenureVerifyResponseContractType = "PAYM"
	TenureVerifyResponseContractTypeBusiness TenureVerifyResponseContractType = "Business"
)

type WebRtcCircleCoordinates 

type WebRtcCircleCoordinates struct {
	// Latitude of the center point in decimal degrees (WGS84).
	Latitude float64 `json:"latitude" api:"required"`
	// Longitude of the center point in decimal degrees (WGS84).
	Longitude float64 `json:"longitude" api:"required"`
	// Radius of the circle in meters, indicating the uncertainty.
	Radius float64 `json:"radius" api:"required"`
	// JSON contains metadata for fields, check presence with [respjson.Field.Valid].
	JSON struct {
		Latitude    respjson.Field
		Longitude   respjson.Field
		Radius      respjson.Field
		ExtraFields map[string]respjson.Field
		// contains filtered or unexported fields
	} `json:"-"`
}

func (WebRtcCircleCoordinates) RawJSON 

func (r WebRtcCircleCoordinates) RawJSON() string

Returns the unmodified JSON received from the API

func (WebRtcCircleCoordinates) ToParam 

func (r WebRtcCircleCoordinates) ToParam() WebRtcCircleCoordinatesParam

ToParam converts this WebRtcCircleCoordinates to a WebRtcCircleCoordinatesParam.

Warning: the fields of the param type will not be present. ToParam should only be used at the last possible moment before sending a request. Test for this with WebRtcCircleCoordinatesParam.Overrides()

func (*WebRtcCircleCoordinates) UnmarshalJSON 

func (r *WebRtcCircleCoordinates) UnmarshalJSON(data []byte) error

type WebRtcCircleCoordinatesParam 

type WebRtcCircleCoordinatesParam struct {
	// Latitude of the center point in decimal degrees (WGS84).
	Latitude float64 `json:"latitude" api:"required"`
	// Longitude of the center point in decimal degrees (WGS84).
	Longitude float64 `json:"longitude" api:"required"`
	// Radius of the circle in meters, indicating the uncertainty.
	Radius float64 `json:"radius" api:"required"`
	// contains filtered or unexported fields
}

The properties Latitude, Longitude, Radius are required.

func (WebRtcCircleCoordinatesParam) MarshalJSON 

func (r WebRtcCircleCoordinatesParam) MarshalJSON() (data []byte, err error)

func (*WebRtcCircleCoordinatesParam) UnmarshalJSON 

func (r *WebRtcCircleCoordinatesParam) UnmarshalJSON(data []byte) error

type WebRtcEllipsoidCoordinates 

type WebRtcEllipsoidCoordinates struct {
	// Latitude in the WGS 84 geocentric coordinate system.
	Latitude float64 `json:"latitude" api:"required"`
	// Longitude in the WGS 84 geocentric coordinate system.
	Longitude float64 `json:"longitude" api:"required"`
	// Orientation of the ellipsoid in degrees.
	Orientation float64 `json:"orientation" api:"required"`
	// Length of the semi-major axis of the ellipsoid in meters.
	SemiMajorAxis float64 `json:"semiMajorAxis" api:"required"`
	// Length of the semi-minor axis of the ellipsoid in meters.
	SemiMinorAxis float64 `json:"semiMinorAxis" api:"required"`
	// Length of the vertical axis of the ellipsoid in meters.
	VerticalAxis float64 `json:"verticalAxis" api:"required"`
	// Altitude (optional) in the WGS 84 geocentric coordinate system.
	ZAxis float64 `json:"zAxis" api:"required"`
	// JSON contains metadata for fields, check presence with [respjson.Field.Valid].
	JSON struct {
		Latitude      respjson.Field
		Longitude     respjson.Field
		Orientation   respjson.Field
		SemiMajorAxis respjson.Field
		SemiMinorAxis respjson.Field
		VerticalAxis  respjson.Field
		ZAxis         respjson.Field
		ExtraFields   map[string]respjson.Field
		// contains filtered or unexported fields
	} `json:"-"`
}

func (WebRtcEllipsoidCoordinates) RawJSON 

func (r WebRtcEllipsoidCoordinates) RawJSON() string

Returns the unmodified JSON received from the API

func (WebRtcEllipsoidCoordinates) ToParam 

func (r WebRtcEllipsoidCoordinates) ToParam() WebRtcEllipsoidCoordinatesParam

ToParam converts this WebRtcEllipsoidCoordinates to a WebRtcEllipsoidCoordinatesParam.

Warning: the fields of the param type will not be present. ToParam should only be used at the last possible moment before sending a request. Test for this with WebRtcEllipsoidCoordinatesParam.Overrides()

func (*WebRtcEllipsoidCoordinates) UnmarshalJSON 

func (r *WebRtcEllipsoidCoordinates) UnmarshalJSON(data []byte) error

type WebRtcEllipsoidCoordinatesParam 

type WebRtcEllipsoidCoordinatesParam struct {
	// Latitude in the WGS 84 geocentric coordinate system.
	Latitude float64 `json:"latitude" api:"required"`
	// Longitude in the WGS 84 geocentric coordinate system.
	Longitude float64 `json:"longitude" api:"required"`
	// Orientation of the ellipsoid in degrees.
	Orientation float64 `json:"orientation" api:"required"`
	// Length of the semi-major axis of the ellipsoid in meters.
	SemiMajorAxis float64 `json:"semiMajorAxis" api:"required"`
	// Length of the semi-minor axis of the ellipsoid in meters.
	SemiMinorAxis float64 `json:"semiMinorAxis" api:"required"`
	// Length of the vertical axis of the ellipsoid in meters.
	VerticalAxis float64 `json:"verticalAxis" api:"required"`
	// Altitude (optional) in the WGS 84 geocentric coordinate system.
	ZAxis float64 `json:"zAxis" api:"required"`
	// contains filtered or unexported fields
}

The properties Latitude, Longitude, Orientation, SemiMajorAxis, SemiMinorAxis, VerticalAxis, ZAxis are required.

func (WebRtcEllipsoidCoordinatesParam) MarshalJSON 

func (r WebRtcEllipsoidCoordinatesParam) MarshalJSON() (data []byte, err error)

func (*WebRtcEllipsoidCoordinatesParam) UnmarshalJSON 

func (r *WebRtcEllipsoidCoordinatesParam) UnmarshalJSON(data []byte) error

type WebRtcLocationDetails 

type WebRtcLocationDetails struct {
	// The confidence level of the location information.
	Confidence WebRtcLocationDetailsConfidence `json:"confidence"`
	// The coordinates of the caller's location, specific to the chosen shape.
	Coordinates WebRtcLocationDetailsCoordinatesUnion `json:"coordinates"`
	// The method used to obtain the location information.
	//
	// - **GPS:** Global Positioning System (highly accurate)
	// - **DBH:** Device-Based Hybrid
	// - **DBH_HELO:** Device-Based Hybrid using Apple Hybridized Emergency Location
	// - **Other:** Other methods (e.g., landmarks, IP Based etc.)
	//
	// Any of "GPS", "DBH", "DBH_HELO", "Other".
	Method WebRtcLocationDetailsMethod `json:"method"`
	// The shape representing the caller's location (Circle or Ellipsoid).
	//
	// Any of "Circle", "Ellipsoid".
	Shape WebRtcLocationDetailsShape `json:"shape"`
	// The timestamp (in ISO 8601 format) indicating when the location information was
	// Calculated. \nThis is crucial for emergency services to assess the timeliness of
	// the data. if not provided current timestamp will be used by default"
	Timestamp time.Time `json:"timestamp" format:"date-time"`
	// JSON contains metadata for fields, check presence with [respjson.Field.Valid].
	JSON struct {
		Confidence  respjson.Field
		Coordinates respjson.Field
		Method      respjson.Field
		Shape       respjson.Field
		Timestamp   respjson.Field
		ExtraFields map[string]respjson.Field
		// contains filtered or unexported fields
	} `json:"-"`
}

Details about the caller's location and related information. This object adheres to 3GPP TS 24.229, RFC 4119, RFC 5139, and RFC 5491 for PIDF-LO compatibility.

func (WebRtcLocationDetails) RawJSON 

func (r WebRtcLocationDetails) RawJSON() string

Returns the unmodified JSON received from the API

func (WebRtcLocationDetails) ToParam 

func (r WebRtcLocationDetails) ToParam() WebRtcLocationDetailsParam

ToParam converts this WebRtcLocationDetails to a WebRtcLocationDetailsParam.

Warning: the fields of the param type will not be present. ToParam should only be used at the last possible moment before sending a request. Test for this with WebRtcLocationDetailsParam.Overrides()

func (*WebRtcLocationDetails) UnmarshalJSON 

func (r *WebRtcLocationDetails) UnmarshalJSON(data []byte) error

type WebRtcLocationDetailsConfidence 

type WebRtcLocationDetailsConfidence struct {
	// The probability density function (PDF) associated with the confidence value.
	//
	// Any of "normal", "uniform".
	Pdf string `json:"pdf"`
	// The confidence value (percentage).
	Value float64 `json:"value"`
	// JSON contains metadata for fields, check presence with [respjson.Field.Valid].
	JSON struct {
		Pdf         respjson.Field
		Value       respjson.Field
		ExtraFields map[string]respjson.Field
		// contains filtered or unexported fields
	} `json:"-"`
}

The confidence level of the location information.

func (WebRtcLocationDetailsConfidence) RawJSON 

func (r WebRtcLocationDetailsConfidence) RawJSON() string

Returns the unmodified JSON received from the API

func (*WebRtcLocationDetailsConfidence) UnmarshalJSON 

func (r *WebRtcLocationDetailsConfidence) UnmarshalJSON(data []byte) error

type WebRtcLocationDetailsConfidenceParam 

type WebRtcLocationDetailsConfidenceParam struct {
	// The confidence value (percentage).
	Value param.Opt[float64] `json:"value,omitzero"`
	// The probability density function (PDF) associated with the confidence value.
	//
	// Any of "normal", "uniform".
	Pdf string `json:"pdf,omitzero"`
	// contains filtered or unexported fields
}

The confidence level of the location information.

func (WebRtcLocationDetailsConfidenceParam) MarshalJSON 

func (r WebRtcLocationDetailsConfidenceParam) MarshalJSON() (data []byte, err error)

func (*WebRtcLocationDetailsConfidenceParam) UnmarshalJSON 

func (r *WebRtcLocationDetailsConfidenceParam) UnmarshalJSON(data []byte) error

type WebRtcLocationDetailsCoordinatesUnion 

type WebRtcLocationDetailsCoordinatesUnion struct {
	Latitude  float64 `json:"latitude"`
	Longitude float64 `json:"longitude"`
	// This field is from variant [WebRtcCircleCoordinates].
	Radius float64 `json:"radius"`
	// This field is from variant [WebRtcEllipsoidCoordinates].
	Orientation float64 `json:"orientation"`
	// This field is from variant [WebRtcEllipsoidCoordinates].
	SemiMajorAxis float64 `json:"semiMajorAxis"`
	// This field is from variant [WebRtcEllipsoidCoordinates].
	SemiMinorAxis float64 `json:"semiMinorAxis"`
	// This field is from variant [WebRtcEllipsoidCoordinates].
	VerticalAxis float64 `json:"verticalAxis"`
	// This field is from variant [WebRtcEllipsoidCoordinates].
	ZAxis float64 `json:"zAxis"`
	JSON  struct {
		Latitude      respjson.Field
		Longitude     respjson.Field
		Radius        respjson.Field
		Orientation   respjson.Field
		SemiMajorAxis respjson.Field
		SemiMinorAxis respjson.Field
		VerticalAxis  respjson.Field
		ZAxis         respjson.Field
		// contains filtered or unexported fields
	} `json:"-"`
}

WebRtcLocationDetailsCoordinatesUnion contains all possible properties and values from WebRtcCircleCoordinates, WebRtcEllipsoidCoordinates.

Use the methods beginning with 'As' to cast the union to one of its variants.

func (WebRtcLocationDetailsCoordinatesUnion) AsWebRtcCircleCoordinates 

func (u WebRtcLocationDetailsCoordinatesUnion) AsWebRtcCircleCoordinates() (v WebRtcCircleCoordinates)

func (WebRtcLocationDetailsCoordinatesUnion) AsWebRtcEllipsoidCoordinates 

func (u WebRtcLocationDetailsCoordinatesUnion) AsWebRtcEllipsoidCoordinates() (v WebRtcEllipsoidCoordinates)

func (WebRtcLocationDetailsCoordinatesUnion) RawJSON 

func (u WebRtcLocationDetailsCoordinatesUnion) RawJSON() string

Returns the unmodified JSON received from the API

func (*WebRtcLocationDetailsCoordinatesUnion) UnmarshalJSON 

func (r *WebRtcLocationDetailsCoordinatesUnion) UnmarshalJSON(data []byte) error

type WebRtcLocationDetailsCoordinatesUnionParam 

type WebRtcLocationDetailsCoordinatesUnionParam struct {
	OfWebRtcCircleCoordinates    *WebRtcCircleCoordinatesParam    `json:",omitzero,inline"`
	OfWebRtcEllipsoidCoordinates *WebRtcEllipsoidCoordinatesParam `json:",omitzero,inline"`
	// contains filtered or unexported fields
}

Only one field can be non-zero.

Use param.IsOmitted to confirm if a field is set.

func (WebRtcLocationDetailsCoordinatesUnionParam) GetLatitude 

func (u WebRtcLocationDetailsCoordinatesUnionParam) GetLatitude() *float64

Returns a pointer to the underlying variant's property, if present.

func (WebRtcLocationDetailsCoordinatesUnionParam) GetLongitude 

func (u WebRtcLocationDetailsCoordinatesUnionParam) GetLongitude() *float64

Returns a pointer to the underlying variant's property, if present.

func (WebRtcLocationDetailsCoordinatesUnionParam) GetOrientation 

func (u WebRtcLocationDetailsCoordinatesUnionParam) GetOrientation() *float64

Returns a pointer to the underlying variant's property, if present.

func (WebRtcLocationDetailsCoordinatesUnionParam) GetRadius 

func (u WebRtcLocationDetailsCoordinatesUnionParam) GetRadius() *float64

Returns a pointer to the underlying variant's property, if present.

func (WebRtcLocationDetailsCoordinatesUnionParam) GetSemiMajorAxis 

func (u WebRtcLocationDetailsCoordinatesUnionParam) GetSemiMajorAxis() *float64

Returns a pointer to the underlying variant's property, if present.

func (WebRtcLocationDetailsCoordinatesUnionParam) GetSemiMinorAxis 

func (u WebRtcLocationDetailsCoordinatesUnionParam) GetSemiMinorAxis() *float64

Returns a pointer to the underlying variant's property, if present.

func (WebRtcLocationDetailsCoordinatesUnionParam) GetVerticalAxis 

func (u WebRtcLocationDetailsCoordinatesUnionParam) GetVerticalAxis() *float64

Returns a pointer to the underlying variant's property, if present.

func (WebRtcLocationDetailsCoordinatesUnionParam) GetZAxis 

func (u WebRtcLocationDetailsCoordinatesUnionParam) GetZAxis() *float64

Returns a pointer to the underlying variant's property, if present.

func (WebRtcLocationDetailsCoordinatesUnionParam) MarshalJSON 

func (u WebRtcLocationDetailsCoordinatesUnionParam) MarshalJSON() ([]byte, error)

func (*WebRtcLocationDetailsCoordinatesUnionParam) UnmarshalJSON 

func (u *WebRtcLocationDetailsCoordinatesUnionParam) UnmarshalJSON(data []byte) error

type WebRtcLocationDetailsMethod 

type WebRtcLocationDetailsMethod string

The method used to obtain the location information.

- **GPS:** Global Positioning System (highly accurate) - **DBH:** Device-Based Hybrid - **DBH_HELO:** Device-Based Hybrid using Apple Hybridized Emergency Location - **Other:** Other methods (e.g., landmarks, IP Based etc.) 

const (
	WebRtcLocationDetailsMethodGps     WebRtcLocationDetailsMethod = "GPS"
	WebRtcLocationDetailsMethodDbh     WebRtcLocationDetailsMethod = "DBH"
	WebRtcLocationDetailsMethodDbhHelo WebRtcLocationDetailsMethod = "DBH_HELO"
	WebRtcLocationDetailsMethodOther   WebRtcLocationDetailsMethod = "Other"
)

type WebRtcLocationDetailsParam 

type WebRtcLocationDetailsParam struct {
	// The timestamp (in ISO 8601 format) indicating when the location information was
	// Calculated. \nThis is crucial for emergency services to assess the timeliness of
	// the data. if not provided current timestamp will be used by default"
	Timestamp param.Opt[time.Time] `json:"timestamp,omitzero" format:"date-time"`
	// The confidence level of the location information.
	Confidence WebRtcLocationDetailsConfidenceParam `json:"confidence,omitzero"`
	// The coordinates of the caller's location, specific to the chosen shape.
	Coordinates WebRtcLocationDetailsCoordinatesUnionParam `json:"coordinates,omitzero"`
	// The method used to obtain the location information.
	//
	// - **GPS:** Global Positioning System (highly accurate)
	// - **DBH:** Device-Based Hybrid
	// - **DBH_HELO:** Device-Based Hybrid using Apple Hybridized Emergency Location
	// - **Other:** Other methods (e.g., landmarks, IP Based etc.)
	//
	// Any of "GPS", "DBH", "DBH_HELO", "Other".
	Method WebRtcLocationDetailsMethod `json:"method,omitzero"`
	// The shape representing the caller's location (Circle or Ellipsoid).
	//
	// Any of "Circle", "Ellipsoid".
	Shape WebRtcLocationDetailsShape `json:"shape,omitzero"`
	// contains filtered or unexported fields
}

Details about the caller's location and related information. This object adheres to 3GPP TS 24.229, RFC 4119, RFC 5139, and RFC 5491 for PIDF-LO compatibility.

func (WebRtcLocationDetailsParam) MarshalJSON 

func (r WebRtcLocationDetailsParam) MarshalJSON() (data []byte, err error)

func (*WebRtcLocationDetailsParam) UnmarshalJSON 

func (r *WebRtcLocationDetailsParam) UnmarshalJSON(data []byte) error

type WebRtcLocationDetailsShape 

type WebRtcLocationDetailsShape string

The shape representing the caller's location (Circle or Ellipsoid). 

const (
	WebRtcLocationDetailsShapeCircle    WebRtcLocationDetailsShape = "Circle"
	WebRtcLocationDetailsShapeEllipsoid WebRtcLocationDetailsShape = "Ellipsoid"
)

type WebrtcService 

type WebrtcService struct {
	Options []option.RequestOption
	// WebRTC Call Handling
	Sessions WebrtcSessionService
}

WebrtcService contains methods and other services that help with interacting with the camara API.

Note, unlike clients, this service does not read variables from the environment automatically. You should not instantiate this service directly, and instead use the NewWebrtcService method instead.

func NewWebrtcService 

func NewWebrtcService(opts ...option.RequestOption) (r WebrtcService)

NewWebrtcService generates a new service that applies the given options to each request. These options are applied after the parent client's options (if there is one), and before any request-specific options.

type WebrtcSessionDeleteParams 

type WebrtcSessionDeleteParams struct {
	XCorrelator param.Opt[string] `header:"x-correlator,omitzero" json:"-"`
	// contains filtered or unexported fields
}

type WebrtcSessionGetParams 

type WebrtcSessionGetParams struct {
	XCorrelator param.Opt[string] `header:"x-correlator,omitzero" json:"-"`
	// contains filtered or unexported fields
}

type WebrtcSessionNewParams 

type WebrtcSessionNewParams struct {
	RegistrationID          string            `header:"registrationId" api:"required" json:"-"`
	XCorrelator             param.Opt[string] `header:"x-correlator,omitzero" json:"-"`
	MediaSessionInformation MediaSessionInformationParam
	// contains filtered or unexported fields
}

func (WebrtcSessionNewParams) MarshalJSON 

func (r WebrtcSessionNewParams) MarshalJSON() (data []byte, err error)

func (*WebrtcSessionNewParams) UnmarshalJSON 

func (r *WebrtcSessionNewParams) UnmarshalJSON(data []byte) error

type WebrtcSessionService 

type WebrtcSessionService struct {
	Options []option.RequestOption
}

WebRTC Call Handling

WebrtcSessionService contains methods and other services that help with interacting with the camara API.

Note, unlike clients, this service does not read variables from the environment automatically. You should not instantiate this service directly, and instead use the NewWebrtcSessionService method instead.

func NewWebrtcSessionService 

func NewWebrtcSessionService(opts ...option.RequestOption) (r WebrtcSessionService)

NewWebrtcSessionService generates a new service that applies the given options to each request. These options are applied after the parent client's options (if there is one), and before any request-specific options.

func (*WebrtcSessionService) Delete 

func (r *WebrtcSessionService) Delete(ctx context.Context, mediaSessionID string, body WebrtcSessionDeleteParams, opts ...option.RequestOption) (err error)

Cancel a 1-1 media session (as originator), Decline a 1-1 media session (as receiver), Terminate a 1-1 an ongoing media session ** The client shall construct the API path using the mediaSessionId supplied in the session creation response (origination) or in the invitation notification (termination). **'

func (*WebrtcSessionService) Get 

func (r *WebrtcSessionService) Get(ctx context.Context, mediaSessionID string, query WebrtcSessionGetParams, opts ...option.RequestOption) (res *MediaSessionInformation, err error)

Get the media Session description based on `mediaSessionId`.

** The client shall construct the API path using the `mediaSessionId` supplied in the session creation response (origination) or in the invitation notification (termination). **

func (*WebrtcSessionService) New 

func (r *WebrtcSessionService) New(ctx context.Context, params WebrtcSessionNewParams, opts ...option.RequestOption) (res *MediaSessionInformation, err error)

Creates a voice and/or video session

func (*WebrtcSessionService) UpdateStatus 

func (r *WebrtcSessionService) UpdateStatus(ctx context.Context, mediaSessionID string, params WebrtcSessionUpdateStatusParams, opts ...option.RequestOption) (res *MediaSessionInformation, err error)

Update the status of the media session, this may include updating SDP media

The API consumer shall construct the API path using the `mediaSessionId` supplied in the session creation response (origination) or in the invitation notification (termination).

type WebrtcSessionUpdateStatusParams 

type WebrtcSessionUpdateStatusParams struct {
	XCorrelator             param.Opt[string] `header:"x-correlator,omitzero" json:"-"`
	MediaSessionInformation MediaSessionInformationParam
	// contains filtered or unexported fields
}

func (WebrtcSessionUpdateStatusParams) MarshalJSON 

func (r WebrtcSessionUpdateStatusParams) MarshalJSON() (data []byte, err error)

func (*WebrtcSessionUpdateStatusParams) UnmarshalJSON 

func (r *WebrtcSessionUpdateStatusParams) UnmarshalJSON(data []byte) error

Source Files

View all Source files

Directories

Path Synopsis
apierror
apiform
apijson
apiquery
encoding/json
Package json implements encoding and decoding of JSON as defined in RFC 7159.
 Package json implements encoding and decoding of JSON as defined in RFC 7159.
encoding/json/sentinel
encoding/json/shims
This package provides shims over Go 1.2{2,3} APIs which are missing from Go 1.22, and used by the Go 1.24 encoding/json package.
 This package provides shims over Go 1.2{2,3} APIs which are missing from Go 1.22, and used by the Go 1.24 encoding/json package.
paramutil
requestconfig
testutil
packages
param
respjson
shared
constant

Jump to

Keyboard shortcuts

? : This menu
/ : Search site
f or F : Jump to
y or Y : Canonical URL
go.dev uses cookies from Google to deliver and enhance the quality of its services and to analyze traffic. Learn more.