API Reference

client.send(AddItemProperty(property_name, type,
    # optional parameters:
    role=<string / dict>,
    metadata=<array>
  )
)

client.send(AddItemProperty.new(propertyName, type, {
    # optional parameters:
    :role => <string / Hash>,
    :metadata => <array>
  })
)

client.send(new AddItemProperty(String propertyName, String type)
  .setRole(PropertyRole role)
  .setMetadata(PropertyMetadata[] metadata)
);

$client->send(new AddItemProperty($property_name, $type, [
    // optional parameters:
    'role' => <string / array (map)>,
    'metadata' => <array>
  ])
);

client.Send(AddItemProperty(string propertyName, string type,
    // optional parameters:
    role: <PropertyRole>,
    metadata: <PropertyMetadata[]>
  )
);

request := client.NewAddItemProperty(propertyName string, type string)    
    // optional parameters:
    .SetRole(role bindings.PropertyRole)
    .SetMetadata(metadata []bindings.PropertyMetadata)


_, err := request.Send()

PUT /{databaseId}/items/properties/{propertyName}
Body (application/json):
{
  "type" => <string>,
  "role" => <string / Object>,
  "metadata" => <array>
}

client.send(DeleteItemProperty(property_name))

client.send(DeleteItemProperty.new(propertyName))

client.send(new DeleteItemProperty(String propertyName));

$client->send(new DeleteItemProperty($property_name));

client.Send(DeleteItemProperty(string propertyName));

request := client.NewDeleteItemProperty(propertyName string)

_, err := request.Send()

DELETE /{databaseId}/items/properties/{propertyName}

result = client.send(GetItemPropertyInfo(property_name))

result = client.send(GetItemPropertyInfo.new(propertyName))

PropertyInfo result = client.send(new GetItemPropertyInfo(String propertyName));

$result = $client->send(new GetItemPropertyInfo($property_name));

PropertyInfo result = client.Send(GetItemPropertyInfo(string propertyName));

request := client.NewGetItemPropertyInfo(propertyName string)

result, err := request.Send() // result is of the type bindings.PropertyInfo

GET /{databaseId}/items/properties/{propertyName}

result = client.send(ListItemProperties())

result = client.send(ListItemProperties.new())

PropertyInfo[] result = client.send(new ListItemProperties());

$result = $client->send(new ListItemProperties());

IEnumerable<PropertyInfo> result = client.Send(ListItemProperties());

request := client.NewListItemProperties()

result, err := request.Send() // result is of the type []bindings.PropertyInfo

GET /{databaseId}/items/properties/list/

client.send(SetItemValues(item_id, values,
    # optional parameters:
    cascade_create=<boolean>
  )
)

client.send(SetItemValues.new(itemId, values, {
    # optional parameters:
    :cascade_create => <boolean>
  })
)

client.send(new SetItemValues(String itemId, Map<String, Object> values)
  .setCascadeCreate(boolean cascadeCreate)
);

$client->send(new SetItemValues($item_id, $values, [
    // optional parameters:
    'cascadeCreate' => <boolean>
  ])
);

client.Send(SetItemValues(string itemId, Dictionary<string, object> values,
    // optional parameters:
    cascadeCreate: <bool>
  )
);

request := client.NewSetItemValues(itemId string, values map[string]interface{})    
    // optional parameters:
    .SetCascadeCreate(cascadeCreate bool)


_, err := request.Send()

POST /{databaseId}/items/{itemId}

result = client.send(GetItemValues(item_id))

result = client.send(GetItemValues.new(itemId))

Map<String, Object> result = client.send(new GetItemValues(String itemId));

$result = $client->send(new GetItemValues($item_id));

Item result = client.Send(GetItemValues(string itemId));

request := client.NewGetItemValues(itemId string)

result, err := request.Send() // result is of the type map[string]interface{}

GET /{databaseId}/items/{itemId}

result = client.send(UpdateMoreItems(filter, changes))

result = client.send(UpdateMoreItems.new(filter, changes))

UpdateMoreItemsResponse result = client.send(new UpdateMoreItems(String filter, Map<String, Object> changes));

$result = $client->send(new UpdateMoreItems($filter, $changes));

UpdateMoreItemsResponse result = client.Send(UpdateMoreItems(string filter, Dictionary<string, object> changes));

request := client.NewUpdateMoreItems(filter string, changes map[string]interface{})

result, err := request.Send() // result is of the type bindings.UpdateMoreItemsResponse

POST /{databaseId}/more-items/
Body (application/json):
{
  "filter" => <string>,
  "changes" => <Object>
}

client.send(AddUserProperty(property_name, type,
    # optional parameters:
    role=<string / dict>,
    metadata=<array>
  )
)

client.send(AddUserProperty.new(propertyName, type, {
    # optional parameters:
    :role => <string / Hash>,
    :metadata => <array>
  })
)

client.send(new AddUserProperty(String propertyName, String type)
  .setRole(PropertyRole role)
  .setMetadata(PropertyMetadata[] metadata)
);

$client->send(new AddUserProperty($property_name, $type, [
    // optional parameters:
    'role' => <string / array (map)>,
    'metadata' => <array>
  ])
);

client.Send(AddUserProperty(string propertyName, string type,
    // optional parameters:
    role: <PropertyRole>,
    metadata: <PropertyMetadata[]>
  )
);

request := client.NewAddUserProperty(propertyName string, type string)    
    // optional parameters:
    .SetRole(role bindings.PropertyRole)
    .SetMetadata(metadata []bindings.PropertyMetadata)


_, err := request.Send()

PUT /{databaseId}/users/properties/{propertyName}
Body (application/json):
{
  "type" => <string>,
  "role" => <string / Object>,
  "metadata" => <array>
}

client.send(DeleteUserProperty(property_name))

client.send(DeleteUserProperty.new(propertyName))

client.send(new DeleteUserProperty(String propertyName));

$client->send(new DeleteUserProperty($property_name));

client.Send(DeleteUserProperty(string propertyName));

request := client.NewDeleteUserProperty(propertyName string)

_, err := request.Send()

DELETE /{databaseId}/users/properties/{propertyName}

result = client.send(GetUserPropertyInfo(property_name))

result = client.send(GetUserPropertyInfo.new(propertyName))

PropertyInfo result = client.send(new GetUserPropertyInfo(String propertyName));

$result = $client->send(new GetUserPropertyInfo($property_name));

PropertyInfo result = client.Send(GetUserPropertyInfo(string propertyName));

request := client.NewGetUserPropertyInfo(propertyName string)

result, err := request.Send() // result is of the type bindings.PropertyInfo

GET /{databaseId}/users/properties/{propertyName}

result = client.send(ListUserProperties())

result = client.send(ListUserProperties.new())

PropertyInfo[] result = client.send(new ListUserProperties());

$result = $client->send(new ListUserProperties());

IEnumerable<PropertyInfo> result = client.Send(ListUserProperties());

request := client.NewListUserProperties()

result, err := request.Send() // result is of the type []bindings.PropertyInfo

GET /{databaseId}/users/properties/list/

client.send(SetUserValues(user_id, values,
    # optional parameters:
    cascade_create=<boolean>
  )
)

client.send(SetUserValues.new(userId, values, {
    # optional parameters:
    :cascade_create => <boolean>
  })
)

client.send(new SetUserValues(String userId, Map<String, Object> values)
  .setCascadeCreate(boolean cascadeCreate)
);

$client->send(new SetUserValues($user_id, $values, [
    // optional parameters:
    'cascadeCreate' => <boolean>
  ])
);

client.Send(SetUserValues(string userId, Dictionary<string, object> values,
    // optional parameters:
    cascadeCreate: <bool>
  )
);

request := client.NewSetUserValues(userId string, values map[string]interface{})    
    // optional parameters:
    .SetCascadeCreate(cascadeCreate bool)


_, err := request.Send()

POST /{databaseId}/users/{userId}

result = client.send(GetUserValues(user_id))

result = client.send(GetUserValues.new(userId))

Map<String, Object> result = client.send(new GetUserValues(String userId));

$result = $client->send(new GetUserValues($user_id));

User result = client.Send(GetUserValues(string userId));

request := client.NewGetUserValues(userId string)

result, err := request.Send() // result is of the type map[string]interface{}

GET /{databaseId}/users/{userId}

client.send(AddDetailView(userId: String, itemId: String,
    // optional parameters:
    timestamp: Instant,
    duration: Long,
    cascadeCreate: Boolean,
    recommId: String,
    additionalData: Map<String, Any>,
    autoPresented: Boolean
  )
)

client.send(AddDetailView(userId: <String>, itemId: <String>,
    // optional parameters:
    timestamp: <Date?>,
    duration: <Int?>,
    cascadeCreate: <Bool?>,
    recommId: <String?>,
    additionalData: <[String: Any]?>,
    autoPresented: <Bool?>
  )
)

client.send(new requests.AddDetailView(userId, itemId, {
  // optional parameters:
  'timestamp': <string / number>,
  'duration': <integer>,
  'cascadeCreate': <boolean>,
  'recommId': <string>,
  'additionalData': <Object>,
  'autoPresented': <boolean>
}));

client.send(AddDetailView(user_id, item_id,
    # optional parameters:
    timestamp=<string / number>,
    duration=<integer>,
    cascade_create=<boolean>,
    recomm_id=<string>,
    additional_data=<dict>,
    auto_presented=<boolean>
  )
)

client.send(AddDetailView.new(userId, itemId, {
    # optional parameters:
    :timestamp => <string / number>,
    :duration => <integer>,
    :cascade_create => <boolean>,
    :recomm_id => <string>,
    :additional_data => <Hash>,
    :auto_presented => <boolean>
  })
)

client.send(new AddDetailView(String userId, String itemId)
  .setTimestamp(Date timestamp)
  .setDuration(long duration)
  .setCascadeCreate(boolean cascadeCreate)
  .setRecommId(String recommId)
  .setAdditionalData(Map<String, Object> additionalData)
  .setAutoPresented(boolean autoPresented)
);

$client->send(new AddDetailView($user_id, $item_id, [
    // optional parameters:
    'timestamp' => <string / number>,
    'duration' => <integer>,
    'cascadeCreate' => <boolean>,
    'recommId' => <string>,
    'additionalData' => <array (map)>,
    'autoPresented' => <boolean>
  ])
);

client.Send(AddDetailView(string userId, string itemId,
    // optional parameters:
    timestamp: <DateTime>,
    duration: <long>,
    cascadeCreate: <bool>,
    recommId: <string>,
    additionalData: <Dictionary<string, object>>,
    autoPresented: <bool>
  )
);

request := client.NewAddDetailView(userId string, itemId string)    
    // optional parameters:
    .SetTimestamp(timestamp time.Time)
    .SetDuration(duration int)
    .SetCascadeCreate(cascadeCreate bool)
    .SetRecommId(recommId string)
    .SetAdditionalData(additionalData map[string]interface{})
    .SetAutoPresented(autoPresented bool)


_, err := request.Send()

POST /{databaseId}/detailviews/
Body (application/json):
{
  "userId" => <string>,
  "itemId" => <string>,
  "timestamp" => <string / number>,
  "duration" => <integer>,
  "cascadeCreate" => <boolean>,
  "recommId" => <string>,
  "additionalData" => <Object>,
  "autoPresented" => <boolean>
}

client.send(DeleteDetailView(user_id, item_id,
    # optional parameters:
    timestamp=<number>
  )
)

client.send(DeleteDetailView.new(userId, itemId, {
    # optional parameters:
    :timestamp => <number>
  })
)

client.send(new DeleteDetailView(String userId, String itemId)
  .setTimestamp(Date timestamp)
);

$client->send(new DeleteDetailView($user_id, $item_id, [
    // optional parameters:
    'timestamp' => <number>
  ])
);

client.Send(DeleteDetailView(string userId, string itemId,
    // optional parameters:
    timestamp: <DateTime>
  )
);

request := client.NewDeleteDetailView(userId string, itemId string)    
    // optional parameters:
    .SetTimestamp(timestamp time.Time)


_, err := request.Send()

DELETE /{databaseId}/detailviews/?userId=<string>
&itemId=<string>
&timestamp=<number>

result = client.send(ListItemDetailViews(item_id))

result = client.send(ListItemDetailViews.new(itemId))

DetailView[] result = client.send(new ListItemDetailViews(String itemId));

$result = $client->send(new ListItemDetailViews($item_id));

IEnumerable<DetailView> result = client.Send(ListItemDetailViews(string itemId));

request := client.NewListItemDetailViews(itemId string)

result, err := request.Send() // result is of the type []bindings.DetailView

GET /{databaseId}/items/{itemId}/detailviews/

result = client.send(ListUserDetailViews(user_id))

result = client.send(ListUserDetailViews.new(userId))

DetailView[] result = client.send(new ListUserDetailViews(String userId));