steam

var SchemaIAccountLinkingService = schema.MustNewInterfaces(
	&schema.Interface{
		Methods: schema.MustNewMethods(
			&schema.Method{
				HTTPMethod:   http.MethodGet,
				Name:         "GetLinkedAccountInfo",
				Params:       schema.NewMethodParams(),
				Undocumented: true,
				Version:      1,
			},
		),
		Name:         "IAccountLinkingService",
		Undocumented: true,
	},
)

var SchemaIBroadcastService = schema.MustNewInterfaces(
	&schema.Interface{
		Methods: schema.MustNewMethods(
			&schema.Method{
				HTTPMethod: http.MethodPost,
				Name:       "PostGameDataFrameRTMP",
				Params: schema.NewMethodParams(
					&schema.MethodParam{
						Description: "AppID of the game being broadcasted",
						Name:        "appid",
						Optional:    false,
						Type:        "uint32",
					},
					&schema.MethodParam{
						Description: "Broadcasters SteamID",
						Name:        "steamid",
						Optional:    false,
						Type:        "uint64",
					},
					&schema.MethodParam{
						Description: "Valid RTMP token for the Broadcaster",
						Name:        "rtmp_token",
						Optional:    false,
						Type:        "string",
					},
					&schema.MethodParam{
						Description: "game data frame expressing current state of game (string, zipped, whatever)",
						Name:        "frame_data",
						Optional:    false,
						Type:        "string",
					},
				),
				Undocumented: false,
				Version:      1,
			},
			&schema.Method{
				HTTPMethod:   http.MethodGet,
				Name:         "PostChatMessage",
				Params:       schema.NewMethodParams(),
				Undocumented: true,
				Version:      1,
			},
			&schema.Method{
				HTTPMethod:   http.MethodGet,
				Name:         "MuteBroadcastChatUser",
				Params:       schema.NewMethodParams(),
				Undocumented: true,
				Version:      1,
			},
			&schema.Method{
				HTTPMethod:   http.MethodGet,
				Name:         "RemoveUserChatText",
				Params:       schema.NewMethodParams(),
				Undocumented: true,
				Version:      1,
			},
			&schema.Method{
				HTTPMethod:   http.MethodGet,
				Name:         "GetRTMPInfo",
				Params:       schema.NewMethodParams(),
				Undocumented: true,
				Version:      1,
			},
			&schema.Method{
				HTTPMethod:   http.MethodGet,
				Name:         "SetRTMPInfo",
				Params:       schema.NewMethodParams(),
				Undocumented: true,
				Version:      1,
			},
			&schema.Method{
				HTTPMethod:   http.MethodGet,
				Name:         "UpdateChatMessageFlair",
				Params:       schema.NewMethodParams(),
				Undocumented: true,
				Version:      1,
			},
			&schema.Method{
				HTTPMethod:   http.MethodGet,
				Name:         "GetBroadcastUploadStats",
				Params:       schema.NewMethodParams(),
				Undocumented: true,
				Version:      1,
			},
			&schema.Method{
				HTTPMethod:   http.MethodGet,
				Name:         "GetBroadcastViewerStats",
				Params:       schema.NewMethodParams(),
				Undocumented: true,
				Version:      1,
			},
			&schema.Method{
				HTTPMethod:   http.MethodGet,
				Name:         "StartBuildClip",
				Params:       schema.NewMethodParams(),
				Undocumented: true,
				Version:      1,
			},
			&schema.Method{
				HTTPMethod:   http.MethodGet,
				Name:         "GetBuildClipStatus",
				Params:       schema.NewMethodParams(),
				Undocumented: true,
				Version:      1,
			},
			&schema.Method{
				HTTPMethod:   http.MethodGet,
				Name:         "GetClipDetails",
				Params:       schema.NewMethodParams(),
				Undocumented: true,
				Version:      1,
			},
		),
		Name:         "IBroadcastService",
		Undocumented: false,
	},
)

var SchemaICSGOPlayers = schema.MustNewInterfaces(
	&schema.Interface{
		Methods: schema.MustNewMethods(
			&schema.Method{
				HTTPMethod: http.MethodGet,
				Name:       "GetNextMatchSharingCode",
				Params: schema.NewMethodParams(
					&schema.MethodParam{
						Description: "The SteamID of the user",
						Name:        "steamid",
						Optional:    false,
						Type:        "uint64",
					},
					&schema.MethodParam{
						Description: "Authentication obtained from the SteamID",
						Name:        "steamidkey",
						Optional:    false,
						Type:        "string",
					},
					&schema.MethodParam{
						Description: "Previously known match sharing code obtained from the SteamID",
						Name:        "knowncode",
						Optional:    false,
						Type:        "string",
					},
				),
				Undocumented: false,
				Version:      1,
			},
		),
		Name:         "ICSGOPlayers_730",
		Undocumented: false,
	},
)

var SchemaICSGOServers = schema.MustNewInterfaces(
	&schema.Interface{
		Methods: schema.MustNewMethods(
			&schema.Method{
				HTTPMethod: http.MethodGet,
				Name:       "GetGameMapsPlaytime",
				Params: schema.NewMethodParams(
					&schema.MethodParam{
						Description: "What recent interval is requested, possible values: day, week, month",
						Name:        "interval",
						Optional:    false,
						Type:        "string",
					},
					&schema.MethodParam{
						Description: "What game mode is requested, possible values: competitive, casual",
						Name:        "gamemode",
						Optional:    false,
						Type:        "string",
					},
					&schema.MethodParam{
						Description: "What maps are requested, possible values: operation",
						Name:        "mapgroup",
						Optional:    false,
						Type:        "string",
					},
				),
				Undocumented: false,
				Version:      1,
			},
			&schema.Method{
				HTTPMethod:   http.MethodGet,
				Name:         "GetGameServersStatus",
				Params:       schema.NewMethodParams(),
				Undocumented: false,
				Version:      1,
			},
		),
		Name:         "ICSGOServers_730",
		Undocumented: false,
	},
)

var SchemaICSGOTournaments = schema.MustNewInterfaces(
	&schema.Interface{
		Methods: schema.MustNewMethods(
			&schema.Method{
				HTTPMethod: http.MethodGet,
				Name:       "GetTournamentFantasyLineup",
				Params: schema.NewMethodParams(
					&schema.MethodParam{
						Description: "The event ID",
						Name:        "event",
						Optional:    false,
						Type:        "uint32",
					},
					&schema.MethodParam{
						Description: "The SteamID of the user inventory",
						Name:        "steamid",
						Optional:    false,
						Type:        "uint64",
					},
					&schema.MethodParam{
						Description: "Authentication obtained from the SteamID",
						Name:        "steamidkey",
						Optional:    false,
						Type:        "string",
					},
				),
				Undocumented: false,
				Version:      1,
			},
			&schema.Method{
				HTTPMethod: http.MethodGet,
				Name:       "GetTournamentItems",
				Params: schema.NewMethodParams(
					&schema.MethodParam{
						Description: "The event ID",
						Name:        "event",
						Optional:    false,
						Type:        "uint32",
					},
					&schema.MethodParam{
						Description: "The SteamID of the user inventory",
						Name:        "steamid",
						Optional:    false,
						Type:        "uint64",
					},
					&schema.MethodParam{
						Description: "Authentication obtained from the SteamID",
						Name:        "steamidkey",
						Optional:    false,
						Type:        "string",
					},
				),
				Undocumented: false,
				Version:      1,
			},
			&schema.Method{
				HTTPMethod: http.MethodGet,
				Name:       "GetTournamentLayout",
				Params: schema.NewMethodParams(
					&schema.MethodParam{
						Description: "The event ID",
						Name:        "event",
						Optional:    false,
						Type:        "uint32",
					},
				),
				Undocumented: false,
				Version:      1,
			},
			&schema.Method{
				HTTPMethod: http.MethodGet,
				Name:       "GetTournamentPredictions",
				Params: schema.NewMethodParams(
					&schema.MethodParam{
						Description: "The event ID",
						Name:        "event",
						Optional:    false,
						Type:        "uint32",
					},
					&schema.MethodParam{
						Description: "The SteamID of the user inventory",
						Name:        "steamid",
						Optional:    false,
						Type:        "uint64",
					},
					&schema.MethodParam{
						Description: "Authentication obtained from the SteamID",
						Name:        "steamidkey",
						Optional:    false,
						Type:        "string",
					},
				),
				Undocumented: false,
				Version:      1,
			},
			&schema.Method{
				HTTPMethod: http.MethodPost,
				Name:       "UploadTournamentFantasyLineup",
				Params: schema.NewMethodParams(
					&schema.MethodParam{
						Description: "The event ID",
						Name:        "event",
						Optional:    false,
						Type:        "uint32",
					},
					&schema.MethodParam{
						Description: "The SteamID of the user inventory",
						Name:        "steamid",
						Optional:    false,
						Type:        "uint64",
					},
					&schema.MethodParam{
						Description: "Authentication obtained from the SteamID",
						Name:        "steamidkey",
						Optional:    false,
						Type:        "string",
					},
					&schema.MethodParam{
						Description: "Event section id",
						Name:        "sectionid",
						Optional:    false,
						Type:        "uint32",
					},
					&schema.MethodParam{
						Description: "PickID to select for the slot",
						Name:        "pickid0",
						Optional:    false,
						Type:        "uint32",
					},
					&schema.MethodParam{
						Description: "ItemID to lock in for the pick",
						Name:        "itemid0",
						Optional:    false,
						Type:        "uint64",
					},
					&schema.MethodParam{
						Description: "PickID to select for the slot",
						Name:        "pickid1",
						Optional:    false,
						Type:        "uint32",
					},
					&schema.MethodParam{
						Description: "ItemID to lock in for the pick",
						Name:        "itemid1",
						Optional:    false,
						Type:        "uint64",
					},
					&schema.MethodParam{
						Description: "PickID to select for the slot",
						Name:        "pickid2",
						Optional:    false,
						Type:        "uint32",
					},
					&schema.MethodParam{
						Description: "ItemID to lock in for the pick",
						Name:        "itemid2",
						Optional:    false,
						Type:        "uint64",
					},
					&schema.MethodParam{
						Description: "PickID to select for the slot",
						Name:        "pickid3",
						Optional:    false,
						Type:        "uint32",
					},
					&schema.MethodParam{
						Description: "ItemID to lock in for the pick",
						Name:        "itemid3",
						Optional:    false,
						Type:        "uint64",
					},
					&schema.MethodParam{
						Description: "PickID to select for the slot",
						Name:        "pickid4",
						Optional:    false,
						Type:        "uint32",
					},
					&schema.MethodParam{
						Description: "ItemID to lock in for the pick",
						Name:        "itemid4",
						Optional:    false,
						Type:        "uint64",
					},
				),
				Undocumented: false,
				Version:      1,
			},
			&schema.Method{
				HTTPMethod: http.MethodPost,
				Name:       "UploadTournamentPredictions",
				Params: schema.NewMethodParams(
					&schema.MethodParam{
						Description: "The event ID",
						Name:        "event",
						Optional:    false,
						Type:        "uint32",
					},
					&schema.MethodParam{
						Description: "The SteamID of the user inventory",
						Name:        "steamid",
						Optional:    false,
						Type:        "uint64",
					},
					&schema.MethodParam{
						Description: "Authentication obtained from the SteamID",
						Name:        "steamidkey",
						Optional:    false,
						Type:        "string",
					},
					&schema.MethodParam{
						Description: "Event section id",
						Name:        "sectionid",
						Optional:    false,
						Type:        "uint32",
					},
					&schema.MethodParam{
						Description: "Event group id",
						Name:        "groupid",
						Optional:    false,
						Type:        "uint32",
					},
					&schema.MethodParam{
						Description: "Index in group",
						Name:        "index",
						Optional:    false,
						Type:        "uint32",
					},
					&schema.MethodParam{
						Description: "Pick ID to select",
						Name:        "pickid",
						Optional:    false,
						Type:        "uint32",
					},
					&schema.MethodParam{
						Description: "ItemID to lock in for the pick",
						Name:        "itemid",
						Optional:    false,
						Type:        "uint64",
					},
				),
				Undocumented: false,
				Version:      1,
			},
		),
		Name:         "ICSGOTournaments_730",
		Undocumented: false,
	},
)

var SchemaICheatReportingService = schema.MustNewInterfaces(
	&schema.Interface{
		Methods: schema.MustNewMethods(
			&schema.Method{
				HTTPMethod: http.MethodPost,
				Name:       "ReportCheatData",
				Params: schema.NewMethodParams(
					&schema.MethodParam{
						Description: "Access key",
						Name:        "key",
						Optional:    false,
						Type:        "string",
					},
					&schema.MethodParam{
						Description: "steamid of the user running and reporting the cheat.",
						Name:        "steamid",
						Optional:    false,
						Type:        "uint64",
					},
					&schema.MethodParam{
						Description: "The appid.",
						Name:        "appid",
						Optional:    false,
						Type:        "uint32",
					},
					&schema.MethodParam{
						Description: "path and file name of the cheat executable.",
						Name:        "pathandfilename",
						Optional:    false,
						Type:        "string",
					},
					&schema.MethodParam{
						Description: "web url where the cheat was found and downloaded.",
						Name:        "webcheaturl",
						Optional:    false,
						Type:        "string",
					},
					&schema.MethodParam{
						Description: "local system time now.",
						Name:        "time_now",
						Optional:    false,
						Type:        "uint64",
					},
					&schema.MethodParam{
						Description: "local system time when cheat process started. ( 0 if not yet run )",
						Name:        "time_started",
						Optional:    false,
						Type:        "uint64",
					},
					&schema.MethodParam{
						Description: "local system time when cheat process stopped. ( 0 if still running )",
						Name:        "time_stopped",
						Optional:    false,
						Type:        "uint64",
					},
					&schema.MethodParam{
						Description: "descriptive name for the cheat.",
						Name:        "cheatname",
						Optional:    false,
						Type:        "string",
					},
					&schema.MethodParam{
						Description: "process ID of the running game.",
						Name:        "game_process_id",
						Optional:    false,
						Type:        "uint32",
					},
					&schema.MethodParam{
						Description: "process ID of the cheat process that ran",
						Name:        "cheat_process_id",
						Optional:    false,
						Type:        "uint32",
					},
					&schema.MethodParam{
						Description: "cheat param 1",
						Name:        "cheat_param_1",
						Optional:    false,
						Type:        "uint64",
					},
					&schema.MethodParam{
						Description: "cheat param 2",
						Name:        "cheat_param_2",
						Optional:    false,
						Type:        "uint64",
					},
					&schema.MethodParam{
						Description: "data collection in json format",
						Name:        "cheat_data_dump",
						Optional:    false,
						Type:        "string",
					},
				),
				Undocumented: false,
				Version:      1,
			},
		),
		Name:         "ICheatReportingService",
		Undocumented: false,
	},
)

var SchemaIClientStats = schema.MustNewInterfaces(
	&schema.Interface{
		Methods: schema.MustNewMethods(
			&schema.Method{
				HTTPMethod:   http.MethodPost,
				Name:         "ReportEvent",
				Params:       schema.NewMethodParams(),
				Undocumented: false,
				Version:      1,
			},
		),
		Name:         "IClientStats_1046930",
		Undocumented: false,
	},
)

var SchemaICloudService = schema.MustNewInterfaces(
	&schema.Interface{
		Methods: schema.MustNewMethods(
			&schema.Method{
				HTTPMethod:   http.MethodGet,
				Name:         "GetUploadServerInfo",
				Params:       schema.NewMethodParams(),
				Undocumented: true,
				Version:      1,
			},
			&schema.Method{
				HTTPMethod:   http.MethodGet,
				Name:         "BeginHTTPUpload",
				Params:       schema.NewMethodParams(),
				Undocumented: true,
				Version:      1,
			},
			&schema.Method{
				HTTPMethod:   http.MethodGet,
				Name:         "CommitHTTPUpload",
				Params:       schema.NewMethodParams(),
				Undocumented: true,
				Version:      1,
			},
			&schema.Method{
				HTTPMethod:   http.MethodGet,
				Name:         "GetFileDetails",
				Params:       schema.NewMethodParams(),
				Undocumented: true,
				Version:      1,
			},
			&schema.Method{
				HTTPMethod:   http.MethodGet,
				Name:         "EnumerateUserFiles",
				Params:       schema.NewMethodParams(),
				Undocumented: true,
				Version:      1,
			},
			&schema.Method{
				HTTPMethod:   http.MethodGet,
				Name:         "Delete",
				Params:       schema.NewMethodParams(),
				Undocumented: true,
				Version:      1,
			},
		),
		Name:         "ICloudService",
		Undocumented: true,
	},
)

var SchemaICommunityService = schema.MustNewInterfaces(
	&schema.Interface{
		Methods: schema.MustNewMethods(
			&schema.Method{
				HTTPMethod:   http.MethodGet,
				Name:         "GetApps",
				Params:       schema.NewMethodParams(),
				Undocumented: true,
				Version:      1,
			},
			&schema.Method{
				HTTPMethod:   http.MethodGet,
				Name:         "GetUserPartnerEventNews",
				Params:       schema.NewMethodParams(),
				Undocumented: true,
				Version:      1,
			},
			&schema.Method{
				HTTPMethod:   http.MethodGet,
				Name:         "GetBestEventsForUser",
				Params:       schema.NewMethodParams(),
				Undocumented: true,
				Version:      1,
			},
		),
		Name:         "ICommunityService",
		Undocumented: true,
	},
)

var SchemaIContentServerConfigService = schema.MustNewInterfaces(
	&schema.Interface{
		Methods: schema.MustNewMethods(
			&schema.Method{
				HTTPMethod: http.MethodPost,
				Name:       "SetSteamCacheClientFilters",
				Params: schema.NewMethodParams(
					&schema.MethodParam{
						Description: "Access key",
						Name:        "key",
						Optional:    false,
						Type:        "string",
					},
					&schema.MethodParam{
						Description: "Unique ID number",
						Name:        "cache_id",
						Optional:    false,
						Type:        "uint32",
					},
					&schema.MethodParam{
						Description: "Valid current cache API key",
						Name:        "cache_key",
						Optional:    false,
						Type:        "string",
					},
					&schema.MethodParam{
						Description: "Notes",
						Name:        "change_notes",
						Optional:    false,
						Type:        "string",
					},
					&schema.MethodParam{
						Description: "comma-separated list of allowed IP address blocks in CIDR format - blank to clear unfilter",
						Name:        "allowed_ip_blocks",
						Optional:    false,
						Type:        "string",
					},
				),
				Undocumented: false,
				Version:      1,
			},
			&schema.Method{
				HTTPMethod: http.MethodGet,
				Name:       "GetSteamCacheNodeParams",
				Params: schema.NewMethodParams(
					&schema.MethodParam{
						Description: "Access key",
						Name:        "key",
						Optional:    false,
						Type:        "string",
					},
					&schema.MethodParam{
						Description: "Unique ID number",
						Name:        "cache_id",
						Optional:    false,
						Type:        "uint32",
					},
					&schema.MethodParam{
						Description: "Valid current cache API key",
						Name:        "cache_key",
						Optional:    false,
						Type:        "string",
					},
				),
				Undocumented: false,
				Version:      1,
			},
			&schema.Method{
				HTTPMethod: http.MethodPost,
				Name:       "SetSteamCachePerformanceStats",
				Params: schema.NewMethodParams(
					&schema.MethodParam{
						Description: "Access key",
						Name:        "key",
						Optional:    false,
						Type:        "string",
					},
					&schema.MethodParam{
						Description: "Unique ID number",
						Name:        "cache_id",
						Optional:    false,
						Type:        "uint32",
					},
					&schema.MethodParam{
						Description: "Valid current cache API key",
						Name:        "cache_key",
						Optional:    false,
						Type:        "string",
					},
					&schema.MethodParam{
						Description: "Outgoing network traffic in Mbps",
						Name:        "mbps_sent",
						Optional:    false,
						Type:        "uint32",
					},
					&schema.MethodParam{
						Description: "Incoming network traffic in Mbps",
						Name:        "mbps_recv",
						Optional:    false,
						Type:        "uint32",
					},
					&schema.MethodParam{
						Description: "Percent CPU load",
						Name:        "cpu_percent",
						Optional:    false,
						Type:        "uint32",
					},
					&schema.MethodParam{
						Description: "Percent cache hits",
						Name:        "cache_hit_percent",
						Optional:    false,
						Type:        "uint32",
					},
					&schema.MethodParam{
						Description: "Number of unique connected IP addresses",
						Name:        "num_connected_ips",
						Optional:    false,
						Type:        "uint32",
					},
					&schema.MethodParam{
						Description: "What is the percent utilization of the busiest datacenter egress link?",
						Name:        "upstream_egress_utilization",
						Optional:    false,
						Type:        "uint32",
					},
				),
				Undocumented: false,
				Version:      1,
			},
		),
		Name:         "IContentServerConfigService",
		Undocumented: false,
	},
)

var SchemaIContentServerDirectoryService = schema.MustNewInterfaces(
	&schema.Interface{
		Methods: schema.MustNewMethods(
			&schema.Method{
				HTTPMethod: http.MethodGet,
				Name:       "GetServersForSteamPipe",
				Params: schema.NewMethodParams(
					&schema.MethodParam{
						Description: "client Cell ID",
						Name:        "cell_id",
						Optional:    false,
						Type:        "uint32",
					},
					&schema.MethodParam{
						Description: "max servers in response list",
						Name:        "max_servers",
						Optional:    true,
						Type:        "uint32",
					},
					&schema.MethodParam{
						Description: "client IP address",
						Name:        "ip_override",
						Optional:    true,
						Type:        "string",
					},
					&schema.MethodParam{
						Description: "launcher type",
						Name:        "launcher_type",
						Optional:    true,
						Type:        "int32",
					},
				),
				Undocumented: false,
				Version:      1,
			},
			&schema.Method{
				HTTPMethod: http.MethodGet,
				Name:       "GetDepotPatchInfo",
				Params: schema.NewMethodParams(
					&schema.MethodParam{
						Description: "",
						Name:        "appid",
						Optional:    false,
						Type:        "uint32",
					},
					&schema.MethodParam{
						Description: "",
						Name:        "depotid",
						Optional:    false,
						Type:        "uint32",
					},
					&schema.MethodParam{
						Description: "",
						Name:        "source_manifestid",
						Optional:    false,
						Type:        "uint64",
					},
					&schema.MethodParam{
						Description: "",
						Name:        "target_manifestid",
						Optional:    false,
						Type:        "uint64",
					},
				),
				Undocumented: false,
				Version:      1,
			},
		),
		Name:         "IContentServerDirectoryService",
		Undocumented: false,
	},
)

var SchemaICredentialsService = schema.MustNewInterfaces(
	&schema.Interface{
		Methods: schema.MustNewMethods(
			&schema.Method{
				HTTPMethod:   http.MethodGet,
				Name:         "ValidateEmailAddress",
				Params:       schema.NewMethodParams(),
				Undocumented: true,
				Version:      1,
			},
			&schema.Method{
				HTTPMethod:   http.MethodGet,
				Name:         "SteamGuardPhishingReport",
				Params:       schema.NewMethodParams(),
				Undocumented: true,
				Version:      1,
			},
		),
		Name:         "ICredentialsService",
		Undocumented: true,
	},
)

var SchemaIDOTA2Fantasy = schema.MustNewInterfaces(
	&schema.Interface{
		Methods: schema.MustNewMethods(
			&schema.Method{
				HTTPMethod: http.MethodGet,
				Name:       "GetFantasyPlayerStats",
				Params: schema.NewMethodParams(
					&schema.MethodParam{
						Description: "The fantasy league ID",
						Name:        "FantasyLeagueID",
						Optional:    false,
						Type:        "uint32",
					},
					&schema.MethodParam{
						Description: "An optional filter for minimum timestamp",
						Name:        "StartTime",
						Optional:    true,
						Type:        "uint32",
					},
					&schema.MethodParam{
						Description: "An optional filter for maximum timestamp",
						Name:        "EndTime",
						Optional:    true,
						Type:        "uint32",
					},
					&schema.MethodParam{
						Description: "An optional filter for a specific match",
						Name:        "MatchID",
						Optional:    true,
						Type:        "uint64",
					},
					&schema.MethodParam{
						Description: "An optional filter for a specific series",
						Name:        "SeriesID",
						Optional:    true,
						Type:        "uint32",
					},
					&schema.MethodParam{
						Description: "An optional filter for a specific player",
						Name:        "PlayerAccountID",
						Optional:    true,
						Type:        "uint32",
					},
				),
				Undocumented: false,
				Version:      1,
			},
			&schema.Method{
				HTTPMethod: http.MethodGet,
				Name:       "GetPlayerOfficialInfo",
				Params: schema.NewMethodParams(
					&schema.MethodParam{
						Description: "The account ID to look up",
						Name:        "accountid",
						Optional:    false,
						Type:        "uint32",
					},
				),
				Undocumented: false,
				Version:      1,
			},
			&schema.Method{
				HTTPMethod:   http.MethodGet,
				Name:         "GetProPlayerList",
				Params:       schema.NewMethodParams(),
				Undocumented: false,
				Version:      1,
			},
		),
		Name:         "IDOTA2Fantasy_205790",
		Undocumented: false,
	},
)

var SchemaIDOTA2Match = schema.MustNewInterfaces(
	&schema.Interface{
		Methods: schema.MustNewMethods(
			&schema.Method{
				HTTPMethod: http.MethodGet,
				Name:       "GetLiveLeagueGames",
				Params: schema.NewMethodParams(
					&schema.MethodParam{
						Description: "Only show matches of the specified league id",
						Name:        "league_id",
						Optional:    true,
						Type:        "uint32",
					},
					&schema.MethodParam{
						Description: "Only show matches of the specified match id",
						Name:        "match_id",
						Optional:    true,
						Type:        "uint64",
					},
				),
				Undocumented: false,
				Version:      1,
			},
			&schema.Method{
				HTTPMethod: http.MethodGet,
				Name:       "GetMatchDetails",
				Params: schema.NewMethodParams(
					&schema.MethodParam{
						Description: "Match id",
						Name:        "match_id",
						Optional:    false,
						Type:        "uint64",
					},
					&schema.MethodParam{
						Description: "Include persona names as part of the response",
						Name:        "include_persona_names",
						Optional:    true,
						Type:        "bool",
					},
				),
				Undocumented: false,
				Version:      1,
			},
			&schema.Method{
				HTTPMethod: http.MethodGet,
				Name:       "GetMatchHistory",
				Params: schema.NewMethodParams(
					&schema.MethodParam{
						Description: "The ID of the hero that must be in the matches being queried",
						Name:        "hero_id",
						Optional:    true,
						Type:        "uint32",
					},
					&schema.MethodParam{
						Description: "Which game mode to return matches for",
						Name:        "game_mode",
						Optional:    true,
						Type:        "uint32",
					},
					&schema.MethodParam{
						Description: "The average skill range of the match, these can be [1-3] with lower numbers being lower skill. Ignored if an account ID is specified",
						Name:        "skill",
						Optional:    true,
						Type:        "uint32",
					},
					&schema.MethodParam{
						Description: "Minimum number of human players that must be in a match for it to be returned",
						Name:        "min_players",
						Optional:    true,
						Type:        "string",
					},
					&schema.MethodParam{
						Description: "An account ID to get matches from. This will fail if the user has their match history hidden",
						Name:        "account_id",
						Optional:    true,
						Type:        "string",
					},
					&schema.MethodParam{
						Description: "The league ID to return games from",
						Name:        "league_id",
						Optional:    true,
						Type:        "string",
					},
					&schema.MethodParam{
						Description: "The minimum match ID to start from",
						Name:        "start_at_match_id",
						Optional:    true,
						Type:        "uint64",
					},
					&schema.MethodParam{
						Description: "The number of requested matches to return",
						Name:        "matches_requested",
						Optional:    true,
						Type:        "string",
					},
				),
				Undocumented: false,
				Version:      1,
			},
			&schema.Method{
				HTTPMethod: http.MethodGet,
				Name:       "GetMatchHistoryBySequenceNum",
				Params: schema.NewMethodParams(
					&schema.MethodParam{
						Description: "",
						Name:        "start_at_match_seq_num",
						Optional:    true,
						Type:        "uint64",
					},
					&schema.MethodParam{
						Description: "",
						Name:        "matches_requested",
						Optional:    true,
						Type:        "uint32",
					},
				),
				Undocumented: false,
				Version:      1,
			},
			&schema.Method{
				HTTPMethod: http.MethodGet,
				Name:       "GetTeamInfoByTeamID",
				Params: schema.NewMethodParams(
					&schema.MethodParam{
						Description: "",
						Name:        "start_at_team_id",
						Optional:    true,
						Type:        "uint64",
					},
					&schema.MethodParam{
						Description: "",
						Name:        "teams_requested",
						Optional:    true,
						Type:        "uint32",
					},
				),
				Undocumented: false,
				Version:      1,
			},
			&schema.Method{
				HTTPMethod: http.MethodGet,
				Name:       "GetTopLiveEventGame",
				Params: schema.NewMethodParams(
					&schema.MethodParam{
						Description: "Which partner's games to use.",
						Name:        "partner",
						Optional:    false,
						Type:        "int32",
					},
				),
				Undocumented: false,
				Version:      1,
			},
			&schema.Method{
				HTTPMethod: http.MethodGet,
				Name:       "GetTopLiveGame",
				Params: schema.NewMethodParams(
					&schema.MethodParam{
						Description: "Which partner's games to use.",
						Name:        "partner",
						Optional:    false,
						Type:        "int32",
					},
				),
				Undocumented: false,
				Version:      1,
			},
			&schema.Method{
				HTTPMethod: http.MethodGet,
				Name:       "GetTopWeekendTourneyGames",
				Params: schema.NewMethodParams(
					&schema.MethodParam{
						Description: "Which partner's games to use.",
						Name:        "partner",
						Optional:    false,
						Type:        "int32",
					},
					&schema.MethodParam{
						Description: "Prefer matches from this division.",
						Name:        "home_division",
						Optional:    true,
						Type:        "int32",
					},
				),
				Undocumented: false,
				Version:      1,
			},
			&schema.Method{
				HTTPMethod: http.MethodGet,
				Name:       "GetTournamentPlayerStats",
				Params: schema.NewMethodParams(
					&schema.MethodParam{
						Description: "",
						Name:        "account_id",
						Optional:    false,
						Type:        "string",
					},
					&schema.MethodParam{
						Description: "",
						Name:        "league_id",
						Optional:    true,
						Type:        "string",
					},
					&schema.MethodParam{
						Description: "",
						Name:        "hero_id",
						Optional:    true,
						Type:        "string",
					},
					&schema.MethodParam{
						Description: "",
						Name:        "time_frame",
						Optional:    true,
						Type:        "string",
					},
					&schema.MethodParam{
						Description: "",
						Name:        "match_id",
						Optional:    true,
						Type:        "uint64",
					},
				),
				Undocumented: false,
				Version:      1,
			},
			&schema.Method{
				HTTPMethod: http.MethodGet,
				Name:       "GetTournamentPlayerStats",
				Params: schema.NewMethodParams(
					&schema.MethodParam{
						Description: "",
						Name:        "account_id",
						Optional:    false,
						Type:        "string",
					},
					&schema.MethodParam{
						Description: "",
						Name:        "league_id",
						Optional:    true,
						Type:        "string",
					},
					&schema.MethodParam{
						Description: "",
						Name:        "hero_id",
						Optional:    true,
						Type:        "string",
					},
					&schema.MethodParam{
						Description: "",
						Name:        "time_frame",
						Optional:    true,
						Type:        "string",
					},
					&schema.MethodParam{
						Description: "",
						Name:        "match_id",
						Optional:    true,
						Type:        "uint64",
					},
					&schema.MethodParam{
						Description: "",
						Name:        "phase_id",
						Optional:    true,
						Type:        "uint32",
					},
				),
				Undocumented: false,
				Version:      2,
			},
		),
		Name:         "IDOTA2Match_570",
		Undocumented: false,
	},
	&schema.Interface{
		Methods: schema.MustNewMethods(
			&schema.Method{
				HTTPMethod:   http.MethodGet,
				Name:         "GetLeagueListing",
				Params:       schema.NewMethodParams(),
				Undocumented: false,
				Version:      1,
			},
			&schema.Method{
				HTTPMethod: http.MethodGet,
				Name:       "GetLiveLeagueGames",
				Params: schema.NewMethodParams(
					&schema.MethodParam{
						Description: "Only show matches of the specified league id",
						Name:        "league_id",
						Optional:    true,
						Type:        "uint32",
					},
					&schema.MethodParam{
						Description: "Only show matches of the specified match id",
						Name:        "match_id",
						Optional:    true,
						Type:        "uint64",
					},
				),
				Undocumented: false,
				Version:      1,
			},
			&schema.Method{
				HTTPMethod: http.MethodGet,
				Name:       "GetMatchDetails",
				Params: schema.NewMethodParams(
					&schema.MethodParam{
						Description: "Match id",
						Name:        "match_id",
						Optional:    false,
						Type:        "uint64",
					},
				),
				Undocumented: false,
				Version:      1,
			},
			&schema.Method{
				HTTPMethod: http.MethodGet,
				Name:       "GetMatchHistory",
				Params: schema.NewMethodParams(
					&schema.MethodParam{
						Description: "The ID of the hero that must be in the matches being queried",
						Name:        "hero_id",
						Optional:    true,
						Type:        "uint32",
					},
					&schema.MethodParam{
						Description: "Which game mode to return matches for",
						Name:        "game_mode",
						Optional:    true,
						Type:        "uint32",
					},
					&schema.MethodParam{
						Description: "The average skill range of the match, these can be [1-3] with lower numbers being lower skill. Ignored if an account ID is specified",
						Name:        "skill",
						Optional:    true,
						Type:        "uint32",
					},
					&schema.MethodParam{
						Description: "Minimum number of human players that must be in a match for it to be returned",
						Name:        "min_players",
						Optional:    true,
						Type:        "string",
					},
					&schema.MethodParam{
						Description: "An account ID to get matches from. This will fail if the user has their match history hidden",
						Name:        "account_id",
						Optional:    true,
						Type:        "string",
					},
					&schema.MethodParam{
						Description: "The league ID to return games from",
						Name:        "league_id",
						Optional:    true,
						Type:        "string",
					},
					&schema.MethodParam{
						Description: "The minimum match ID to start from",
						Name:        "start_at_match_id",
						Optional:    true,
						Type:        "uint64",
					},
					&schema.MethodParam{
						Description: "The number of requested matches to return",
						Name:        "matches_requested",
						Optional:    true,
						Type:        "string",
					},
				),
				Undocumented: false,
				Version:      1,
			},
			&schema.Method{
				HTTPMethod: http.MethodGet,
				Name:       "GetMatchHistoryBySequenceNum",
				Params: schema.NewMethodParams(
					&schema.MethodParam{
						Description: "",
						Name:        "start_at_match_seq_num",
						Optional:    true,
						Type:        "uint64",
					},
					&schema.MethodParam{
						Description: "",
						Name:        "matches_requested",
						Optional:    true,
						Type:        "uint32",
					},
				),
				Undocumented: false,
				Version:      1,
			},
			&schema.Method{
				HTTPMethod: http.MethodGet,
				Name:       "GetTeamInfoByTeamID",
				Params: schema.NewMethodParams(
					&schema.MethodParam{
						Description: "",
						Name:        "start_at_team_id",
						Optional:    true,
						Type:        "uint64",
					},
					&schema.MethodParam{
						Description: "",
						Name:        "teams_requested",
						Optional:    true,
						Type:        "uint32",
					},
				),
				Undocumented: false,
				Version:      1,
			},
			&schema.Method{
				HTTPMethod: http.MethodGet,
				Name:       "GetTopLiveEventGame",
				Params: schema.NewMethodParams(
					&schema.MethodParam{
						Description: "Which partner's games to use.",
						Name:        "partner",
						Optional:    false,
						Type:        "int32",
					},
				),
				Undocumented: false,
				Version:      1,
			},
			&schema.Method{
				HTTPMethod: http.MethodGet,
				Name:       "GetTopLiveGame",
				Params: schema.NewMethodParams(
					&schema.MethodParam{
						Description: "Which partner's games to use.",
						Name:        "partner",
						Optional:    false,
						Type:        "int32",
					},
				),
				Undocumented: false,
				Version:      1,
			},
			&schema.Method{
				HTTPMethod: http.MethodGet,
				Name:       "GetTopWeekendTourneyGames",
				Params: schema.NewMethodParams(
					&schema.MethodParam{
						Description: "Which partner's games to use.",
						Name:        "partner",
						Optional:    false,
						Type:        "int32",
					},
					&schema.MethodParam{
						Description: "Prefer matches from this division.",
						Name:        "home_division",
						Optional:    true,
						Type:        "int32",
					},
				),
				Undocumented: false,
				Version:      1,
			},
			&schema.Method{
				HTTPMethod: http.MethodGet,
				Name:       "GetTournamentPlayerStats",
				Params: schema.NewMethodParams(
					&schema.MethodParam{
						Description: "",
						Name:        "account_id",
						Optional:    false,
						Type:        "string",
					},
					&schema.MethodParam{
						Description: "",
						Name:        "league_id",
						Optional:    true,
						Type:        "string",
					},
					&schema.MethodParam{
						Description: "",
						Name:        "hero_id",
						Optional:    true,
						Type:        "string",
					},
					&schema.MethodParam{
						Description: "",
						Name:        "time_frame",
						Optional:    true,
						Type:        "string",
					},
					&schema.MethodParam{
						Description: "",
						Name:        "match_id",
						Optional:    true,
						Type:        "uint64",
					},
					&schema.MethodParam{
						Description: "",
						Name:        "phase_id",
						Optional:    true,
						Type:        "uint32",
					},
				),
				Undocumented: false,
				Version:      1,
			},
			&schema.Method{
				HTTPMethod: http.MethodGet,
				Name:       "GetTournamentPlayerStats",
				Params: schema.NewMethodParams(
					&schema.MethodParam{
						Description: "",
						Name:        "account_id",
						Optional:    false,
						Type:        "string",
					},
					&schema.MethodParam{
						Description: "",
						Name:        "league_id",
						Optional:    true,
						Type:        "string",
					},
					&schema.MethodParam{
						Description: "",
						Name:        "hero_id",
						Optional:    true,
						Type:        "string",
					},
					&schema.MethodParam{
						Description: "",
						Name:        "time_frame",
						Optional:    true,
						Type:        "string",
					},
					&schema.MethodParam{
						Description: "",
						Name:        "match_id",
						Optional:    true,
						Type:        "uint64",
					},
					&schema.MethodParam{
						Description: "",
						Name:        "phase_id",
						Optional:    true,
						Type:        "uint32",
					},
				),
				Undocumented: false,
				Version:      2,
			},
		),
		Name:         "IDOTA2Match_205790",
		Undocumented: false,
	},
)

var SchemaIDOTA2MatchStats = schema.MustNewInterfaces(
	&schema.Interface{
		Methods: schema.MustNewMethods(
			&schema.Method{
				HTTPMethod: http.MethodGet,
				Name:       "GetRealtimeStats",
				Params: schema.NewMethodParams(
					&schema.MethodParam{
						Description: "",
						Name:        "server_steam_id",
						Optional:    false,
						Type:        "uint64",
					},
				),
				Undocumented: false,
				Version:      1,
			},
		),
		Name:         "IDOTA2MatchStats_570",
		Undocumented: false,
	},
	&schema.Interface{
		Methods: schema.MustNewMethods(
			&schema.Method{
				HTTPMethod: http.MethodGet,
				Name:       "GetRealtimeStats",
				Params: schema.NewMethodParams(
					&schema.MethodParam{
						Description: "",
						Name:        "server_steam_id",
						Optional:    false,
						Type:        "uint64",
					},
				),
				Undocumented: false,
				Version:      1,
			},
		),
		Name:         "IDOTA2MatchStats_205790",
		Undocumented: false,
	},
)

var SchemaIDOTA2StreamSystem = schema.MustNewInterfaces(
	&schema.Interface{
		Methods: schema.MustNewMethods(
			&schema.Method{
				HTTPMethod: http.MethodGet,
				Name:       "GetBroadcasterInfo",
				Params: schema.NewMethodParams(
					&schema.MethodParam{
						Description: "64-bit Steam ID of the broadcaster",
						Name:        "broadcaster_steam_id",
						Optional:    false,
						Type:        "uint64",
					},
					&schema.MethodParam{
						Description: "LeagueID to use if we aren't in a lobby",
						Name:        "league_id",
						Optional:    true,
						Type:        "uint32",
					},
				),
				Undocumented: false,
				Version:      1,
			},
		),
		Name:         "IDOTA2StreamSystem_570",
		Undocumented: false,
	},
	&schema.Interface{
		Methods: schema.MustNewMethods(
			&schema.Method{
				HTTPMethod: http.MethodGet,
				Name:       "GetBroadcasterInfo",
				Params: schema.NewMethodParams(
					&schema.MethodParam{
						Description: "64-bit Steam ID of the broadcaster",
						Name:        "broadcaster_steam_id",
						Optional:    false,
						Type:        "uint64",
					},
					&schema.MethodParam{
						Description: "LeagueID to use if we aren't in a lobby",
						Name:        "league_id",
						Optional:    true,
						Type:        "uint32",
					},
				),
				Undocumented: false,
				Version:      1,
			},
		),
		Name:         "IDOTA2StreamSystem_205790",
		Undocumented: false,
	},
)

var SchemaIDOTA2Ticket = schema.MustNewInterfaces(
	&schema.Interface{
		Methods: schema.MustNewMethods(
			&schema.Method{
				HTTPMethod: http.MethodGet,
				Name:       "ClaimBadgeReward",
				Params: schema.NewMethodParams(
					&schema.MethodParam{
						Description: "The Badge ID",
						Name:        "BadgeID",
						Optional:    false,
						Type:        "string",
					},
					&schema.MethodParam{
						Description: "Valid Badge Type 1",
						Name:        "ValidBadgeType1",
						Optional:    false,
						Type:        "uint32",
					},
					&schema.MethodParam{
						Description: "Valid Badge Type 2",
						Name:        "ValidBadgeType2",
						Optional:    false,
						Type:        "uint32",
					},
					&schema.MethodParam{
						Description: "Valid Badge Type 3",
						Name:        "ValidBadgeType3",
						Optional:    false,
						Type:        "uint32",
					},
				),
				Undocumented: false,
				Version:      1,
			},
			&schema.Method{
				HTTPMethod: http.MethodGet,
				Name:       "GetSteamIDForBadgeID",
				Params: schema.NewMethodParams(
					&schema.MethodParam{
						Description: "The badge ID",
						Name:        "BadgeID",
						Optional:    false,
						Type:        "string",
					},
				),
				Undocumented: false,
				Version:      1,
			},
			&schema.Method{
				HTTPMethod: http.MethodPost,
				Name:       "SetSteamAccountPurchased",
				Params: schema.NewMethodParams(
					&schema.MethodParam{
						Description: "The 64-bit Steam ID",
						Name:        "steamid",
						Optional:    false,
						Type:        "uint64",
					},
					&schema.MethodParam{
						Description: "Badge Type",
						Name:        "BadgeType",
						Optional:    false,
						Type:        "uint32",
					},
				),
				Undocumented: false,
				Version:      1,
			},
			&schema.Method{
				HTTPMethod: http.MethodGet,
				Name:       "SteamAccountValidForBadgeType",
				Params: schema.NewMethodParams(
					&schema.MethodParam{
						Description: "The 64-bit Steam ID",
						Name:        "steamid",
						Optional:    false,
						Type:        "uint64",
					},
					&schema.MethodParam{
						Description: "Valid Badge Type 1",
						Name:        "ValidBadgeType1",
						Optional:    false,
						Type:        "uint32",
					},
					&schema.MethodParam{
						Description: "Valid Badge Type 2",
						Name:        "ValidBadgeType2",
						Optional:    false,
						Type:        "uint32",
					},
					&schema.MethodParam{
						Description: "Valid Badge Type 3",
						Name:        "ValidBadgeType3",
						Optional:    false,
						Type:        "uint32",
					},
				),
				Undocumented: false,
				Version:      1,
			},
		),
		Name:         "IDOTA2Ticket_570",
		Undocumented: false,
	},
	&schema.Interface{
		Methods: schema.MustNewMethods(
			&schema.Method{
				HTTPMethod: http.MethodGet,
				Name:       "ClaimBadgeReward",
				Params: schema.NewMethodParams(
					&schema.MethodParam{
						Description: "The Badge ID",
						Name:        "BadgeID",
						Optional:    false,
						Type:        "string",
					},
					&schema.MethodParam{
						Description: "Valid Badge Type 1",
						Name:        "ValidBadgeType1",
						Optional:    false,
						Type:        "uint32",
					},
					&schema.MethodParam{
						Description: "Valid Badge Type 2",
						Name:        "ValidBadgeType2",
						Optional:    false,
						Type:        "uint32",
					},
					&schema.MethodParam{
						Description: "Valid Badge Type 3",
						Name:        "ValidBadgeType3",
						Optional:    false,
						Type:        "uint32",
					},
				),
				Undocumented: false,
				Version:      1,
			},
			&schema.Method{
				HTTPMethod: http.MethodGet,
				Name:       "GetSteamIDForBadgeID",
				Params: schema.NewMethodParams(
					&schema.MethodParam{
						Description: "The badge ID",
						Name:        "BadgeID",
						Optional:    false,
						Type:        "string",
					},
				),
				Undocumented: false,
				Version:      1,
			},
			&schema.Method{
				HTTPMethod: http.MethodPost,
				Name:       "SetSteamAccountPurchased",
				Params: schema.NewMethodParams(
					&schema.MethodParam{
						Description: "The 64-bit Steam ID",
						Name:        "steamid",
						Optional:    false,
						Type:        "uint64",
					},
					&schema.MethodParam{
						Description: "Badge Type",
						Name:        "BadgeType",
						Optional:    false,
						Type:        "uint32",
					},
				),
				Undocumented: false,
				Version:      1,
			},
			&schema.Method{
				HTTPMethod: http.MethodGet,
				Name:       "SteamAccountValidForBadgeType",
				Params: schema.NewMethodParams(
					&schema.MethodParam{
						Description: "The 64-bit Steam ID",
						Name:        "steamid",
						Optional:    false,
						Type:        "uint64",
					},
					&schema.MethodParam{
						Description: "Valid Badge Type 1",
						Name:        "ValidBadgeType1",
						Optional:    false,
						Type:        "uint32",
					},
					&schema.MethodParam{
						Description: "Valid Badge Type 2",
						Name:        "ValidBadgeType2",
						Optional:    false,
						Type:        "uint32",
					},
					&schema.MethodParam{
						Description: "Valid Badge Type 3",
						Name:        "ValidBadgeType3",
						Optional:    false,
						Type:        "uint32",
					},
				),
				Undocumented: false,
				Version:      1,
			},
		),
		Name:         "IDOTA2Ticket_205790",
		Undocumented: false,
	},
)

var SchemaIEconDOTA2 = schema.MustNewInterfaces(
	&schema.Interface{
		Methods: schema.MustNewMethods(
			&schema.Method{
				HTTPMethod: http.MethodGet,
				Name:       "GetEventStatsForAccount",
				Params: schema.NewMethodParams(
					&schema.MethodParam{
						Description: "The League ID of the compendium you're looking for.",
						Name:        "eventid",
						Optional:    false,
						Type:        "uint32",
					},
					&schema.MethodParam{
						Description: "The account ID to look up.",
						Name:        "accountid",
						Optional:    false,
						Type:        "uint32",
					},
					&schema.MethodParam{
						Description: "The language to provide hero names in.",
						Name:        "language",
						Optional:    true,
						Type:        "string",
					},
				),
				Undocumented: false,
				Version:      1,
			},
			&schema.Method{
				HTTPMethod: http.MethodGet,
				Name:       "GetGameItems",
				Params: schema.NewMethodParams(
					&schema.MethodParam{
						Description: "The language to provide item names in.",
						Name:        "language",
						Optional:    true,
						Type:        "string",
					},
				),
				Undocumented: false,
				Version:      1,
			},
			&schema.Method{
				HTTPMethod: http.MethodGet,
				Name:       "GetHeroes",
				Params: schema.NewMethodParams(
					&schema.MethodParam{
						Description: "The language to provide hero names in.",
						Name:        "language",
						Optional:    true,
						Type:        "string",
					},
					&schema.MethodParam{
						Description: "Return a list of itemized heroes only.",
						Name:        "itemizedonly",
						Optional:    true,
						Type:        "bool",
					},
				),
				Undocumented: false,
				Version:      1,
			},
			&schema.Method{
				HTTPMethod: http.MethodGet,
				Name:       "GetItemCreators",
				Params: schema.NewMethodParams(
					&schema.MethodParam{
						Description: "The item definition to get creator information for.",
						Name:        "itemdef",
						Optional:    false,
						Type:        "uint32",
					},
				),
				Undocumented: false,
				Version:      1,
			},
			&schema.Method{
				HTTPMethod: http.MethodGet,
				Name:       "GetRarities",
				Params: schema.NewMethodParams(
					&schema.MethodParam{
						Description: "The language to provide rarity names in.",
						Name:        "language",
						Optional:    true,
						Type:        "string",
					},
				),
				Undocumented: false,
				Version:      1,
			},
			&schema.Method{
				HTTPMethod: http.MethodGet,
				Name:       "GetTournamentPrizePool",
				Params: schema.NewMethodParams(
					&schema.MethodParam{
						Description: "The ID of the league to get the prize pool of",
						Name:        "leagueid",
						Optional:    true,
						Type:        "uint32",
					},
				),
				Undocumented: false,
				Version:      1,
			},
		),
		Name:         "IEconDOTA2_570",
		Undocumented: false,
	},
	&schema.Interface{
		Methods: schema.MustNewMethods(
			&schema.Method{
				HTTPMethod: http.MethodGet,
				Name:       "GetEventStatsForAccount",
				Params: schema.NewMethodParams(
					&schema.MethodParam{
						Description: "The League ID of the compendium you're looking for.",
						Name:        "eventid",
						Optional:    false,
						Type:        "uint32",
					},
					&schema.MethodParam{
						Description: "The account ID to look up.",
						Name:        "accountid",
						Optional:    false,
						Type:        "uint32",
					},
					&schema.MethodParam{
						Description: "The language to provide hero names in.",
						Name:        "language",
						Optional:    true,
						Type:        "string",
					},
				),
				Undocumented: false,
				Version:      1,
			},
			&schema.Method{
				HTTPMethod: http.MethodGet,
				Name:       "GetGameItems",
				Params: schema.NewMethodParams(
					&schema.MethodParam{
						Description: "The language to provide item names in.",
						Name:        "language",
						Optional:    true,
						Type:        "string",
					},
				),
				Undocumented: false,
				Version:      1,
			},
			&schema.Method{
				HTTPMethod: http.MethodGet,
				Name:       "GetHeroes",
				Params: schema.NewMethodParams(
					&schema.MethodParam{
						Description: "The language to provide hero names in.",
						Name:        "language",
						Optional:    true,
						Type:        "string",
					},
					&schema.MethodParam{
						Description: "Return a list of itemized heroes only.",
						Name:        "itemizedonly",
						Optional:    true,
						Type:        "bool",
					},
				),
				Undocumented: false,
				Version:      1,
			},
			&schema.Method{
				HTTPMethod: http.MethodGet,
				Name:       "GetItemIconPath",
				Params: schema.NewMethodParams(
					&schema.MethodParam{
						Description: "The item icon name to get the CDN path of",
						Name:        "iconname",
						Optional:    false,
						Type:        "string",
					},
					&schema.MethodParam{
						Description: "The type of image you want. 0 = normal, 1 = large, 2 = ingame",
						Name:        "icontype",
						Optional:    true,
						Type:        "uint32",
					},
				),
				Undocumented: false,
				Version:      1,
			},
			&schema.Method{
				HTTPMethod: http.MethodGet,
				Name:       "GetRarities",
				Params: schema.NewMethodParams(
					&schema.MethodParam{
						Description: "The language to provide rarity names in.",
						Name:        "language",
						Optional:    true,
						Type:        "string",
					},
				),
				Undocumented: false,
				Version:      1,
			},
			&schema.Method{
				HTTPMethod: http.MethodGet,
				Name:       "GetTournamentPrizePool",
				Params: schema.NewMethodParams(
					&schema.MethodParam{
						Description: "The ID of the league to get the prize pool of",
						Name:        "leagueid",
						Optional:    true,
						Type:        "uint32",
					},
				),
				Undocumented: false,
				Version:      1,
			},
		),
		Name:         "IEconDOTA2_205790",
		Undocumented: false,
	},
)

var SchemaIEconItems = schema.MustNewInterfaces(
	&schema.Interface{
		Methods: schema.MustNewMethods(
			&schema.Method{
				HTTPMethod: http.MethodGet,
				Name:       "GetPlayerItems",
				Params: schema.NewMethodParams(
					&schema.MethodParam{
						Description: "The Steam ID to fetch items for",
						Name:        "steamid",
						Optional:    false,
						Type:        "uint64",
					},
				),
				Undocumented: false,
				Version:      1,
			},
			&schema.Method{
				HTTPMethod: http.MethodGet,
				Name:       "GetSchema",
				Params: schema.NewMethodParams(
					&schema.MethodParam{
						Description: "The language to return the names in. Defaults to returning string keys.",
						Name:        "language",
						Optional:    true,
						Type:        "string",
					},
				),
				Undocumented: false,
				Version:      1,
			},
			&schema.Method{
				HTTPMethod: http.MethodGet,
				Name:       "GetSchemaItems",
				Params: schema.NewMethodParams(
					&schema.MethodParam{
						Description: "The language to return the names in. Defaults to returning string keys.",
						Name:        "language",
						Optional:    true,
						Type:        "string",
					},
					&schema.MethodParam{
						Description: "The first item id to return. Defaults to 0. Response will indicate next value to query if applicable.",
						Name:        "start",
						Optional:    true,
						Type:        "int32",
					},
				),
				Undocumented: false,
				Version:      1,
			},
			&schema.Method{
				HTTPMethod: http.MethodGet,
				Name:       "GetSchemaOverview",
				Params: schema.NewMethodParams(
					&schema.MethodParam{
						Description: "The language to return the names in. Defaults to returning string keys.",
						Name:        "language",
						Optional:    true,
						Type:        "string",
					},
				),
				Undocumented: false,
				Version:      1,
			},
			&schema.Method{
				HTTPMethod:   http.MethodGet,
				Name:         "GetSchemaURL",
				Params:       schema.NewMethodParams(),
				Undocumented: false,
				Version:      1,
			},
			&schema.Method{
				HTTPMethod: http.MethodGet,
				Name:       "GetStoreMetaData",
				Params: schema.NewMethodParams(
					&schema.MethodParam{
						Description: "The language to results in.",
						Name:        "language",
						Optional:    true,
						Type:        "string",
					},
				),
				Undocumented: false,
				Version:      1,
			},
			&schema.Method{
				HTTPMethod:   http.MethodGet,
				Name:         "GetStoreStatus",
				Params:       schema.NewMethodParams(),
				Undocumented: false,
				Version:      1,
			},
		),
		Name:         "IEconItems_440",
		Undocumented: false,
	},
	&schema.Interface{
		Methods: schema.MustNewMethods(
			&schema.Method{
				HTTPMethod: http.MethodGet,
				Name:       "GetEquippedPlayerItems",
				Params: schema.NewMethodParams(
					&schema.MethodParam{
						Description: "The Steam ID to fetch items for",
						Name:        "steamid",
						Optional:    false,
						Type:        "uint64",
					},
					&schema.MethodParam{
						Description: "Return items equipped for this class id",
						Name:        "class_id",
						Optional:    false,
						Type:        "uint32",
					},
				),
				Undocumented: false,
				Version:      1,
			},
			&schema.Method{
				HTTPMethod: http.MethodGet,
				Name:       "GetPlayerItems",
				Params: schema.NewMethodParams(
					&schema.MethodParam{
						Description: "The Steam ID to fetch items for",
						Name:        "steamid",
						Optional:    false,
						Type:        "uint64",
					},
				),
				Undocumented: false,
				Version:      1,
			},
			&schema.Method{
				HTTPMethod:   http.MethodGet,
				Name:         "GetSchemaURL",
				Params:       schema.NewMethodParams(),
				Undocumented: false,
				Version:      1,
			},
			&schema.Method{
				HTTPMethod: http.MethodGet,
				Name:       "GetStoreMetaData",
				Params: schema.NewMethodParams(
					&schema.MethodParam{
						Description: "The language to results in.",
						Name:        "language",
						Optional:    true,
						Type:        "string",
					},
				),
				Undocumented: false,
				Version:      1,
			},
		),
		Name:         "IEconItems_570",
		Undocumented: false,
	},
	&schema.Interface{
		Methods: schema.MustNewMethods(
			&schema.Method{
				HTTPMethod: http.MethodGet,
				Name:       "GetPlayerItems",
				Params: schema.NewMethodParams(
					&schema.MethodParam{
						Description: "The Steam ID to fetch items for",
						Name:        "steamid",
						Optional:    false,
						Type:        "uint64",
					},
				),
				Undocumented: false,
				Version:      1,
			},
			&schema.Method{
				HTTPMethod: http.MethodGet,
				Name:       "GetSchema",
				Params: schema.NewMethodParams(
					&schema.MethodParam{
						Description: "The language to return the names in. Defaults to returning string keys.",
						Name:        "language",
						Optional:    true,
						Type:        "string",
					},
				),
				Undocumented: false,
				Version:      1,
			},
		),
		Name:         "IEconItems_620",
		Undocumented: false,
	},
	&schema.Interface{
		Methods: schema.MustNewMethods(
			&schema.Method{
				HTTPMethod: http.MethodGet,
				Name:       "GetPlayerItems",
				Params: schema.NewMethodParams(
					&schema.MethodParam{
						Description: "The Steam ID to fetch items for",
						Name:        "steamid",
						Optional:    false,
						Type:        "uint64",
					},
				),
				Undocumented: false,
				Version:      1,
			},
			&schema.Method{
				HTTPMethod: http.MethodGet,
				Name:       "GetSchema",
				Params: schema.NewMethodParams(
					&schema.MethodParam{
						Description: "The language to return the names in. Defaults to returning string keys.",
						Name:        "language",
						Optional:    true,
						Type:        "string",
					},
				),
				Undocumented: false,
				Version:      2,
			},
			&schema.Method{
				HTTPMethod:   http.MethodGet,
				Name:         "GetSchemaURL",
				Params:       schema.NewMethodParams(),
				Undocumented: false,
				Version:      2,
			},
			&schema.Method{
				HTTPMethod: http.MethodGet,
				Name:       "GetStoreMetaData",
				Params: schema.NewMethodParams(
					&schema.MethodParam{
						Description: "The language to results in.",
						Name:        "language",
						Optional:    true,
						Type:        "string",
					},
				),
				Undocumented: false,
				Version:      1,
			},
		),
		Name:         "IEconItems_730",
		Undocumented: false,
	},
	&schema.Interface{
		Methods: schema.MustNewMethods(
			&schema.Method{
				HTTPMethod: http.MethodGet,
				Name:       "GetEquippedPlayerItems",
				Params: schema.NewMethodParams(
					&schema.MethodParam{
						Description: "The Steam ID to fetch items for",
						Name:        "steamid",
						Optional:    false,
						Type:        "uint64",
					},
					&schema.MethodParam{
						Description: "Return items equipped for this class id",
						Name:        "class_id",
						Optional:    false,
						Type:        "uint32",
					},
				),
				Undocumented: false,
				Version:      1,
			},
			&schema.Method{
				HTTPMethod: http.MethodGet,
				Name:       "GetPlayerItems",
				Params: schema.NewMethodParams(
					&schema.MethodParam{
						Description: "The Steam ID to fetch items for",
						Name:        "steamid",
						Optional:    false,
						Type:        "uint64",
					},
				),
				Undocumented: false,
				Version:      1,
			},
			&schema.Method{
				HTTPMethod:   http.MethodGet,
				Name:         "GetSchemaURL",
				Params:       schema.NewMethodParams(),
				Undocumented: false,
				Version:      1,
			},
			&schema.Method{
				HTTPMethod: http.MethodGet,
				Name:       "GetStoreMetaData",
				Params: schema.NewMethodParams(
					&schema.MethodParam{
						Description: "The language to results in.",
						Name:        "language",
						Optional:    true,
						Type:        "string",
					},
				),
				Undocumented: false,
				Version:      1,
			},
		),
		Name:         "IEconItems_205790",
		Undocumented: false,
	},
	&schema.Interface{
		Methods: schema.MustNewMethods(
			&schema.Method{
				HTTPMethod: http.MethodGet,
				Name:       "GetPlayerItems",
				Params: schema.NewMethodParams(
					&schema.MethodParam{
						Description: "The Steam ID to fetch items for",
						Name:        "steamid",
						Optional:    false,
						Type:        "uint64",
					},
				),
				Undocumented: false,
				Version:      1,
			},
		),
		Name:         "IEconItems_221540",
		Undocumented: false,
	},
	&schema.Interface{
		Methods: schema.MustNewMethods(
			&schema.Method{
				HTTPMethod: http.MethodGet,
				Name:       "GetPlayerItems",
				Params: schema.NewMethodParams(
					&schema.MethodParam{
						Description: "The Steam ID to fetch items for",
						Name:        "steamid",
						Optional:    false,
						Type:        "uint64",
					},
				),
				Undocumented: false,
				Version:      1,
			},
		),
		Name:         "IEconItems_238460",
		Undocumented: false,
	},
	&schema.Interface{
		Methods: schema.MustNewMethods(
			&schema.Method{
				HTTPMethod: http.MethodGet,
				Name:       "GetEquippedPlayerItems",
				Params: schema.NewMethodParams(
					&schema.MethodParam{
						Description: "The Steam ID to fetch items for",
						Name:        "steamid",
						Optional:    false,
						Type:        "uint64",
					},
					&schema.MethodParam{
						Description: "Return items equipped for this class id",
						Name:        "class_id",
						Optional:    false,
						Type:        "uint32",
					},
				),
				Undocumented: false,
				Version:      1,
			},
		),
		Name:         "IEconItems_583950",
		Undocumented: false,
	},
)

var SchemaIEconService = schema.MustNewInterfaces(
	&schema.Interface{
		Methods: schema.MustNewMethods(
			&schema.Method{
				HTTPMethod: http.MethodGet,
				Name:       "GetTradeHistory",
				Params: schema.NewMethodParams(
					&schema.MethodParam{
						Description: "Access key",
						Name:        "key",
						Optional:    false,
						Type:        "string",
					},
					&schema.MethodParam{
						Description: "The number of trades to return information for",
						Name:        "max_trades",
						Optional:    false,
						Type:        "uint32",
					},
					&schema.MethodParam{
						Description: "The time of the last trade shown on the previous page of results, or the time of the first trade if navigating back",
						Name:        "start_after_time",
						Optional:    false,
						Type:        "uint32",
					},
					&schema.MethodParam{
						Description: "The tradeid shown on the previous page of results, or the ID of the first trade if navigating back",
						Name:        "start_after_tradeid",
						Optional:    false,
						Type:        "uint64",
					},
					&schema.MethodParam{
						Description: "The user wants the previous page of results, so return the previous max_trades trades before the start time and ID",
						Name:        "navigating_back",
						Optional:    false,
						Type:        "bool",
					},
					&schema.MethodParam{
						Description: "If set, the item display data for the items included in the returned trades will also be returned",
						Name:        "get_descriptions",
						Optional:    false,
						Type:        "bool",
					},
					&schema.MethodParam{
						Description: "The language to use when loading item display data",
						Name:        "language",
						Optional:    false,
						Type:        "string",
					},
					&schema.MethodParam{
						Description: "",
						Name:        "include_failed",
						Optional:    false,
						Type:        "bool",
					},
					&schema.MethodParam{
						Description: "If set, the total number of trades the account has participated in will be included in the response",
						Name:        "include_total",
						Optional:    false,
						Type:        "bool",
					},
				),
				Undocumented: false,
				Version:      1,
			},
			&schema.Method{
				HTTPMethod: http.MethodGet,
				Name:       "GetTradeStatus",
				Params: schema.NewMethodParams(
					&schema.MethodParam{
						Description: "Access key",
						Name:        "key",
						Optional:    false,
						Type:        "string",
					},
					&schema.MethodParam{
						Description: "",
						Name:        "tradeid",
						Optional:    false,
						Type:        "uint64",
					},
					&schema.MethodParam{
						Description: "If set, the item display data for the items included in the returned trades will also be returned",
						Name:        "get_descriptions",
						Optional:    false,
						Type:        "bool",
					},
					&schema.MethodParam{
						Description: "The language to use when loading item display data",
						Name:        "language",
						Optional:    false,
						Type:        "string",
					},
				),
				Undocumented: false,
				Version:      1,
			},
			&schema.Method{
				HTTPMethod: http.MethodGet,
				Name:       "GetTradeOffers",
				Params: schema.NewMethodParams(
					&schema.MethodParam{
						Description: "Access key",
						Name:        "key",
						Optional:    false,
						Type:        "string",
					},
					&schema.MethodParam{
						Description: "Request the list of sent offers.",
						Name:        "get_sent_offers",
						Optional:    false,
						Type:        "bool",
					},
					&schema.MethodParam{
						Description: "Request the list of received offers.",
						Name:        "get_received_offers",
						Optional:    false,
						Type:        "bool",
					},
					&schema.MethodParam{
						Description: "If set, the item display data for the items included in the returned trade offers will also be returned. If one or more descriptions can't be retrieved, then your request will fail.",
						Name:        "get_descriptions",
						Optional:    false,
						Type:        "bool",
					},
					&schema.MethodParam{
						Description: "The language to use when loading item display data.",
						Name:        "language",
						Optional:    false,
						Type:        "string",
					},
					&schema.MethodParam{
						Description: "Indicates we should only return offers which are still active, or offers that have changed in state since the time_historical_cutoff",
						Name:        "active_only",
						Optional:    false,
						Type:        "bool",
					},
					&schema.MethodParam{
						Description: "Indicates we should only return offers which are not active.",
						Name:        "historical_only",
						Optional:    false,
						Type:        "bool",
					},
					&schema.MethodParam{
						Description: "When active_only is set, offers updated since this time will also be returned",
						Name:        "time_historical_cutoff",
						Optional:    false,
						Type:        "uint32",
					},
				),
				Undocumented: false,
				Version:      1,
			},
			&schema.Method{
				HTTPMethod: http.MethodGet,
				Name:       "GetTradeOffer",
				Params: schema.NewMethodParams(
					&schema.MethodParam{
						Description: "Access key",
						Name:        "key",
						Optional:    false,
						Type:        "string",
					},
					&schema.MethodParam{
						Description: "",
						Name:        "tradeofferid",
						Optional:    false,
						Type:        "uint64",
					},
					&schema.MethodParam{
						Description: "",
						Name:        "language",
						Optional:    false,
						Type:        "string",
					},
					&schema.MethodParam{
						Description: "If set, the item display data for the items included in the returned trade offers will also be returned. If one or more descriptions can't be retrieved, then your request will fail.",
						Name:        "get_descriptions",
						Optional:    false,
						Type:        "bool",
					},
				),
				Undocumented: false,
				Version:      1,
			},
			&schema.Method{
				HTTPMethod: http.MethodGet,
				Name:       "GetTradeOffersSummary",
				Params: schema.NewMethodParams(
					&schema.MethodParam{
						Description: "Access key",
						Name:        "key",
						Optional:    false,
						Type:        "string",
					},
					&schema.MethodParam{
						Description: "The time the user last visited.  If not passed, will use the time the user last visited the trade offer page.",
						Name:        "time_last_visit",
						Optional:    false,
						Type:        "uint32",
					},
				),
				Undocumented: false,
				Version:      1,
			},
			&schema.Method{
				HTTPMethod: http.MethodPost,
				Name:       "DeclineTradeOffer",
				Params: schema.NewMethodParams(
					&schema.MethodParam{
						Description: "Access key",
						Name:        "key",
						Optional:    false,
						Type:        "string",
					},
					&schema.MethodParam{
						Description: "",
						Name:        "tradeofferid",
						Optional:    false,
						Type:        "uint64",
					},
				),
				Undocumented: false,
				Version:      1,
			},
			&schema.Method{
				HTTPMethod: http.MethodPost,
				Name:       "CancelTradeOffer",
				Params: schema.NewMethodParams(
					&schema.MethodParam{
						Description: "Access key",
						Name:        "key",
						Optional:    false,
						Type:        "string",
					},
					&schema.MethodParam{
						Description: "",
						Name:        "tradeofferid",
						Optional:    false,
						Type:        "uint64",
					},
				),
				Undocumented: false,
				Version:      1,
			},
			&schema.Method{
				HTTPMethod: http.MethodGet,
				Name:       "GetTradeHoldDurations",
				Params: schema.NewMethodParams(
					&schema.MethodParam{
						Description: "Access key",
						Name:        "key",
						Optional:    false,
						Type:        "string",
					},
					&schema.MethodParam{
						Description: "User you are trading with",
						Name:        "steamid_target",
						Optional:    false,
						Type:        "uint64",
					},
					&schema.MethodParam{
						Description: "A special token that allows for trade offers from non-friends.",
						Name:        "trade_offer_access_token",
						Optional:    false,
						Type:        "string",
					},
				),
				Undocumented: false,
				Version:      1,
			},
		),
		Name:         "IEconService",
		Undocumented: false,
	},
)

var SchemaIFriendMessagesService = schema.MustNewInterfaces(
	&schema.Interface{
		Methods: schema.MustNewMethods(
			&schema.Method{
				HTTPMethod:   http.MethodGet,
				Name:         "GetActiveMessageSessions",
				Params:       schema.NewMethodParams(),
				Undocumented: true,
				Version:      1,
			},
			&schema.Method{
				HTTPMethod:   http.MethodGet,
				Name:         "GetRecentMessages",
				Params:       schema.NewMethodParams(),
				Undocumented: true,
				Version:      1,
			},
			&schema.Method{
				HTTPMethod:   http.MethodGet,
				Name:         "MarkOfflineMessagesRead",
				Params:       schema.NewMethodParams(),
				Undocumented: true,
				Version:      1,
			},
		),
		Name:         "IFriendMessagesService",
		Undocumented: true,
	},
)

var SchemaIGCVersion = schema.MustNewInterfaces(
	&schema.Interface{
		Methods: schema.MustNewMethods(
			&schema.Method{
				HTTPMethod:   http.MethodGet,
				Name:         "GetClientVersion",
				Params:       schema.NewMethodParams(),
				Undocumented: false,
				Version:      1,
			},
			&schema.Method{
				HTTPMethod:   http.MethodGet,
				Name:         "GetServerVersion",
				Params:       schema.NewMethodParams(),
				Undocumented: false,
				Version:      1,
			},
		),
		Name:         "IGCVersion_440",
		Undocumented: false,
	},
	&schema.Interface{
		Methods: schema.MustNewMethods(
			&schema.Method{
				HTTPMethod:   http.MethodGet,
				Name:         "GetClientVersion",
				Params:       schema.NewMethodParams(),
				Undocumented: false,
				Version:      1,
			},
			&schema.Method{
				HTTPMethod:   http.MethodGet,
				Name:         "GetServerVersion",
				Params:       schema.NewMethodParams(),
				Undocumented: false,
				Version:      1,
			},
		),
		Name:         "IGCVersion_570",
		Undocumented: false,
	},
	&schema.Interface{
		Methods: schema.MustNewMethods(
			&schema.Method{
				HTTPMethod:   http.MethodGet,
				Name:         "GetServerVersion",
				Params:       schema.NewMethodParams(),
				Undocumented: false,
				Version:      1,
			},
		),
		Name:         "IGCVersion_730",
		Undocumented: false,
	},
	&schema.Interface{
		Methods: schema.MustNewMethods(
			&schema.Method{
				HTTPMethod:   http.MethodGet,
				Name:         "GetClientVersion",
				Params:       schema.NewMethodParams(),
				Undocumented: false,
				Version:      1,
			},
			&schema.Method{
				HTTPMethod:   http.MethodGet,
				Name:         "GetServerVersion",
				Params:       schema.NewMethodParams(),
				Undocumented: false,
				Version:      1,
			},
		),
		Name:         "IGCVersion_205790",
		Undocumented: false,
	},
	&schema.Interface{
		Methods: schema.MustNewMethods(
			&schema.Method{
				HTTPMethod:   http.MethodGet,
				Name:         "GetClientVersion",
				Params:       schema.NewMethodParams(),
				Undocumented: false,
				Version:      1,
			},
			&schema.Method{
				HTTPMethod:   http.MethodGet,
				Name:         "GetServerVersion",
				Params:       schema.NewMethodParams(),
				Undocumented: false,
				Version:      1,
			},
		),
		Name:         "IGCVersion_583950",
		Undocumented: false,
	},
	&schema.Interface{
		Methods: schema.MustNewMethods(
			&schema.Method{
				HTTPMethod:   http.MethodGet,
				Name:         "GetClientVersion",
				Params:       schema.NewMethodParams(),
				Undocumented: false,
				Version:      1,
			},
			&schema.Method{
				HTTPMethod:   http.MethodGet,
				Name:         "GetServerVersion",
				Params:       schema.NewMethodParams(),
				Undocumented: false,
				Version:      1,
			},
		),
		Name:         "IGCVersion_1046930",
		Undocumented: false,
	},
)

var SchemaIGameCoordinator = schema.MustNewInterfaces(
	&schema.Interface{
		Methods: schema.MustNewMethods(
			&schema.Method{
				HTTPMethod:   http.MethodGet,
				Name:         "GetMessages",
				Params:       schema.NewMethodParams(),
				Undocumented: true,
				Version:      1,
			},
			&schema.Method{
				HTTPMethod:   http.MethodGet,
				Name:         "PostMessages",
				Params:       schema.NewMethodParams(),
				Undocumented: true,
				Version:      1,
			},
		),
		Name:         "IGameCoordinator",
		Undocumented: true,
	},
)

var SchemaIGameInventory = schema.MustNewInterfaces(
	&schema.Interface{
		Methods: schema.MustNewMethods(
			&schema.Method{
				HTTPMethod:   http.MethodGet,
				Name:         "GetItemDefArchive",
				Params:       schema.NewMethodParams(),
				Undocumented: true,
				Version:      1,
			},
		),
		Name:         "IGameInventory",
		Undocumented: true,
	},
)

var SchemaIGameNotificationsService = schema.MustNewInterfaces(
	&schema.Interface{
		Methods: schema.MustNewMethods(
			&schema.Method{
				HTTPMethod: http.MethodPost,
				Name:       "UserCreateSession",
				Params: schema.NewMethodParams(
					&schema.MethodParam{
						Description: "The appid to create the session for.",
						Name:        "appid",
						Optional:    false,
						Type:        "uint32",
					},
					&schema.MethodParam{
						Description: "Game-specified context value the game can used to associate the session with some object on their backend.",
						Name:        "context",
						Optional:    false,
						Type:        "uint64",
					},
					&schema.MethodParam{
						Description: "The title of the session to be displayed within each user's list of sessions.",
						Name:        "title",
						Optional:    false,
						Type:        "{message}",
					},
					&schema.MethodParam{
						Description: "The initial state of all users in the session.",
						Name:        "users",
						Optional:    false,
						Type:        "{message}",
					},
					&schema.MethodParam{
						Description: "(Optional) steamid to make the request on behalf of -- if specified, the user must be in the session and all users being added to the session must be friends with the user.",
						Name:        "steamid",
						Optional:    false,
						Type:        "uint64",
					},
				),
				Undocumented: false,
				Version:      1,
			},
			&schema.Method{
				HTTPMethod: http.MethodPost,
				Name:       "UserUpdateSession",
				Params: schema.NewMethodParams(
					&schema.MethodParam{
						Description: "The sessionid to update.",
						Name:        "sessionid",
						Optional:    false,
						Type:        "uint64",
					},
					&schema.MethodParam{
						Description: "The appid of the session to update.",
						Name:        "appid",
						Optional:    false,
						Type:        "uint32",
					},
					&schema.MethodParam{
						Description: "(Optional) The new title of the session.  If not specified, the title will not be changed.",
						Name:        "title",
						Optional:    false,
						Type:        "{message}",
					},
					&schema.MethodParam{
						Description: "(Optional) A list of users whose state will be updated to reflect the given state. If the users are not already in the session, they will be added to it.",
						Name:        "users",
						Optional:    false,
						Type:        "{message}",
					},
					&schema.MethodParam{
						Description: "(Optional) steamid to make the request on behalf of -- if specified, the user must be in the session and all users being added to the session must be friends with the user.",
						Name:        "steamid",
						Optional:    false,
						Type:        "uint64",
					},
				),
				Undocumented: false,
				Version:      1,
			},
			&schema.Method{
				HTTPMethod: http.MethodPost,
				Name:       "UserDeleteSession",
				Params: schema.NewMethodParams(
					&schema.MethodParam{
						Description: "The sessionid to delete.",
						Name:        "sessionid",
						Optional:    false,
						Type:        "uint64",
					},
					&schema.MethodParam{
						Description: "The appid of the session to delete.",
						Name:        "appid",
						Optional:    false,
						Type:        "uint32",
					},
					&schema.MethodParam{
						Description: "(Optional) steamid to make the request on behalf of -- if specified, the user must be in the session.",
						Name:        "steamid",
						Optional:    false,
						Type:        "uint64",
					},
				),
				Undocumented: false,
				Version:      1,
			},
		),
		Name:         "IGameNotificationsService",
		Undocumented: false,
	},
)

var SchemaIGameServersService = schema.MustNewInterfaces(
	&schema.Interface{
		Methods: schema.MustNewMethods(
			&schema.Method{
				HTTPMethod: http.MethodGet,
				Name:       "GetAccountList",
				Params: schema.NewMethodParams(
					&schema.MethodParam{
						Description: "Access key",
						Name:        "key",
						Optional:    false,
						Type:        "string",
					},
				),
				Undocumented: false,
				Version:      1,
			},
			&schema.Method{
				HTTPMethod: http.MethodPost,
				Name:       "CreateAccount",
				Params: schema.NewMethodParams(
					&schema.MethodParam{
						Description: "Access key",
						Name:        "key",
						Optional:    false,
						Type:        "string",
					},
					&schema.MethodParam{
						Description: "The app to use the account for",
						Name:        "appid",
						Optional:    false,
						Type:        "uint32",
					},
					&schema.MethodParam{
						Description: "The memo to set on the new account",
						Name:        "memo",
						Optional:    false,
						Type:        "string",
					},
				),
				Undocumented: false,
				Version:      1,
			},
			&schema.Method{
				HTTPMethod: http.MethodPost,
				Name:       "SetMemo",
				Params: schema.NewMethodParams(
					&schema.MethodParam{
						Description: "Access key",
						Name:        "key",
						Optional:    false,
						Type:        "string",
					},
					&schema.MethodParam{
						Description: "The SteamID of the game server to set the memo on",
						Name:        "steamid",
						Optional:    false,
						Type:        "uint64",
					},
					&schema.MethodParam{
						Description: "The memo to set on the new account",
						Name:        "memo",
						Optional:    false,
						Type:        "string",
					},
				),
				Undocumented: false,
				Version:      1,
			},
			&schema.Method{
				HTTPMethod: http.MethodPost,
				Name:       "ResetLoginToken",
				Params: schema.NewMethodParams(
					&schema.MethodParam{
						Description: "Access key",
						Name:        "key",
						Optional:    false,
						Type:        "string",
					},
					&schema.MethodParam{
						Description: "The SteamID of the game server to reset the login token of",
						Name:        "steamid",
						Optional:    false,
						Type:        "uint64",
					},
				),
				Undocumented: false,
				Version:      1,
			},
			&schema.Method{
				HTTPMethod: http.MethodPost,
				Name:       "DeleteAccount",
				Params: schema.NewMethodParams(
					&schema.MethodParam{
						Description: "Access key",
						Name:        "key",
						Optional:    false,
						Type:        "string",
					},
					&schema.MethodParam{
						Description: "The SteamID of the game server account to delete",
						Name:        "steamid",
						Optional:    false,
						Type:        "uint64",
					},
				),
				Undocumented: false,
				Version:      1,
			},
			&schema.Method{
				HTTPMethod: http.MethodGet,
				Name:       "GetAccountPublicInfo",
				Params: schema.NewMethodParams(
					&schema.MethodParam{
						Description: "Access key",
						Name:        "key",
						Optional:    false,
						Type:        "string",
					},
					&schema.MethodParam{
						Description: "The SteamID of the game server to get info on",
						Name:        "steamid",
						Optional:    false,
						Type:        "uint64",
					},
				),
				Undocumented: false,
				Version:      1,
			},
			&schema.Method{
				HTTPMethod: http.MethodGet,
				Name:       "QueryLoginToken",
				Params: schema.NewMethodParams(
					&schema.MethodParam{
						Description: "Access key",
						Name:        "key",
						Optional:    false,
						Type:        "string",
					},
					&schema.MethodParam{
						Description: "Login token to query",
						Name:        "login_token",
						Optional:    false,
						Type:        "string",
					},
				),
				Undocumented: false,
				Version:      1,
			},
			&schema.Method{
				HTTPMethod: http.MethodGet,
				Name:       "GetServerSteamIDsByIP",
				Params: schema.NewMethodParams(
					&schema.MethodParam{
						Description: "Access key",
						Name:        "key",
						Optional:    false,
						Type:        "string",
					},
					&schema.MethodParam{
						Description: "",
						Name:        "server_ips",
						Optional:    false,
						Type:        "string",
					},
				),
				Undocumented: false,
				Version:      1,
			},
			&schema.Method{
				HTTPMethod: http.MethodGet,
				Name:       "GetServerIPsBySteamID",
				Params: schema.NewMethodParams(
					&schema.MethodParam{
						Description: "Access key",
						Name:        "key",
						Optional:    false,
						Type:        "string",
					},
					&schema.MethodParam{
						Description: "",
						Name:        "server_steamids",
						Optional:    false,
						Type:        "uint64",
					},
				),
				Undocumented: false,
				Version:      1,
			},
			&schema.Method{
				HTTPMethod:   http.MethodGet,
				Name:         "GetServerList",
				Params:       schema.NewMethodParams(),
				Undocumented: true,
				Version:      1,
			},
		),
		Name:         "IGameServersService",
		Undocumented: false,
	},
)

var SchemaIInventoryService = schema.MustNewInterfaces(
	&schema.Interface{
		Methods: schema.MustNewMethods(
			&schema.Method{
				HTTPMethod: http.MethodPost,
				Name:       "SplitItemStack",
				Params: schema.NewMethodParams(
					&schema.MethodParam{
						Description: "Access key",
						Name:        "key",
						Optional:    false,
						Type:        "string",
					},
					&schema.MethodParam{
						Description: "",
						Name:        "appid",
						Optional:    false,
						Type:        "uint32",
					},
					&schema.MethodParam{
						Description: "",
						Name:        "itemid",
						Optional:    false,
						Type:        "uint64",
					},
					&schema.MethodParam{
						Description: "",
						Name:        "quantity",
						Optional:    false,
						Type:        "uint32",
					},
				),
				Undocumented: false,
				Version:      1,
			},
			&schema.Method{
				HTTPMethod: http.MethodPost,
				Name:       "CombineItemStacks",
				Params: schema.NewMethodParams(
					&schema.MethodParam{
						Description: "Access key",
						Name:        "key",
						Optional:    false,
						Type:        "string",
					},
					&schema.MethodParam{
						Description: "",
						Name:        "appid",
						Optional:    false,
						Type:        "uint32",
					},
					&schema.MethodParam{
						Description: "",
						Name:        "fromitemid",
						Optional:    false,
						Type:        "uint64",
					},
					&schema.MethodParam{
						Description: "",
						Name:        "destitemid",
						Optional:    false,
						Type:        "uint64",
					},
					&schema.MethodParam{
						Description: "",
						Name:        "quantity",
						Optional:    false,
						Type:        "uint32",
					},
				),
				Undocumented: false,
				Version:      1,
			},
			&schema.Method{
				HTTPMethod: http.MethodGet,
				Name:       "GetPriceSheet",
				Params: schema.NewMethodParams(
					&schema.MethodParam{
						Description: "Access key",
						Name:        "key",
						Optional:    false,
						Type:        "string",
					},
					&schema.MethodParam{
						Description: "",
						Name:        "ecurrency",
						Optional:    false,
						Type:        "int32",
					},
				),
				Undocumented: false,
				Version:      1,
			},
			&schema.Method{
				HTTPMethod:   http.MethodGet,
				Name:         "GetInventory",
				Params:       schema.NewMethodParams(),
				Undocumented: true,
				Version:      1,
			},
			&schema.Method{
				HTTPMethod:   http.MethodGet,
				Name:         "ExchangeItem",
				Params:       schema.NewMethodParams(),
				Undocumented: true,
				Version:      1,
			},
			&schema.Method{
				HTTPMethod:   http.MethodGet,
				Name:         "AddPromoItem",
				Params:       schema.NewMethodParams(),
				Undocumented: true,
				Version:      1,
			},
			&schema.Method{
				HTTPMethod:   http.MethodGet,
				Name:         "GetItemDefs",
				Params:       schema.NewMethodParams(),
				Undocumented: true,
				Version:      1,
			},
			&schema.Method{
				HTTPMethod:   http.MethodGet,
				Name:         "GetItemDefMeta",
				Params:       schema.NewMethodParams(),
				Undocumented: true,
				Version:      1,
			},
			&schema.Method{
				HTTPMethod:   http.MethodGet,
				Name:         "ConsumeItem",
				Params:       schema.NewMethodParams(),
				Undocumented: true,
				Version:      1,
			},
		),
		Name:         "IInventoryService",
		Undocumented: false,
	},
)

var SchemaIMobileAuthService = schema.MustNewInterfaces(
	&schema.Interface{
		Methods: schema.MustNewMethods(
			&schema.Method{
				HTTPMethod:   http.MethodGet,
				Name:         "GetWGToken",
				Params:       schema.NewMethodParams(),
				Undocumented: true,
				Version:      1,
			},
		),
		Name:         "IMobileAuthService",
		Undocumented: true,
	},
)

var SchemaIMobileNotificationService = schema.MustNewInterfaces(
	&schema.Interface{
		Methods: schema.MustNewMethods(
			&schema.Method{
				HTTPMethod:   http.MethodGet,
				Name:         "GetUserNotificationCounts",
				Params:       schema.NewMethodParams(),
				Undocumented: true,
				Version:      1,
			},
			&schema.Method{
				HTTPMethod:   http.MethodGet,
				Name:         "SwitchSessionToPush",
				Params:       schema.NewMethodParams(),
				Undocumented: true,
				Version:      1,
			},
		),
		Name:         "IMobileNotificationService",
		Undocumented: true,
	},
)

var SchemaIPlayerService = schema.MustNewInterfaces(
	&schema.Interface{
		Methods: schema.MustNewMethods(
			&schema.Method{
				HTTPMethod: http.MethodPost,
				Name:       "RecordOfflinePlaytime",
				Params: schema.NewMethodParams(
					&schema.MethodParam{
						Description: "",
						Name:        "steamid",
						Optional:    false,
						Type:        "uint64",
					},
					&schema.MethodParam{
						Description: "",
						Name:        "ticket",
						Optional:    false,
						Type:        "string",
					},
					&schema.MethodParam{
						Description: "",
						Name:        "play_sessions",
						Optional:    false,
						Type:        "{message}",
					},
				),
				Undocumented: false,
				Version:      1,
			},
			&schema.Method{
				HTTPMethod: http.MethodGet,
				Name:       "GetRecentlyPlayedGames",
				Params: schema.NewMethodParams(
					&schema.MethodParam{
						Description: "Access key",
						Name:        "key",
						Optional:    false,
						Type:        "string",
					},
					&schema.MethodParam{
						Description: "The player we're asking about",
						Name:        "steamid",
						Optional:    false,
						Type:        "uint64",
					},
					&schema.MethodParam{
						Description: "The number of games to return (0/unset: all)",
						Name:        "count",
						Optional:    false,
						Type:        "uint32",
					},
				),
				Undocumented: false,
				Version:      1,
			},
			&schema.Method{
				HTTPMethod: http.MethodGet,
				Name:       "GetOwnedGames",
				Params: schema.NewMethodParams(
					&schema.MethodParam{
						Description: "Access key",
						Name:        "key",
						Optional:    false,
						Type:        "string",
					},
					&schema.MethodParam{
						Description: "The player we're asking about",
						Name:        "steamid",
						Optional:    false,
						Type:        "uint64",
					},
					&schema.MethodParam{
						Description: "true if we want additional details (name, icon) about each game",
						Name:        "include_appinfo",
						Optional:    false,
						Type:        "bool",
					},
					&schema.MethodParam{
						Description: "Free games are excluded by default.  If this is set, free games the user has played will be returned.",
						Name:        "include_played_free_games",
						Optional:    false,
						Type:        "bool",
					},
					&schema.MethodParam{
						Description: "if set, restricts result set to the passed in apps",
						Name:        "appids_filter",
						Optional:    false,
						Type:        "uint32",
					},
				),
				Undocumented: false,
				Version:      1,
			},
			&schema.Method{
				HTTPMethod: http.MethodGet,
				Name:       "GetSteamLevel",
				Params: schema.NewMethodParams(
					&schema.MethodParam{
						Description: "Access key",
						Name:        "key",
						Optional:    false,
						Type:        "string",
					},
					&schema.MethodParam{
						Description: "The player we're asking about",
						Name:        "steamid",
						Optional:    false,
						Type:        "uint64",
					},
				),
				Undocumented: false,
				Version:      1,
			},
			&schema.Method{
				HTTPMethod: http.MethodGet,
				Name:       "GetBadges",
				Params: schema.NewMethodParams(
					&schema.MethodParam{
						Description: "Access key",
						Name:        "key",
						Optional:    false,
						Type:        "string",
					},
					&schema.MethodParam{
						Description: "The player we're asking about",
						Name:        "steamid",
						Optional:    false,
						Type:        "uint64",
					},
				),
				Undocumented: false,
				Version:      1,
			},
			&schema.Method{
				HTTPMethod: http.MethodGet,
				Name:       "GetCommunityBadgeProgress",
				Params: schema.NewMethodParams(
					&schema.MethodParam{
						Description: "Access key",
						Name:        "key",
						Optional:    false,
						Type:        "string",
					},
					&schema.MethodParam{
						Description: "The player we're asking about",
						Name:        "steamid",
						Optional:    false,
						Type:        "uint64",
					},
					&schema.MethodParam{
						Description: "The badge we're asking about",
						Name:        "badgeid",
						Optional:    false,
						Type:        "int32",
					},
				),
				Undocumented: false,
				Version:      1,
			},
			&schema.Method{
				HTTPMethod: http.MethodGet,
				Name:       "IsPlayingSharedGame",
				Params: schema.NewMethodParams(
					&schema.MethodParam{
						Description: "Access key",
						Name:        "key",
						Optional:    false,
						Type:        "string",
					},
					&schema.MethodParam{
						Description: "The player we're asking about",
						Name:        "steamid",
						Optional:    false,
						Type:        "uint64",
					},
					&schema.MethodParam{
						Description: "The game player is currently playing",
						Name:        "appid_playing",
						Optional:    false,
						Type:        "uint32",
					},
				),
				Undocumented: false,
				Version:      1,
			},
			&schema.Method{
				HTTPMethod:   http.MethodGet,
				Name:         "GetSteamLevelDistribution",
				Params:       schema.NewMethodParams(),
				Undocumented: true,
				Version:      1,
			},
			&schema.Method{
				HTTPMethod:   http.MethodGet,
				Name:         "GetNicknameList",
				Params:       schema.NewMethodParams(),
				Undocumented: true,
				Version:      1,
			},
			&schema.Method{
				HTTPMethod:   http.MethodGet,
				Name:         "AddFriend",
				Params:       schema.NewMethodParams(),
				Undocumented: true,
				Version:      1,
			},
			&schema.Method{
				HTTPMethod:   http.MethodGet,
				Name:         "RemoveFriend",
				Params:       schema.NewMethodParams(),
				Undocumented: true,
				Version:      1,
			},
			&schema.Method{
				HTTPMethod:   http.MethodGet,
				Name:         "IgnoreFriend",
				Params:       schema.NewMethodParams(),
				Undocumented: true,
				Version:      1,
			},
		),
		Name:         "IPlayerService",
		Undocumented: false,
	},
)

var SchemaIPortal2Leaderboards = schema.MustNewInterfaces(
	&schema.Interface{
		Methods: schema.MustNewMethods(
			&schema.Method{
				HTTPMethod: http.MethodGet,
				Name:       "GetBucketizedData",
				Params: schema.NewMethodParams(
					&schema.MethodParam{
						Description: "The leaderboard name to fetch data for.",
						Name:        "leaderboardName",
						Optional:    false,
						Type:        "string",
					},
				),
				Undocumented: false,
				Version:      1,
			},
		),
		Name:         "IPortal2Leaderboards_620",
		Undocumented: false,
	},
)

var SchemaIPublishedFileService = schema.MustNewInterfaces(
	&schema.Interface{
		Methods: schema.MustNewMethods(
			&schema.Method{
				HTTPMethod: http.MethodGet,
				Name:       "QueryFiles",
				Params: schema.NewMethodParams(
					&schema.MethodParam{
						Description: "Access key",
						Name:        "key",
						Optional:    false,
						Type:        "string",
					},
					&schema.MethodParam{
						Description: "enumeration EPublishedFileQueryType in clientenums.h",
						Name:        "query_type",
						Optional:    false,
						Type:        "uint32",
					},
					&schema.MethodParam{
						Description: "Current page",
						Name:        "page",
						Optional:    false,
						Type:        "uint32",
					},
					&schema.MethodParam{
						Description: "Cursor to paginate through the results (set to '*' for the first request).  Prefer this over using the page parameter, as it will allow you to do deep pagination.  When used, the page parameter will be ignored.",
						Name:        "cursor",
						Optional:    false,
						Type:        "string",
					},
					&schema.MethodParam{
						Description: "(Optional) The number of results, per page to return.",
						Name:        "numperpage",
						Optional:    true,
						Type:        "uint32",
					},
					&schema.MethodParam{
						Description: "App that created the files",
						Name:        "creator_appid",
						Optional:    false,
						Type:        "uint32",
					},
					&schema.MethodParam{
						Description: "App that consumes the files",
						Name:        "appid",
						Optional:    false,
						Type:        "uint32",
					},
					&schema.MethodParam{
						Description: "Tags to match on. See match_all_tags parameter below",
						Name:        "requiredtags",
						Optional:    false,
						Type:        "string",
					},
					&schema.MethodParam{
						Description: "(Optional) Tags that must NOT be present on a published file to satisfy the query.",
						Name:        "excludedtags",
						Optional:    false,
						Type:        "string",
					},
					&schema.MethodParam{
						Description: "If true, then items must have all the tags specified, otherwise they must have at least one of the tags.",
						Name:        "match_all_tags",
						Optional:    true,
						Type:        "bool",
					},
					&schema.MethodParam{
						Description: "Required flags that must be set on any returned items",
						Name:        "required_flags",
						Optional:    false,
						Type:        "string",
					},
					&schema.MethodParam{
						Description: "Flags that must not be set on any returned items",
						Name:        "omitted_flags",
						Optional:    false,
						Type:        "string",
					},
					&schema.MethodParam{
						Description: "Text to match in the item's title or description",
						Name:        "search_text",
						Optional:    false,
						Type:        "string",
					},
					&schema.MethodParam{
						Description: "EPublishedFileInfoMatchingFileType",
						Name:        "filetype",
						Optional:    false,
						Type:        "uint32",
					},
					&schema.MethodParam{
						Description: "Find all items that reference the given item.",
						Name:        "child_publishedfileid",
						Optional:    false,
						Type:        "uint64",
					},
					&schema.MethodParam{
						Description: "If query_type is k_PublishedFileQueryType_RankedByTrend, then this is the number of days to get votes for [1,7].",
						Name:        "days",
						Optional:    false,
						Type:        "uint32",
					},
					&schema.MethodParam{
						Description: "If query_type is k_PublishedFileQueryType_RankedByTrend, then limit result set just to items that have votes within the day range given",
						Name:        "include_recent_votes_only",
						Optional:    false,
						Type:        "bool",
					},
					&schema.MethodParam{
						Description: "Allow stale data to be returned for the specified number of seconds.",
						Name:        "cache_max_age_seconds",
						Optional:    true,
						Type:        "uint32",
					},
					&schema.MethodParam{
						Description: "Language to search in and also what gets returned. Defaults to English.",
						Name:        "language",
						Optional:    true,
						Type:        "int32",
					},
					&schema.MethodParam{
						Description: "Required key-value tags to match on.",
						Name:        "required_kv_tags",
						Optional:    false,
						Type:        "{message}",
					},
					&schema.MethodParam{
						Description: "(Optional) At least one of the tags must be present on a published file to satisfy the query.",
						Name:        "taggroups",
						Optional:    false,
						Type:        "{message}",
					},
					&schema.MethodParam{
						Description: "(Optional) If true, only return the total number of files that satisfy this query.",
						Name:        "totalonly",
						Optional:    false,
						Type:        "bool",
					},
					&schema.MethodParam{
						Description: "(Optional) If true, only return the published file ids of files that satisfy this query.",
						Name:        "ids_only",
						Optional:    false,
						Type:        "bool",
					},
					&schema.MethodParam{
						Description: "Return vote data",
						Name:        "return_vote_data",
						Optional:    false,
						Type:        "bool",
					},
					&schema.MethodParam{
						Description: "Return tags in the file details",
						Name:        "return_tags",
						Optional:    false,
						Type:        "bool",
					},
					&schema.MethodParam{
						Description: "Return key-value tags in the file details",
						Name:        "return_kv_tags",
						Optional:    false,
						Type:        "bool",
					},
					&schema.MethodParam{
						Description: "Return preview image and video details in the file details",
						Name:        "return_previews",
						Optional:    false,
						Type:        "bool",
					},
					&schema.MethodParam{
						Description: "Return child item ids in the file details",
						Name:        "return_children",
						Optional:    false,
						Type:        "bool",
					},
					&schema.MethodParam{
						Description: "Populate the short_description field instead of file_description",
						Name:        "return_short_description",
						Optional:    false,
						Type:        "bool",
					},
					&schema.MethodParam{
						Description: "Return pricing information, if applicable",
						Name:        "return_for_sale_data",
						Optional:    false,
						Type:        "bool",
					},
					&schema.MethodParam{
						Description: "Populate the metadata",
						Name:        "return_metadata",
						Optional:    true,
						Type:        "bool",
					},
					&schema.MethodParam{
						Description: "Return playtime stats for the specified number of days before today.",
						Name:        "return_playtime_stats",
						Optional:    false,
						Type:        "uint32",
					},
					&schema.MethodParam{
						Description: "By default, if none of the other 'return_*' fields are set, only some voting details are returned. Set this to true to return the default set of details.",
						Name:        "return_details",
						Optional:    false,
						Type:        "bool",
					},
					&schema.MethodParam{
						Description: "Strips BBCode from descriptions.",
						Name:        "strip_description_bbcode",
						Optional:    false,
						Type:        "bool",
					},
					&schema.MethodParam{
						Description: "Return the data for the specified revision.",
						Name:        "desired_revision",
						Optional:    true,
						Type:        "{enum}",
					},
				),
				Undocumented: false,
				Version:      1,
			},
			&schema.Method{
				HTTPMethod: http.MethodGet,
				Name:       "GetDetails",
				Params: schema.NewMethodParams(
					&schema.MethodParam{
						Description: "Access key",
						Name:        "key",
						Optional:    false,
						Type:        "string",
					},
					&schema.MethodParam{
						Description: "Set of published file Ids to retrieve details for.",
						Name:        "publishedfileids",
						Optional:    false,
						Type:        "uint64",
					},
					&schema.MethodParam{
						Description: "If true, return tag information in the returned details.",
						Name:        "includetags",
						Optional:    false,
						Type:        "bool",
					},
					&schema.MethodParam{
						Description: "If true, return preview information in the returned details.",
						Name:        "includeadditionalpreviews",
						Optional:    false,
						Type:        "bool",
					},
					&schema.MethodParam{
						Description: "If true, return children in the returned details.",
						Name:        "includechildren",
						Optional:    false,
						Type:        "bool",
					},
					&schema.MethodParam{
						Description: "If true, return key value tags in the returned details.",
						Name:        "includekvtags",
						Optional:    false,
						Type:        "bool",
					},
					&schema.MethodParam{
						Description: "If true, return vote data in the returned details.",
						Name:        "includevotes",
						Optional:    false,
						Type:        "bool",
					},
					&schema.MethodParam{
						Description: "If true, return a short description instead of the full description.",
						Name:        "short_description",
						Optional:    false,
						Type:        "bool",
					},
					&schema.MethodParam{
						Description: "If true, return pricing data, if applicable.",
						Name:        "includeforsaledata",
						Optional:    false,
						Type:        "bool",
					},
					&schema.MethodParam{
						Description: "If true, populate the metadata field.",
						Name:        "includemetadata",
						Optional:    false,
						Type:        "bool",
					},
					&schema.MethodParam{
						Description: "Specifies the localized text to return. Defaults to English.",
						Name:        "language",
						Optional:    true,
						Type:        "int32",
					},
					&schema.MethodParam{
						Description: "Return playtime stats for the specified number of days before today.",
						Name:        "return_playtime_stats",
						Optional:    false,
						Type:        "uint32",
					},
					&schema.MethodParam{
						Description: "",
						Name:        "appid",
						Optional:    false,
						Type:        "uint32",
					},
					&schema.MethodParam{
						Description: "Strips BBCode from descriptions.",
						Name:        "strip_description_bbcode",
						Optional:    false,
						Type:        "bool",
					},
					&schema.MethodParam{
						Description: "Return the data for the specified revision.",
						Name:        "desired_revision",
						Optional:    true,
						Type:        "{enum}",
					},
				),
				Undocumented: false,
				Version:      1,
			},
			&schema.Method{
				HTTPMethod: http.MethodGet,
				Name:       "GetUserFiles",
				Params: schema.NewMethodParams(
					&schema.MethodParam{
						Description: "Access key",
						Name:        "key",
						Optional:    false,
						Type:        "string",
					},
					&schema.MethodParam{
						Description: "Steam ID of the user whose files are being requested.",
						Name:        "steamid",
						Optional:    false,
						Type:        "uint64",
					},
					&schema.MethodParam{
						Description: "App Id of the app that the files were published to.",
						Name:        "appid",
						Optional:    false,
						Type:        "uint32",
					},
					&schema.MethodParam{
						Description: "(Optional) Starting page for results.",
						Name:        "page",
						Optional:    true,
						Type:        "uint32",
					},
					&schema.MethodParam{
						Description: "(Optional) The number of results, per page to return.",
						Name:        "numperpage",
						Optional:    true,
						Type:        "uint32",
					},
					&schema.MethodParam{
						Description: "(Optional) Type of files to be returned.",
						Name:        "type",
						Optional:    true,
						Type:        "string",
					},
					&schema.MethodParam{
						Description: "(Optional) Sorting method to use on returned values.",
						Name:        "sortmethod",
						Optional:    true,
						Type:        "string",
					},
					&schema.MethodParam{
						Description: "(optional) Filter by privacy settings.",
						Name:        "privacy",
						Optional:    false,
						Type:        "uint32",
					},
					&schema.MethodParam{
						Description: "(Optional) Tags that must be present on a published file to satisfy the query.",
						Name:        "requiredtags",
						Optional:    false,
						Type:        "string",
					},
					&schema.MethodParam{
						Description: "(Optional) Tags that must NOT be present on a published file to satisfy the query.",
						Name:        "excludedtags",
						Optional:    false,
						Type:        "string",
					},
					&schema.MethodParam{
						Description: "Required key-value tags to match on.",
						Name:        "required_kv_tags",
						Optional:    false,
						Type:        "{message}",
					},
					&schema.MethodParam{
						Description: "(Optional) File type to match files to.",
						Name:        "filetype",
						Optional:    false,
						Type:        "uint32",
					},
					&schema.MethodParam{
						Description: "App Id of the app that published the files, only matched if specified.",
						Name:        "creator_appid",
						Optional:    false,
						Type:        "uint32",
					},
					&schema.MethodParam{
						Description: "Match this cloud filename if specified.",
						Name:        "match_cloud_filename",
						Optional:    false,
						Type:        "string",
					},
					&schema.MethodParam{
						Description: "Allow stale data to be returned for the specified number of seconds.",
						Name:        "cache_max_age_seconds",
						Optional:    true,
						Type:        "uint32",
					},
					&schema.MethodParam{
						Description: "Specifies the localized text to return. Defaults to English.",
						Name:        "language",
						Optional:    true,
						Type:        "int32",
					},
					&schema.MethodParam{
						Description: "(Optional) At least one of the tags must be present on a published file to satisfy the query.",
						Name:        "taggroups",
						Optional:    false,
						Type:        "{message}",
					},
					&schema.MethodParam{
						Description: "(Optional) If true, only return the total number of files that satisfy this query.",
						Name:        "totalonly",
						Optional:    false,
						Type:        "bool",
					},
					&schema.MethodParam{
						Description: "(Optional) If true, only return the published file ids of files that satisfy this query.",
						Name:        "ids_only",
						Optional:    false,
						Type:        "bool",
					},
					&schema.MethodParam{
						Description: "Return vote data",
						Name:        "return_vote_data",
						Optional:    true,
						Type:        "bool",
					},
					&schema.MethodParam{
						Description: "Return tags in the file details",
						Name:        "return_tags",
						Optional:    false,
						Type:        "bool",
					},
					&schema.MethodParam{
						Description: "Return key-value tags in the file details",
						Name:        "return_kv_tags",
						Optional:    true,
						Type:        "bool",
					},
					&schema.MethodParam{
						Description: "Return preview image and video details in the file details",
						Name:        "return_previews",
						Optional:    false,
						Type:        "bool",
					},
					&schema.MethodParam{
						Description: "Return child item ids in the file details",
						Name:        "return_children",
						Optional:    false,
						Type:        "bool",
					},
					&schema.MethodParam{
						Description: "Populate the short_description field instead of file_description",
						Name:        "return_short_description",
						Optional:    true,
						Type:        "bool",
					},
					&schema.MethodParam{
						Description: "Return pricing information, if applicable",
						Name:        "return_for_sale_data",
						Optional:    false,
						Type:        "bool",
					},
					&schema.MethodParam{
						Description: "Populate the metadata field",
						Name:        "return_metadata",
						Optional:    true,
						Type:        "bool",
					},
					&schema.MethodParam{
						Description: "Return playtime stats for the specified number of days before today.",
						Name:        "return_playtime_stats",
						Optional:    false,
						Type:        "uint32",
					},
					&schema.MethodParam{
						Description: "Strips BBCode from descriptions.",
						Name:        "strip_description_bbcode",
						Optional:    false,
						Type:        "bool",
					},
					&schema.MethodParam{
						Description: "Return the data for the specified revision.",
						Name:        "desired_revision",
						Optional:    true,
						Type:        "{enum}",
					},
				),
				Undocumented: false,
				Version:      1,
			},
			&schema.Method{
				HTTPMethod:   http.MethodGet,
				Name:         "Subscribe",
				Params:       schema.NewMethodParams(),
				Undocumented: true,
				Version:      1,
			},
			&schema.Method{
				HTTPMethod:   http.MethodGet,
				Name:         "Unsubscribe",
				Params:       schema.NewMethodParams(),
				Undocumented: true,
				Version:      1,
			},
			&schema.Method{
				HTTPMethod:   http.MethodGet,
				Name:         "CanSubscribe",
				Params:       schema.NewMethodParams(),
				Undocumented: true,
				Version:      1,
			},
			&schema.Method{
				HTTPMethod:   http.MethodGet,
				Name:         "Publish",
				Params:       schema.NewMethodParams(),
				Undocumented: true,
				Version:      1,
			},
			&schema.Method{
				HTTPMethod:   http.MethodGet,
				Name:         "Update",
				Params:       schema.NewMethodParams(),
				Undocumented: true,
				Version:      1,
			},
			&schema.Method{
				HTTPMethod:   http.MethodGet,
				Name:         "RefreshVotingQueue",
				Params:       schema.NewMethodParams(),
				Undocumented: true,
				Version:      1,
			},
			&schema.Method{
				HTTPMethod:   http.MethodGet,
				Name:         "SetDeveloperMetadata",
				Params:       schema.NewMethodParams(),
				Undocumented: true,
				Version:      1,
			},
			&schema.Method{
				HTTPMethod:   http.MethodGet,
				Name:         "UpdateTags",
				Params:       schema.NewMethodParams(),
				Undocumented: true,
				Version:      1,
			},
		),
		Name:         "IPublishedFileService",
		Undocumented: false,
	},
)

var SchemaIQuestService = schema.MustNewInterfaces(
	&schema.Interface{
		Methods: schema.MustNewMethods(
			&schema.Method{
				HTTPMethod:   http.MethodGet,
				Name:         "GetCommunityItemDefinitions",
				Params:       schema.NewMethodParams(),
				Undocumented: true,
				Version:      1,
			},
		),
		Name:         "IQuestService",
		Undocumented: true,
	},
)

var SchemaIRemoteClientService = schema.MustNewInterfaces(
	&schema.Interface{
		Methods: schema.MustNewMethods(
			&schema.Method{
				HTTPMethod:   http.MethodGet,
				Name:         "NotifyRemotePacket",
				Params:       schema.NewMethodParams(),
				Undocumented: true,
				Version:      1,
			},
			&schema.Method{
				HTTPMethod:   http.MethodGet,
				Name:         "NotifyRegisterStatusUpdate",
				Params:       schema.NewMethodParams(),
				Undocumented: true,
				Version:      1,
			},
			&schema.Method{
				HTTPMethod:   http.MethodGet,
				Name:         "NotifyUnregisterStatusUpdate",
				Params:       schema.NewMethodParams(),
				Undocumented: true,
				Version:      1,
			},
		),
		Name:         "IRemoteClientService",
		Undocumented: true,
	},
)

var SchemaISteamApps = schema.MustNewInterfaces(
	&schema.Interface{
		Methods: schema.MustNewMethods(
			&schema.Method{
				HTTPMethod:   http.MethodGet,
				Name:         "GetAppList",
				Params:       schema.NewMethodParams(),
				Undocumented: false,
				Version:      1,
			},
			&schema.Method{
				HTTPMethod:   http.MethodGet,
				Name:         "GetAppList",
				Params:       schema.NewMethodParams(),
				Undocumented: false,
				Version:      2,
			},
			&schema.Method{
				HTTPMethod: http.MethodGet,
				Name:       "GetSDRConfig",
				Params: schema.NewMethodParams(
					&schema.MethodParam{
						Description: "AppID of game",
						Name:        "appid",
						Optional:    false,
						Type:        "uint32",
					},
					&schema.MethodParam{
						Description: "Partner type",
						Name:        "partner",
						Optional:    true,
						Type:        "string",
					},
				),
				Undocumented: false,
				Version:      1,
			},
			&schema.Method{
				HTTPMethod: http.MethodGet,
				Name:       "GetServersAtAddress",
				Params: schema.NewMethodParams(
					&schema.MethodParam{
						Description: "IP or IP:queryport to list",
						Name:        "addr",
						Optional:    false,
						Type:        "string",
					},
				),
				Undocumented: false,
				Version:      1,
			},
			&schema.Method{
				HTTPMethod: http.MethodGet,
				Name:       "UpToDateCheck",
				Params: schema.NewMethodParams(
					&schema.MethodParam{
						Description: "AppID of game",
						Name:        "appid",
						Optional:    false,
						Type:        "uint32",
					},
					&schema.MethodParam{
						Description: "The installed version of the game",
						Name:        "version",
						Optional:    false,
						Type:        "uint32",
					},
				),
				Undocumented: false,
				Version:      1,
			},
		),
		Name:         "ISteamApps",
		Undocumented: false,
	},
)

var SchemaISteamBitPay = schema.MustNewInterfaces(
	&schema.Interface{
		Methods: schema.MustNewMethods(
			&schema.Method{
				HTTPMethod:   http.MethodGet,
				Name:         "BitPayPaymentNotification",
				Params:       schema.NewMethodParams(),
				Undocumented: true,
				Version:      1,
			},
		),
		Name:         "ISteamBitPay",
		Undocumented: true,
	},
)

var SchemaISteamBoaCompra = schema.MustNewInterfaces(
	&schema.Interface{
		Methods: schema.MustNewMethods(
			&schema.Method{
				HTTPMethod:   http.MethodGet,
				Name:         "BoaCompraCheckTransactionStatus",
				Params:       schema.NewMethodParams(),
				Undocumented: true,
				Version:      1,
			},
		),
		Name:         "ISteamBoaCompra",
		Undocumented: true,
	},
)

var SchemaISteamBroadcast = schema.MustNewInterfaces(
	&schema.Interface{
		Methods: schema.MustNewMethods(
			&schema.Method{
				HTTPMethod: http.MethodGet,
				Name:       "ViewerHeartbeat",
				Params: schema.NewMethodParams(
					&schema.MethodParam{
						Description: "Steam ID of the broadcaster",
						Name:        "steamid",
						Optional:    false,
						Type:        "uint64",
					},
					&schema.MethodParam{
						Description: "Broadcast Session ID",
						Name:        "sessionid",
						Optional:    false,
						Type:        "uint64",
					},
					&schema.MethodParam{
						Description: "Viewer token",
						Name:        "token",
						Optional:    false,
						Type:        "uint64",
					},
					&schema.MethodParam{
						Description: "video stream representation watching",
						Name:        "stream",
						Optional:    true,
						Type:        "int32",
					},
				),
				Undocumented: false,
				Version:      1,
			},
		),
		Name:         "ISteamBroadcast",
		Undocumented: false,
	},
)

var SchemaISteamCDN = schema.MustNewInterfaces(
	&schema.Interface{
		Methods: schema.MustNewMethods(
			&schema.Method{
				HTTPMethod: http.MethodPost,
				Name:       "SetClientFilters",
				Params: schema.NewMethodParams(
					&schema.MethodParam{
						Description: "access key",
						Name:        "key",
						Optional:    false,
						Type:        "string",
					},
					&schema.MethodParam{
						Description: "Steam name of CDN property",
						Name:        "cdnname",
						Optional:    false,
						Type:        "string",
					},
					&schema.MethodParam{
						Description: "comma-separated list of allowed IP address blocks in CIDR format - blank for not used",
						Name:        "allowedipblocks",
						Optional:    true,
						Type:        "string",
					},
					&schema.MethodParam{
						Description: "comma-separated list of allowed client network AS numbers - blank for not used",
						Name:        "allowedasns",
						Optional:    true,
						Type:        "string",
					},
					&schema.MethodParam{
						Description: "comma-separated list of allowed client IP country codes in ISO 3166-1 format - blank for not used",
						Name:        "allowedipcountries",
						Optional:    true,
						Type:        "string",
					},
				),
				Undocumented: false,
				Version:      1,
			},
			&schema.Method{
				HTTPMethod: http.MethodPost,
				Name:       "SetPerformanceStats",
				Params: schema.NewMethodParams(
					&schema.MethodParam{
						Description: "access key",
						Name:        "key",
						Optional:    false,
						Type:        "string",
					},
					&schema.MethodParam{
						Description: "Steam name of CDN property",
						Name:        "cdnname",
						Optional:    false,
						Type:        "string",
					},
					&schema.MethodParam{
						Description: "Outgoing network traffic in Mbps",
						Name:        "mbps_sent",
						Optional:    true,
						Type:        "uint32",
					},
					&schema.MethodParam{
						Description: "Incoming network traffic in Mbps",
						Name:        "mbps_recv",
						Optional:    true,
						Type:        "uint32",
					},
					&schema.MethodParam{
						Description: "Percent CPU load",
						Name:        "cpu_percent",
						Optional:    true,
						Type:        "uint32",
					},
					&schema.MethodParam{
						Description: "Percent cache hits",
						Name:        "cache_hit_percent",
						Optional:    true,
						Type:        "uint32",
					},
				),
				Undocumented: false,
				Version:      1,
			},
		),
		Name:         "ISteamCDN",
		Undocumented: false,
	},
)

var SchemaISteamDirectory = schema.MustNewInterfaces(
	&schema.Interface{
		Methods: schema.MustNewMethods(
			&schema.Method{
				HTTPMethod: http.MethodGet,
				Name:       "GetCMList",
				Params: schema.NewMethodParams(
					&schema.MethodParam{
						Description: "Client's Steam cell ID",
						Name:        "cellid",
						Optional:    false,
						Type:        "uint32",
					},
					&schema.MethodParam{
						Description: "Max number of servers to return",
						Name:        "maxcount",
						Optional:    true,
						Type:        "uint32",
					},
				),
				Undocumented: false,
				Version:      1,
			},
			&schema.Method{
				HTTPMethod: http.MethodGet,
				Name:       "GetCSList",
				Params: schema.NewMethodParams(
					&schema.MethodParam{
						Description: "Client's Steam cell ID",
						Name:        "cellid",
						Optional:    false,
						Type:        "uint32",
					},
					&schema.MethodParam{
						Description: "Max number of servers to return",
						Name:        "maxcount",
						Optional:    true,
						Type:        "uint32",
					},
				),
				Undocumented: false,
				Version:      1,
			},
			&schema.Method{
				HTTPMethod:   http.MethodGet,
				Name:         "GetSteamPipeDomains",
				Params:       schema.NewMethodParams(),
				Undocumented: false,
				Version:      1,
			},
		),
		Name:         "ISteamDirectory",
		Undocumented: false,
	},
)

var SchemaISteamEconomy = schema.MustNewInterfaces(
	&schema.Interface{
		Methods: schema.MustNewMethods(
			&schema.Method{
				HTTPMethod: http.MethodGet,
				Name:       "GetAssetClassInfo",
				Params: schema.NewMethodParams(
					&schema.MethodParam{
						Description: "Must be a steam economy app.",
						Name:        "appid",
						Optional:    false,
						Type:        "uint32",
					},
					&schema.MethodParam{
						Description: "The user's local language",
						Name:        "language",
						Optional:    true,
						Type:        "string",
					},
					&schema.MethodParam{
						Description: "Number of classes requested. Must be at least one.",
						Name:        "class_count",
						Optional:    false,
						Type:        "uint32",
					},
					&schema.MethodParam{
						Description: "Class ID of the nth class.",
						Name:        "classid0",
						Optional:    false,
						Type:        "uint64",
					},
					&schema.MethodParam{
						Description: "Instance ID of the nth class.",
						Name:        "instanceid0",
						Optional:    true,
						Type:        "uint64",
					},
				),
				Undocumented: false,
				Version:      1,
			},
			&schema.Method{
				HTTPMethod: http.MethodGet,
				Name:       "GetAssetPrices",
				Params: schema.NewMethodParams(
					&schema.MethodParam{
						Description: "Must be a steam economy app.",
						Name:        "appid",
						Optional:    false,
						Type:        "uint32",
					},
					&schema.MethodParam{
						Description: "The currency to filter for",
						Name:        "currency",
						Optional:    true,
						Type:        "string",
					},
					&schema.MethodParam{
						Description: "The user's local language",
						Name:        "language",
						Optional:    true,
						Type:        "string",
					},
				),
				Undocumented: false,
				Version:      1,
			},
		),
		Name:         "ISteamEconomy",
		Undocumented: false,
	},
)

var SchemaISteamGameOAuth = schema.MustNewInterfaces(
	&schema.Interface{
		Methods: schema.MustNewMethods(
			&schema.Method{
				HTTPMethod:   http.MethodGet,
				Name:         "GetAppInfo",
				Params:       schema.NewMethodParams(),
				Undocumented: true,
				Version:      1,
			},
			&schema.Method{
				HTTPMethod:   http.MethodGet,
				Name:         "GetPackageInfo",
				Params:       schema.NewMethodParams(),
				Undocumented: true,
				Version:      1,
			},
		),
		Name:         "ISteamGameOAuth",
		Undocumented: true,
	},
)

var SchemaISteamNews = schema.MustNewInterfaces(
	&schema.Interface{
		Methods: schema.MustNewMethods(
			&schema.Method{
				HTTPMethod: http.MethodGet,
				Name:       "GetNewsForApp",
				Params: schema.NewMethodParams(
					&schema.MethodParam{
						Description: "AppID to retrieve news for",
						Name:        "appid",
						Optional:    false,
						Type:        "uint32",
					},
					&schema.MethodParam{
						Description: "Maximum length for the content to return, if this is 0 the full content is returned, if it's less then a blurb is generated to fit.",
						Name:        "maxlength",
						Optional:    true,
						Type:        "uint32",
					},
					&schema.MethodParam{
						Description: "Retrieve posts earlier than this date (unix epoch timestamp)",
						Name:        "enddate",
						Optional:    true,
						Type:        "uint32",
					},
					&schema.MethodParam{
						Description: "# of posts to retrieve (default 20)",
						Name:        "count",
						Optional:    true,
						Type:        "uint32",
					},
					&schema.MethodParam{
						Description: "Comma-separated list of tags to filter by (e.g. 'patchnodes')",
						Name:        "tags",
						Optional:    true,
						Type:        "string",
					},
				),
				Undocumented: false,
				Version:      1,
			},
			&schema.Method{
				HTTPMethod: http.MethodGet,
				Name:       "GetNewsForApp",
				Params: schema.NewMethodParams(
					&schema.MethodParam{
						Description: "AppID to retrieve news for",
						Name:        "appid",
						Optional:    false,
						Type:        "uint32",
					},
					&schema.MethodParam{
						Description: "Maximum length for the content to return, if this is 0 the full content is returned, if it's less then a blurb is generated to fit.",
						Name:        "maxlength",
						Optional:    true,
						Type:        "uint32",
					},
					&schema.MethodParam{
						Description: "Retrieve posts earlier than this date (unix epoch timestamp)",
						Name:        "enddate",
						Optional:    true,
						Type:        "uint32",
					},
					&schema.MethodParam{
						Description: "# of posts to retrieve (default 20)",
						Name:        "count",
						Optional:    true,
						Type:        "uint32",
					},
					&schema.MethodParam{
						Description: "Comma-separated list of feed names to return news for",
						Name:        "feeds",
						Optional:    true,
						Type:        "string",
					},
					&schema.MethodParam{
						Description: "Comma-separated list of tags to filter by (e.g. 'patchnodes')",
						Name:        "tags",
						Optional:    true,
						Type:        "string",
					},
				),
				Undocumented: false,
				Version:      2,
			},
		),
		Name:         "ISteamNews",
		Undocumented: false,
	},
)

var SchemaISteamNodwin = schema.MustNewInterfaces(
	&schema.Interface{
		Methods: schema.MustNewMethods(
			&schema.Method{
				HTTPMethod:   http.MethodGet,
				Name:         "NodwinPaymentNotification",
				Params:       schema.NewMethodParams(),
				Undocumented: true,
				Version:      1,
			},
		),
		Name:         "ISteamNodwin",
		Undocumented: true,
	},
)

var SchemaISteamPayPalPaymentsHub = schema.MustNewInterfaces(
	&schema.Interface{
		Methods: schema.MustNewMethods(
			&schema.Method{
				HTTPMethod:   http.MethodGet,
				Name:         "PayPalPaymentsHubPaymentNotification",
				Params:       schema.NewMethodParams(),
				Undocumented: true,
				Version:      1,
			},
		),
		Name:         "ISteamPayPalPaymentsHub",
		Undocumented: true,
	},
)

var SchemaISteamRemoteStorage = schema.MustNewInterfaces(
	&schema.Interface{
		Methods: schema.MustNewMethods(
			&schema.Method{
				HTTPMethod: http.MethodPost,
				Name:       "GetCollectionDetails",
				Params: schema.NewMethodParams(
					&schema.MethodParam{
						Description: "Number of collections being requested",
						Name:        "collectioncount",
						Optional:    false,
						Type:        "uint32",
					},
					&schema.MethodParam{
						Description: "collection ids to get the details for",
						Name:        "publishedfileids[0]",
						Optional:    false,
						Type:        "uint64",
					},
				),
				Undocumented: false,
				Version:      1,
			},
			&schema.Method{
				HTTPMethod: http.MethodPost,
				Name:       "GetPublishedFileDetails",
				Params: schema.NewMethodParams(
					&schema.MethodParam{
						Description: "Number of items being requested",
						Name:        "itemcount",
						Optional:    false,
						Type:        "uint32",
					},
					&schema.MethodParam{
						Description: "published file id to look up",
						Name:        "publishedfileids[0]",
						Optional:    false,
						Type:        "uint64",
					},
				),
				Undocumented: false,
				Version:      1,
			},
			&schema.Method{
				HTTPMethod: http.MethodGet,
				Name:       "GetUGCFileDetails",
				Params: schema.NewMethodParams(
					&schema.MethodParam{
						Description: "If specified, only returns details if the file is owned by the SteamID specified",
						Name:        "steamid",
						Optional:    true,
						Type:        "uint64",
					},
					&schema.MethodParam{
						Description: "ID of UGC file to get info for",
						Name:        "ugcid",
						Optional:    false,
						Type:        "uint64",
					},
					&schema.MethodParam{
						Description: "appID of product",
						Name:        "appid",
						Optional:    false,
						Type:        "uint32",
					},
				),
				Undocumented: false,
				Version:      1,
			},
		),
		Name:         "ISteamRemoteStorage",
		Undocumented: false,
	},
)

var SchemaISteamTVService = schema.MustNewInterfaces(
	&schema.Interface{
		Methods: schema.MustNewMethods(
			&schema.Method{
				HTTPMethod:   http.MethodGet,
				Name:         "CreateBroadcastChannel",
				Params:       schema.NewMethodParams(),
				Undocumented: true,
				Version:      1,
			},
			&schema.Method{
				HTTPMethod:   http.MethodGet,
				Name:         "GetBroadcastChannelID",
				Params:       schema.NewMethodParams(),
				Undocumented: true,
				Version:      1,
			},
			&schema.Method{
				HTTPMethod:   http.MethodGet,
				Name:         "SetBroadcastChannelProfile",
				Params:       schema.NewMethodParams(),
				Undocumented: true,
				Version:      1,
			},
			&schema.Method{
				HTTPMethod:   http.MethodGet,
				Name:         "GetBroadcastChannelProfile",
				Params:       schema.NewMethodParams(),
				Undocumented: true,
				Version:      1,
			},
			&schema.Method{
				HTTPMethod:   http.MethodGet,
				Name:         "SetBroadcastChannelImage",
				Params:       schema.NewMethodParams(),
				Undocumented: true,
				Version:      1,
			},
			&schema.Method{
				HTTPMethod:   http.MethodGet,
				Name:         "GetBroadcastChannelImages",
				Params:       schema.NewMethodParams(),
				Undocumented: true,
				Version:      1,
			},
			&schema.Method{
				HTTPMethod:   http.MethodGet,
				Name:         "SetBroadcastChannelLinkRegions",
				Params:       schema.NewMethodParams(),
				Undocumented: true,
				Version:      1,
			},
			&schema.Method{
				HTTPMethod:   http.MethodGet,
				Name:         "GetBroadcastChannelLinks",
				Params:       schema.NewMethodParams(),
				Undocumented: true,
				Version:      1,
			},
			&schema.Method{
				HTTPMethod:   http.MethodGet,
				Name:         "GetBroadcastChannelBroadcasters",
				Params:       schema.NewMethodParams(),
				Undocumented: true,
				Version:      1,
			},
			&schema.Method{
				HTTPMethod:   http.MethodGet,
				Name:         "GetFollowedChannels",
				Params:       schema.NewMethodParams(),
				Undocumented: true,
				Version:      1,
			},
			&schema.Method{
				HTTPMethod:   http.MethodGet,
				Name:         "GetSubscribedChannels",
				Params:       schema.NewMethodParams(),
				Undocumented: true,
				Version:      1,
			},
			&schema.Method{
				HTTPMethod:   http.MethodGet,
				Name:         "GetBroadcastChannelStatus",
				Params:       schema.NewMethodParams(),
				Undocumented: true,
				Version:      1,
			},
			&schema.Method{
				HTTPMethod:   http.MethodGet,
				Name:         "FollowBroadcastChannel",
				Params:       schema.NewMethodParams(),
				Undocumented: true,
				Version:      1,
			},
			&schema.Method{
				HTTPMethod:   http.MethodGet,
				Name:         "SubscribeBroadcastChannel",
				Params:       schema.NewMethodParams(),
				Undocumented: true,
				Version:      1,
			},
			&schema.Method{
				HTTPMethod:   http.MethodGet,
				Name:         "ReportBroadcastChannel",
				Params:       schema.NewMethodParams(),
				Undocumented: true,
				Version:      1,
			},
			&schema.Method{
				HTTPMethod:   http.MethodGet,
				Name:         "GetBroadcastChannelInteraction",
				Params:       schema.NewMethodParams(),
				Undocumented: true,
				Version:      1,
			},
			&schema.Method{
				HTTPMethod:   http.MethodGet,
				Name:         "GetGames",
				Params:       schema.NewMethodParams(),
				Undocumented: true,
				Version:      1,
			},
			&schema.Method{
				HTTPMethod:   http.MethodGet,
				Name:         "GetFeatured",
				Params:       schema.NewMethodParams(),
				Undocumented: true,
				Version:      1,
			},
			&schema.Method{
				HTTPMethod:   http.MethodGet,
				Name:         "AddChatBan",
				Params:       schema.NewMethodParams(),
				Undocumented: true,
				Version:      1,
			},
			&schema.Method{
				HTTPMethod:   http.MethodGet,
				Name:         "GetChatBans",
				Params:       schema.NewMethodParams(),
				Undocumented: true,
				Version:      1,
			},
			&schema.Method{
				HTTPMethod:   http.MethodGet,
				Name:         "AddChatModerator",
				Params:       schema.NewMethodParams(),
				Undocumented: true,
				Version:      1,
			},
			&schema.Method{
				HTTPMethod:   http.MethodGet,
				Name:         "GetChatModerators",
				Params:       schema.NewMethodParams(),
				Undocumented: true,
				Version:      1,
			},
			&schema.Method{
				HTTPMethod:   http.MethodGet,
				Name:         "AddWordBan",
				Params:       schema.NewMethodParams(),
				Undocumented: true,
				Version:      1,
			},
			&schema.Method{
				HTTPMethod:   http.MethodGet,
				Name:         "GetWordBans",
				Params:       schema.NewMethodParams(),
				Undocumented: true,
				Version:      1,
			},
			&schema.Method{
				HTTPMethod:   http.MethodGet,
				Name:         "JoinChat",
				Params:       schema.NewMethodParams(),
				Undocumented: true,
				Version:      1,
			},
			&schema.Method{
				HTTPMethod:   http.MethodGet,
				Name:         "Search",
				Params:       schema.NewMethodParams(),
				Undocumented: true,
				Version:      1,
			},
			&schema.Method{
				HTTPMethod:   http.MethodGet,
				Name:         "GetSteamTVUserSettings",
				Params:       schema.NewMethodParams(),
				Undocumented: true,
				Version:      1,
			},
			&schema.Method{
				HTTPMethod:   http.MethodGet,
				Name:         "SetSteamTVUserSettings",
				Params:       schema.NewMethodParams(),
				Undocumented: true,
				Version:      1,
			},
			&schema.Method{
				HTTPMethod:   http.MethodGet,
				Name:         "GetMyBroadcastChannels",
				Params:       schema.NewMethodParams(),
				Undocumented: true,
				Version:      1,
			},
			&schema.Method{
				HTTPMethod:   http.MethodGet,
				Name:         "GetBroadcastChannelClips",
				Params:       schema.NewMethodParams(),
				Undocumented: true,
				Version:      1,
			},
			&schema.Method{
				HTTPMethod:   http.MethodGet,
				Name:         "GetChannels",
				Params:       schema.NewMethodParams(),
				Undocumented: true,
				Version:      1,
			},
			&schema.Method{
				HTTPMethod:   http.MethodGet,
				Name:         "GetHomePageContents",
				Params:       schema.NewMethodParams(),
				Undocumented: true,
				Version:      1,
			},
		),
		Name:         "ISteamTVService",
		Undocumented: true,
	},
)

var SchemaISteamUser = schema.MustNewInterfaces(
	&schema.Interface{
		Methods: schema.MustNewMethods(
			&schema.Method{
				HTTPMethod: http.MethodGet,
				Name:       "GetFriendList",
				Params: schema.NewMethodParams(
					&schema.MethodParam{
						Description: "access key",
						Name:        "key",
						Optional:    false,
						Type:        "string",
					},
					&schema.MethodParam{
						Description: "SteamID of user",
						Name:        "steamid",
						Optional:    false,
						Type:        "uint64",
					},
					&schema.MethodParam{
						Description: "relationship type (ex: friend)",
						Name:        "relationship",
						Optional:    true,
						Type:        "string",
					},
				),
				Undocumented: false,
				Version:      1,
			},
			&schema.Method{
				HTTPMethod: http.MethodGet,
				Name:       "GetPlayerBans",
				Params: schema.NewMethodParams(
					&schema.MethodParam{
						Description: "access key",
						Name:        "key",
						Optional:    false,
						Type:        "string",
					},
					&schema.MethodParam{
						Description: "Comma-delimited list of SteamIDs",
						Name:        "steamids",
						Optional:    false,
						Type:        "string",
					},
				),
				Undocumented: false,
				Version:      1,
			},
			&schema.Method{
				HTTPMethod: http.MethodGet,
				Name:       "GetPlayerSummaries",
				Params: schema.NewMethodParams(
					&schema.MethodParam{
						Description: "access key",
						Name:        "key",
						Optional:    false,
						Type:        "string",
					},
					&schema.MethodParam{
						Description: "Comma-delimited list of SteamIDs",
						Name:        "steamids",
						Optional:    false,
						Type:        "string",
					},
				),
				Undocumented: false,
				Version:      1,
			},
			&schema.Method{
				HTTPMethod: http.MethodGet,
				Name:       "GetPlayerSummaries",
				Params: schema.NewMethodParams(
					&schema.MethodParam{
						Description: "access key",
						Name:        "key",
						Optional:    false,
						Type:        "string",
					},
					&schema.MethodParam{
						Description: "Comma-delimited list of SteamIDs (max: 100)",
						Name:        "steamids",
						Optional:    false,
						Type:        "string",
					},
				),
				Undocumented: false,
				Version:      2,
			},
			&schema.Method{
				HTTPMethod: http.MethodGet,
				Name:       "GetUserGroupList",
				Params: schema.NewMethodParams(
					&schema.MethodParam{
						Description: "access key",
						Name:        "key",
						Optional:    false,
						Type:        "string",
					},
					&schema.MethodParam{
						Description: "SteamID of user",
						Name:        "steamid",
						Optional:    false,
						Type:        "uint64",
					},
				),
				Undocumented: false,
				Version:      1,
			},
			&schema.Method{
				HTTPMethod: http.MethodGet,
				Name:       "ResolveVanityURL",
				Params: schema.NewMethodParams(
					&schema.MethodParam{
						Description: "access key",
						Name:        "key",
						Optional:    false,
						Type:        "string",
					},
					&schema.MethodParam{
						Description: "The vanity URL to get a SteamID for",
						Name:        "vanityurl",
						Optional:    false,
						Type:        "string",
					},
					&schema.MethodParam{
						Description: "The type of vanity URL. 1 (default): Individual profile, 2: Group, 3: Official game group",
						Name:        "url_type",
						Optional:    true,
						Type:        "int32",
					},
				),
				Undocumented: false,
				Version:      1,
			},
		),
		Name:         "ISteamUser",
		Undocumented: false,
	},
)

var SchemaISteamUserAuth = schema.MustNewInterfaces(
	&schema.Interface{
		Methods: schema.MustNewMethods(
			&schema.Method{
				HTTPMethod: http.MethodPost,
				Name:       "AuthenticateUser",
				Params: schema.NewMethodParams(
					&schema.MethodParam{
						Description: "Should be the users steamid, unencrypted.",
						Name:        "steamid",
						Optional:    false,
						Type:        "uint64",
					},
					&schema.MethodParam{
						Description: "Should be a 32 byte random blob of data, which is then encrypted with RSA using the Steam system's public key.  Randomness is important here for security.",
						Name:        "sessionkey",
						Optional:    false,
						Type:        "rawbinary",
					},
					&schema.MethodParam{
						Description: "Should be the users hashed loginkey, AES encrypted with the sessionkey.",
						Name:        "encrypted_loginkey",
						Optional:    false,
						Type:        "rawbinary",
					},
				),
				Undocumented: false,
				Version:      1,
			},
			&schema.Method{
				HTTPMethod: http.MethodGet,
				Name:       "AuthenticateUserTicket",
				Params: schema.NewMethodParams(
					&schema.MethodParam{
						Description: "access key",
						Name:        "key",
						Optional:    false,
						Type:        "string",
					},
					&schema.MethodParam{
						Description: "appid of game",
						Name:        "appid",
						Optional:    false,
						Type:        "uint32",
					},
					&schema.MethodParam{
						Description: "Ticket from GetAuthSessionTicket.",
						Name:        "ticket",
						Optional:    false,
						Type:        "string",
					},
				),
				Undocumented: false,
				Version:      1,
			},
		),
		Name:         "ISteamUserAuth",
		Undocumented: false,
	},
)

var SchemaISteamUserOAuth = schema.MustNewInterfaces(
	&schema.Interface{
		Methods: schema.MustNewMethods(
			&schema.Method{
				HTTPMethod: http.MethodGet,
				Name:       "GetTokenDetails",
				Params: schema.NewMethodParams(
					&schema.MethodParam{
						Description: "OAuth2 token for which to return details",
						Name:        "access_token",
						Optional:    false,
						Type:        "string",
					},
				),
				Undocumented: false,
				Version:      1,
			},
			&schema.Method{
				HTTPMethod:   http.MethodGet,
				Name:         "GetUserSummaries",
				Params:       schema.NewMethodParams(),
				Undocumented: true,
				Version:      1,
			},
			&schema.Method{
				HTTPMethod:   http.MethodGet,
				Name:         "GetGroupSummaries",
				Params:       schema.NewMethodParams(),
				Undocumented: true,
				Version:      1,
			},
			&schema.Method{
				HTTPMethod:   http.MethodGet,
				Name:         "GetGroupList",
				Params:       schema.NewMethodParams(),
				Undocumented: true,
				Version:      1,
			},
			&schema.Method{
				HTTPMethod:   http.MethodGet,
				Name:         "GetFriendList",
				Params:       schema.NewMethodParams(),
				Undocumented: true,
				Version:      1,
			},
			&schema.Method{
				HTTPMethod:   http.MethodGet,
				Name:         "Search",
				Params:       schema.NewMethodParams(),
				Undocumented: true,
				Version:      1,
			},
		),
		Name:         "ISteamUserOAuth",
		Undocumented: false,
	},
)

var SchemaISteamUserStats = schema.MustNewInterfaces(
	&schema.Interface{
		Methods: schema.MustNewMethods(
			&schema.Method{
				HTTPMethod: http.MethodGet,
				Name:       "GetGlobalAchievementPercentagesForApp",
				Params: schema.NewMethodParams(
					&schema.MethodParam{
						Description: "GameID to retrieve the achievement percentages for",
						Name:        "gameid",
						Optional:    false,
						Type:        "uint64",
					},
				),
				Undocumented: false,
				Version:      1,
			},
			&schema.Method{
				HTTPMethod: http.MethodGet,
				Name:       "GetGlobalAchievementPercentagesForApp",
				Params: schema.NewMethodParams(
					&schema.MethodParam{
						Description: "GameID to retrieve the achievement percentages for",
						Name:        "gameid",
						Optional:    false,
						Type:        "uint64",
					},
				),
				Undocumented: false,
				Version:      2,
			},
			&schema.Method{
				HTTPMethod: http.MethodGet,
				Name:       "GetGlobalStatsForGame",
				Params: schema.NewMethodParams(
					&schema.MethodParam{
						Description: "AppID that we're getting global stats for",
						Name:        "appid",
						Optional:    false,
						Type:        "uint32",
					},
					&schema.MethodParam{
						Description: "Number of stats get data for",
						Name:        "count",
						Optional:    false,
						Type:        "uint32",
					},
					&schema.MethodParam{
						Description: "Names of stat to get data for",
						Name:        "name[0]",
						Optional:    false,
						Type:        "string",
					},
					&schema.MethodParam{
						Description: "Start date for daily totals (unix epoch timestamp)",
						Name:        "startdate",
						Optional:    true,
						Type:        "uint32",
					},
					&schema.MethodParam{
						Description: "End date for daily totals (unix epoch timestamp)",
						Name:        "enddate",
						Optional:    true,
						Type:        "uint32",
					},
				),
				Undocumented: false,
				Version:      1,
			},
			&schema.Method{
				HTTPMethod: http.MethodGet,
				Name:       "GetNumberOfCurrentPlayers",
				Params: schema.NewMethodParams(
					&schema.MethodParam{
						Description: "AppID that we're getting user count for",
						Name:        "appid",
						Optional:    false,
						Type:        "uint32",
					},
				),
				Undocumented: false,
				Version:      1,
			},
			&schema.Method{
				HTTPMethod: http.MethodGet,
				Name:       "GetPlayerAchievements",
				Params: schema.NewMethodParams(
					&schema.MethodParam{
						Description: "access key",
						Name:        "key",
						Optional:    false,
						Type:        "string",
					},
					&schema.MethodParam{
						Description: "SteamID of user",
						Name:        "steamid",
						Optional:    false,
						Type:        "uint64",
					},
					&schema.MethodParam{
						Description: "AppID to get achievements for",
						Name:        "appid",
						Optional:    false,
						Type:        "uint32",
					},
					&schema.MethodParam{
						Description: "Language to return strings for",
						Name:        "l",
						Optional:    true,
						Type:        "string",
					},
				),
				Undocumented: false,
				Version:      1,
			},
			&schema.Method{
				HTTPMethod: http.MethodGet,
				Name:       "GetSchemaForGame",
				Params: schema.NewMethodParams(
					&schema.MethodParam{
						Description: "access key",
						Name:        "key",
						Optional:    false,
						Type:        "string",
					},
					&schema.MethodParam{
						Description: "appid of game",
						Name:        "appid",
						Optional:    false,
						Type:        "uint32",
					},
					&schema.MethodParam{
						Description: "localized langauge to return (english, french, etc.)",
						Name:        "l",
						Optional:    true,
						Type:        "string",
					},
				),
				Undocumented: false,
				Version:      1,
			},
			&schema.Method{
				HTTPMethod: http.MethodGet,
				Name:       "GetSchemaForGame",
				Params: schema.NewMethodParams(
					&schema.MethodParam{
						Description: "access key",
						Name:        "key",
						Optional:    false,
						Type:        "string",
					},
					&schema.MethodParam{
						Description: "appid of game",
						Name:        "appid",
						Optional:    false,
						Type:        "uint32",
					},
					&schema.MethodParam{
						Description: "localized language to return (english, french, etc.)",
						Name:        "l",
						Optional:    true,
						Type:        "string",
					},
				),
				Undocumented: false,
				Version:      2,
			},
			&schema.Method{
				HTTPMethod: http.MethodGet,
				Name:       "GetUserStatsForGame",
				Params: schema.NewMethodParams(
					&schema.MethodParam{
						Description: "access key",
						Name:        "key",
						Optional:    false,
						Type:        "string",
					},
					&schema.MethodParam{
						Description: "SteamID of user",
						Name:        "steamid",
						Optional:    false,
						Type:        "uint64",
					},
					&schema.MethodParam{
						Description: "appid of game",
						Name:        "appid",
						Optional:    false,
						Type:        "uint32",
					},
				),
				Undocumented: false,
				Version:      1,
			},
			&schema.Method{
				HTTPMethod: http.MethodGet,
				Name:       "GetUserStatsForGame",
				Params: schema.NewMethodParams(
					&schema.MethodParam{
						Description: "access key",
						Name:        "key",
						Optional:    false,
						Type:        "string",
					},
					&schema.MethodParam{
						Description: "SteamID of user",
						Name:        "steamid",
						Optional:    false,
						Type:        "uint64",
					},
					&schema.MethodParam{
						Description: "appid of game",
						Name:        "appid",
						Optional:    false,
						Type:        "uint32",
					},
				),
				Undocumented: false,
				Version:      2,
			},
		),
		Name:         "ISteamUserStats",
		Undocumented: false,
	},
)

var SchemaISteamWebAPIUtil = schema.MustNewInterfaces(
	&schema.Interface{
		Methods: schema.MustNewMethods(
			&schema.Method{
				HTTPMethod:   http.MethodGet,
				Name:         "GetServerInfo",
				Params:       schema.NewMethodParams(),
				Undocumented: false,
				Version:      1,
			},
			&schema.Method{
				HTTPMethod: http.MethodGet,
				Name:       "GetSupportedAPIList",
				Params: schema.NewMethodParams(
					&schema.MethodParam{
						Description: "access key",
						Name:        "key",
						Optional:    true,
						Type:        "string",
					},
				),
				Undocumented: false,
				Version:      1,
			},
		),
		Name:         "ISteamWebAPIUtil",
		Undocumented: false,
	},
)

var SchemaISteamWebUserPresenceOAuth = schema.MustNewInterfaces(
	&schema.Interface{
		Methods: schema.MustNewMethods(
			&schema.Method{
				HTTPMethod: http.MethodPost,
				Name:       "PollStatus",
				Params: schema.NewMethodParams(
					&schema.MethodParam{
						Description: "Steam ID of the user",
						Name:        "steamid",
						Optional:    false,
						Type:        "string",
					},
					&schema.MethodParam{
						Description: "UMQ Session ID",
						Name:        "umqid",
						Optional:    false,
						Type:        "uint64",
					},
					&schema.MethodParam{
						Description: "Message that was last known to the user",
						Name:        "message",
						Optional:    false,
						Type:        "uint32",
					},
					&schema.MethodParam{
						Description: "Caller-specific poll id",
						Name:        "pollid",
						Optional:    true,
						Type:        "uint32",
					},
					&schema.MethodParam{
						Description: "Long-poll timeout in seconds",
						Name:        "sectimeout",
						Optional:    true,
						Type:        "uint32",
					},
					&schema.MethodParam{
						Description: "How many seconds is client considering itself idle, e.g. screen is off",
						Name:        "secidletime",
						Optional:    true,
						Type:        "uint32",
					},
					&schema.MethodParam{
						Description: "Boolean, 0 (default): return steamid_from in output, 1: return accountid_from",
						Name:        "use_accountids",
						Optional:    true,
						Type:        "uint32",
					},
				),
				Undocumented: false,
				Version:      1,
			},
			&schema.Method{
				HTTPMethod:   http.MethodGet,
				Name:         "Logon",
				Params:       schema.NewMethodParams(),
				Undocumented: true,
				Version:      1,
			},
			&schema.Method{
				HTTPMethod:   http.MethodGet,
				Name:         "Logoff",
				Params:       schema.NewMethodParams(),
				Undocumented: true,
				Version:      1,
			},
			&schema.Method{
				HTTPMethod:   http.MethodGet,
				Name:         "Message",
				Params:       schema.NewMethodParams(),
				Undocumented: true,
				Version:      1,
			},
			&schema.Method{
				HTTPMethod:   http.MethodGet,
				Name:         "DeviceInfo",
				Params:       schema.NewMethodParams(),
				Undocumented: true,
				Version:      1,
			},
			&schema.Method{
				HTTPMethod:   http.MethodGet,
				Name:         "Poll",
				Params:       schema.NewMethodParams(),
				Undocumented: true,
				Version:      1,
			},
		),
		Name:         "ISteamWebUserPresenceOAuth",
		Undocumented: false,
	},
)

var SchemaIStoreService = schema.MustNewInterfaces(
	&schema.Interface{
		Methods: schema.MustNewMethods(
			&schema.Method{
				HTTPMethod: http.MethodGet,
				Name:       "GetAppList",
				Params: schema.NewMethodParams(
					&schema.MethodParam{
						Description: "Access key",
						Name:        "key",
						Optional:    false,
						Type:        "string",
					},
					&schema.MethodParam{
						Description: "Return only items that have been modified since this date.",
						Name:        "if_modified_since",
						Optional:    true,
						Type:        "uint32",
					},
					&schema.MethodParam{
						Description: "Return only items that have a description in this language.",
						Name:        "have_description_language",
						Optional:    true,
						Type:        "string",
					},
					&schema.MethodParam{
						Description: "Include games (defaults to enabled)",
						Name:        "include_games",
						Optional:    true,
						Type:        "bool",
					},
					&schema.MethodParam{
						Description: "Include DLC",
						Name:        "include_dlc",
						Optional:    true,
						Type:        "bool",
					},
					&schema.MethodParam{
						Description: "Include software items",
						Name:        "include_software",
						Optional:    true,
						Type:        "bool",
					},
					&schema.MethodParam{
						Description: "Include videos and series",
						Name:        "include_videos",
						Optional:    true,
						Type:        "bool",
					},
					&schema.MethodParam{
						Description: "Include hardware",
						Name:        "include_hardware",
						Optional:    true,
						Type:        "bool",
					},
					&schema.MethodParam{
						Description: "For continuations, this is the last appid returned from the previous call.",
						Name:        "last_appid",
						Optional:    true,
						Type:        "uint32",
					},
					&schema.MethodParam{
						Description: "Number of results to return at a time.  Default 10k, max 50k.",
						Name:        "max_results",
						Optional:    true,
						Type:        "uint32",
					},
				),
				Undocumented: false,
				Version:      1,
			},
		),
		Name:         "IStoreService",
		Undocumented: false,
	},
)

var SchemaITFItems = schema.MustNewInterfaces(
	&schema.Interface{
		Methods: schema.MustNewMethods(
			&schema.Method{
				HTTPMethod:   http.MethodGet,
				Name:         "GetGoldenWrenches",
				Params:       schema.NewMethodParams(),
				Undocumented: false,
				Version:      1,
			},
			&schema.Method{
				HTTPMethod:   http.MethodGet,
				Name:         "GetGoldenWrenches",
				Params:       schema.NewMethodParams(),
				Undocumented: false,
				Version:      2,
			},
		),
		Name:         "ITFItems_440",
		Undocumented: false,
	},
)

var SchemaITFPromos = schema.MustNewInterfaces(
	&schema.Interface{
		Methods: schema.MustNewMethods(
			&schema.Method{
				HTTPMethod: http.MethodGet,
				Name:       "GetItemID",
				Params: schema.NewMethodParams(
					&schema.MethodParam{
						Description: "The Steam ID to fetch items for",
						Name:        "steamid",
						Optional:    false,
						Type:        "uint64",
					},
					&schema.MethodParam{
						Description: "The promo ID to grant an item for",
						Name:        "promoid",
						Optional:    false,
						Type:        "uint32",
					},
				),
				Undocumented: false,
				Version:      1,
			},
			&schema.Method{
				HTTPMethod: http.MethodPost,
				Name:       "GrantItem",
				Params: schema.NewMethodParams(
					&schema.MethodParam{
						Description: "The Steam ID to fetch items for",
						Name:        "steamid",
						Optional:    false,
						Type:        "uint64",
					},
					&schema.MethodParam{
						Description: "The promo ID to grant an item for",
						Name:        "promoid",
						Optional:    false,
						Type:        "uint32",
					},
				),
				Undocumented: false,
				Version:      1,
			},
		),
		Name:         "ITFPromos_440",
		Undocumented: false,
	},
	&schema.Interface{
		Methods: schema.MustNewMethods(
			&schema.Method{
				HTTPMethod: http.MethodGet,
				Name:       "GetItemID",
				Params: schema.NewMethodParams(
					&schema.MethodParam{
						Description: "The Steam ID to fetch items for",
						Name:        "steamid",
						Optional:    false,
						Type:        "uint64",
					},
					&schema.MethodParam{
						Description: "The promo ID to grant an item for",
						Name:        "promoid",
						Optional:    false,
						Type:        "uint32",
					},
				),
				Undocumented: false,
				Version:      1,
			},
			&schema.Method{
				HTTPMethod: http.MethodPost,
				Name:       "GrantItem",
				Params: schema.NewMethodParams(
					&schema.MethodParam{
						Description: "The Steam ID to fetch items for",
						Name:        "steamid",
						Optional:    false,
						Type:        "uint64",
					},
					&schema.MethodParam{
						Description: "The promo ID to grant an item for",
						Name:        "promoid",
						Optional:    false,
						Type:        "uint32",
					},
				),
				Undocumented: false,
				Version:      1,
			},
		),
		Name:         "ITFPromos_570",
		Undocumented: false,
	},
	&schema.Interface{
		Methods: schema.MustNewMethods(
			&schema.Method{
				HTTPMethod: http.MethodGet,
				Name:       "GetItemID",
				Params: schema.NewMethodParams(
					&schema.MethodParam{
						Description: "The Steam ID to fetch items for",
						Name:        "steamid",
						Optional:    false,
						Type:        "uint64",
					},
					&schema.MethodParam{
						Description: "The promo ID to grant an item for",
						Name:        "PromoID",
						Optional:    false,
						Type:        "uint32",
					},
				),
				Undocumented: false,
				Version:      1,
			},
			&schema.Method{
				HTTPMethod: http.MethodPost,
				Name:       "GrantItem",
				Params: schema.NewMethodParams(
					&schema.MethodParam{
						Description: "The Steam ID to fetch items for",
						Name:        "steamid",
						Optional:    false,
						Type:        "uint64",
					},
					&schema.MethodParam{
						Description: "The promo ID to grant an item for",
						Name:        "PromoID",
						Optional:    false,
						Type:        "uint32",
					},
				),
				Undocumented: false,
				Version:      1,
			},
		),
		Name:         "ITFPromos_620",
		Undocumented: false,
	},
	&schema.Interface{
		Methods: schema.MustNewMethods(
			&schema.Method{
				HTTPMethod: http.MethodGet,
				Name:       "GetItemID",
				Params: schema.NewMethodParams(
					&schema.MethodParam{
						Description: "The Steam ID to fetch items for",
						Name:        "steamid",
						Optional:    false,
						Type:        "uint64",
					},
					&schema.MethodParam{
						Description: "The promo ID to grant an item for",
						Name:        "promoid",
						Optional:    false,
						Type:        "uint32",
					},
				),
				Undocumented: false,
				Version:      1,
			},
			&schema.Method{
				HTTPMethod: http.MethodPost,
				Name:       "GrantItem",
				Params: schema.NewMethodParams(
					&schema.MethodParam{
						Description: "The Steam ID to fetch items for",
						Name:        "steamid",
						Optional:    false,
						Type:        "uint64",
					},
					&schema.MethodParam{
						Description: "The promo ID to grant an item for",
						Name:        "promoid",
						Optional:    false,
						Type:        "uint32",
					},
				),
				Undocumented: false,
				Version:      1,
			},
		),
		Name:         "ITFPromos_205790",
		Undocumented: false,
	},
)

var SchemaITFSystem = schema.MustNewInterfaces(
	&schema.Interface{
		Methods: schema.MustNewMethods(
			&schema.Method{
				HTTPMethod:   http.MethodGet,
				Name:         "GetWorldStatus",
				Params:       schema.NewMethodParams(),
				Undocumented: false,
				Version:      1,
			},
		),
		Name:         "ITFSystem_440",
		Undocumented: false,
	},
)

var SchemaITwoFactorService = schema.MustNewInterfaces(
	&schema.Interface{
		Methods: schema.MustNewMethods(
			&schema.Method{
				HTTPMethod:   http.MethodGet,
				Name:         "AddAuthenticator",
				Params:       schema.NewMethodParams(),
				Undocumented: true,
				Version:      1,
			},
			&schema.Method{
				HTTPMethod:   http.MethodGet,
				Name:         "RecoverAuthenticatorCommit",
				Params:       schema.NewMethodParams(),
				Undocumented: true,
				Version:      1,
			},
			&schema.Method{
				HTTPMethod:   http.MethodGet,
				Name:         "RecoverAuthenticatorContinue",
				Params:       schema.NewMethodParams(),
				Undocumented: true,
				Version:      1,
			},
			&schema.Method{
				HTTPMethod:   http.MethodGet,
				Name:         "RemoveAuthenticator",
				Params:       schema.NewMethodParams(),
				Undocumented: true,
				Version:      1,
			},
			&schema.Method{
				HTTPMethod:   http.MethodGet,
				Name:         "RemoveAuthenticatorViaChallengeStart",
				Params:       schema.NewMethodParams(),
				Undocumented: true,
				Version:      1,
			},
			&schema.Method{
				HTTPMethod:   http.MethodGet,
				Name:         "RemoveAuthenticatorViaChallengeContinue",
				Params:       schema.NewMethodParams(),
				Undocumented: true,
				Version:      1,
			},
			&schema.Method{
				HTTPMethod:   http.MethodGet,
				Name:         "FinalizeAddAuthenticator",
				Params:       schema.NewMethodParams(),
				Undocumented: true,
				Version:      1,
			},
			&schema.Method{
				HTTPMethod:   http.MethodGet,
				Name:         "QueryStatus",
				Params:       schema.NewMethodParams(),
				Undocumented: true,
				Version:      1,
			},
			&schema.Method{
				HTTPMethod:   http.MethodGet,
				Name:         "QueryTime",
				Params:       schema.NewMethodParams(),
				Undocumented: true,
				Version:      1,
			},
			&schema.Method{
				HTTPMethod:   http.MethodGet,
				Name:         "QuerySecrets",
				Params:       schema.NewMethodParams(),
				Undocumented: true,
				Version:      1,
			},
			&schema.Method{
				HTTPMethod:   http.MethodGet,
				Name:         "SendEmail",
				Params:       schema.NewMethodParams(),
				Undocumented: true,
				Version:      1,
			},
			&schema.Method{
				HTTPMethod:   http.MethodGet,
				Name:         "ValidateToken",
				Params:       schema.NewMethodParams(),
				Undocumented: true,
				Version:      1,
			},
			&schema.Method{
				HTTPMethod:   http.MethodGet,
				Name:         "CreateEmergencyCodes",
				Params:       schema.NewMethodParams(),
				Undocumented: true,
				Version:      1,
			},
			&schema.Method{
				HTTPMethod:   http.MethodGet,
				Name:         "DestroyEmergencyCodes",
				Params:       schema.NewMethodParams(),
				Undocumented: true,
				Version:      1,
			},
		),
		Name:         "ITwoFactorService",
		Undocumented: true,
	},
)

var SchemaIVideoService = schema.MustNewInterfaces(
	&schema.Interface{
		Methods: schema.MustNewMethods(
			&schema.Method{
				HTTPMethod:   http.MethodGet,
				Name:         "SetVideoBookmark",
				Params:       schema.NewMethodParams(),
				Undocumented: true,
				Version:      1,
			},
			&schema.Method{
				HTTPMethod:   http.MethodGet,
				Name:         "GetVideoBookmarks",
				Params:       schema.NewMethodParams(),
				Undocumented: true,
				Version:      1,
			},
		),
		Name:         "IVideoService",
		Undocumented: true,
	},
)