mii/vrchatapi-rust
1
0
Fork 0
mirror of https://github.com/mii443/vrchatapi-rust.git synced 2025-08-22 15:45:35 +00:00
Code Issues Packages Projects Releases Wiki Activity

Apply Changes

Browse Source
This commit is contained in:
C0D3 M4513R
2024-08-11 18:22:20 +02:00
parent dfcd8ff73c
commit 15e93d80a2
116 changed files with 1881 additions and 814 deletions
Download Patch File Download Diff File Expand all files Collapse all files

4
Cargo.toml
View File

@ -7,7 +7,7 @@ license = "MIT"
edition = "2021"
[dependencies]
serde = { version = "^1.0", features = ["derive"] }
serde = {version = "^1.0", features = ["rc", "derive"] }
serde_with = { version = "^3.8", default-features = false, features = ["base64", "std", "macros"] }
serde_json = "^1.0"
url = "^2.5"
@ -16,3 +16,5 @@ reqwest = { version = "^0.12", features = ["json", "cookies", "multipart"] }
[dev-dependencies]
tokio = { version = '1', features = ['macros', 'rt-multi-thread'] }
[dependencies.log]
version = "0.4"

1
docs/UserExists.md
View File

@ -5,6 +5,7 @@
Name | Type | Description | Notes
------------ | ------------- | ------------- | -------------
**user_exists** | **bool** | Status if a user exist with that username or userId. | [default to false]
**name_ok** | **bool** | Is the username valid? | [default to false]
[[Back to Model list]](../README.md#documentation-for-models) [[Back to API list]](../README.md#documentation-for-api-endpoints) [[Back to README]](../README.md)

2
generate.sh
View File

@ -41,7 +41,7 @@ echo "pub mod tags;" >> src/models/mod.rs
sed -i 's/tags: Vec<String>/tags: Vec<crate::models::tags::Tags>/g' src/models/*.rs
#replace Strings with Arc<str> in tradeoff to Default impls
sed -Ei 's/(:[a-zA-Z0-9 \-_<>]*)String/\1std::sync::Arc<str>/g' src/models/*.rs
sed -Ei 's/serde = "(.*)"/serde = {version = "\1", features = ["rc"]}/g' Cargo.toml
sed -Ei 's/serde = \{ version = "(.*)", features = \[/serde = {version = "\1", features = ["rc", /g' Cargo.toml
sed -Ei 's/#\[derive\((.*)(, )?Default(, )?/#[derive(\1/g' src/models/*.rs
#add log crate. Used by tag impl
echo "" >> Cargo.toml

8
src/models/account_deletion_log.rs
View File

@ -9,17 +9,17 @@
use crate::models;
use serde::{Deserialize, Serialize};
#[derive(Clone, Default, Debug, PartialEq, Serialize, Deserialize)]
#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
pub struct AccountDeletionLog {
/// Typically \"Deletion requested\" or \"Deletion canceled\". Other messages like \"Deletion completed\" may exist, but are these are not possible to see as a regular user.
#[serde(rename = "message", skip_serializing_if = "Option::is_none")]
pub message: Option<String>,
pub message: Option<std::sync::Arc<str>>,
/// When the deletion is scheduled to happen, standard is 14 days after the request.
#[serde(rename = "deletionScheduled", default, with = "::serde_with::rust::double_option", skip_serializing_if = "Option::is_none")]
pub deletion_scheduled: Option<Option<String>>,
pub deletion_scheduled: Option<Option<std::sync::Arc<str>>>,
/// Date and time of the deletion request.
#[serde(rename = "dateTime", skip_serializing_if = "Option::is_none")]
pub date_time: Option<String>,
pub date_time: Option<std::sync::Arc<str>>,
}
impl AccountDeletionLog {

8
src/models/add_favorite_request.rs
View File

@ -9,20 +9,20 @@
use crate::models;
use serde::{Deserialize, Serialize};
#[derive(Clone, Default, Debug, PartialEq, Serialize, Deserialize)]
#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
pub struct AddFavoriteRequest {
#[serde(rename = "type")]
pub r#type: models::FavoriteType,
/// Must be either AvatarID, WorldID or UserID.
#[serde(rename = "favoriteId")]
pub favorite_id: String,
pub favorite_id: std::sync::Arc<str>,
/// Tags indicate which group this favorite belongs to. Adding multiple groups makes it show up in all. Removing it from one in that case removes it from all.
#[serde(rename = "tags")]
pub tags: Vec<String>,
pub tags: Vec<crate::models::tags::Tags>,
}
impl AddFavoriteRequest {
pub fn new(r#type: models::FavoriteType, favorite_id: String, tags: Vec<String>) -> AddFavoriteRequest {
pub fn new(r#type: models::FavoriteType, favorite_id: std::sync::Arc<str>, tags: Vec<crate::models::tags::Tags>) -> AddFavoriteRequest {
AddFavoriteRequest {
r#type,
favorite_id,

6
src/models/add_group_gallery_image_request.rs
View File

@ -9,14 +9,14 @@
use crate::models;
use serde::{Deserialize, Serialize};
#[derive(Clone, Default, Debug, PartialEq, Serialize, Deserialize)]
#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
pub struct AddGroupGalleryImageRequest {
#[serde(rename = "fileId")]
pub file_id: String,
pub file_id: std::sync::Arc<str>,
}
impl AddGroupGalleryImageRequest {
pub fn new(file_id: String) -> AddGroupGalleryImageRequest {
pub fn new(file_id: std::sync::Arc<str>) -> AddGroupGalleryImageRequest {
AddGroupGalleryImageRequest {
file_id,
}

78
src/models/api_config.rs
View File

@ -10,7 +10,7 @@ use crate::models;
use serde::{Deserialize, Serialize};
/// ApiConfig :
#[derive(Clone, Default, Debug, PartialEq, Serialize, Deserialize)]
#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
pub struct ApiConfig {
/// Unknown, probably voice optimization testing
#[serde(rename = "VoiceEnableDegradation")]
@ -20,25 +20,25 @@ pub struct ApiConfig {
pub voice_enable_receiver_limiting: bool,
/// VRChat's office address
#[serde(rename = "address")]
pub address: String,
pub address: std::sync::Arc<str>,
/// Public Announcements
#[serde(rename = "announcements")]
pub announcements: Vec<models::ApiConfigAnnouncement>,
/// Game name
#[serde(rename = "appName")]
pub app_name: String,
pub app_name: std::sync::Arc<str>,
/// List of supported Languages
#[serde(rename = "availableLanguageCodes")]
pub available_language_codes: Vec<String>,
pub available_language_codes: Vec<std::sync::Arc<str>>,
/// List of supported Languages
#[serde(rename = "availableLanguages")]
pub available_languages: Vec<String>,
pub available_languages: Vec<std::sync::Arc<str>>,
/// Build tag of the API server
#[serde(rename = "buildVersionTag")]
pub build_version_tag: String,
pub build_version_tag: std::sync::Arc<str>,
/// apiKey to be used for all other requests
#[serde(rename = "clientApiKey")]
pub client_api_key: String,
pub client_api_key: std::sync::Arc<str>,
/// Unknown
#[serde(rename = "clientBPSCeiling")]
pub client_bps_ceiling: i32,
@ -83,10 +83,10 @@ pub struct ApiConfig {
pub client_sent_count_allowance: i32,
/// VRChat's contact email
#[serde(rename = "contactEmail")]
pub contact_email: String,
pub contact_email: std::sync::Arc<str>,
/// VRChat's copyright-issues-related email
#[serde(rename = "copyrightEmail")]
pub copyright_email: String,
pub copyright_email: std::sync::Arc<str>,
/// Current version number of the Privacy Agreement
#[serde(rename = "currentPrivacyVersion", skip_serializing_if = "Option::is_none")]
pub current_privacy_version: Option<i32>,
@ -94,21 +94,21 @@ pub struct ApiConfig {
#[serde(rename = "currentTOSVersion")]
pub current_tos_version: i32,
#[serde(rename = "defaultAvatar")]
pub default_avatar: String,
pub default_avatar: std::sync::Arc<str>,
#[serde(rename = "deploymentGroup")]
pub deployment_group: models::DeploymentGroup,
/// Unknown
#[serde(rename = "devLanguageCodes", skip_serializing_if = "Option::is_none")]
pub dev_language_codes: Option<Vec<String>>,
pub dev_language_codes: Option<Vec<std::sync::Arc<str>>>,
/// Link to download the development SDK, use downloadUrls instead
#[serde(rename = "devSdkUrl")]
pub dev_sdk_url: String,
pub dev_sdk_url: std::sync::Arc<str>,
/// Version of the development SDK
#[serde(rename = "devSdkVersion")]
pub dev_sdk_version: String,
pub dev_sdk_version: std::sync::Arc<str>,
/// Unknown, \"dis\" maybe for disconnect?
#[serde(rename = "dis-countdown")]
pub dis_countdown: String,
pub dis_countdown: std::sync::Arc<str>,
/// Unknown
#[serde(rename = "disableAVProInProton", skip_serializing_if = "Option::is_none")]
pub disable_av_pro_in_proton: Option<bool>,
@ -162,7 +162,7 @@ pub struct ApiConfig {
pub disable_upgrade_account: bool,
/// Download link for game on the Oculus Rift website.
#[serde(rename = "downloadLinkWindows")]
pub download_link_windows: String,
pub download_link_windows: std::sync::Arc<str>,
#[serde(rename = "downloadUrls")]
pub download_urls: Box<models::ApiConfigDownloadUrlList>,
/// Array of DynamicWorldRow objects, used by the game to display the list of world rows
@ -170,10 +170,10 @@ pub struct ApiConfig {
pub dynamic_world_rows: Vec<models::DynamicContentRow>,
/// Unknown
#[serde(rename = "economyPauseEnd", skip_serializing_if = "Option::is_none")]
pub economy_pause_end: Option<String>,
pub economy_pause_end: Option<std::sync::Arc<str>>,
/// Unknown
#[serde(rename = "economyPauseStart", skip_serializing_if = "Option::is_none")]
pub economy_pause_start: Option<String>,
pub economy_pause_start: Option<std::sync::Arc<str>>,
/// Unknown
#[serde(rename = "economyState", skip_serializing_if = "Option::is_none")]
pub economy_state: Option<i32>,
@ -181,52 +181,52 @@ pub struct ApiConfig {
pub events: Box<models::ApiConfigEvents>,
/// WorldID be \"offline\" on User profiles if you are not friends with that user.
#[serde(rename = "homeWorldId")]
pub home_world_id: String,
pub home_world_id: std::sync::Arc<str>,
/// Redirect target if you try to open the base API domain in your browser
#[serde(rename = "homepageRedirectTarget")]
pub homepage_redirect_target: String,
pub homepage_redirect_target: std::sync::Arc<str>,
/// WorldID be \"offline\" on User profiles if you are not friends with that user.
#[serde(rename = "hubWorldId")]
pub hub_world_id: String,
pub hub_world_id: std::sync::Arc<str>,
/// A list of explicitly allowed origins that worlds can request images from via the Udon's [VRCImageDownloader#DownloadImage](https://creators.vrchat.com/worlds/udon/image-loading/#downloadimage).
#[serde(rename = "imageHostUrlList")]
pub image_host_url_list: Vec<String>,
pub image_host_url_list: Vec<std::sync::Arc<str>>,
/// VRChat's job application email
#[serde(rename = "jobsEmail")]
pub jobs_email: String,
pub jobs_email: std::sync::Arc<str>,
/// VRChat's moderation related email
#[serde(rename = "moderationEmail")]
pub moderation_email: String,
pub moderation_email: std::sync::Arc<str>,
/// Used in-game to notify a user they aren't allowed to select avatars in private worlds
#[serde(rename = "notAllowedToSelectAvatarInPrivateWorldMessage")]
pub not_allowed_to_select_avatar_in_private_world_message: String,
pub not_allowed_to_select_avatar_in_private_world_message: std::sync::Arc<str>,
/// Link to the developer FAQ
#[serde(rename = "sdkDeveloperFaqUrl")]
pub sdk_developer_faq_url: String,
pub sdk_developer_faq_url: std::sync::Arc<str>,
/// Link to the official VRChat Discord
#[serde(rename = "sdkDiscordUrl")]
pub sdk_discord_url: String,
pub sdk_discord_url: std::sync::Arc<str>,
/// Used in the SDK to notify a user they aren't allowed to upload avatars/worlds yet
#[serde(rename = "sdkNotAllowedToPublishMessage")]
pub sdk_not_allowed_to_publish_message: String,
pub sdk_not_allowed_to_publish_message: std::sync::Arc<str>,
/// Unity version supported by the SDK
#[serde(rename = "sdkUnityVersion")]
pub sdk_unity_version: String,
pub sdk_unity_version: std::sync::Arc<str>,
/// Server name of the API server currently responding
#[serde(rename = "serverName")]
pub server_name: String,
pub server_name: std::sync::Arc<str>,
/// A list of explicitly allowed origins that worlds can request strings from via the Udon's [VRCStringDownloader.LoadUrl](https://creators.vrchat.com/worlds/udon/string-loading/#ivrcstringdownload).
#[serde(rename = "stringHostUrlList")]
pub string_host_url_list: Vec<String>,
pub string_host_url_list: Vec<std::sync::Arc<str>>,
/// VRChat's support email
#[serde(rename = "supportEmail")]
pub support_email: String,
pub support_email: std::sync::Arc<str>,
/// WorldID be \"offline\" on User profiles if you are not friends with that user.
#[serde(rename = "timeOutWorldId")]
pub time_out_world_id: String,
pub time_out_world_id: std::sync::Arc<str>,
/// WorldID be \"offline\" on User profiles if you are not friends with that user.
#[serde(rename = "tutorialWorldId")]
pub tutorial_world_id: String,
pub tutorial_world_id: std::sync::Arc<str>,
/// Unknown
#[serde(rename = "updateRateMsMaximum")]
pub update_rate_ms_maximum: i32,
@ -244,26 +244,26 @@ pub struct ApiConfig {
pub upload_analysis_percent: i32,
/// List of allowed URLs that bypass the \"Allow untrusted URL's\" setting in-game
#[serde(rename = "urlList")]
pub url_list: Vec<String>,
pub url_list: Vec<std::sync::Arc<str>>,
/// Unknown
#[serde(rename = "useReliableUdpForVoice")]
pub use_reliable_udp_for_voice: bool,
/// Download link for game on the Steam website.
#[serde(rename = "viveWindowsUrl")]
pub vive_windows_url: String,
pub vive_windows_url: std::sync::Arc<str>,
/// List of allowed URLs that are allowed to host avatar assets
#[serde(rename = "whiteListedAssetUrls")]
pub white_listed_asset_urls: Vec<String>,
pub white_listed_asset_urls: Vec<std::sync::Arc<str>>,
/// Currently used youtube-dl.exe version
#[serde(rename = "player-url-resolver-version")]
pub player_url_resolver_version: String,
pub player_url_resolver_version: std::sync::Arc<str>,
/// Currently used youtube-dl.exe hash in SHA1-delimited format
#[serde(rename = "player-url-resolver-sha1")]
pub player_url_resolver_sha1: String,
pub player_url_resolver_sha1: std::sync::Arc<str>,
}
impl ApiConfig {
pub fn new(voice_enable_degradation: bool, voice_enable_receiver_limiting: bool, address: String, announcements: Vec<models::ApiConfigAnnouncement>, app_name: String, available_language_codes: Vec<String>, available_languages: Vec<String>, build_version_tag: String, client_api_key: String, client_bps_ceiling: i32, client_disconnect_timeout: i32, client_reserved_player_bps: i32, client_sent_count_allowance: i32, contact_email: String, copyright_email: String, current_tos_version: i32, default_avatar: String, deployment_group: models::DeploymentGroup, dev_sdk_url: String, dev_sdk_version: String, dis_countdown: String, disable_avatar_copying: bool, disable_avatar_gating: bool, disable_community_labs: bool, disable_community_labs_promotion: bool, disable_email: bool, disable_event_stream: bool, disable_feedback_gating: bool, disable_frontend_builds: bool, disable_hello: bool, disable_oculus_subs: bool, disable_registration: bool, disable_steam_networking: bool, disable_two_factor_auth: bool, disable_udon: bool, disable_upgrade_account: bool, download_link_windows: String, download_urls: models::ApiConfigDownloadUrlList, dynamic_world_rows: Vec<models::DynamicContentRow>, events: models::ApiConfigEvents, home_world_id: String, homepage_redirect_target: String, hub_world_id: String, image_host_url_list: Vec<String>, jobs_email: String, moderation_email: String, not_allowed_to_select_avatar_in_private_world_message: String, sdk_developer_faq_url: String, sdk_discord_url: String, sdk_not_allowed_to_publish_message: String, sdk_unity_version: String, server_name: String, string_host_url_list: Vec<String>, support_email: String, time_out_world_id: String, tutorial_world_id: String, update_rate_ms_maximum: i32, update_rate_ms_minimum: i32, update_rate_ms_normal: i32, update_rate_ms_udon_manual: i32, upload_analysis_percent: i32, url_list: Vec<String>, use_reliable_udp_for_voice: bool, vive_windows_url: String, white_listed_asset_urls: Vec<String>, player_url_resolver_version: String, player_url_resolver_sha1: String) -> ApiConfig {
pub fn new(voice_enable_degradation: bool, voice_enable_receiver_limiting: bool, address: std::sync::Arc<str>, announcements: Vec<models::ApiConfigAnnouncement>, app_name: std::sync::Arc<str>, available_language_codes: Vec<std::sync::Arc<str>>, available_languages: Vec<std::sync::Arc<str>>, build_version_tag: std::sync::Arc<str>, client_api_key: std::sync::Arc<str>, client_bps_ceiling: i32, client_disconnect_timeout: i32, client_reserved_player_bps: i32, client_sent_count_allowance: i32, contact_email: std::sync::Arc<str>, copyright_email: std::sync::Arc<str>, current_tos_version: i32, default_avatar: std::sync::Arc<str>, deployment_group: models::DeploymentGroup, dev_sdk_url: std::sync::Arc<str>, dev_sdk_version: std::sync::Arc<str>, dis_countdown: std::sync::Arc<str>, disable_avatar_copying: bool, disable_avatar_gating: bool, disable_community_labs: bool, disable_community_labs_promotion: bool, disable_email: bool, disable_event_stream: bool, disable_feedback_gating: bool, disable_frontend_builds: bool, disable_hello: bool, disable_oculus_subs: bool, disable_registration: bool, disable_steam_networking: bool, disable_two_factor_auth: bool, disable_udon: bool, disable_upgrade_account: bool, download_link_windows: std::sync::Arc<str>, download_urls: models::ApiConfigDownloadUrlList, dynamic_world_rows: Vec<models::DynamicContentRow>, events: models::ApiConfigEvents, home_world_id: std::sync::Arc<str>, homepage_redirect_target: std::sync::Arc<str>, hub_world_id: std::sync::Arc<str>, image_host_url_list: Vec<std::sync::Arc<str>>, jobs_email: std::sync::Arc<str>, moderation_email: std::sync::Arc<str>, not_allowed_to_select_avatar_in_private_world_message: std::sync::Arc<str>, sdk_developer_faq_url: std::sync::Arc<str>, sdk_discord_url: std::sync::Arc<str>, sdk_not_allowed_to_publish_message: std::sync::Arc<str>, sdk_unity_version: std::sync::Arc<str>, server_name: std::sync::Arc<str>, string_host_url_list: Vec<std::sync::Arc<str>>, support_email: std::sync::Arc<str>, time_out_world_id: std::sync::Arc<str>, tutorial_world_id: std::sync::Arc<str>, update_rate_ms_maximum: i32, update_rate_ms_minimum: i32, update_rate_ms_normal: i32, update_rate_ms_udon_manual: i32, upload_analysis_percent: i32, url_list: Vec<std::sync::Arc<str>>, use_reliable_udp_for_voice: bool, vive_windows_url: std::sync::Arc<str>, white_listed_asset_urls: Vec<std::sync::Arc<str>>, player_url_resolver_version: std::sync::Arc<str>, player_url_resolver_sha1: std::sync::Arc<str>) -> ApiConfig {
ApiConfig {
voice_enable_degradation,
voice_enable_receiver_limiting,

8
src/models/api_config_announcement.rs
View File

@ -10,19 +10,19 @@ use crate::models;
use serde::{Deserialize, Serialize};
/// ApiConfigAnnouncement : Public Announcement
#[derive(Clone, Default, Debug, PartialEq, Serialize, Deserialize)]
#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
pub struct ApiConfigAnnouncement {
/// Announcement name
#[serde(rename = "name")]
pub name: String,
pub name: std::sync::Arc<str>,
/// Announcement text
#[serde(rename = "text")]
pub text: String,
pub text: std::sync::Arc<str>,
}
impl ApiConfigAnnouncement {
/// Public Announcement
pub fn new(name: String, text: String) -> ApiConfigAnnouncement {
pub fn new(name: std::sync::Arc<str>, text: std::sync::Arc<str>) -> ApiConfigAnnouncement {
ApiConfigAnnouncement {
name,
text,

14
src/models/api_config_download_url_list.rs
View File

@ -10,28 +10,28 @@ use crate::models;
use serde::{Deserialize, Serialize};
/// ApiConfigDownloadUrlList : Download links for various development assets.
#[derive(Clone, Default, Debug, PartialEq, Serialize, Deserialize)]
#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
pub struct ApiConfigDownloadUrlList {
/// Download link for legacy SDK2
#[serde(rename = "sdk2")]
pub sdk2: String,
pub sdk2: std::sync::Arc<str>,
/// Download link for SDK3 for Avatars
#[serde(rename = "sdk3-avatars")]
pub sdk3_avatars: String,
pub sdk3_avatars: std::sync::Arc<str>,
/// Download link for SDK3 for Worlds
#[serde(rename = "sdk3-worlds")]
pub sdk3_worlds: String,
pub sdk3_worlds: std::sync::Arc<str>,
/// Download link for the Creator Companion
#[serde(rename = "vcc")]
pub vcc: String,
pub vcc: std::sync::Arc<str>,
/// Download link for ???
#[serde(rename = "bootstrap")]
pub bootstrap: String,
pub bootstrap: std::sync::Arc<str>,
}
impl ApiConfigDownloadUrlList {
/// Download links for various development assets.
pub fn new(sdk2: String, sdk3_avatars: String, sdk3_worlds: String, vcc: String, bootstrap: String) -> ApiConfigDownloadUrlList {
pub fn new(sdk2: std::sync::Arc<str>, sdk3_avatars: std::sync::Arc<str>, sdk3_worlds: std::sync::Arc<str>, vcc: std::sync::Arc<str>, bootstrap: std::sync::Arc<str>) -> ApiConfigDownloadUrlList {
ApiConfigDownloadUrlList {
sdk2,
sdk3_avatars,

2
src/models/api_config_events.rs
View File

@ -9,7 +9,7 @@
use crate::models;
use serde::{Deserialize, Serialize};
#[derive(Clone, Default, Debug, PartialEq, Serialize, Deserialize)]
#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
pub struct ApiConfigEvents {
/// Unknown
#[serde(rename = "distanceClose")]

8
src/models/api_health.rs
View File

@ -9,18 +9,18 @@
use crate::models;
use serde::{Deserialize, Serialize};
#[derive(Clone, Default, Debug, PartialEq, Serialize, Deserialize)]
#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
pub struct ApiHealth {
#[serde(rename = "ok")]
pub ok: bool,
#[serde(rename = "serverName")]
pub server_name: String,
pub server_name: std::sync::Arc<str>,
#[serde(rename = "buildVersionTag")]
pub build_version_tag: String,
pub build_version_tag: std::sync::Arc<str>,
}
impl ApiHealth {
pub fn new(ok: bool, server_name: String, build_version_tag: String) -> ApiHealth {
pub fn new(ok: bool, server_name: std::sync::Arc<str>, build_version_tag: std::sync::Arc<str>) -> ApiHealth {
ApiHealth {
ok,
server_name,

28
src/models/avatar.rs
View File

@ -10,51 +10,51 @@ use crate::models;
use serde::{Deserialize, Serialize};
/// Avatar :
#[derive(Clone, Default, Debug, PartialEq, Serialize, Deserialize)]
#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
pub struct Avatar {
/// Not present from general serach `/avatars`, only on specific requests `/avatars/{avatarId}`.
#[serde(rename = "assetUrl", skip_serializing_if = "Option::is_none")]
pub asset_url: Option<String>,
pub asset_url: Option<std::sync::Arc<str>>,
/// Not present from general serach `/avatars`, only on specific requests `/avatars/{avatarId}`. **Deprecation:** `Object` has unknown usage/fields, and is always empty. Use normal `Url` field instead.
#[serde(rename = "assetUrlObject", skip_serializing_if = "Option::is_none")]
pub asset_url_object: Option<serde_json::Value>,
/// A users unique ID, usually in the form of `usr_c1644b5b-3ca4-45b4-97c6-a2a0de70d469`. Legacy players can have old IDs in the form of `8JoV9XEdpo`. The ID can never be changed.
#[serde(rename = "authorId")]
pub author_id: String,
pub author_id: std::sync::Arc<str>,
#[serde(rename = "authorName")]
pub author_name: String,
pub author_name: std::sync::Arc<str>,
#[serde(rename = "created_at")]
pub created_at: String,
pub created_at: std::sync::Arc<str>,
#[serde(rename = "description")]
pub description: String,
pub description: std::sync::Arc<str>,
#[serde(rename = "featured")]
pub featured: bool,
#[serde(rename = "id")]
pub id: String,
pub id: std::sync::Arc<str>,
#[serde(rename = "imageUrl")]
pub image_url: String,
pub image_url: std::sync::Arc<str>,
#[serde(rename = "name")]
pub name: String,
pub name: std::sync::Arc<str>,
#[serde(rename = "releaseStatus")]
pub release_status: models::ReleaseStatus,
#[serde(rename = "tags")]
pub tags: Vec<String>,
pub tags: Vec<crate::models::tags::Tags>,
#[serde(rename = "thumbnailImageUrl")]
pub thumbnail_image_url: String,
pub thumbnail_image_url: std::sync::Arc<str>,
#[serde(rename = "unityPackageUrl")]
pub unity_package_url: String,
pub unity_package_url: std::sync::Arc<str>,
#[serde(rename = "unityPackageUrlObject")]
pub unity_package_url_object: Box<models::AvatarUnityPackageUrlObject>,
#[serde(rename = "unityPackages")]
pub unity_packages: Vec<models::UnityPackage>,
#[serde(rename = "updated_at")]
pub updated_at: String,
pub updated_at: std::sync::Arc<str>,
#[serde(rename = "version")]
pub version: i32,
}
impl Avatar {
pub fn new(author_id: String, author_name: String, created_at: String, description: String, featured: bool, id: String, image_url: String, name: String, release_status: models::ReleaseStatus, tags: Vec<String>, thumbnail_image_url: String, unity_package_url: String, unity_package_url_object: models::AvatarUnityPackageUrlObject, unity_packages: Vec<models::UnityPackage>, updated_at: String, version: i32) -> Avatar {
pub fn new(author_id: std::sync::Arc<str>, author_name: std::sync::Arc<str>, created_at: std::sync::Arc<str>, description: std::sync::Arc<str>, featured: bool, id: std::sync::Arc<str>, image_url: std::sync::Arc<str>, name: std::sync::Arc<str>, release_status: models::ReleaseStatus, tags: Vec<crate::models::tags::Tags>, thumbnail_image_url: std::sync::Arc<str>, unity_package_url: std::sync::Arc<str>, unity_package_url_object: models::AvatarUnityPackageUrlObject, unity_packages: Vec<models::UnityPackage>, updated_at: std::sync::Arc<str>, version: i32) -> Avatar {
Avatar {
asset_url: None,
asset_url_object: None,

4
src/models/avatar_unity_package_url_object.rs
View File

@ -10,10 +10,10 @@ use crate::models;
use serde::{Deserialize, Serialize};
/// AvatarUnityPackageUrlObject : **Deprecation:** `Object` has unknown usage/fields, and is always empty. Use normal `Url` field instead.
#[derive(Clone, Default, Debug, PartialEq, Serialize, Deserialize)]
#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
pub struct AvatarUnityPackageUrlObject {
#[serde(rename = "unityPackageUrl", skip_serializing_if = "Option::is_none")]
pub unity_package_url: Option<String>,
pub unity_package_url: Option<std::sync::Arc<str>>,
}
impl AvatarUnityPackageUrlObject {

16
src/models/badge.rs
View File

@ -9,20 +9,20 @@
use crate::models;
use serde::{Deserialize, Serialize};
#[derive(Clone, Default, Debug, PartialEq, Serialize, Deserialize)]
#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
pub struct Badge {
/// only present in CurrentUser badges
#[serde(rename = "assignedAt", default, with = "::serde_with::rust::double_option", skip_serializing_if = "Option::is_none")]
pub assigned_at: Option<Option<String>>,
pub assigned_at: Option<Option<std::sync::Arc<str>>>,
#[serde(rename = "badgeDescription")]
pub badge_description: String,
pub badge_description: std::sync::Arc<str>,
#[serde(rename = "badgeId")]
pub badge_id: String,
pub badge_id: std::sync::Arc<str>,
/// direct url to image
#[serde(rename = "badgeImageUrl")]
pub badge_image_url: String,
pub badge_image_url: std::sync::Arc<str>,
#[serde(rename = "badgeName")]
pub badge_name: String,
pub badge_name: std::sync::Arc<str>,
/// only present in CurrentUser badges
#[serde(rename = "hidden", default, with = "::serde_with::rust::double_option", skip_serializing_if = "Option::is_none")]
pub hidden: Option<Option<bool>>,
@ -30,11 +30,11 @@ pub struct Badge {
pub showcased: bool,
/// only present in CurrentUser badges
#[serde(rename = "updatedAt", default, with = "::serde_with::rust::double_option", skip_serializing_if = "Option::is_none")]
pub updated_at: Option<Option<String>>,
pub updated_at: Option<Option<std::sync::Arc<str>>>,
}
impl Badge {
pub fn new(badge_description: String, badge_id: String, badge_image_url: String, badge_name: String, showcased: bool) -> Badge {
pub fn new(badge_description: std::sync::Arc<str>, badge_id: std::sync::Arc<str>, badge_image_url: std::sync::Arc<str>, badge_name: std::sync::Arc<str>, showcased: bool) -> Badge {
Badge {
assigned_at: None,
badge_description,

6
src/models/ban_group_member_request.rs
View File

@ -9,15 +9,15 @@
use crate::models;
use serde::{Deserialize, Serialize};
#[derive(Clone, Default, Debug, PartialEq, Serialize, Deserialize)]
#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
pub struct BanGroupMemberRequest {
/// A users unique ID, usually in the form of `usr_c1644b5b-3ca4-45b4-97c6-a2a0de70d469`. Legacy players can have old IDs in the form of `8JoV9XEdpo`. The ID can never be changed.
#[serde(rename = "userId")]
pub user_id: String,
pub user_id: std::sync::Arc<str>,
}
impl BanGroupMemberRequest {
pub fn new(user_id: String) -> BanGroupMemberRequest {
pub fn new(user_id: std::sync::Arc<str>) -> BanGroupMemberRequest {
BanGroupMemberRequest {
user_id,
}

20
src/models/create_avatar_request.rs
View File

@ -9,32 +9,32 @@
use crate::models;
use serde::{Deserialize, Serialize};
#[derive(Clone, Default, Debug, PartialEq, Serialize, Deserialize)]
#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
pub struct CreateAvatarRequest {
#[serde(rename = "assetUrl", skip_serializing_if = "Option::is_none")]
pub asset_url: Option<String>,
pub asset_url: Option<std::sync::Arc<str>>,
#[serde(rename = "id", skip_serializing_if = "Option::is_none")]
pub id: Option<String>,
pub id: Option<std::sync::Arc<str>>,
#[serde(rename = "name")]
pub name: String,
pub name: std::sync::Arc<str>,
#[serde(rename = "description", skip_serializing_if = "Option::is_none")]
pub description: Option<String>,
pub description: Option<std::sync::Arc<str>>,
#[serde(rename = "tags", skip_serializing_if = "Option::is_none")]
pub tags: Option<Vec<String>>,
pub tags: Option<Vec<std::sync::Arc<str>>>,
#[serde(rename = "imageUrl")]
pub image_url: String,
pub image_url: std::sync::Arc<str>,
#[serde(rename = "releaseStatus", skip_serializing_if = "Option::is_none")]
pub release_status: Option<models::ReleaseStatus>,
#[serde(rename = "version", skip_serializing_if = "Option::is_none")]
pub version: Option<f64>,
#[serde(rename = "unityPackageUrl", skip_serializing_if = "Option::is_none")]
pub unity_package_url: Option<String>,
pub unity_package_url: Option<std::sync::Arc<str>>,
#[serde(rename = "unityVersion", skip_serializing_if = "Option::is_none")]
pub unity_version: Option<String>,
pub unity_version: Option<std::sync::Arc<str>>,
}
impl CreateAvatarRequest {
pub fn new(name: String, image_url: String) -> CreateAvatarRequest {
pub fn new(name: std::sync::Arc<str>, image_url: std::sync::Arc<str>) -> CreateAvatarRequest {
CreateAvatarRequest {
asset_url: None,
id: None,

10
src/models/create_file_request.rs
View File

@ -9,20 +9,20 @@
use crate::models;
use serde::{Deserialize, Serialize};
#[derive(Clone, Default, Debug, PartialEq, Serialize, Deserialize)]
#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
pub struct CreateFileRequest {
#[serde(rename = "name")]
pub name: String,
pub name: std::sync::Arc<str>,
#[serde(rename = "mimeType")]
pub mime_type: models::MimeType,
#[serde(rename = "extension")]
pub extension: String,
pub extension: std::sync::Arc<str>,
#[serde(rename = "tags", skip_serializing_if = "Option::is_none")]
pub tags: Option<Vec<String>>,
pub tags: Option<Vec<std::sync::Arc<str>>>,
}
impl CreateFileRequest {
pub fn new(name: String, mime_type: models::MimeType, extension: String) -> CreateFileRequest {
pub fn new(name: std::sync::Arc<str>, mime_type: models::MimeType, extension: std::sync::Arc<str>) -> CreateFileRequest {
CreateFileRequest {
name,
mime_type,

8
src/models/create_file_version_request.rs
View File

@ -9,20 +9,20 @@
use crate::models;
use serde::{Deserialize, Serialize};
#[derive(Clone, Default, Debug, PartialEq, Serialize, Deserialize)]
#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
pub struct CreateFileVersionRequest {
#[serde(rename = "signatureMd5")]
pub signature_md5: String,
pub signature_md5: std::sync::Arc<str>,
#[serde(rename = "signatureSizeInBytes")]
pub signature_size_in_bytes: f64,
#[serde(rename = "fileMd5", skip_serializing_if = "Option::is_none")]
pub file_md5: Option<String>,
pub file_md5: Option<std::sync::Arc<str>>,
#[serde(rename = "fileSizeInBytes", skip_serializing_if = "Option::is_none")]
pub file_size_in_bytes: Option<f64>,
}
impl CreateFileVersionRequest {
pub fn new(signature_md5: String, signature_size_in_bytes: f64) -> CreateFileVersionRequest {
pub fn new(signature_md5: std::sync::Arc<str>, signature_size_in_bytes: f64) -> CreateFileVersionRequest {
CreateFileVersionRequest {
signature_md5,
signature_size_in_bytes,

10
src/models/create_group_announcement_request.rs
View File

@ -9,23 +9,23 @@
use crate::models;
use serde::{Deserialize, Serialize};
#[derive(Clone, Default, Debug, PartialEq, Serialize, Deserialize)]
#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
pub struct CreateGroupAnnouncementRequest {
/// Announcement title
#[serde(rename = "title")]
pub title: String,
pub title: std::sync::Arc<str>,
/// Announcement text
#[serde(rename = "text", skip_serializing_if = "Option::is_none")]
pub text: Option<String>,
pub text: Option<std::sync::Arc<str>>,
#[serde(rename = "imageId", skip_serializing_if = "Option::is_none")]
pub image_id: Option<String>,
pub image_id: Option<std::sync::Arc<str>>,
/// Send notification to group members.
#[serde(rename = "sendNotification", skip_serializing_if = "Option::is_none")]
pub send_notification: Option<bool>,
}
impl CreateGroupAnnouncementRequest {
pub fn new(title: String) -> CreateGroupAnnouncementRequest {
pub fn new(title: std::sync::Arc<str>) -> CreateGroupAnnouncementRequest {
CreateGroupAnnouncementRequest {
title,
text: None,

16
src/models/create_group_gallery_request.rs
View File

@ -9,29 +9,29 @@
use crate::models;
use serde::{Deserialize, Serialize};
#[derive(Clone, Default, Debug, PartialEq, Serialize, Deserialize)]
#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
pub struct CreateGroupGalleryRequest {
/// Name of the gallery.
#[serde(rename = "name")]
pub name: String,
pub name: std::sync::Arc<str>,
/// Description of the gallery.
#[serde(rename = "description", skip_serializing_if = "Option::is_none")]
pub description: Option<String>,
pub description: Option<std::sync::Arc<str>>,
/// Whether the gallery is members only.
#[serde(rename = "membersOnly", skip_serializing_if = "Option::is_none")]
pub members_only: Option<bool>,
#[serde(rename = "roleIdsToView", default, with = "::serde_with::rust::double_option", skip_serializing_if = "Option::is_none")]
pub role_ids_to_view: Option<Option<Vec<String>>>,
pub role_ids_to_view: Option<Option<Vec<std::sync::Arc<str>>>>,
#[serde(rename = "roleIdsToSubmit", default, with = "::serde_with::rust::double_option", skip_serializing_if = "Option::is_none")]
pub role_ids_to_submit: Option<Option<Vec<String>>>,
pub role_ids_to_submit: Option<Option<Vec<std::sync::Arc<str>>>>,
#[serde(rename = "roleIdsToAutoApprove", default, with = "::serde_with::rust::double_option", skip_serializing_if = "Option::is_none")]
pub role_ids_to_auto_approve: Option<Option<Vec<String>>>,
pub role_ids_to_auto_approve: Option<Option<Vec<std::sync::Arc<str>>>>,
#[serde(rename = "roleIdsToManage", default, with = "::serde_with::rust::double_option", skip_serializing_if = "Option::is_none")]
pub role_ids_to_manage: Option<Option<Vec<String>>>,
pub role_ids_to_manage: Option<Option<Vec<std::sync::Arc<str>>>>,
}
impl CreateGroupGalleryRequest {
pub fn new(name: String) -> CreateGroupGalleryRequest {
pub fn new(name: std::sync::Arc<str>) -> CreateGroupGalleryRequest {
CreateGroupGalleryRequest {
name,
description: None,

6
src/models/create_group_invite_request.rs
View File

@ -9,17 +9,17 @@
use crate::models;
use serde::{Deserialize, Serialize};
#[derive(Clone, Default, Debug, PartialEq, Serialize, Deserialize)]
#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
pub struct CreateGroupInviteRequest {
/// A users unique ID, usually in the form of `usr_c1644b5b-3ca4-45b4-97c6-a2a0de70d469`. Legacy players can have old IDs in the form of `8JoV9XEdpo`. The ID can never be changed.
#[serde(rename = "userId")]
pub user_id: String,
pub user_id: std::sync::Arc<str>,
#[serde(rename = "confirmOverrideBlock", skip_serializing_if = "Option::is_none")]
pub confirm_override_block: Option<bool>,
}
impl CreateGroupInviteRequest {
pub fn new(user_id: String) -> CreateGroupInviteRequest {
pub fn new(user_id: std::sync::Arc<str>) -> CreateGroupInviteRequest {
CreateGroupInviteRequest {
user_id,
confirm_override_block: None,

12
src/models/create_group_post_request.rs
View File

@ -9,27 +9,27 @@
use crate::models;
use serde::{Deserialize, Serialize};
#[derive(Clone, Default, Debug, PartialEq, Serialize, Deserialize)]
#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
pub struct CreateGroupPostRequest {
/// Post title
#[serde(rename = "title")]
pub title: String,
pub title: std::sync::Arc<str>,
/// Post text
#[serde(rename = "text")]
pub text: String,
pub text: std::sync::Arc<str>,
#[serde(rename = "imageId", skip_serializing_if = "Option::is_none")]
pub image_id: Option<String>,
pub image_id: Option<std::sync::Arc<str>>,
/// Send notification to group members.
#[serde(rename = "sendNotification")]
pub send_notification: bool,
#[serde(rename = "roleIds", skip_serializing_if = "Option::is_none")]
pub role_ids: Option<Vec<String>>,
pub role_ids: Option<Vec<std::sync::Arc<str>>>,
#[serde(rename = "visibility")]
pub visibility: models::GroupPostVisibility,
}
impl CreateGroupPostRequest {
pub fn new(title: String, text: String, send_notification: bool, visibility: models::GroupPostVisibility) -> CreateGroupPostRequest {
pub fn new(title: std::sync::Arc<str>, text: std::sync::Arc<str>, send_notification: bool, visibility: models::GroupPostVisibility) -> CreateGroupPostRequest {
CreateGroupPostRequest {
title,
text,

14
src/models/create_group_request.rs
View File

@ -9,20 +9,20 @@
use crate::models;
use serde::{Deserialize, Serialize};
#[derive(Clone, Default, Debug, PartialEq, Serialize, Deserialize)]
#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
pub struct CreateGroupRequest {
#[serde(rename = "name")]
pub name: String,
pub name: std::sync::Arc<str>,
#[serde(rename = "shortCode")]
pub short_code: String,
pub short_code: std::sync::Arc<str>,
#[serde(rename = "description", skip_serializing_if = "Option::is_none")]
pub description: Option<String>,
pub description: Option<std::sync::Arc<str>>,
#[serde(rename = "joinState", skip_serializing_if = "Option::is_none")]
pub join_state: Option<models::GroupJoinState>,
#[serde(rename = "iconId", default, with = "::serde_with::rust::double_option", skip_serializing_if = "Option::is_none")]
pub icon_id: Option<Option<String>>,
pub icon_id: Option<Option<std::sync::Arc<str>>>,
#[serde(rename = "bannerId", default, with = "::serde_with::rust::double_option", skip_serializing_if = "Option::is_none")]
pub banner_id: Option<Option<String>>,
pub banner_id: Option<Option<std::sync::Arc<str>>>,
#[serde(rename = "privacy", skip_serializing_if = "Option::is_none")]
pub privacy: Option<models::GroupPrivacy>,
#[serde(rename = "roleTemplate")]
@ -30,7 +30,7 @@ pub struct CreateGroupRequest {
}
impl CreateGroupRequest {
pub fn new(name: String, short_code: String, role_template: models::GroupRoleTemplate) -> CreateGroupRequest {
pub fn new(name: std::sync::Arc<str>, short_code: std::sync::Arc<str>, role_template: models::GroupRoleTemplate) -> CreateGroupRequest {
CreateGroupRequest {
name,
short_code,

10
src/models/create_group_role_request.rs
View File

@ -9,18 +9,18 @@
use crate::models;
use serde::{Deserialize, Serialize};
#[derive(Clone, Default, Debug, PartialEq, Serialize, Deserialize)]
#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
pub struct CreateGroupRoleRequest {
#[serde(rename = "id", skip_serializing_if = "Option::is_none")]
pub id: Option<String>,
pub id: Option<std::sync::Arc<str>>,
#[serde(rename = "name", skip_serializing_if = "Option::is_none")]
pub name: Option<String>,
pub name: Option<std::sync::Arc<str>>,
#[serde(rename = "description", skip_serializing_if = "Option::is_none")]
pub description: Option<String>,
pub description: Option<std::sync::Arc<str>>,
#[serde(rename = "isSelfAssignable", skip_serializing_if = "Option::is_none")]
pub is_self_assignable: Option<bool>,
#[serde(rename = "permissions", skip_serializing_if = "Option::is_none")]
pub permissions: Option<Vec<String>>,
pub permissions: Option<Vec<std::sync::Arc<str>>>,
}
impl CreateGroupRoleRequest {

12
src/models/create_instance_request.rs
View File

@ -9,28 +9,28 @@
use crate::models;
use serde::{Deserialize, Serialize};
#[derive(Clone, Default, Debug, PartialEq, Serialize, Deserialize)]
#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
pub struct CreateInstanceRequest {
/// WorldID be \"offline\" on User profiles if you are not friends with that user.
#[serde(rename = "worldId")]
pub world_id: String,
pub world_id: std::sync::Arc<str>,
#[serde(rename = "type")]
pub r#type: models::InstanceType,
#[serde(rename = "region")]
pub region: models::InstanceRegion,
/// A groupId if the instance type is \"group\", null if instance type is public, or a userId otherwise
#[serde(rename = "ownerId", default, with = "::serde_with::rust::double_option", skip_serializing_if = "Option::is_none")]
pub owner_id: Option<Option<String>>,
pub owner_id: Option<Option<std::sync::Arc<str>>>,
/// Group roleIds that are allowed to join if the type is \"group\" and groupAccessType is \"member\"
#[serde(rename = "roleIds", skip_serializing_if = "Option::is_none")]
pub role_ids: Option<Vec<String>>,
pub role_ids: Option<Vec<std::sync::Arc<str>>>,
#[serde(rename = "groupAccessType", skip_serializing_if = "Option::is_none")]
pub group_access_type: Option<models::GroupAccessType>,
#[serde(rename = "queueEnabled", skip_serializing_if = "Option::is_none")]
pub queue_enabled: Option<bool>,
/// The time after which users won't be allowed to join the instance. This doesn't work for public instances.
#[serde(rename = "closedAt", skip_serializing_if = "Option::is_none")]
pub closed_at: Option<String>,
pub closed_at: Option<std::sync::Arc<str>>,
/// Only applies to invite type instances to make them invite+
#[serde(rename = "canRequestInvite", skip_serializing_if = "Option::is_none")]
pub can_request_invite: Option<bool>,
@ -42,7 +42,7 @@ pub struct CreateInstanceRequest {
}
impl CreateInstanceRequest {
pub fn new(world_id: String, r#type: models::InstanceType, region: models::InstanceRegion) -> CreateInstanceRequest {
pub fn new(world_id: std::sync::Arc<str>, r#type: models::InstanceType, region: models::InstanceRegion) -> CreateInstanceRequest {
CreateInstanceRequest {
world_id,
r#type,

26
src/models/create_world_request.rs
View File

@ -9,43 +9,43 @@
use crate::models;
use serde::{Deserialize, Serialize};
#[derive(Clone, Default, Debug, PartialEq, Serialize, Deserialize)]
#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
pub struct CreateWorldRequest {
#[serde(rename = "assetUrl")]
pub asset_url: String,
pub asset_url: std::sync::Arc<str>,
#[serde(rename = "assetVersion", skip_serializing_if = "Option::is_none")]
pub asset_version: Option<i32>,
/// A users unique ID, usually in the form of `usr_c1644b5b-3ca4-45b4-97c6-a2a0de70d469`. Legacy players can have old IDs in the form of `8JoV9XEdpo`. The ID can never be changed.
#[serde(rename = "authorId", skip_serializing_if = "Option::is_none")]
pub author_id: Option<String>,
pub author_id: Option<std::sync::Arc<str>>,
#[serde(rename = "authorName", skip_serializing_if = "Option::is_none")]
pub author_name: Option<String>,
pub author_name: Option<std::sync::Arc<str>>,
#[serde(rename = "capacity", skip_serializing_if = "Option::is_none")]
pub capacity: Option<i32>,
#[serde(rename = "description", skip_serializing_if = "Option::is_none")]
pub description: Option<String>,
pub description: Option<std::sync::Arc<str>>,
/// WorldID be \"offline\" on User profiles if you are not friends with that user.
#[serde(rename = "id", skip_serializing_if = "Option::is_none")]
pub id: Option<String>,
pub id: Option<std::sync::Arc<str>>,
#[serde(rename = "imageUrl")]
pub image_url: String,
pub image_url: std::sync::Arc<str>,
#[serde(rename = "name")]
pub name: String,
pub name: std::sync::Arc<str>,
/// This can be `standalonewindows` or `android`, but can also pretty much be any random Unity verison such as `2019.2.4-801-Release` or `2019.2.2-772-Release` or even `unknownplatform`.
#[serde(rename = "platform", skip_serializing_if = "Option::is_none")]
pub platform: Option<String>,
pub platform: Option<std::sync::Arc<str>>,
#[serde(rename = "releaseStatus", skip_serializing_if = "Option::is_none")]
pub release_status: Option<models::ReleaseStatus>,
#[serde(rename = "tags", skip_serializing_if = "Option::is_none")]
pub tags: Option<Vec<String>>,
pub tags: Option<Vec<std::sync::Arc<str>>>,
#[serde(rename = "unityPackageUrl", skip_serializing_if = "Option::is_none")]
pub unity_package_url: Option<String>,
pub unity_package_url: Option<std::sync::Arc<str>>,
#[serde(rename = "unityVersion", skip_serializing_if = "Option::is_none")]
pub unity_version: Option<String>,
pub unity_version: Option<std::sync::Arc<str>>,
}
impl CreateWorldRequest {
pub fn new(asset_url: String, image_url: String, name: String) -> CreateWorldRequest {
pub fn new(asset_url: std::sync::Arc<str>, image_url: std::sync::Arc<str>, name: std::sync::Arc<str>) -> CreateWorldRequest {
CreateWorldRequest {
asset_url,
asset_version: None,

92
src/models/current_user.rs
View File

@ -9,63 +9,63 @@
use crate::models;
use serde::{Deserialize, Serialize};
#[derive(Clone, Default, Debug, PartialEq, Serialize, Deserialize)]
#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
pub struct CurrentUser {
#[serde(rename = "acceptedTOSVersion")]
pub accepted_tos_version: i32,
#[serde(rename = "acceptedPrivacyVersion", skip_serializing_if = "Option::is_none")]
pub accepted_privacy_version: Option<i32>,
#[serde(rename = "accountDeletionDate", default, with = "::serde_with::rust::double_option", skip_serializing_if = "Option::is_none")]
pub account_deletion_date: Option<Option<String>>,
pub account_deletion_date: Option<Option<std::sync::Arc<str>>>,
#[serde(rename = "accountDeletionLog", default, with = "::serde_with::rust::double_option", skip_serializing_if = "Option::is_none")]
pub account_deletion_log: Option<Option<Vec<models::AccountDeletionLog>>>,
#[serde(rename = "activeFriends", skip_serializing_if = "Option::is_none")]
pub active_friends: Option<Vec<String>>,
pub active_friends: Option<Vec<std::sync::Arc<str>>>,
#[serde(rename = "allowAvatarCopying")]
pub allow_avatar_copying: bool,
#[serde(rename = "badges", skip_serializing_if = "Option::is_none")]
pub badges: Option<Vec<models::Badge>>,
#[serde(rename = "bio")]
pub bio: String,
pub bio: std::sync::Arc<str>,
#[serde(rename = "bioLinks")]
pub bio_links: Vec<String>,
pub bio_links: Vec<std::sync::Arc<str>>,
#[serde(rename = "currentAvatar")]
pub current_avatar: String,
pub current_avatar: std::sync::Arc<str>,
#[serde(rename = "currentAvatarAssetUrl")]
pub current_avatar_asset_url: String,
pub current_avatar_asset_url: std::sync::Arc<str>,
/// When profilePicOverride is not empty, use it instead.
#[serde(rename = "currentAvatarImageUrl")]
pub current_avatar_image_url: String,
pub current_avatar_image_url: std::sync::Arc<str>,
/// When profilePicOverride is not empty, use it instead.
#[serde(rename = "currentAvatarThumbnailImageUrl")]
pub current_avatar_thumbnail_image_url: String,
pub current_avatar_thumbnail_image_url: std::sync::Arc<str>,
#[serde(rename = "currentAvatarTags")]
pub current_avatar_tags: Vec<String>,
pub current_avatar_tags: Vec<crate::models::tags::Tags>,
#[serde(rename = "date_joined")]
pub date_joined: String,
pub date_joined: std::sync::Arc<str>,
#[serde(rename = "developerType")]
pub developer_type: models::DeveloperType,
#[serde(rename = "displayName")]
pub display_name: String,
pub display_name: std::sync::Arc<str>,
#[serde(rename = "emailVerified")]
pub email_verified: bool,
#[serde(rename = "fallbackAvatar", skip_serializing_if = "Option::is_none")]
pub fallback_avatar: Option<String>,
pub fallback_avatar: Option<std::sync::Arc<str>>,
/// Always empty array.
#[serde(rename = "friendGroupNames")]
pub friend_group_names: Vec<String>,
pub friend_group_names: Vec<std::sync::Arc<str>>,
#[serde(rename = "friendKey")]
pub friend_key: String,
pub friend_key: std::sync::Arc<str>,
#[serde(rename = "friends")]
pub friends: Vec<String>,
pub friends: Vec<std::sync::Arc<str>>,
#[serde(rename = "hasBirthday")]
pub has_birthday: bool,
#[serde(rename = "hideContentFilterSettings", skip_serializing_if = "Option::is_none")]
pub hide_content_filter_settings: Option<bool>,
#[serde(rename = "userLanguage", default, with = "::serde_with::rust::double_option", skip_serializing_if = "Option::is_none")]
pub user_language: Option<Option<String>>,
pub user_language: Option<Option<std::sync::Arc<str>>>,
#[serde(rename = "userLanguageCode", default, with = "::serde_with::rust::double_option", skip_serializing_if = "Option::is_none")]
pub user_language_code: Option<Option<String>>,
pub user_language_code: Option<Option<std::sync::Arc<str>>>,
#[serde(rename = "hasEmail")]
pub has_email: bool,
#[serde(rename = "hasLoggedInFromClient")]
@ -74,84 +74,84 @@ pub struct CurrentUser {
pub has_pending_email: bool,
/// WorldID be \"offline\" on User profiles if you are not friends with that user.
#[serde(rename = "homeLocation")]
pub home_location: String,
pub home_location: std::sync::Arc<str>,
/// A users unique ID, usually in the form of `usr_c1644b5b-3ca4-45b4-97c6-a2a0de70d469`. Legacy players can have old IDs in the form of `8JoV9XEdpo`. The ID can never be changed.
#[serde(rename = "id")]
pub id: String,
pub id: std::sync::Arc<str>,
#[serde(rename = "isBoopingEnabled", skip_serializing_if = "Option::is_none")]
pub is_booping_enabled: Option<bool>,
#[serde(rename = "isFriend")]
pub is_friend: bool,
#[serde(rename = "last_activity", skip_serializing_if = "Option::is_none")]
pub last_activity: Option<String>,
pub last_activity: Option<std::sync::Arc<str>>,
#[serde(rename = "last_login")]
pub last_login: String,
pub last_login: std::sync::Arc<str>,
#[serde(rename = "last_mobile", deserialize_with = "Option::deserialize")]
pub last_mobile: Option<String>,
pub last_mobile: Option<std::sync::Arc<str>>,
/// This can be `standalonewindows` or `android`, but can also pretty much be any random Unity verison such as `2019.2.4-801-Release` or `2019.2.2-772-Release` or even `unknownplatform`.
#[serde(rename = "last_platform")]
pub last_platform: String,
pub last_platform: std::sync::Arc<str>,
#[serde(rename = "obfuscatedEmail")]
pub obfuscated_email: String,
pub obfuscated_email: std::sync::Arc<str>,
#[serde(rename = "obfuscatedPendingEmail")]
pub obfuscated_pending_email: String,
pub obfuscated_pending_email: std::sync::Arc<str>,
#[serde(rename = "oculusId")]
pub oculus_id: String,
pub oculus_id: std::sync::Arc<str>,
#[serde(rename = "googleId", skip_serializing_if = "Option::is_none")]
pub google_id: Option<String>,
pub google_id: Option<std::sync::Arc<str>>,
#[serde(rename = "googleDetails", skip_serializing_if = "Option::is_none")]
pub google_details: Option<serde_json::Value>,
#[serde(rename = "picoId", skip_serializing_if = "Option::is_none")]
pub pico_id: Option<String>,
pub pico_id: Option<std::sync::Arc<str>>,
#[serde(rename = "viveId", skip_serializing_if = "Option::is_none")]
pub vive_id: Option<String>,
pub vive_id: Option<std::sync::Arc<str>>,
#[serde(rename = "offlineFriends", skip_serializing_if = "Option::is_none")]
pub offline_friends: Option<Vec<String>>,
pub offline_friends: Option<Vec<std::sync::Arc<str>>>,
#[serde(rename = "onlineFriends", skip_serializing_if = "Option::is_none")]
pub online_friends: Option<Vec<String>>,
pub online_friends: Option<Vec<std::sync::Arc<str>>>,
#[serde(rename = "pastDisplayNames")]
pub past_display_names: Vec<models::PastDisplayName>,
#[serde(rename = "presence", skip_serializing_if = "Option::is_none")]
pub presence: Option<Box<models::CurrentUserPresence>>,
#[serde(rename = "profilePicOverride")]
pub profile_pic_override: String,
pub profile_pic_override: std::sync::Arc<str>,
#[serde(rename = "profilePicOverrideThumbnail")]
pub profile_pic_override_thumbnail: String,
pub profile_pic_override_thumbnail: std::sync::Arc<str>,
#[serde(rename = "pronouns")]
pub pronouns: String,
pub pronouns: std::sync::Arc<str>,
#[serde(rename = "state")]
pub state: models::UserState,
#[serde(rename = "status")]
pub status: models::UserStatus,
#[serde(rename = "statusDescription")]
pub status_description: String,
pub status_description: std::sync::Arc<str>,
#[serde(rename = "statusFirstTime")]
pub status_first_time: bool,
#[serde(rename = "statusHistory")]
pub status_history: Vec<String>,
pub status_history: Vec<std::sync::Arc<str>>,
#[serde(rename = "steamDetails")]
pub steam_details: serde_json::Value,
#[serde(rename = "steamId")]
pub steam_id: String,
pub steam_id: std::sync::Arc<str>,
#[serde(rename = "tags")]
pub tags: Vec<String>,
pub tags: Vec<crate::models::tags::Tags>,
#[serde(rename = "twoFactorAuthEnabled")]
pub two_factor_auth_enabled: bool,
#[serde(rename = "twoFactorAuthEnabledDate", default, with = "::serde_with::rust::double_option", skip_serializing_if = "Option::is_none")]
pub two_factor_auth_enabled_date: Option<Option<String>>,
pub two_factor_auth_enabled_date: Option<Option<std::sync::Arc<str>>>,
#[serde(rename = "unsubscribe")]
pub unsubscribe: bool,
#[serde(rename = "updated_at", skip_serializing_if = "Option::is_none")]
pub updated_at: Option<String>,
pub updated_at: Option<std::sync::Arc<str>>,
#[serde(rename = "userIcon")]
pub user_icon: String,
pub user_icon: std::sync::Arc<str>,
/// -| **DEPRECATED:** VRChat API no longer return usernames of other users. [See issue by Tupper for more information](https://github.com/pypy-vrc/VRCX/issues/429).
#[serde(rename = "username", skip_serializing_if = "Option::is_none")]
pub username: Option<String>,
pub username: Option<std::sync::Arc<str>>,
}
impl CurrentUser {
pub fn new(accepted_tos_version: i32, allow_avatar_copying: bool, bio: String, bio_links: Vec<String>, current_avatar: String, current_avatar_asset_url: String, current_avatar_image_url: String, current_avatar_thumbnail_image_url: String, current_avatar_tags: Vec<String>, date_joined: String, developer_type: models::DeveloperType, display_name: String, email_verified: bool, friend_group_names: Vec<String>, friend_key: String, friends: Vec<String>, has_birthday: bool, has_email: bool, has_logged_in_from_client: bool, has_pending_email: bool, home_location: String, id: String, is_friend: bool, last_login: String, last_mobile: Option<String>, last_platform: String, obfuscated_email: String, obfuscated_pending_email: String, oculus_id: String, past_display_names: Vec<models::PastDisplayName>, profile_pic_override: String, profile_pic_override_thumbnail: String, pronouns: String, state: models::UserState, status: models::UserStatus, status_description: String, status_first_time: bool, status_history: Vec<String>, steam_details: serde_json::Value, steam_id: String, tags: Vec<String>, two_factor_auth_enabled: bool, unsubscribe: bool, user_icon: String) -> CurrentUser {
pub fn new(accepted_tos_version: i32, allow_avatar_copying: bool, bio: std::sync::Arc<str>, bio_links: Vec<std::sync::Arc<str>>, current_avatar: std::sync::Arc<str>, current_avatar_asset_url: std::sync::Arc<str>, current_avatar_image_url: std::sync::Arc<str>, current_avatar_thumbnail_image_url: std::sync::Arc<str>, current_avatar_tags: Vec<crate::models::tags::Tags>, date_joined: std::sync::Arc<str>, developer_type: models::DeveloperType, display_name: std::sync::Arc<str>, email_verified: bool, friend_group_names: Vec<std::sync::Arc<str>>, friend_key: std::sync::Arc<str>, friends: Vec<std::sync::Arc<str>>, has_birthday: bool, has_email: bool, has_logged_in_from_client: bool, has_pending_email: bool, home_location: std::sync::Arc<str>, id: std::sync::Arc<str>, is_friend: bool, last_login: std::sync::Arc<str>, last_mobile: Option<std::sync::Arc<str>>, last_platform: std::sync::Arc<str>, obfuscated_email: std::sync::Arc<str>, obfuscated_pending_email: std::sync::Arc<str>, oculus_id: std::sync::Arc<str>, past_display_names: Vec<models::PastDisplayName>, profile_pic_override: std::sync::Arc<str>, profile_pic_override_thumbnail: std::sync::Arc<str>, pronouns: std::sync::Arc<str>, state: models::UserState, status: models::UserStatus, status_description: std::sync::Arc<str>, status_first_time: bool, status_history: Vec<std::sync::Arc<str>>, steam_details: serde_json::Value, steam_id: std::sync::Arc<str>, tags: Vec<crate::models::tags::Tags>, two_factor_auth_enabled: bool, unsubscribe: bool, user_icon: std::sync::Arc<str>) -> CurrentUser {
CurrentUser {
accepted_tos_version,
accepted_privacy_version: None,
@ -229,8 +229,8 @@ pub enum EitherUserOrTwoFactor{
RequiresTwoFactorAuth(RequiresTwoFactorAuth),
}
#[derive(Clone, Debug, PartialEq, Eq, Default, Serialize, Deserialize)]
#[derive(Clone, Debug, PartialEq, Eq, Serialize, Deserialize)]
pub struct RequiresTwoFactorAuth{
#[serde(rename = "requiresTwoFactorAuth")]
pub requires_two_factor_auth: Vec<String>
pub requires_two_factor_auth: Vec<std::sync::Arc<str>>
}

28
src/models/current_user_presence.rs
View File

@ -9,40 +9,40 @@
use crate::models;
use serde::{Deserialize, Serialize};
#[derive(Clone, Default, Debug, PartialEq, Serialize, Deserialize)]
#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
pub struct CurrentUserPresence {
#[serde(rename = "avatarThumbnail", default, with = "::serde_with::rust::double_option", skip_serializing_if = "Option::is_none")]
pub avatar_thumbnail: Option<Option<String>>,
pub avatar_thumbnail: Option<Option<std::sync::Arc<str>>>,
#[serde(rename = "displayName", skip_serializing_if = "Option::is_none")]
pub display_name: Option<String>,
pub display_name: Option<std::sync::Arc<str>>,
#[serde(rename = "groups", default, with = "::serde_with::rust::double_option", skip_serializing_if = "Option::is_none")]
pub groups: Option<Option<Vec<String>>>,
pub groups: Option<Option<Vec<std::sync::Arc<str>>>>,
/// A users unique ID, usually in the form of `usr_c1644b5b-3ca4-45b4-97c6-a2a0de70d469`. Legacy players can have old IDs in the form of `8JoV9XEdpo`. The ID can never be changed.
#[serde(rename = "id", skip_serializing_if = "Option::is_none")]
pub id: Option<String>,
pub id: Option<std::sync::Arc<str>>,
#[serde(rename = "instance", default, with = "::serde_with::rust::double_option", skip_serializing_if = "Option::is_none")]
pub instance: Option<Option<String>>,
pub instance: Option<Option<std::sync::Arc<str>>>,
/// either an InstanceType or an empty string
#[serde(rename = "instanceType", default, with = "::serde_with::rust::double_option", skip_serializing_if = "Option::is_none")]
pub instance_type: Option<Option<String>>,
pub instance_type: Option<Option<std::sync::Arc<str>>>,
#[serde(rename = "isRejoining", default, with = "::serde_with::rust::double_option", skip_serializing_if = "Option::is_none")]
pub is_rejoining: Option<Option<String>>,
pub is_rejoining: Option<Option<std::sync::Arc<str>>>,
/// either a Platform or an empty string
#[serde(rename = "platform", default, with = "::serde_with::rust::double_option", skip_serializing_if = "Option::is_none")]
pub platform: Option<Option<String>>,
pub platform: Option<Option<std::sync::Arc<str>>>,
#[serde(rename = "profilePicOverride", default, with = "::serde_with::rust::double_option", skip_serializing_if = "Option::is_none")]
pub profile_pic_override: Option<Option<String>>,
pub profile_pic_override: Option<Option<std::sync::Arc<str>>>,
/// either a UserStatus or empty string
#[serde(rename = "status", default, with = "::serde_with::rust::double_option", skip_serializing_if = "Option::is_none")]
pub status: Option<Option<String>>,
pub status: Option<Option<std::sync::Arc<str>>>,
#[serde(rename = "travelingToInstance", default, with = "::serde_with::rust::double_option", skip_serializing_if = "Option::is_none")]
pub traveling_to_instance: Option<Option<String>>,
pub traveling_to_instance: Option<Option<std::sync::Arc<str>>>,
/// WorldID be \"offline\" on User profiles if you are not friends with that user.
#[serde(rename = "travelingToWorld", skip_serializing_if = "Option::is_none")]
pub traveling_to_world: Option<String>,
pub traveling_to_world: Option<std::sync::Arc<str>>,
/// WorldID be \"offline\" on User profiles if you are not friends with that user.
#[serde(rename = "world", skip_serializing_if = "Option::is_none")]
pub world: Option<String>,
pub world: Option<std::sync::Arc<str>>,
}
impl CurrentUserPresence {

18
src/models/dynamic_content_row.rs
View File

@ -9,31 +9,31 @@
use crate::models;
use serde::{Deserialize, Serialize};
#[derive(Clone, Default, Debug, PartialEq, Serialize, Deserialize)]
#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
pub struct DynamicContentRow {
#[serde(rename = "index", skip_serializing_if = "Option::is_none")]
pub index: Option<i32>,
#[serde(rename = "name")]
pub name: String,
pub name: std::sync::Arc<str>,
/// Usually \"ThisPlatformSupported\", but can also be other values such as \"all\" or platform specific identifiers.
#[serde(rename = "platform")]
pub platform: String,
pub platform: std::sync::Arc<str>,
#[serde(rename = "sortHeading")]
pub sort_heading: String,
pub sort_heading: std::sync::Arc<str>,
#[serde(rename = "sortOrder")]
pub sort_order: String,
pub sort_order: std::sync::Arc<str>,
#[serde(rename = "sortOwnership")]
pub sort_ownership: String,
pub sort_ownership: std::sync::Arc<str>,
/// Tag to filter content for this row.
#[serde(rename = "tag", skip_serializing_if = "Option::is_none")]
pub tag: Option<String>,
pub tag: Option<std::sync::Arc<str>>,
/// Type is not present if it is a world.
#[serde(rename = "type", skip_serializing_if = "Option::is_none")]
pub r#type: Option<String>,
pub r#type: Option<std::sync::Arc<str>>,
}
impl DynamicContentRow {
pub fn new(name: String, platform: String, sort_heading: String, sort_order: String, sort_ownership: String) -> DynamicContentRow {
pub fn new(name: std::sync::Arc<str>, platform: std::sync::Arc<str>, sort_heading: std::sync::Arc<str>, sort_order: std::sync::Arc<str>, sort_ownership: std::sync::Arc<str>) -> DynamicContentRow {
DynamicContentRow {
index: None,
name,

2
src/models/error.rs
View File

@ -9,7 +9,7 @@
use crate::models;
use serde::{Deserialize, Serialize};
#[derive(Clone, Default, Debug, PartialEq, Serialize, Deserialize)]
#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
pub struct Error {
#[serde(rename = "error", skip_serializing_if = "Option::is_none")]
pub error: Option<Box<models::Response>>,

10
src/models/favorite.rs
View File

@ -10,21 +10,21 @@ use crate::models;
use serde::{Deserialize, Serialize};
/// Favorite :
#[derive(Clone, Default, Debug, PartialEq, Serialize, Deserialize)]
#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
pub struct Favorite {
/// MUST be either AvatarID, UserID or WorldID.
#[serde(rename = "favoriteId")]
pub favorite_id: String,
pub favorite_id: std::sync::Arc<str>,
#[serde(rename = "id")]
pub id: String,
pub id: std::sync::Arc<str>,
#[serde(rename = "tags")]
pub tags: Vec<String>,
pub tags: Vec<crate::models::tags::Tags>,
#[serde(rename = "type")]
pub r#type: models::FavoriteType,
}
impl Favorite {
pub fn new(favorite_id: String, id: String, tags: Vec<String>, r#type: models::FavoriteType) -> Favorite {
pub fn new(favorite_id: std::sync::Arc<str>, id: std::sync::Arc<str>, tags: Vec<crate::models::tags::Tags>, r#type: models::FavoriteType) -> Favorite {
Favorite {
favorite_id,
id,

16
src/models/favorite_group.rs
View File

@ -10,21 +10,21 @@ use crate::models;
use serde::{Deserialize, Serialize};
/// FavoriteGroup :
#[derive(Clone, Default, Debug, PartialEq, Serialize, Deserialize)]
#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
pub struct FavoriteGroup {
#[serde(rename = "displayName")]
pub display_name: String,
pub display_name: std::sync::Arc<str>,
#[serde(rename = "id")]
pub id: String,
pub id: std::sync::Arc<str>,
#[serde(rename = "name")]
pub name: String,
pub name: std::sync::Arc<str>,
#[serde(rename = "ownerDisplayName")]
pub owner_display_name: String,
pub owner_display_name: std::sync::Arc<str>,
/// A users unique ID, usually in the form of `usr_c1644b5b-3ca4-45b4-97c6-a2a0de70d469`. Legacy players can have old IDs in the form of `8JoV9XEdpo`. The ID can never be changed.
#[serde(rename = "ownerId")]
pub owner_id: String,
pub owner_id: std::sync::Arc<str>,
#[serde(rename = "tags")]
pub tags: Vec<String>,
pub tags: Vec<crate::models::tags::Tags>,
#[serde(rename = "type")]
pub r#type: models::FavoriteType,
#[serde(rename = "visibility")]
@ -32,7 +32,7 @@ pub struct FavoriteGroup {
}
impl FavoriteGroup {
pub fn new(display_name: String, id: String, name: String, owner_display_name: String, owner_id: String, tags: Vec<String>, r#type: models::FavoriteType, visibility: models::FavoriteGroupVisibility) -> FavoriteGroup {
pub fn new(display_name: std::sync::Arc<str>, id: std::sync::Arc<str>, name: std::sync::Arc<str>, owner_display_name: std::sync::Arc<str>, owner_id: std::sync::Arc<str>, tags: Vec<crate::models::tags::Tags>, r#type: models::FavoriteType, visibility: models::FavoriteGroupVisibility) -> FavoriteGroup {
FavoriteGroup {
display_name,
id,

14
src/models/file.rs
View File

@ -10,27 +10,27 @@ use crate::models;
use serde::{Deserialize, Serialize};
/// File :
#[derive(Clone, Default, Debug, PartialEq, Serialize, Deserialize)]
#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
pub struct File {
#[serde(rename = "extension")]
pub extension: String,
pub extension: std::sync::Arc<str>,
#[serde(rename = "id")]
pub id: String,
pub id: std::sync::Arc<str>,
#[serde(rename = "mimeType")]
pub mime_type: models::MimeType,
#[serde(rename = "name")]
pub name: String,
pub name: std::sync::Arc<str>,
/// A users unique ID, usually in the form of `usr_c1644b5b-3ca4-45b4-97c6-a2a0de70d469`. Legacy players can have old IDs in the form of `8JoV9XEdpo`. The ID can never be changed.
#[serde(rename = "ownerId")]
pub owner_id: String,
pub owner_id: std::sync::Arc<str>,
#[serde(rename = "tags")]
pub tags: Vec<String>,
pub tags: Vec<crate::models::tags::Tags>,
#[serde(rename = "versions")]
pub versions: Vec<models::FileVersion>,
}
impl File {
pub fn new(extension: String, id: String, mime_type: models::MimeType, name: String, owner_id: String, tags: Vec<String>, versions: Vec<models::FileVersion>) -> File {
pub fn new(extension: std::sync::Arc<str>, id: std::sync::Arc<str>, mime_type: models::MimeType, name: std::sync::Arc<str>, owner_id: std::sync::Arc<str>, tags: Vec<crate::models::tags::Tags>, versions: Vec<models::FileVersion>) -> File {
File {
extension,
id,

12
src/models/file_data.rs
View File

@ -10,26 +10,26 @@ use crate::models;
use serde::{Deserialize, Serialize};
/// FileData :
#[derive(Clone, Default, Debug, PartialEq, Serialize, Deserialize)]
#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
pub struct FileData {
#[serde(rename = "category")]
pub category: Category,
#[serde(rename = "fileName")]
pub file_name: String,
pub file_name: std::sync::Arc<str>,
#[serde(rename = "md5", skip_serializing_if = "Option::is_none")]
pub md5: Option<String>,
pub md5: Option<std::sync::Arc<str>>,
#[serde(rename = "sizeInBytes")]
pub size_in_bytes: i32,
#[serde(rename = "status")]
pub status: models::FileStatus,
#[serde(rename = "uploadId")]
pub upload_id: String,
pub upload_id: std::sync::Arc<str>,
#[serde(rename = "url")]
pub url: String,
pub url: std::sync::Arc<str>,
}
impl FileData {
pub fn new(category: Category, file_name: String, size_in_bytes: i32, status: models::FileStatus, upload_id: String, url: String) -> FileData {
pub fn new(category: Category, file_name: std::sync::Arc<str>, size_in_bytes: i32, status: models::FileStatus, upload_id: std::sync::Arc<str>, url: std::sync::Arc<str>) -> FileData {
FileData {
category,
file_name,

6
src/models/file_upload_url.rs
View File

@ -10,14 +10,14 @@ use crate::models;
use serde::{Deserialize, Serialize};
/// FileUploadUrl :
#[derive(Clone, Default, Debug, PartialEq, Serialize, Deserialize)]
#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
pub struct FileUploadUrl {
#[serde(rename = "url")]
pub url: String,
pub url: std::sync::Arc<str>,
}
impl FileUploadUrl {
pub fn new(url: String) -> FileUploadUrl {
pub fn new(url: std::sync::Arc<str>) -> FileUploadUrl {
FileUploadUrl {
url,
}

6
src/models/file_version.rs
View File

@ -10,10 +10,10 @@ use crate::models;
use serde::{Deserialize, Serialize};
/// FileVersion :
#[derive(Clone, Default, Debug, PartialEq, Serialize, Deserialize)]
#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
pub struct FileVersion {
#[serde(rename = "created_at")]
pub created_at: String,
pub created_at: std::sync::Arc<str>,
/// Usually only present if `true`
#[serde(rename = "deleted", skip_serializing_if = "Option::is_none")]
pub deleted: Option<bool>,
@ -31,7 +31,7 @@ pub struct FileVersion {
}
impl FileVersion {
pub fn new(created_at: String, status: models::FileStatus, version: i32) -> FileVersion {
pub fn new(created_at: std::sync::Arc<str>, status: models::FileStatus, version: i32) -> FileVersion {
FileVersion {
created_at,
deleted: None,

8
src/models/file_version_upload_status.rs
View File

@ -10,12 +10,12 @@ use crate::models;
use serde::{Deserialize, Serialize};
/// FileVersionUploadStatus :
#[derive(Clone, Default, Debug, PartialEq, Serialize, Deserialize)]
#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
pub struct FileVersionUploadStatus {
#[serde(rename = "uploadId")]
pub upload_id: String,
pub upload_id: std::sync::Arc<str>,
#[serde(rename = "fileName")]
pub file_name: String,
pub file_name: std::sync::Arc<str>,
#[serde(rename = "nextPartNumber")]
pub next_part_number: f64,
#[serde(rename = "maxParts")]
@ -28,7 +28,7 @@ pub struct FileVersionUploadStatus {
}
impl FileVersionUploadStatus {
pub fn new(upload_id: String, file_name: String, next_part_number: f64, max_parts: f64, parts: Vec<serde_json::Value>, etags: Vec<serde_json::Value>) -> FileVersionUploadStatus {
pub fn new(upload_id: std::sync::Arc<str>, file_name: std::sync::Arc<str>, next_part_number: f64, max_parts: f64, parts: Vec<serde_json::Value>, etags: Vec<serde_json::Value>) -> FileVersionUploadStatus {
FileVersionUploadStatus {
upload_id,
file_name,

10
src/models/finish_file_data_upload_request.rs
View File

@ -10,21 +10,21 @@ use crate::models;
use serde::{Deserialize, Serialize};
/// FinishFileDataUploadRequest :
#[derive(Clone, Default, Debug, PartialEq, Serialize, Deserialize)]
#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
pub struct FinishFileDataUploadRequest {
/// Array of ETags uploaded.
#[serde(rename = "etags", skip_serializing_if = "Option::is_none")]
pub etags: Option<Vec<String>>,
pub etags: Option<Vec<std::sync::Arc<str>>>,
/// Always a zero in string form, despite how many parts uploaded.
#[serde(rename = "nextPartNumber")]
pub next_part_number: String,
pub next_part_number: std::sync::Arc<str>,
/// Always a zero in string form, despite how many parts uploaded.
#[serde(rename = "maxParts")]
pub max_parts: String,
pub max_parts: std::sync::Arc<str>,
}
impl FinishFileDataUploadRequest {
pub fn new(next_part_number: String, max_parts: String) -> FinishFileDataUploadRequest {
pub fn new(next_part_number: std::sync::Arc<str>, max_parts: std::sync::Arc<str>) -> FinishFileDataUploadRequest {
FinishFileDataUploadRequest {
etags: None,
next_part_number,

2
src/models/friend_status.rs
View File

@ -9,7 +9,7 @@
use crate::models;
use serde::{Deserialize, Serialize};
#[derive(Clone, Default, Debug, PartialEq, Serialize, Deserialize)]
#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
pub struct FriendStatus {
#[serde(rename = "incomingRequest")]
pub incoming_request: bool,

42
src/models/group.rs
View File

@ -9,58 +9,58 @@
use crate::models;
use serde::{Deserialize, Serialize};
#[derive(Clone, Default, Debug, PartialEq, Serialize, Deserialize)]
#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
pub struct Group {
#[serde(rename = "id", skip_serializing_if = "Option::is_none")]
pub id: Option<String>,
pub id: Option<std::sync::Arc<str>>,
#[serde(rename = "name", skip_serializing_if = "Option::is_none")]
pub name: Option<String>,
pub name: Option<std::sync::Arc<str>>,
#[serde(rename = "shortCode", skip_serializing_if = "Option::is_none")]
pub short_code: Option<String>,
pub short_code: Option<std::sync::Arc<str>>,
#[serde(rename = "discriminator", skip_serializing_if = "Option::is_none")]
pub discriminator: Option<String>,
pub discriminator: Option<std::sync::Arc<str>>,
#[serde(rename = "description", skip_serializing_if = "Option::is_none")]
pub description: Option<String>,
pub description: Option<std::sync::Arc<str>>,
#[serde(rename = "iconUrl", default, with = "::serde_with::rust::double_option", skip_serializing_if = "Option::is_none")]
pub icon_url: Option<Option<String>>,
pub icon_url: Option<Option<std::sync::Arc<str>>>,
#[serde(rename = "bannerUrl", default, with = "::serde_with::rust::double_option", skip_serializing_if = "Option::is_none")]
pub banner_url: Option<Option<String>>,
pub banner_url: Option<Option<std::sync::Arc<str>>>,
#[serde(rename = "privacy", skip_serializing_if = "Option::is_none")]
pub privacy: Option<models::GroupPrivacy>,
/// A users unique ID, usually in the form of `usr_c1644b5b-3ca4-45b4-97c6-a2a0de70d469`. Legacy players can have old IDs in the form of `8JoV9XEdpo`. The ID can never be changed.
#[serde(rename = "ownerId", skip_serializing_if = "Option::is_none")]
pub owner_id: Option<String>,
pub owner_id: Option<std::sync::Arc<str>>,
#[serde(rename = "rules", default, with = "::serde_with::rust::double_option", skip_serializing_if = "Option::is_none")]
pub rules: Option<Option<String>>,
pub rules: Option<Option<std::sync::Arc<str>>>,
#[serde(rename = "links", skip_serializing_if = "Option::is_none")]
pub links: Option<Vec<String>>,
pub links: Option<Vec<std::sync::Arc<str>>>,
#[serde(rename = "languages", skip_serializing_if = "Option::is_none")]
pub languages: Option<Vec<String>>,
pub languages: Option<Vec<std::sync::Arc<str>>>,
#[serde(rename = "iconId", default, with = "::serde_with::rust::double_option", skip_serializing_if = "Option::is_none")]
pub icon_id: Option<Option<String>>,
pub icon_id: Option<Option<std::sync::Arc<str>>>,
#[serde(rename = "bannerId", default, with = "::serde_with::rust::double_option", skip_serializing_if = "Option::is_none")]
pub banner_id: Option<Option<String>>,
pub banner_id: Option<Option<std::sync::Arc<str>>>,
#[serde(rename = "memberCount", skip_serializing_if = "Option::is_none")]
pub member_count: Option<i32>,
#[serde(rename = "memberCountSyncedAt", skip_serializing_if = "Option::is_none")]
pub member_count_synced_at: Option<String>,
pub member_count_synced_at: Option<std::sync::Arc<str>>,
#[serde(rename = "isVerified", skip_serializing_if = "Option::is_none")]
pub is_verified: Option<bool>,
#[serde(rename = "joinState", skip_serializing_if = "Option::is_none")]
pub join_state: Option<models::GroupJoinState>,
#[serde(rename = "tags", skip_serializing_if = "Option::is_none")]
pub tags: Option<Vec<String>>,
pub tags: Option<Vec<std::sync::Arc<str>>>,
/// A users unique ID, usually in the form of `usr_c1644b5b-3ca4-45b4-97c6-a2a0de70d469`. Legacy players can have old IDs in the form of `8JoV9XEdpo`. The ID can never be changed.
#[serde(rename = "transferTargetId", skip_serializing_if = "Option::is_none")]
pub transfer_target_id: Option<String>,
pub transfer_target_id: Option<std::sync::Arc<str>>,
#[serde(rename = "galleries", skip_serializing_if = "Option::is_none")]
pub galleries: Option<Vec<models::GroupGallery>>,
#[serde(rename = "createdAt", skip_serializing_if = "Option::is_none")]
pub created_at: Option<String>,
pub created_at: Option<std::sync::Arc<str>>,
#[serde(rename = "updatedAt", skip_serializing_if = "Option::is_none")]
pub updated_at: Option<String>,
#[serde(rename = "lastPostCreatedAt", skip_serializing_if = "Option::is_none")]
pub last_post_created_at: Option<String>,
pub updated_at: Option<std::sync::Arc<str>>,
#[serde(rename = "lastPostCreatedAt", default, with = "::serde_with::rust::double_option", skip_serializing_if = "Option::is_none")]
pub last_post_created_at: Option<Option<std::sync::Arc<str>>>,
#[serde(rename = "onlineMemberCount", skip_serializing_if = "Option::is_none")]
pub online_member_count: Option<i32>,
#[serde(rename = "membershipStatus", skip_serializing_if = "Option::is_none")]

20
src/models/group_announcement.rs
View File

@ -9,27 +9,27 @@
use crate::models;
use serde::{Deserialize, Serialize};
#[derive(Clone, Default, Debug, PartialEq, Serialize, Deserialize)]
#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
pub struct GroupAnnouncement {
#[serde(rename = "id", skip_serializing_if = "Option::is_none")]
pub id: Option<String>,
pub id: Option<std::sync::Arc<str>>,
#[serde(rename = "groupId", skip_serializing_if = "Option::is_none")]
pub group_id: Option<String>,
pub group_id: Option<std::sync::Arc<str>>,
/// A users unique ID, usually in the form of `usr_c1644b5b-3ca4-45b4-97c6-a2a0de70d469`. Legacy players can have old IDs in the form of `8JoV9XEdpo`. The ID can never be changed.
#[serde(rename = "authorId", skip_serializing_if = "Option::is_none")]
pub author_id: Option<String>,
pub author_id: Option<std::sync::Arc<str>>,
#[serde(rename = "title", default, with = "::serde_with::rust::double_option", skip_serializing_if = "Option::is_none")]
pub title: Option<Option<String>>,
pub title: Option<Option<std::sync::Arc<str>>>,
#[serde(rename = "text", default, with = "::serde_with::rust::double_option", skip_serializing_if = "Option::is_none")]
pub text: Option<Option<String>>,
pub text: Option<Option<std::sync::Arc<str>>>,
#[serde(rename = "imageId", skip_serializing_if = "Option::is_none")]
pub image_id: Option<String>,
pub image_id: Option<std::sync::Arc<str>>,
#[serde(rename = "imageUrl", default, with = "::serde_with::rust::double_option", skip_serializing_if = "Option::is_none")]
pub image_url: Option<Option<String>>,
pub image_url: Option<Option<std::sync::Arc<str>>>,
#[serde(rename = "createdAt", default, with = "::serde_with::rust::double_option", skip_serializing_if = "Option::is_none")]
pub created_at: Option<Option<String>>,
pub created_at: Option<Option<std::sync::Arc<str>>>,
#[serde(rename = "updatedAt", default, with = "::serde_with::rust::double_option", skip_serializing_if = "Option::is_none")]
pub updated_at: Option<Option<String>>,
pub updated_at: Option<Option<std::sync::Arc<str>>>,
}
impl GroupAnnouncement {

18
src/models/group_audit_log_entry.rs
View File

@ -9,28 +9,28 @@
use crate::models;
use serde::{Deserialize, Serialize};
#[derive(Clone, Default, Debug, PartialEq, Serialize, Deserialize)]
#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
pub struct GroupAuditLogEntry {
#[serde(rename = "id", skip_serializing_if = "Option::is_none")]
pub id: Option<String>,
pub id: Option<std::sync::Arc<str>>,
#[serde(rename = "created_at", skip_serializing_if = "Option::is_none")]
pub created_at: Option<String>,
pub created_at: Option<std::sync::Arc<str>>,
#[serde(rename = "groupId", skip_serializing_if = "Option::is_none")]
pub group_id: Option<String>,
pub group_id: Option<std::sync::Arc<str>>,
/// A users unique ID, usually in the form of `usr_c1644b5b-3ca4-45b4-97c6-a2a0de70d469`. Legacy players can have old IDs in the form of `8JoV9XEdpo`. The ID can never be changed.
#[serde(rename = "actorId", skip_serializing_if = "Option::is_none")]
pub actor_id: Option<String>,
pub actor_id: Option<std::sync::Arc<str>>,
#[serde(rename = "actorDisplayName", skip_serializing_if = "Option::is_none")]
pub actor_display_name: Option<String>,
pub actor_display_name: Option<std::sync::Arc<str>>,
/// Typically GroupID or GroupRoleID, but could be other types of IDs.
#[serde(rename = "targetId", skip_serializing_if = "Option::is_none")]
pub target_id: Option<String>,
pub target_id: Option<std::sync::Arc<str>>,
/// The type of event that occurred. This is a string that is prefixed with the type of object that the event occurred on. For example, a group role update event would be prefixed with `group.role`.
#[serde(rename = "eventType", skip_serializing_if = "Option::is_none")]
pub event_type: Option<String>,
pub event_type: Option<std::sync::Arc<str>>,
/// A human-readable description of the event.
#[serde(rename = "description", skip_serializing_if = "Option::is_none")]
pub description: Option<String>,
pub description: Option<std::sync::Arc<str>>,
/// The data associated with the event. The format of this data is dependent on the event type.
#[serde(rename = "data", skip_serializing_if = "Option::is_none")]
pub data: Option<serde_json::Value>,

20
src/models/group_gallery.rs
View File

@ -9,31 +9,31 @@
use crate::models;
use serde::{Deserialize, Serialize};
#[derive(Clone, Default, Debug, PartialEq, Serialize, Deserialize)]
#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
pub struct GroupGallery {
#[serde(rename = "id", skip_serializing_if = "Option::is_none")]
pub id: Option<String>,
pub id: Option<std::sync::Arc<str>>,
/// Name of the gallery.
#[serde(rename = "name", skip_serializing_if = "Option::is_none")]
pub name: Option<String>,
pub name: Option<std::sync::Arc<str>>,
/// Description of the gallery.
#[serde(rename = "description", skip_serializing_if = "Option::is_none")]
pub description: Option<String>,
pub description: Option<std::sync::Arc<str>>,
/// Whether the gallery is members only.
#[serde(rename = "membersOnly", skip_serializing_if = "Option::is_none")]
pub members_only: Option<bool>,
#[serde(rename = "roleIdsToView", default, with = "::serde_with::rust::double_option", skip_serializing_if = "Option::is_none")]
pub role_ids_to_view: Option<Option<Vec<String>>>,
pub role_ids_to_view: Option<Option<Vec<std::sync::Arc<str>>>>,
#[serde(rename = "roleIdsToSubmit", default, with = "::serde_with::rust::double_option", skip_serializing_if = "Option::is_none")]
pub role_ids_to_submit: Option<Option<Vec<String>>>,
pub role_ids_to_submit: Option<Option<Vec<std::sync::Arc<str>>>>,
#[serde(rename = "roleIdsToAutoApprove", default, with = "::serde_with::rust::double_option", skip_serializing_if = "Option::is_none")]
pub role_ids_to_auto_approve: Option<Option<Vec<String>>>,
pub role_ids_to_auto_approve: Option<Option<Vec<std::sync::Arc<str>>>>,
#[serde(rename = "roleIdsToManage", default, with = "::serde_with::rust::double_option", skip_serializing_if = "Option::is_none")]
pub role_ids_to_manage: Option<Option<Vec<String>>>,
pub role_ids_to_manage: Option<Option<Vec<std::sync::Arc<str>>>>,
#[serde(rename = "createdAt", skip_serializing_if = "Option::is_none")]
pub created_at: Option<String>,
pub created_at: Option<std::sync::Arc<str>>,
#[serde(rename = "updatedAt", skip_serializing_if = "Option::is_none")]
pub updated_at: Option<String>,
pub updated_at: Option<std::sync::Arc<str>>,
}
impl GroupGallery {

20
src/models/group_gallery_image.rs
View File

@ -9,30 +9,30 @@
use crate::models;
use serde::{Deserialize, Serialize};
#[derive(Clone, Default, Debug, PartialEq, Serialize, Deserialize)]
#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
pub struct GroupGalleryImage {
#[serde(rename = "id", skip_serializing_if = "Option::is_none")]
pub id: Option<String>,
pub id: Option<std::sync::Arc<str>>,
#[serde(rename = "groupId", skip_serializing_if = "Option::is_none")]
pub group_id: Option<String>,
pub group_id: Option<std::sync::Arc<str>>,
#[serde(rename = "galleryId", skip_serializing_if = "Option::is_none")]
pub gallery_id: Option<String>,
pub gallery_id: Option<std::sync::Arc<str>>,
#[serde(rename = "fileId", skip_serializing_if = "Option::is_none")]
pub file_id: Option<String>,
pub file_id: Option<std::sync::Arc<str>>,
#[serde(rename = "imageUrl", skip_serializing_if = "Option::is_none")]
pub image_url: Option<String>,
pub image_url: Option<std::sync::Arc<str>>,
#[serde(rename = "createdAt", skip_serializing_if = "Option::is_none")]
pub created_at: Option<String>,
pub created_at: Option<std::sync::Arc<str>>,
/// A users unique ID, usually in the form of `usr_c1644b5b-3ca4-45b4-97c6-a2a0de70d469`. Legacy players can have old IDs in the form of `8JoV9XEdpo`. The ID can never be changed.
#[serde(rename = "submittedByUserId", skip_serializing_if = "Option::is_none")]
pub submitted_by_user_id: Option<String>,
pub submitted_by_user_id: Option<std::sync::Arc<str>>,
#[serde(rename = "approved", skip_serializing_if = "Option::is_none")]
pub approved: Option<bool>,
/// A users unique ID, usually in the form of `usr_c1644b5b-3ca4-45b4-97c6-a2a0de70d469`. Legacy players can have old IDs in the form of `8JoV9XEdpo`. The ID can never be changed.
#[serde(rename = "approvedByUserId", skip_serializing_if = "Option::is_none")]
pub approved_by_user_id: Option<String>,
pub approved_by_user_id: Option<std::sync::Arc<str>>,
#[serde(rename = "approvedAt", skip_serializing_if = "Option::is_none")]
pub approved_at: Option<String>,
pub approved_at: Option<std::sync::Arc<str>>,
}
impl GroupGalleryImage {

8
src/models/group_instance.rs
View File

@ -9,13 +9,13 @@
use crate::models;
use serde::{Deserialize, Serialize};
#[derive(Clone, Default, Debug, PartialEq, Serialize, Deserialize)]
#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
pub struct GroupInstance {
#[serde(rename = "instanceId")]
pub instance_id: String,
pub instance_id: std::sync::Arc<str>,
/// InstanceID can be \"offline\" on User profiles if you are not friends with that user and \"private\" if you are friends and user is in private instance.
#[serde(rename = "location")]
pub location: String,
pub location: std::sync::Arc<str>,
#[serde(rename = "world")]
pub world: Box<models::World>,
#[serde(rename = "memberCount")]
@ -23,7 +23,7 @@ pub struct GroupInstance {
}
impl GroupInstance {
pub fn new(instance_id: String, location: String, world: models::World, member_count: i32) -> GroupInstance {
pub fn new(instance_id: std::sync::Arc<str>, location: std::sync::Arc<str>, world: models::World, member_count: i32) -> GroupInstance {
GroupInstance {
instance_id,
location,

24
src/models/group_limited_member.rs
View File

@ -9,41 +9,41 @@
use crate::models;
use serde::{Deserialize, Serialize};
#[derive(Clone, Default, Debug, PartialEq, Serialize, Deserialize)]
#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
pub struct GroupLimitedMember {
#[serde(rename = "id", skip_serializing_if = "Option::is_none")]
pub id: Option<String>,
pub id: Option<std::sync::Arc<str>>,
#[serde(rename = "groupId", skip_serializing_if = "Option::is_none")]
pub group_id: Option<String>,
pub group_id: Option<std::sync::Arc<str>>,
/// A users unique ID, usually in the form of `usr_c1644b5b-3ca4-45b4-97c6-a2a0de70d469`. Legacy players can have old IDs in the form of `8JoV9XEdpo`. The ID can never be changed.
#[serde(rename = "userId", skip_serializing_if = "Option::is_none")]
pub user_id: Option<String>,
pub user_id: Option<std::sync::Arc<str>>,
/// Whether the user is representing the group. This makes the group show up above the name tag in-game.
#[serde(rename = "isRepresenting", skip_serializing_if = "Option::is_none")]
pub is_representing: Option<bool>,
#[serde(rename = "roleIds", skip_serializing_if = "Option::is_none")]
pub role_ids: Option<Vec<String>>,
pub role_ids: Option<Vec<std::sync::Arc<str>>>,
#[serde(rename = "mRoleIds", skip_serializing_if = "Option::is_none")]
pub m_role_ids: Option<Vec<String>>,
pub m_role_ids: Option<Vec<std::sync::Arc<str>>>,
#[serde(rename = "joinedAt", default, with = "::serde_with::rust::double_option", skip_serializing_if = "Option::is_none")]
pub joined_at: Option<Option<String>>,
pub joined_at: Option<Option<std::sync::Arc<str>>>,
#[serde(rename = "membershipStatus", skip_serializing_if = "Option::is_none")]
pub membership_status: Option<models::GroupMemberStatus>,
#[serde(rename = "visibility", skip_serializing_if = "Option::is_none")]
pub visibility: Option<String>,
pub visibility: Option<std::sync::Arc<str>>,
#[serde(rename = "isSubscribedToAnnouncements", skip_serializing_if = "Option::is_none")]
pub is_subscribed_to_announcements: Option<bool>,
/// Only visible via the /groups/:groupId/members endpoint, **not** when fetching a specific user.
#[serde(rename = "createdAt", default, with = "::serde_with::rust::double_option", skip_serializing_if = "Option::is_none")]
pub created_at: Option<Option<String>>,
pub created_at: Option<Option<std::sync::Arc<str>>>,
/// Only visible via the /groups/:groupId/members endpoint, **not** when fetching a specific user.
#[serde(rename = "bannedAt", default, with = "::serde_with::rust::double_option", skip_serializing_if = "Option::is_none")]
pub banned_at: Option<Option<String>>,
pub banned_at: Option<Option<std::sync::Arc<str>>>,
/// Only visible via the /groups/:groupId/members endpoint, **not** when fetching a specific user.
#[serde(rename = "managerNotes", default, with = "::serde_with::rust::double_option", skip_serializing_if = "Option::is_none")]
pub manager_notes: Option<Option<String>>,
pub manager_notes: Option<Option<std::sync::Arc<str>>>,
#[serde(rename = "lastPostReadAt", default, with = "::serde_with::rust::double_option", skip_serializing_if = "Option::is_none")]
pub last_post_read_at: Option<Option<String>>,
pub last_post_read_at: Option<Option<std::sync::Arc<str>>>,
#[serde(rename = "hasJoinedFromPurchase", skip_serializing_if = "Option::is_none")]
pub has_joined_from_purchase: Option<bool>,
}

24
src/models/group_member.rs
View File

@ -9,43 +9,43 @@
use crate::models;
use serde::{Deserialize, Serialize};
#[derive(Clone, Default, Debug, PartialEq, Serialize, Deserialize)]
#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
pub struct GroupMember {
#[serde(rename = "id", skip_serializing_if = "Option::is_none")]
pub id: Option<String>,
pub id: Option<std::sync::Arc<str>>,
#[serde(rename = "groupId", skip_serializing_if = "Option::is_none")]
pub group_id: Option<String>,
pub group_id: Option<std::sync::Arc<str>>,
/// A users unique ID, usually in the form of `usr_c1644b5b-3ca4-45b4-97c6-a2a0de70d469`. Legacy players can have old IDs in the form of `8JoV9XEdpo`. The ID can never be changed.
#[serde(rename = "userId", skip_serializing_if = "Option::is_none")]
pub user_id: Option<String>,
pub user_id: Option<std::sync::Arc<str>>,
/// Whether the user is representing the group. This makes the group show up above the name tag in-game.
#[serde(rename = "isRepresenting", skip_serializing_if = "Option::is_none")]
pub is_representing: Option<bool>,
#[serde(rename = "user", skip_serializing_if = "Option::is_none")]
pub user: Option<Box<models::GroupMemberLimitedUser>>,
#[serde(rename = "roleIds", skip_serializing_if = "Option::is_none")]
pub role_ids: Option<Vec<String>>,
pub role_ids: Option<Vec<std::sync::Arc<str>>>,
#[serde(rename = "mRoleIds", skip_serializing_if = "Option::is_none")]
pub m_role_ids: Option<Vec<String>>,
pub m_role_ids: Option<Vec<std::sync::Arc<str>>>,
#[serde(rename = "joinedAt", default, with = "::serde_with::rust::double_option", skip_serializing_if = "Option::is_none")]
pub joined_at: Option<Option<String>>,
pub joined_at: Option<Option<std::sync::Arc<str>>>,
#[serde(rename = "membershipStatus", skip_serializing_if = "Option::is_none")]
pub membership_status: Option<models::GroupMemberStatus>,
#[serde(rename = "visibility", skip_serializing_if = "Option::is_none")]
pub visibility: Option<String>,
pub visibility: Option<std::sync::Arc<str>>,
#[serde(rename = "isSubscribedToAnnouncements", skip_serializing_if = "Option::is_none")]
pub is_subscribed_to_announcements: Option<bool>,
/// Only visible via the /groups/:groupId/members endpoint, **not** when fetching a specific user.
#[serde(rename = "createdAt", default, with = "::serde_with::rust::double_option", skip_serializing_if = "Option::is_none")]
pub created_at: Option<Option<String>>,
pub created_at: Option<Option<std::sync::Arc<str>>>,
/// Only visible via the /groups/:groupId/members endpoint, **not** when fetching a specific user.
#[serde(rename = "bannedAt", default, with = "::serde_with::rust::double_option", skip_serializing_if = "Option::is_none")]
pub banned_at: Option<Option<String>>,
pub banned_at: Option<Option<std::sync::Arc<str>>>,
/// Only visible via the /groups/:groupId/members endpoint, **not** when fetching a specific user.
#[serde(rename = "managerNotes", default, with = "::serde_with::rust::double_option", skip_serializing_if = "Option::is_none")]
pub manager_notes: Option<Option<String>>,
pub manager_notes: Option<Option<std::sync::Arc<str>>>,
#[serde(rename = "lastPostReadAt", default, with = "::serde_with::rust::double_option", skip_serializing_if = "Option::is_none")]
pub last_post_read_at: Option<Option<String>>,
pub last_post_read_at: Option<Option<std::sync::Arc<str>>>,
#[serde(rename = "hasJoinedFromPurchase", skip_serializing_if = "Option::is_none")]
pub has_joined_from_purchase: Option<bool>,
}

16
src/models/group_member_limited_user.rs
View File

@ -10,23 +10,23 @@ use crate::models;
use serde::{Deserialize, Serialize};
/// GroupMemberLimitedUser : Only visible via the /groups/:groupId/members endpoint, **not** when fetching a specific user.
#[derive(Clone, Default, Debug, PartialEq, Serialize, Deserialize)]
#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
pub struct GroupMemberLimitedUser {
/// A users unique ID, usually in the form of `usr_c1644b5b-3ca4-45b4-97c6-a2a0de70d469`. Legacy players can have old IDs in the form of `8JoV9XEdpo`. The ID can never be changed.
#[serde(rename = "id", skip_serializing_if = "Option::is_none")]
pub id: Option<String>,
pub id: Option<std::sync::Arc<str>>,
#[serde(rename = "displayName", skip_serializing_if = "Option::is_none")]
pub display_name: Option<String>,
pub display_name: Option<std::sync::Arc<str>>,
#[serde(rename = "thumbnailUrl", default, with = "::serde_with::rust::double_option", skip_serializing_if = "Option::is_none")]
pub thumbnail_url: Option<Option<String>>,
pub thumbnail_url: Option<Option<std::sync::Arc<str>>>,
#[serde(rename = "iconUrl", skip_serializing_if = "Option::is_none")]
pub icon_url: Option<String>,
pub icon_url: Option<std::sync::Arc<str>>,
#[serde(rename = "profilePicOverride", skip_serializing_if = "Option::is_none")]
pub profile_pic_override: Option<String>,
pub profile_pic_override: Option<std::sync::Arc<str>>,
#[serde(rename = "currentAvatarThumbnailImageUrl", default, with = "::serde_with::rust::double_option", skip_serializing_if = "Option::is_none")]
pub current_avatar_thumbnail_image_url: Option<Option<String>>,
pub current_avatar_thumbnail_image_url: Option<Option<std::sync::Arc<str>>>,
#[serde(rename = "currentAvatarTags", skip_serializing_if = "Option::is_none")]
pub current_avatar_tags: Option<Vec<String>>,
pub current_avatar_tags: Option<Vec<std::sync::Arc<str>>>,
}
impl GroupMemberLimitedUser {

36
src/models/group_my_member.rs
View File

@ -9,48 +9,48 @@
use crate::models;
use serde::{Deserialize, Serialize};
#[derive(Clone, Default, Debug, PartialEq, Serialize, Deserialize)]
#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
pub struct GroupMyMember {
#[serde(rename = "id", skip_serializing_if = "Option::is_none")]
pub id: Option<String>,
pub id: Option<std::sync::Arc<str>>,
#[serde(rename = "groupId", skip_serializing_if = "Option::is_none")]
pub group_id: Option<String>,
pub group_id: Option<std::sync::Arc<str>>,
/// A users unique ID, usually in the form of `usr_c1644b5b-3ca4-45b4-97c6-a2a0de70d469`. Legacy players can have old IDs in the form of `8JoV9XEdpo`. The ID can never be changed.
#[serde(rename = "userId", skip_serializing_if = "Option::is_none")]
pub user_id: Option<String>,
pub user_id: Option<std::sync::Arc<str>>,
#[serde(rename = "roleIds", skip_serializing_if = "Option::is_none")]
pub role_ids: Option<Vec<String>>,
#[serde(rename = "acceptedByDisplayName", skip_serializing_if = "Option::is_none")]
pub accepted_by_display_name: Option<String>,
pub role_ids: Option<Vec<std::sync::Arc<str>>>,
#[serde(rename = "acceptedByDisplayName", default, with = "::serde_with::rust::double_option", skip_serializing_if = "Option::is_none")]
pub accepted_by_display_name: Option<Option<std::sync::Arc<str>>>,
/// A users unique ID, usually in the form of `usr_c1644b5b-3ca4-45b4-97c6-a2a0de70d469`. Legacy players can have old IDs in the form of `8JoV9XEdpo`. The ID can never be changed.
#[serde(rename = "acceptedById", skip_serializing_if = "Option::is_none")]
pub accepted_by_id: Option<String>,
pub accepted_by_id: Option<std::sync::Arc<str>>,
#[serde(rename = "createdAt", skip_serializing_if = "Option::is_none")]
pub created_at: Option<String>,
pub created_at: Option<std::sync::Arc<str>>,
#[serde(rename = "managerNotes", skip_serializing_if = "Option::is_none")]
pub manager_notes: Option<String>,
pub manager_notes: Option<std::sync::Arc<str>>,
#[serde(rename = "membershipStatus", skip_serializing_if = "Option::is_none")]
pub membership_status: Option<String>,
pub membership_status: Option<std::sync::Arc<str>>,
#[serde(rename = "isSubscribedToAnnouncements", skip_serializing_if = "Option::is_none")]
pub is_subscribed_to_announcements: Option<bool>,
#[serde(rename = "visibility", skip_serializing_if = "Option::is_none")]
pub visibility: Option<String>,
pub visibility: Option<std::sync::Arc<str>>,
#[serde(rename = "isRepresenting", skip_serializing_if = "Option::is_none")]
pub is_representing: Option<bool>,
#[serde(rename = "joinedAt", skip_serializing_if = "Option::is_none")]
pub joined_at: Option<String>,
pub joined_at: Option<std::sync::Arc<str>>,
#[serde(rename = "bannedAt", default, with = "::serde_with::rust::double_option", skip_serializing_if = "Option::is_none")]
pub banned_at: Option<Option<String>>,
pub banned_at: Option<Option<std::sync::Arc<str>>>,
#[serde(rename = "has2FA", skip_serializing_if = "Option::is_none")]
pub has2_fa: Option<bool>,
#[serde(rename = "hasJoinedFromPurchase", skip_serializing_if = "Option::is_none")]
pub has_joined_from_purchase: Option<bool>,
#[serde(rename = "lastPostReadAt", skip_serializing_if = "Option::is_none")]
pub last_post_read_at: Option<String>,
#[serde(rename = "lastPostReadAt", default, with = "::serde_with::rust::double_option", skip_serializing_if = "Option::is_none")]
pub last_post_read_at: Option<Option<std::sync::Arc<str>>>,
#[serde(rename = "mRoleIds", skip_serializing_if = "Option::is_none")]
pub m_role_ids: Option<Vec<String>>,
pub m_role_ids: Option<Vec<std::sync::Arc<str>>>,
#[serde(rename = "permissions", skip_serializing_if = "Option::is_none")]
pub permissions: Option<Vec<String>>,
pub permissions: Option<Vec<std::sync::Arc<str>>>,
}
impl GroupMyMember {

8
src/models/group_permission.rs
View File

@ -10,17 +10,17 @@ use crate::models;
use serde::{Deserialize, Serialize};
/// GroupPermission : A permission that can be granted to a role in a group.
#[derive(Clone, Default, Debug, PartialEq, Serialize, Deserialize)]
#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
pub struct GroupPermission {
/// The name of the permission.
#[serde(rename = "name", skip_serializing_if = "Option::is_none")]
pub name: Option<String>,
pub name: Option<std::sync::Arc<str>>,
/// The display name of the permission.
#[serde(rename = "displayName", skip_serializing_if = "Option::is_none")]
pub display_name: Option<String>,
pub display_name: Option<std::sync::Arc<str>>,
/// Human-readable description of the permission.
#[serde(rename = "help", skip_serializing_if = "Option::is_none")]
pub help: Option<String>,
pub help: Option<std::sync::Arc<str>>,
/// Whether this permission is a \"management\" permission.
#[serde(rename = "isManagementPermission", skip_serializing_if = "Option::is_none")]
pub is_management_permission: Option<bool>,

24
src/models/group_post.rs
View File

@ -9,34 +9,34 @@
use crate::models;
use serde::{Deserialize, Serialize};
#[derive(Clone, Default, Debug, PartialEq, Serialize, Deserialize)]
#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
pub struct GroupPost {
#[serde(rename = "id", skip_serializing_if = "Option::is_none")]
pub id: Option<String>,
pub id: Option<std::sync::Arc<str>>,
#[serde(rename = "groupId", skip_serializing_if = "Option::is_none")]
pub group_id: Option<String>,
pub group_id: Option<std::sync::Arc<str>>,
/// A users unique ID, usually in the form of `usr_c1644b5b-3ca4-45b4-97c6-a2a0de70d469`. Legacy players can have old IDs in the form of `8JoV9XEdpo`. The ID can never be changed.
#[serde(rename = "authorId", skip_serializing_if = "Option::is_none")]
pub author_id: Option<String>,
pub author_id: Option<std::sync::Arc<str>>,
/// A users unique ID, usually in the form of `usr_c1644b5b-3ca4-45b4-97c6-a2a0de70d469`. Legacy players can have old IDs in the form of `8JoV9XEdpo`. The ID can never be changed.
#[serde(rename = "editorId", skip_serializing_if = "Option::is_none")]
pub editor_id: Option<String>,
pub editor_id: Option<std::sync::Arc<str>>,
#[serde(rename = "visibility", skip_serializing_if = "Option::is_none")]
pub visibility: Option<models::GroupPostVisibility>,
#[serde(rename = "roleId", skip_serializing_if = "Option::is_none")]
pub role_id: Option<Vec<String>>,
pub role_id: Option<Vec<std::sync::Arc<str>>>,
#[serde(rename = "title", skip_serializing_if = "Option::is_none")]
pub title: Option<String>,
pub title: Option<std::sync::Arc<str>>,
#[serde(rename = "text", skip_serializing_if = "Option::is_none")]
pub text: Option<String>,
pub text: Option<std::sync::Arc<str>>,
#[serde(rename = "imageId", skip_serializing_if = "Option::is_none")]
pub image_id: Option<String>,
pub image_id: Option<std::sync::Arc<str>>,
#[serde(rename = "imageUrl", default, with = "::serde_with::rust::double_option", skip_serializing_if = "Option::is_none")]
pub image_url: Option<Option<String>>,
pub image_url: Option<Option<std::sync::Arc<str>>>,
#[serde(rename = "createdAt", skip_serializing_if = "Option::is_none")]
pub created_at: Option<String>,
pub created_at: Option<std::sync::Arc<str>>,
#[serde(rename = "updatedAt", skip_serializing_if = "Option::is_none")]
pub updated_at: Option<String>,
pub updated_at: Option<std::sync::Arc<str>>,
}
impl GroupPost {

16
src/models/group_role.rs
View File

@ -9,20 +9,20 @@
use crate::models;
use serde::{Deserialize, Serialize};
#[derive(Clone, Default, Debug, PartialEq, Serialize, Deserialize)]
#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
pub struct GroupRole {
#[serde(rename = "id", skip_serializing_if = "Option::is_none")]
pub id: Option<String>,
pub id: Option<std::sync::Arc<str>>,
#[serde(rename = "groupId", skip_serializing_if = "Option::is_none")]
pub group_id: Option<String>,
pub group_id: Option<std::sync::Arc<str>>,
#[serde(rename = "name", skip_serializing_if = "Option::is_none")]
pub name: Option<String>,
pub name: Option<std::sync::Arc<str>>,
#[serde(rename = "description", skip_serializing_if = "Option::is_none")]
pub description: Option<String>,
pub description: Option<std::sync::Arc<str>>,
#[serde(rename = "isSelfAssignable", skip_serializing_if = "Option::is_none")]
pub is_self_assignable: Option<bool>,
#[serde(rename = "permissions", skip_serializing_if = "Option::is_none")]
pub permissions: Option<Vec<String>>,
pub permissions: Option<Vec<std::sync::Arc<str>>>,
#[serde(rename = "isManagementRole", skip_serializing_if = "Option::is_none")]
pub is_management_role: Option<bool>,
#[serde(rename = "requiresTwoFactor", skip_serializing_if = "Option::is_none")]
@ -32,9 +32,9 @@ pub struct GroupRole {
#[serde(rename = "order", skip_serializing_if = "Option::is_none")]
pub order: Option<i32>,
#[serde(rename = "createdAt", skip_serializing_if = "Option::is_none")]
pub created_at: Option<String>,
pub created_at: Option<std::sync::Arc<str>>,
#[serde(rename = "updatedAt", skip_serializing_if = "Option::is_none")]
pub updated_at: Option<String>,
pub updated_at: Option<std::sync::Arc<str>>,
}
impl GroupRole {

18
src/models/info_push.rs
View File

@ -10,10 +10,10 @@ use crate::models;
use serde::{Deserialize, Serialize};
/// InfoPush :
#[derive(Clone, Default, Debug, PartialEq, Serialize, Deserialize)]
#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
pub struct InfoPush {
#[serde(rename = "id")]
pub id: String,
pub id: std::sync::Arc<str>,
#[serde(rename = "isEnabled")]
pub is_enabled: bool,
#[serde(rename = "releaseStatus")]
@ -21,24 +21,24 @@ pub struct InfoPush {
#[serde(rename = "priority")]
pub priority: i32,
#[serde(rename = "tags")]
pub tags: Vec<String>,
pub tags: Vec<crate::models::tags::Tags>,
#[serde(rename = "data")]
pub data: Box<models::InfoPushData>,
/// Unknown usage, MD5
#[serde(rename = "hash")]
pub hash: String,
pub hash: std::sync::Arc<str>,
#[serde(rename = "createdAt")]
pub created_at: String,
pub created_at: std::sync::Arc<str>,
#[serde(rename = "updatedAt")]
pub updated_at: String,
pub updated_at: std::sync::Arc<str>,
#[serde(rename = "startDate", skip_serializing_if = "Option::is_none")]
pub start_date: Option<String>,
pub start_date: Option<std::sync::Arc<str>>,
#[serde(rename = "endDate", skip_serializing_if = "Option::is_none")]
pub end_date: Option<String>,
pub end_date: Option<std::sync::Arc<str>>,
}
impl InfoPush {
pub fn new(id: String, is_enabled: bool, release_status: models::ReleaseStatus, priority: i32, tags: Vec<String>, data: models::InfoPushData, hash: String, created_at: String, updated_at: String) -> InfoPush {
pub fn new(id: std::sync::Arc<str>, is_enabled: bool, release_status: models::ReleaseStatus, priority: i32, tags: Vec<crate::models::tags::Tags>, data: models::InfoPushData, hash: std::sync::Arc<str>, created_at: std::sync::Arc<str>, updated_at: std::sync::Arc<str>) -> InfoPush {
InfoPush {
id,
is_enabled,

12
src/models/info_push_data.rs
View File

@ -10,22 +10,22 @@ use crate::models;
use serde::{Deserialize, Serialize};
/// InfoPushData :
#[derive(Clone, Default, Debug, PartialEq, Serialize, Deserialize)]
#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
pub struct InfoPushData {
#[serde(rename = "contentList", skip_serializing_if = "Option::is_none")]
pub content_list: Option<Box<models::DynamicContentRow>>,
#[serde(rename = "description", skip_serializing_if = "Option::is_none")]
pub description: Option<String>,
pub description: Option<std::sync::Arc<str>>,
#[serde(rename = "imageUrl", skip_serializing_if = "Option::is_none")]
pub image_url: Option<String>,
pub image_url: Option<std::sync::Arc<str>>,
#[serde(rename = "name", skip_serializing_if = "Option::is_none")]
pub name: Option<String>,
pub name: Option<std::sync::Arc<str>>,
#[serde(rename = "onPressed", skip_serializing_if = "Option::is_none")]
pub on_pressed: Option<Box<models::InfoPushDataClickable>>,
#[serde(rename = "template", skip_serializing_if = "Option::is_none")]
pub template: Option<String>,
pub template: Option<std::sync::Arc<str>>,
#[serde(rename = "version", skip_serializing_if = "Option::is_none")]
pub version: Option<String>,
pub version: Option<std::sync::Arc<str>>,
#[serde(rename = "article", skip_serializing_if = "Option::is_none")]
pub article: Option<Box<models::InfoPushDataArticle>>,
}

2
src/models/info_push_data_article.rs
View File

@ -9,7 +9,7 @@
use crate::models;
use serde::{Deserialize, Serialize};
#[derive(Clone, Default, Debug, PartialEq, Serialize, Deserialize)]
#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
pub struct InfoPushDataArticle {
#[serde(rename = "content", skip_serializing_if = "Option::is_none")]
pub content: Option<Box<models::InfoPushDataArticleContent>>,

6
src/models/info_push_data_article_content.rs
View File

@ -9,12 +9,12 @@
use crate::models;
use serde::{Deserialize, Serialize};
#[derive(Clone, Default, Debug, PartialEq, Serialize, Deserialize)]
#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
pub struct InfoPushDataArticleContent {
#[serde(rename = "text", skip_serializing_if = "Option::is_none")]
pub text: Option<String>,
pub text: Option<std::sync::Arc<str>>,
#[serde(rename = "imageUrl", skip_serializing_if = "Option::is_none")]
pub image_url: Option<String>,
pub image_url: Option<std::sync::Arc<str>>,
#[serde(rename = "onPressed", skip_serializing_if = "Option::is_none")]
pub on_pressed: Option<Box<models::InfoPushDataClickable>>,
}

4
src/models/info_push_data_clickable.rs
View File

@ -9,13 +9,13 @@
use crate::models;
use serde::{Deserialize, Serialize};
#[derive(Clone, Default, Debug, PartialEq, Serialize, Deserialize)]
#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
pub struct InfoPushDataClickable {
#[serde(rename = "command")]
pub command: Command,
/// In case of OpenURL, this would contain the link.
#[serde(rename = "parameters", skip_serializing_if = "Option::is_none")]
pub parameters: Option<Vec<String>>,
pub parameters: Option<Vec<std::sync::Arc<str>>>,
}
impl InfoPushDataClickable {

34
src/models/instance.rs
View File

@ -10,7 +10,7 @@ use crate::models;
use serde::{Deserialize, Serialize};
/// Instance : * `hidden` field is only present if InstanceType is `hidden` aka \"Friends+\", and is instance creator. * `friends` field is only present if InstanceType is `friends` aka \"Friends\", and is instance creator. * `private` field is only present if InstanceType is `private` aka \"Invite\" or \"Invite+\", and is instance creator.
#[derive(Clone, Default, Debug, PartialEq, Serialize, Deserialize)]
#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
pub struct Instance {
#[serde(rename = "active")]
pub active: bool,
@ -20,24 +20,24 @@ pub struct Instance {
pub capacity: i32,
/// Always returns \"unknown\".
#[serde(rename = "clientNumber")]
pub client_number: String,
pub client_number: std::sync::Arc<str>,
#[serde(rename = "full")]
pub full: bool,
/// InstanceID can be \"offline\" on User profiles if you are not friends with that user and \"private\" if you are friends and user is in private instance.
#[serde(rename = "id")]
pub id: String,
pub id: std::sync::Arc<str>,
#[serde(rename = "instanceId")]
pub instance_id: String,
pub instance_id: std::sync::Arc<str>,
/// InstanceID can be \"offline\" on User profiles if you are not friends with that user and \"private\" if you are friends and user is in private instance.
#[serde(rename = "location")]
pub location: String,
pub location: std::sync::Arc<str>,
#[serde(rename = "n_users")]
pub n_users: i32,
#[serde(rename = "name")]
pub name: String,
pub name: std::sync::Arc<str>,
/// A groupId if the instance type is \"group\", null if instance type is public, or a userId otherwise
#[serde(rename = "ownerId", default, with = "::serde_with::rust::double_option", skip_serializing_if = "Option::is_none")]
pub owner_id: Option<Option<String>>,
pub owner_id: Option<Option<std::sync::Arc<str>>>,
#[serde(rename = "permanent")]
pub permanent: bool,
#[serde(rename = "photonRegion")]
@ -47,26 +47,26 @@ pub struct Instance {
#[serde(rename = "region")]
pub region: models::InstanceRegion,
#[serde(rename = "secureName")]
pub secure_name: String,
pub secure_name: std::sync::Arc<str>,
#[serde(rename = "shortName", default, with = "::serde_with::rust::double_option", skip_serializing_if = "Option::is_none")]
pub short_name: Option<Option<String>>,
pub short_name: Option<Option<std::sync::Arc<str>>>,
/// The tags array on Instances usually contain the language tags of the people in the instance.
#[serde(rename = "tags")]
pub tags: Vec<String>,
pub tags: Vec<crate::models::tags::Tags>,
#[serde(rename = "type")]
pub r#type: models::InstanceType,
/// WorldID be \"offline\" on User profiles if you are not friends with that user.
#[serde(rename = "worldId")]
pub world_id: String,
pub world_id: std::sync::Arc<str>,
/// A users unique ID, usually in the form of `usr_c1644b5b-3ca4-45b4-97c6-a2a0de70d469`. Legacy players can have old IDs in the form of `8JoV9XEdpo`. The ID can never be changed.
#[serde(rename = "hidden", skip_serializing_if = "Option::is_none")]
pub hidden: Option<String>,
pub hidden: Option<std::sync::Arc<str>>,
/// A users unique ID, usually in the form of `usr_c1644b5b-3ca4-45b4-97c6-a2a0de70d469`. Legacy players can have old IDs in the form of `8JoV9XEdpo`. The ID can never be changed.
#[serde(rename = "friends", skip_serializing_if = "Option::is_none")]
pub friends: Option<String>,
pub friends: Option<std::sync::Arc<str>>,
/// A users unique ID, usually in the form of `usr_c1644b5b-3ca4-45b4-97c6-a2a0de70d469`. Legacy players can have old IDs in the form of `8JoV9XEdpo`. The ID can never be changed.
#[serde(rename = "private", skip_serializing_if = "Option::is_none")]
pub private: Option<String>,
pub private: Option<std::sync::Arc<str>>,
#[serde(rename = "queueEnabled")]
pub queue_enabled: bool,
#[serde(rename = "queueSize")]
@ -89,16 +89,16 @@ pub struct Instance {
#[serde(rename = "hasCapacityForYou", skip_serializing_if = "Option::is_none")]
pub has_capacity_for_you: Option<bool>,
#[serde(rename = "nonce", skip_serializing_if = "Option::is_none")]
pub nonce: Option<String>,
pub nonce: Option<std::sync::Arc<str>>,
#[serde(rename = "closedAt", default, with = "::serde_with::rust::double_option", skip_serializing_if = "Option::is_none")]
pub closed_at: Option<Option<String>>,
pub closed_at: Option<Option<std::sync::Arc<str>>>,
#[serde(rename = "hardClose", default, with = "::serde_with::rust::double_option", skip_serializing_if = "Option::is_none")]
pub hard_close: Option<Option<bool>>,
}
impl Instance {
/// * `hidden` field is only present if InstanceType is `hidden` aka \"Friends+\", and is instance creator. * `friends` field is only present if InstanceType is `friends` aka \"Friends\", and is instance creator. * `private` field is only present if InstanceType is `private` aka \"Invite\" or \"Invite+\", and is instance creator.
pub fn new(active: bool, can_request_invite: bool, capacity: i32, client_number: String, full: bool, id: String, instance_id: String, location: String, n_users: i32, name: String, permanent: bool, photon_region: models::Region, platforms: models::InstancePlatforms, region: models::InstanceRegion, secure_name: String, tags: Vec<String>, r#type: models::InstanceType, world_id: String, queue_enabled: bool, queue_size: i32, recommended_capacity: i32, strict: bool, user_count: i32, world: models::World) -> Instance {
pub fn new(active: bool, can_request_invite: bool, capacity: i32, client_number: std::sync::Arc<str>, full: bool, id: std::sync::Arc<str>, instance_id: std::sync::Arc<str>, location: std::sync::Arc<str>, n_users: i32, name: std::sync::Arc<str>, permanent: bool, photon_region: models::Region, platforms: models::InstancePlatforms, region: models::InstanceRegion, secure_name: std::sync::Arc<str>, tags: Vec<crate::models::tags::Tags>, r#type: models::InstanceType, world_id: std::sync::Arc<str>, queue_enabled: bool, queue_size: i32, recommended_capacity: i32, strict: bool, user_count: i32, world: models::World) -> Instance {
Instance {
active,
can_request_invite,

2
src/models/instance_platforms.rs
View File

@ -9,7 +9,7 @@
use crate::models;
use serde::{Deserialize, Serialize};
#[derive(Clone, Default, Debug, PartialEq, Serialize, Deserialize)]
#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
pub struct InstancePlatforms {
#[serde(rename = "android")]
pub android: i32,

8
src/models/instance_short_name_response.rs
View File

@ -9,16 +9,16 @@
use crate::models;
use serde::{Deserialize, Serialize};
#[derive(Clone, Default, Debug, PartialEq, Serialize, Deserialize)]
#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
pub struct InstanceShortNameResponse {
#[serde(rename = "secureName")]
pub secure_name: String,
pub secure_name: std::sync::Arc<str>,
#[serde(rename = "shortName", skip_serializing_if = "Option::is_none")]
pub short_name: Option<String>,
pub short_name: Option<std::sync::Arc<str>>,
}
impl InstanceShortNameResponse {
pub fn new(secure_name: String) -> InstanceShortNameResponse {
pub fn new(secure_name: std::sync::Arc<str>) -> InstanceShortNameResponse {
InstanceShortNameResponse {
secure_name,
short_name: None,

10
src/models/invite_message.rs
View File

@ -10,14 +10,14 @@ use crate::models;
use serde::{Deserialize, Serialize};
/// InviteMessage :
#[derive(Clone, Default, Debug, PartialEq, Serialize, Deserialize)]
#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
pub struct InviteMessage {
#[serde(rename = "canBeUpdated")]
pub can_be_updated: bool,
#[serde(rename = "id")]
pub id: String,
pub id: std::sync::Arc<str>,
#[serde(rename = "message")]
pub message: String,
pub message: std::sync::Arc<str>,
#[serde(rename = "messageType")]
pub message_type: models::InviteMessageType,
/// Changes to 60 when updated, although probably server-side configurable.
@ -26,11 +26,11 @@ pub struct InviteMessage {
#[serde(rename = "slot")]
pub slot: i32,
#[serde(rename = "updatedAt")]
pub updated_at: String,
pub updated_at: std::sync::Arc<str>,
}
impl InviteMessage {
pub fn new(can_be_updated: bool, id: String, message: String, message_type: models::InviteMessageType, remaining_cooldown_minutes: i32, slot: i32, updated_at: String) -> InviteMessage {
pub fn new(can_be_updated: bool, id: std::sync::Arc<str>, message: std::sync::Arc<str>, message_type: models::InviteMessageType, remaining_cooldown_minutes: i32, slot: i32, updated_at: std::sync::Arc<str>) -> InviteMessage {
InviteMessage {
can_be_updated,
id,

6
src/models/invite_request.rs
View File

@ -9,17 +9,17 @@
use crate::models;
use serde::{Deserialize, Serialize};
#[derive(Clone, Default, Debug, PartialEq, Serialize, Deserialize)]
#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
pub struct InviteRequest {
/// InstanceID can be \"offline\" on User profiles if you are not friends with that user and \"private\" if you are friends and user is in private instance.
#[serde(rename = "instanceId")]
pub instance_id: String,
pub instance_id: std::sync::Arc<str>,
#[serde(rename = "messageSlot", skip_serializing_if = "Option::is_none")]
pub message_slot: Option<i32>,
}
impl InviteRequest {
pub fn new(instance_id: String) -> InviteRequest {
pub fn new(instance_id: std::sync::Arc<str>) -> InviteRequest {
InviteRequest {
instance_id,
message_slot: None,

2
src/models/invite_response.rs
View File

@ -9,7 +9,7 @@
use crate::models;
use serde::{Deserialize, Serialize};
#[derive(Clone, Default, Debug, PartialEq, Serialize, Deserialize)]
#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
pub struct InviteResponse {
#[serde(rename = "responseSlot")]
pub response_slot: i32,

8
src/models/license.rs
View File

@ -9,21 +9,21 @@
use crate::models;
use serde::{Deserialize, Serialize};
#[derive(Clone, Default, Debug, PartialEq, Serialize, Deserialize)]
#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
pub struct License {
/// Either a AvatarID, LicenseGroupID, PermissionID or ProductID. This depends on the `forType` field.
#[serde(rename = "forId")]
pub for_id: String,
pub for_id: std::sync::Arc<str>,
#[serde(rename = "forType")]
pub for_type: models::LicenseType,
#[serde(rename = "forName")]
pub for_name: String,
pub for_name: std::sync::Arc<str>,
#[serde(rename = "forAction")]
pub for_action: models::LicenseAction,
}
impl License {
pub fn new(for_id: String, for_type: models::LicenseType, for_name: String, for_action: models::LicenseAction) -> License {
pub fn new(for_id: std::sync::Arc<str>, for_type: models::LicenseType, for_name: std::sync::Arc<str>, for_action: models::LicenseAction) -> License {
License {
for_id,
for_type,

10
src/models/license_group.rs
View File

@ -10,20 +10,20 @@ use crate::models;
use serde::{Deserialize, Serialize};
/// LicenseGroup :
#[derive(Clone, Default, Debug, PartialEq, Serialize, Deserialize)]
#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
pub struct LicenseGroup {
#[serde(rename = "id")]
pub id: String,
pub id: std::sync::Arc<str>,
#[serde(rename = "name")]
pub name: String,
pub name: std::sync::Arc<str>,
#[serde(rename = "description")]
pub description: String,
pub description: std::sync::Arc<str>,
#[serde(rename = "licenses")]
pub licenses: Vec<models::License>,
}
impl LicenseGroup {
pub fn new(id: String, name: String, description: String, licenses: Vec<models::License>) -> LicenseGroup {
pub fn new(id: std::sync::Arc<str>, name: std::sync::Arc<str>, description: std::sync::Arc<str>, licenses: Vec<models::License>) -> LicenseGroup {
LicenseGroup {
id,
name,

28
src/models/limited_group.rs
View File

@ -9,37 +9,37 @@
use crate::models;
use serde::{Deserialize, Serialize};
#[derive(Clone, Default, Debug, PartialEq, Serialize, Deserialize)]
#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
pub struct LimitedGroup {
#[serde(rename = "id", skip_serializing_if = "Option::is_none")]
pub id: Option<String>,
pub id: Option<std::sync::Arc<str>>,
#[serde(rename = "name", skip_serializing_if = "Option::is_none")]
pub name: Option<String>,
pub name: Option<std::sync::Arc<str>>,
#[serde(rename = "shortCode", skip_serializing_if = "Option::is_none")]
pub short_code: Option<String>,
pub short_code: Option<std::sync::Arc<str>>,
#[serde(rename = "discriminator", skip_serializing_if = "Option::is_none")]
pub discriminator: Option<String>,
pub discriminator: Option<std::sync::Arc<str>>,
#[serde(rename = "description", skip_serializing_if = "Option::is_none")]
pub description: Option<String>,
pub description: Option<std::sync::Arc<str>>,
#[serde(rename = "iconUrl", default, with = "::serde_with::rust::double_option", skip_serializing_if = "Option::is_none")]
pub icon_url: Option<Option<String>>,
pub icon_url: Option<Option<std::sync::Arc<str>>>,
#[serde(rename = "bannerUrl", default, with = "::serde_with::rust::double_option", skip_serializing_if = "Option::is_none")]
pub banner_url: Option<Option<String>>,
pub banner_url: Option<Option<std::sync::Arc<str>>>,
/// A users unique ID, usually in the form of `usr_c1644b5b-3ca4-45b4-97c6-a2a0de70d469`. Legacy players can have old IDs in the form of `8JoV9XEdpo`. The ID can never be changed.
#[serde(rename = "ownerId", skip_serializing_if = "Option::is_none")]
pub owner_id: Option<String>,
pub owner_id: Option<std::sync::Arc<str>>,
#[serde(rename = "rules", default, with = "::serde_with::rust::double_option", skip_serializing_if = "Option::is_none")]
pub rules: Option<Option<String>>,
pub rules: Option<Option<std::sync::Arc<str>>>,
#[serde(rename = "iconId", default, with = "::serde_with::rust::double_option", skip_serializing_if = "Option::is_none")]
pub icon_id: Option<Option<String>>,
pub icon_id: Option<Option<std::sync::Arc<str>>>,
#[serde(rename = "bannerId", default, with = "::serde_with::rust::double_option", skip_serializing_if = "Option::is_none")]
pub banner_id: Option<Option<String>>,
pub banner_id: Option<Option<std::sync::Arc<str>>>,
#[serde(rename = "memberCount", skip_serializing_if = "Option::is_none")]
pub member_count: Option<i32>,
#[serde(rename = "tags", skip_serializing_if = "Option::is_none")]
pub tags: Option<Vec<String>>,
pub tags: Option<Vec<std::sync::Arc<str>>>,
#[serde(rename = "createdAt", skip_serializing_if = "Option::is_none")]
pub created_at: Option<String>,
pub created_at: Option<std::sync::Arc<str>>,
#[serde(rename = "membershipStatus", skip_serializing_if = "Option::is_none")]
pub membership_status: Option<models::GroupMemberStatus>,
#[serde(rename = "isSearchable", skip_serializing_if = "Option::is_none")]

8
src/models/limited_unity_package.rs
View File

@ -10,17 +10,17 @@ use crate::models;
use serde::{Deserialize, Serialize};
/// LimitedUnityPackage :
#[derive(Clone, Default, Debug, PartialEq, Serialize, Deserialize)]
#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
pub struct LimitedUnityPackage {
/// This can be `standalonewindows` or `android`, but can also pretty much be any random Unity verison such as `2019.2.4-801-Release` or `2019.2.2-772-Release` or even `unknownplatform`.
#[serde(rename = "platform")]
pub platform: String,
pub platform: std::sync::Arc<str>,
#[serde(rename = "unityVersion")]
pub unity_version: String,
pub unity_version: std::sync::Arc<str>,
}
impl LimitedUnityPackage {
pub fn new(platform: String, unity_version: String) -> LimitedUnityPackage {
pub fn new(platform: std::sync::Arc<str>, unity_version: std::sync::Arc<str>) -> LimitedUnityPackage {
LimitedUnityPackage {
platform,
unity_version,

38
src/models/limited_user.rs
View File

@ -10,58 +10,58 @@ use crate::models;
use serde::{Deserialize, Serialize};
/// LimitedUser :
#[derive(Clone, Default, Debug, PartialEq, Serialize, Deserialize)]
#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
pub struct LimitedUser {
#[serde(rename = "bio", skip_serializing_if = "Option::is_none")]
pub bio: Option<String>,
pub bio: Option<std::sync::Arc<str>>,
#[serde(rename = "bioLinks", skip_serializing_if = "Option::is_none")]
pub bio_links: Option<Vec<String>>,
pub bio_links: Option<Vec<std::sync::Arc<str>>>,
/// When profilePicOverride is not empty, use it instead.
#[serde(rename = "currentAvatarImageUrl", skip_serializing_if = "Option::is_none")]
pub current_avatar_image_url: Option<String>,
pub current_avatar_image_url: Option<std::sync::Arc<str>>,
/// When profilePicOverride is not empty, use it instead.
#[serde(rename = "currentAvatarThumbnailImageUrl", skip_serializing_if = "Option::is_none")]
pub current_avatar_thumbnail_image_url: Option<String>,
pub current_avatar_thumbnail_image_url: Option<std::sync::Arc<str>>,
#[serde(rename = "currentAvatarTags", skip_serializing_if = "Option::is_none")]
pub current_avatar_tags: Option<Vec<String>>,
pub current_avatar_tags: Option<Vec<std::sync::Arc<str>>>,
#[serde(rename = "developerType")]
pub developer_type: models::DeveloperType,
#[serde(rename = "displayName")]
pub display_name: String,
pub display_name: std::sync::Arc<str>,
#[serde(rename = "fallbackAvatar", skip_serializing_if = "Option::is_none")]
pub fallback_avatar: Option<String>,
pub fallback_avatar: Option<std::sync::Arc<str>>,
/// A users unique ID, usually in the form of `usr_c1644b5b-3ca4-45b4-97c6-a2a0de70d469`. Legacy players can have old IDs in the form of `8JoV9XEdpo`. The ID can never be changed.
#[serde(rename = "id")]
pub id: String,
pub id: std::sync::Arc<str>,
#[serde(rename = "isFriend")]
pub is_friend: bool,
/// This can be `standalonewindows` or `android`, but can also pretty much be any random Unity verison such as `2019.2.4-801-Release` or `2019.2.2-772-Release` or even `unknownplatform`.
#[serde(rename = "last_platform")]
pub last_platform: String,
pub last_platform: std::sync::Arc<str>,
#[serde(rename = "profilePicOverride", skip_serializing_if = "Option::is_none")]
pub profile_pic_override: Option<String>,
pub profile_pic_override: Option<std::sync::Arc<str>>,
#[serde(rename = "pronouns", skip_serializing_if = "Option::is_none")]
pub pronouns: Option<String>,
pub pronouns: Option<std::sync::Arc<str>>,
#[serde(rename = "status")]
pub status: models::UserStatus,
#[serde(rename = "statusDescription")]
pub status_description: String,
pub status_description: std::sync::Arc<str>,
/// <- Always empty.
#[serde(rename = "tags")]
pub tags: Vec<String>,
pub tags: Vec<crate::models::tags::Tags>,
#[serde(rename = "userIcon", skip_serializing_if = "Option::is_none")]
pub user_icon: Option<String>,
pub user_icon: Option<std::sync::Arc<str>>,
/// -| **DEPRECATED:** VRChat API no longer return usernames of other users. [See issue by Tupper for more information](https://github.com/pypy-vrc/VRCX/issues/429).
#[serde(rename = "username", skip_serializing_if = "Option::is_none")]
pub username: Option<String>,
pub username: Option<std::sync::Arc<str>>,
#[serde(rename = "location", skip_serializing_if = "Option::is_none")]
pub location: Option<String>,
pub location: Option<std::sync::Arc<str>>,
#[serde(rename = "friendKey", skip_serializing_if = "Option::is_none")]
pub friend_key: Option<String>,
pub friend_key: Option<std::sync::Arc<str>>,
}
impl LimitedUser {
pub fn new(developer_type: models::DeveloperType, display_name: String, id: String, is_friend: bool, last_platform: String, status: models::UserStatus, status_description: String, tags: Vec<String>) -> LimitedUser {
pub fn new(developer_type: models::DeveloperType, display_name: std::sync::Arc<str>, id: std::sync::Arc<str>, is_friend: bool, last_platform: std::sync::Arc<str>, status: models::UserStatus, status_description: std::sync::Arc<str>, tags: Vec<crate::models::tags::Tags>) -> LimitedUser {
LimitedUser {
bio: None,
bio_links: None,

32
src/models/limited_user_groups.rs
View File

@ -9,45 +9,45 @@
use crate::models;
use serde::{Deserialize, Serialize};
#[derive(Clone, Default, Debug, PartialEq, Serialize, Deserialize)]
#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
pub struct LimitedUserGroups {
#[serde(rename = "id", skip_serializing_if = "Option::is_none")]
pub id: Option<String>,
pub id: Option<std::sync::Arc<str>>,
#[serde(rename = "name", skip_serializing_if = "Option::is_none")]
pub name: Option<String>,
pub name: Option<std::sync::Arc<str>>,
#[serde(rename = "shortCode", skip_serializing_if = "Option::is_none")]
pub short_code: Option<String>,
pub short_code: Option<std::sync::Arc<str>>,
#[serde(rename = "discriminator", skip_serializing_if = "Option::is_none")]
pub discriminator: Option<String>,
pub discriminator: Option<std::sync::Arc<str>>,
#[serde(rename = "description", skip_serializing_if = "Option::is_none")]
pub description: Option<String>,
pub description: Option<std::sync::Arc<str>>,
#[serde(rename = "iconId", default, with = "::serde_with::rust::double_option", skip_serializing_if = "Option::is_none")]
pub icon_id: Option<Option<String>>,
pub icon_id: Option<Option<std::sync::Arc<str>>>,
#[serde(rename = "iconUrl", default, with = "::serde_with::rust::double_option", skip_serializing_if = "Option::is_none")]
pub icon_url: Option<Option<String>>,
pub icon_url: Option<Option<std::sync::Arc<str>>>,
#[serde(rename = "bannerId", default, with = "::serde_with::rust::double_option", skip_serializing_if = "Option::is_none")]
pub banner_id: Option<Option<String>>,
pub banner_id: Option<Option<std::sync::Arc<str>>>,
#[serde(rename = "bannerUrl", default, with = "::serde_with::rust::double_option", skip_serializing_if = "Option::is_none")]
pub banner_url: Option<Option<String>>,
pub banner_url: Option<Option<std::sync::Arc<str>>>,
#[serde(rename = "privacy", skip_serializing_if = "Option::is_none")]
pub privacy: Option<String>,
pub privacy: Option<std::sync::Arc<str>>,
#[serde(rename = "lastPostCreatedAt", default, with = "::serde_with::rust::double_option", skip_serializing_if = "Option::is_none")]
pub last_post_created_at: Option<Option<String>>,
pub last_post_created_at: Option<Option<std::sync::Arc<str>>>,
/// A users unique ID, usually in the form of `usr_c1644b5b-3ca4-45b4-97c6-a2a0de70d469`. Legacy players can have old IDs in the form of `8JoV9XEdpo`. The ID can never be changed.
#[serde(rename = "ownerId", skip_serializing_if = "Option::is_none")]
pub owner_id: Option<String>,
pub owner_id: Option<std::sync::Arc<str>>,
#[serde(rename = "memberCount", skip_serializing_if = "Option::is_none")]
pub member_count: Option<i32>,
#[serde(rename = "groupId", skip_serializing_if = "Option::is_none")]
pub group_id: Option<String>,
pub group_id: Option<std::sync::Arc<str>>,
#[serde(rename = "memberVisibility", skip_serializing_if = "Option::is_none")]
pub member_visibility: Option<String>,
pub member_visibility: Option<std::sync::Arc<str>>,
#[serde(rename = "isRepresenting", skip_serializing_if = "Option::is_none")]
pub is_representing: Option<bool>,
#[serde(rename = "mutualGroup", skip_serializing_if = "Option::is_none")]
pub mutual_group: Option<bool>,
#[serde(rename = "lastPostReadAt", default, with = "::serde_with::rust::double_option", skip_serializing_if = "Option::is_none")]
pub last_post_read_at: Option<Option<String>>,
pub last_post_read_at: Option<Option<std::sync::Arc<str>>>,
}
impl LimitedUserGroups {

32
src/models/limited_world.rs
View File

@ -10,19 +10,19 @@ use crate::models;
use serde::{Deserialize, Serialize};
/// LimitedWorld :
#[derive(Clone, Default, Debug, PartialEq, Serialize, Deserialize)]
#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
pub struct LimitedWorld {
/// A users unique ID, usually in the form of `usr_c1644b5b-3ca4-45b4-97c6-a2a0de70d469`. Legacy players can have old IDs in the form of `8JoV9XEdpo`. The ID can never be changed.
#[serde(rename = "authorId")]
pub author_id: String,
pub author_id: std::sync::Arc<str>,
#[serde(rename = "authorName")]
pub author_name: String,
pub author_name: std::sync::Arc<str>,
#[serde(rename = "capacity")]
pub capacity: i32,
#[serde(rename = "recommendedCapacity", skip_serializing_if = "Option::is_none")]
pub recommended_capacity: Option<i32>,
#[serde(rename = "created_at")]
pub created_at: String,
pub created_at: std::sync::Arc<str>,
#[serde(rename = "favorites")]
pub favorites: i32,
#[serde(rename = "visits", skip_serializing_if = "Option::is_none")]
@ -31,39 +31,39 @@ pub struct LimitedWorld {
pub heat: i32,
/// WorldID be \"offline\" on User profiles if you are not friends with that user.
#[serde(rename = "id")]
pub id: String,
pub id: std::sync::Arc<str>,
#[serde(rename = "imageUrl")]
pub image_url: String,
pub image_url: std::sync::Arc<str>,
#[serde(rename = "labsPublicationDate")]
pub labs_publication_date: String,
pub labs_publication_date: std::sync::Arc<str>,
#[serde(rename = "name")]
pub name: String,
pub name: std::sync::Arc<str>,
#[serde(rename = "occupants")]
pub occupants: i32,
#[serde(rename = "organization")]
pub organization: String,
pub organization: std::sync::Arc<str>,
#[serde(rename = "popularity")]
pub popularity: i32,
#[serde(rename = "previewYoutubeId", default, with = "::serde_with::rust::double_option", skip_serializing_if = "Option::is_none")]
pub preview_youtube_id: Option<Option<String>>,
pub preview_youtube_id: Option<Option<std::sync::Arc<str>>>,
#[serde(rename = "publicationDate")]
pub publication_date: String,
pub publication_date: std::sync::Arc<str>,
#[serde(rename = "releaseStatus")]
pub release_status: models::ReleaseStatus,
#[serde(rename = "tags")]
pub tags: Vec<String>,
pub tags: Vec<crate::models::tags::Tags>,
#[serde(rename = "thumbnailImageUrl")]
pub thumbnail_image_url: String,
pub thumbnail_image_url: std::sync::Arc<str>,
#[serde(rename = "unityPackages")]
pub unity_packages: Vec<models::LimitedUnityPackage>,
#[serde(rename = "updated_at")]
pub updated_at: String,
pub updated_at: std::sync::Arc<str>,
#[serde(rename = "udonProducts", skip_serializing_if = "Option::is_none")]
pub udon_products: Option<Vec<String>>,
pub udon_products: Option<Vec<std::sync::Arc<str>>>,
}
impl LimitedWorld {
pub fn new(author_id: String, author_name: String, capacity: i32, created_at: String, favorites: i32, heat: i32, id: String, image_url: String, labs_publication_date: String, name: String, occupants: i32, organization: String, popularity: i32, publication_date: String, release_status: models::ReleaseStatus, tags: Vec<String>, thumbnail_image_url: String, unity_packages: Vec<models::LimitedUnityPackage>, updated_at: String) -> LimitedWorld {
pub fn new(author_id: std::sync::Arc<str>, author_name: std::sync::Arc<str>, capacity: i32, created_at: std::sync::Arc<str>, favorites: i32, heat: i32, id: std::sync::Arc<str>, image_url: std::sync::Arc<str>, labs_publication_date: std::sync::Arc<str>, name: std::sync::Arc<str>, occupants: i32, organization: std::sync::Arc<str>, popularity: i32, publication_date: std::sync::Arc<str>, release_status: models::ReleaseStatus, tags: Vec<crate::models::tags::Tags>, thumbnail_image_url: std::sync::Arc<str>, unity_packages: Vec<models::LimitedUnityPackage>, updated_at: std::sync::Arc<str>) -> LimitedWorld {
LimitedWorld {
author_id,
author_name,

1
src/models/mod.rs
View File

@ -278,3 +278,4 @@ pub mod world_metadata;
pub use self::world_metadata::WorldMetadata;
pub mod world_publish_status;
pub use self::world_publish_status::WorldPublishStatus;
pub mod tags;

6
src/models/moderate_user_request.rs
View File

@ -9,17 +9,17 @@
use crate::models;
use serde::{Deserialize, Serialize};
#[derive(Clone, Default, Debug, PartialEq, Serialize, Deserialize)]
#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
pub struct ModerateUserRequest {
/// A users unique ID, usually in the form of `usr_c1644b5b-3ca4-45b4-97c6-a2a0de70d469`. Legacy players can have old IDs in the form of `8JoV9XEdpo`. The ID can never be changed.
#[serde(rename = "moderated")]
pub moderated: String,
pub moderated: std::sync::Arc<str>,
#[serde(rename = "type")]
pub r#type: models::PlayerModerationType,
}
impl ModerateUserRequest {
pub fn new(moderated: String, r#type: models::PlayerModerationType) -> ModerateUserRequest {
pub fn new(moderated: std::sync::Arc<str>, r#type: models::PlayerModerationType) -> ModerateUserRequest {
ModerateUserRequest {
moderated,
r#type,

18
src/models/notification.rs
View File

@ -10,35 +10,35 @@ use crate::models;
use serde::{Deserialize, Serialize};
/// Notification :
#[derive(Clone, Default, Debug, PartialEq, Serialize, Deserialize)]
#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
pub struct Notification {
#[serde(rename = "created_at")]
pub created_at: String,
pub created_at: std::sync::Arc<str>,
/// **NOTICE:** This is not a JSON object when received from the REST API, but it is when received from the Websocket API. When received from the REST API, this is a json **encoded** object, meaning you have to json-de-encode to get the NotificationDetail object depending on the NotificationType.
#[serde(rename = "details")]
pub details: String,
pub details: std::sync::Arc<str>,
#[serde(rename = "id")]
pub id: String,
pub id: std::sync::Arc<str>,
#[serde(rename = "message")]
pub message: String,
pub message: std::sync::Arc<str>,
/// Not included in notification objects received from the Websocket API
#[serde(rename = "seen", skip_serializing_if = "Option::is_none")]
pub seen: Option<bool>,
/// A users unique ID, usually in the form of `usr_c1644b5b-3ca4-45b4-97c6-a2a0de70d469`. Legacy players can have old IDs in the form of `8JoV9XEdpo`. The ID can never be changed.
#[serde(rename = "receiverUserId", skip_serializing_if = "Option::is_none")]
pub receiver_user_id: Option<String>,
pub receiver_user_id: Option<std::sync::Arc<str>>,
/// A users unique ID, usually in the form of `usr_c1644b5b-3ca4-45b4-97c6-a2a0de70d469`. Legacy players can have old IDs in the form of `8JoV9XEdpo`. The ID can never be changed.
#[serde(rename = "senderUserId")]
pub sender_user_id: String,
pub sender_user_id: std::sync::Arc<str>,
/// -| **DEPRECATED:** VRChat API no longer return usernames of other users. [See issue by Tupper for more information](https://github.com/pypy-vrc/VRCX/issues/429).
#[serde(rename = "senderUsername", skip_serializing_if = "Option::is_none")]
pub sender_username: Option<String>,
pub sender_username: Option<std::sync::Arc<str>>,
#[serde(rename = "type")]
pub r#type: models::NotificationType,
}
impl Notification {
pub fn new(created_at: String, details: String, id: String, message: String, sender_user_id: String, r#type: models::NotificationType) -> Notification {
pub fn new(created_at: std::sync::Arc<str>, details: std::sync::Arc<str>, id: std::sync::Arc<str>, message: std::sync::Arc<str>, sender_user_id: std::sync::Arc<str>, r#type: models::NotificationType) -> Notification {
Notification {
created_at,
details,

10
src/models/notification_detail_invite.rs
View File

@ -9,19 +9,19 @@
use crate::models;
use serde::{Deserialize, Serialize};
#[derive(Clone, Default, Debug, PartialEq, Serialize, Deserialize)]
#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
pub struct NotificationDetailInvite {
#[serde(rename = "inviteMessage", skip_serializing_if = "Option::is_none")]
pub invite_message: Option<String>,
pub invite_message: Option<std::sync::Arc<str>>,
/// WorldID be \"offline\" on User profiles if you are not friends with that user.
#[serde(rename = "worldId")]
pub world_id: String,
pub world_id: std::sync::Arc<str>,
#[serde(rename = "worldName")]
pub world_name: String,
pub world_name: std::sync::Arc<str>,
}
impl NotificationDetailInvite {
pub fn new(world_id: String, world_name: String) -> NotificationDetailInvite {
pub fn new(world_id: std::sync::Arc<str>, world_name: std::sync::Arc<str>) -> NotificationDetailInvite {
NotificationDetailInvite {
invite_message: None,
world_id,

8
src/models/notification_detail_invite_response.rs
View File

@ -9,16 +9,16 @@
use crate::models;
use serde::{Deserialize, Serialize};
#[derive(Clone, Default, Debug, PartialEq, Serialize, Deserialize)]
#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
pub struct NotificationDetailInviteResponse {
#[serde(rename = "inResponseTo")]
pub in_response_to: String,
pub in_response_to: std::sync::Arc<str>,
#[serde(rename = "responseMessage")]
pub response_message: String,
pub response_message: std::sync::Arc<str>,
}
impl NotificationDetailInviteResponse {
pub fn new(in_response_to: String, response_message: String) -> NotificationDetailInviteResponse {
pub fn new(in_response_to: std::sync::Arc<str>, response_message: std::sync::Arc<str>) -> NotificationDetailInviteResponse {
NotificationDetailInviteResponse {
in_response_to,
response_message,

6
src/models/notification_detail_request_invite.rs
View File

@ -9,14 +9,14 @@
use crate::models;
use serde::{Deserialize, Serialize};
#[derive(Clone, Default, Debug, PartialEq, Serialize, Deserialize)]
#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
pub struct NotificationDetailRequestInvite {
/// TODO: Does this still exist?
#[serde(rename = "platform", skip_serializing_if = "Option::is_none")]
pub platform: Option<String>,
pub platform: Option<std::sync::Arc<str>>,
/// Used when using InviteMessage Slot.
#[serde(rename = "requestMessage", skip_serializing_if = "Option::is_none")]
pub request_message: Option<String>,
pub request_message: Option<std::sync::Arc<str>>,
}
impl NotificationDetailRequestInvite {

8
src/models/notification_detail_request_invite_response.rs
View File

@ -9,17 +9,17 @@
use crate::models;
use serde::{Deserialize, Serialize};
#[derive(Clone, Default, Debug, PartialEq, Serialize, Deserialize)]
#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
pub struct NotificationDetailRequestInviteResponse {
#[serde(rename = "inResponseTo")]
pub in_response_to: String,
pub in_response_to: std::sync::Arc<str>,
/// Used when using InviteMessage Slot.
#[serde(rename = "requestMessage", skip_serializing_if = "Option::is_none")]
pub request_message: Option<String>,
pub request_message: Option<std::sync::Arc<str>>,
}
impl NotificationDetailRequestInviteResponse {
pub fn new(in_response_to: String) -> NotificationDetailRequestInviteResponse {
pub fn new(in_response_to: std::sync::Arc<str>) -> NotificationDetailRequestInviteResponse {
NotificationDetailRequestInviteResponse {
in_response_to,
request_message: None,

8
src/models/notification_detail_vote_to_kick.rs
View File

@ -9,18 +9,18 @@
use crate::models;
use serde::{Deserialize, Serialize};
#[derive(Clone, Default, Debug, PartialEq, Serialize, Deserialize)]
#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
pub struct NotificationDetailVoteToKick {
/// A users unique ID, usually in the form of `usr_c1644b5b-3ca4-45b4-97c6-a2a0de70d469`. Legacy players can have old IDs in the form of `8JoV9XEdpo`. The ID can never be changed.
#[serde(rename = "initiatorUserId")]
pub initiator_user_id: String,
pub initiator_user_id: std::sync::Arc<str>,
/// A users unique ID, usually in the form of `usr_c1644b5b-3ca4-45b4-97c6-a2a0de70d469`. Legacy players can have old IDs in the form of `8JoV9XEdpo`. The ID can never be changed.
#[serde(rename = "userToKickId")]
pub user_to_kick_id: String,
pub user_to_kick_id: std::sync::Arc<str>,
}
impl NotificationDetailVoteToKick {
pub fn new(initiator_user_id: String, user_to_kick_id: String) -> NotificationDetailVoteToKick {
pub fn new(initiator_user_id: std::sync::Arc<str>, user_to_kick_id: std::sync::Arc<str>) -> NotificationDetailVoteToKick {
NotificationDetailVoteToKick {
initiator_user_id,
user_to_kick_id,

2
src/models/paginated_group_audit_log_entry_list.rs
View File

@ -9,7 +9,7 @@
use crate::models;
use serde::{Deserialize, Serialize};
#[derive(Clone, Default, Debug, PartialEq, Serialize, Deserialize)]
#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
pub struct PaginatedGroupAuditLogEntryList {
#[serde(rename = "results", skip_serializing_if = "Option::is_none")]
pub results: Option<Vec<models::GroupAuditLogEntry>>,

8
src/models/past_display_name.rs
View File

@ -9,16 +9,16 @@
use crate::models;
use serde::{Deserialize, Serialize};
#[derive(Clone, Default, Debug, PartialEq, Serialize, Deserialize)]
#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
pub struct PastDisplayName {
#[serde(rename = "displayName")]
pub display_name: String,
pub display_name: std::sync::Arc<str>,
#[serde(rename = "updated_at")]
pub updated_at: String,
pub updated_at: std::sync::Arc<str>,
}
impl PastDisplayName {
pub fn new(display_name: String, updated_at: String) -> PastDisplayName {
pub fn new(display_name: std::sync::Arc<str>, updated_at: std::sync::Arc<str>) -> PastDisplayName {
PastDisplayName {
display_name,
updated_at,

12
src/models/permission.rs
View File

@ -10,23 +10,23 @@ use crate::models;
use serde::{Deserialize, Serialize};
/// Permission :
#[derive(Clone, Default, Debug, PartialEq, Serialize, Deserialize)]
#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
pub struct Permission {
#[serde(rename = "id")]
pub id: String,
pub id: std::sync::Arc<str>,
#[serde(rename = "ownerDisplayName")]
pub owner_display_name: String,
pub owner_display_name: std::sync::Arc<str>,
#[serde(rename = "name")]
pub name: String,
pub name: std::sync::Arc<str>,
/// A users unique ID, usually in the form of `usr_c1644b5b-3ca4-45b4-97c6-a2a0de70d469`. Legacy players can have old IDs in the form of `8JoV9XEdpo`. The ID can never be changed.
#[serde(rename = "ownerId")]
pub owner_id: String,
pub owner_id: std::sync::Arc<str>,
#[serde(rename = "data", skip_serializing_if = "Option::is_none")]
pub data: Option<serde_json::Value>,
}
impl Permission {
pub fn new(id: String, owner_display_name: String, name: String, owner_id: String) -> Permission {
pub fn new(id: std::sync::Arc<str>, owner_display_name: std::sync::Arc<str>, name: std::sync::Arc<str>, owner_id: std::sync::Arc<str>) -> Permission {
Permission {
id,
owner_display_name,

16
src/models/player_moderation.rs
View File

@ -9,28 +9,28 @@
use crate::models;
use serde::{Deserialize, Serialize};
#[derive(Clone, Default, Debug, PartialEq, Serialize, Deserialize)]
#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
pub struct PlayerModeration {
#[serde(rename = "created")]
pub created: String,
pub created: std::sync::Arc<str>,
#[serde(rename = "id")]
pub id: String,
pub id: std::sync::Arc<str>,
#[serde(rename = "sourceDisplayName")]
pub source_display_name: String,
pub source_display_name: std::sync::Arc<str>,
/// A users unique ID, usually in the form of `usr_c1644b5b-3ca4-45b4-97c6-a2a0de70d469`. Legacy players can have old IDs in the form of `8JoV9XEdpo`. The ID can never be changed.
#[serde(rename = "sourceUserId")]
pub source_user_id: String,
pub source_user_id: std::sync::Arc<str>,
#[serde(rename = "targetDisplayName")]
pub target_display_name: String,
pub target_display_name: std::sync::Arc<str>,
/// A users unique ID, usually in the form of `usr_c1644b5b-3ca4-45b4-97c6-a2a0de70d469`. Legacy players can have old IDs in the form of `8JoV9XEdpo`. The ID can never be changed.
#[serde(rename = "targetUserId")]
pub target_user_id: String,
pub target_user_id: std::sync::Arc<str>,
#[serde(rename = "type")]
pub r#type: models::PlayerModerationType,
}
impl PlayerModeration {
pub fn new(created: String, id: String, source_display_name: String, source_user_id: String, target_display_name: String, target_user_id: String, r#type: models::PlayerModerationType) -> PlayerModeration {
pub fn new(created: std::sync::Arc<str>, id: std::sync::Arc<str>, source_display_name: std::sync::Arc<str>, source_user_id: std::sync::Arc<str>, target_display_name: std::sync::Arc<str>, target_user_id: std::sync::Arc<str>, r#type: models::PlayerModerationType) -> PlayerModeration {
PlayerModeration {
created,
id,

22
src/models/represented_group.rs
View File

@ -9,33 +9,33 @@
use crate::models;
use serde::{Deserialize, Serialize};
#[derive(Clone, Default, Debug, PartialEq, Serialize, Deserialize)]
#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
pub struct RepresentedGroup {
#[serde(rename = "name", skip_serializing_if = "Option::is_none")]
pub name: Option<String>,
pub name: Option<std::sync::Arc<str>>,
#[serde(rename = "shortCode", skip_serializing_if = "Option::is_none")]
pub short_code: Option<String>,
pub short_code: Option<std::sync::Arc<str>>,
#[serde(rename = "discriminator", skip_serializing_if = "Option::is_none")]
pub discriminator: Option<String>,
pub discriminator: Option<std::sync::Arc<str>>,
#[serde(rename = "description", skip_serializing_if = "Option::is_none")]
pub description: Option<String>,
pub description: Option<std::sync::Arc<str>>,
#[serde(rename = "iconId", default, with = "::serde_with::rust::double_option", skip_serializing_if = "Option::is_none")]
pub icon_id: Option<Option<String>>,
pub icon_id: Option<Option<std::sync::Arc<str>>>,
#[serde(rename = "iconUrl", default, with = "::serde_with::rust::double_option", skip_serializing_if = "Option::is_none")]
pub icon_url: Option<Option<String>>,
pub icon_url: Option<Option<std::sync::Arc<str>>>,
#[serde(rename = "bannerId", default, with = "::serde_with::rust::double_option", skip_serializing_if = "Option::is_none")]
pub banner_id: Option<Option<String>>,
pub banner_id: Option<Option<std::sync::Arc<str>>>,
#[serde(rename = "bannerUrl", default, with = "::serde_with::rust::double_option", skip_serializing_if = "Option::is_none")]
pub banner_url: Option<Option<String>>,
pub banner_url: Option<Option<std::sync::Arc<str>>>,
#[serde(rename = "privacy", skip_serializing_if = "Option::is_none")]
pub privacy: Option<models::GroupPrivacy>,
/// A users unique ID, usually in the form of `usr_c1644b5b-3ca4-45b4-97c6-a2a0de70d469`. Legacy players can have old IDs in the form of `8JoV9XEdpo`. The ID can never be changed.
#[serde(rename = "ownerId", skip_serializing_if = "Option::is_none")]
pub owner_id: Option<String>,
pub owner_id: Option<std::sync::Arc<str>>,
#[serde(rename = "memberCount", skip_serializing_if = "Option::is_none")]
pub member_count: Option<i32>,
#[serde(rename = "groupId", skip_serializing_if = "Option::is_none")]
pub group_id: Option<String>,
pub group_id: Option<std::sync::Arc<str>>,
#[serde(rename = "memberVisibility", skip_serializing_if = "Option::is_none")]
pub member_visibility: Option<models::GroupUserVisibility>,
#[serde(rename = "isRepresenting", skip_serializing_if = "Option::is_none")]

2
src/models/request_invite_request.rs
View File

@ -9,7 +9,7 @@
use crate::models;
use serde::{Deserialize, Serialize};
#[derive(Clone, Default, Debug, PartialEq, Serialize, Deserialize)]
#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
pub struct RequestInviteRequest {
#[serde(rename = "messageSlot", skip_serializing_if = "Option::is_none")]
pub message_slot: Option<i32>,

2
src/models/respond_group_join_request.rs
View File

@ -9,7 +9,7 @@
use crate::models;
use serde::{Deserialize, Serialize};
#[derive(Clone, Default, Debug, PartialEq, Serialize, Deserialize)]
#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
pub struct RespondGroupJoinRequest {
#[serde(rename = "action")]
pub action: models::GroupJoinRequestAction,

4
src/models/response.rs
View File

@ -9,10 +9,10 @@
use crate::models;
use serde::{Deserialize, Serialize};
#[derive(Clone, Default, Debug, PartialEq, Serialize, Deserialize)]
#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
pub struct Response {
#[serde(rename = "message", skip_serializing_if = "Option::is_none")]
pub message: Option<String>,
pub message: Option<std::sync::Arc<str>>,
#[serde(rename = "status_code")]
pub status_code: i32,
}

16
src/models/sent_notification.rs
View File

@ -10,31 +10,31 @@ use crate::models;
use serde::{Deserialize, Serialize};
/// SentNotification :
#[derive(Clone, Default, Debug, PartialEq, Serialize, Deserialize)]
#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
pub struct SentNotification {
#[serde(rename = "created_at")]
pub created_at: String,
pub created_at: std::sync::Arc<str>,
#[serde(rename = "details")]
pub details: serde_json::Value,
#[serde(rename = "id")]
pub id: String,
pub id: std::sync::Arc<str>,
#[serde(rename = "message")]
pub message: String,
pub message: std::sync::Arc<str>,
/// A users unique ID, usually in the form of `usr_c1644b5b-3ca4-45b4-97c6-a2a0de70d469`. Legacy players can have old IDs in the form of `8JoV9XEdpo`. The ID can never be changed.
#[serde(rename = "receiverUserId")]
pub receiver_user_id: String,
pub receiver_user_id: std::sync::Arc<str>,
/// A users unique ID, usually in the form of `usr_c1644b5b-3ca4-45b4-97c6-a2a0de70d469`. Legacy players can have old IDs in the form of `8JoV9XEdpo`. The ID can never be changed.
#[serde(rename = "senderUserId")]
pub sender_user_id: String,
pub sender_user_id: std::sync::Arc<str>,
/// -| **DEPRECATED:** VRChat API no longer return usernames of other users. [See issue by Tupper for more information](https://github.com/pypy-vrc/VRCX/issues/429).
#[serde(rename = "senderUsername", skip_serializing_if = "Option::is_none")]
pub sender_username: Option<String>,
pub sender_username: Option<std::sync::Arc<str>>,
#[serde(rename = "type")]
pub r#type: models::NotificationType,
}
impl SentNotification {
pub fn new(created_at: String, details: serde_json::Value, id: String, message: String, receiver_user_id: String, sender_user_id: String, r#type: models::NotificationType) -> SentNotification {
pub fn new(created_at: std::sync::Arc<str>, details: serde_json::Value, id: std::sync::Arc<str>, message: std::sync::Arc<str>, receiver_user_id: std::sync::Arc<str>, sender_user_id: std::sync::Arc<str>, r#type: models::NotificationType) -> SentNotification {
SentNotification {
created_at,
details,

18
src/models/subscription.rs
View File

@ -10,24 +10,24 @@ use crate::models;
use serde::{Deserialize, Serialize};
/// Subscription :
#[derive(Clone, Default, Debug, PartialEq, Serialize, Deserialize)]
#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
pub struct Subscription {
#[serde(rename = "id")]
pub id: String,
pub id: std::sync::Arc<str>,
#[serde(rename = "steamItemId")]
pub steam_item_id: String,
pub steam_item_id: std::sync::Arc<str>,
#[serde(rename = "oculusSku", skip_serializing_if = "Option::is_none")]
pub oculus_sku: Option<String>,
pub oculus_sku: Option<std::sync::Arc<str>>,
#[serde(rename = "googleProductId", skip_serializing_if = "Option::is_none")]
pub google_product_id: Option<String>,
pub google_product_id: Option<std::sync::Arc<str>>,
#[serde(rename = "googlePlanId", skip_serializing_if = "Option::is_none")]
pub google_plan_id: Option<String>,
pub google_plan_id: Option<std::sync::Arc<str>>,
#[serde(rename = "picoSku", skip_serializing_if = "Option::is_none")]
pub pico_sku: Option<String>,
pub pico_sku: Option<std::sync::Arc<str>>,
#[serde(rename = "amount")]
pub amount: f64,
#[serde(rename = "description")]
pub description: String,
pub description: std::sync::Arc<str>,
#[serde(rename = "period")]
pub period: models::SubscriptionPeriod,
#[serde(rename = "tier")]
@ -35,7 +35,7 @@ pub struct Subscription {
}
impl Subscription {
pub fn new(id: String, steam_item_id: String, amount: f64, description: String, period: models::SubscriptionPeriod, tier: f64) -> Subscription {
pub fn new(id: std::sync::Arc<str>, steam_item_id: std::sync::Arc<str>, amount: f64, description: std::sync::Arc<str>, period: models::SubscriptionPeriod, tier: f64) -> Subscription {
Subscription {
id,
steam_item_id,

2
src/models/success.rs
View File

@ -9,7 +9,7 @@
use crate::models;
use serde::{Deserialize, Serialize};
#[derive(Clone, Default, Debug, PartialEq, Serialize, Deserialize)]
#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
pub struct Success {
#[serde(rename = "success", skip_serializing_if = "Option::is_none")]
pub success: Option<Box<models::Response>>,

1059
src/models/tags.rs Normal file
View File

File diff suppressed because it is too large Load Diff

16
src/models/transaction.rs
View File

@ -10,15 +10,15 @@ use crate::models;
use serde::{Deserialize, Serialize};
/// Transaction :
#[derive(Clone, Default, Debug, PartialEq, Serialize, Deserialize)]
#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
pub struct Transaction {
#[serde(rename = "id")]
pub id: String,
pub id: std::sync::Arc<str>,
/// A users unique ID, usually in the form of `usr_c1644b5b-3ca4-45b4-97c6-a2a0de70d469`. Legacy players can have old IDs in the form of `8JoV9XEdpo`. The ID can never be changed.
#[serde(rename = "userId", skip_serializing_if = "Option::is_none")]
pub user_id: Option<String>,
pub user_id: Option<std::sync::Arc<str>>,
#[serde(rename = "userDisplayName", skip_serializing_if = "Option::is_none")]
pub user_display_name: Option<String>,
pub user_display_name: Option<std::sync::Arc<str>>,
#[serde(rename = "status")]
pub status: models::TransactionStatus,
#[serde(rename = "subscription")]
@ -26,15 +26,15 @@ pub struct Transaction {
#[serde(rename = "sandbox")]
pub sandbox: bool,
#[serde(rename = "created_at")]
pub created_at: String,
pub created_at: std::sync::Arc<str>,
#[serde(rename = "updated_at")]
pub updated_at: String,
pub updated_at: std::sync::Arc<str>,
#[serde(rename = "steam", skip_serializing_if = "Option::is_none")]
pub steam: Option<Box<models::TransactionSteamInfo>>,
#[serde(rename = "agreement", skip_serializing_if = "Option::is_none")]
pub agreement: Option<Box<models::TransactionAgreement>>,
#[serde(rename = "error")]
pub error: String,
pub error: std::sync::Arc<str>,
#[serde(rename = "isGift", skip_serializing_if = "Option::is_none")]
pub is_gift: Option<bool>,
#[serde(rename = "isTokens", skip_serializing_if = "Option::is_none")]
@ -42,7 +42,7 @@ pub struct Transaction {
}
impl Transaction {
pub fn new(id: String, status: models::TransactionStatus, subscription: models::Subscription, sandbox: bool, created_at: String, updated_at: String, error: String) -> Transaction {
pub fn new(id: std::sync::Arc<str>, status: models::TransactionStatus, subscription: models::Subscription, sandbox: bool, created_at: std::sync::Arc<str>, updated_at: std::sync::Arc<str>, error: std::sync::Arc<str>) -> Transaction {
Transaction {
id,
user_id: None,

26
src/models/transaction_agreement.rs
View File

@ -10,37 +10,37 @@ use crate::models;
use serde::{Deserialize, Serialize};
/// TransactionAgreement : Represents a single Transaction, which is likely between VRChat and Steam.
#[derive(Clone, Default, Debug, PartialEq, Serialize, Deserialize)]
#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
pub struct TransactionAgreement {
#[serde(rename = "agreementId")]
pub agreement_id: String,
pub agreement_id: std::sync::Arc<str>,
#[serde(rename = "itemId")]
pub item_id: f64,
#[serde(rename = "agreement")]
pub agreement: String,
pub agreement: std::sync::Arc<str>,
/// This is NOT TransactionStatus, but whatever Steam return.
#[serde(rename = "status")]
pub status: String,
pub status: std::sync::Arc<str>,
#[serde(rename = "period")]
pub period: String,
pub period: std::sync::Arc<str>,
#[serde(rename = "frequency")]
pub frequency: f64,
#[serde(rename = "billingType")]
pub billing_type: String,
pub billing_type: std::sync::Arc<str>,
#[serde(rename = "startDate")]
pub start_date: String,
pub start_date: std::sync::Arc<str>,
#[serde(rename = "endDate")]
pub end_date: String,
pub end_date: std::sync::Arc<str>,
#[serde(rename = "recurringAmt")]
pub recurring_amt: f64,
#[serde(rename = "currency")]
pub currency: String,
pub currency: std::sync::Arc<str>,
#[serde(rename = "timeCreated")]
pub time_created: String,
pub time_created: std::sync::Arc<str>,
#[serde(rename = "nextPayment")]
pub next_payment: String,
pub next_payment: std::sync::Arc<str>,
#[serde(rename = "lastPayment")]
pub last_payment: String,
pub last_payment: std::sync::Arc<str>,
#[serde(rename = "lastAmount")]
pub last_amount: f64,
#[serde(rename = "lastAmountVat")]
@ -53,7 +53,7 @@ pub struct TransactionAgreement {
impl TransactionAgreement {
/// Represents a single Transaction, which is likely between VRChat and Steam.
pub fn new(agreement_id: String, item_id: f64, agreement: String, status: String, period: String, frequency: f64, billing_type: String, start_date: String, end_date: String, recurring_amt: f64, currency: String, time_created: String, next_payment: String, last_payment: String, last_amount: f64, last_amount_vat: f64, outstanding: f64, failed_attempts: f64) -> TransactionAgreement {
pub fn new(agreement_id: std::sync::Arc<str>, item_id: f64, agreement: std::sync::Arc<str>, status: std::sync::Arc<str>, period: std::sync::Arc<str>, frequency: f64, billing_type: std::sync::Arc<str>, start_date: std::sync::Arc<str>, end_date: std::sync::Arc<str>, recurring_amt: f64, currency: std::sync::Arc<str>, time_created: std::sync::Arc<str>, next_payment: std::sync::Arc<str>, last_payment: std::sync::Arc<str>, last_amount: f64, last_amount_vat: f64, outstanding: f64, failed_attempts: f64) -> TransactionAgreement {
TransactionAgreement {
agreement_id,
item_id,

12
src/models/transaction_steam_info.rs
View File

@ -10,26 +10,26 @@ use crate::models;
use serde::{Deserialize, Serialize};
/// TransactionSteamInfo :
#[derive(Clone, Default, Debug, PartialEq, Serialize, Deserialize)]
#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
pub struct TransactionSteamInfo {
#[serde(rename = "walletInfo")]
pub wallet_info: Box<models::TransactionSteamWalletInfo>,
/// Steam User ID
#[serde(rename = "steamId")]
pub steam_id: String,
pub steam_id: std::sync::Arc<str>,
/// Steam Order ID
#[serde(rename = "orderId")]
pub order_id: String,
pub order_id: std::sync::Arc<str>,
/// Empty
#[serde(rename = "steamUrl")]
pub steam_url: String,
pub steam_url: std::sync::Arc<str>,
/// Steam Transaction ID, NOT the same as VRChat TransactionID
#[serde(rename = "transId")]
pub trans_id: String,
pub trans_id: std::sync::Arc<str>,
}
impl TransactionSteamInfo {
pub fn new(wallet_info: models::TransactionSteamWalletInfo, steam_id: String, order_id: String, steam_url: String, trans_id: String) -> TransactionSteamInfo {
pub fn new(wallet_info: models::TransactionSteamWalletInfo, steam_id: std::sync::Arc<str>, order_id: std::sync::Arc<str>, steam_url: std::sync::Arc<str>, trans_id: std::sync::Arc<str>) -> TransactionSteamInfo {
TransactionSteamInfo {
wallet_info: Box::new(wallet_info),
steam_id,

12
src/models/transaction_steam_wallet_info.rs
View File

@ -10,20 +10,20 @@ use crate::models;
use serde::{Deserialize, Serialize};
/// TransactionSteamWalletInfo :
#[derive(Clone, Default, Debug, PartialEq, Serialize, Deserialize)]
#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
pub struct TransactionSteamWalletInfo {
#[serde(rename = "state")]
pub state: String,
pub state: std::sync::Arc<str>,
#[serde(rename = "country")]
pub country: String,
pub country: std::sync::Arc<str>,
#[serde(rename = "currency")]
pub currency: String,
pub currency: std::sync::Arc<str>,
#[serde(rename = "status")]
pub status: String,
pub status: std::sync::Arc<str>,
}
impl TransactionSteamWalletInfo {
pub fn new(state: String, country: String, currency: String, status: String) -> TransactionSteamWalletInfo {
pub fn new(state: std::sync::Arc<str>, country: std::sync::Arc<str>, currency: std::sync::Arc<str>, status: std::sync::Arc<str>) -> TransactionSteamWalletInfo {
TransactionSteamWalletInfo {
state,
country,

6
src/models/two_factor_auth_code.rs
View File

@ -9,14 +9,14 @@
use crate::models;
use serde::{Deserialize, Serialize};
#[derive(Clone, Default, Debug, PartialEq, Serialize, Deserialize)]
#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
pub struct TwoFactorAuthCode {
#[serde(rename = "code")]
pub code: String,
pub code: std::sync::Arc<str>,
}
impl TwoFactorAuthCode {
pub fn new(code: String) -> TwoFactorAuthCode {
pub fn new(code: std::sync::Arc<str>) -> TwoFactorAuthCode {
TwoFactorAuthCode {
code,
}

6
src/models/two_factor_email_code.rs
View File

@ -9,14 +9,14 @@
use crate::models;
use serde::{Deserialize, Serialize};
#[derive(Clone, Default, Debug, PartialEq, Serialize, Deserialize)]
#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
pub struct TwoFactorEmailCode {
#[serde(rename = "code")]
pub code: String,
pub code: std::sync::Arc<str>,
}
impl TwoFactorEmailCode {
pub fn new(code: String) -> TwoFactorEmailCode {
pub fn new(code: std::sync::Arc<str>) -> TwoFactorEmailCode {
TwoFactorEmailCode {
code,
}

22
src/models/unity_package.rs
View File

@ -10,39 +10,39 @@ use crate::models;
use serde::{Deserialize, Serialize};
/// UnityPackage :
#[derive(Clone, Default, Debug, PartialEq, Serialize, Deserialize)]
#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
pub struct UnityPackage {
#[serde(rename = "id")]
pub id: String,
pub id: std::sync::Arc<str>,
#[serde(rename = "assetUrl", default, with = "::serde_with::rust::double_option", skip_serializing_if = "Option::is_none")]
pub asset_url: Option<Option<String>>,
pub asset_url: Option<Option<std::sync::Arc<str>>>,
#[serde(rename = "assetUrlObject", skip_serializing_if = "Option::is_none")]
pub asset_url_object: Option<serde_json::Value>,
#[serde(rename = "assetVersion")]
pub asset_version: i32,
#[serde(rename = "created_at", skip_serializing_if = "Option::is_none")]
pub created_at: Option<String>,
pub created_at: Option<std::sync::Arc<str>>,
/// This can be `standalonewindows` or `android`, but can also pretty much be any random Unity verison such as `2019.2.4-801-Release` or `2019.2.2-772-Release` or even `unknownplatform`.
#[serde(rename = "platform")]
pub platform: String,
pub platform: std::sync::Arc<str>,
#[serde(rename = "pluginUrl", skip_serializing_if = "Option::is_none")]
pub plugin_url: Option<String>,
pub plugin_url: Option<std::sync::Arc<str>>,
#[serde(rename = "pluginUrlObject", skip_serializing_if = "Option::is_none")]
pub plugin_url_object: Option<serde_json::Value>,
#[serde(rename = "unitySortNumber", skip_serializing_if = "Option::is_none")]
pub unity_sort_number: Option<i64>,
#[serde(rename = "unityVersion")]
pub unity_version: String,
pub unity_version: std::sync::Arc<str>,
#[serde(rename = "impostorUrl", default, with = "::serde_with::rust::double_option", skip_serializing_if = "Option::is_none")]
pub impostor_url: Option<Option<String>>,
pub impostor_url: Option<Option<std::sync::Arc<str>>>,
#[serde(rename = "scanStatus", skip_serializing_if = "Option::is_none")]
pub scan_status: Option<String>,
pub scan_status: Option<std::sync::Arc<str>>,
#[serde(rename = "variant", skip_serializing_if = "Option::is_none")]
pub variant: Option<String>,
pub variant: Option<std::sync::Arc<str>>,
}
impl UnityPackage {
pub fn new(id: String, asset_version: i32, platform: String, unity_version: String) -> UnityPackage {
pub fn new(id: std::sync::Arc<str>, asset_version: i32, platform: std::sync::Arc<str>, unity_version: std::sync::Arc<str>) -> UnityPackage {
UnityPackage {
id,
asset_url: None,

18
src/models/update_avatar_request.rs
View File

@ -9,28 +9,28 @@
use crate::models;
use serde::{Deserialize, Serialize};
#[derive(Clone, Default, Debug, PartialEq, Serialize, Deserialize)]
#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
pub struct UpdateAvatarRequest {
#[serde(rename = "assetUrl", skip_serializing_if = "Option::is_none")]
pub asset_url: Option<String>,
pub asset_url: Option<std::sync::Arc<str>>,
#[serde(rename = "id", skip_serializing_if = "Option::is_none")]
pub id: Option<String>,
pub id: Option<std::sync::Arc<str>>,
#[serde(rename = "name", skip_serializing_if = "Option::is_none")]
pub name: Option<String>,
pub name: Option<std::sync::Arc<str>>,
#[serde(rename = "description", skip_serializing_if = "Option::is_none")]
pub description: Option<String>,
pub description: Option<std::sync::Arc<str>>,
#[serde(rename = "tags", skip_serializing_if = "Option::is_none")]
pub tags: Option<Vec<String>>,
pub tags: Option<Vec<std::sync::Arc<str>>>,
#[serde(rename = "imageUrl", skip_serializing_if = "Option::is_none")]
pub image_url: Option<String>,
pub image_url: Option<std::sync::Arc<str>>,
#[serde(rename = "releaseStatus", skip_serializing_if = "Option::is_none")]
pub release_status: Option<models::ReleaseStatus>,
#[serde(rename = "version", skip_serializing_if = "Option::is_none")]
pub version: Option<f64>,
#[serde(rename = "unityPackageUrl", skip_serializing_if = "Option::is_none")]
pub unity_package_url: Option<String>,
pub unity_package_url: Option<std::sync::Arc<str>>,
#[serde(rename = "unityVersion", skip_serializing_if = "Option::is_none")]
pub unity_version: Option<String>,
pub unity_version: Option<std::sync::Arc<str>>,
}
impl UpdateAvatarRequest {

6
src/models/update_favorite_group_request.rs
View File

@ -9,15 +9,15 @@
use crate::models;
use serde::{Deserialize, Serialize};
#[derive(Clone, Default, Debug, PartialEq, Serialize, Deserialize)]
#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
pub struct UpdateFavoriteGroupRequest {
#[serde(rename = "displayName", skip_serializing_if = "Option::is_none")]
pub display_name: Option<String>,
pub display_name: Option<std::sync::Arc<str>>,
#[serde(rename = "visibility", skip_serializing_if = "Option::is_none")]
pub visibility: Option<models::FavoriteGroupVisibility>,
/// Tags on FavoriteGroups are believed to do nothing.
#[serde(rename = "tags", skip_serializing_if = "Option::is_none")]
pub tags: Option<Vec<String>>,
pub tags: Option<Vec<std::sync::Arc<str>>>,
}
impl UpdateFavoriteGroupRequest {

14
src/models/update_group_gallery_request.rs
View File

@ -9,25 +9,25 @@
use crate::models;
use serde::{Deserialize, Serialize};
#[derive(Clone, Default, Debug, PartialEq, Serialize, Deserialize)]
#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
pub struct UpdateGroupGalleryRequest {
/// Name of the gallery.
#[serde(rename = "name", skip_serializing_if = "Option::is_none")]
pub name: Option<String>,
pub name: Option<std::sync::Arc<str>>,
/// Description of the gallery.
#[serde(rename = "description", skip_serializing_if = "Option::is_none")]
pub description: Option<String>,
pub description: Option<std::sync::Arc<str>>,
/// Whether the gallery is members only.
#[serde(rename = "membersOnly", skip_serializing_if = "Option::is_none")]
pub members_only: Option<bool>,
#[serde(rename = "roleIdsToView", default, with = "::serde_with::rust::double_option", skip_serializing_if = "Option::is_none")]
pub role_ids_to_view: Option<Option<Vec<String>>>,
pub role_ids_to_view: Option<Option<Vec<std::sync::Arc<str>>>>,
#[serde(rename = "roleIdsToSubmit", default, with = "::serde_with::rust::double_option", skip_serializing_if = "Option::is_none")]
pub role_ids_to_submit: Option<Option<Vec<String>>>,
pub role_ids_to_submit: Option<Option<Vec<std::sync::Arc<str>>>>,
#[serde(rename = "roleIdsToAutoApprove", default, with = "::serde_with::rust::double_option", skip_serializing_if = "Option::is_none")]
pub role_ids_to_auto_approve: Option<Option<Vec<String>>>,
pub role_ids_to_auto_approve: Option<Option<Vec<std::sync::Arc<str>>>>,
#[serde(rename = "roleIdsToManage", default, with = "::serde_with::rust::double_option", skip_serializing_if = "Option::is_none")]
pub role_ids_to_manage: Option<Option<Vec<String>>>,
pub role_ids_to_manage: Option<Option<Vec<std::sync::Arc<str>>>>,
}
impl UpdateGroupGalleryRequest {

Some files were not shown because too many files have changed in this diff Show More