diff --git a/idl/Microsoft.Xbox.Services.Achievements.idl b/idl/Microsoft.Xbox.Services.Achievements.idl
new file mode 100644
index 0000000..fa5739e
--- /dev/null
+++ b/idl/Microsoft.Xbox.Services.Achievements.idl
@@ -0,0 +1,138 @@
+namespace Microsoft.Xbox.Services.Achievements
+{
+    enum AchievementMediaAssetType
+    {
+        Unknown,
+        Icon,
+        Art,
+    };
+
+    enum AchievementOrderBy
+    {
+        Default,
+        TitleId,
+        UnlockTime,
+    };
+
+    enum AchievementParticipationType
+    {
+        Unknown,
+        Individual,
+        Group,
+    };
+
+    enum AchievementProgressState
+    {
+        Unknown,
+        Achieved,
+        NotStarted,
+        InProgress,
+    };
+
+    enum AchievementRewardType
+    {
+        Unknown,
+        Gamerscore,
+        InApp,
+        Art,
+    };
+
+    enum AchievementType
+    {
+        Unknown,
+        All,
+        Persistent,
+        Challenge,
+    };
+
+    [interface_name("__IAchievementPublicNonVirtuals", 82424441-5E17-32E3-AD51-8D1010C911B1)]
+    runtimeclass Achievement
+    {
+        String Id { get; };
+        String ServiceConfigurationId { get; };
+        String Name { get; };
+        Windows.Foundation.Collections.IVectorView<AchievementTitleAssociation> TitleAssociations { get; };
+        AchievementProgressState ProgressState { get; };
+        AchievementProgression Progression { get; };
+        Windows.Foundation.Collections.IVectorView<AchievementMediaAsset> MediaAssets { get; };
+        Windows.Foundation.Collections.IVectorView<String> PlatformsAvailableOn { get; };
+        Boolean IsSecret { get; };
+        String UnlockedDescription { get; };
+        String LockedDescription { get; };
+        String ProductId { get; };
+        AchievementType AchievementType { get; };
+        AchievementParticipationType ParticipationType { get; };
+        AchievementTimeWindow Available { get; };
+        Windows.Foundation.Collections.IVectorView<AchievementReward> Rewards { get; };
+        Windows.Foundation.TimeSpan EstimatedUnlockTime { get; };
+        String DeepLink { get; };
+        Boolean IsRevoked { get; };
+    }
+
+    [interface_name("__IAchievementMediaAssetPublicNonVirtuals", 3CE72950-7EF1-369E-A510-BF4D26DCD129)]
+    runtimeclass AchievementMediaAsset
+    {
+        String Name { get; };
+        AchievementMediaAssetType MediaAssetType { get; };
+        String Url { get; };
+    }
+
+    [interface_name("__IAchievementProgressionPublicNonVirtuals", 63E20CA3-78E1-3587-A3DB-F1E6EC6FA1E9)]
+    runtimeclass AchievementProgression
+    {
+        Windows.Foundation.Collections.IVectorView<AchievementRequirement> Requirements { get; };
+        Windows.Foundation.DateTime TimeUnlocked { get; };
+    }
+
+    [interface_name("__IAchievementRequirementPublicNonVirtuals", 69D62348-8641-36E6-B097-3EB2C9F17E91)]
+    runtimeclass AchievementRequirement
+    {
+        String Id { get; };
+        String CurrentProgressValue { get; };
+        String TargetProgressValue { get; };
+    }
+
+    [interface_name("__IAchievementRewardPublicNonVirtuals", 634388A7-1CA8-3CE9-9711-16CE27DC3F24)]
+    runtimeclass AchievementReward
+    {
+        String Name { get; };
+        String Description { get; };
+        String Data { get; };
+        AchievementRewardType RewardType { get; };
+        Windows.Foundation.PropertyType ValuePropertyType { get; };
+        AchievementMediaAsset MediaAsset { get; };
+    }
+
+    [interface_name("__IAchievementServicePublicNonVirtuals", 09B122FA-0CDF-3F97-912C-0D37F444231D)]
+    runtimeclass AchievementService
+    {
+        [method_name("UpdateAchievementAsync2")]
+        Windows.Foundation.IAsyncAction UpdateAchievementAsync(String xboxUserId, String achievementId, UInt32 percentComplete);
+        [method_name("UpdateAchievementAsync1")]
+        Windows.Foundation.IAsyncAction UpdateAchievementAsync(String xboxUserId, UInt32 titleId, String serviceConfigurationId, String achievementId, UInt32 percentComplete);
+        Windows.Foundation.IAsyncOperation<AchievementsResult> GetAchievementsForTitleIdAsync(String xboxUserId, UInt32 titleId, AchievementType type, Boolean unlockedOnly, AchievementOrderBy orderBy, UInt32 skipItems, UInt32 maxItems);
+        Windows.Foundation.IAsyncOperation<Achievement> GetAchievementAsync(String xboxUserId, String serviceConfigurationId, String achievementId);
+    }
+
+    [interface_name("__IAchievementsResultPublicNonVirtuals", A5B75CB8-804B-3C73-A78A-701B7C027C04)]
+    runtimeclass AchievementsResult
+    {
+        Windows.Foundation.Collections.IVectorView<Achievement> Items { get; };
+        Windows.Foundation.IAsyncOperation<AchievementsResult> GetNextAsync(UInt32 maxItems);
+        Boolean HasNext { get; };
+    }
+
+    [interface_name("__IAchievementTimeWindowPublicNonVirtuals", 400B6A0C-CCB5-3385-A746-76AB089A524E)]
+    runtimeclass AchievementTimeWindow
+    {
+        Windows.Foundation.DateTime StartDate { get; };
+        Windows.Foundation.DateTime EndDate { get; };
+    }
+
+    [interface_name("__IAchievementTitleAssociationPublicNonVirtuals", 59AE7969-946B-330F-A6DC-CAE3A531DAF8)]
+    runtimeclass AchievementTitleAssociation
+    {
+        String Name { get; };
+        UInt32 TitleId { get; };
+    }
+}
\ No newline at end of file
diff --git a/idl/Microsoft.Xbox.Services.Clubs.idl b/idl/Microsoft.Xbox.Services.Clubs.idl
new file mode 100644
index 0000000..de46e9e
--- /dev/null
+++ b/idl/Microsoft.Xbox.Services.Clubs.idl
@@ -0,0 +1,253 @@
+namespace Microsoft.Xbox.Services.Clubs
+{
+    enum ClubRole
+    {
+        Nonmember,
+        Member,
+        Moderator,
+        Owner,
+        RequestedToJoin,
+        Recommended,
+        Invited,
+        Banned,
+        Follower,
+    };
+
+    enum ClubType
+    {
+        Unknown,
+        Public,
+        Private,
+        Hidden,
+    };
+
+    enum ClubUserPresence
+    {
+        NotInClub,
+        InClub,
+        Chat,
+        Feed,
+        Roster,
+        Play,
+        InGame,
+    };
+
+    [interface_name("__IClubPublicNonVirtuals", BDC5FD5A-B3A0-3E4B-995A-CCE8545DF7B2)]
+    runtimeclass Club
+    {
+        String Id { get; };
+        ClubType Type { get; };
+        Windows.Foundation.DateTime Created { get; };
+        String Owner { get; };
+        String TitleFamilyId { get; };
+        String TitleFamilyName { get; };
+        String ShortName { get; };
+        ClubProfile Profile { get; };
+        String GlyphImageUrl { get; };
+        String BannerImageUrl { get; };
+        Boolean IsClubSuspended { get; };
+        Windows.Foundation.DateTime SuspendedUntil { get; };
+        String FounderXuid { get; };
+        UInt32 FollowersCount { get; };
+        UInt32 PresenceCount { get; };
+        UInt32 PresenceTodayCount { get; };
+        UInt32 MembersCount { get; };
+        UInt32 ModeratorsCount { get; };
+        UInt32 RecommendedCount { get; };
+        UInt32 RequestedToJoinCount { get; };
+        UInt32 ReportCount { get; };
+        UInt32 ReporteItemsCount { get; };
+        ClubActionSettings ActionSettings { get; };
+        Windows.Foundation.Collections.IVectorView<ClubRole> ViewerRoles { get; };
+        Windows.Foundation.IAsyncOperation<ClubRoster> GetRosterAsync();
+        Windows.Foundation.IAsyncOperation<Windows.Foundation.Collections.IVectorView<ClubUserPresenceRecord> > GetClubUserPresenceRecordsAsync();
+        Windows.Foundation.IAsyncAction RenameClubAsync(String newName);
+        Windows.Foundation.IAsyncOperation<Windows.Foundation.Collections.IVectorView<ClubRole> > GetRolesAsync(String xuid);
+        [method_name("GetRoleRecordsAsync2")] 
+        Windows.Foundation.IAsyncOperation<Windows.Foundation.Collections.IVectorView<ClubRoleRecord> > GetRoleRecordsAsync();
+        [method_name("GetRoleRecordsAsync1")] 
+        Windows.Foundation.IAsyncOperation<Windows.Foundation.Collections.IVectorView<ClubRoleRecord> > GetRoleRecordsAsync(String xuid);
+        Windows.Foundation.IAsyncOperation<ClubPresenceCounts> GetPresenceCountsAsync();
+        Windows.Foundation.IAsyncAction SetPresenceWithinClubAsync(ClubUserPresence presence);
+        [method_name("AddUserToClubAsync2")] 
+        Windows.Foundation.IAsyncOperation<Windows.Foundation.Collections.IVectorView<ClubRole> > AddUserToClubAsync();
+        [method_name("AddUserToClubAsync1")] 
+        Windows.Foundation.IAsyncOperation<Windows.Foundation.Collections.IVectorView<ClubRole> > AddUserToClubAsync(String xuid);
+        [method_name("RemoveUserFromClubAsync2")] 
+        Windows.Foundation.IAsyncOperation<Windows.Foundation.Collections.IVectorView<ClubRole> > RemoveUserFromClubAsync();
+        [method_name("RemoveUserFromClubAsync1")] 
+        Windows.Foundation.IAsyncOperation<Windows.Foundation.Collections.IVectorView<ClubRole> > RemoveUserFromClubAsync(String xuid);
+        Windows.Foundation.IAsyncOperation<Windows.Foundation.Collections.IVectorView<ClubRole> > FollowClubAsync();
+        Windows.Foundation.IAsyncOperation<Windows.Foundation.Collections.IVectorView<ClubRole> > UnfollowClubAsync();
+        Windows.Foundation.IAsyncOperation<Windows.Foundation.Collections.IVectorView<ClubRole> > BanUserFromClubAsync(String xuid);
+        Windows.Foundation.IAsyncOperation<Windows.Foundation.Collections.IVectorView<ClubRole> > UnbanUserFromClubAsync(String xuid);
+        Windows.Foundation.IAsyncOperation<Windows.Foundation.Collections.IVectorView<ClubRole> > AddClubModeratorAsync(String xuid);
+        Windows.Foundation.IAsyncOperation<Windows.Foundation.Collections.IVectorView<ClubRole> > RemoveClubModeratorAsync(String xuid);
+    }
+
+    [interface_name("__IClubActionSettingPublicNonVirtuals", 6ECA8CC0-DC33-3349-95EA-737FAFC27ADA)]
+    runtimeclass ClubActionSetting
+    {
+        ClubRole RequiredRole { get; };
+        Windows.Foundation.Collections.IVectorView<ClubRole> AllowedValues { get; };
+        Boolean CanViewerChangeSetting { get; };
+        Boolean CanViewerAct { get; };
+    }
+
+    [interface_name("__IClubActionSettingsPublicNonVirtuals", 378800EF-598A-3D16-86AB-2503369A1655)]
+    runtimeclass ClubActionSettings
+    {
+        ClubActionSetting PostToFeed { get; };
+        ClubActionSetting ViewFeed { get; };
+        ClubActionSetting WriteInChat { get; };
+        ClubActionSetting ViewChat { get; };
+        ClubActionSetting SetChatTopic { get; };
+        ClubActionSetting JoinLookingForGame { get; };
+        ClubActionSetting CreateLookingForGame { get; };
+        ClubActionSetting ViewLookingForGame { get; };
+        ClubActionSetting InviteOrAcceptJoinRequests { get; };
+        ClubActionSetting KickOrBan { get; };
+        ClubActionSetting ViewRoster { get; };
+        ClubActionSetting UpdateProfile { get; };
+        ClubActionSetting DeleteProfile { get; };
+        ClubActionSetting ViewProfile { get; };
+    }
+
+    [interface_name("__IClubBooleanSettingPublicNonVirtuals", 731F040A-D7E1-34A1-B41F-5C77A1925341)]
+    runtimeclass ClubBooleanSetting
+    {
+        Boolean Value { get; };
+        Boolean CanViewerChangeSetting { get; };
+    }
+
+    [interface_name("__IClubPresenceCountsPublicNonVirtuals", D11CEF81-306F-3C92-BCA0-7FEF719D91DA)]
+    runtimeclass ClubPresenceCounts
+    {
+        UInt32 TotalCount { get; };
+        UInt32 HereNow { get; };
+        UInt32 HereToday { get; };
+        UInt32 InGameNow { get; };
+    }
+
+    [interface_name("__IClubProfilePublicNonVirtuals", 39A75E9F-7D2E-36EC-84A5-DB8D14E49FB3)]
+    runtimeclass ClubProfile
+    {
+        ClubStringSetting Name { get; };
+        ClubStringSetting Description { get; };
+        ClubBooleanSetting MatureContentEnabled { get; };
+        ClubBooleanSetting WatchClubTitlesOnly { get; };
+        ClubBooleanSetting IsSearchable { get; };
+        ClubBooleanSetting IsRecommendable { get; };
+        ClubBooleanSetting RequestToJoinEnabled { get; };
+        ClubBooleanSetting LeaveEnabled { get; };
+        ClubBooleanSetting TransferOwnershipEnabled { get; };
+        ClubStringSetting DisplayImageUrl { get; };
+        ClubStringSetting BackgroundImageUrl { get; };
+        ClubStringMultiSetting Tags { get; };
+        ClubStringSetting PreferredLocale { get; };
+        ClubStringMultiSetting AssociatedTitles { get; };
+        ClubStringSetting PrimaryColor { get; };
+        ClubStringSetting SecondayColor { get; };
+        ClubStringSetting TertiaryColor { get; };
+    }
+
+    [interface_name("__IClubRecommendationPublicNonVirtuals", 9B269AAE-E4CB-3956-9E7D-6FE7E9C950C3)]
+    runtimeclass ClubRecommendation
+    {
+        Club RecommendedClub { get; };
+        Windows.Foundation.Collections.IVectorView<String> Reasons { get; };
+    }
+
+    [interface_name("__IClubRoleRecordPublicNonVirtuals", 2BC260D8-0C2E-3A4A-B402-B898B0922D50)]
+    runtimeclass ClubRoleRecord
+    {
+        String Xuid { get; };
+        ClubRole Role { get; };
+        String ActorXuid { get; };
+        Windows.Foundation.DateTime CreatedDate { get; };
+    }
+
+    [interface_name("__IClubRosterPublicNonVirtuals", 37664663-3487-32DE-9E6D-96C70D85BDCA)]
+    runtimeclass ClubRoster
+    {
+        Windows.Foundation.Collections.IVectorView<ClubRoleRecord> Moderators { get; };
+        Windows.Foundation.Collections.IVectorView<ClubRoleRecord> RequestedToJoin { get; };
+        Windows.Foundation.Collections.IVectorView<ClubRoleRecord> Recommended { get; };
+        Windows.Foundation.Collections.IVectorView<ClubRoleRecord> Banned { get; };
+    }
+
+    [interface_name("__IClubSearchAutoCompletePublicNonVirtuals", D16F9653-CF60-3238-8C19-80EBDC0FF085)]
+    runtimeclass ClubSearchAutoComplete
+    {
+        String Id { get; };
+        String Name { get; };
+        String Description { get; };
+        String DisplayImageUrl { get; };
+        Double Score { get; };
+        String SuggestedQueryText { get; };
+        Windows.Foundation.Collections.IVectorView<String> Tags { get; };
+        Windows.Foundation.Collections.IVectorView<String> AssociatedTitles { get; };
+    }
+
+    [interface_name("__IClubSearchFacetResultPublicNonVirtuals", 5EC0011A-A9D6-3CC8-90B0-2A4DCF613994)]
+    runtimeclass ClubSearchFacetResult
+    {
+        String Value { get; };
+        UInt32 Count { get; };
+    }
+
+    [interface_name("__IClubsOwnedResultPublicNonVirtuals", 0175DE09-7A7A-31E1-92AE-9955DED4A006)]
+    runtimeclass ClubsOwnedResult
+    {
+        Windows.Foundation.Collections.IVectorView<String> ClubIds { get; };
+        UInt32 RemainingClubs { get; };
+    }
+
+    [interface_name("__IClubsSearchResultPublicNonVirtuals", FED28AF5-D3CD-34C8-9DBF-091E3136B01D)]
+    runtimeclass ClubsSearchResult
+    {
+        Windows.Foundation.Collections.IVectorView<Club> Clubs { get; };
+        Windows.Foundation.Collections.IMap<String, Windows.Foundation.Collections.IVectorView<ClubSearchFacetResult> > SearchFacetResults { get; };
+    }
+
+    [interface_name("__IClubsServicePublicNonVirtuals", 64E9FB60-A1D9-3324-88AB-CFEF6FAAC660)]
+    runtimeclass ClubsService
+    {
+        Windows.Foundation.IAsyncOperation<Club> GetClubAsync(String clubId);
+        Windows.Foundation.IAsyncOperation<Windows.Foundation.Collections.IVectorView<Club> > GetClubsAsync(Windows.Foundation.Collections.IVectorView<String> clubIds);
+        Windows.Foundation.IAsyncOperation<ClubsOwnedResult> GetClubsOwnedAsync();
+        Windows.Foundation.IAsyncOperation<Club> CreateClubAsync(String name, ClubType type, String titleFamilyId);
+        Windows.Foundation.IAsyncAction DeleteClubAsync(String clubId);
+        [method_name("GetClubAssociationsAsync2")] 
+        Windows.Foundation.IAsyncOperation<Windows.Foundation.Collections.IVectorView<Club> > GetClubAssociationsAsync();
+        [method_name("GetClubAssociationsAsync1")] 
+        Windows.Foundation.IAsyncOperation<Windows.Foundation.Collections.IVectorView<Club> > GetClubAssociationsAsync(String xuid);
+        Windows.Foundation.IAsyncOperation<Windows.Foundation.Collections.IVectorView<ClubRecommendation> > GetClubRecommendationsAsync();
+        Windows.Foundation.IAsyncOperation<ClubsSearchResult> SearchClubsAsync(String queryString, Windows.Foundation.Collections.IVectorView<String> titleIds, Windows.Foundation.Collections.IVectorView<String> tags);
+        Windows.Foundation.IAsyncOperation<Windows.Foundation.Collections.IVectorView<ClubSearchAutoComplete> > SuggestClubsAsync(String queryString, Windows.Foundation.Collections.IVectorView<String> titleIds, Windows.Foundation.Collections.IVectorView<String> tags);
+    }
+
+    [interface_name("__IClubStringMultiSettingPublicNonVirtuals", 7BA0E7EA-264A-3A17-A5B3-BC55EB54079C)]
+    runtimeclass ClubStringMultiSetting
+    {
+        Windows.Foundation.Collections.IVectorView<String> Values { get; };
+        Windows.Foundation.Collections.IVectorView<String> AllowedValues { get; };
+        Boolean CanViewerChangeSetting { get; };
+    }
+
+    [interface_name("__IClubStringSettingPublicNonVirtuals", 56DD2636-7E25-39A3-AF42-862ABAC7B407)]
+    runtimeclass ClubStringSetting
+    {
+        String Value { get; };
+        Windows.Foundation.Collections.IVectorView<String> AllowedValues { get; };
+        Boolean CanViewerChangeSetting { get; };
+    }
+
+    [interface_name("__IClubUserPresenceRecordPublicNonVirtuals", A30E1C5D-EBB3-3232-90AC-9527DA967139)]
+    runtimeclass ClubUserPresenceRecord
+    {
+        String Xuid { get; };
+        Windows.Foundation.DateTime LastSeen { get; };
+        ClubUserPresence LastSeenState { get; };
+    }
+}
\ No newline at end of file
diff --git a/idl/Microsoft.Xbox.Services.ContextualSearch.idl b/idl/Microsoft.Xbox.Services.ContextualSearch.idl
new file mode 100644
index 0000000..6b2768b
--- /dev/null
+++ b/idl/Microsoft.Xbox.Services.ContextualSearch.idl
@@ -0,0 +1,170 @@
+namespace Microsoft.Xbox.Services.ContextualSearch
+{
+    enum ContextualSearchFilterOperator
+    {
+        Equal,
+        NotEqual,
+        GreaterThan,
+        GreaterThanOrEqual,
+        LessThan,
+        LessThanOrEqual,
+    };
+
+    enum ContextualSearchGameClipThumbnailType
+    {
+        None,
+        SmallThumbnail,
+        LargeThumbnail,
+    };
+
+    enum ContextualSearchGameClipType
+    {
+        None,
+        DeveloperInitiated,
+        Achievement,
+        UserGenerated,
+    };
+
+    enum ContextualSearchGameClipUriType
+    {
+        None,
+        Original,
+        Download,
+        SmoothStreaming,
+        HttpLiveStreaming,
+    };
+
+    enum ContextualSearchStatDisplayType
+    {
+        Unknown,
+        UndefinedRange,
+        DefinedRange,
+        Set,
+    };
+
+    enum ContextualSearchStatVisibility
+    {
+        Unknown,
+        PublicVisibility,
+        PrivateVisibility,
+    };
+
+    [interface_name("__IContextualSearchBroadcastPublicNonVirtuals", 7A5CD441-8D2A-3A44-A08F-F443F757CBC4)]
+    runtimeclass ContextualSearchBroadcast
+    {
+        String XboxUserId { get; };
+        String Provider { get; };
+        String BroadcasterIdFromProvider { get; };
+        UInt64 Viewers { get; };
+        Windows.Foundation.DateTime StartedDate { get; };
+        Windows.Foundation.Collections.IMap<String, String> CurrentStats { get; };
+    }
+
+    [interface_name("__IContextualSearchConfiguredStatPublicNonVirtuals", F46C4EE0-F970-3AAA-86B7-54C114410726)]
+    runtimeclass ContextualSearchConfiguredStat
+    {
+        String Name { get; };
+        String DataType { get; };
+        ContextualSearchStatVisibility Visibility { get; };
+        String DisplayName { get; };
+        Boolean CanBeFiltered { get; };
+        Boolean CanBeSorted { get; };
+        ContextualSearchStatVisibility DisplayType { get; };
+        Windows.Foundation.Collections.IMap<String, String> ValueToDisplayName { get; };
+        UInt64 RangeMin { get; };
+        UInt64 RangeMax { get; };
+    }
+
+    [interface_name("__IContextualSearchGameClipPublicNonVirtuals", C615F72A-E034-3CFE-9525-208AA0B12D7C)]
+    runtimeclass ContextualSearchGameClip
+    {
+        String ClipName { get; };
+        UInt64 DurationInSeconds { get; };
+        String GameClipId { get; };
+        String GameClipLocale { get; };
+        Windows.Foundation.Collections.IVectorView<ContextualSearchGameClipUriInfo> GameClipUris { get; };
+        Windows.Foundation.Collections.IVectorView<ContextualSearchGameClipThumbnail> Thumbnails { get; };
+        ContextualSearchGameClipType GameClipType { get; };
+        UInt64 Views { get; };
+        String XboxUserId { get; };
+        Windows.Foundation.Collections.IVectorView<ContextualSearchGameClipStat> Stats { get; };
+    }
+
+    [interface_name("__IContextualSearchGameClipsResultPublicNonVirtuals", 6D5DC521-FF7B-3F99-A8D1-E3A034103270)]
+    runtimeclass ContextualSearchGameClipsResult
+    {
+        Windows.Foundation.IAsyncOperation<ContextualSearchGameClipsResult> GetNextAsync(UInt32 maxItems);
+        Windows.Foundation.Collections.IVectorView<ContextualSearchGameClip> Items { get; };
+    }
+
+    [interface_name("__IContextualSearchGameClipStatPublicNonVirtuals", 6C459652-6255-31A6-A09E-3D76EC893E9F)]
+    runtimeclass ContextualSearchGameClipStat
+    {
+        String Name { get; };
+        String Value { get; };
+        String MinValue { get; };
+        String MaxValue { get; };
+        String DeltaValue { get; };
+    }
+
+    [interface_name("__IContextualSearchGameClipThumbnailPublicNonVirtuals", 5967E0AB-A34E-3D0E-88BD-2119EBEB2420)]
+    runtimeclass ContextualSearchGameClipThumbnail
+    {
+        Windows.Foundation.Uri Url { get; };
+        UInt64 FileSize { get; };
+        ContextualSearchGameClipThumbnailType ThumbnailType { get; };
+    }
+
+    [interface_name("__IContextualSearchGameClipUriInfoPublicNonVirtuals", B5026641-7F95-3663-BBC7-E5986BD120C3)]
+    runtimeclass ContextualSearchGameClipUriInfo
+    {
+        Windows.Foundation.Uri Url { get; };
+        UInt64 FileSize { get; };
+        ContextualSearchGameClipUriType UriType { get; };
+        Windows.Foundation.DateTime Expiration { get; };
+    }
+
+    [interface_name("__IClubUserPresenceRecordPublicNonVirtuals", 5403F955-3CED-30D5-A8C1-D6598A78DFC1)]
+    runtimeclass ContextualSearchService
+    {
+        Windows.Foundation.IAsyncOperation<Windows.Foundation.Collections.IVectorView<ContextualSearchConfiguredStat> > GetConfigurationAsync(UInt32 titleId);
+        [method_name("GetBroadcastsAsync3")] 
+        Windows.Foundation.IAsyncOperation<Windows.Foundation.Collections.IVectorView<ContextualSearchBroadcast> > GetBroadcastsAsync(UInt32 titleId);
+        [method_name("GetBroadcastsAsync2")] 
+        Windows.Foundation.IAsyncOperation<Windows.Foundation.Collections.IVectorView<ContextualSearchBroadcast> > GetBroadcastsAsync(
+            UInt32 titleId,
+            UInt32 skipItems,
+            UInt32 maxItems,
+            String orderByStatName,
+            Boolean orderAscending,
+            String searchQuery);
+        [method_name("GetBroadcastsAsync1")] 
+        Windows.Foundation.IAsyncOperation<Windows.Foundation.Collections.IVectorView<ContextualSearchBroadcast> > GetBroadcastsAsync(
+            UInt32 titleId,
+            UInt32 skipItems,
+            UInt32 maxItems,
+            String orderByStatName,
+            Boolean orderAscending,
+            String filterStatName,
+            ContextualSearchFilterOperator filterOperator,
+            String filterStatValue);
+        [method_name("GetGameClipsAsync2")] 
+        Windows.Foundation.IAsyncOperation<ContextualSearchGameClipsResult> GetGameClipsAsync(
+            UInt32 titleId,
+            UInt32 skipItems,
+            UInt32 maxItems,
+            String orderByStatName,
+            Boolean orderAscending,
+            String filterStatName,
+            ContextualSearchFilterOperator filterOperator,
+            String filterStatValue);
+        [method_name("GetGameClipsAsync1")] 
+        Windows.Foundation.IAsyncOperation<ContextualSearchGameClipsResult> GetGameClipsAsync(
+            UInt32 titleId,
+            UInt32 skipItems,
+            UInt32 maxItems,
+            String orderByStatName,
+            Boolean orderAscending,
+            String searchQuery);
+    }
+}
\ No newline at end of file
diff --git a/idl/Microsoft.Xbox.Services.Events.idl b/idl/Microsoft.Xbox.Services.Events.idl
new file mode 100644
index 0000000..c2a8724
--- /dev/null
+++ b/idl/Microsoft.Xbox.Services.Events.idl
@@ -0,0 +1,11 @@
+namespace Microsoft.Xbox.Services.Events
+{
+    [interface_name("__IEventsServicePublicNonVirtuals", 260EC3FB-ABB2-3670-AC97-EBCDC85325B8)]
+    runtimeclass EventsService
+    {
+        [method_name("WriteInGameEvent2")] 
+        void WriteInGameEvent(String eventName);
+        [method_name("WriteInGameEvent1")] 
+        void WriteInGameEvent(String eventName, Windows.Foundation.Collections.PropertySet dimensions, Windows.Foundation.Collections.PropertySet measurements);
+    }
+}
\ No newline at end of file
diff --git a/idl/Microsoft.Xbox.Services.GameServerPlatform.idl b/idl/Microsoft.Xbox.Services.GameServerPlatform.idl
new file mode 100644
index 0000000..bf57735
--- /dev/null
+++ b/idl/Microsoft.Xbox.Services.GameServerPlatform.idl
@@ -0,0 +1,155 @@
+namespace Microsoft.Xbox.Services.GameServerPlatform
+{
+    enum GameServerFulfillmentState
+    {
+        Unknown,
+        Fulfilled,
+        Queued,
+        Aborted,
+    };
+
+    enum GameServerHostStatus
+    {
+        Unknown,
+        Active,
+        Queued,
+        Aborted,
+        Error,
+    };
+
+    [interface_name("__IAllocationResultPublicNonVirtuals", 3E22C098-732E-3939-9994-F14BB1B84340)]
+    runtimeclass AllocationResult
+    {
+        GameServerFulfillmentState FulfillmentState { get; };
+        String HostName { get; };
+        String SessionHostId { get; };
+        String Region { get; };
+        Windows.Foundation.Collections.IVectorView<GameServerPortMapping> PortMappings { get; };
+        String SecureDeviceAddress { get; };
+    }
+
+    [interface_name("__IClusterResultPublicNonVirtuals", 280460DE-C1B9-399E-BDA8-3128857F98B9)]
+    runtimeclass ClusterResult
+    {
+        Windows.Foundation.TimeSpan PollInterval { get; };
+        GameServerFulfillmentState FulfillmentState { get; };
+        String HostName { get; };
+        String Region { get; };
+        Windows.Foundation.Collections.IVectorView<GameServerPortMapping> PortMappings { get; };
+        String SecureDeviceAddress { get; };
+    }
+
+    [interface_name("__IGameServerImageSetPublicNonVirtuals", C4710FEB-8F0F-3CB3-A453-CCF2936F3267)]
+    runtimeclass GameServerImageSet
+    {
+        UInt64 MinPlayers { get; };
+        UInt64 MaxPlayers { get; };
+        String Id { get; };
+        String Name { get; };
+        UInt64 SelectionOrder { get; };
+        String SchemaContent { get; };
+        String SchemaName { get; };
+        String SchemaId { get; };
+        Windows.Foundation.Collections.IMap<String, String> Tags { get; };
+    }
+
+    [interface_name("__IGameServerMetadataResultPublicNonVirtuals", 95DCFF81-C19B-3CAE-9E7B-D97AFF1BEBB0)]
+    runtimeclass GameServerMetadataResult
+    {
+        Windows.Foundation.Collections.IVectorView<GameVariant> GameVariants { get; };
+        Windows.Foundation.Collections.IVectorView<GameServerImageSet> GameServerImageSets { get; };
+    }
+
+    [interface_name("__IGameServerPlatformServicePublicNonVirtuals", 1A690220-0FC1-3C16-8EB6-0041CD88E182)]
+    runtimeclass GameServerPlatformService
+    {
+        Windows.Foundation.IAsyncOperation<ClusterResult> AllocateClusterAsync(
+            UInt32 gameServerTitleId,
+            String serviceConfigurationId,
+            String sessionTemplateName,
+            String sessionName,
+            Boolean abortIfQueued);
+        Windows.Foundation.IAsyncOperation<ClusterResult> AllocateClusterInlineAsync(
+            UInt32 gameServerTitleId,
+            String serviceConfigurationId,
+            String sandboxId,
+            String ticketId,
+            String gsiSetId,
+            String gameVariantId,
+            UInt64 maxAllowedPlayers,
+            String location,
+            Boolean abortIfQueued);
+        Windows.Foundation.IAsyncOperation<GameServerTicketStatus> GetTicketStatusAsync(
+            UInt32 gameServerTitleId,
+            String ticketId);
+        [method_name("GetGameServerMetadataAsync2")] 
+        Windows.Foundation.IAsyncOperation<GameServerMetadataResult> GetGameServerMetadataAsync(
+            UInt32 titleId,
+            UInt32 maxAllowedPlayers,
+            Boolean publisherOnly,
+            UInt32 maxVariants,
+            String locale);
+        [method_name("GetGameServerMetadataAsync1")] 
+        Windows.Foundation.IAsyncOperation<GameServerMetadataResult> GetGameServerMetadataAsync(
+            UInt32 titleId,
+            UInt32 maxAllowedPlayers,
+            Boolean publisherOnly,
+            UInt32 maxVariants,
+            String locale,
+            Windows.Foundation.Collections.IMap<String, String> filterTags);
+        Windows.Foundation.IAsyncOperation<Windows.Foundation.Collections.IVectorView<QualityOfServiceServer> > GetQualityOfServiceServersAsync();
+        Windows.Foundation.IAsyncOperation<AllocationResult> AllocateSessionHost(
+            UInt32 gameServerTitleId,
+            Windows.Foundation.Collections.IVectorView<String> locations,
+            String sessionId,
+            String cloudGameId,
+            String gameModeId,
+            String sessionCookie);
+        Windows.Foundation.IAsyncOperation<AllocationResult> GetSessionHostAllocationStatus(
+            UInt32 gameServerTitleId,
+            String sessionId);
+    }
+
+    [interface_name("__IGameServerPortMappingPublicNonVirtuals", 3E1555B2-A11A-3897-83EE-B91BD866DE94)]
+    runtimeclass GameServerPortMapping
+    {
+        String PortName { get; };
+        UInt32 InternalPortNumber { get; };
+        UInt32 ExternalPortNumber { get; };
+    }
+
+    [interface_name("__IEventsServicePublicNonVirtuals", F8386A41-3F9B-3BDD-BA30-B80B72DCA633)]
+    runtimeclass GameServerTicketStatus
+    {
+        String TicketId { get; };
+        String ClusterId { get; };
+        UInt32 TitleId { get; };
+        String HostName { get; };
+        GameServerHostStatus Status { get; };
+        String Description { get; };
+        String SecureContext { get; };
+        Windows.Foundation.Collections.IVectorView<GameServerPortMapping> PortMappings { get; };
+        String GameHostId { get; };
+        String Region { get; };
+    }
+
+    [interface_name("__IGameVariantPublicNonVirtuals", 17D6E9E9-C8B3-3C00-98DF-84ED485AEC6D)]
+    runtimeclass GameVariant
+    {
+        String Id { get; };
+        String Name { get; };
+        Boolean IsPublisher { get; };
+        UInt64 Rank { get; };
+        String SchemaContent { get; };
+        String SchemaName { get; };
+        String SchemaId { get; };
+    }
+
+    [interface_name("__IQualityOfServiceServerPublicNonVirtuals", 1A5DD7A9-49E7-3167-BFC2-4DEC58720467)]
+    runtimeclass QualityOfServiceServer
+    {
+        String ServerFullQualifiedDomainName { get; };
+        String SecureDeviceAddressBase64 { get; };
+        String TargetLocation { get; };
+    }
+}
\ No newline at end of file
diff --git a/idl/Microsoft.Xbox.Services.Leaderboard.idl b/idl/Microsoft.Xbox.Services.Leaderboard.idl
new file mode 100644
index 0000000..fc0e6df
--- /dev/null
+++ b/idl/Microsoft.Xbox.Services.Leaderboard.idl
@@ -0,0 +1,170 @@
+namespace Microsoft.Xbox.Services.Leaderboard
+{
+    enum SortOrder
+    {
+        Ascending,
+        Descending,
+    };
+
+    [interface_name("__ILeaderboardColumnPublicNonVirtuals", 5AA7B403-39AB-358C-AFB7-F7161F958D49)]
+    runtimeclass LeaderboardColumn
+    {
+        String DisplayName { get; };
+        String StatisticName { get; };
+        Windows.Foundation.PropertyType StatisticType { get; };
+    }
+
+    [interface_name("__ILeaderboardQueryPublicNonVirtuals", FDA27C92-0698-36B7-8901-C94284C3CB1F)]
+    runtimeclass LeaderboardQuery
+    {
+        Boolean SkipResultToMe { get; set; };
+        UInt32 SkipResultToRank { get; set; };
+        UInt32 MaxItems { get; set; };
+        SortOrder Order { get; set; };
+        String StatName { get; };
+        String SocialGroup { get; };
+        Boolean HasNext { get; };
+    }
+
+    [interface_name("__ILeaderboardResultPublicNonVirtuals", 11BBB68A-409E-37AF-B493-22205E5DF3C8)]
+    runtimeclass LeaderboardResult
+    {
+        String DisplayName { get; };
+        UInt32 TotalRowCount { get; };
+        Windows.Foundation.Collections.IVectorView<LeaderboardColumn> Columns { get; };
+        Windows.Foundation.Collections.IVectorView<LeaderboardRow> Rows { get; };
+        Boolean HasNext { get; };
+        Windows.Foundation.IAsyncOperation<LeaderboardResult> GetNextAsync(UInt32 maxItems);
+        LeaderboardQuery GetNextQuery();
+    }
+
+    [interface_name("__ILeaderboardRowPublicNonVirtuals", BB067BA4-AA51-3FF1-9FD9-E26FC027DA62)]
+    runtimeclass LeaderboardRow
+    {
+        String Gamertag { get; };
+        String XboxUserId { get; };
+        Double Percentile { get; };
+        UInt32 Rank { get; };
+        Windows.Foundation.Collections.IVectorView<String> Values { get; };
+    }
+
+    [interface_name("__ILeaderboardServicePublicNonVirtuals", 37BD7FF3-0B31-3DAF-BC3F-B0F5301F2173)]
+    runtimeclass LeaderboardService
+    {
+        [method_name("GetLeaderboardAsync4")]
+        Windows.Foundation.IAsyncOperation<LeaderboardResult> GetLeaderboardAsync(
+            String serviceConfigurationId,
+            String leaderboardName);
+        [method_name("GetLeaderboardAsync3")]
+        Windows.Foundation.IAsyncOperation<LeaderboardResult> GetLeaderboardAsync(
+            String serviceConfigurationId,
+            String leaderboardName,
+            UInt32 skipToRank,
+            UInt32 maxItems);
+        [method_name("GetLeaderboardAsync2")]
+        Windows.Foundation.IAsyncOperation<LeaderboardResult> GetLeaderboardAsync(
+            String serviceConfigurationId,
+            String leaderboardName,
+            String xuid,
+            String socialGroup,
+            UInt32 maxItems);
+        [method_name("GetLeaderboardAsync1")]
+        Windows.Foundation.IAsyncOperation<LeaderboardResult> GetLeaderboardAsync(
+            String serviceConfigurationId,
+            String leaderboardName,
+            String xuid,
+            String socialGroup,
+            UInt32 skipToRank,
+            UInt32 maxItems);
+        [method_name("GetLeaderboardWithAdditionalColumnsAsync4")]
+        Windows.Foundation.IAsyncOperation<LeaderboardResult> GetLeaderboardWithAdditionalColumnsAsync(
+            String serviceConfigurationId,
+            String leaderboardName,
+            Windows.Foundation.Collections.IVectorView<String> additionalColumns);
+        [method_name("GetLeaderboardWithAdditionalColumnsAsync3")]
+        Windows.Foundation.IAsyncOperation<LeaderboardResult> GetLeaderboardWithAdditionalColumnsAsync(
+            String serviceConfigurationId,
+            String leaderboardName,
+            String xuid,
+            String socialGroup,
+            Windows.Foundation.Collections.IVectorView<String> additionalColumns,
+            UInt32 maxItems);
+        [method_name("GetLeaderboardWithAdditionalColumnsAsync2")]
+        Windows.Foundation.IAsyncOperation<LeaderboardResult> GetLeaderboardWithAdditionalColumnsAsync(
+            String serviceConfigurationId,
+            String leaderboardName,
+            UInt32 skipToRank,
+            Windows.Foundation.Collections.IVectorView<String> additionalColumns,
+            UInt32 maxItems);
+        [method_name("GetLeaderboardWithAdditionalColumnsAsync1")]
+        Windows.Foundation.IAsyncOperation<LeaderboardResult> GetLeaderboardWithAdditionalColumnsAsync(
+            String serviceConfigurationId,
+            String leaderboardName,
+            String xuid,
+            String socialGroup,
+            UInt32 skipToRank,
+            Windows.Foundation.Collections.IVectorView<String> additionalColumns,
+            UInt32 maxItems);
+        [method_name("GetLeaderboardWithSkipToUserAsync2")]
+        Windows.Foundation.IAsyncOperation<LeaderboardResult> GetLeaderboardWithSkipToUserAsync(
+            String serviceConfigurationId,
+            String leaderboardName,
+            String skipToXboxUserId,
+            UInt32 maxItems);
+        [method_name("GetLeaderboardWithSkipToUserAsync1")]
+        Windows.Foundation.IAsyncOperation<LeaderboardResult> GetLeaderboardWithSkipToUserAsync(
+            String serviceConfigurationId,
+            String leaderboardName,
+            String xuid,
+            String socialGroup,
+            String skipToXboxUserId,
+            UInt32 maxItems);
+        [method_name("GetLeaderboardWithSkipToUserWithAdditionalColumnsAsync2")]
+        Windows.Foundation.IAsyncOperation<LeaderboardResult> GetLeaderboardWithSkipToUserWithAdditionalColumnsAsync(
+            String serviceConfigurationId,
+            String leaderboardName,
+            String skipToXboxUserId,
+            Windows.Foundation.Collections.IVectorView<String> additionalColumns,
+            UInt32 maxItems);
+        [method_name("GetLeaderboardWithSkipToUserWithAdditionalColumnsAsync1")]
+        Windows.Foundation.IAsyncOperation<LeaderboardResult> GetLeaderboardWithSkipToUserWithAdditionalColumnsAsync(
+            String serviceConfigurationId,
+            String leaderboardName,
+            String xuid,
+            String socialGroup,
+            String skipToXboxUserId,
+            Windows.Foundation.Collections.IVectorView<String> additionalColumns,
+            UInt32 maxItems);
+        [method_name("GetLeaderboardForSocialGroupAsync2")]
+        Windows.Foundation.IAsyncOperation<LeaderboardResult> GetLeaderboardForSocialGroupAsync(
+            String xboxUserId,
+            String serviceConfigurationId,
+            String statisticName,
+            String socialGroup,
+            UInt32 maxItems);
+        [method_name("GetLeaderboardForSocialGroupAsync1")]
+        Windows.Foundation.IAsyncOperation<LeaderboardResult> GetLeaderboardForSocialGroupAsync(
+            String xboxUserId,
+            String serviceConfigurationId,
+            String statisticName,
+            String socialGroup,
+            String sortOrder,
+            UInt32 maxItems);
+        Windows.Foundation.IAsyncOperation<LeaderboardResult> GetLeaderboardForSocialGroupWithSkipToRankAsync(
+            String xboxUserId,
+            String serviceConfigurationId,
+            String statisticName,
+            String socialGroup,
+            UInt32 skipToRank,
+            String sortOrder,
+            UInt32 maxItems);
+        Windows.Foundation.IAsyncOperation<LeaderboardResult> GetLeaderboardForSocialGroupWithSkipToUserAsync(
+            String xboxUserId,
+            String serviceConfigurationId,
+            String statisticName,
+            String socialGroup,
+            String skipToXboxUserId,
+            String sortOrder,
+            UInt32 maxItems);
+    }
+}
\ No newline at end of file
diff --git a/idl/Microsoft.Xbox.Services.Matchmaking.idl b/idl/Microsoft.Xbox.Services.Matchmaking.idl
new file mode 100644
index 0000000..3ea914b
--- /dev/null
+++ b/idl/Microsoft.Xbox.Services.Matchmaking.idl
@@ -0,0 +1,68 @@
+import "Microsoft.Xbox.Services.Multiplayer.idl";
+namespace Microsoft.Xbox.Services.Matchmaking
+{
+    enum PreserveSessionMode
+    {
+        Unknown,
+        Always,
+        Never,
+    };
+
+    enum TicketStatus
+    {
+        Unknown,
+        Expired,
+        Searching,
+        Found,
+        Canceled,
+    };
+
+    [interface_name("__ICreateMatchTicketResponsePublicNonVirtuals", C8A4E252-CC3A-3C0F-92F2-127CEF0CF7AC)]
+    runtimeclass CreateMatchTicketResponse
+    {
+        String MatchTicketId { get; };
+        Windows.Foundation.TimeSpan EstimatedWaitTime { get; };
+    }
+
+    [interface_name("__IHopperStatisticsResponsePublicNonVirtuals", AC6AB0AE-BFCC-3C82-80D4-B64E4B5F9BBE)]
+    runtimeclass HopperStatisticsResponse
+    {
+        String HopperName { get; };
+        Windows.Foundation.TimeSpan EstimatedWaitTime { get; };
+        UInt32 PlayersWaitingToMatch { get; };
+    }
+
+    [interface_name("__IMatchmakingServicePublicNonVirtuals", 734B7637-E6F0-3AFA-AD16-AF54959436F7)]
+    runtimeclass MatchmakingService
+    {
+        Windows.Foundation.IAsyncOperation<CreateMatchTicketResponse> CreateMatchTicketAsync(
+            Microsoft.Xbox.Services.Multiplayer.MultiplayerSessionReference ticketSessionReference,
+            String matchmakingServiceConfigurationId,
+            String hopperName,
+            Windows.Foundation.TimeSpan ticketTimeout,
+            PreserveSessionMode preserveSession,
+            String ticketAttributesJson);
+        Windows.Foundation.IAsyncAction DeleteMatchTicketAsync(
+            String serviceConfigurationId,
+            String hopperName,
+            String ticketId);
+        Windows.Foundation.IAsyncOperation<MatchTicketDetailsResponse> GetMatchTicketDetailsAsync(
+            String serviceConfigurationId,
+            String hopperName,
+            String ticketId);
+        Windows.Foundation.IAsyncOperation<HopperStatisticsResponse> GetHopperStatisticsAsync(
+            String serviceConfigurationId,
+            String hopperName);
+    }
+
+    [interface_name("__IMatchTicketDetailsResponsePublicNonVirtuals", 8A2649C9-BE8F-3FC5-B78D-802B1833DD0B)]
+    runtimeclass MatchTicketDetailsResponse
+    {
+        TicketStatus MatchStatus { get; };
+        Windows.Foundation.TimeSpan EstimatedWaitTime { get; };
+        PreserveSessionMode PreserveSession { get; };
+        Microsoft.Xbox.Services.Multiplayer.MultiplayerSessionReference TicketSession { get; };
+        Microsoft.Xbox.Services.Multiplayer.MultiplayerSessionReference TargetSession { get; };
+        String TicketAttributes { get; };
+    }
+}
\ No newline at end of file
diff --git a/idl/Microsoft.Xbox.Services.Multiplayer.idl b/idl/Microsoft.Xbox.Services.Multiplayer.idl
new file mode 100644
index 0000000..ddf89e6
--- /dev/null
+++ b/idl/Microsoft.Xbox.Services.Multiplayer.idl
@@ -0,0 +1,702 @@
+import "Microsoft.Xbox.Services.idl";
+namespace Microsoft.Xbox.Services.Multiplayer
+{
+    enum MatchmakingStatus
+    {
+        Unknown,
+        None,
+        Searching,
+        Expired,
+        Found,
+        Canceled,
+    };
+
+    enum MultiplayerInitializationStage
+    {
+        Unknown,
+        None,
+        Joining,
+        Measuring,
+        Evaluating,
+        Failed,
+    };
+
+    enum MultiplayerMeasurementFailure
+    {
+        Unknown,
+        None,
+        Timeout,
+        Latency,
+        BandwidthUp,
+        BandwidthDown,
+        Group,
+        Network,
+        Episode,
+    };
+
+    enum MultiplayerSessionChangeTypes
+    {
+        None = 0,
+        Everything = 1,
+        HostDeviceTokenChange = 2,
+        InitializationStateChange = 4,
+        MatchmakingStatusChange = 8,
+        MemberListChange = 16,
+        MemberStatusChange = 32,
+        SessionJoinabilityChange = 64,
+        CustomPropertyChange = 128,
+        MemberCustomPropertyChange = 256,
+        TournamentPropertyChange = 512,
+        ArbitrationPropertyChange = 1024,
+    };
+
+    enum MultiplayerSessionMemberStatus
+    {
+        Reserved,
+        Inactive,
+        Ready,
+        Active,
+    };
+
+    enum MultiplayerSessionRestriction
+    {
+        Unknown,
+        None,
+        Local,
+        Followed,
+    };
+
+    enum MultiplayerSessionStatus
+    {
+        Unknown,
+        Active,
+        Inactive,
+        Reserved,
+    };
+
+    enum MultiplayerSessionVisibility
+    {
+        Unknown,
+        Any,
+        Private,
+        Visible,
+        Full,
+        Open,
+    };
+
+    enum MultiplayerSessionWriteMode
+    {
+        CreateNew,
+        UpdateOrCreateNew,
+        UpdateExisting,
+        SynchronizedUpdate,
+    };
+
+    enum MultiplayMetrics
+    {
+        Unknown,
+        BandwidthUp,
+        BandwidthDown,
+        Bandwidth,
+        Latency,
+    };
+
+    enum MutableRoleSetting
+    {
+        Max,
+        Target,
+    };
+
+    enum NetworkAddressTranslationSetting
+    {
+        Unknown,
+        Open,
+        Moderate,
+        Strict,
+    };
+
+    enum WriteSessionStatus
+    {
+        Unknown,
+        AccessDenied,
+        Created,
+        Conflict,
+        HandleNotFound,
+        OutOfSync,
+        SessionDeleted,
+        Updated,
+    };
+
+    [interface_name("__IMultiplayerActivityDetailsPublicNonVirtuals", 53305C6D-739B-376B-80E8-3326830AF6D8)]
+    runtimeclass MultiplayerActivityDetails
+    {
+        Microsoft.Xbox.Services.Multiplayer.MultiplayerSessionReference SessionReference { get; };
+        String HandleId { get; };
+        UInt32 TitleId { get; };
+        MultiplayerSessionVisibility Visibility { get; };
+        MultiplayerSessionRestriction JoinRestriction { get; };
+        Boolean Closed { get; };
+        String OwnerXboxUserId { get; };
+        UInt32 MaxMembersCount { get; };
+        UInt32 MembersCount { get; };
+        String CustomSessionPropertiesJson { get; };
+    }
+
+    [interface_name("__IMultiplayerGetSessionsRequestFactory", A6CC2F15-DD97-398D-9697-5714A1237154)]
+    runtimeclass MultiplayerGetSessionsRequest
+    {
+        MultiplayerGetSessionsRequest();
+        [constructor_name("__IMultiplayerGetSessionsRequestFactory", 6171E340-4846-3DFA-9E61-3F8B89F91AAA)]
+        {
+            MultiplayerGetSessionsRequest(String serviceConfigurationId, UInt32 maxItems);
+        }
+        String ServiceConfigurationId { get; };
+        UInt32 MaxItems { get; };
+        Boolean IncludePrivateSessions { get; set; };
+        Boolean IncludeReservations { get; set; };
+        Boolean IncludeInactiveSessions { get; set; };
+        String XboxUserIdFilter { get; set; };
+        Windows.Foundation.Collections.IVectorView<String> XboxUserIdsFilter { get; set; };
+        String KeywordFilter { get; set; };
+        String SessionTemplateNameFilter { get; set; };
+        MultiplayerSessionVisibility VisibilityFilter { get; set; };
+        UInt32 ContractVersionFilter { get; set; };
+    }
+
+    [interface_name("__IMultiplayerManagedInitializationPublicNonVirtuals", 3529F4B5-C8C3-3450-8C0B-ED9CCC7D3B43)]
+    runtimeclass MultiplayerManagedInitialization
+    {
+        Boolean ManagedInitializationSet { get; };
+        Windows.Foundation.TimeSpan JoinTimeout { get; };
+        Windows.Foundation.TimeSpan MeasurementTimeout { get; };
+        Windows.Foundation.TimeSpan EvaluationTimeout { get; };
+        Boolean AutoEvaluate { get; };
+        UInt32 MembersNeededToStart { get; };
+    }
+
+    [interface_name("__IMultiplayerMemberInitializationPublicNonVirtuals", EA083398-9FCE-3AE2-9675-58F864582BB3)]
+    runtimeclass MultiplayerMemberInitialization
+    {
+        Boolean MemberInitializationSet { get; };
+        Windows.Foundation.TimeSpan JoinTimeout { get; };
+        Windows.Foundation.TimeSpan MeasurementTimeout { get; };
+        Windows.Foundation.TimeSpan EvaluationTimeout { get; };
+        Boolean ExternalEvaluation { get; };
+        UInt32 MembersNeededToStart { get; };
+    }
+
+    [interface_name("__IMultiplayerPeerToHostRequirementsPublicNonVirtuals", D65923C4-377A-3D2A-B386-BBCC51DF563B)]
+    runtimeclass MultiplayerPeerToHostRequirements
+    {
+        Windows.Foundation.TimeSpan LatencyMaximum { get; };
+        UInt64 BandwidthDownMinimumInKilobitsPerSecond { get; };
+        UInt64 BandwidthUpMinimumInKilobitsPerSecond { get; };
+        MultiplayMetrics HostSelectionMetric { get; };
+    }
+
+    [interface_name("__IMultiplayerPeerToPeerRequirementsPublicNonVirtuals", 542B9A2F-2DBC-3531-AEA5-70A65A632798)]
+    runtimeclass MultiplayerPeerToPeerRequirements
+    {
+        Windows.Foundation.TimeSpan LatencyMaximum { get; };
+        UInt64 BandwidthMinimumInKilobitsPerSecond { get; };
+    }
+
+    [interface_name("__IMultiplayerQualityOfServiceMeasurementsPublicNonVirtuals", 59AE7969-946B-330F-A6DC-CAE3A531DAF8)]
+    runtimeclass MultiplayerQualityOfServiceMeasurements
+    {
+        MultiplayerQualityOfServiceMeasurements();
+        [constructor_name("__IMultiplayerQualityOfServiceMeasurementsFactory", 31F504A3-E299-30BB-8192-1499302DC716)]
+        {
+            MultiplayerQualityOfServiceMeasurements(String memberDeviceToken, Windows.Foundation.TimeSpan latency, UInt64 bandwidthDownInKilobitsPerSecond, 
+                UInt64 bandwidthUpInKilobitsPerSecond, String customJson);
+        }
+        String MemberDeviceToken { get; };
+        Windows.Foundation.TimeSpan Latency { get; };
+        UInt64 BandwidthDownInKilobitsPerSecond { get; };
+        UInt64 BandwidthUpInKilobitsPerSecond { get; };
+        String CustomJson { get; };
+    }
+
+    [interface_name("__IMultiplayerQuerySearchHandleRequestPublicNonVirtuals", 784DF025-7F33-3920-AE8C-E4FC5DD22613)]
+    runtimeclass MultiplayerQuerySearchHandleRequest
+    {
+        MultiplayerQuerySearchHandleRequest();
+        [constructor_name("__IMultiplayerQuerySearchHandleRequestFactory", 60FA4058-9047-3060-9259-6F2F1F2011EE)]
+        {
+            MultiplayerQuerySearchHandleRequest(String serviceConfigurationId, String sessionTemplateName);
+        }
+        String ServiceConfigurationId { get; };
+        String SessionTemplateName { get; };
+        String OrderBy { get; set; };
+        Boolean OrderAscending { get; set; };
+        String SearchFilter { get; set; };
+        String SocialGroup { get; set; };
+    }
+
+    [interface_name("__IMultiplayerRoleInfoPublicNonVirtuals", 6717C834-28D0-3B29-896C-900C92B3ADEA)]
+    runtimeclass MultiplayerRoleInfo
+    {
+        Windows.Foundation.Collections.IVectorView<String> MemberXboxUserIds { get; };
+        UInt32 MembersCount { get; };
+        UInt32 TargetCount { get; set; };
+        UInt32 MaxMembersCount { get; set; };
+    }
+
+    [interface_name("__IMultiplayerRoleTypePublicNonVirtuals", 3D91948B-802B-3B76-B2CA-5BE46AC3F286)]
+    runtimeclass MultiplayerRoleType
+    {
+        Boolean OwnerManaged { get; };
+        Windows.Foundation.Collections.IVectorView<MutableRoleSetting> MutableRoleSettings { get; };
+        Windows.Foundation.Collections.IMap<String, MultiplayerRoleInfo> Roles { get; set; };
+    }
+
+    [interface_name("__IMultiplayerSearchHandleDetailsPublicNonVirtuals", B5309ABB-C608-3FD9-B251-831155FB31B3)]
+    runtimeclass MultiplayerSearchHandleDetails
+    {
+        MultiplayerSessionReference SessionReference { get; };
+        String HandleId { get; };
+        Windows.Foundation.Collections.IVectorView<String> SessionOwnerXboxUserIds { get; };
+        Windows.Foundation.Collections.IVectorView<String> Tags { get; };
+        Windows.Foundation.Collections.IMap<String, Double> NumbersMetadata { get; };
+        Windows.Foundation.Collections.IMap<String, String> StringsMetadata { get; };
+        Windows.Foundation.Collections.IMap<String, MultiplayerRoleType> RoleTypes { get; };
+        MultiplayerSessionVisibility Visibility { get; };
+        MultiplayerSessionRestriction JoinRestriction { get; };
+        Boolean Closed { get; };
+        UInt32 MaxMembersCount { get; };
+        UInt32 MembersCount { get; };
+        Windows.Foundation.DateTime HandleCreationTime { get; };
+        String CustomSessionPropertiesJson { get; };
+    }
+
+    [interface_name("__IMultiplayerSearchHandleRequestPublicNonVirtuals", D19FF83D-3A08-304E-80E6-7783D4BDCDC8)]
+    runtimeclass MultiplayerSearchHandleRequest
+    {
+        MultiplayerSearchHandleRequest();
+        [constructor_name("__IMultiplayerSearchHandleRequestFactory", 26BA91FF-EFB0-31BA-A704-333B9B8C31E5)]
+        {
+            MultiplayerSearchHandleRequest(MultiplayerSessionReference sessionReference);
+        }
+        MultiplayerSessionReference SessionReference { get; };
+        Windows.Foundation.Collections.IVectorView<String> Tags { get; set; };
+        Windows.Foundation.Collections.IMap<String, Double> NumbersMetadata { get; set; };
+        Windows.Foundation.Collections.IMap<String, String> StringsMetadata { get; set; };
+    }
+
+    [interface_name("__IMultiplayerServicePublicNonVirtuals", 4B294BF8-4CF7-363F-9415-D35C8FC3F27C)]
+    runtimeclass MultiplayerService
+    {
+        [interface_name("__IMultiplayerServiceProtectedNonVirtuals", 046E9A52-2DC0-3789-B90B-054040CD9CC9)]
+        {
+        }
+        event Windows.Foundation.EventHandler<MultiplayerSessionChangeEventArgs> MultiplayerSessionChanged;
+        event Windows.Foundation.EventHandler<MultiplayerSubscriptionLostEventArgs> MultiplayerSubscriptionLost;
+        Windows.Foundation.IAsyncOperation<MultiplayerSession> WriteSessionAsync(
+            MultiplayerSession multiplayerSession,
+            MultiplayerSessionWriteMode multiplayerSessionWriteMode);
+        Windows.Foundation.IAsyncOperation<WriteSessionResult> TryWriteSessionAsync(
+            MultiplayerSession multiplayerSession,
+            MultiplayerSessionWriteMode multiplayerSessionWriteMode);
+        Windows.Foundation.IAsyncOperation<MultiplayerSession> WriteSessionByHandleAsync(
+            MultiplayerSession multiplayerSession,
+            MultiplayerSessionWriteMode multiplayerSessionWriteMode,
+            String handleId);
+        Windows.Foundation.IAsyncOperation<WriteSessionResult> TryWriteSessionByHandleAsync(
+            MultiplayerSession multiplayerSession,
+            MultiplayerSessionWriteMode multiplayerSessionWriteMode,
+            String handleId);
+        Windows.Foundation.IAsyncOperation<MultiplayerSession> GetCurrentSessionAsync(
+            MultiplayerSessionReference sessionReference);
+        Windows.Foundation.IAsyncOperation<MultiplayerSession> GetCurrentSessionByHandleAsync(String handleId);
+        [method_name("GetSessionsAsync2")]
+        Windows.Foundation.IAsyncOperation<Windows.Foundation.Collections.IVectorView<MultiplayerSessionStates> > GetSessionsAsync(MultiplayerGetSessionsRequest getSessionsRequest);
+        [method_name("GetSessionsAsync1")]
+        Windows.Foundation.IAsyncOperation<Windows.Foundation.Collections.IVectorView<MultiplayerSessionStates> > GetSessionsAsync(
+            String serviceConfigurationId,
+            String sessionTemplateNameFilter,
+            String xboxUserIdFilter,
+            String keywordFilter,
+            MultiplayerSessionVisibility visibilityFilter,
+            UInt32 contractVersionFilter,
+            Boolean includePrivateSessions,
+            Boolean includeReservations,
+            Boolean includeInactiveSessions,
+            UInt32 maxItems);
+        Windows.Foundation.IAsyncOperation<Windows.Foundation.Collections.IVectorView<MultiplayerSessionStates> > GetSessionsForUsersFilterAsync(
+            String serviceConfigurationId,
+            String sessionTemplateNameFilter,
+            Windows.Foundation.Collections.IVectorView<String> xboxUserIdsFilter,
+            String keywordFilter,
+            MultiplayerSessionVisibility visibilityFilter,
+            UInt32 contractVersionFilter,
+            Boolean includePrivateSessions,
+            Boolean includeReservations,
+            Boolean includeInactiveSessions,
+            UInt32 maxItems);
+        IAsyncAction SetActivityAsync(MultiplayerSessionReference sessionReference);
+        Windows.Foundation.IAsyncOperation<String> SetTransferHandleAsync(
+            MultiplayerSessionReference targetSessionReference,
+            MultiplayerSessionReference originSessionReference);
+        IAsyncAction SetSearchHandleAsync(MultiplayerSearchHandleRequest searchHandleRequest);
+        IAsyncAction ClearActivityAsync(String serviceConfigurationId);
+        IAsyncAction ClearSearchHandleAsync(String handleId);
+        [method_name("SendInvitesAsync2")]
+        Windows.Foundation.IAsyncOperation<Windows.Foundation.Collections.IVectorView<String> > SendInvitesAsync(
+            MultiplayerSessionReference sessionReference,
+            Windows.Foundation.Collections.IVectorView<String> xboxUserIds,
+            UInt32 titleId);
+        [method_name("SendInvitesAsync1")]
+        Windows.Foundation.IAsyncOperation<Windows.Foundation.Collections.IVectorView<String> > SendInvitesAsync(
+            MultiplayerSessionReference sessionReference,
+            Windows.Foundation.Collections.IVectorView<String> xboxUserIds,
+            UInt32 titleId,
+            String contextStringId,
+            String activationContext);
+        Windows.Foundation.IAsyncOperation<Windows.Foundation.Collections.IVectorView<MultiplayerActivityDetails> > GetActivitiesForSocialGroupAsync(
+            String serviceConfigurationId,
+            String socialGroupOwnerXboxUserId,
+            String socialGroup);
+        Windows.Foundation.IAsyncOperation<Windows.Foundation.Collections.IVectorView<MultiplayerActivityDetails> > GetActivitiesForUsersAsync(
+            String serviceConfigurationId,
+            Windows.Foundation.Collections.IVectorView<String> xboxUserIds);
+        [method_name("GetSearchHandlesAsync2")]
+        Windows.Foundation.IAsyncOperation<Windows.Foundation.Collections.IVectorView<MultiplayerSearchHandleDetails> > GetSearchHandlesAsync(
+            String serviceConfigurationId,
+            String sessionTemplateName,
+            String orderBy,
+            Boolean orderAscending,
+            String searchFilter);
+        [method_name("GetSearchHandlesAsync1")]
+        Windows.Foundation.IAsyncOperation<Windows.Foundation.Collections.IVectorView<MultiplayerSearchHandleDetails> > GetSearchHandlesAsync(
+            MultiplayerQuerySearchHandleRequest searchHandleRequest);
+        void EnableMultiplayerSubscriptions();
+        void DisableMultiplayerSubscriptions();
+        Boolean MultiplayerSubscriptionsEnabled { get; };
+    }
+
+    [interface_name("__IMultiplayerSessionPublicNonVirtuals", 8BCE98DE-EF37-3120-BB37-0DEA877A8AFE)]
+    [static_name("__IMultiplayerSessionStatics", 8821DA91-7CAB-3E33-A26B-07F139C4BBC8)]
+    runtimeclass MultiplayerSession
+    {
+        MultiplayerSession();
+        [constructor_name("__IMultiplayerSessionFactory", 8A63BF8F-E772-384F-A87F-82CC01EAF837)]
+        {
+            MultiplayerSession(Microsoft.Xbox.Services.XboxLiveContext xboxLiveContext);
+            MultiplayerSession(Microsoft.Xbox.Services.XboxLiveContext xboxLiveContext,
+                MultiplayerSessionReference multiplayerSessionReference,
+                UInt32 maxMembersInSession,
+                MultiplayerSessionVisibility multiplayerSessionVisibility,
+                Windows.Foundation.Collections.IVectorView<String> initiatorXboxUserIds,
+                String sessionCustomConstantsJson);
+            MultiplayerSession(Microsoft.Xbox.Services.XboxLiveContext xboxLiveContext, MultiplayerSessionReference multiplayerSessionReference);
+        }
+        static MultiplayerSessionChangeTypes CompareMultiplayerSessions(
+            MultiplayerSession currentSession,
+            MultiplayerSession oldSession);
+        static WriteSessionStatus ConvertHttpStatusToWriteSessionStatus(Int32 httpStatusCode);
+        String MultiplayerCorrelationId { get; };
+        String SearchHandleId { get; };
+        TournamentArbitrationStatus ArbitrationStatus { get; };
+        Windows.Foundation.DateTime StartTime { get; };
+        Windows.Foundation.DateTime DateOfNextTimer { get; };
+        Windows.Foundation.DateTime DateOfSession { get; };
+        MultiplayerInitializationStage InitializationStage { get; };
+        Windows.Foundation.DateTime InitializingStageStartTime { get; };
+        UInt32 InitializingEpisode { get; };
+        WriteSessionStatus WriteStatus { get; };
+        Windows.Foundation.Collections.IVectorView<String> HostCandidates { get; };
+        MultiplayerSessionReference SessionReference { get; };
+        MultiplayerSessionConstants SessionConstants { get; };
+        MultiplayerSessionProperties SessionProperties { get; };
+        MultiplayerSessionRoleTypes SessionRoleTypes { get; };
+        Windows.Foundation.Collections.IVectorView<MultiplayerSessionMember> Members { get; };
+        MultiplayerSessionMatchmakingServer MatchmakingServer { get; };
+        MultiplayerSessionTournamentsServer TournamentsServer { get; };
+        MultiplayerSessionArbitrationServer ArbitrationServer { get; };
+        UInt32 MembersAccepted { get; };
+        String ServersJson { get; set; };
+        String ETag { get; };
+        MultiplayerSessionChangeTypes SubscribedChangeTypes { get; };
+        MultiplayerSessionMember CurrentUser { get; };
+        String Branch { get; };
+        UInt64 ChangeNumber { get; };
+        [method_name("AddMemberReservation2")]
+        void AddMemberReservation(String xboxUserId, String memberCustomConstantsJson);
+        [method_name("AddMemberReservation1")]
+        void AddMemberReservation(
+            String xboxUserId,
+            String memberCustomConstantsJson,
+            Boolean initializeRequested);
+        [method_name("Join4")]
+        MultiplayerSessionMember Join();
+        [method_name("Join3")]
+        MultiplayerSessionMember Join(String memberCustomConstantsJson);
+        [method_name("Join2")]
+        MultiplayerSessionMember Join(String memberCustomConstantsJson, Boolean initializeRequested);
+        [method_name("Join1")]
+        MultiplayerSessionMember Join(
+            String memberCustomConstantsJson,
+            Boolean initializeRequested,
+            Boolean joinWithActiveStatus);
+        void SetVisibility(MultiplayerSessionVisibility visibility);
+        void SetMaxMembersInSession(UInt32 maxMembersInSession);
+        void SetMutableRoleSettings(
+            Windows.Foundation.Collections.IMap<String, MultiplayerRoleType> roleTypes);
+        void SetTimeouts(
+            Windows.Foundation.TimeSpan memberReservedTimeout,
+            Windows.Foundation.TimeSpan memberInactiveTimeout,
+            Windows.Foundation.TimeSpan memberReadyTimeout,
+            Windows.Foundation.TimeSpan sessionEmptyTimeout);
+        void SetArbitrationTimeouts(TimeSpan arbitrationTimeout, Windows.Foundation.TimeSpan forfeitTimeout);
+        void SetQualityOfServiceConnectivityMetrics(
+            Boolean enableLatencyMetric,
+            Boolean enableBandwidthDownMetric,
+            Boolean enableBandwidthUpMetric,
+            Boolean enableCustomMetric);
+        void SetManagedInitialization(
+            Windows.Foundation.TimeSpan joinTimeout,
+            Windows.Foundation.TimeSpan measurementTimeout,
+            Windows.Foundation.TimeSpan evaluationTimeout,
+            Boolean autoEvalute,
+            UInt32 membersNeededToStart);
+        void SetMemberInitialization(
+            Windows.Foundation.TimeSpan joinTimeout,
+            Windows.Foundation.TimeSpan measurementTimeout,
+            Windows.Foundation.TimeSpan evaluationTimeout,
+            Boolean autoEvalute,
+            UInt32 membersNeededToStart);
+        void SetPeerToPeerRequirements(TimeSpan latencyMaximum, UInt32 bandwidthMinimumInKilobitsPerSecond);
+        void SetPeerToHostRequirements(
+            Windows.Foundation.TimeSpan latencyMaximum,
+            UInt32 bandwidthDownMinimumInKilobitsPerSecond,
+            UInt32 bandwidthUpMinimumInKilobitsPerSecond,
+            MultiplayMetrics hostSelectionMetric);
+        void SetMeasurementServerAddresses(
+            Windows.Foundation.Collections.IVectorView<QualityOfServiceServer> measurementServerAddresses);
+        void SetCloudComputePackageJson(String sessionCloudComputePackageConstantsJson);
+        void SetSessionCapabilities(MultiplayerSessionCapabilities capabilities);
+        void SetInitializationStatus(Boolean initializationSucceeded);
+        void SetHostDeviceToken(String hostDeviceToken);
+        void SetMatchmakingServerConnectionPath(String serverConnectionPath);
+        void SetClosed(Boolean closed);
+        void SetLocked(Boolean locked);
+        void SetAllocateCloudCompute(Boolean allocateCloudCompute);
+        void SetMatchmakingResubmit(Boolean matchResubmit);
+        void SetServerConnectionStringCandidates(
+            Windows.Foundation.Collections.IVectorView<String> serverConnectionStringCandidates);
+        void SetSessionChangeSubscription(MultiplayerSessionChangeTypes changeTypes);
+        void Leave();
+        void SetCurrentUserStatus(MultiplayerSessionMemberStatus status);
+        void SetCurrentUserSecureDeviceAddressBase64(String value);
+        void SetCurrentUserRoleInfo(Windows.Foundation.Collections.IMap<String, String> roles);
+        void SetCurrentUserMembersInGroup(
+            Windows.Foundation.Collections.IVectorView<MultiplayerSessionMember> membersInGroup);
+        void SetCurrentUserQualityOfServiceMeasurements(
+            Windows.Foundation.Collections.IVectorView<MultiplayerQualityOfServiceMeasurements> measurements);
+        void SetCurrentUserQualityOfServiceServerMeasurementsJson(String valueJson);
+        void SetCurrentUserArbitrationResults(
+            Windows.Foundation.Collections.IMap<String, TournamentTeamResult> results);
+        void SetCurrentUserMemberCustomPropertyJson(String name, String valueJson);
+        void DeleteCurrentUserMemberCustomPropertyJson(String name);
+        void SetMatchmakingTargetSessionConstantsJson(String matchmakingTargetSessionConstants);
+        void SetSessionCustomPropertyJson(String name, String valueJson);
+        void DeleteSessionCustomPropertyJson(String name);
+        void _Init(
+            Microsoft.Xbox.Services.XboxLiveContext xboxLiveContext,
+            MultiplayerSessionReference multiplayerSessionReference,
+            UInt32 maxMembersInSession,
+            MultiplayerSessionVisibility multiplayerSessionVisibility,
+            Windows.Foundation.Collections.IVectorView<String> initiatorXboxUserIds,
+            String sessionCustomConstantsJson);
+    }
+
+    [interface_name("__IMultiplayerSessionArbitrationServerPublicNonVirtuals", 13D13CAA-6B68-341D-9676-B4F26CB5EB50)]
+    runtimeclass MultiplayerSessionArbitrationServer
+    {
+        Windows.Foundation.DateTime ArbitrationStartTime { get; };
+        TournamentArbitrationState ResultState { get; };
+        TournamentGameResultSource ResultSource { get; };
+        UInt32 ResultConfidenceLevel { get; };
+        Windows.Foundation.Collections.IMap<String, TournamentTeamResult> Results { get; };
+    }
+
+    [interface_name("__IMultiplayerSessionCapabilitiesPublicNonVirtuals", 65631F01-B22C-30C4-BCCC-6C22E25EF67B)]
+    runtimeclass MultiplayerSessionCapabilities
+    {
+        Boolean Connectivity { get; set; };
+        Boolean SuppressPresenceActivityCheck { get; set; };
+        Boolean Gameplay { get; set; };
+        Boolean Large { get; set; };
+        Boolean ConnectionRequiredForActiveMembers { get; set; };
+        Boolean UserAuthorizationStyle { get; set; };
+        Boolean Crossplay { get; set; };
+        Boolean Team { get; set; };
+        Boolean Arbitration { get; set; };
+        Boolean Searchable { get; set; };
+        Boolean HasOwners { get; set; };
+    }
+
+    [interface_name("__IMultiplayerSessionChangeEventArgsPublicNonVirtuals", 57CCF7F2-CA61-3015-9D79-FEBF8E9928FE)]
+    runtimeclass MultiplayerSessionChangeEventArgs
+    {
+        MultiplayerSessionReference SessionReference { get; };
+        String Branch { get; };
+        UInt64 ChangeNumber { get; };
+    }
+
+    [interface_name("__IMultiplayerSessionConstantsPublicNonVirtuals", 2B147D84-6481-39D6-9E13-DFA306842D56)]
+    runtimeclass MultiplayerSessionConstants
+    {
+        UInt32 MaxMembersInSession { get; set; };
+        MultiplayerSessionVisibility MultiplayerSessionVisibility { get; set; };
+        Windows.Foundation.Collections.IVectorView<String> InitiatorXboxUserIds { get; };
+        String CustomConstantsJson { get; };
+        Windows.Foundation.TimeSpan MemberReservationTimeout { get; };
+        Windows.Foundation.TimeSpan MemberInactiveTimeout { get; };
+        Windows.Foundation.TimeSpan MemberReadyTimeout { get; };
+        Windows.Foundation.TimeSpan SessionEmptyTimeout { get; };
+        Windows.Foundation.TimeSpan ArbitrationTimeout { get; };
+        Windows.Foundation.TimeSpan ForfeitTimeout { get; };
+        Boolean CapabilitiesConnectivity { get; };
+        Boolean CapabilitiesSuppressPresenceActivityCheck { get; };
+        Boolean CapabilitiesGameplay { get; };
+        Boolean CapabilitiesLarge { get; };
+        Boolean CapabilitiesConnectionRequiredForActiveMember { get; };
+        Boolean CapabilitiesCrossplay { get; };
+        Boolean CapabilitiesUserAuthorizationStyle { get; };
+        Boolean CapabilitiesTeam { get; };
+        Boolean CapabilitiesSearchable { get; };
+        Boolean CapabilitiesArbitration { get; };
+        Boolean EnableMetricsLatency { get; };
+        Boolean EnableMetricsBandwidthDown { get; };
+        Boolean EnableMetricsBandwidthUp { get; };
+        Boolean EnableMetricsCustom { get; };
+        MultiplayerManagedInitialization ManagedInitialization { get; };
+        MultiplayerMemberInitialization MemberInitialization { get; };
+        MultiplayerPeerToPeerRequirements PeerToPeerRequirements { get; };
+        MultiplayerPeerToHostRequirements PeerToHostRequirements { get; };
+        String MeasurementServerAddressesJson { get; };
+    }
+
+    [interface_name("__IMultiplayerSessionMatchmakingServerPublicNonVirtuals", 845BA528-399D-3ACC-94EE-2E9373060213)]
+    runtimeclass MultiplayerSessionMatchmakingServer
+    {
+        MatchmakingStatus Status { get; };
+        String StatusDetails { get; };
+        Windows.Foundation.TimeSpan TypicalWait { get; };
+        MultiplayerSessionReference TargetSessionRef { get; };
+    }
+
+    [interface_name("__IMultiplayerSessionMemberPublicNonVirtuals", E96A2AC6-40FF-3A82-B623-0672FF8ECA82)]
+    runtimeclass MultiplayerSessionMember
+    {
+        UInt32 MemberId { get; };
+        String TeamId { get; };
+        String XboxUserId { get; };
+        String MemberCustomConstantsJson { get; };
+        String SecureDeviceAddressBase64 { get; };
+        Windows.Foundation.Collections.IMap<String, String> Roles { get; };
+        String MemberCustomPropertiesJson { get; };
+        String Gamertag { get; };
+        MultiplayerSessionMemberStatus Status { get; };
+        Boolean IsTurnAvailable { get; };
+        Boolean IsCurrentUser { get; };
+        Boolean InitializeRequested { get; };
+        String MatchmakingResultServerMeasurementsJson { get; };
+        String MemberServerMeasurementsJson { get; };
+        Windows.Foundation.Collections.IVectorView<MultiplayerSessionMember> MembersInGroup { get; };
+        Windows.Foundation.Collections.IVectorView<MultiplayerQualityOfServiceMeasurements> MemberMeasurements { get; };
+        String DeviceToken { get; };
+        NetworkAddressTranslationSetting Nat { get; };
+        UInt32 ActiveTitleId { get; };
+        UInt32 InitializationEpisode { get; };
+        Windows.Foundation.DateTime JoinTime { get; };
+        MultiplayerMeasurementFailure InitializationFailureCause { get; };
+        MultiplayerSessionReference TournamentTeamSessionRef { get; };
+        Windows.Foundation.Collections.IVectorView<String> Groups { get; set; };
+        Windows.Foundation.Collections.IVectorView<String> Encounters { get; set; };
+        Windows.Foundation.Collections.IMap<String, TournamentTeamResult> Results { get; };
+        TournamentArbitrationStatus ArbitrationStatus { get; };
+    }
+
+    [interface_name("__IMultiplayerSessionPropertiesPublicNonVirtuals", 07C42B10-B64C-3F8B-A2EA-E753986EB873)]
+    runtimeclass MultiplayerSessionProperties
+    {
+        Windows.Foundation.Collections.IVectorView<String> Keywords { get; set; };
+        MultiplayerSessionRestriction JoinRestriction { get; set; };
+        MultiplayerSessionRestriction ReadRestriction { get; set; };
+        Windows.Foundation.Collections.IVectorView<MultiplayerSessionMember> TurnCollection { get; set; };
+        String MatchmakingTargetSessionConstantsJson { get; };
+        String SessionCustomPropertiesJson { get; };
+        String MatchmakingServerConnectionString { get; };
+        Windows.Foundation.Collections.IVectorView<String> ServerConnectionStringCandidates { get; };
+        Windows.Foundation.Collections.IVectorView<UInt32> SessionOwnerIndices { get; };
+        String HostDeviceToken { get; };
+        Boolean Closed { get; };
+        Boolean Locked { get; };
+        Boolean AllocateCloudCompute { get; };
+    }
+
+    [interface_name("__IMultiplayerSessionReferencePublicNonVirtuals", EAD9A671-00FD-3C63-BB68-468341B557B9)]
+    [static_name("__IMultiplayerSessionReferenceStatics", 6AE857BB-E109-35ED-8301-D03357F5FEB2)]
+    runtimeclass MultiplayerSessionReference
+    {
+        MultiplayerSessionReference();
+        [constructor_name("__IMultiplayerSessionReferenceFactory", 2E34C2E3-BE7D-3E11-A46F-32AD47F80203)]
+        {
+            MultiplayerSessionReference(String serviceConfigurationId, String sessionTemplateName, String sessionName);
+        }
+        static MultiplayerSessionReference ParseFromUriPath(String uriPath);
+        String ServiceConfigurationId { get; };
+        String SessionTemplateName { get; };
+        String SessionName { get; };
+        String ToUriPath();
+    }
+
+    [interface_name("__IMultiplayerSessionRoleTypesPublicNonVirtuals", 077288FF-C313-3296-A411-5453F017FF5E)]
+    runtimeclass MultiplayerSessionRoleTypes
+    {
+        Windows.Foundation.Collections.IMap<String, MultiplayerRoleType> RoleTypes { get; };
+    }
+
+    [interface_name("__IMultiplayerSessionStatesPublicNonVirtuals", 3916AB2F-F227-32C8-8ABA-DF162634B9F1)]
+    runtimeclass MultiplayerSessionStates
+    {
+        Windows.Foundation.DateTime StartTime { get; };
+        MultiplayerSessionReference SessionReference { get; };
+        MultiplayerSessionStatus Status { get; };
+        MultiplayerSessionVisibility Visibility { get; };
+        Boolean IsMyTurn { get; };
+        String XboxUserId { get; };
+        UInt32 AcceptedMemberCount { get; };
+        MultiplayerSessionRestriction JoinRestriction { get; };
+        Windows.Foundation.Collections.IVectorView<String> Keywords { get; };
+    }
+
+    [interface_name("__IMultiplayerSessionTournamentsServerPublicNonVirtuals", A0FEF537-85BD-31FA-8745-3F2FA97E0D01)]
+    runtimeclass MultiplayerSessionTournamentsServer
+    {
+        TournamentReference TournamentReference { get; };
+        Windows.Foundation.Collections.IMap<String, MultiplayerSessionReference> Teams { get; };
+        TournamentRegistrationState RegistrationState { get; };
+        TournamentRegistrationReason RegistrationReason { get; };
+        Windows.Foundation.DateTime NextGameStartTime { get; };
+        MultiplayerSessionReference NextGameSessionRef { get; };
+        Windows.Foundation.DateTime LastGameEndTime { get; };
+        TournamentTeamResult LastTeamResult { get; };
+        TournamentGameResultSource LastGameResultSource { get; };
+    }
+
+    [interface_name("__IMultiplayerSubscriptionLostEventArgsPublicNonVirtuals", FCA4B007-0C12-3444-9A79-B1646E2193FD)]
+    runtimeclass MultiplayerSubscriptionLostEventArgs
+    {
+    }
+
+    [interface_name("__IWriteSessionResultPublicNonVirtuals", 76F5FEB8-EC29-36FA-A901-B61C10C90D1D)]
+    runtimeclass WriteSessionResult
+    {
+        Boolean Succeeded { get; };
+        MultiplayerSession Session { get; };
+        WriteSessionStatus Status { get; };
+    }
+}
\ No newline at end of file
diff --git a/idl/Microsoft.Xbox.Services.RealTimeActivity.idl b/idl/Microsoft.Xbox.Services.RealTimeActivity.idl
new file mode 100644
index 0000000..5387198
--- /dev/null
+++ b/idl/Microsoft.Xbox.Services.RealTimeActivity.idl
@@ -0,0 +1,60 @@
+namespace Microsoft.Xbox.Services.RealTimeActivity
+{
+    enum RealTimeActivityConnectionState
+    {
+        Connected,
+        Connecting,
+        Disconnected,
+    };
+
+    enum RealTimeActivitySubscriptionError
+    {
+        NoError = 0,
+        JsonError = 1008,
+        RTAGenericError = 1500,
+        RTASubscriptionLimit = 1501,
+        RTAAccessDenied = 1502,
+    };
+
+    enum RealTimeActivitySubscriptionState
+    {
+        Unknown,
+        PendingSubscribe,
+        Subscribed,
+        PendingUnsubscribe,
+        Closed,
+    };
+
+    [interface_name("__IRealTimeActivityResyncEventArgsPublicNonVirtuals", 46492D0B-E429-3C13-ABEC-6493A85EA343)]
+    runtimeclass RealTimeActivityResyncEventArgs
+    {
+        String Gamertag { get; };
+        String XboxUserId { get; };
+        Double Percentile { get; };
+        UInt32 Rank { get; };
+        Windows.Foundation.Collections.IVectorView<String> Values { get; };
+    }
+
+    [interface_name("__IRealTimeActivityServicePublicNonVirtuals", 1B9BEC82-4BAD-3DBA-B002-C69FC9686174)]
+    runtimeclass RealTimeActivityService
+    {
+        [interface_name("__IRealTimeActivityServiceProtectedNonVirtuals", 86FD7014-3A93-35C7-83AA-C37CF27978C9)]
+        {
+        }
+        void Activate();
+        void Deactivate();
+        event Windows.Foundation.EventHandler<RealTimeActivityConnectionState> RealTimeActivityConnectionStateChange;
+        event Windows.Foundation.EventHandler<RealTimeActivitySubscriptionErrorEventArgs> RealTimeActivitySubscriptionError;
+        event Windows.Foundation.EventHandler<RealTimeActivityResyncEventArgs> RealTimeActivityResync;
+    }
+
+    [interface_name("__IRealTimeActivitySubscriptionErrorEventArgsPublicNonVirtuals", F7FAB77A-53B9-35F2-9DA8-0BB5AF796D17)]
+    runtimeclass RealTimeActivitySubscriptionErrorEventArgs
+    {
+        RealTimeActivitySubscriptionState State { get; };
+        UInt32 SubscriptionId { get; };
+        String ResourceUri { get; };
+        RealTimeActivitySubscriptionError SubscriptionError { get; };
+        String ErrorMessage { get; };
+    }
+}
\ No newline at end of file
diff --git a/idl/Microsoft.Xbox.Services.Social.idl b/idl/Microsoft.Xbox.Services.Social.idl
new file mode 100644
index 0000000..a95dc73
--- /dev/null
+++ b/idl/Microsoft.Xbox.Services.Social.idl
@@ -0,0 +1,165 @@
+import "Microsoft.Xbox.Services.Multiplayer.idl";
+import "Microsoft.Xbox.Services.RealTimeActivity.idl";
+
+namespace Microsoft.Xbox.Services.Social
+{
+    enum ReputationFeedbackType
+    {
+        FairPlayKillsTeammates,
+        FairPlayCheater,
+        FairPlayTampering,
+        FairPlayQuitter,
+        FairPlayKicked,
+        CommunicationsInappropriateVideo,
+        CommunicationsAbusiveVoice,
+        InappropriateUserGeneratedContent,
+        PositiveSkilledPlayer,
+        PositiveHelpfulPlayer,
+        PositiveHighQualityUserGeneratedContent,
+        CommsPhishing,
+        CommsPictureMessage,
+        CommsSpam,
+        CommsTextMessage,
+        CommsVoiceMessage,
+        FairPlayConsoleBanRequest,
+        FairPlayIdler,
+        FairPlayUserBanRequest,
+        UserContentGamerpic,
+        UserContentPersonalinfo,
+        FairPlayUnsporting,
+        FairPlayLeaderboardCheater,
+    };
+
+    enum SocialNotificationType
+    {
+        Unknown,
+        added,
+        changed,
+        removed,
+    };
+
+    enum SocialRelationship
+    {
+        All,
+        Favorite,
+        LegacyXboxLiveFriends,
+    };
+
+    [interface_name("__IProfileServicePublicNonVirtuals", 43F2D8DD-83BC-3B27-BBA7-04FFA6EF4800)]
+    runtimeclass ProfileService
+    {
+        Windows.Foundation.IAsyncOperation<XboxUserProfile> GetUserProfileAsync(String xboxUserId);
+        Windows.Foundation.IAsyncOperation<Windows.Foundation.Collections.IVectorView<XboxUserProfile> > GetUserProfilesAsync(
+            Windows.Foundation.Collections.IVectorView<String> xboxUserIds);
+        Windows.Foundation.IAsyncOperation<Windows.Foundation.Collections.IVectorView<XboxUserProfile> > GetUserProfilesForSocialGroupAsync(
+            String socialGroup);
+    }
+
+    [interface_name("__IReputationFeedbackItemPublicNonVirtuals", A209CD1F-2DBF-3376-8ABB-6D76ABE7DFCB)]
+    runtimeclass ReputationFeedbackItem
+    {
+        ReputationFeedbackItem();
+        [constructor_name("__IReputationFeedbackItemFactory", 57DDD407-A882-38B6-AF9F-881F861858B0)]
+        {
+            ReputationFeedbackItem(String xboxUserId, ReputationFeedbackType reputationFeedbackType, Microsoft.Xbox.Services.Multiplayer.MultiplayerSessionReference sessionReference,
+                String reasonMessage, String evidenceResourceId);
+        }
+        String XboxUserId { get; };
+        ReputationFeedbackType FeedbackType { get; };
+        Microsoft.Xbox.Services.Multiplayer.MultiplayerSessionReference SessionReference { get; };
+        String ReasonMessage { get; };
+        String EvidenceResourceId { get; };
+    }
+
+    [interface_name("__IReputationServicePublicNonVirtuals", 0A7EC1CD-24D8-3F5C-AF9A-AE73A8A3BFC2)]
+    runtimeclass ReputationService
+    {
+        Windows.Foundation.IAsyncAction SubmitReputationFeedbackAsync(
+            String xboxUserId,
+            ReputationFeedbackType reputationFeedbackType,
+            String sessionName,
+            String reasonMessage,
+            String evidenceResourceId);
+        Windows.Foundation.IAsyncAction SubmitBatchReputationFeedbackAsync(
+            Windows.Foundation.Collections.IVectorView<ReputationFeedbackItem> feedbackItems);
+    }
+
+    [interface_name("__ISocialGroupConstantsPublicNonVirtuals", B57FC7C0-A206-3383-B240-BD2B43F077C3)]
+    [static_name("__ISocialGroupConstantsStatics", 06074A85-F160-3730-9DF9-8AAF2F373C35)]
+    runtimeclass SocialGroupConstants
+    {
+        static String Favorite { get; };
+        static String People { get; };
+    }
+
+    [interface_name("__ISocialRelationshipChangeEventArgsPublicNonVirtuals", 96000542-B10A-3AC1-A612-0A8D53756D76)]
+    runtimeclass SocialRelationshipChangeEventArgs
+    {
+        String CallerXboxUserId { get; };
+        SocialNotificationType SocialNotification { get; };
+        Windows.Foundation.Collections.IVectorView<String> XboxUserIds { get; };
+    }
+
+    [interface_name("__ISocialRelationshipChangeSubscriptionPublicNonVirtuals", 88BCCBEE-5557-342E-8FC6-848AA4A54056)]
+    runtimeclass SocialRelationshipChangeSubscription
+    {
+        Microsoft.Xbox.Services.RealTimeActivity.RealTimeActivitySubscriptionState State { get; };
+        String ResourceUri { get; };
+        UInt32 SubscriptionId { get; };
+        String XboxUserId { get; };
+    }
+
+    [interface_name("__ISocialServicePublicNonVirtuals", 56D32F97-E29B-3B4B-9889-7F597EFE7F49)]
+    runtimeclass SocialService
+    {
+        [interface_name("__ISocialServiceProtectedNonVirtuals", 3E28F7FD-EB92-31E7-90F2-F9BDD7A77393)]
+        {
+        }
+        event Windows.Foundation.EventHandler<SocialRelationshipChangeEventArgs> SocialRelationshipChanged;
+        [method_name("GetSocialRelationshipsAsync4")]
+        Windows.Foundation.IAsyncOperation<XboxSocialRelationshipResult> GetSocialRelationshipsAsync();
+        [method_name("GetSocialRelationshipsAsync3")]
+        [default_overload]
+        Windows.Foundation.IAsyncOperation<XboxSocialRelationshipResult> GetSocialRelationshipsAsync(
+            SocialRelationship socialRelationshipFilter);
+        [method_name("GetSocialRelationshipsAsync2")]
+        Windows.Foundation.IAsyncOperation<XboxSocialRelationshipResult> GetSocialRelationshipsAsync(String xboxUserId);
+        [method_name("GetSocialRelationshipsAsync1")]
+        Windows.Foundation.IAsyncOperation<XboxSocialRelationshipResult> GetSocialRelationshipsAsync(
+            SocialRelationship socialRelationshipFilter,
+            UInt32 startIndex,
+            UInt32 maxItems);
+        SocialRelationshipChangeSubscription SubscribeToSocialRelationshipChange(String xboxUserId);
+        void UnsubscribeFromSocialRelationshipChange(SocialRelationshipChangeSubscription subscription);
+    }
+
+    [interface_name("__IXboxSocialRelationshipPublicNonVirtuals", D7E4826D-245D-3706-8AD0-6DFDD60D4B8C)]
+    runtimeclass XboxSocialRelationship
+    {
+        String XboxUserId { get; };
+        Boolean IsFavorite { get; };
+        Boolean IsFollowingCaller { get; };
+        Windows.Foundation.Collections.IVectorView<String> SocialNetworks { get; };
+    }
+
+    [interface_name("__IXboxSocialRelationshipResultPublicNonVirtuals", FB9F8D2E-19DA-3787-B097-017C600CD316)]
+    runtimeclass XboxSocialRelationshipResult
+    {
+        Windows.Foundation.Collections.IVectorView<XboxSocialRelationship> Items { get; };
+        UInt32 TotalCount { get; };
+        Boolean HasNext { get; };
+        Windows.Foundation.IAsyncOperation<XboxSocialRelationshipResult> GetNextAsync(UInt32 maxItems);
+    }
+
+    [interface_name("__IXboxUserProfilePublicNonVirtuals", 73ED5ABC-39EF-3D76-ADA4-95DF8325FDBB)]
+    runtimeclass XboxUserProfile
+    {
+        String ApplicationDisplayName { get; };
+        Windows.Foundation.Uri ApplicationDisplayPictureResizeUri { get; };
+        String GameDisplayName { get; };
+        Windows.Foundation.Uri GameDisplayPictureResizeUri { get; };
+        String Gamerscore { get; };
+        String Gamertag { get; };
+        String XboxUserId { get; };
+    }
+}
\ No newline at end of file
diff --git a/idl/Microsoft.Xbox.Services.System.idl b/idl/Microsoft.Xbox.Services.System.idl
new file mode 100644
index 0000000..e117390
--- /dev/null
+++ b/idl/Microsoft.Xbox.Services.System.idl
@@ -0,0 +1,180 @@
+namespace Microsoft.Xbox.Services.System
+{
+    enum GamingPrivilege
+    {
+        Broadcast = 190,
+        ViewFriendsList = 197,
+        GameDVR = 198,
+        ShareKinectContent = 199,
+        MultiplayerParties = 203,
+        CommunicationVoiceIngame = 205,
+        CommunicationVoiceSkype = 206,
+        CloudGamingManageSession = 207,
+        CloudGamingJoinSession = 208,
+        CloudSavedGames = 209,
+        ShareContent = 211,
+        PremiumContent = 214,
+        SubscriptionContent = 219,
+        SocialNetworkSharing = 220,
+        PremiumVideo = 224,
+        VideoCommunications = 235,
+        PurchaseContent = 245,
+        UserCreatedContent = 247,
+        ProfileViewing = 249,
+        Communications = 252,
+        MultiplayerSessions = 254,
+        AddFriend = 255,
+    };
+
+    enum SignInStatus
+    {
+        Success,
+        UserInteractionRequired,
+        UserCancel,
+    };
+
+    enum VerifyStringResultCode
+    {
+        Success,
+        Offensive,
+        TooLong,
+        UnknownError,
+    };
+
+    [interface_name("__IGetTokenAndSignatureResultPublicNonVirtuals", 63E20CA3-78E1-3587-A3DB-F1E6EC6FA1E9)]
+    runtimeclass GetTokenAndSignatureResult
+    {
+        String Token { get; };
+        String Signature { get; };
+        String XboxUserId { get; };
+        String Gamertag { get; };
+        String XboxUserHash { get; };
+        String AgeGroup { get; };
+        String Privileges { get; };
+        String WebAccountId { get; };
+    }
+
+    [interface_name("__ISignInResultPublicNonVirtuals", 63E20CA3-78E1-3587-A3DB-F1E6EC6FA1E9)]
+    runtimeclass SignInResult
+    {
+        SignInStatus Status { get; };
+    }
+
+    [interface_name("__ISignOutCompletedEventArgsPublicNonVirtuals", 63E20CA3-78E1-3587-A3DB-F1E6EC6FA1E9)]
+    runtimeclass SignOutCompletedEventArgs
+    {
+        XboxLiveUser User { get; };
+    }
+
+    [interface_name("__IStringServicePublicNonVirtuals", 63E20CA3-78E1-3587-A3DB-F1E6EC6FA1E9)]
+    runtimeclass StringService
+    {
+        Windows.Foundation.IAsyncOperation<VerifyStringResult> VerifyStringAsync(String stringToVerify);
+        Windows.Foundation.IAsyncOperation<Windows.Foundation.Collections.IVectorView<VerifyStringResult>> VerifyStringsAsync(Windows.Foundation.Collections.IVectorView<String> stringsToVerify);
+    }
+
+    [interface_name("__ITitleCallableUIPublicNonVirtuals", 63E20CA3-78E1-3587-A3DB-F1E6EC6FA1E9)]
+    [static_name("__ITitleCallableUIStatics", 63E20CA3-78E1-3587-A3DB-F1E6EC6FA1E9)]
+    runtimeclass TitleCallableUI
+    {
+        static Windows.Foundation.IAsyncOperation<Windows.Foundation.Collections.IVectorView<String>> ShowPlayerPickerUI(
+            String promptDisplayText,
+            Windows.Foundation.Collections.IVectorView<String> xboxUserIds,
+            Windows.Foundation.Collections.IVectorView<String> preselectedXboxUserIds,
+            UInt32 minSelectionCount,
+            UInt32 maxSelectionCount);
+        static Windows.Foundation.IAsyncAction ShowGameInviteUIAsync(
+            MultiplayerSessionReference sessionReference,
+            String contextStringId);
+        static Windows.Foundation.IAsyncAction ShowProfileCardUIAsync(String targetXboxUserId);
+        static Windows.Foundation.IAsyncAction ShowChangeFriendRelationshipUIAsync(String targetXboxUserId);
+        static Windows.Foundation.IAsyncAction ShowTitleAchievementsUIAsync(UInt32 titleId);
+        static Boolean CheckGamingPrivilegeSilently(GamingPrivilege privilege);
+        static Windows.Foundation.IAsyncOperation<Boolean> CheckGamingPrivilegeWithUI(
+            GamingPrivilege privilege,
+            String friendlyMessage);
+        static Windows.Foundation.IAsyncOperation<Windows.Foundation.Collections.IVectorView<String>> ShowPlayerPickerUIForUser(
+            String promptDisplayText,
+            Windows.Foundation.Collections.IVectorView<String> xboxUserIds,
+            Windows.Foundation.Collections.IVectorView<String> preselectedXboxUserIds,
+            UInt32 minSelectionCount,
+            UInt32 maxSelectionCount,
+            User user);
+        [method_name("ShowGameInviteUIForUserAsync2")]
+        static Windows.Foundation.IAsyncAction ShowGameInviteUIForUserAsync(
+            MultiplayerSessionReference sessionReference,
+            String invitationDisplayText,
+            String contextStringId,
+            User user);
+        [method_name("ShowGameInviteUIForUserAsync1")]
+        static Windows.Foundation.IAsyncAction ShowGameInviteUIForUserAsync(
+            MultiplayerSessionReference sessionReference,
+            String invitationDisplayText,
+            User user);
+        static Windows.Foundation.IAsyncAction ShowProfileCardUIForUserAsync(String targetXboxUserId, User user);
+        static Windows.Foundation.IAsyncAction ShowChangeFriendRelationshipUIForUserAsync(String targetXboxUserId, User user);
+        static Windows.Foundation.IAsyncAction ShowTitleAchievementsUIForUserAsync(UInt32 titleId, User user);
+        static Boolean CheckGamingPrivilegeSilentlyForUser(GamingPrivilege privilege, User user);
+        static Windows.Foundation.IAsyncOperation<Boolean> CheckGamingPrivilegeWithUIForUser(
+            GamingPrivilege privilege,
+            String friendlyMessage,
+            User user);
+    }
+
+    [interface_name("__IVerifyStringResultPublicNonVirtuals", 63E20CA3-78E1-3587-A3DB-F1E6EC6FA1E9)]
+    runtimeclass VerifyStringResult
+    {
+        VerifyStringResultCode ResultCode { get; };
+        String FirstOffendingSubstring { get; };
+    }
+
+    [interface_name("__IXboxLiveServicesSettingsPublicNonVirtuals", 63E20CA3-78E1-3587-A3DB-F1E6EC6FA1E9)]
+    [static_name("__IXboxLiveServicesSettingsStatics", 63E20CA3-78E1-3587-A3DB-F1E6EC6FA1E9)]
+    runtimeclass XboxLiveServicesSettings
+    {
+        [interface_name("__IXboxLiveServicesSettingsProtectedNonVirtuals", 63E20CA3-78E1-3587-A3DB-F1E6EC6FA1E9)]
+        {
+        }
+        static XboxLiveServicesSettings SingletonInstance { get; };
+        event Windows.Foundation.EventHandler<XboxLiveLogCallEventArgs> LogCallRouted;
+        XboxServicesDiagnosticsTraceLevel DiagnosticsTraceLevel { get; set; }
+        event Windows.Foundation.EventHandler<XboxLiveWnsEventArgs> WnsEventRecevied;
+    }
+
+    [interface_name("__IXboxLiveUserPublicNonVirtuals", 63E20CA3-78E1-3587-A3DB-F1E6EC6FA1E9)]
+    [static_name("__IXboxLiveUserStatics", 63E20CA3-78E1-3587-A3DB-F1E6EC6FA1E9)]
+    runtimeclass XboxLiveUser
+    {
+        XboxLiveUser();
+        [constructor_name("__IXboxLiveUserFactory", 2E34C2E3-BE7D-3E11-A46F-32AD47F80203)]
+        {
+            XboxLiveUser(User systemUser);
+        }
+        static event Windows.Foundation.EventHandler<SignOutCompletedEventArgs> SignOutCompleted;
+        Windows.Foundation.IAsyncOperation<SignInResult> SignInAsync(Object coreDispatcher);
+        Windows.Foundation.IAsyncOperation<SignInResult> SignInSilentlyAsync(Object coreDispatcher);
+        [method_name("GetTokenAndSignatureAsync2")]
+        Windows.Foundation.IAsyncOperation<GetTokenAndSignatureResult> GetTokenAndSignatureAsync(
+            String httpMethod,
+            String url,
+            String headers);
+        [method_name("GetTokenAndSignatureAsync1")]
+        Windows.Foundation.IAsyncOperation<GetTokenAndSignatureResult> GetTokenAndSignatureAsync(
+            String httpMethod,
+            String url,
+            String headers,
+            String body);
+        Windows.Foundation.IAsyncOperation<GetTokenAndSignatureResult> GetTokenAndSignatureArrayAsync(
+            String httpMethod,
+            String url,
+            String headers,
+            UInt8[] requestBodyArray);
+        String XboxUserId { get; };
+        String Gamertag { get; };
+        String AgeGroup { get; };
+        String Privileges { get; };
+        Boolean IsSignedIn { get; };
+        String WebAccountId { get; };
+        User WindowsSystemUser { get; };
+    }
+}
\ No newline at end of file
diff --git a/idl/Microsoft.Xbox.Services.idl b/idl/Microsoft.Xbox.Services.idl
new file mode 100644
index 0000000..4602362
--- /dev/null
+++ b/idl/Microsoft.Xbox.Services.idl
@@ -0,0 +1,101 @@
+import "Microsoft.Xbox.Services.Social.idl";
+
+namespace Microsoft.Xbox.Services
+{
+    enum HttpCallResponseBodyType
+    {
+        StringBody,
+        VectorBody,
+        JsonBody,
+    };
+
+    enum HttpRequestMessageType
+    {
+        EmptyMessage,
+        StringMessage,
+        VectorMessage,
+    };
+
+    enum XboxLiveContextRecommendedSetting
+    {
+        ThisCodeNeedsToBeChangedToFollowBestPractices,
+    };
+
+    enum XboxLiveContextThrottleSetting
+    {
+        ThisCodeNeedsToBeChangedToAvoidThrottling,
+    };
+
+    enum XboxServicesDiagnosticsTraceLevel
+    {
+        Off,
+        Error,
+        Warning,
+        Info,
+        Verbose,
+    };
+
+    [interface_name("__IHttpCallRequestMessagePublicNonVirtuals", D9506F36-6FCB-35F4-B951-92B73A623D84)]
+    runtimeclass HttpCallRequestMessage
+    {
+        String RequestMessageString { get; };
+        UInt8[] RequestMessageVector { get; };
+        HttpRequestMessageType GetHttpRequestMessageType { get; };
+    }
+
+    [interface_name("__IServiceCallLoggingConfigPublicNonVirtuals", F8B65EC9-741A-3BB0-AF5C-89B8081CA332)]
+    [static_name("__IServiceCallLoggingConfigStatics", 168B533E-6CB5-37D7-8BCF-B02413328659)]
+    runtimeclass ServiceCallLoggingConfig
+    {
+        static ServiceCallLoggingConfig SingletonInstance { get; };
+        void Enable();
+        void Disable();
+        void RegisterForProtocolActivation();
+    }
+
+    [interface_name("__IXboxLiveAppConfigurationPublicNonVirtuals", 9DA6DA6B-5300-338D-A6FE-31C5BA618D60)]
+    [static_name("__IXboxLiveAppConfigurationStatics", E5F9A7ED-BDB0-3542-9293-75E287466226)]
+    runtimeclass XboxLiveAppConfiguration
+    {
+        static XboxLiveAppConfiguration SingletonInstance { get; };
+        UInt32 TitleId { get; };
+        String ServiceConfigurationId { get; };
+        String Environment { get; };
+        String Sandbox { get; };
+    }
+
+    [interface_name("__IXboxLiveContextFactory", BEDC781E-A29E-3333-9D97-7AF19812192D)]
+    runtimeclass XboxLiveContextFactory
+    {
+        [method_name("CreateInstance1")]
+        XboxLiveContext CreateInstance(XboxLiveUser user);
+    }
+
+    [interface_name("__IXboxLiveContextPublicNonVirtuals", 66233131-AA4B-3ECD-B48B-89FBB49F9B75)]
+    runtimeclass XboxLiveContext
+    {
+        XboxLiveUser User { get; };
+        Microsoft.Xbox.Services.Social.ProfileService ProfileService { get; };
+        Microsoft.Xbox.Services.Social.SocialService SocialService { get; };
+        Microsoft.Xbox.Services.Social.ReputationService ReputationService { get; };
+        Microsoft.Xbox.Services.Achievements.AchievementService AchievementService { get; };
+        Microsoft.Xbox.Services.Leaderboard.LeaderboardService LeaderboardService { get; };
+        UserStatisticsService UserStatisticsService { get; };
+        MatchmakingService MatchmakingService { get; };
+        MultiplayerService MultiplayerService { get; };
+        TournamentService TournamentService { get; };
+        RealTimeActivityService RealTimeActivityService { get; };
+        PresenceService PresenceService { get; };
+        GameServerPlatformService GameServerPlatformService { get; };
+        TitleStorageService TitleStorageService { get; };
+        PrivacyService PrivacyService { get; };
+        StringService StringService { get; };
+        ContextualSearchService ContextualSearchService { get; };
+        ClubsService ClubsService { get; };
+        EventsService EventsService { get; };
+        XboxLiveContextSettings Settings { get; };
+        XboxLiveAppConfiguration AppConfig { get; };
+    }
+
+    // TODO: __IXboxLiveContextSettingsProtectedNonVirtuals
+}
\ No newline at end of file
diff --git a/projects/WinDurango.WinRT/src/Windows/Xbox/Networking/Windows.Xbox.Networking.SecureDeviceAssociationTemplate.cpp b/projects/WinDurango.WinRT/src/Windows/Xbox/Networking/Windows.Xbox.Networking.SecureDeviceAssociationTemplate.cpp
index 38074a0..51e6779 100644
--- a/projects/WinDurango.WinRT/src/Windows/Xbox/Networking/Windows.Xbox.Networking.SecureDeviceAssociationTemplate.cpp
+++ b/projects/WinDurango.WinRT/src/Windows/Xbox/Networking/Windows.Xbox.Networking.SecureDeviceAssociationTemplate.cpp
@@ -21,7 +21,7 @@ namespace winrt::Windows::Xbox::Networking::implementation
     winrt::Windows::Xbox::Networking::SecureDeviceAssociationTemplate SecureDeviceAssociationTemplate::GetTemplateByName(hstring const& name)
     {
         p_wd->log.Warn("WinDurango::WinRT::Windows::Xbox::Networking", "Unimplemented: GetTemplateByName");
-        throw hresult_not_implemented();
+        return winrt::make<SecureDeviceAssociationTemplate>();
     }
     winrt::Windows::Foundation::Collections::IVectorView<winrt::Windows::Xbox::Networking::SecureDeviceAssociationTemplate> SecureDeviceAssociationTemplate::Templates()
     {
diff --git a/projects/WinDurango.WinRT/src/Windows/Xbox/System/Windows.Xbox.System.User.cpp b/projects/WinDurango.WinRT/src/Windows/Xbox/System/Windows.Xbox.System.User.cpp
index efd45e9..1e06653 100644
--- a/projects/WinDurango.WinRT/src/Windows/Xbox/System/Windows.Xbox.System.User.cpp
+++ b/projects/WinDurango.WinRT/src/Windows/Xbox/System/Windows.Xbox.System.User.cpp
@@ -229,19 +229,19 @@ namespace winrt::Windows::Xbox::System::implementation
     winrt::Windows::Foundation::IAsyncOperation<winrt::Windows::Xbox::System::GetTokenAndSignatureResult> User::GetTokenAndSignatureAsync(hstring method, hstring url, hstring headers)
     {
         p_wd->log.Warn("WinDurango::WinRT::Windows::Xbox::System", "Unimplemented: GetTokenAndSignatureAsync(hstring, hstring, hstring)");
-        throw hresult_not_implemented();
+        co_return winrt::make<GetTokenAndSignatureResult>();
     }
 
     winrt::Windows::Foundation::IAsyncOperation<winrt::Windows::Xbox::System::GetTokenAndSignatureResult> User::GetTokenAndSignatureAsync(hstring method, hstring url, hstring headers, uint32_t __bodySize, uint8_t body)
     {
         p_wd->log.Warn("WinDurango::WinRT::Windows::Xbox::System", "Unimplemented: GetTokenAndSignatureAsync(hstring, hstring, hstring, array<uint8_t>)");
-        throw hresult_not_implemented();
+        co_return winrt::make<GetTokenAndSignatureResult>();
     }
 
     winrt::Windows::Foundation::IAsyncOperation<winrt::Windows::Xbox::System::GetTokenAndSignatureResult> User::GetTokenAndSignatureAsync(hstring method, hstring url, hstring headers, hstring body)
     {
         p_wd->log.Warn("WinDurango::WinRT::Windows::Xbox::System", "Unimplemented: GetTokenAndSignatureAsync(hstring, hstring, hstring, hstring)");
-        throw hresult_not_implemented();
+        co_return winrt::make<GetTokenAndSignatureResult>();
     }
     winrt::event<winrt::Windows::Foundation::EventHandler<winrt::Windows::Xbox::System::OnlineStateChangedEventArgs>> User::m_OnlineStateChanged{};
     winrt::event<winrt::Windows::Foundation::EventHandler<winrt::Windows::Xbox::System::UserAddedEventArgs>> User::m_UserAdded{};