igdb

package module
v1.0.2 Latest Latest
Warning

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

 Go to latest Published: Nov 13, 2019 License: MIT Imports: 17 Imported by: 0

README

IGDB

GoDoc Build Status Coverage Status Go Report Card Mentioned in Awesome Go

Recently updated to support IGDB V3!

Communicate with the Internet Game Database API quickly and easily with the igdb Go package. With the igdb client, you can retrieve extensive information on any number of video games, characters, companies, media, artwork and much more. Every IGDB API endpoint is supported!

If you would like to help the Go igdb project, please submit a pull request - it's always greatly appreciated.

Installation

If you do not have Go installed yet, you can find installation instructions here. Please note that the package requires Go version 1.9 or later.

To pull the most recent version of igdb, use go get.

go get github.com/Henry-Sarabia/igdb

Then import the package into your project as you normally would.

import "github.com/Henry-Sarabia/igdb"

Now you're ready to Go.

Usage

Creating A Client

Before using the igdb package, you need to have an IGDB API key. If you do not have a key yet, you can sign up here.

Create a client with your API key to start communicating with the IGDB API.

client, err := igdb.NewClient("YOUR_API_KEY", nil)

If you need to use a preconfigured HTTP client, simply pass its address to the NewClient function.

client, err := igdb.NewClient("YOUR_API_KEY", &customClient)
Services

The client contains a distinct service for working with each of the IGDB API endpoints. Each service has a set of service functions that make specific API calls to their respective endpoint.

To start communicating with the IGDB, choose a service and call its service function. Take the Games service for example.

To search for a Game, use the Search service function.

games, err := client.Games.Search("zelda")

To retrieve several Games by their IGDB ID, use the List service function.

games, err := client.Games.List([]int{7346, 1721, 2777})

The rest of the service functions work much the same way; they are concise and behave as you would expect. The documentation contains several examples on how to use each service function.

Service functions by themselves allow you to retrieve a considerable amount of information from the IGDB but sometimes you need more control over the results being returned. For this reason, the igdb package provides a set of flexible functional options for customizing a service function's API query.

Functional Options

The igdb package uses what are called functional options to apply different query parameters to service function's API call. Functional options themselves are merely first order functions that are passed to a service function.

Let's walk through a few different functional option examples.

To set the limit of the amount of results returned from an API query, pass SetLimit to the service function.

games, err := client.Games.Search("megaman", SetLimit(15))

As you can see, you simply need to pass the functional option as an argument to the service function.

To offset the results returned from an API call, pass SetOffset to the service function.

games, err := client.Games.Search("megaman", SetOffset(15))

SetOffset is used to iterate through a large set of results that cannot be retrieved in a single API call. In this case, the first 15 results are ignored so we effectively iterated through to the next set of results by 15.

To set the order of the results returned from an API call, pass SetOrder much in the same way as the previous examples.

games, err := client.Games.Search("megaman", SetOrder("popularity", igdb.OrderDescending))

SetOrder is used to specify in what order you want the results to be retrieved in and by what criteria. Here, SetOrder will retrieve the results with the highest popularity first.

The remaining functional options are not unlike the examples we covered and are further described in the documentation.

Functional Option Composition

More often than not, you will need to set more than one option for an API query. Fortunately, this functionality is supported through variadic functions and functional option composition.

First, service functions are variadic so you can pass in any number of functional options.

chars, err := client.Characters.Search(
    "mario",
    SetFields("id", "name", "games"),
    SetFilter("gender", "1"),
    SetLimit(5), 
    )

This API call will search the Characters endpoint using the query "mario", filter out any character that does not have a gender code of 1 (which in this case represents male), retrieve the id, name, and games fields, and return only up to 5 of these results.

Second, the igdb package provides a ComposeOptions function which takes any number of functional options as its parameters, composes them into a single functional option, and returns that composed functional option.

popularOpt := igdb.ComposeOptions(
    igdb.SetLimit(5),
    igdb.SetFields("name"),
	igdb.SetOrder("popularity", igdb.OrderDescending),
)

This call to ComposeOptions creates a single functional option that will allow you to retrieve the names of the top 5 most popular games when passed to the appropriate service function.

Functional option composition allows you to create custom functional options that can be reused in different API calls.

Taking the previous example, this can be done in the following way.

PS4, err := c.Games.Index(
		popularOpt,
		igdb.SetFilter("platforms", igdb.OpEquals, "48"),    // filter out games not on PS4
    )
    
XBOX, err := c.Games.Index(
		popularOpt, 
		igdb.SetFilter("platforms", igdb.OpEquals, "49"),    // filter out games not on XB1
    )

This example has two service function calls that each utilize the previously composed functional option in the same way but for different platforms. The first function retrieves the top 5 most popular PS4 games while the second function retrieves the top 5 most popular XB1 games.

Functional option composition reduces duplicate code and helps keep your code DRY. You can even compose newly composed functional options for even more finely grained control over similar API calls.

Examples

The repository contains several example mini-applications that demonstrate how one might use the igdb package.

If you have used the igdb package for a project and would like to have it featured here as a reference for new users, please submit an issue and I'll be sure to add it.

Contributions

If you would like to contribute to this project, please adhere to the following guidelines.

  • Submit an issue describing the problem.
  • Fork the repo and add your contribution.
  • Add appropriate tests.
  • Run go fmt, go vet, and golint.
  • Prefer idiomatic Go over non-idiomatic code.
  • Follow the basic Go conventions found here.
  • If in doubt, try to match your code to the current codebase.
  • Create a pull request with a description of your changes.

Again, contributions are greatly appreciated!

Special Thanks

  • You for your interest
  • John for the IGDB Gopher
  • Peter for the "Thank You" Gopher
  • Dave Cheney for his article on functional options
  • The DiscordGo and Go Spotify projects for inspiring me to create my own open source package for others to enjoy
  • The Awesome Go project for so many references to admire
  • The awesome people in the IGDB community who were always open to my questions

Documentation

Index

Examples

Constants

View Source 
const (
	EndpointAchievement                endpoint = "achievements/"
	EndpointAchievementIcon            endpoint = "achievement_icons/"
	EndpointAgeRating                  endpoint = "age_ratings/"
	EndpointAgeRatingContent           endpoint = "age_rating_content_descriptions/"
	EndpointAlternativeName            endpoint = "alternative_names/"
	EndpointArtwork                    endpoint = "artworks/"
	EndpointCharacter                  endpoint = "characters/"
	EndpointCharacterMugshot           endpoint = "character_mug_shots/"
	EndpointCollection                 endpoint = "collections/"
	EndpointCompany                    endpoint = "companies/"
	EndpointCompanyWebsite             endpoint = "company_websites/"
	EndpointCover                      endpoint = "covers/"
	EndpointExternalGame               endpoint = "external_games/"
	EndpointFeed                       endpoint = "feeds/"
	EndpointFranchise                  endpoint = "franchises/"
	EndpointGame                       endpoint = "games/"
	EndpointGameEngine                 endpoint = "game_engines/"
	EndpointGameMode                   endpoint = "game_modes/"
	EndpointGameVersion                endpoint = "game_versions/"
	EndpointGameVersionFeature         endpoint = "game_version_features/"
	EndpointGameVersionFeatureValue    endpoint = "game_version_feature_values/"
	EndpointGameVideo                  endpoint = "game_videos/"
	EndpointGenre                      endpoint = "genres/"
	EndpointInvolvedCompany            endpoint = "involved_companies/"
	EndpointKeyword                    endpoint = "keywords/"
	EndpointMultiplayerMode            endpoint = "multiplayer_modes/"
	EndpointPage                       endpoint = "pages/"
	EndpointPageBackground             endpoint = "page_backgrounds/"
	EndpointPageWebsite                endpoint = "page_websites/"
	EndpointPlatform                   endpoint = "platforms/"
	EndpointPlatformVersion            endpoint = "platform_versions/"
	EndpointPlatformVersionCompany     endpoint = "platform_version_companies/"
	EndpointPlatformVersionReleaseDate endpoint = "platform_version_release_dates/"
	EndpointPlatformWebsite            endpoint = "platform_websites/"
	EndpointPlayerPerspective          endpoint = "player_perspectives/"
	EndpointProductFamily              endpoint = "product_families/"
	EndpointPulse                      endpoint = "pulses/"
	EndpointPulseGroup                 endpoint = "pulse_groups/"
	EndpointPulseSource                endpoint = "pulse_sources/"
	EndpointPulseURL                   endpoint = "pulse_urls/"
	EndpointReleaseDate                endpoint = "release_dates/"
	EndpointScreenshot                 endpoint = "screenshots/"
	EndpointSearch                     endpoint = "search/"
	EndpointTheme                      endpoint = "themes/"
	EndpointTimeToBeat                 endpoint = "time_to_beats/"
	EndpointTitle                      endpoint = "titles/"
	EndpointWebsite                    endpoint = "websites/"
)

Public IGDB API endpoints

View Source 
const (
	EndpointCredit        endpoint = "private/credits/"
	EndpointFeedFollow    endpoint = "private/feed_follows/"
	EndpointFollow        endpoint = "private/follows/"
	EndpointList          endpoint = "private/lists/"
	EndpointListEntry     endpoint = "private/list_entries/"
	EndpointPerson        endpoint = "private/people/"
	EndpointPersonMugshot endpoint = "private/person_mug_shots/"
	EndpointPersonWebsite endpoint = "private/person_websites/"
	EndpointRate          endpoint = "private/rates/"
	EndpointReview        endpoint = "private/reviews/"
	EndpointReviewVideo   endpoint = "private/review_videos/"
	EndpointSocialMetric  endpoint = "private/social_metrics/"
	EndpointTestDummy     endpoint = "private/test_dummies/"
)

Private IGDB API endpoints

View Source 
const (
	// SizeCoverSmall is sized at 90x128.
	SizeCoverSmall imageSize = "cover_small"
	// SizeCoverBig is sized at 227x320.
	SizeCoverBig imageSize = "cover_big"
	// SizeScreenshotMed is sized at 569x320.
	SizeScreenshotMed imageSize = "screenshot_med"
	// SizeScreenshotBig is sized at 889x500
	SizeScreenshotBig imageSize = "screenshot_big"
	// SizeScreenshotHuge is sized at 1280x720.
	SizeScreenshotHuge imageSize = "screenshot_huge"
	// SizeLogoMed is sized at 284x160.
	SizeLogoMed imageSize = "logo_med"
	// SizeMicro is sized at 35x35.
	SizeMicro imageSize = "micro"
	// SizeThumb is sized at 90x90.
	SizeThumb imageSize = "thumb"
	// Size720p is sized at 1280x720.
	Size720p imageSize = "720p"
	// Size1080p is sized at 1920x1080.
	Size1080p imageSize = "1080p"
)

Available image sizes supported by the IGDB API

View Source 
const (
	// OrderAscending is used as an argument in the SetOrder functional
	// option to organize the results from an API call in ascending order.
	OrderAscending order = "asc"
	// OrderDescending is used as an argument in the SetOrder functional
	// option to organize the results from an API call in descending order.
	OrderDescending order = "desc"
)

Available orders for the functional option SetOrder

View Source 
const (
	// OpEquals checks for equality. Must match exactly.
	OpEquals operator = "%s = %s"
	// OpNotEquals checks for inequality. Any non-exact match.
	OpNotEquals operator = "%s != %s"
	// OpGreaterThan checks if a field value is greater than a given value. Only works on numbers.
	OpGreaterThan operator = "%s > %s"
	// OpGreaterThanEqual checks if a field value is greater than or equal to a given value. Only works on numbers.
	OpGreaterThanEqual operator = "%s >= %s"
	// OpLessThan checks if a field value is less than a given value. Only works on numbers.
	OpLessThan operator = "%s < %s"
	// OpLessThanEqual checks if a field value is less than or equal to a given value. Only works on numbers.
	OpLessThanEqual operator = "%s <= %s"
	// OpContainsAll checks if the given value exists in within the array.
	OpContainsAll operator = "%s = [%s]"
	// OpNotContainsAll checks if the given value does not exist in within the array.
	OpNotContainsAll operator = "%s != [%s]"
	// OpContainsAtLeast checks if any of the given values exist within the array.
	OpContainsAtLeast operator = "%s = (%s)"
	// OpNotContainsAtLeast checks if any of the given values do not exist within the array.
	OpNotContainsAtLeast operator = "%s != (%s)"
	// OpContainsExactly checks if the the given values exactly match the array.
	OpContainsExactly operator = "%s = {%s}"
)

Available operators for the functional option SetFilter

View Source 
const (
	TagTheme tagType = iota
	TagGenre
	TagKeyword
	TagGame
	TagPerspective
)

These tagTypes correspond to their respective IGDB Object Type IDs.

For the list of these IDs and other information, visit: https://igdb.github.io/api/references/tag-numbers/

View Source 
const EndpointStatus endpoint = "api_status"

EndpointStatus is a unique endpoint for checking the status of the API.

Variables

View Source 
var (
	// ErrNegativeID occurs when a negative ID is used as an argument in an API call.
	ErrNegativeID = errors.New("ID cannot be negative")
	// ErrEmptyIDs occurs when a List function is called without a populated int slice.
	ErrEmptyIDs = errors.New("IDs argument empty")
	// ErrNoResults occurs when the IGDB returns an empty array, void of results.
	ErrNoResults = errors.New("results are empty")
)
View Source 
var (
	// ErrBadRequest occurs when a request is malformed.
	ErrBadRequest = ServerError{
		Status: http.StatusBadRequest,
		Msg:    "bad request: check query parameters",
	}
	// ErrUnauthorized occurs when a request is made without authorization.
	ErrUnauthorized = ServerError{
		Status: http.StatusUnauthorized,
		Msg:    "authentication failed: check for valid API key in user-key header",
	}
	// ErrForbidden occurs when a request is made without authorization.
	ErrForbidden = ServerError{
		Status: http.StatusForbidden,
		Msg:    "authentication failed: check for valid API key in user-key header",
	}
	// ErrInternalError occurs when an unexpected IGDB server error occurs and should be reported.
	ErrInternalError = ServerError{
		Status: http.StatusInternalServerError,
		Msg:    "internal error: report bug",
	}
)

Errors returned when encountering error status codes.

View Source 
var (
	// ErrBlankID occurs when an empty string is used as an argument.
	ErrBlankID = errors.New("image id value empty")
	// ErrPixelRatio occurs when an unsupported display pixel ratio is used as an argument in a function.
	ErrPixelRatio = errors.New("invalid display pixel ratio")
)

Errors returned when creating Image URLs.

View Source 
var (
	// ErrEmptyQry occurs when an empty string is used as a query value.
	ErrEmptyQry = errors.New("provided option query value is empty")
	// ErrEmptyFields occurs when an empty string is used as a field value.
	ErrEmptyFields = errors.New("one or more provided option field values are empty")
	// ErrExpandedField occurs when a field value tries to access an expanded subfield.
	ErrExpandedField = errors.New("one or more provided option field values is an expanded subfield which is not supported")
	// ErrEmptyFilterVals occurs when an empty string is used as a filter value.
	ErrEmptyFilterVals = errors.New("one or more provided filter option values are empty")
	// ErrOutOfRange occurs when a provided number value is out of valid range.
	ErrOutOfRange = errors.New("provided option value is out of range")
)

Errors returned by an Option when setting options for an API call.

Functions

func SizedImageURL 

func SizedImageURL(imageID string, size imageSize, ratio int) (string, error)

SizedImageURL returns the URL of an image identified by the provided imageID, image size, and display pixel ratio. The display pixel ratio only multiplies the resolution of the image. The current available ratios are 1 and 2.

Types

type Achievement 

type Achievement struct {
	ID               int                 `json:"id"`
	AchievementIcon  int                 `json:"achievement_icon"`
	Category         AchievementCategory `json:"category"`
	CreatedAt        int                 `json:"created_at"`
	Description      string              `json:"description"`
	ExternalID       string              `json:"external_id"`
	Game             int                 `json:"game"`
	Language         AchievementLanguage `json:"language"`
	Name             string              `json:"name"`
	OwnersPercentage float64             `json:"owners_percentage"`
	Rank             AchievementRank     `json:"rank"`
	Slug             string              `json:"slug"`
	Tags             []Tag               `json:"tags"`
	UpdatedAt        int                 `json:"updated_at"`
}

Achievement data for specific games for specific platforms (currently limited to achievements from Steam, Playstation, and XBox). For more information visit: https://api-docs.igdb.com/#achievement

type AchievementCategory 

type AchievementCategory int

AchievementCategory specifies an achievement's native platform. 

const (
	AchievementPlaystation AchievementCategory = iota + 1
	AchievementXbox
	AchievementSteam
)

Expected AchievementCategory enums from the IGDB.

func (AchievementCategory) String 

func (i AchievementCategory) String() string

type AchievementIcon 

type AchievementIcon struct {
	Image
	ID int `json:"id"`
}

AchievementIcon is an icon for a specific achievement. For more information visit: https://api-docs.igdb.com/#achievement-icon

type AchievementIconService 

type AchievementIconService service

AchievementIconService handles all the API calls for the IGDB AchievementIcon endpoint. This endpoint is only available for the IGDB Pro tier or above.

func (*AchievementIconService) Count 

func (as *AchievementIconService) Count(opts ...Option) (int, error)

Count returns the number of AchievementIcons available in the IGDB. Provide the SetFilter functional option if you need to filter which AchievementIcons to count.

func (*AchievementIconService) Fields 

func (as *AchievementIconService) Fields() ([]string, error)

Fields returns the up-to-date list of fields in an IGDB AchievementIcon object.

func (*AchievementIconService) Get 

func (as *AchievementIconService) Get(id int, opts ...Option) (*AchievementIcon, error)

Get returns a single AchievementIcon identified by the provided IGDB ID. Provide the SetFields functional option if you need to specify which fields to retrieve. If the ID does not match any AchievementIcons, an error is returned.

func (*AchievementIconService) Index 

func (as *AchievementIconService) Index(opts ...Option) ([]*AchievementIcon, error)

Index returns an index of AchievementIcons based solely on the provided functional options used to sort, filter, and paginate the results. If no AchievementIcons can be found using the provided options, an error is returned.

func (*AchievementIconService) List 

func (as *AchievementIconService) List(ids []int, opts ...Option) ([]*AchievementIcon, error)

List returns a list of AchievementIcons identified by the provided list of IGDB IDs. Provide functional options to sort, filter, and paginate the results. Any ID that does not match a AchievementIcon is ignored. If none of the IDs match a AchievementIcon, an error is returned.

type AchievementLanguage 

type AchievementLanguage int

AchievementLanguage specifies an achievement's language. 

const (
	LanguageEurope AchievementLanguage = iota + 1
	LanguageNorthAmerica
	LanguageAustralia
	LanguageNewZealand
	LanguageJapan
	LanguageChina
	LanguageAsia
	LanguageWorldwide
	LanguageHongKong
	LanguageSouthKorea
)

Expected AchievementLanguage enums from the IGDB.

func (AchievementLanguage) String 

func (i AchievementLanguage) String() string

type AchievementRank 

type AchievementRank int

AchievementRank specifies an achievement's rank ranging from bronze to platinum. 

const (
	RankBronze AchievementRank = iota + 1
	RankSilver
	RankGold
	RankPlatinum
)

Expected AchievementRank enums from the IGDB.

func (AchievementRank) String 

func (i AchievementRank) String() string

type AchievementService 

type AchievementService service

AchievementService handles all the API calls for the IGDB Achievement endpoint. This endpoint is only available for the IGDB Pro tier or above.

func (*AchievementService) Count 

func (as *AchievementService) Count(opts ...Option) (int, error)

Count returns the number of Achievements available in the IGDB. Provide the SetFilter functional option if you need to filter which Achievements to count.

func (*AchievementService) Fields 

func (as *AchievementService) Fields() ([]string, error)

Fields returns the up-to-date list of fields in an IGDB Achievement object.

func (*AchievementService) Get 

func (as *AchievementService) Get(id int, opts ...Option) (*Achievement, error)

Get returns a single Achievement identified by the provided IGDB ID. Provide the SetFields functional option if you need to specify which fields to retrieve. If the ID does not match any Achievements, an error is returned.

func (*AchievementService) Index 

func (as *AchievementService) Index(opts ...Option) ([]*Achievement, error)

Index returns an index of Achievements based solely on the provided functional options used to sort, filter, and paginate the results. If no Achievements can be found using the provided options, an error is returned.

func (*AchievementService) List 

func (as *AchievementService) List(ids []int, opts ...Option) ([]*Achievement, error)

List returns a list of Achievements identified by the provided list of IGDB IDs. Provide functional options to sort, filter, and paginate the results. Any ID that does not match a Achievement is ignored. If none of the IDs match a Achievement, an error is returned.

type AgeRating 

type AgeRating struct {
	ID                  int               `json:"id"`
	Category            AgeRatingCategory `json:"category"`
	ContentDescriptions []int             `json:"content_descriptions"`
	Rating              AgeRatingEnum     `json:"rating"`
	RatingCoverURL      string            `json:"rating_cover_url"`
	Synopsis            string            `json:"synopsis"`
}

AgeRating describes an age rating according to various organizations. For more information visit: https://api-docs.igdb.com/#age-rating

type AgeRatingCategory 

type AgeRatingCategory int

AgeRatingCategory specifies a regulatory organization. 

const (
	AgeRatingESRB AgeRatingCategory = iota + 1
	AgeRatingPEGI
)

Expected AgeRatingCategory enums from the IGDB.

func (AgeRatingCategory) String 

func (i AgeRatingCategory) String() string

type AgeRatingContent 

type AgeRatingContent struct {
	ID          int                      `json:"id"`
	Category    AgeRatingContentCategory `json:"category"`
	Description string                   `json:"description"`
}

AgeRatingContent is the organization behind a specific rating.

type AgeRatingContentCategory 

type AgeRatingContentCategory int

AgeRatingContentCategory specifies a regulatory organization. 

const (
	AgeRatingContentPEGI AgeRatingContentCategory = iota + 1
	AgeRatingContentESRB
)

Expected AgeRatingContentCategory enums from the IGDB.

func (AgeRatingContentCategory) String 

func (i AgeRatingContentCategory) String() string

type AgeRatingContentService 

type AgeRatingContentService service

AgeRatingContentService handles all the API calls for the IGDB AgeRatingContent endpoint.

func (*AgeRatingContentService) Count 

func (as *AgeRatingContentService) Count(opts ...Option) (int, error)

Count returns the number of AgeRatingContents available in the IGDB. Provide the SetFilter functional option if you need to filter which AgeRatingContents to count.

func (*AgeRatingContentService) Fields 

func (as *AgeRatingContentService) Fields() ([]string, error)

Fields returns the up-to-date list of fields in an IGDB AgeRatingContent object.

func (*AgeRatingContentService) Get 

func (as *AgeRatingContentService) Get(id int, opts ...Option) (*AgeRatingContent, error)

Get returns a single AgeRatingContent identified by the provided IGDB ID. Provide the SetFields functional option if you need to specify which fields to retrieve. If the ID does not match any AgeRatingContents, an error is returned.

func (*AgeRatingContentService) Index 

func (as *AgeRatingContentService) Index(opts ...Option) ([]*AgeRatingContent, error)

Index returns an index of AgeRatingContents based solely on the provided functional options used to sort, filter, and paginate the results. If no AgeRatingContents can be found using the provided options, an error is returned.

func (*AgeRatingContentService) List 

func (as *AgeRatingContentService) List(ids []int, opts ...Option) ([]*AgeRatingContent, error)

List returns a list of AgeRatingContents identified by the provided list of IGDB IDs. Provide functional options to sort, filter, and paginate the results. Any ID that does not match a AgeRatingContent is ignored. If none of the IDs match a AgeRatingContent, an error is returned.

type AgeRatingEnum 

type AgeRatingEnum int

AgeRatingEnum specifies a specific age rating. 

const (
	AgeRatingThree AgeRatingEnum = iota + 1
	AgeRatingSeven
	AgeRatingTwelve
	AgeRatingSixteen
	AgeRatingEighteen
	AgeRatingRP
	AgeRatingEC
	AgeRatingE
	AgeRatingE10
	AgeRatingT
	AgeRatingM
	AgeRatingAO
)

Expected AgeRatingEnum enums from the IGDB.

func (AgeRatingEnum) String 

func (i AgeRatingEnum) String() string

type AgeRatingService 

type AgeRatingService service

AgeRatingService handles all the API calls for the IGDB AgeRating endpoint.

func (*AgeRatingService) Count 

func (as *AgeRatingService) Count(opts ...Option) (int, error)

Count returns the number of AgeRatings available in the IGDB. Provide the SetFilter functional option if you need to filter which AgeRatings to count.

func (*AgeRatingService) Fields 

func (as *AgeRatingService) Fields() ([]string, error)

Fields returns the up-to-date list of fields in an IGDB AgeRating object.

func (*AgeRatingService) Get 

func (as *AgeRatingService) Get(id int, opts ...Option) (*AgeRating, error)

Get returns a single AgeRating identified by the provided IGDB ID. Provide the SetFields functional option if you need to specify which fields to retrieve. If the ID does not match any AgeRatings, an error is returned.

func (*AgeRatingService) Index 

func (as *AgeRatingService) Index(opts ...Option) ([]*AgeRating, error)

Index returns an index of AgeRatings based solely on the provided functional options used to sort, filter, and paginate the results. If no AgeRatings can be found using the provided options, an error is returned.

func (*AgeRatingService) List 

func (as *AgeRatingService) List(ids []int, opts ...Option) ([]*AgeRating, error)

List returns a list of AgeRatings identified by the provided list of IGDB IDs. Provide functional options to sort, filter, and paginate the results. Any ID that does not match a AgeRating is ignored. If none of the IDs match a AgeRating, an error is returned.

type AlternativeName 

type AlternativeName struct {
	ID      int    `json:"id"`
	Comment string `json:"comment"`
	Game    int    `json:"game"`
	Name    string `json:"name"`
}

AlternativeName represents an alternative or international name for a particular video game. For more information visit: https://api-docs.igdb.com/#alternative-name

type AlternativeNameService 

type AlternativeNameService service

AlternativeNameService handles all the API calls for the IGDB AlternativeName endpoint.

func (*AlternativeNameService) Count 

func (as *AlternativeNameService) Count(opts ...Option) (int, error)

Count returns the number of AlternativeNames available in the IGDB. Provide the SetFilter functional option if you need to filter which AlternativeNames to count.

func (*AlternativeNameService) Fields 

func (as *AlternativeNameService) Fields() ([]string, error)

Fields returns the up-to-date list of fields in an IGDB AlternativeName object.

func (*AlternativeNameService) Get 

func (as *AlternativeNameService) Get(id int, opts ...Option) (*AlternativeName, error)

Get returns a single AlternativeName identified by the provided IGDB ID. Provide the SetFields functional option if you need to specify which fields to retrieve. If the ID does not match any AlternativeNames, an error is returned.

func (*AlternativeNameService) Index 

func (as *AlternativeNameService) Index(opts ...Option) ([]*AlternativeName, error)

Index returns an index of AlternativeNames based solely on the provided functional options used to sort, filter, and paginate the results. If no AlternativeNames can be found using the provided options, an error is returned.

func (*AlternativeNameService) List 

func (as *AlternativeNameService) List(ids []int, opts ...Option) ([]*AlternativeName, error)

List returns a list of AlternativeNames identified by the provided list of IGDB IDs. Provide functional options to sort, filter, and paginate the results. Any ID that does not match a AlternativeName is ignored. If none of the IDs match a AlternativeName, an error is returned.

type Artwork 

type Artwork struct {
	Image
	ID   int `json:"id"`
	Game int `json:"game"`
}

Artwork represents an official piece of artwork. Resolution and aspect ratio may vary. For more information visit: https://api-docs.igdb.com/#artwork

type ArtworkService 

type ArtworkService service

ArtworkService handles all the API calls for the IGDB Artwork endpoint.

func (*ArtworkService) Count 

func (as *ArtworkService) Count(opts ...Option) (int, error)

Count returns the number of Artworks available in the IGDB. Provide the SetFilter functional option if you need to filter which Artworks to count.

func (*ArtworkService) Fields 

func (as *ArtworkService) Fields() ([]string, error)

Fields returns the up-to-date list of fields in an IGDB Artwork object.

func (*ArtworkService) Get 

func (as *ArtworkService) Get(id int, opts ...Option) (*Artwork, error)

Get returns a single Artwork identified by the provided IGDB ID. Provide the SetFields functional option if you need to specify which fields to retrieve. If the ID does not match any Artworks, an error is returned.

func (*ArtworkService) Index 

func (as *ArtworkService) Index(opts ...Option) ([]*Artwork, error)

Index returns an index of Artworks based solely on the provided functional options used to sort, filter, and paginate the results. If no Artworks can be found using the provided options, an error is returned.

func (*ArtworkService) List 

func (as *ArtworkService) List(ids []int, opts ...Option) ([]*Artwork, error)

List returns a list of Artworks identified by the provided list of IGDB IDs. Provide functional options to sort, filter, and paginate the results. Any ID that does not match a Artwork is ignored. If none of the IDs match a Artwork, an error is returned.

type Character 

type Character struct {
	ID          int              `json:"ID"`
	AKAS        []string         `json:"akas"`
	CountryName string           `json:"country_name"`
	CreatedAt   int              `json:"created_at"`
	Description string           `json:"description"`
	Games       []int            `json:"games"`
	Gender      CharacterGender  `json:"gender"`
	MugShot     int              `json:"mug_shot"`
	Name        string           `json:"name"`
	People      []int            `json:"people"`
	Slug        string           `json:"slug"`
	Species     CharacterSpecies `json:"species"`
	UpdatedAt   int              `json:"updated_at"`
	URL         string           `json:"url"`
}

Character represents a video game character. For more information visit: https://api-docs.igdb.com/#character

type CharacterGender 

type CharacterGender int

CharacterGender specifies a specific gender. 

const (
	GenderMale CharacterGender = iota + 1
	GenderFemale
	GenderOther
)

Expected CharacterGender enums from the IGDB.

func (CharacterGender) String 

func (i CharacterGender) String() string

type CharacterMugshot 

type CharacterMugshot struct {
	Image
	ID int `json:"id"`
}

CharacterMugshot represents an image depicting a game character. For more information visit: https://api-docs.igdb.com/#character-mug-shot

type CharacterMugshotService 

type CharacterMugshotService service

CharacterMugshotService handles all the API calls for the IGDB CharacterMugshot endpoint.

func (*CharacterMugshotService) Count 

func (cs *CharacterMugshotService) Count(opts ...Option) (int, error)

Count returns the number of CharacterMugshots available in the IGDB. Provide the SetFilter functional option if you need to filter which CharacterMugshots to count.

func (*CharacterMugshotService) Fields 

func (cs *CharacterMugshotService) Fields() ([]string, error)

Fields returns the up-to-date list of fields in an IGDB CharacterMugshot object.

func (*CharacterMugshotService) Get 

func (cs *CharacterMugshotService) Get(id int, opts ...Option) (*CharacterMugshot, error)

Get returns a single CharacterMugshot identified by the provided IGDB ID. Provide the SetFields functional option if you need to specify which fields to retrieve. If the ID does not match any CharacterMugshots, an error is returned.

func (*CharacterMugshotService) Index 

func (cs *CharacterMugshotService) Index(opts ...Option) ([]*CharacterMugshot, error)

Index returns an index of CharacterMugshots based solely on the provided functional options used to sort, filter, and paginate the results. If no CharacterMugshots can be found using the provided options, an error is returned.

func (*CharacterMugshotService) List 

func (cs *CharacterMugshotService) List(ids []int, opts ...Option) ([]*CharacterMugshot, error)

List returns a list of CharacterMugshots identified by the provided list of IGDB IDs. Provide functional options to sort, filter, and paginate the results. Any ID that does not match a CharacterMugshot is ignored. If none of the IDs match a CharacterMugshot, an error is returned.

type CharacterService 

type CharacterService service

CharacterService handles all the API calls for the IGDB Character endpoint.

func (*CharacterService) Count 

func (cs *CharacterService) Count(opts ...Option) (int, error)

Count returns the number of Characters available in the IGDB. Provide the SetFilter functional option if you need to filter which Characters to count.

func (*CharacterService) Fields 

func (cs *CharacterService) Fields() ([]string, error)

Fields returns the up-to-date list of fields in an IGDB Character object.

func (*CharacterService) Get 

func (cs *CharacterService) Get(id int, opts ...Option) (*Character, error)

Get returns a single Character identified by the provided IGDB ID. Provide the SetFields functional option if you need to specify which fields to retrieve. If the ID does not match any Characters, an error is returned.

func (*CharacterService) Index 

func (cs *CharacterService) Index(opts ...Option) ([]*Character, error)

Index returns an index of Characters based solely on the provided functional options used to sort, filter, and paginate the results. If no Characters can be found using the provided options, an error is returned.

func (*CharacterService) List 

func (cs *CharacterService) List(ids []int, opts ...Option) ([]*Character, error)

List returns a list of Characters identified by the provided list of IGDB IDs. Provide functional options to sort, filter, and paginate the results. Any ID that does not match a Character is ignored. If none of the IDs match a Character, an error is returned.

func (*CharacterService) Search 

func (cs *CharacterService) Search(qry string, opts ...Option) ([]*Character, error)

Search returns a list of Characters found by searching the IGDB using the provided query. Provide functional options to sort, filter, and paginate the results. If no Characters are found using the provided query, an error is returned.

type CharacterSpecies 

type CharacterSpecies int

CharacterSpecies specifies a specific species. 

const (
	SpeciesHuman CharacterSpecies = iota + 1
	SpeciesAlien
	SpeciesAnimal
	SpeciesAndroid
	SpeciesUnknown
)

Expected CharacterSpecies enums from the IGDB.

func (CharacterSpecies) String 

func (i CharacterSpecies) String() string

type Client 

type Client struct {

	// Services
	Achievements                *AchievementService
	AchievementIcons            *AchievementIconService
	AgeRatings                  *AgeRatingService
	AgeRatingContents           *AgeRatingContentService
	AlternativeNames            *AlternativeNameService
	Artworks                    *ArtworkService
	Characters                  *CharacterService
	CharacterMugshots           *CharacterMugshotService
	Collections                 *CollectionService
	Companies                   *CompanyService
	CompanyLogos                *CompanyLogoService
	CompanyWebsites             *CompanyWebsiteService
	Covers                      *CoverService
	ExternalGames               *ExternalGameService
	Feeds                       *FeedService
	Franchises                  *FranchiseService
	Games                       *GameService
	GameEngines                 *GameEngineService
	GameEngineLogos             *GameEngineLogoService
	GameModes                   *GameModeService
	GameVersions                *GameVersionService
	GameVersionFeatures         *GameVersionFeatureService
	GameVersionFeatureValues    *GameVersionFeatureValueService
	GameVideos                  *GameVideoService
	Genres                      *GenreService
	InvolvedCompanies           *InvolvedCompanyService
	Keywords                    *KeywordService
	MultiplayerModes            *MultiplayerModeService
	Pages                       *PageService
	PageBackgrounds             *PageBackgroundService
	PageLogos                   *PageLogoService
	PageWebsites                *PageWebsiteService
	Platforms                   *PlatformService
	PlatformLogos               *PlatformLogoService
	PlatformVersions            *PlatformVersionService
	PlatformVersionCompanies    *PlatformVersionCompanyService
	PlatformVersionReleaseDates *PlatformVersionReleaseDateService
	PlatformWebsites            *PlatformWebsiteService
	PlayerPerspectives          *PlayerPerspectiveService
	ProductFamilies             *ProductFamilyService
	Pulses                      *PulseService
	PulseGroups                 *PulseGroupService
	PulseSources                *PulseSourceService
	PulseURLs                   *PulseURLService
	ReleaseDates                *ReleaseDateService
	Screenshots                 *ScreenshotService
	Themes                      *ThemeService
	TimeToBeats                 *TimeToBeatService
	Titles                      *TitleService
	Websites                    *WebsiteService

	// Private Services
	Credits        *CreditService
	FeedFollows    *FeedFollowService
	Follows        *FollowService
	Lists          *ListService
	ListEntrys     *ListEntryService
	Persons        *PersonService
	PersonMugshots *PersonMugshotService
	PersonWebsites *PersonWebsiteService
	Rates          *RateService
	Reviews        *ReviewService
	ReviewVideos   *ReviewVideoService
	SocialMetrics  *SocialMetricService
	TestDummies    *TestDummyService
	// contains filtered or unexported fields
}

Client wraps an HTTP Client used to communicate with the IGDB, the root URL of the IGDB, and the user's IGDB API key. Client also initializes all the separate services to communicate with each individual IGDB API endpoint.

func NewClient 

func NewClient(apiKey string, custom *http.Client) *Client

NewClient returns a new Client configured to communicate with the IGDB. The provided apiKey will be used to make requests on your behalf. The provided Tier will determine the maximum limit and offset your key entitles you to in an API call. The provided HTTP Client will be the client making requests to the IGDB. If no HTTP Client is provided, a default HTTP client is used instead.

If you need an IGDB API key, please visit: https://api.igdb.com/signup

func (*Client) Search 

func (c *Client) Search(qry string, opts ...Option) ([]*SearchResult, error)

Search returns a list of SearchResults using the provided query. Provide functional options to sort, filter, and paginate the results. If no results are found, an error is returned. Search can only search through Characters, Collections, Games, People, Platforms, and Themes.

func (*Client) Status 

func (c *Client) Status() (*Status, error)

Status returns a usage report for the user's API key. It shows stats such as requests made in the current period and when that period ends. For more information visit: https://api-docs.igdb.com/#api-status

type Collection 

type Collection struct {
	ID        int    `json:"id"`
	CreatedAt int    `json:"created_at"`
	Name      string `json:"name"`
	Slug      string `json:"slug"`
	UpdatedAt int    `json:"updated_at"`
	URL       string `json:"url"`
}

Collection represents a video game series. For more information visit: https://api-docs.igdb.com/#collection

type CollectionService 

type CollectionService service

CollectionService handles all the API calls for the IGDB Collection endpoint.

func (*CollectionService) Count 

func (cs *CollectionService) Count(opts ...Option) (int, error)

Count returns the number of Collections available in the IGDB. Provide the SetFilter functional option if you need to filter which Collections to count.

func (*CollectionService) Fields 

func (cs *CollectionService) Fields() ([]string, error)

Fields returns the up-to-date list of fields in an IGDB Collection object.

func (*CollectionService) Get 

func (cs *CollectionService) Get(id int, opts ...Option) (*Collection, error)

Get returns a single Collection identified by the provided IGDB ID. Provide the SetFields functional option if you need to specify which fields to retrieve. If the ID does not match any Collections, an error is returned.

func (*CollectionService) Index 

func (cs *CollectionService) Index(opts ...Option) ([]*Collection, error)

Index returns an index of Collections based solely on the provided functional options used to sort, filter, and paginate the results. If no Collections can be found using the provided options, an error is returned.

func (*CollectionService) List 

func (cs *CollectionService) List(ids []int, opts ...Option) ([]*Collection, error)

List returns a list of Collections identified by the provided list of IGDB IDs. Provide functional options to sort, filter, and paginate the results. Any ID that does not match a Collection is ignored. If none of the IDs match a Collection, an error is returned.

func (*CollectionService) Search 

func (cs *CollectionService) Search(qry string, opts ...Option) ([]*Collection, error)

Search returns a list of Collections found by searching the IGDB using the provided query. Provide functional options to sort, filter, and paginate the results. If no Collections are found using the provided query, an error is returned.

type Company 

type Company struct {
	ID                 int          `json:"id"`
	ChangeDate         int          `json:"change_date"`
	ChangeDateCategory DateCategory `json:"change_date_category"`
	ChangedCompanyID   int          `json:"changed_company_id"`
	Country            int          `json:"country"`
	CreatedAt          int          `json:"created_at"`
	Description        string       `json:"description"`
	Developed          []int        `json:"developed"`
	Name               string       `json:"name"`
	Parent             int          `json:"parent"`
	Published          []int        `json:"published"`
	Slug               string       `json:"slug"`
	StartDate          int          `json:"start_date"`
	StartDateCategory  DateCategory `json:"start_date_category"`
	UpdatedAt          int          `json:"updated_at"`
	URL                string       `json:"url"`
	Websites           []int        `json:"websites"`
}

Company represents a video game company. This includes both publishers and developers. For more information visit: https://api-docs.igdb.com/#company 

type CompanyLogo struct {
	Image
	ID int `json:"id"`
}

CompanyLogo represents the logo of a developer or publisher. For more information visit: https://api-docs.igdb.com/#company-logo

type CompanyLogoService 

type CompanyLogoService service

CompanyLogoService handles all the API calls for the IGDB CompanyLogo endpoint.

func (*CompanyLogoService) Count 

func (cs *CompanyLogoService) Count(opts ...Option) (int, error)

Count returns the number of CompanyLogos available in the IGDB. Provide the SetFilter functional option if you need to filter which CompanyLogos to count.

func (*CompanyLogoService) Fields 

func (cs *CompanyLogoService) Fields() ([]string, error)

Fields returns the up-to-date list of fields in an IGDB CompanyLogo object.

func (*CompanyLogoService) Get 

func (cs *CompanyLogoService) Get(id int, opts ...Option) (*CompanyLogo, error)

Get returns a single CompanyLogo identified by the provided IGDB ID. Provide the SetFields functional option if you need to specify which fields to retrieve. If the ID does not match any CompanyLogos, an error is returned.

func (*CompanyLogoService) Index 

func (cs *CompanyLogoService) Index(opts ...Option) ([]*CompanyLogo, error)

Index returns an index of CompanyLogos based solely on the provided functional options used to sort, filter, and paginate the results. If no CompanyLogos can be found using the provided options, an error is returned.

func (*CompanyLogoService) List 

func (cs *CompanyLogoService) List(ids []int, opts ...Option) ([]*CompanyLogo, error)

List returns a list of CompanyLogos identified by the provided list of IGDB IDs. Provide functional options to sort, filter, and paginate the results. Any ID that does not match a CompanyLogo is ignored. If none of the IDs match a CompanyLogo, an error is returned.

type CompanyService 

type CompanyService service

CompanyService handles all the API calls for the IGDB Company endpoint.

func (*CompanyService) Count 

func (cs *CompanyService) Count(opts ...Option) (int, error)

Count returns the number of Companies available in the IGDB. Provide the SetFilter functional option if you need to filter which Companies to count.

func (*CompanyService) Fields 

func (cs *CompanyService) Fields() ([]string, error)

Fields returns the up-to-date list of fields in an IGDB Company object.

func (*CompanyService) Get 

func (cs *CompanyService) Get(id int, opts ...Option) (*Company, error)

Get returns a single Company identified by the provided IGDB ID. Provide the SetFields functional option if you need to specify which fields to retrieve. If the ID does not match any Companies, an error is returned.

func (*CompanyService) Index 

func (cs *CompanyService) Index(opts ...Option) ([]*Company, error)

Index returns an index of Companies based solely on the provided functional options used to sort, filter, and paginate the results. If no Companies can be found using the provided options, an error is returned.

func (*CompanyService) List 

func (cs *CompanyService) List(ids []int, opts ...Option) ([]*Company, error)

List returns a list of Companies identified by the provided list of IGDB IDs. Provide functional options to sort, filter, and paginate the results. Any ID that does not match a Company is ignored. If none of the IDs match a Company, an error is returned.

type CompanyWebsite 

type CompanyWebsite struct {
	ID       int             `json:"id"`
	Category WebsiteCategory `json:"category"`
	Trusted  bool            `json:"trusted"`
	URL      string          `json:"url"`
}

CompanyWebsite represents a website for a specific company. For more information visit: https://api-docs.igdb.com/#company-website

type CompanyWebsiteService 

type CompanyWebsiteService service

CompanyWebsiteService handles all the API calls for the IGDB CompanyWebsite endpoint.

func (*CompanyWebsiteService) Count 

func (zs *CompanyWebsiteService) Count(opts ...Option) (int, error)

Count returns the number of CompanyWebsites available in the IGDB. Provide the SetFilter functional option if you need to filter which CompanyWebsites to count.

func (*CompanyWebsiteService) Fields 

func (zs *CompanyWebsiteService) Fields() ([]string, error)

Fields returns the up-to-date list of fields in an IGDB CompanyWebsite object.

func (*CompanyWebsiteService) Get 

func (zs *CompanyWebsiteService) Get(id int, opts ...Option) (*CompanyWebsite, error)

Get returns a single CompanyWebsite identified by the provided IGDB ID. Provide the SetFields functional option if you need to specify which fields to retrieve. If the ID does not match any CompanyWebsites, an error is returned.

func (*CompanyWebsiteService) Index 

func (zs *CompanyWebsiteService) Index(opts ...Option) ([]*CompanyWebsite, error)

Index returns an index of CompanyWebsites based solely on the provided functional options used to sort, filter, and paginate the results. If no CompanyWebsites can be found using the provided options, an error is returned.

func (*CompanyWebsiteService) List 

func (zs *CompanyWebsiteService) List(ids []int, opts ...Option) ([]*CompanyWebsite, error)

List returns a list of CompanyWebsites identified by the provided list of IGDB IDs. Provide functional options to sort, filter, and paginate the results. Any ID that does not match a CompanyWebsite is ignored. If none of the IDs match a CompanyWebsite, an error is returned.

type Count 

type Count struct {
	Count int `json:"count"`
}

Count contains the number of objects of a certain type counted in the IGDB.

type Cover 

type Cover struct {
	Image
	ID   int `json:"id"`
	Game int `json:"game"`
}

Cover represents the cover art for a specific video game. For more information visit: https://api-docs.igdb.com/#cover

type CoverService 

type CoverService service

CoverService handles all the API calls for the IGDB Cover endpoint.

func (*CoverService) Count 

func (cs *CoverService) Count(opts ...Option) (int, error)

Count returns the number of Covers available in the IGDB. Provide the SetFilter functional option if you need to filter which Covers to count.

func (*CoverService) Fields 

func (cs *CoverService) Fields() ([]string, error)

Fields returns the up-to-date list of fields in an IGDB Cover object.

func (*CoverService) Get 

func (cs *CoverService) Get(id int, opts ...Option) (*Cover, error)

Get returns a single Cover identified by the provided IGDB ID. Provide the SetFields functional option if you need to specify which fields to retrieve. If the ID does not match any Covers, an error is returned.

func (*CoverService) Index 

func (cs *CoverService) Index(opts ...Option) ([]*Cover, error)

Index returns an index of Covers based solely on the provided functional options used to sort, filter, and paginate the results. If no Covers can be found using the provided options, an error is returned.

func (*CoverService) List 

func (cs *CoverService) List(ids []int, opts ...Option) ([]*Cover, error)

List returns a list of Covers identified by the provided list of IGDB IDs. Provide functional options to sort, filter, and paginate the results. Any ID that does not match a Cover is ignored. If none of the IDs match a Cover, an error is returned.

type Credit 

type Credit struct {
	ID                    int            `json:"id"`
	Category              CreditCategory `json:"category"`
	Character             int            `json:"character"`
	CharacterCreditedName string         `json:"character_credited_name"`
	Comment               string         `json:"comment"`
	Company               int            `json:"company"`
	Country               int            `json:"country"`
	CreatedAt             int            `json:"created_at"`
	CreditedName          string         `json:"credited_name"`
	Game                  int            `json:"game"`
	Person                int            `json:"person"`
	PersonTitle           int            `json:"person_title"`
	Position              int            `json:"position"`
	UpdatedAt             int            `json:"updated_at"`
}

Credit represents an employee responsible for working on a particular game. For more information visit: https://api-docs.igdb.com/#credit

type CreditCategory 

type CreditCategory int

CreditCategory specifies a specific job or role within a company. 

const (
	CreditVoiceActor CreditCategory = iota + 1
	CreditLanguage
	CreditCompany
	CreditEmployee
	CreditMisc
	CreditSupportCompany
)

Expected CreditCategory enums from the IGDB.

func (CreditCategory) String 

func (i CreditCategory) String() string

type CreditService 

type CreditService service

CreditService handles all the API calls for the IGDB Credit endpoint.

func (*CreditService) Count 

func (cs *CreditService) Count(opts ...Option) (int, error)

Count returns the number of Credits available in the IGDB. Provide the SetFilter functional option if you need to filter which Credits to count.

func (*CreditService) Fields 

func (cs *CreditService) Fields() ([]string, error)

Fields returns the up-to-date list of fields in an IGDB Credit object.

func (*CreditService) Get 

func (cs *CreditService) Get(id int, opts ...Option) (*Credit, error)

Get returns a single Credit identified by the provided IGDB ID. Provide the SetFields functional option if you need to specify which fields to retrieve. If the ID does not match any Credits, an error is returned.

func (*CreditService) Index 

func (cs *CreditService) Index(opts ...Option) ([]*Credit, error)

Index returns an index of Credits based solely on the provided functional options used to sort, filter, and paginate the results. If no Credits can be found using the provided options, an error is returned.

func (*CreditService) List 

func (cs *CreditService) List(ids []int, opts ...Option) ([]*Credit, error)

List returns a list of Credits identified by the provided list of IGDB IDs. Provide functional options to sort, filter, and paginate the results. Any ID that does not match a Credit is ignored. If none of the IDs match a Credit, an error is returned.

type DateCategory 

type DateCategory int

DateCategory specifies the format of a release date. 

const (
	DateYYYYMMMMDD DateCategory = iota
	DateYYYYMMMM
	DateYYYY
	DateYYYYQ1
	DateYYYYQ2
	DateYYYYQ3
	DateYYYYQ4
	DateTBD
)

Expected DateCategory enums from the IGDB.

func (DateCategory) String 

func (i DateCategory) String() string

type ExternalGame 

type ExternalGame struct {
	ID        int                  `json:"id"`
	Category  ExternalGameCategory `json:"category"`
	CreatedAt int                  `json:"created_at"`
	Game      int                  `json:"game"`
	Name      string               `json:"name"`
	UID       string               `json:"uid"`
	UpdatedAt int                  `json:"updated_at"`
	Url       string               `json:"url"`
	Year      int                  `json:"year"`
}

ExternalGame contains the ID and other metadata for a game on a third party service. For more information visit: https://api-docs.igdb.com/#external-game

type ExternalGameCategory 

type ExternalGameCategory int

ExternalGameCategory speficies an external game, platform, or media service. 

const (
	ExternalSteam ExternalGameCategory = iota + 1

	ExternalGOG

	ExternalYoutube
	ExternalMicrosoft

	ExternalApple
	ExternalTwitch
	ExternalAndroid
)

Expected ExternalGameCategory enums from the IGDB.

func (ExternalGameCategory) String 

func (i ExternalGameCategory) String() string

type ExternalGameService 

type ExternalGameService service

ExternalGameService handles all the API calls for the IGDB ExternalGame endpoint. This endpoint is only available for the IGDB Pro tier or above.

func (*ExternalGameService) Count 

func (es *ExternalGameService) Count(opts ...Option) (int, error)

Count returns the number of ExternalGames available in the IGDB. Provide the SetFilter functional option if you need to filter which ExternalGames to count.

func (*ExternalGameService) Fields 

func (es *ExternalGameService) Fields() ([]string, error)

Fields returns the up-to-date list of fields in an IGDB ExternalGame object.

func (*ExternalGameService) Get 

func (es *ExternalGameService) Get(id int, opts ...Option) (*ExternalGame, error)

Get returns a single ExternalGame identified by the provided IGDB ID. Provide the SetFields functional option if you need to specify which fields to retrieve. If the ID does not match any ExternalGames, an error is returned.

func (*ExternalGameService) Index 

func (es *ExternalGameService) Index(opts ...Option) ([]*ExternalGame, error)

Index returns an index of ExternalGames based solely on the provided functional options used to sort, filter, and paginate the results. If no ExternalGames can be found using the provided options, an error is returned.

func (*ExternalGameService) List 

func (es *ExternalGameService) List(ids []int, opts ...Option) ([]*ExternalGame, error)

List returns a list of ExternalGames identified by the provided list of IGDB IDs. Provide functional options to sort, filter, and paginate the results. Any ID that does not match a ExternalGame is ignored. If none of the IDs match a ExternalGame, an error is returned.

type Feed 

type Feed struct {
	ID             int          `json:"id"`
	Category       FeedCategory `json:"category"`
	Content        string       `json:"content"`
	CreatedAt      int          `json:"created_at"`
	FeedLikesCount int          `json:"feed_likes_count"`
	FeedVideo      int          `json:"feed_video"`
	Games          []int        `json:"games"`
	Meta           string       `json:"meta"`
	PublishedAt    int          `json:"published_at"`
	Pulse          int          `json:"pulse"`
	Slug           string       `json:"slug"`
	Title          string       `json:"title"`
	UID            string       `json:"uid"`
	UpdatedAt      int          `json:"updated_at"`
	URL            string       `json:"url"`
	User           int          `json:"user"`
}

Feed items are a social feed of status updates, media, and news articles. For more information visit: https://api-docs.igdb.com/#feed

type FeedCategory 

type FeedCategory int

FeedCategory specifies a specific type of media. 

const (
	FeedPulseArticle FeedCategory = iota + 1
	FeedComingSoon
	FeedNewTrailer

	FeedUserContributedItem
	FeedUserContributionsItem
	FeedPageContributedItem
)

Expected FeedCategory enums from the IGDB.

func (FeedCategory) String 

func (i FeedCategory) String() string

type FeedFollow 

type FeedFollow struct {
	ID          int          `json:"id"`
	CreatedAt   int          `json:"created_at"`
	Feed        FeedCategory `json:"feed"`
	PublishedAt int          `json:"published_at"`
	UpdatedAt   int          `json:"updated_at"`
	User        int          `json:"user"`
}

FeedFollow represents the following of social feed composed of status updates, media, and news articles. For more information visit: https://api-docs.igdb.com/#feed-follow

type FeedFollowService 

type FeedFollowService service

FeedFollowService handles all the API calls for the IGDB FeedFollow endpoint.

func (*FeedFollowService) Count 

func (fs *FeedFollowService) Count(opts ...Option) (int, error)

Count returns the number of FeedFollows available in the IGDB. Provide the SetFilter functional option if you need to filter which FeedFollows to count.

func (*FeedFollowService) Fields 

func (fs *FeedFollowService) Fields() ([]string, error)

Fields returns the up-to-date list of fields in an IGDB FeedFollow object.

func (*FeedFollowService) Get 

func (fs *FeedFollowService) Get(id int, opts ...Option) (*FeedFollow, error)

Get returns a single FeedFollow identified by the provided IGDB ID. Provide the SetFields functional option if you need to specify which fields to retrieve. If the ID does not match any FeedFollows, an error is returned.

func (*FeedFollowService) Index 

func (fs *FeedFollowService) Index(opts ...Option) ([]*FeedFollow, error)

Index returns an index of FeedFollows based solely on the provided functional options used to sort, filter, and paginate the results. If no FeedFollows can be found using the provided options, an error is returned.

func (*FeedFollowService) List 

func (fs *FeedFollowService) List(ids []int, opts ...Option) ([]*FeedFollow, error)

List returns a list of FeedFollows identified by the provided list of IGDB IDs. Provide functional options to sort, filter, and paginate the results. Any ID that does not match a FeedFollow is ignored. If none of the IDs match a FeedFollow, an error is returned.

type FeedService 

type FeedService service

FeedService handles all the API calls for the IGDB Feed endpoint.

func (*FeedService) Count 

func (fs *FeedService) Count(opts ...Option) (int, error)

Count returns the number of Feeds available in the IGDB. Provide the SetFilter functional option if you need to filter which Feeds to count.

func (*FeedService) Fields 

func (fs *FeedService) Fields() ([]string, error)

Fields returns the up-to-date list of fields in an IGDB Feed object.

func (*FeedService) Get 

func (fs *FeedService) Get(id int, opts ...Option) (*Feed, error)

Get returns a single Feed identified by the provided IGDB ID. Provide the SetFields functional option if you need to specify which fields to retrieve. If the ID does not match any Feeds, an error is returned.

func (*FeedService) Index 

func (fs *FeedService) Index(opts ...Option) ([]*Feed, error)

Index returns an index of Feeds based solely on the provided functional options used to sort, filter, and paginate the results. If no Feeds can be found using the provided options, an error is returned.

func (*FeedService) List 

func (fs *FeedService) List(ids []int, opts ...Option) ([]*Feed, error)

List returns a list of Feeds identified by the provided list of IGDB IDs. Provide functional options to sort, filter, and paginate the results. Any ID that does not match a Feed is ignored. If none of the IDs match a Feed, an error is returned.

type Follow 

type Follow struct {
	ID   int `json:"id"`
	Game int `json:"game"`
	User int `json:"user"`
}

Follow represents a particular user's following of a particular game. For more information visit: https://api-docs.igdb.com/#follow

type FollowService 

type FollowService service

FollowService handles all the API calls for the IGDB Follow endpoint.

func (*FollowService) Count 

func (fs *FollowService) Count(opts ...Option) (int, error)

Count returns the number of Follows available in the IGDB. Provide the SetFilter functional option if you need to filter which Follows to count.

func (*FollowService) Fields 

func (fs *FollowService) Fields() ([]string, error)

Fields returns the up-to-date list of fields in an IGDB Follow object.

func (*FollowService) Get 

func (fs *FollowService) Get(id int, opts ...Option) (*Follow, error)

Get returns a single Follow identified by the provided IGDB ID. Provide the SetFields functional option if you need to specify which fields to retrieve. If the ID does not match any Follows, an error is returned.

func (*FollowService) Index 

func (fs *FollowService) Index(opts ...Option) ([]*Follow, error)

Index returns an index of Follows based solely on the provided functional options used to sort, filter, and paginate the results. If no Follows can be found using the provided options, an error is returned.

func (*FollowService) List 

func (fs *FollowService) List(ids []int, opts ...Option) ([]*Follow, error)

List returns a list of Follows identified by the provided list of IGDB IDs. Provide functional options to sort, filter, and paginate the results. Any ID that does not match a Follow is ignored. If none of the IDs match a Follow, an error is returned.

type Franchise 

type Franchise struct {
	ID        int    `json:"id"`
	CreatedAt int    `json:"created_at"`
	Name      string `json:"name"`
	Slug      string `json:"slug"`
	UpdatedAt int    `json:"updated_at"`
	Url       string `json:"url"`
}

Franchise is a list of video game franchises such as Star Wars. For more information visit: https://api-docs.igdb.com/#franchise

type FranchiseService 

type FranchiseService service

FranchiseService handles all the API calls for the IGDB Franchise endpoint.

func (*FranchiseService) Count 

func (fs *FranchiseService) Count(opts ...Option) (int, error)

Count returns the number of Franchises available in the IGDB. Provide the SetFilter functional option if you need to filter which Franchises to count.

func (*FranchiseService) Fields 

func (fs *FranchiseService) Fields() ([]string, error)

Fields returns the up-to-date list of fields in an IGDB Franchise object.

func (*FranchiseService) Get 

func (fs *FranchiseService) Get(id int, opts ...Option) (*Franchise, error)

Get returns a single Franchise identified by the provided IGDB ID. Provide the SetFields functional option if you need to specify which fields to retrieve. If the ID does not match any Franchises, an error is returned.

func (*FranchiseService) Index 

func (fs *FranchiseService) Index(opts ...Option) ([]*Franchise, error)

Index returns an index of Franchises based solely on the provided functional options used to sort, filter, and paginate the results. If no Franchises can be found using the provided options, an error is returned.

func (*FranchiseService) List 

func (fs *FranchiseService) List(ids []int, opts ...Option) ([]*Franchise, error)

List returns a list of Franchises identified by the provided list of IGDB IDs. Provide functional options to sort, filter, and paginate the results. Any ID that does not match a Franchise is ignored. If none of the IDs match a Franchise, an error is returned.

type Game 

type Game struct {
	ID                    int          `json:"id"`
	AgeRatings            []int        `json:"age_ratings"`
	AggregatedRating      float64      `json:"aggregated_rating"`
	AggregatedRatingCount int          `json:"aggregated_rating_count"`
	AlternativeNames      []int        `json:"alternative_names"`
	Artworks              []int        `json:"artworks"`
	Bundles               []int        `json:"bundles"`
	Category              GameCategory `json:"category"`
	Collection            int          `json:"collection"`
	Cover                 int          `json:"cover"`
	CreatedAt             int          `json:"created_at"`
	DLCS                  []int        `json:"dlcs"`
	Expansions            []int        `json:"expansions"`
	ExternalGames         []int        `json:"external_games"`
	FirstReleaseDate      int          `json:"first_release_date"`
	Follows               int          `json:"follows"`
	Franchise             int          `json:"franchise"`
	Franchises            []int        `json:"franchises"`
	GameEngines           []int        `json:"game_engines"`
	GameModes             []int        `json:"game_modes"`
	Genres                []int        `json:"genres"`
	Hypes                 int          `json:"hypes"`
	InvolvedCompanies     []int        `json:"involved_companies"`
	Keywords              []int        `json:"keywords"`
	MultiplayerModes      []int        `json:"multiplayer_modes"`
	Name                  string       `json:"name"`
	ParentGame            int          `json:"parent_game"`
	Platforms             []int        `json:"platforms"`
	PlayerPerspectives    []int        `json:"player_perspectives"`
	Popularity            float64      `json:"popularity"`
	PulseCount            int          `json:"pulse_count"`
	Rating                float64      `json:"rating"`
	RatingCount           int          `json:"rating_count"`
	ReleaseDates          []int        `json:"release_dates"`
	Screenshots           []int        `json:"screenshots"`
	SimilarGames          []int        `json:"similar_games"`
	Slug                  string       `json:"slug"`
	StandaloneExpansions  []int        `json:"standalone_expansions"`
	Status                GameStatus   `json:"status"`
	Storyline             string       `json:"storyline"`
	Summary               string       `json:"summary"`
	Tags                  []Tag        `json:"tags"`
	Themes                []int        `json:"themes"`
	TimeToBeat            int          `json:"time_to_beat"`
	TotalRating           float64      `json:"total_rating"`
	TotalRatingCount      int          `json:"total_rating_count"`
	UpdatedAt             int          `json:"updated_at"`
	URL                   string       `json:"url"`
	VersionParent         int          `json:"version_parent"`
	VersionTitle          string       `json:"version_title"`
	Videos                []int        `json:"videos"`
	Websites              []int        `json:"websites"`
}

Game contains information on an IGDB entry for a particular video game. For more information visit: https://api-docs.igdb.com/#game

type GameCategory 

type GameCategory int

GameCategory specifies a type of game content. 

const (
	MainGame GameCategory = iota
	DLCAddon
	Expansion
	Bundle
	StandaloneExpansion
)

Expected GameCategory enums from the IGDB.

func (GameCategory) String 

func (i GameCategory) String() string

type GameEngine 

type GameEngine struct {
	ID          int    `json:"id"`
	Companies   []int  `json:"companies"`
	CreatedAt   int    `json:"created_at"`
	Description string `json:"description"`
	Name        string `json:"name"`
	Platforms   []int  `json:"platforms"`
	Slug        string `json:"slug"`
	UpdatedAt   int    `json:"updated_at"`
	URL         string `json:"url"`
}

GameEngine represents a video game engine such as Unreal Engine. For more information visit: https://api-docs.igdb.com/#game-engine 

type GameEngineLogo struct {
	Image
	ID int `json:"id"`
}

GameEngineLogo represents the logo of a particular game engine. For more information visit: https://api-docs.igdb.com/#game-engine-logo

type GameEngineLogoService 

type GameEngineLogoService service

GameEngineLogoService handles all the API calls for the IGDB GameEngineLogo endpoint.

func (*GameEngineLogoService) Count 

func (gs *GameEngineLogoService) Count(opts ...Option) (int, error)

Count returns the number of GameEngineLogos available in the IGDB. Provide the SetFilter functional option if you need to filter which GameEngineLogos to count.

func (*GameEngineLogoService) Fields 

func (gs *GameEngineLogoService) Fields() ([]string, error)

Fields returns the up-to-date list of fields in an IGDB GameEngineLogo object.

func (*GameEngineLogoService) Get 

func (gs *GameEngineLogoService) Get(id int, opts ...Option) (*GameEngineLogo, error)

Get returns a single GameEngineLogo identified by the provided IGDB ID. Provide the SetFields functional option if you need to specify which fields to retrieve. If the ID does not match any GameEngineLogos, an error is returned.

func (*GameEngineLogoService) Index 

func (gs *GameEngineLogoService) Index(opts ...Option) ([]*GameEngineLogo, error)

Index returns an index of GameEngineLogos based solely on the provided functional options used to sort, filter, and paginate the results. If no GameEngineLogos can be found using the provided options, an error is returned.

func (*GameEngineLogoService) List 

func (gs *GameEngineLogoService) List(ids []int, opts ...Option) ([]*GameEngineLogo, error)

List returns a list of GameEngineLogos identified by the provided list of IGDB IDs. Provide functional options to sort, filter, and paginate the results. Any ID that does not match a GameEngineLogo is ignored. If none of the IDs match a GameEngineLogo, an error is returned.

type GameEngineService 

type GameEngineService service

GameEngineService handles all the API calls for the IGDB GameEngine endpoint.

func (*GameEngineService) Count 

func (gs *GameEngineService) Count(opts ...Option) (int, error)

Count returns the number of GameEngines available in the IGDB. Provide the SetFilter functional option if you need to filter which GameEngines to count.

func (*GameEngineService) Fields 

func (gs *GameEngineService) Fields() ([]string, error)

Fields returns the up-to-date list of fields in an IGDB GameEngine object.

func (*GameEngineService) Get 

func (gs *GameEngineService) Get(id int, opts ...Option) (*GameEngine, error)

Get returns a single GameEngine identified by the provided IGDB ID. Provide the SetFields functional option if you need to specify which fields to retrieve. If the ID does not match any GameEngines, an error is returned.

func (*GameEngineService) Index 

func (gs *GameEngineService) Index(opts ...Option) ([]*GameEngine, error)

Index returns an index of GameEngines based solely on the provided functional options used to sort, filter, and paginate the results. If no GameEngines can be found using the provided options, an error is returned.

func (*GameEngineService) List 

func (gs *GameEngineService) List(ids []int, opts ...Option) ([]*GameEngine, error)

List returns a list of GameEngines identified by the provided list of IGDB IDs. Provide functional options to sort, filter, and paginate the results. Any ID that does not match a GameEngine is ignored. If none of the IDs match a GameEngine, an error is returned.

type GameMode 

type GameMode struct {
	CreatedAt int    `json:"created_at"`
	Name      string `json:"name"`
	Slug      string `json:"slug"`
	UpdatedAt int    `json:"updated_at"`
	URL       string `json:"url"`
}

GameMode represents a video game mode such as single or multi player. For more information visit: https://api-docs.igdb.com/#game-mode

type GameModeService 

type GameModeService service

GameModeService handles all the API calls for the IGDB GameMode endpoint.

func (*GameModeService) Count 

func (gs *GameModeService) Count(opts ...Option) (int, error)

Count returns the number of GameModes available in the IGDB. Provide the SetFilter functional option if you need to filter which GameModes to count.

func (*GameModeService) Fields 

func (gs *GameModeService) Fields() ([]string, error)

Fields returns the up-to-date list of fields in an IGDB GameMode object.

func (*GameModeService) Get 

func (gs *GameModeService) Get(id int, opts ...Option) (*GameMode, error)

Get returns a single GameMode identified by the provided IGDB ID. Provide the SetFields functional option if you need to specify which fields to retrieve. If the ID does not match any GameModes, an error is returned.

func (*GameModeService) Index 

func (gs *GameModeService) Index(opts ...Option) ([]*GameMode, error)

Index returns an index of GameModes based solely on the provided functional options used to sort, filter, and paginate the results. If no GameModes can be found using the provided options, an error is returned.

func (*GameModeService) List 

func (gs *GameModeService) List(ids []int, opts ...Option) ([]*GameMode, error)

List returns a list of GameModes identified by the provided list of IGDB IDs. Provide functional options to sort, filter, and paginate the results. Any ID that does not match a GameMode is ignored. If none of the IDs match a GameMode, an error is returned.

type GameService 

type GameService service

GameService handles all the API calls for the IGDB Game endpoint.

func (*GameService) Count 

func (gs *GameService) Count(opts ...Option) (int, error)

Count returns the number of Games available in the IGDB. Provide the SetFilter functional option if you need to filter which Games to count.

Example 
c := NewClient("YOUR_API_KEY", nil)

ct, err := c.Games.Count(SetFilter("created_at", OpGreaterThan, "1993-12-15"))
if err != nil {
	fmt.Println(err)
	return
}

fmt.Println("Number of games created after December 15, 1993: ", ct)

Output:

func (*GameService) Fields 

func (gs *GameService) Fields() ([]string, error)

Fields returns the up-to-date list of fields in an IGDB Game object.

Example 
c := NewClient("YOUR_API_KEY", nil)

fl, err := c.Games.Fields()
if err != nil {
	fmt.Println(err)
	return
}

fmt.Println("List of available fields for the IGDB Game object: ", fl)

Output:

func (*GameService) Get 

func (gs *GameService) Get(id int, opts ...Option) (*Game, error)

Get returns a single Game identified by the provided IGDB ID. Provide the SetFields functional option if you need to specify which fields to retrieve. If the ID does not match any Games, an error is returned.

Example 
c := NewClient("YOUR_API_KEY", nil)

g, err := c.Games.Get(7346, SetFields("name", "url", "summary", "storyline", "rating", "popularity", "cover"))
if err != nil {
	fmt.Println(err)
	return
}

fmt.Println("IGDB entry for The Legend of Zelda: Breath of the Wild\n", *g)

Output:

func (*GameService) Index 

func (gs *GameService) Index(opts ...Option) ([]*Game, error)

Index returns an index of Games based solely on the provided functional options used to sort, filter, and paginate the results. If no Games can be found using the provided options, an error is returned.

Example 
c := NewClient("YOUR_API_KEY", nil)

g, err := c.Games.Index(
	SetLimit(5),
	SetFilter("popularity", OpGreaterThan, "80"),
)
if err != nil {
	fmt.Println(err)
	return
}

fmt.Println("IGDB entries for 5 Games with popularity above 80")
for _, v := range g {
	fmt.Println(*v)
}

Output:

func (*GameService) List 

func (gs *GameService) List(ids []int, opts ...Option) ([]*Game, error)

List returns a list of Games identified by the provided list of IGDB IDs. Provide functional options to sort, filter, and paginate the results. Any ID that does not match a Game is ignored. If none of the IDs match a Game, an error is returned.

Example 
c := NewClient("YOUR_API_KEY", nil)

g, err := c.Games.List([]int{1721, 2777, 1074})
if err != nil {
	fmt.Println(err)
	return
}

fmt.Println("IGDB entries for Megaman 8, Kirby Air Ride, and Super Mario 64")
for _, v := range g {
	fmt.Println(*v)
}

Output:

func (*GameService) Search 

func (gs *GameService) Search(qry string, opts ...Option) ([]*Game, error)

Search returns a list of Games found by searching the IGDB using the provided query. Provide functional options to sort, filter, and paginate the results. If no Games are found using the provided query, an error is returned.

Example 
c := NewClient("YOUR_API_KEY", nil)

g, err := c.Games.Search(
	"mario",
	SetFields("*"),
	SetFilter("rating", OpGreaterThanEqual, "80"),
	SetOrder("rating", OrderDescending),
	SetLimit(3))
if err != nil {
	fmt.Println(err)
	return
}

fmt.Println("IGDB entries for Super Mario 64, Mario Kart 8, and Mario Party")
for _, v := range g {
	fmt.Println(*v)
}

Output:

type GameStatus 

type GameStatus int

GameStatus specifies the release status of a specific game. 

const (
	StatusReleased GameStatus = iota

	StatusAlpha
	StatusBeta
	StatusEarlyAccess
	StatusOffline
	StatusCancelled
)

Expected GameStatus enums from the IGDB.

func (GameStatus) String 

func (i GameStatus) String() string

type GameVersion 

type GameVersion struct {
	CreatedAt int    `json:"created_at"`
	Features  []int  `json:"features"`
	Game      int    `json:"game"`
	Games     []int  `json:"games"`
	UpdatedAt int    `json:"updated_at"`
	URL       string `json:"url"`
}

GameVersion provides details about game editions and versions. For more information visit: https://api-docs.igdb.com/#game-version

type GameVersionFeature 

type GameVersionFeature struct {
	ID          int                    `json:"id"`
	Category    VersionFeatureCategory `json:"category"`
	Description string                 `json:"description"`
	Position    int                    `json:"position"`
	Title       string                 `json:"title"`
	Values      []int                  `json:"values"`
}

GameVersionFeature represents features and descriptions of what makes each version/edition different from their main game. For more information visit: https://api-docs.igdb.com/#game-version-feature

type GameVersionFeatureService 

type GameVersionFeatureService service

GameVersionFeatureService handles all the API calls for the IGDB GameVersionFeature endpoint.

func (*GameVersionFeatureService) Count 

func (gs *GameVersionFeatureService) Count(opts ...Option) (int, error)

Count returns the number of GameVersionFeatures available in the IGDB. Provide the SetFilter functional option if you need to filter which GameVersionFeatures to count.

func (*GameVersionFeatureService) Fields 

func (gs *GameVersionFeatureService) Fields() ([]string, error)

Fields returns the up-to-date list of fields in an IGDB GameVersionFeature object.

func (*GameVersionFeatureService) Get 

func (gs *GameVersionFeatureService) Get(id int, opts ...Option) (*GameVersionFeature, error)

Get returns a single GameVersionFeature identified by the provided IGDB ID. Provide the SetFields functional option if you need to specify which fields to retrieve. If the ID does not match any GameVersionFeatures, an error is returned.

func (*GameVersionFeatureService) Index 

func (gs *GameVersionFeatureService) Index(opts ...Option) ([]*GameVersionFeature, error)

Index returns an index of GameVersionFeatures based solely on the provided functional options used to sort, filter, and paginate the results. If no GameVersionFeatures can be found using the provided options, an error is returned.

func (*GameVersionFeatureService) List 

func (gs *GameVersionFeatureService) List(ids []int, opts ...Option) ([]*GameVersionFeature, error)

List returns a list of GameVersionFeatures identified by the provided list of IGDB IDs. Provide functional options to sort, filter, and paginate the results. Any ID that does not match a GameVersionFeature is ignored. If none of the IDs match a GameVersionFeature, an error is returned.

type GameVersionFeatureValue 

type GameVersionFeatureValue struct {
	ID              int                     `json:"id"`
	Game            int                     `json:"game"`
	GameFeature     int                     `json:"game_feature"`
	IncludedFeature VersionFeatureInclusion `json:"included_feature"`
	Note            string                  `json:"note"`
}

GameVersionFeatureValue represents the bool/text value of a particular feature. For more information visit: https://api-docs.igdb.com/#game-version-feature-value

type GameVersionFeatureValueService 

type GameVersionFeatureValueService service

GameVersionFeatureValueService handles all the API calls for the IGDB GameVersionFeatureValue endpoint.

func (*GameVersionFeatureValueService) Count 

func (gs *GameVersionFeatureValueService) Count(opts ...Option) (int, error)

Count returns the number of GameVersionFeatureValues available in the IGDB. Provide the SetFilter functional option if you need to filter which GameVersionFeatureValues to count.

func (*GameVersionFeatureValueService) Fields 

func (gs *GameVersionFeatureValueService) Fields() ([]string, error)

Fields returns the up-to-date list of fields in an IGDB GameVersionFeatureValue object.

func (*GameVersionFeatureValueService) Get 

func (gs *GameVersionFeatureValueService) Get(id int, opts ...Option) (*GameVersionFeatureValue, error)

Get returns a single GameVersionFeatureValue identified by the provided IGDB ID. Provide the SetFields functional option if you need to specify which fields to retrieve. If the ID does not match any GameVersionFeatureValues, an error is returned.

func (*GameVersionFeatureValueService) Index 

func (gs *GameVersionFeatureValueService) Index(opts ...Option) ([]*GameVersionFeatureValue, error)

Index returns an index of GameVersionFeatureValues based solely on the provided functional options used to sort, filter, and paginate the results. If no GameVersionFeatureValues can be found using the provided options, an error is returned.

func (*GameVersionFeatureValueService) List 

func (gs *GameVersionFeatureValueService) List(ids []int, opts ...Option) ([]*GameVersionFeatureValue, error)

List returns a list of GameVersionFeatureValues identified by the provided list of IGDB IDs. Provide functional options to sort, filter, and paginate the results. Any ID that does not match a GameVersionFeatureValue is ignored. If none of the IDs match a GameVersionFeatureValue, an error is returned.

type GameVersionService 

type GameVersionService service

GameVersionService handles all the API calls for the IGDB GameVersion endpoint.

func (*GameVersionService) Count 

func (gs *GameVersionService) Count(opts ...Option) (int, error)

Count returns the number of GameVersions available in the IGDB. Provide the SetFilter functional option if you need to filter which GameVersions to count.

func (*GameVersionService) Fields 

func (gs *GameVersionService) Fields() ([]string, error)

Fields returns the up-to-date list of fields in an IGDB GameVersion object.

func (*GameVersionService) Get 

func (gs *GameVersionService) Get(id int, opts ...Option) (*GameVersion, error)

Get returns a single GameVersion identified by the provided IGDB ID. Provide the SetFields functional option if you need to specify which fields to retrieve. If the ID does not match any GameVersions, an error is returned.

func (*GameVersionService) Index 

func (gs *GameVersionService) Index(opts ...Option) ([]*GameVersion, error)

Index returns an index of GameVersions based solely on the provided functional options used to sort, filter, and paginate the results. If no GameVersions can be found using the provided options, an error is returned.

func (*GameVersionService) List 

func (gs *GameVersionService) List(ids []int, opts ...Option) ([]*GameVersion, error)

List returns a list of GameVersions identified by the provided list of IGDB IDs. Provide functional options to sort, filter, and paginate the results. Any ID that does not match a GameVersion is ignored. If none of the IDs match a GameVersion, an error is returned.

type GameVideo 

type GameVideo struct {
	Game    int    `json:"game"`
	Name    string `json:"name"`
	VideoID string `json:"video_id"`
}

GameVideo represents a video associated with a particular game. For more information visit: https://api-docs.igdb.com/#game-video

type GameVideoService 

type GameVideoService service

GameVideoService handles all the API calls for the IGDB GameVideo endpoint.

func (*GameVideoService) Count 

func (gs *GameVideoService) Count(opts ...Option) (int, error)

Count returns the number of GameVideos available in the IGDB. Provide the SetFilter functional option if you need to filter which GameVideos to count.

func (*GameVideoService) Fields 

func (gs *GameVideoService) Fields() ([]string, error)

Fields returns the up-to-date list of fields in an IGDB GameVideo object.

func (*GameVideoService) Get 

func (gs *GameVideoService) Get(id int, opts ...Option) (*GameVideo, error)

Get returns a single GameVideo identified by the provided IGDB ID. Provide the SetFields functional option if you need to specify which fields to retrieve. If the ID does not match any GameVideos, an error is returned.

func (*GameVideoService) Index 

func (gs *GameVideoService) Index(opts ...Option) ([]*GameVideo, error)

Index returns an index of GameVideos based solely on the provided functional options used to sort, filter, and paginate the results. If no GameVideos can be found using the provided options, an error is returned.

func (*GameVideoService) List 

func (gs *GameVideoService) List(ids []int, opts ...Option) ([]*GameVideo, error)

List returns a list of GameVideos identified by the provided list of IGDB IDs. Provide functional options to sort, filter, and paginate the results. Any ID that does not match a GameVideo is ignored. If none of the IDs match a GameVideo, an error is returned.

type Genre 

type Genre struct {
	ID        int    `json:"id"`
	CreatedAt int    `json:"created_at"`
	Name      string `json:"name"`
	Slug      string `json:"slug"`
	UpdatedAt int    `json:"updated_at"`
	URL       string `json:"url"`
}

Genre represents the genre of a particular video game. For more information visit: https://api-docs.igdb.com/#genre

type GenreService 

type GenreService service

GenreService handles all the API calls for the IGDB Genre endpoint.

func (*GenreService) Count 

func (gs *GenreService) Count(opts ...Option) (int, error)

Count returns the number of Genres available in the IGDB. Provide the SetFilter functional option if you need to filter which Genres to count.

func (*GenreService) Fields 

func (gs *GenreService) Fields() ([]string, error)

Fields returns the up-to-date list of fields in an IGDB Genre object.

func (*GenreService) Get 

func (gs *GenreService) Get(id int, opts ...Option) (*Genre, error)

Get returns a single Genre identified by the provided IGDB ID. Provide the SetFields functional option if you need to specify which fields to retrieve. If the ID does not match any Genres, an error is returned.

func (*GenreService) Index 

func (gs *GenreService) Index(opts ...Option) ([]*Genre, error)

Index returns an index of Genres based solely on the provided functional options used to sort, filter, and paginate the results. If no Genres can be found using the provided options, an error is returned.

func (*GenreService) List 

func (gs *GenreService) List(ids []int, opts ...Option) ([]*Genre, error)

List returns a list of Genres identified by the provided list of IGDB IDs. Provide functional options to sort, filter, and paginate the results. Any ID that does not match a Genre is ignored. If none of the IDs match a Genre, an error is returned.

type Image 

type Image struct {
	AlphaChannel bool   `json:"alpha_channel"`
	Animated     bool   `json:"animated"`
	Height       int    `json:"height"`
	ImageID      string `json:"image_id"`
	URL          string `json:"url"`
	Width        int    `json:"width"`
}

Image contains the URL, dimensions, and ID of a particular image. For more information visit: https://api-docs.igdb.com/#images

func (Image) SizedURL 

func (i Image) SizedURL(size imageSize, ratio int) (string, error)

SizedURL returns the URL of this image at the provided image size and display pixel ratio. The display pixel ratio only multiplies the resolution of the image. The current available ratios are 1 and 2.

type InvolvedCompany 

type InvolvedCompany struct {
	ID         int  `json:"id"`
	Company    int  `json:"company"`
	CreatedAt  int  `json:"created_at"`
	Developer  bool `json:"developer"`
	Game       int  `json:"game"`
	Porting    bool `json:"porting"`
	Publisher  bool `json:"publisher"`
	Supporting bool `json:"supporting"`
	UpdatedAt  int  `json:"updated_at"`
}

InvolvedCompany represents a company involved in the development of a particular video game. For more information visit: https://api-docs.igdb.com/#involved-company

type InvolvedCompanyService 

type InvolvedCompanyService service

InvolvedCompanyService handles all the API calls for the IGDB InvolvedCompany endpoint.

func (*InvolvedCompanyService) Count 

func (is *InvolvedCompanyService) Count(opts ...Option) (int, error)

Count returns the number of InvolvedCompanies available in the IGDB. Provide the SetFilter functional option if you need to filter which InvolvedCompanies to count.

func (*InvolvedCompanyService) Fields 

func (is *InvolvedCompanyService) Fields() ([]string, error)

Fields returns the up-to-date list of fields in an IGDB InvolvedCompany object.

func (*InvolvedCompanyService) Get 

func (is *InvolvedCompanyService) Get(id int, opts ...Option) (*InvolvedCompany, error)

Get returns a single InvolvedCompany identified by the provided IGDB ID. Provide the SetFields functional option if you need to specify which fields to retrieve. If the ID does not match any InvolvedCompanies, an error is returned.

func (*InvolvedCompanyService) Index 

func (is *InvolvedCompanyService) Index(opts ...Option) ([]*InvolvedCompany, error)

Index returns an index of InvolvedCompanies based solely on the provided functional options used to sort, filter, and paginate the results. If no InvolvedCompanies can be found using the provided options, an error is returned.

func (*InvolvedCompanyService) List 

func (is *InvolvedCompanyService) List(ids []int, opts ...Option) ([]*InvolvedCompany, error)

List returns a list of InvolvedCompanies identified by the provided list of IGDB IDs. Provide functional options to sort, filter, and paginate the results. Any ID that does not match a InvolvedCompany is ignored. If none of the IDs match a InvolvedCompany, an error is returned.

type Keyword 

type Keyword struct {
	CreatedAt int    `json:"created_at"`
	Name      string `json:"name"`
	Slug      string `json:"slug"`
	UpdatedAt int    `json:"updated_at"`
	Url       string `json:"url"`
}

Keyword represents a word or phrase that get tagged to a game such as "World War 2" or "Steampunk". For more information visit: https://api-docs.igdb.com/#keyword

type KeywordService 

type KeywordService service

KeywordService handles all the API calls for the IGDB Keyword endpoint.

func (*KeywordService) Count 

func (ks *KeywordService) Count(opts ...Option) (int, error)

Count returns the number of Keywords available in the IGDB. Provide the SetFilter functional option if you need to filter which Keywords to count.

func (*KeywordService) Fields 

func (ks *KeywordService) Fields() ([]string, error)

Fields returns the up-to-date list of fields in an IGDB Keyword object.

func (*KeywordService) Get 

func (ks *KeywordService) Get(id int, opts ...Option) (*Keyword, error)

Get returns a single Keyword identified by the provided IGDB ID. Provide the SetFields functional option if you need to specify which fields to retrieve. If the ID does not match any Keywords, an error is returned.

func (*KeywordService) Index 

func (ks *KeywordService) Index(opts ...Option) ([]*Keyword, error)

Index returns an index of Keywords based solely on the provided functional options used to sort, filter, and paginate the results. If no Keywords can be found using the provided options, an error is returned.

func (*KeywordService) List 

func (ks *KeywordService) List(ids []int, opts ...Option) ([]*Keyword, error)

List returns a list of Keywords identified by the provided list of IGDB IDs. Provide functional options to sort, filter, and paginate the results. Any ID that does not match a Keyword is ignored. If none of the IDs match a Keyword, an error is returned.

type List 

type List struct {
	ID           int    `json:"id"`
	CreatedAt    int    `json:"created_at"`
	Description  string `json:"description"`
	EntriesCount int    `json:"entries_count"`
	ListEntries  []int  `json:"list_entries"`
	ListTags     []int  `json:"list_tags"`
	ListedGames  []int  `json:"listed_games"`
	Name         string `json:"name"`
	Numbering    bool   `json:"numbering"`
	Private      bool   `json:"private"`
	SimilarLists []int  `json:"similar_lists"`
	Slug         string `json:"slug"`
	UpdatedAt    int    `json:"updated_at"`
	URL          string `json:"url"`
	User         int    `json:"user"`
}

List represents a user-created list of games. For more information visit: https://api-docs.igdb.com/#list

type ListEntry 

type ListEntry struct {
	ID          int    `json:"id"`
	Description string `json:"description"`
	Game        int    `json:"game"`
	List        int    `json:"list"`
	Platform    int    `json:"platform"`
	Position    int    `json:"position"`
	Private     bool   `json:"private"`
	User        int    `json:"user"`
}

ListEntry represents an entry in a user-created list of games. For more information visit: https://api-docs.igdb.com/#list-entry

type ListEntryService 

type ListEntryService service

ListEntryService handles all the API calls for the IGDB ListEntry endpoint.

func (*ListEntryService) Count 

func (ls *ListEntryService) Count(opts ...Option) (int, error)

Count returns the number of ListEntrys available in the IGDB. Provide the SetFilter functional option if you need to filter which ListEntrys to count.

func (*ListEntryService) Fields 

func (ls *ListEntryService) Fields() ([]string, error)

Fields returns the up-to-date list of fields in an IGDB ListEntry object.

func (*ListEntryService) Get 

func (ls *ListEntryService) Get(id int, opts ...Option) (*ListEntry, error)

Get returns a single ListEntry identified by the provided IGDB ID. Provide the SetFields functional option if you need to specify which fields to retrieve. If the ID does not match any ListEntrys, an error is returned.

func (*ListEntryService) Index 

func (ls *ListEntryService) Index(opts ...Option) ([]*ListEntry, error)

Index returns an index of ListEntrys based solely on the provided functional options used to sort, filter, and paginate the results. If no ListEntrys can be found using the provided options, an error is returned.

func (*ListEntryService) List 

func (ls *ListEntryService) List(ids []int, opts ...Option) ([]*ListEntry, error)

List returns a list of ListEntrys identified by the provided list of IGDB IDs. Provide functional options to sort, filter, and paginate the results. Any ID that does not match a ListEntry is ignored. If none of the IDs match a ListEntry, an error is returned.

type ListService 

type ListService service

ListService handles all the API calls for the IGDB List endpoint.

func (*ListService) Count 

func (ls *ListService) Count(opts ...Option) (int, error)

Count returns the number of Lists available in the IGDB. Provide the SetFilter functional option if you need to filter which Lists to count.

func (*ListService) Fields 

func (ls *ListService) Fields() ([]string, error)

Fields returns the up-to-date list of fields in an IGDB List object.

func (*ListService) Get 

func (ls *ListService) Get(id int, opts ...Option) (*List, error)

Get returns a single List identified by the provided IGDB ID. Provide the SetFields functional option if you need to specify which fields to retrieve. If the ID does not match any Lists, an error is returned.

func (*ListService) Index 

func (ls *ListService) Index(opts ...Option) ([]*List, error)

Index returns an index of Lists based solely on the provided functional options used to sort, filter, and paginate the results. If no Lists can be found using the provided options, an error is returned.

func (*ListService) List 

func (ls *ListService) List(ids []int, opts ...Option) ([]*List, error)

List returns a list of Lists identified by the provided list of IGDB IDs. Provide functional options to sort, filter, and paginate the results. Any ID that does not match a List is ignored. If none of the IDs match a List, an error is returned.

type MultiplayerMode 

type MultiplayerMode struct {
	Campaigncoop      bool `json:"campaigncoop"`
	Dropin            bool `json:"dropin"`
	Lancoop           bool `json:"lancoop"`
	Offlinecoop       bool `json:"offlinecoop"`
	Offlinecoopmax    int  `json:"offlinecoopmax"`
	Offlinemax        int  `json:"offlinemax"`
	Onlinecoop        bool `json:"onlinecoop"`
	Onlinecoopmax     int  `json:"onlinecoopmax"`
	Onlinemax         int  `json:"onlinemax"`
	Platform          int  `json:"platform"`
	Splitscreen       bool `json:"splitscreen"`
	Splitscreenonline bool `json:"splitscreenonline"`
}

MultiplayerMode contains data about the supported multiplayer types. For more information visit: https://api-docs.igdb.com/#multiplayer-mode

type MultiplayerModeService 

type MultiplayerModeService service

MultiplayerModeService handles all the API calls for the IGDB MultiplayerMode endpoint.

func (*MultiplayerModeService) Count 

func (ms *MultiplayerModeService) Count(opts ...Option) (int, error)

Count returns the number of MultiplayerModes available in the IGDB. Provide the SetFilter functional option if you need to filter which MultiplayerModes to count.

func (*MultiplayerModeService) Fields 

func (ms *MultiplayerModeService) Fields() ([]string, error)

Fields returns the up-to-date list of fields in an IGDB MultiplayerMode object.

func (*MultiplayerModeService) Get 

func (ms *MultiplayerModeService) Get(id int, opts ...Option) (*MultiplayerMode, error)

Get returns a single MultiplayerMode identified by the provided IGDB ID. Provide the SetFields functional option if you need to specify which fields to retrieve. If the ID does not match any MultiplayerModes, an error is returned.

func (*MultiplayerModeService) Index 

func (ms *MultiplayerModeService) Index(opts ...Option) ([]*MultiplayerMode, error)

Index returns an index of MultiplayerModes based solely on the provided functional options used to sort, filter, and paginate the results. If no MultiplayerModes can be found using the provided options, an error is returned.

func (*MultiplayerModeService) List 

func (ms *MultiplayerModeService) List(ids []int, opts ...Option) ([]*MultiplayerMode, error)

List returns a list of MultiplayerModes identified by the provided list of IGDB IDs. Provide functional options to sort, filter, and paginate the results. Any ID that does not match a MultiplayerMode is ignored. If none of the IDs match a MultiplayerMode, an error is returned.

type Option 

type Option func() (apicalypse.Option, error)

Option functions are used to set the options for an API call. Option is the first-order function returned by the available functional options (e.g. SetLimit or SetFilter). This first-order function is then passed into a service's Get, List, Index, Search, or Count function.

func ComposeOptions 

func ComposeOptions(opts ...Option) Option

ComposeOptions composes multiple functional options into a single Option. This is primarily used to create a single functional option that can be used repeatedly across multiple queries.

Example 
c := NewClient("YOUR_API_KEY", nil)

// Composing FuncOptions to filter for top 5 popular games
composed := ComposeOptions(
	SetLimit(5),
	SetFields("name", "cover"),
	SetOrder("popularity", OrderDescending),
	SetFilter("category", OpEquals, "0"),
)

// Using composed FuncOptions
PS4, err := c.Games.Index(
	composed,
	SetFilter("platforms", OpEquals, "48"), // only PS4 games
)
if err != nil {
	log.Fatal(err)
}

// Reusing composed FuncOptions
XBOX, err := c.Games.Index(
	composed,
	SetFilter("platforms", OpEquals, "49"), // only XBOX games
)
if err != nil {
	log.Fatal(err)
}

fmt.Println("Top 5 PS4 Games: ")
for _, v := range PS4 {
	fmt.Println(*v)
}

fmt.Println("Top 5 Xbox Games: ")
for _, v := range XBOX {
	fmt.Println(*v)
}

Output:

func SetExclude 

func SetExclude(fields ...string) Option

SetExclude is a functional option used to specify which fields of the requested IGDB object you want the API to exclude. Note that the field string must match an IGDB object's JSON field tag exactly, not the Go struct name.

For more information, visit: https://api-docs.igdb.com/#exclude

Example 
c := NewClient("YOUR_API_KEY", nil)

// Exclude name field
c.Characters.Search("mario", SetFields("name"))

// Exclude gender field
c.Characters.Search("mario", SetFields("gender"))

// Exclude both name and gender field
c.Characters.Search("mario", SetFields("name", "gender"))

// Exclude whole mug_shot field
c.Characters.Search("mario", SetFields("mug_shot"))

// Exclude any number of fields
c.Characters.Search("mario", SetFields("name", "gender", "url", "species", "games", "mug_shot"))

// Exclude all available fields
c.Characters.Search("mario", SetFields("*"))

Output:

func SetFields 

func SetFields(fields ...string) Option

SetFields is a functional option used to specify which fields of the requested IGDB object you want the API to provide. Subfields are accessed with a dot operator (e.g. cover.url). To select all available fields at once, use an asterisk character (i.e. *). Note that the field string must match an IGDB object's JSON field tag exactly, not the Go struct field name.

For more information, visit: https://api-docs.igdb.com/#fields

Example 
c := NewClient("YOUR_API_KEY", nil)

// Retrieve name field
c.Characters.Search("mario", SetFields("name"))

// Retrieve gender field
c.Characters.Search("mario", SetFields("gender"))

// Retrieve both name and gender field
c.Characters.Search("mario", SetFields("name", "gender"))

// Retrieve whole mug_shot field
c.Characters.Search("mario", SetFields("mug_shot"))

// Retrieve any number of fields
c.Characters.Search("mario", SetFields("name", "gender", "url", "species", "games", "mug_shot"))

// Retrieve all available fields
c.Characters.Search("mario", SetFields("*"))

Output:

func SetFilter 

func SetFilter(field string, op operator, val ...string) Option

SetFilter is a functional option used to filter the results from an API call. Filtering operations need three different arguments: an operator and 2 operands, the field and its value. The provided field and val string act as the operands for the provided operator. If multiple values are provided, they will be concatenated into a comma separated list. If no values are provided, an error is returned.

SetFilter is the only option allowed to be set multiple times in a single API call. By default, results are unfiltered.

Note that when filtering a field that consists of an enumerated type (e.g. Gender Code, Feed Category, Game Status, etc.), you must provide the number corresponding to the intended field value. For your convenience, you may also provide the enumerated constant.

For more information, visit: https://api-docs.igdb.com/#filters

Example 
c := NewClient("YOUR_API_KEY", nil)

// Retrieve unfiltered games - default
c.Games.Index()

// Retrieve games with popularity above 50
c.Games.Index(SetFilter("popularity", OpGreaterThan, "50"))

// Retrieve games with cover art
c.Games.Index(SetFilter("cover", OpNotEquals, "null"))

// Retrieve games released on PS4 (platform ID of 48)
c.Games.Index(SetFilter("platforms", OpEquals, "48"))

// Retrieve games whose name does not match "Horizon: Zero Dawn"
c.Games.Index(SetFilter("name", OpNotEquals, "Horizon: Zero Dawn"))

// Retrieve games which have the Adventure genre (Genre ID of 31)
c.Games.Index(SetFilter("genres", OpContainsAtLeast, "31"))

// Retrieve games that meet all the previous requirements
c.Games.Index(
	SetFilter("popularity", OpGreaterThan, "50"),
	SetFilter("cover", OpNotEquals, "null"),
	SetFilter("platforms", OpEquals, "48"),
	SetFilter("name", OpNotEquals, "Horizon: Zero Dawn"),
	SetFilter("genres", OpContainsAtLeast, "31"),
)

Output:

func SetLimit 

func SetLimit(lim int) Option

SetLimit is a functional option used to limit the number of results from an API call. The default limit is 10. For free tier users, the maximum limit is 50. For pro tier users, the maximum limit is 500. For enterprise users, the maximum limit is 5000.

For more information, visit: https://api-docs.igdb.com/#pagination

Example 
c := NewClient("YOUR_API_KEY", nil)

// Retrieve up to 10 results - default
c.Characters.Search("snake")

// Retrieve up to 50 results
c.Characters.Search("snake", SetLimit(50))

// Retrieve up to 1 result
c.Characters.Search("snake", SetLimit(1))

Output:

func SetOffset 

func SetOffset(off int) Option

SetOffset is a functional option used to offset the results from an API call. The default offset is 0. For free tier users, the maximum offset is 150. For pro tier users, the maximum offest is 5000. For enterprise users, there is no maximum offset.

For more information, visit: https://api-docs.igdb.com/#pagination

Example 
c := NewClient("YOUR_API_KEY", nil)

batchLimit := SetLimit(50)

// Retrieve first batch of results - default
c.Persons.Index(batchLimit)

// Retrieve second batch of results
c.Persons.Index(batchLimit, SetOffset(50))

// Retrieve third batch of results
c.Persons.Index(batchLimit, SetOffset(100))

// Retrieve fourth batch of results
c.Persons.Index(batchLimit, SetOffset(150))

Output:

func SetOrder 

func SetOrder(field string, order order) Option

SetOrder is a functional option used to sort the results from an API call. The default order is by relevance.

For more information, visit: https://api-docs.igdb.com/#sorting

Example 
c := NewClient("YOUR_API_KEY", nil)

// Retrieve most relevant games - default
c.Games.Search("zelda")

// Retrieve most popular games
c.Games.Search("zelda", SetOrder("popularity", OrderDescending))

// Retrieve least hyped games
c.Games.Search("zelda", SetOrder("hypes", OrderAscending))

Output:

type Page 

type Page struct {
	ID               int             `json:"id"`
	Background       int             `json:"background"`
	Battlenet        string          `json:"battlenet"`
	Category         PageCategory    `json:"category"`
	Color            PageColor       `json:"color"`
	Company          int             `json:"company"`
	Country          int             `json:"country"`
	CreatedAt        int             `json:"created_at"`
	Description      string          `json:"description"`
	Feed             int             `json:"feed"`
	Game             int             `json:"game"`
	Name             string          `json:"name"`
	Origin           string          `json:"origin"`
	PageFollowsCount int             `json:"page_follows_count"`
	Slug             string          `json:"slug"`
	SubCategory      PageSubCategory `json:"sub_category"`
	UpdatedAt        int             `json:"updated_at"`
	Uplay            string          `json:"uplay"`
	URL              string          `json:"url"`
	User             int             `json:"user"`
	Websites         []int           `json:"websites"`
}

Page represents an entry in the multipurpose page system currently used for youtubers and media organizations. For more information visit: https://api-docs.igdb.com/#page

type PageBackground 

type PageBackground struct {
	Image
	ID int `json:"id"`
}

PageBackground represents the background image of a specific page. For more information visit: https://api-docs.igdb.com/#page-background

type PageBackgroundService 

type PageBackgroundService service

PageBackgroundService handles all the API calls for the IGDB PageBackground endpoint.

func (*PageBackgroundService) Count 

func (ps *PageBackgroundService) Count(opts ...Option) (int, error)

Count returns the number of PageBackgrounds available in the IGDB. Provide the SetFilter functional option if you need to filter which PageBackgrounds to count.

func (*PageBackgroundService) Fields 

func (ps *PageBackgroundService) Fields() ([]string, error)

Fields returns the up-to-date list of fields in an IGDB PageBackground object.

func (*PageBackgroundService) Get 

func (ps *PageBackgroundService) Get(id int, opts ...Option) (*PageBackground, error)

Get returns a single PageBackground identified by the provided IGDB ID. Provide the SetFields functional option if you need to specify which fields to retrieve. If the ID does not match any PageBackgrounds, an error is returned.

func (*PageBackgroundService) Index 

func (ps *PageBackgroundService) Index(opts ...Option) ([]*PageBackground, error)

Index returns an index of PageBackgrounds based solely on the provided functional options used to sort, filter, and paginate the results. If no PageBackgrounds can be found using the provided options, an error is returned.

func (*PageBackgroundService) List 

func (ps *PageBackgroundService) List(ids []int, opts ...Option) ([]*PageBackground, error)

List returns a list of PageBackgrounds identified by the provided list of IGDB IDs. Provide functional options to sort, filter, and paginate the results. Any ID that does not match a PageBackground is ignored. If none of the IDs match a PageBackground, an error is returned.

type PageCategory 

type PageCategory int

PageCategory specifies the type of media associated with a particular page. 

const (
	PagePersonality PageCategory = iota + 1
	PageMediaOrganization
	PageContentCreator
	PageClanTeam
)

Expected PageCategory enums from the IGDB.

func (PageCategory) String 

func (i PageCategory) String() string

type PageColor 

type PageColor int

PageColor specifies a particular color. 

const (
	PageGreen PageColor = iota
	PageBlue
	PageRed
	PageOrange
	PagePink
	PageYellow
)

Expected PageColor enums from the IGDB.

func (PageColor) String 

func (i PageColor) String() string
type PageLogo struct {
	Image
	ID int `json:"id"`
}

PageLogo represents the logo of a specific page. For more information visit: https://api-docs.igdb.com/#page-logo

type PageLogoService 

type PageLogoService service

PageLogoService handles all the API calls for the IGDB PageLogo endpoint.

func (*PageLogoService) Count 

func (ps *PageLogoService) Count(opts ...Option) (int, error)

Count returns the number of PageLogos available in the IGDB. Provide the SetFilter functional option if you need to filter which PageLogos to count.

func (*PageLogoService) Fields 

func (ps *PageLogoService) Fields() ([]string, error)

Fields returns the up-to-date list of fields in an IGDB PageLogo object.

func (*PageLogoService) Get 

func (ps *PageLogoService) Get(id int, opts ...Option) (*PageLogo, error)

Get returns a single PageLogo identified by the provided IGDB ID. Provide the SetFields functional option if you need to specify which fields to retrieve. If the ID does not match any PageLogos, an error is returned.

func (*PageLogoService) Index 

func (ps *PageLogoService) Index(opts ...Option) ([]*PageLogo, error)

Index returns an index of PageLogos based solely on the provided functional options used to sort, filter, and paginate the results. If no PageLogos can be found using the provided options, an error is returned.

func (*PageLogoService) List 

func (ps *PageLogoService) List(ids []int, opts ...Option) ([]*PageLogo, error)

List returns a list of PageLogos identified by the provided list of IGDB IDs. Provide functional options to sort, filter, and paginate the results. Any ID that does not match a PageLogo is ignored. If none of the IDs match a PageLogo, an error is returned.

type PageService 

type PageService service

PageService handles all the API calls for the IGDB Page endpoint.

func (*PageService) Count 

func (ps *PageService) Count(opts ...Option) (int, error)

Count returns the number of Pages available in the IGDB. Provide the SetFilter functional option if you need to filter which Pages to count.

func (*PageService) Fields 

func (ps *PageService) Fields() ([]string, error)

Fields returns the up-to-date list of fields in an IGDB Page object.

func (*PageService) Get 

func (ps *PageService) Get(id int, opts ...Option) (*Page, error)

Get returns a single Page identified by the provided IGDB ID. Provide the SetFields functional option if you need to specify which fields to retrieve. If the ID does not match any Pages, an error is returned.

func (*PageService) Index 

func (ps *PageService) Index(opts ...Option) ([]*Page, error)

Index returns an index of Pages based solely on the provided functional options used to sort, filter, and paginate the results. If no Pages can be found using the provided options, an error is returned.

func (*PageService) List 

func (ps *PageService) List(ids []int, opts ...Option) ([]*Page, error)

List returns a list of Pages identified by the provided list of IGDB IDs. Provide functional options to sort, filter, and paginate the results. Any ID that does not match a Page is ignored. If none of the IDs match a Page, an error is returned.

type PageSubCategory 

type PageSubCategory int

PageSubCategory specifies a specific field of media for a particular page. 

const (
	PageUser PageSubCategory = iota + 1
	PageGame
	PageCompany
	PageConsumer
	PageIndustry
	PageESports
)

Expected PageSubCategory enums from the IGDB.

func (PageSubCategory) String 

func (i PageSubCategory) String() string

type PageWebsite 

type PageWebsite struct {
	ID       int             `json:"id"`
	Category WebsiteCategory `json:"category"`
	Trusted  bool            `json:"trusted"`
	URL      string          `json:"url"`
}

PageWebsite represents the website of a specific page. For more information visit: https://api-docs.igdb.com/#page-website

type PageWebsiteService 

type PageWebsiteService service

PageWebsiteService handles all the API calls for the IGDB PageWebsite endpoint.

func (*PageWebsiteService) Count 

func (ps *PageWebsiteService) Count(opts ...Option) (int, error)

Count returns the number of PageWebsites available in the IGDB. Provide the SetFilter functional option if you need to filter which PageWebsites to count.

func (*PageWebsiteService) Fields 

func (ps *PageWebsiteService) Fields() ([]string, error)

Fields returns the up-to-date list of fields in an IGDB PageWebsite object.

func (*PageWebsiteService) Get 

func (ps *PageWebsiteService) Get(id int, opts ...Option) (*PageWebsite, error)

Get returns a single PageWebsite identified by the provided IGDB ID. Provide the SetFields functional option if you need to specify which fields to retrieve. If the ID does not match any PageWebsites, an error is returned.

func (*PageWebsiteService) Index 

func (ps *PageWebsiteService) Index(opts ...Option) ([]*PageWebsite, error)

Index returns an index of PageWebsites based solely on the provided functional options used to sort, filter, and paginate the results. If no PageWebsites can be found using the provided options, an error is returned.

func (*PageWebsiteService) List 

func (ps *PageWebsiteService) List(ids []int, opts ...Option) ([]*PageWebsite, error)

List returns a list of PageWebsites identified by the provided list of IGDB IDs. Provide functional options to sort, filter, and paginate the results. Any ID that does not match a PageWebsite is ignored. If none of the IDs match a PageWebsite, an error is returned.

type Person 

type Person struct {
	ID            int             `json:"id"`
	Bio           string          `json:"bio"`
	Characters    []int           `json:"characters"`
	Country       int             `json:"country"`
	CreatedAt     int             `json:"created_at"`
	CreditedGames []int           `json:"credited_games"`
	Description   string          `json:"description"`
	DOB           int             `json:"dob"`
	Gender        CharacterGender `json:"gender"`
	LovesCount    int             `json:"loves_count"`
	MugShot       int             `json:"mug_shot"`
	Name          string          `json:"name"`
	Nicknames     []string        `json:"nicknames"`
	Parent        int             `json:"parent"`
	Slug          string          `json:"slug"`
	UpdatedAt     int             `json:"updated_at"`
	URL           string          `json:"url"`
	VoiceActed    []int           `json:"voice_acted"`
	Websites      []int           `json:"websites"`
}

Person represents a person in the video game industry. For more information visit: https://api-docs.igdb.com/#person

type PersonMugshot 

type PersonMugshot struct {
	Image
	ID int `json:"id"`
}

PersonMugshot represents the mugshot of a person in the video game industry. For more information visit: https://api-docs.igdb.com/#person-mug-shot

type PersonMugshotService 

type PersonMugshotService service

PersonMugshotService handles all the API calls for the IGDB PersonMugshot endpoint.

func (*PersonMugshotService) Count 

func (ps *PersonMugshotService) Count(opts ...Option) (int, error)

Count returns the number of PersonMugshots available in the IGDB. Provide the SetFilter functional option if you need to filter which PersonMugshots to count.

func (*PersonMugshotService) Fields 

func (ps *PersonMugshotService) Fields() ([]string, error)

Fields returns the up-to-date list of fields in an IGDB PersonMugshot object.

func (*PersonMugshotService) Get 

func (ps *PersonMugshotService) Get(id int, opts ...Option) (*PersonMugshot, error)

Get returns a single PersonMugshot identified by the provided IGDB ID. Provide the SetFields functional option if you need to specify which fields to retrieve. If the ID does not match any PersonMugshots, an error is returned.

func (*PersonMugshotService) Index 

func (ps *PersonMugshotService) Index(opts ...Option) ([]*PersonMugshot, error)

Index returns an index of PersonMugshots based solely on the provided functional options used to sort, filter, and paginate the results. If no PersonMugshots can be found using the provided options, an error is returned.

func (*PersonMugshotService) List 

func (ps *PersonMugshotService) List(ids []int, opts ...Option) ([]*PersonMugshot, error)

List returns a list of PersonMugshots identified by the provided list of IGDB IDs. Provide functional options to sort, filter, and paginate the results. Any ID that does not match a PersonMugshot is ignored. If none of the IDs match a PersonMugshot, an error is returned.

type PersonService 

type PersonService service

PersonService handles all the API calls for the IGDB Person endpoint.

func (*PersonService) Count 

func (ps *PersonService) Count(opts ...Option) (int, error)

Count returns the number of People available in the IGDB. Provide the SetFilter functional option if you need to filter which People to count.

func (*PersonService) Fields 

func (ps *PersonService) Fields() ([]string, error)

Fields returns the up-to-date list of fields in an IGDB Person object.

func (*PersonService) Get 

func (ps *PersonService) Get(id int, opts ...Option) (*Person, error)

Get returns a single Person identified by the provided IGDB ID. Provide the SetFields functional option if you need to specify which fields to retrieve. If the ID does not match any People, an error is returned.

func (*PersonService) Index 

func (ps *PersonService) Index(opts ...Option) ([]*Person, error)

Index returns an index of People based solely on the provided functional options used to sort, filter, and paginate the results. If no People can be found using the provided options, an error is returned.

func (*PersonService) List 

func (ps *PersonService) List(ids []int, opts ...Option) ([]*Person, error)

List returns a list of People identified by the provided list of IGDB IDs. Provide functional options to sort, filter, and paginate the results. Any ID that does not match a Person is ignored. If none of the IDs match a Person, an error is returned.

func (*PersonService) Search 

func (ps *PersonService) Search(qry string, opts ...Option) ([]*Person, error)

Search returns a list of People found by searching the IGDB using the provided query. Provide functional options to sort, filter, and paginate the results. If no People are found using the provided query, an error is returned.

type PersonWebsite 

type PersonWebsite struct {
	ID       int             `json:"id"`
	Category WebsiteCategory `json:"category"`
	Trusted  bool            `json:"trusted"`
	URL      string          `json:"url"`
}

PersonWebsite represents a website associated with a person in the video game industry. For more information visit: https://api-docs.igdb.com/#person-website

type PersonWebsiteService 

type PersonWebsiteService service

PersonWebsiteService handles all the API calls for the IGDB PersonWebsite endpoint.

func (*PersonWebsiteService) Count 

func (ps *PersonWebsiteService) Count(opts ...Option) (int, error)

Count returns the number of PersonWebsites available in the IGDB. Provide the SetFilter functional option if you need to filter which PersonWebsites to count.

func (*PersonWebsiteService) Fields 

func (ps *PersonWebsiteService) Fields() ([]string, error)

Fields returns the up-to-date list of fields in an IGDB PersonWebsite object.

func (*PersonWebsiteService) Get 

func (ps *PersonWebsiteService) Get(id int, opts ...Option) (*PersonWebsite, error)

Get returns a single PersonWebsite identified by the provided IGDB ID. Provide the SetFields functional option if you need to specify which fields to retrieve. If the ID does not match any PersonWebsites, an error is returned.

func (*PersonWebsiteService) Index 

func (ps *PersonWebsiteService) Index(opts ...Option) ([]*PersonWebsite, error)

Index returns an index of PersonWebsites based solely on the provided functional options used to sort, filter, and paginate the results. If no PersonWebsites can be found using the provided options, an error is returned.

func (*PersonWebsiteService) List 

func (ps *PersonWebsiteService) List(ids []int, opts ...Option) ([]*PersonWebsite, error)

List returns a list of PersonWebsites identified by the provided list of IGDB IDs. Provide functional options to sort, filter, and paginate the results. Any ID that does not match a PersonWebsite is ignored. If none of the IDs match a PersonWebsite, an error is returned.

type Platform 

type Platform struct {
	ID              int              `json:"id"`
	Abbreviation    string           `json:"abbreviation"`
	AlternativeName string           `json:"alternative_name"`
	Category        PlatformCategory `json:"category"`
	CreatedAt       int              `json:"created_at"`
	Generation      int              `json:"generation"`
	Name            string           `json:"name"`
	ProductFamily   int              `json:"product_family"`
	Slug            string           `json:"slug"`
	Summary         string           `json:"summary"`
	UpdatedAt       int              `json:"updated_at"`
	URL             string           `json:"url"`
	Versions        []int            `json:"versions"`
	Websites        []int            `json:"websites"`
}

Platform represents the hardware used to run the game or game delivery network. For more information visit: https://api-docs.igdb.com/#platform

type PlatformCategory 

type PlatformCategory int

PlatformCategory specifies a type of platform. 

const (
	PlatformConsole PlatformCategory = iota + 1
	PlatformArcade
	PlatformPlatform
	PlatformOperatingSystem
	PlatformPortableConsole
	PlatformComputer
)

Expected PlatformCategory enums from the IGDB.

func (PlatformCategory) String 

func (i PlatformCategory) String() string
type PlatformLogo struct {
	Image
	ID int `json:"id"`
}

PlatformLogo represents a logo for a particular platform. For more information visit: https://api-docs.igdb.com/#platform-logo

type PlatformLogoService 

type PlatformLogoService service

PlatformLogoService handles all the API calls for the IGDB PlatformLogo endpoint.

func (*PlatformLogoService) Count 

func (ps *PlatformLogoService) Count(opts ...Option) (int, error)

Count returns the number of PlatformLogos available in the IGDB. Provide the SetFilter functional option if you need to filter which PlatformLogos to count.

func (*PlatformLogoService) Fields 

func (ps *PlatformLogoService) Fields() ([]string, error)

Fields returns the up-to-date list of fields in an IGDB PlatformLogo object.

func (*PlatformLogoService) Get 

func (ps *PlatformLogoService) Get(id int, opts ...Option) (*PlatformLogo, error)

Get returns a single PlatformLogo identified by the provided IGDB ID. Provide the SetFields functional option if you need to specify which fields to retrieve. If the ID does not match any PlatformLogos, an error is returned.

func (*PlatformLogoService) Index 

func (ps *PlatformLogoService) Index(opts ...Option) ([]*PlatformLogo, error)

Index returns an index of PlatformLogos based solely on the provided functional options used to sort, filter, and paginate the results. If no PlatformLogos can be found using the provided options, an error is returned.

func (*PlatformLogoService) List 

func (ps *PlatformLogoService) List(ids []int, opts ...Option) ([]*PlatformLogo, error)

List returns a list of PlatformLogos identified by the provided list of IGDB IDs. Provide functional options to sort, filter, and paginate the results. Any ID that does not match a PlatformLogo is ignored. If none of the IDs match a PlatformLogo, an error is returned.

type PlatformService 

type PlatformService service

PlatformService handles all the API calls for the IGDB Platform endpoint.

func (*PlatformService) Count 

func (ps *PlatformService) Count(opts ...Option) (int, error)

Count returns the number of Platforms available in the IGDB. Provide the SetFilter functional option if you need to filter which Platforms to count.

func (*PlatformService) Fields 

func (ps *PlatformService) Fields() ([]string, error)

Fields returns the up-to-date list of fields in an IGDB Platform object.

func (*PlatformService) Get 

func (ps *PlatformService) Get(id int, opts ...Option) (*Platform, error)

Get returns a single Platform identified by the provided IGDB ID. Provide the SetFields functional option if you need to specify which fields to retrieve. If the ID does not match any Platforms, an error is returned.

func (*PlatformService) Index 

func (ps *PlatformService) Index(opts ...Option) ([]*Platform, error)

Index returns an index of Platforms based solely on the provided functional options used to sort, filter, and paginate the results. If no Platforms can be found using the provided options, an error is returned.

func (*PlatformService) List 

func (ps *PlatformService) List(ids []int, opts ...Option) ([]*Platform, error)

List returns a list of Platforms identified by the provided list of IGDB IDs. Provide functional options to sort, filter, and paginate the results. Any ID that does not match a Platform is ignored. If none of the IDs match a Platform, an error is returned.

func (*PlatformService) Search 

func (ps *PlatformService) Search(qry string, opts ...Option) ([]*Platform, error)

Search returns a list of Platforms found by searching the IGDB using the provided query. Provide functional options to sort, filter, and paginate the results. If no Platforms are found using the provided query, an error is returned.

type PlatformVersion 

type PlatformVersion struct {
	ID                          int    `json:"id"`
	Companies                   []int  `json:"companies"`
	Connectivity                string `json:"connectivity"`
	CPU                         string `json:"cpu"`
	Graphics                    string `json:"graphics"`
	MainManufacturer            int    `json:"main_manufacturer"`
	Media                       string `json:"media"`
	Memory                      string `json:"memory"`
	Name                        string `json:"name"`
	OS                          string `json:"os"`
	Output                      string `json:"output"`
	PlatformVersionReleaseDates []int  `json:"platform_version_release_dates"`
	Resolutions                 string `json:"resolutions"`
	Slug                        string `json:"slug"`
	Sound                       string `json:"sound"`
	Storage                     string `json:"storage"`
	Summary                     string `json:"summary"`
	URL                         string `json:"url"`
}

PlatformVersion represents a particular version of a platform. For more information visit: https://api-docs.igdb.com/#platform-version

type PlatformVersionCompany 

type PlatformVersionCompany struct {
	ID           int    `json:"id"`
	Comment      string `json:"comment"`
	Company      int    `json:"company"`
	Developer    bool   `json:"developer"`
	Manufacturer bool   `json:"manufacturer"`
}

PlatformVersionCompany represents a platform developer. For more information visit: https://api-docs.igdb.com/#platform-version-company

type PlatformVersionCompanyService 

type PlatformVersionCompanyService service

PlatformVersionCompanyService handles all the API calls for the IGDB PlatformVersionCompany endpoint.

func (*PlatformVersionCompanyService) Count 

func (ps *PlatformVersionCompanyService) Count(opts ...Option) (int, error)

Count returns the number of PlatformVersionCompanies available in the IGDB. Provide the SetFilter functional option if you need to filter which PlatformVersionCompanies to count.

func (*PlatformVersionCompanyService) Fields 

func (ps *PlatformVersionCompanyService) Fields() ([]string, error)

Fields returns the up-to-date list of fields in an IGDB PlatformVersionCompany object.

func (*PlatformVersionCompanyService) Get 

func (ps *PlatformVersionCompanyService) Get(id int, opts ...Option) (*PlatformVersionCompany, error)

Get returns a single PlatformVersionCompany identified by the provided IGDB ID. Provide the SetFields functional option if you need to specify which fields to retrieve. If the ID does not match any PlatformVersionCompanies, an error is returned.

func (*PlatformVersionCompanyService) Index 

func (ps *PlatformVersionCompanyService) Index(opts ...Option) ([]*PlatformVersionCompany, error)

Index returns an index of PlatformVersionCompanies based solely on the provided functional options used to sort, filter, and paginate the results. If no PlatformVersionCompanies can be found using the provided options, an error is returned.

func (*PlatformVersionCompanyService) List 

func (ps *PlatformVersionCompanyService) List(ids []int, opts ...Option) ([]*PlatformVersionCompany, error)

List returns a list of PlatformVersionCompanies identified by the provided list of IGDB IDs. Provide functional options to sort, filter, and paginate the results. Any ID that does not match a PlatformVersionCompany is ignored. If none of the IDs match a PlatformVersionCompany, an error is returned.

type PlatformVersionReleaseDate 

type PlatformVersionReleaseDate struct {
	ID              int            `json:"id"`
	Category        DateCategory   `json:"category"`
	CreatedAt       int            `json:"created_at"`
	Date            int            `json:"date"`
	Human           string         `json:"human"`
	M               int            `json:"m"`
	PlatformVersion int            `json:"platform_version"`
	Region          RegionCategory `json:"region"`
	UpdatedAt       int            `json:"updated_at"`
	Y               int            `json:"y"`
}

PlatformVersionReleaseDate describes a platform release date. Used to dig deeper into release dates, platforms, and versions. For more information visit: https://api-docs.igdb.com/#platform-version-release-date

type PlatformVersionReleaseDateService 

type PlatformVersionReleaseDateService service

PlatformVersionReleaseDateService handles all the API calls for the IGDB PlatformVersionReleaseDate endpoint.

func (*PlatformVersionReleaseDateService) Count 

func (ps *PlatformVersionReleaseDateService) Count(opts ...Option) (int, error)

Count returns the number of PlatformVersionReleaseDates available in the IGDB. Provide the SetFilter functional option if you need to filter which PlatformVersionReleaseDates to count.

func (*PlatformVersionReleaseDateService) Fields 

func (ps *PlatformVersionReleaseDateService) Fields() ([]string, error)

Fields returns the up-to-date list of fields in an IGDB PlatformVersionReleaseDate object.

func (*PlatformVersionReleaseDateService) Get 

func (ps *PlatformVersionReleaseDateService) Get(id int, opts ...Option) (*PlatformVersionReleaseDate, error)

Get returns a single PlatformVersionReleaseDate identified by the provided IGDB ID. Provide the SetFields functional option if you need to specify which fields to retrieve. If the ID does not match any PlatformVersionReleaseDates, an error is returned.

func (*PlatformVersionReleaseDateService) Index 

func (ps *PlatformVersionReleaseDateService) Index(opts ...Option) ([]*PlatformVersionReleaseDate, error)

Index returns an index of PlatformVersionReleaseDates based solely on the provided functional options used to sort, filter, and paginate the results. If no PlatformVersionReleaseDates can be found using the provided options, an error is returned.

func (*PlatformVersionReleaseDateService) List 

func (ps *PlatformVersionReleaseDateService) List(ids []int, opts ...Option) ([]*PlatformVersionReleaseDate, error)

List returns a list of PlatformVersionReleaseDates identified by the provided list of IGDB IDs. Provide functional options to sort, filter, and paginate the results. Any ID that does not match a PlatformVersionReleaseDate is ignored. If none of the IDs match a PlatformVersionReleaseDate, an error is returned.

type PlatformVersionService 

type PlatformVersionService service

PlatformVersionService handles all the API calls for the IGDB PlatformVersion endpoint.

func (*PlatformVersionService) Count 

func (ps *PlatformVersionService) Count(opts ...Option) (int, error)

Count returns the number of PlatformVersions available in the IGDB. Provide the SetFilter functional option if you need to filter which PlatformVersions to count.

func (*PlatformVersionService) Fields 

func (ps *PlatformVersionService) Fields() ([]string, error)

Fields returns the up-to-date list of fields in an IGDB PlatformVersion object.

func (*PlatformVersionService) Get 

func (ps *PlatformVersionService) Get(id int, opts ...Option) (*PlatformVersion, error)

Get returns a single PlatformVersion identified by the provided IGDB ID. Provide the SetFields functional option if you need to specify which fields to retrieve. If the ID does not match any PlatformVersions, an error is returned.

func (*PlatformVersionService) Index 

func (ps *PlatformVersionService) Index(opts ...Option) ([]*PlatformVersion, error)

Index returns an index of PlatformVersions based solely on the provided functional options used to sort, filter, and paginate the results. If no PlatformVersions can be found using the provided options, an error is returned.

func (*PlatformVersionService) List 

func (ps *PlatformVersionService) List(ids []int, opts ...Option) ([]*PlatformVersion, error)

List returns a list of PlatformVersions identified by the provided list of IGDB IDs. Provide functional options to sort, filter, and paginate the results. Any ID that does not match a PlatformVersion is ignored. If none of the IDs match a PlatformVersion, an error is returned.

type PlatformWebsite 

type PlatformWebsite struct {
	ID       int             `json:"id"`
	Category WebsiteCategory `json:"category"`
	Trusted  bool            `json:"trusted"`
	URL      string          `json:"url"`
}

PlatformWebsite represents the main website for a particular platform. For more information visit: https://api-docs.igdb.com/#platform-website

type PlatformWebsiteService 

type PlatformWebsiteService service

PlatformWebsiteService handles all the API calls for the IGDB PlatformWebsite endpoint.

func (*PlatformWebsiteService) Count 

func (ps *PlatformWebsiteService) Count(opts ...Option) (int, error)

Count returns the number of PlatformWebsites available in the IGDB. Provide the SetFilter functional option if you need to filter which PlatformWebsites to count.

func (*PlatformWebsiteService) Fields 

func (ps *PlatformWebsiteService) Fields() ([]string, error)

Fields returns the up-to-date list of fields in an IGDB PlatformWebsite object.

func (*PlatformWebsiteService) Get 

func (ps *PlatformWebsiteService) Get(id int, opts ...Option) (*PlatformWebsite, error)

Get returns a single PlatformWebsite identified by the provided IGDB ID. Provide the SetFields functional option if you need to specify which fields to retrieve. If the ID does not match any PlatformWebsites, an error is returned.

func (*PlatformWebsiteService) Index 

func (ps *PlatformWebsiteService) Index(opts ...Option) ([]*PlatformWebsite, error)

Index returns an index of PlatformWebsites based solely on the provided functional options used to sort, filter, and paginate the results. If no PlatformWebsites can be found using the provided options, an error is returned.

func (*PlatformWebsiteService) List 

func (ps *PlatformWebsiteService) List(ids []int, opts ...Option) ([]*PlatformWebsite, error)

List returns a list of PlatformWebsites identified by the provided list of IGDB IDs. Provide functional options to sort, filter, and paginate the results. Any ID that does not match a PlatformWebsite is ignored. If none of the IDs match a PlatformWebsite, an error is returned.

type PlayerPerspective 

type PlayerPerspective struct {
	ID        int    `json:"id"`
	CreatedAt int    `json:"created_at"`
	Name      string `json:"name"`
	Slug      string `json:"slug"`
	UpdatedAt int    `json:"updated_at"`
	URL       string `json:"url"`
}

PlayerPerspective describes the view or perspective of the player in a video game. For more information visit: https://api-docs.igdb.com/#player-perspective

type PlayerPerspectiveService 

type PlayerPerspectiveService service

PlayerPerspectiveService handles all the API calls for the IGDB PlayerPerspective endpoint.

func (*PlayerPerspectiveService) Count 

func (ps *PlayerPerspectiveService) Count(opts ...Option) (int, error)

Count returns the number of PlayerPerspectives available in the IGDB. Provide the SetFilter functional option if you need to filter which PlayerPerspectives to count.

func (*PlayerPerspectiveService) Fields 

func (ps *PlayerPerspectiveService) Fields() ([]string, error)

Fields returns the up-to-date list of fields in an IGDB PlayerPerspective object.

func (*PlayerPerspectiveService) Get 

func (ps *PlayerPerspectiveService) Get(id int, opts ...Option) (*PlayerPerspective, error)

Get returns a single PlayerPerspective identified by the provided IGDB ID. Provide the SetFields functional option if you need to specify which fields to retrieve. If the ID does not match any PlayerPerspectives, an error is returned.

func (*PlayerPerspectiveService) Index 

func (ps *PlayerPerspectiveService) Index(opts ...Option) ([]*PlayerPerspective, error)

Index returns an index of PlayerPerspectives based solely on the provided functional options used to sort, filter, and paginate the results. If no PlayerPerspectives can be found using the provided options, an error is returned.

func (*PlayerPerspectiveService) List 

func (ps *PlayerPerspectiveService) List(ids []int, opts ...Option) ([]*PlayerPerspective, error)

List returns a list of PlayerPerspectives identified by the provided list of IGDB IDs. Provide functional options to sort, filter, and paginate the results. Any ID that does not match a PlayerPerspective is ignored. If none of the IDs match a PlayerPerspective, an error is returned.

type ProductFamily 

type ProductFamily struct {
	ID   int    `json:"id"`
	Name string `json:"name"`
	Slug string `json:"slug"`
}

ProductFamily represents a collection of closely related platforms. For more information visit: https://api-docs.igdb.com/#product-family

type ProductFamilyService 

type ProductFamilyService service

ProductFamilyService handles all the API calls for the IGDB ProductFamily endpoint.

func (*ProductFamilyService) Count 

func (ps *ProductFamilyService) Count(opts ...Option) (int, error)

Count returns the number of ProductFamilies available in the IGDB. Provide the SetFilter functional option if you need to filter which ProductFamilies to count.

func (*ProductFamilyService) Fields 

func (ps *ProductFamilyService) Fields() ([]string, error)

Fields returns the up-to-date list of fields in an IGDB ProductFamily object.

func (*ProductFamilyService) Get 

func (ps *ProductFamilyService) Get(id int, opts ...Option) (*ProductFamily, error)

Get returns a single ProductFamily identified by the provided IGDB ID. Provide the SetFields functional option if you need to specify which fields to retrieve. If the ID does not match any ProductFamilies, an error is returned.

func (*ProductFamilyService) Index 

func (ps *ProductFamilyService) Index(opts ...Option) ([]*ProductFamily, error)

Index returns an index of ProductFamilies based solely on the provided functional options used to sort, filter, and paginate the results. If no ProductFamilies can be found using the provided options, an error is returned.

func (*ProductFamilyService) List 

func (ps *ProductFamilyService) List(ids []int, opts ...Option) ([]*ProductFamily, error)

List returns a list of ProductFamilies identified by the provided list of IGDB IDs. Provide functional options to sort, filter, and paginate the results. Any ID that does not match a ProductFamily is ignored. If none of the IDs match a ProductFamily, an error is returned.

type Pulse 

type Pulse struct {
	ID          int      `json:"id"`
	Author      string   `json:"author"`
	CreatedAt   int      `json:"created_at"`
	Image       string   `json:"image"`
	PublishedAt int      `json:"published_at"`
	PulseSource int      `json:"pulse_source"`
	Summary     string   `json:"summary"`
	Tags        []Tag    `json:"tags"`
	Title       string   `json:"title"`
	UID         string   `json:"uid"`
	UpdatedAt   int      `json:"updated_at"`
	Videos      []string `json:"videos"`
	Website     int      `json:"website"`
}

Pulse represents a single news article. For more information visit: https://api-docs.igdb.com/#pulse

type PulseGroup 

type PulseGroup struct {
	ID          int    `json:"id"`
	CreatedAt   int    `json:"created_at"`
	Game        int    `json:"game"`
	Name        string `json:"name"`
	PublishedAt int    `json:"published_at"`
	Pulses      []int  `json:"pulses"`
	Tags        []Tag  `json:"tags"`
	UpdatedAt   int    `json:"updated_at"`
}

PulseGroup represents a combined array of news articles about a specific game that were published around the same time period. For more information visit: https://api-docs.igdb.com/#pulse-group

type PulseGroupService 

type PulseGroupService service

PulseGroupService handles all the API calls for the IGDB PulseGroup endpoint.

func (*PulseGroupService) Count 

func (ps *PulseGroupService) Count(opts ...Option) (int, error)

Count returns the number of PulseGroups available in the IGDB. Provide the SetFilter functional option if you need to filter which PulseGroups to count.

func (*PulseGroupService) Fields 

func (ps *PulseGroupService) Fields() ([]string, error)

Fields returns the up-to-date list of fields in an IGDB PulseGroup object.

func (*PulseGroupService) Get 

func (ps *PulseGroupService) Get(id int, opts ...Option) (*PulseGroup, error)

Get returns a single PulseGroup identified by the provided IGDB ID. Provide the SetFields functional option if you need to specify which fields to retrieve. If the ID does not match any PulseGroups, an error is returned.

func (*PulseGroupService) Index 

func (ps *PulseGroupService) Index(opts ...Option) ([]*PulseGroup, error)

Index returns an index of PulseGroups based solely on the provided functional options used to sort, filter, and paginate the results. If no PulseGroups can be found using the provided options, an error is returned.

func (*PulseGroupService) List 

func (ps *PulseGroupService) List(ids []int, opts ...Option) ([]*PulseGroup, error)

List returns a list of PulseGroups identified by the provided list of IGDB IDs. Provide functional options to sort, filter, and paginate the results. Any ID that does not match a PulseGroup is ignored. If none of the IDs match a PulseGroup, an error is returned.

type PulseService 

type PulseService service

PulseService handles all the API calls for the IGDB Pulse endpoint.

func (*PulseService) Count 

func (ps *PulseService) Count(opts ...Option) (int, error)

Count returns the number of Pulses available in the IGDB. Provide the SetFilter functional option if you need to filter which Pulses to count.

func (*PulseService) Fields 

func (ps *PulseService) Fields() ([]string, error)

Fields returns the up-to-date list of fields in an IGDB Pulse object.

func (*PulseService) Get 

func (ps *PulseService) Get(id int, opts ...Option) (*Pulse, error)

Get returns a single Pulse identified by the provided IGDB ID. Provide the SetFields functional option if you need to specify which fields to retrieve. If the ID does not match any Pulses, an error is returned.

func (*PulseService) Index 

func (ps *PulseService) Index(opts ...Option) ([]*Pulse, error)

Index returns an index of Pulses based solely on the provided functional options used to sort, filter, and paginate the results. If no Pulses can be found using the provided options, an error is returned.

func (*PulseService) List 

func (ps *PulseService) List(ids []int, opts ...Option) ([]*Pulse, error)

List returns a list of Pulses identified by the provided list of IGDB IDs. Provide functional options to sort, filter, and paginate the results. Any ID that does not match a Pulse is ignored. If none of the IDs match a Pulse, an error is returned.

type PulseSource 

type PulseSource struct {
	ID   int    `json:"id"`
	Game int    `json:"game"`
	Name string `json:"name"`
	Page int    `json:"page"`
}

PulseSource represents a news article source such as IGN. For more information visit: https://api-docs.igdb.com/#pulse-source

type PulseSourceService 

type PulseSourceService service

PulseSourceService handles all the API calls for the IGDB PulseSource endpoint.

func (*PulseSourceService) Count 

func (ps *PulseSourceService) Count(opts ...Option) (int, error)

Count returns the number of PulseSources available in the IGDB. Provide the SetFilter functional option if you need to filter which PulseSources to count.

func (*PulseSourceService) Fields 

func (ps *PulseSourceService) Fields() ([]string, error)

Fields returns the up-to-date list of fields in an IGDB PulseSource object.

func (*PulseSourceService) Get 

func (ps *PulseSourceService) Get(id int, opts ...Option) (*PulseSource, error)

Get returns a single PulseSource identified by the provided IGDB ID. Provide the SetFields functional option if you need to specify which fields to retrieve. If the ID does not match any PulseSources, an error is returned.

func (*PulseSourceService) Index 

func (ps *PulseSourceService) Index(opts ...Option) ([]*PulseSource, error)

Index returns an index of PulseSources based solely on the provided functional options used to sort, filter, and paginate the results. If no PulseSources can be found using the provided options, an error is returned.

func (*PulseSourceService) List 

func (ps *PulseSourceService) List(ids []int, opts ...Option) ([]*PulseSource, error)

List returns a list of PulseSources identified by the provided list of IGDB IDs. Provide functional options to sort, filter, and paginate the results. Any ID that does not match a PulseSource is ignored. If none of the IDs match a PulseSource, an error is returned.

type PulseURL 

type PulseURL struct {
	ID      int    `json:"id"`
	Trusted bool   `json:"trusted"`
	URL     string `json:"url"`
}

PulseURL represents a URL linking to an article. For more information visit: https://api-docs.igdb.com/#pulse-url

type PulseURLService 

type PulseURLService service

PulseURLService handles all the API calls for the IGDB PulseURL endpoint.

func (*PulseURLService) Count 

func (ps *PulseURLService) Count(opts ...Option) (int, error)

Count returns the number of PulseURLs available in the IGDB. Provide the SetFilter functional option if you need to filter which PulseURLs to count.

func (*PulseURLService) Fields 

func (ps *PulseURLService) Fields() ([]string, error)

Fields returns the up-to-date list of fields in an IGDB PulseURL object.

func (*PulseURLService) Get 

func (ps *PulseURLService) Get(id int, opts ...Option) (*PulseURL, error)

Get returns a single PulseURL identified by the provided IGDB ID. Provide the SetFields functional option if you need to specify which fields to retrieve. If the ID does not match any PulseURLs, an error is returned.

func (*PulseURLService) Index 

func (ps *PulseURLService) Index(opts ...Option) ([]*PulseURL, error)

Index returns an index of PulseURLs based solely on the provided functional options used to sort, filter, and paginate the results. If no PulseURLs can be found using the provided options, an error is returned.

func (*PulseURLService) List 

func (ps *PulseURLService) List(ids []int, opts ...Option) ([]*PulseURL, error)

List returns a list of PulseURLs identified by the provided list of IGDB IDs. Provide functional options to sort, filter, and paginate the results. Any ID that does not match a PulseURL is ignored. If none of the IDs match a PulseURL, an error is returned.

func (*PulseURLService) Search 

func (ps *PulseURLService) Search(qry string, opts ...Option) ([]*PulseURL, error)

Search returns a list of PulseURLs found by searching the IGDB using the provided query. Provide functional options to sort, filter, and paginate the results. If no PulseURLs are found using the provided query, an error is returned.

type Rate 

type Rate struct {
	ID     int     `json:"id"`
	Rating float64 `json:"rating"`
	User   int     `json:"user"`
}

Rate represents a user's rating. For more information visit: https://api-docs.igdb.com/#rate

type RateService 

type RateService service

RateService handles all the API calls for the IGDB Rate endpoint.

func (*RateService) Count 

func (rs *RateService) Count(opts ...Option) (int, error)

Count returns the number of Rates available in the IGDB. Provide the SetFilter functional option if you need to filter which Rates to count.

func (*RateService) Fields 

func (rs *RateService) Fields() ([]string, error)

Fields returns the up-to-date list of fields in an IGDB Rate object.

func (*RateService) Get 

func (rs *RateService) Get(id int, opts ...Option) (*Rate, error)

Get returns a single Rate identified by the provided IGDB ID. Provide the SetFields functional option if you need to specify which fields to retrieve. If the ID does not match any Rates, an error is returned.

func (*RateService) Index 

func (rs *RateService) Index(opts ...Option) ([]*Rate, error)

Index returns an index of Rates based solely on the provided functional options used to sort, filter, and paginate the results. If no Rates can be found using the provided options, an error is returned.

func (*RateService) List 

func (rs *RateService) List(ids []int, opts ...Option) ([]*Rate, error)

List returns a list of Rates identified by the provided list of IGDB IDs. Provide functional options to sort, filter, and paginate the results. Any ID that does not match a Rate is ignored. If none of the IDs match a Rate, an error is returned.

type RegionCategory 

type RegionCategory int

RegionCategory specifies a specific geographic region. 

const (
	RegionEurope RegionCategory = iota + 1
	RegionNorthAmerica
	RegionAustralia
	RegionNewZealand
	RegionJapan
	RegionChina
	RegionAsia
	RegionWorldwide
)

Expected RegionCategory enums from the IGDB.

func (RegionCategory) String 

func (i RegionCategory) String() string

type ReleaseDate 

type ReleaseDate struct {
	ID        int            `json:"id"`
	Category  DateCategory   `json:"category"`
	CreatedAt int            `json:"created_at"`
	Date      int            `json:"date"`
	Game      int            `json:"game"`
	Human     string         `json:"human"`
	M         int            `json:"m"`
	Platform  int            `json:"platform"`
	Region    RegionCategory `json:"region"`
	UpdatedAt int            `json:"updated_at"`
	Y         int            `json:"y"`
}

ReleaseDate represents the release date for a particular game. Used to dig deeper into release dates, platforms, and versions. For more information visit: https://api-docs.igdb.com/#release-date

type ReleaseDateService 

type ReleaseDateService service

ReleaseDateService handles all the API calls for the IGDB ReleaseDate endpoint.

func (*ReleaseDateService) Count 

func (rs *ReleaseDateService) Count(opts ...Option) (int, error)

Count returns the number of ReleaseDates available in the IGDB. Provide the SetFilter functional option if you need to filter which ReleaseDates to count.

func (*ReleaseDateService) Fields 

func (rs *ReleaseDateService) Fields() ([]string, error)

Fields returns the up-to-date list of fields in an IGDB ReleaseDate object.

func (*ReleaseDateService) Get 

func (rs *ReleaseDateService) Get(id int, opts ...Option) (*ReleaseDate, error)

Get returns a single ReleaseDate identified by the provided IGDB ID. Provide the SetFields functional option if you need to specify which fields to retrieve. If the ID does not match any ReleaseDates, an error is returned.

func (*ReleaseDateService) Index 

func (rs *ReleaseDateService) Index(opts ...Option) ([]*ReleaseDate, error)

Index returns an index of ReleaseDates based solely on the provided functional options used to sort, filter, and paginate the results. If no ReleaseDates can be found using the provided options, an error is returned.

func (*ReleaseDateService) List 

func (rs *ReleaseDateService) List(ids []int, opts ...Option) ([]*ReleaseDate, error)

List returns a list of ReleaseDates identified by the provided list of IGDB IDs. Provide functional options to sort, filter, and paginate the results. Any ID that does not match a ReleaseDate is ignored. If none of the IDs match a ReleaseDate, an error is returned.

type Review 

type Review struct {
	ID             int            `json:"id"`
	Category       ReviewCategory `json:"category"`
	Conclusion     string         `json:"conclusion"`
	Content        string         `json:"content"`
	CreatedAt      int            `json:"created_at"`
	Game           int            `json:"game"`
	Introduction   string         `json:"introduction"`
	Likes          int            `json:"likes"`
	NegativePoints string         `json:"negative_points"`
	Platform       int            `json:"platform"`
	PositivePoints string         `json:"positive_points"`
	Slug           string         `json:"slug"`
	Title          string         `json:"title"`
	UpdatedAt      int            `json:"updated_at"`
	URL            string         `json:"url"`
	User           int            `json:"user"`
	UserRating     int            `json:"user_rating"`
	Video          int            `json:"video"`
	Views          int            `json:"views"`
}

Review represents a user-created review of a particular video game. For more information visit: https://api-docs.igdb.com/#review-video

type ReviewCategory 

type ReviewCategory int

ReviewCategory specifies the medium of review. 

const (
	ReviewText ReviewCategory = iota + 1
	ReviewVid
)

Expected ReviewCategory enums from the IGDB.

func (ReviewCategory) String 

func (i ReviewCategory) String() string

type ReviewService 

type ReviewService service

ReviewService handles all the API calls for the IGDB Review endpoint.

func (*ReviewService) Count 

func (rs *ReviewService) Count(opts ...Option) (int, error)

Count returns the number of Reviews available in the IGDB. Provide the SetFilter functional option if you need to filter which Reviews to count.

func (*ReviewService) Fields 

func (rs *ReviewService) Fields() ([]string, error)

Fields returns the up-to-date list of fields in an IGDB Review object.

func (*ReviewService) Get 

func (rs *ReviewService) Get(id int, opts ...Option) (*Review, error)

Get returns a single Review identified by the provided IGDB ID. Provide the SetFields functional option if you need to specify which fields to retrieve. If the ID does not match any Reviews, an error is returned.

func (*ReviewService) Index 

func (rs *ReviewService) Index(opts ...Option) ([]*Review, error)

Index returns an index of Reviews based solely on the provided functional options used to sort, filter, and paginate the results. If no Reviews can be found using the provided options, an error is returned.

func (*ReviewService) List 

func (rs *ReviewService) List(ids []int, opts ...Option) ([]*Review, error)

List returns a list of Reviews identified by the provided list of IGDB IDs. Provide functional options to sort, filter, and paginate the results. Any ID that does not match a Review is ignored. If none of the IDs match a Review, an error is returned.

type ReviewVideo 

type ReviewVideo struct {
	ID      int    `json:"id"`
	Trusted bool   `json:"trusted"`
	URL     string `json:"url"`
}

ReviewVideo represents a user-created review video. For more information visit: https://api-docs.igdb.com/#review-video

type ReviewVideoService 

type ReviewVideoService service

ReviewVideoService handles all the API calls for the IGDB ReviewVideo endpoint.

func (*ReviewVideoService) Count 

func (rs *ReviewVideoService) Count(opts ...Option) (int, error)

Count returns the number of ReviewVideos available in the IGDB. Provide the SetFilter functional option if you need to filter which ReviewVideos to count.

func (*ReviewVideoService) Fields 

func (rs *ReviewVideoService) Fields() ([]string, error)

Fields returns the up-to-date list of fields in an IGDB ReviewVideo object.

func (*ReviewVideoService) Get 

func (rs *ReviewVideoService) Get(id int, opts ...Option) (*ReviewVideo, error)

Get returns a single ReviewVideo identified by the provided IGDB ID. Provide the SetFields functional option if you need to specify which fields to retrieve. If the ID does not match any ReviewVideos, an error is returned.

func (*ReviewVideoService) Index 

func (rs *ReviewVideoService) Index(opts ...Option) ([]*ReviewVideo, error)

Index returns an index of ReviewVideos based solely on the provided functional options used to sort, filter, and paginate the results. If no ReviewVideos can be found using the provided options, an error is returned.

func (*ReviewVideoService) List 

func (rs *ReviewVideoService) List(ids []int, opts ...Option) ([]*ReviewVideo, error)

List returns a list of ReviewVideos identified by the provided list of IGDB IDs. Provide functional options to sort, filter, and paginate the results. Any ID that does not match a ReviewVideo is ignored. If none of the IDs match a ReviewVideo, an error is returned.

type Screenshot 

type Screenshot struct {
	Image `json:"image"`
	ID    int `json:"id"`
	Game  int `json:"game"`
}

Screenshot represents a screenshot of a particular game. For more information visit: https://api-docs.igdb.com/#screenshot

type ScreenshotService 

type ScreenshotService service

ScreenshotService handles all the API calls for the IGDB Screenshot endpoint.

func (*ScreenshotService) Count 

func (ss *ScreenshotService) Count(opts ...Option) (int, error)

Count returns the number of Screenshots available in the IGDB. Provide the SetFilter functional option if you need to filter which Screenshots to count.

func (*ScreenshotService) Fields 

func (ss *ScreenshotService) Fields() ([]string, error)

Fields returns the up-to-date list of fields in an IGDB Screenshot object.

func (*ScreenshotService) Get 

func (ss *ScreenshotService) Get(id int, opts ...Option) (*Screenshot, error)

Get returns a single Screenshot identified by the provided IGDB ID. Provide the SetFields functional option if you need to specify which fields to retrieve. If the ID does not match any Screenshots, an error is returned.

func (*ScreenshotService) Index 

func (ss *ScreenshotService) Index(opts ...Option) ([]*Screenshot, error)

Index returns an index of Screenshots based solely on the provided functional options used to sort, filter, and paginate the results. If no Screenshots can be found using the provided options, an error is returned.

func (*ScreenshotService) List 

func (ss *ScreenshotService) List(ids []int, opts ...Option) ([]*Screenshot, error)

List returns a list of Screenshots identified by the provided list of IGDB IDs. Provide functional options to sort, filter, and paginate the results. Any ID that does not match a Screenshot is ignored. If none of the IDs match a Screenshot, an error is returned.

type SearchResult 

type SearchResult struct {
	AlternativeName string  `json:"alternative_name"`
	Character       int     `json:"character"`
	Collection      int     `json:"collection"`
	Company         int     `json:"company"`
	Description     string  `json:"description"`
	Game            int     `json:"game"`
	Name            string  `json:"name"`
	Person          int     `json:"person"`
	Platform        int     `json:"platform"`
	Popularity      float64 `json:"popularity"`
	PublishedAt     int     `json:"published_at"`
	TestDummy       int     `json:"test_dummy"`
	Theme           int     `json:"theme"`
}

SearchResult represents a result from searching the IGDB. It can contain: Characters, Collections Games, People, Platforms, and Themes.

type ServerError 

type ServerError struct {
	Status int    `json:"status"`
	Msg    string `json:"message"`
}

ServerError contains information on an error returned from an IGDB API call.

func (ServerError) Error 

func (e ServerError) Error() string

Error formats the ServerError and fulfills the error interface.

type SocialMetric 

type SocialMetric struct {
	ID                 int                  `json:"id"`
	Category           SocialMetricCategory `json:"category"`
	CreatedAt          int                  `json:"created_at"`
	SocialMetricSource int                  `json:"social_metric_source"`
	Value              int                  `json:"value"`
}

SocialMetric represents a particular social media metric such as follows, likes, shares, views, favorites, etc. For more information visit: https://api-docs.igdb.com/#social-metric

type SocialMetricCategory 

type SocialMetricCategory int

SocialMetricCategory specifies a particular type of social metric. 

const (
	SocialFollows SocialMetricCategory = iota + 1
	SocialLikes
	SocialHates
	SocialShares
	SocialViews
	SocialComments
	SocialFavorites
)

Expected SocialMetricCategory enums from the IGDB.

func (SocialMetricCategory) String 

func (i SocialMetricCategory) String() string

type SocialMetricService 

type SocialMetricService service

SocialMetricService handles all the API calls for the IGDB SocialMetric endpoint.

func (*SocialMetricService) Count 

func (ss *SocialMetricService) Count(opts ...Option) (int, error)

Count returns the number of SocialMetrics available in the IGDB. Provide the SetFilter functional option if you need to filter which SocialMetrics to count.

func (*SocialMetricService) Fields 

func (ss *SocialMetricService) Fields() ([]string, error)

Fields returns the up-to-date list of fields in an IGDB SocialMetric object.

func (*SocialMetricService) Get 

func (ss *SocialMetricService) Get(id int, opts ...Option) (*SocialMetric, error)

Get returns a single SocialMetric identified by the provided IGDB ID. Provide the SetFields functional option if you need to specify which fields to retrieve. If the ID does not match any SocialMetrics, an error is returned.

func (*SocialMetricService) Index 

func (ss *SocialMetricService) Index(opts ...Option) ([]*SocialMetric, error)

Index returns an index of SocialMetrics based solely on the provided functional options used to sort, filter, and paginate the results. If no SocialMetrics can be found using the provided options, an error is returned.

func (*SocialMetricService) List 

func (ss *SocialMetricService) List(ids []int, opts ...Option) ([]*SocialMetric, error)

List returns a list of SocialMetrics identified by the provided list of IGDB IDs. Provide functional options to sort, filter, and paginate the results. Any ID that does not match a SocialMetric is ignored. If none of the IDs match a SocialMetric, an error is returned.

type Status 

type Status struct {
	Authorized   bool        `json:"authorized"`
	Plan         string      `json:"plan"`
	UsageReports UsageReport `json:"usage_reports"`
}

Status contains the usage report for the user's API key along with other metadata. For more information visit: https://api-docs.igdb.com/#api-status

type Tag 

type Tag int

Tag is a generated number that represents a specific IGDB object. Tag provides a quick and compact way to do complex filtering on the IGDB API.

func GenerateTag 

func GenerateTag(typeID tagType, objectID int) (Tag, error)

GenerateTag uses the ID of an IGDB object type and the ID of an IGDB object to generate a Tag addressed to that object. Negative ID values are considered invalid.

func (Tag) String 

func (t Tag) String() string

String returns the provided Tag as a string.

type TestDummy 

type TestDummy struct {
	ID              int           `json:"int"`
	BoolValue       bool          `json:"bool_value"`
	CreatedAt       int           `json:"created_at"`
	EnumTest        TestDummyEnum `json:"enum_test"`
	FloatValue      float64       `json:"float_value"`
	Game            int           `json:"game"`
	IntegerArray    []int         `json:"integer_array"`
	IntegerValue    int           `json:"integer_value"`
	Name            string        `json:"name"`
	NewIntegerValue int           `json:"new_integer_value"`
	Private         bool          `json:"private"`
	Slug            string        `json:"slug"`
	StringArray     []string      `json:"string_array"`
	TestDummies     []int         `json:"test_dummies"`
	TestDummy       int           `json:"test_dummy"`
	UpdatedAt       int           `json:"updated_at"`
	URL             string        `json:"url"`
	User            int           `json:"user"`
}

TestDummy represents a mocked IGDB object. For more information visit: https://api-docs.igdb.com/#test-dummy

type TestDummyEnum 

type TestDummyEnum int

TestDummyEnum mocks an enum. 

const (
	TestDummyEnum1 TestDummyEnum = iota + 1
	TestDummyEnum2
)

Expected TestDummyEnum enums from the IGDB.

func (TestDummyEnum) String 

func (i TestDummyEnum) String() string

type TestDummyService 

type TestDummyService service

TestDummyService handles all the API calls for the IGDB TestDummy endpoint.

func (*TestDummyService) Count 

func (ts *TestDummyService) Count(opts ...Option) (int, error)

Count returns the number of TestDummies available in the IGDB. Provide the SetFilter functional option if you need to filter which TestDummies to count.

func (*TestDummyService) Fields 

func (ts *TestDummyService) Fields() ([]string, error)

Fields returns the up-to-date list of fields in an IGDB TestDummy object.

func (*TestDummyService) Get 

func (ts *TestDummyService) Get(id int, opts ...Option) (*TestDummy, error)

Get returns a single TestDummy identified by the provided IGDB ID. Provide the SetFields functional option if you need to specify which fields to retrieve. If the ID does not match any TestDummies, an error is returned.

func (*TestDummyService) Index 

func (ts *TestDummyService) Index(opts ...Option) ([]*TestDummy, error)

Index returns an index of TestDummies based solely on the provided functional options used to sort, filter, and paginate the results. If no TestDummies can be found using the provided options, an error is returned.

func (*TestDummyService) List 

func (ts *TestDummyService) List(ids []int, opts ...Option) ([]*TestDummy, error)

List returns a list of TestDummies identified by the provided list of IGDB IDs. Provide functional options to sort, filter, and paginate the results. Any ID that does not match a TestDummy is ignored. If none of the IDs match a TestDummy, an error is returned.

type Theme 

type Theme struct {
	ID        int    `json:"id"`
	CreatedAt int    `json:"created_at"`
	Name      string `json:"name"`
	Slug      string `json:"slug"`
	UpdatedAt int    `json:"updated_at"`
	URL       string `json:"url"`
}

Theme represents a particular video game theme. For more information visit: https://api-docs.igdb.com/#theme

type ThemeService 

type ThemeService service

ThemeService handles all the API calls for the IGDB Theme endpoint.

func (*ThemeService) Count 

func (ts *ThemeService) Count(opts ...Option) (int, error)

Count returns the number of Themes available in the IGDB. Provide the SetFilter functional option if you need to filter which Themes to count.

func (*ThemeService) Fields 

func (ts *ThemeService) Fields() ([]string, error)

Fields returns the up-to-date list of fields in an IGDB Theme object.

func (*ThemeService) Get 

func (ts *ThemeService) Get(id int, opts ...Option) (*Theme, error)

Get returns a single Theme identified by the provided IGDB ID. Provide the SetFields functional option if you need to specify which fields to retrieve. If the ID does not match any Themes, an error is returned.

func (*ThemeService) Index 

func (ts *ThemeService) Index(opts ...Option) ([]*Theme, error)

Index returns an index of Themes based solely on the provided functional options used to sort, filter, and paginate the results. If no Themes can be found using the provided options, an error is returned.

func (*ThemeService) List 

func (ts *ThemeService) List(ids []int, opts ...Option) ([]*Theme, error)

List returns a list of Themes identified by the provided list of IGDB IDs. Provide functional options to sort, filter, and paginate the results. Any ID that does not match a Theme is ignored. If none of the IDs match a Theme, an error is returned.

func (*ThemeService) Search 

func (ts *ThemeService) Search(qry string, opts ...Option) ([]*Theme, error)

Search returns a list of Themes found by searching the IGDB using the provided query. Provide functional options to sort, filter, and paginate the results. If no Themes are found using the provided query, an error is returned.

type TimeToBeat 

type TimeToBeat struct {
	ID         int `json:"id"`
	Completely int `json:"completely"`
	Game       int `json:"game"`
	Hastly     int `json:"hastly"`
	Normally   int `json:"normally"`
}

TimeToBeat represents the average completion times for a particular game. For more information: https://api-docs.igdb.com/#time-to-beat

type TimeToBeatService 

type TimeToBeatService service

TimeToBeatService handles all the API calls for the IGDB TimeToBeat endpoint.

func (*TimeToBeatService) Count 

func (ts *TimeToBeatService) Count(opts ...Option) (int, error)

Count returns the number of TimeToBeats available in the IGDB. Provide the SetFilter functional option if you need to filter which TimeToBeats to count.

func (*TimeToBeatService) Fields 

func (ts *TimeToBeatService) Fields() ([]string, error)

Fields returns the up-to-date list of fields in an IGDB TimeToBeat object.

func (*TimeToBeatService) Get 

func (ts *TimeToBeatService) Get(id int, opts ...Option) (*TimeToBeat, error)

Get returns a single TimeToBeat identified by the provided IGDB ID. Provide the SetFields functional option if you need to specify which fields to retrieve. If the ID does not match any TimeToBeats, an error is returned.

func (*TimeToBeatService) Index 

func (ts *TimeToBeatService) Index(opts ...Option) ([]*TimeToBeat, error)

Index returns an index of TimeToBeats based solely on the provided functional options used to sort, filter, and paginate the results. If no TimeToBeats can be found using the provided options, an error is returned.

func (*TimeToBeatService) List 

func (ts *TimeToBeatService) List(ids []int, opts ...Option) ([]*TimeToBeat, error)

List returns a list of TimeToBeats identified by the provided list of IGDB IDs. Provide functional options to sort, filter, and paginate the results. Any ID that does not match a TimeToBeat is ignored. If none of the IDs match a TimeToBeat, an error is returned.

type Title 

type Title struct {
	ID          int    `json:"id"`
	CreatedAt   int    `json:"created_at"`
	Description string `json:"description"`
	Games       []int  `json:"games"`
	Name        string `json:"name"`
	Slug        string `json:"slug"`
	UpdatedAt   int    `json:"updated_at"`
	URL         string `json:"url"`
}

Title represents a particular job title in the game industry. For more information visit: https://api-docs.igdb.com/#title

type TitleService 

type TitleService service

TitleService handles all the API calls for the IGDB Title endpoint.

func (*TitleService) Count 

func (ts *TitleService) Count(opts ...Option) (int, error)

Count returns the number of Titles available in the IGDB. Provide the SetFilter functional option if you need to filter which Titles to count.

func (*TitleService) Fields 

func (ts *TitleService) Fields() ([]string, error)

Fields returns the up-to-date list of fields in an IGDB Title object.

func (*TitleService) Get 

func (ts *TitleService) Get(id int, opts ...Option) (*Title, error)

Get returns a single Title identified by the provided IGDB ID. Provide the SetFields functional option if you need to specify which fields to retrieve. If the ID does not match any Titles, an error is returned.

func (*TitleService) Index 

func (ts *TitleService) Index(opts ...Option) ([]*Title, error)

Index returns an index of Titles based solely on the provided functional options used to sort, filter, and paginate the results. If no Titles can be found using the provided options, an error is returned.

func (*TitleService) List 

func (ts *TitleService) List(ids []int, opts ...Option) ([]*Title, error)

List returns a list of Titles identified by the provided list of IGDB IDs. Provide functional options to sort, filter, and paginate the results. Any ID that does not match a Title is ignored. If none of the IDs match a Title, an error is returned.

type UsageReport 

type UsageReport struct {
	Metric       string `json:"metric"`
	Period       string `json:"period"`
	PeriodStart  string `json:"period_start"`
	PeriodEnd    string `json:"period_end"`
	MaxValue     int    `json:"max_value"`
	CurrentValue int    `json:"current_value"`
}

UsageReport contains information and statistics for the the current user's API usage in the current period.

type VersionFeatureCategory 

type VersionFeatureCategory int

VersionFeatureCategory specifies the type of feature for a particular game. 

const (
	VersionFeatureBoolean VersionFeatureCategory = iota
	VersionFeatureDescription
)

Expected VersionFeatureCategory enums from the IGDB.

func (VersionFeatureCategory) String 

func (i VersionFeatureCategory) String() string

type VersionFeatureInclusion 

type VersionFeatureInclusion int

VersionFeatureInclusion specifies whether a feature is included or not. 

const (
	VersionFeatureNotIncluded VersionFeatureInclusion = iota
	VersionFeatureIncluded
	VersionFeaturePreOrderOnly
)

Expected VersionFeatureInclusion enums from the IGDB.

func (VersionFeatureInclusion) String 

func (i VersionFeatureInclusion) String() string

type Website 

type Website struct {
	ID       int             `json:"id"`
	Category WebsiteCategory `json:"category"`
	Trusted  bool            `json:"trusted"`
	URL      string          `json:"url"`
}

Website represents a website and its URL; usually associated with a game. For more information visit: https://api-docs.igdb.com/#website

type WebsiteCategory 

type WebsiteCategory int

WebsiteCategory specifies a specific popular website. 

const (
	WebsiteOfficial WebsiteCategory = iota + 1
	WebsiteWikia
	WebsiteWikipedia
	WebsiteFacebook
	WebsiteTwitter
	WebsiteTwitch

	WebsiteInstagram
	WebsiteYoutube
	WebsiteIphone
	WebsiteIpad
	WebsiteAndroid
	WebsiteSteam
	WebsiteReddit
	WebsiteDiscord
	WebsiteGooglePlus
	WebsiteTumblr
	WebsiteLinkedin
	WebsitePinterest
	WebsiteSoundcloud
)

Expected WebsiteCategory enums from the IGDB.

type WebsiteService 

type WebsiteService service

WebsiteService handles all the API calls for the IGDB Website endpoint.

func (*WebsiteService) Count 

func (ws *WebsiteService) Count(opts ...Option) (int, error)

Count returns the number of Websites available in the IGDB. Provide the SetFilter functional option if you need to filter which Websites to count.

func (*WebsiteService) Fields 

func (ws *WebsiteService) Fields() ([]string, error)

Fields returns the up-to-date list of fields in an IGDB Website object.

func (*WebsiteService) Get 

func (ws *WebsiteService) Get(id int, opts ...Option) (*Website, error)

Get returns a single Website identified by the provided IGDB ID. Provide the SetFields functional option if you need to specify which fields to retrieve. If the ID does not match any Websites, an error is returned.

func (*WebsiteService) Index 

func (ws *WebsiteService) Index(opts ...Option) ([]*Website, error)

Index returns an index of Websites based solely on the provided functional options used to sort, filter, and paginate the results. If no Websites can be found using the provided options, an error is returned.

func (*WebsiteService) List 

func (ws *WebsiteService) List(ids []int, opts ...Option) ([]*Website, error)

List returns a list of Websites identified by the provided list of IGDB IDs. Provide functional options to sort, filter, and paginate the results. Any ID that does not match a Website is ignored. If none of the IDs match a Website, an error is returned.

Source Files

View all Source files

Directories

Path Synopsis
examples
characterphotos
companycount
topgames

Jump to

Keyboard shortcuts

? : This menu
/ : Search site
f or F : Jump to
y or Y : Canonical URL
go.dev uses cookies from Google to deliver and enhance the quality of its services and to analyze traffic. Learn more.