@space-cow-media/spellbook-client 7.0.5 → 7.1.0

package/spellbook-client/apis/SaltVotesApi.ts

@@ -0,0 +1,386 @@
+/* tslint:disable */
+/* eslint-disable */
+/**
+ * Commander Spellbook API
+ * API for Commander Spellbook, the combo database engine for Magic: The Gathering.  ## Bulk data  Please do not use this API to export the whole dataset: consuming hundreds of result pages every time costs you time and us a ton of resources. Every variant, together with the variant aliases, is published as a single JSON document, refreshed periodically:  * [/variants.json.gz](/variants.json.gz) — gzipped, prefer this one * [/variants.json](/variants.json) — uncompressed  The document holds the `timestamp` it was built at, the `version` that built it, and the `variants` and `aliases` arrays, whose items have the very same shape as the `/variants/` and `/variant-aliases/` responses. Fetch it on a schedule of your own and read it locally.  ## Using this API  Make sparse, unauthenticated requests, with the general guideline of a few HTTP calls per user interaction with your tool.  * Name your service, optionally with a version, in the [User-Agent](https://developer.mozilla.org/en-US/docs/Web/HTTP/Reference/Headers/User-Agent#library_and_net_tool_ua_strings) header. * You may be rate limited: 80 requests per minute should be a safe rate, and clients should always   handle `429 Too Many Requests` responses. * Responses use camelCase keys. * A TypeScript client is published on npm as [`@space-cow-media/spellbook-client`](https://www.npmjs.com/package/@space-cow-media/spellbook-client).  Please credit us, and link back to []() where applicable. Thanks!
+ *
+ * The version of the OpenAPI document: 7.1.0
+ * 
+ *
+ * NOTE: This class is auto generated by OpenAPI Generator (https://openapi-generator.tech).
+ * https://openapi-generator.tech
+ * Do not edit the class manually.
+ */
+
+import * as runtime from '../runtime.js';
+import {
+    type PaginatedSaltVoteList,
+    PaginatedSaltVoteListFromJSON,
+    PaginatedSaltVoteListToJSON,
+} from '../models/PaginatedSaltVoteList.js';
+import {
+    type SaltVote,
+    SaltVoteFromJSON,
+    SaltVoteToJSON,
+} from '../models/SaltVote.js';
+import {
+    type SaltVoteRequest,
+    SaltVoteRequestFromJSON,
+    SaltVoteRequestToJSON,
+} from '../models/SaltVoteRequest.js';
+import {
+    type Variant,
+    VariantFromJSON,
+    VariantToJSON,
+} from '../models/Variant.js';
+
+export interface SaltVotesDestroyRequest {
+    /**
+     * 
+     */
+    variant: string;
+}
+
+export interface SaltVotesListRequest {
+    /**
+     * Set to true to enable count query. If false, count will be omitted.
+     */
+    count?: boolean;
+    /**
+     * Number of results to return per page.
+     */
+    limit?: number;
+    /**
+     * The initial index from which to return the results.
+     */
+    offset?: number;
+    /**
+     * Filters for the vote on the variant with the given id.
+     */
+    variant?: string;
+}
+
+export interface SaltVotesQueueListRequest {
+    /**
+     * Number of variants to return.
+     */
+    limit?: number;
+}
+
+export interface SaltVotesRetrieveRequest {
+    /**
+     * 
+     */
+    variant: string;
+}
+
+export interface SaltVotesUpdateRequest {
+    /**
+     * 
+     */
+    variant: string;
+    /**
+     * 
+     */
+    saltVoteRequest: SaltVoteRequest;
+}
+
+/**
+ * 
+ */
+export class SaltVotesApi extends runtime.BaseAPI {
+
+    /**
+     * Creates request options for saltVotesDestroy without sending the request
+     */
+    async saltVotesDestroyRequestOpts(requestParameters: SaltVotesDestroyRequest): Promise<runtime.RequestOpts> {
+        if (requestParameters['variant'] == null) {
+            throw new runtime.RequiredError(
+                'variant',
+                'Required parameter "variant" was null or undefined when calling saltVotesDestroy().'
+            );
+        }
+
+        const queryParameters: any = {};
+
+        const headerParameters: runtime.HTTPHeaders = {};
+
+        if (this.configuration && (this.configuration.username !== undefined || this.configuration.password !== undefined)) {
+            headerParameters["Authorization"] = "Basic " + btoa(this.configuration.username + ":" + this.configuration.password);
+        }
+        if (this.configuration && this.configuration.accessToken) {
+            const token = this.configuration.accessToken;
+            const tokenString = await token("jwtAuth", []);
+
+            if (tokenString) {
+                headerParameters["Authorization"] = `Bearer ${tokenString}`;
+            }
+        }
+
+        let urlPath = `/salt-votes/{variant}/`;
+        urlPath = urlPath.replace('{variant}', encodeURIComponent(String(requestParameters['variant'])));
+
+        return {
+            path: urlPath,
+            method: 'DELETE',
+            headers: headerParameters,
+            query: queryParameters,
+        };
+    }
+
+    /**
+     * Votes on how salty a combo is, that is how unfun it is to play against, from 0 (not at all) to 4 (the most).  Voting requires logging in. Each user has a single vote per variant, addressed by the variant id: `PUT` casts or changes it, `DELETE` retracts it, and nobody but its author can read it. A vote comes back with the live average and count of the recent votes on its variant.  Only the votes cast or changed in the last year are recent. Every variant shows the average of its recent votes as `salt`, once they are at least five, and their number as `saltVoteCount`, both refreshed every couple of hours: order the variants by `salt`, or search them with terms like `salt>2.5`, to find the saltiest combos.  `queue` serves variants to vote on, drawn at random with a preference for popular ones still short of a hundred recent votes, leaving out those the user already voted on recently.
+     */
+    async saltVotesDestroyRaw(requestParameters: SaltVotesDestroyRequest, initOverrides?: RequestInit | runtime.InitOverrideFunction): Promise<runtime.ApiResponse<void>> {
+        const requestOptions = await this.saltVotesDestroyRequestOpts(requestParameters);
+        const response = await this.request(requestOptions, initOverrides);
+
+        return new runtime.VoidApiResponse(response);
+    }
+
+    /**
+     * Votes on how salty a combo is, that is how unfun it is to play against, from 0 (not at all) to 4 (the most).  Voting requires logging in. Each user has a single vote per variant, addressed by the variant id: `PUT` casts or changes it, `DELETE` retracts it, and nobody but its author can read it. A vote comes back with the live average and count of the recent votes on its variant.  Only the votes cast or changed in the last year are recent. Every variant shows the average of its recent votes as `salt`, once they are at least five, and their number as `saltVoteCount`, both refreshed every couple of hours: order the variants by `salt`, or search them with terms like `salt>2.5`, to find the saltiest combos.  `queue` serves variants to vote on, drawn at random with a preference for popular ones still short of a hundred recent votes, leaving out those the user already voted on recently.
+     */
+    async saltVotesDestroy(requestParameters: SaltVotesDestroyRequest, initOverrides?: RequestInit | runtime.InitOverrideFunction): Promise<void> {
+        await this.saltVotesDestroyRaw(requestParameters, initOverrides);
+    }
+
+    /**
+     * Creates request options for saltVotesList without sending the request
+     */
+    async saltVotesListRequestOpts(requestParameters: SaltVotesListRequest): Promise<runtime.RequestOpts> {
+        const queryParameters: any = {};
+
+        if (requestParameters['count'] != null) {
+            queryParameters['count'] = requestParameters['count'];
+        }
+
+        if (requestParameters['limit'] != null) {
+            queryParameters['limit'] = requestParameters['limit'];
+        }
+
+        if (requestParameters['offset'] != null) {
+            queryParameters['offset'] = requestParameters['offset'];
+        }
+
+        if (requestParameters['variant'] != null) {
+            queryParameters['variant'] = requestParameters['variant'];
+        }
+
+        const headerParameters: runtime.HTTPHeaders = {};
+
+        if (this.configuration && (this.configuration.username !== undefined || this.configuration.password !== undefined)) {
+            headerParameters["Authorization"] = "Basic " + btoa(this.configuration.username + ":" + this.configuration.password);
+        }
+        if (this.configuration && this.configuration.accessToken) {
+            const token = this.configuration.accessToken;
+            const tokenString = await token("jwtAuth", []);
+
+            if (tokenString) {
+                headerParameters["Authorization"] = `Bearer ${tokenString}`;
+            }
+        }
+
+        let urlPath = `/salt-votes/`;
+
+        return {
+            path: urlPath,
+            method: 'GET',
+            headers: headerParameters,
+            query: queryParameters,
+        };
+    }
+
+    /**
+     * Votes on how salty a combo is, that is how unfun it is to play against, from 0 (not at all) to 4 (the most).  Voting requires logging in. Each user has a single vote per variant, addressed by the variant id: `PUT` casts or changes it, `DELETE` retracts it, and nobody but its author can read it. A vote comes back with the live average and count of the recent votes on its variant.  Only the votes cast or changed in the last year are recent. Every variant shows the average of its recent votes as `salt`, once they are at least five, and their number as `saltVoteCount`, both refreshed every couple of hours: order the variants by `salt`, or search them with terms like `salt>2.5`, to find the saltiest combos.  `queue` serves variants to vote on, drawn at random with a preference for popular ones still short of a hundred recent votes, leaving out those the user already voted on recently.
+     */
+    async saltVotesListRaw(requestParameters: SaltVotesListRequest, initOverrides?: RequestInit | runtime.InitOverrideFunction): Promise<runtime.ApiResponse<PaginatedSaltVoteList>> {
+        const requestOptions = await this.saltVotesListRequestOpts(requestParameters);
+        const response = await this.request(requestOptions, initOverrides);
+
+        return new runtime.JSONApiResponse(response, (jsonValue) => PaginatedSaltVoteListFromJSON(jsonValue));
+    }
+
+    /**
+     * Votes on how salty a combo is, that is how unfun it is to play against, from 0 (not at all) to 4 (the most).  Voting requires logging in. Each user has a single vote per variant, addressed by the variant id: `PUT` casts or changes it, `DELETE` retracts it, and nobody but its author can read it. A vote comes back with the live average and count of the recent votes on its variant.  Only the votes cast or changed in the last year are recent. Every variant shows the average of its recent votes as `salt`, once they are at least five, and their number as `saltVoteCount`, both refreshed every couple of hours: order the variants by `salt`, or search them with terms like `salt>2.5`, to find the saltiest combos.  `queue` serves variants to vote on, drawn at random with a preference for popular ones still short of a hundred recent votes, leaving out those the user already voted on recently.
+     */
+    async saltVotesList(requestParameters: SaltVotesListRequest = {}, initOverrides?: RequestInit | runtime.InitOverrideFunction): Promise<PaginatedSaltVoteList> {
+        const response = await this.saltVotesListRaw(requestParameters, initOverrides);
+        return await response.value();
+    }
+
+    /**
+     * Creates request options for saltVotesQueueList without sending the request
+     */
+    async saltVotesQueueListRequestOpts(requestParameters: SaltVotesQueueListRequest): Promise<runtime.RequestOpts> {
+        const queryParameters: any = {};
+
+        if (requestParameters['limit'] != null) {
+            queryParameters['limit'] = requestParameters['limit'];
+        }
+
+        const headerParameters: runtime.HTTPHeaders = {};
+
+        if (this.configuration && (this.configuration.username !== undefined || this.configuration.password !== undefined)) {
+            headerParameters["Authorization"] = "Basic " + btoa(this.configuration.username + ":" + this.configuration.password);
+        }
+        if (this.configuration && this.configuration.accessToken) {
+            const token = this.configuration.accessToken;
+            const tokenString = await token("jwtAuth", []);
+
+            if (tokenString) {
+                headerParameters["Authorization"] = `Bearer ${tokenString}`;
+            }
+        }
+
+        let urlPath = `/salt-votes/queue/`;
+
+        return {
+            path: urlPath,
+            method: 'GET',
+            headers: headerParameters,
+            query: queryParameters,
+        };
+    }
+
+    /**
+     * Votes on how salty a combo is, that is how unfun it is to play against, from 0 (not at all) to 4 (the most).  Voting requires logging in. Each user has a single vote per variant, addressed by the variant id: `PUT` casts or changes it, `DELETE` retracts it, and nobody but its author can read it. A vote comes back with the live average and count of the recent votes on its variant.  Only the votes cast or changed in the last year are recent. Every variant shows the average of its recent votes as `salt`, once they are at least five, and their number as `saltVoteCount`, both refreshed every couple of hours: order the variants by `salt`, or search them with terms like `salt>2.5`, to find the saltiest combos.  `queue` serves variants to vote on, drawn at random with a preference for popular ones still short of a hundred recent votes, leaving out those the user already voted on recently.
+     */
+    async saltVotesQueueListRaw(requestParameters: SaltVotesQueueListRequest, initOverrides?: RequestInit | runtime.InitOverrideFunction): Promise<runtime.ApiResponse<Array<Variant>>> {
+        const requestOptions = await this.saltVotesQueueListRequestOpts(requestParameters);
+        const response = await this.request(requestOptions, initOverrides);
+
+        return new runtime.JSONApiResponse(response, (jsonValue) => jsonValue.map(VariantFromJSON));
+    }
+
+    /**
+     * Votes on how salty a combo is, that is how unfun it is to play against, from 0 (not at all) to 4 (the most).  Voting requires logging in. Each user has a single vote per variant, addressed by the variant id: `PUT` casts or changes it, `DELETE` retracts it, and nobody but its author can read it. A vote comes back with the live average and count of the recent votes on its variant.  Only the votes cast or changed in the last year are recent. Every variant shows the average of its recent votes as `salt`, once they are at least five, and their number as `saltVoteCount`, both refreshed every couple of hours: order the variants by `salt`, or search them with terms like `salt>2.5`, to find the saltiest combos.  `queue` serves variants to vote on, drawn at random with a preference for popular ones still short of a hundred recent votes, leaving out those the user already voted on recently.
+     */
+    async saltVotesQueueList(requestParameters: SaltVotesQueueListRequest = {}, initOverrides?: RequestInit | runtime.InitOverrideFunction): Promise<Array<Variant>> {
+        const response = await this.saltVotesQueueListRaw(requestParameters, initOverrides);
+        return await response.value();
+    }
+
+    /**
+     * Creates request options for saltVotesRetrieve without sending the request
+     */
+    async saltVotesRetrieveRequestOpts(requestParameters: SaltVotesRetrieveRequest): Promise<runtime.RequestOpts> {
+        if (requestParameters['variant'] == null) {
+            throw new runtime.RequiredError(
+                'variant',
+                'Required parameter "variant" was null or undefined when calling saltVotesRetrieve().'
+            );
+        }
+
+        const queryParameters: any = {};
+
+        const headerParameters: runtime.HTTPHeaders = {};
+
+        if (this.configuration && (this.configuration.username !== undefined || this.configuration.password !== undefined)) {
+            headerParameters["Authorization"] = "Basic " + btoa(this.configuration.username + ":" + this.configuration.password);
+        }
+        if (this.configuration && this.configuration.accessToken) {
+            const token = this.configuration.accessToken;
+            const tokenString = await token("jwtAuth", []);
+
+            if (tokenString) {
+                headerParameters["Authorization"] = `Bearer ${tokenString}`;
+            }
+        }
+
+        let urlPath = `/salt-votes/{variant}/`;
+        urlPath = urlPath.replace('{variant}', encodeURIComponent(String(requestParameters['variant'])));
+
+        return {
+            path: urlPath,
+            method: 'GET',
+            headers: headerParameters,
+            query: queryParameters,
+        };
+    }
+
+    /**
+     * Votes on how salty a combo is, that is how unfun it is to play against, from 0 (not at all) to 4 (the most).  Voting requires logging in. Each user has a single vote per variant, addressed by the variant id: `PUT` casts or changes it, `DELETE` retracts it, and nobody but its author can read it. A vote comes back with the live average and count of the recent votes on its variant.  Only the votes cast or changed in the last year are recent. Every variant shows the average of its recent votes as `salt`, once they are at least five, and their number as `saltVoteCount`, both refreshed every couple of hours: order the variants by `salt`, or search them with terms like `salt>2.5`, to find the saltiest combos.  `queue` serves variants to vote on, drawn at random with a preference for popular ones still short of a hundred recent votes, leaving out those the user already voted on recently.
+     */
+    async saltVotesRetrieveRaw(requestParameters: SaltVotesRetrieveRequest, initOverrides?: RequestInit | runtime.InitOverrideFunction): Promise<runtime.ApiResponse<SaltVote>> {
+        const requestOptions = await this.saltVotesRetrieveRequestOpts(requestParameters);
+        const response = await this.request(requestOptions, initOverrides);
+
+        return new runtime.JSONApiResponse(response, (jsonValue) => SaltVoteFromJSON(jsonValue));
+    }
+
+    /**
+     * Votes on how salty a combo is, that is how unfun it is to play against, from 0 (not at all) to 4 (the most).  Voting requires logging in. Each user has a single vote per variant, addressed by the variant id: `PUT` casts or changes it, `DELETE` retracts it, and nobody but its author can read it. A vote comes back with the live average and count of the recent votes on its variant.  Only the votes cast or changed in the last year are recent. Every variant shows the average of its recent votes as `salt`, once they are at least five, and their number as `saltVoteCount`, both refreshed every couple of hours: order the variants by `salt`, or search them with terms like `salt>2.5`, to find the saltiest combos.  `queue` serves variants to vote on, drawn at random with a preference for popular ones still short of a hundred recent votes, leaving out those the user already voted on recently.
+     */
+    async saltVotesRetrieve(requestParameters: SaltVotesRetrieveRequest, initOverrides?: RequestInit | runtime.InitOverrideFunction): Promise<SaltVote> {
+        const response = await this.saltVotesRetrieveRaw(requestParameters, initOverrides);
+        return await response.value();
+    }
+
+    /**
+     * Creates request options for saltVotesUpdate without sending the request
+     */
+    async saltVotesUpdateRequestOpts(requestParameters: SaltVotesUpdateRequest): Promise<runtime.RequestOpts> {
+        if (requestParameters['variant'] == null) {
+            throw new runtime.RequiredError(
+                'variant',
+                'Required parameter "variant" was null or undefined when calling saltVotesUpdate().'
+            );
+        }
+
+        if (requestParameters['saltVoteRequest'] == null) {
+            throw new runtime.RequiredError(
+                'saltVoteRequest',
+                'Required parameter "saltVoteRequest" was null or undefined when calling saltVotesUpdate().'
+            );
+        }
+
+        const queryParameters: any = {};
+
+        const headerParameters: runtime.HTTPHeaders = {};
+
+        headerParameters['Content-Type'] = 'application/json';
+
+        if (this.configuration && (this.configuration.username !== undefined || this.configuration.password !== undefined)) {
+            headerParameters["Authorization"] = "Basic " + btoa(this.configuration.username + ":" + this.configuration.password);
+        }
+        if (this.configuration && this.configuration.accessToken) {
+            const token = this.configuration.accessToken;
+            const tokenString = await token("jwtAuth", []);
+
+            if (tokenString) {
+                headerParameters["Authorization"] = `Bearer ${tokenString}`;
+            }
+        }
+
+        let urlPath = `/salt-votes/{variant}/`;
+        urlPath = urlPath.replace('{variant}', encodeURIComponent(String(requestParameters['variant'])));
+
+        return {
+            path: urlPath,
+            method: 'PUT',
+            headers: headerParameters,
+            query: queryParameters,
+            body: SaltVoteRequestToJSON(requestParameters['saltVoteRequest']),
+        };
+    }
+
+    /**
+     * Votes on how salty a combo is, that is how unfun it is to play against, from 0 (not at all) to 4 (the most).  Voting requires logging in. Each user has a single vote per variant, addressed by the variant id: `PUT` casts or changes it, `DELETE` retracts it, and nobody but its author can read it. A vote comes back with the live average and count of the recent votes on its variant.  Only the votes cast or changed in the last year are recent. Every variant shows the average of its recent votes as `salt`, once they are at least five, and their number as `saltVoteCount`, both refreshed every couple of hours: order the variants by `salt`, or search them with terms like `salt>2.5`, to find the saltiest combos.  `queue` serves variants to vote on, drawn at random with a preference for popular ones still short of a hundred recent votes, leaving out those the user already voted on recently.
+     */
+    async saltVotesUpdateRaw(requestParameters: SaltVotesUpdateRequest, initOverrides?: RequestInit | runtime.InitOverrideFunction): Promise<runtime.ApiResponse<SaltVote>> {
+        const requestOptions = await this.saltVotesUpdateRequestOpts(requestParameters);
+        const response = await this.request(requestOptions, initOverrides);
+
+        return new runtime.JSONApiResponse(response, (jsonValue) => SaltVoteFromJSON(jsonValue));
+    }
+
+    /**
+     * Votes on how salty a combo is, that is how unfun it is to play against, from 0 (not at all) to 4 (the most).  Voting requires logging in. Each user has a single vote per variant, addressed by the variant id: `PUT` casts or changes it, `DELETE` retracts it, and nobody but its author can read it. A vote comes back with the live average and count of the recent votes on its variant.  Only the votes cast or changed in the last year are recent. Every variant shows the average of its recent votes as `salt`, once they are at least five, and their number as `saltVoteCount`, both refreshed every couple of hours: order the variants by `salt`, or search them with terms like `salt>2.5`, to find the saltiest combos.  `queue` serves variants to vote on, drawn at random with a preference for popular ones still short of a hundred recent votes, leaving out those the user already voted on recently.
+     */
+    async saltVotesUpdate(requestParameters: SaltVotesUpdateRequest, initOverrides?: RequestInit | runtime.InitOverrideFunction): Promise<SaltVote> {
+        const response = await this.saltVotesUpdateRaw(requestParameters, initOverrides);
+        return await response.value();
+    }
+
+}

package/spellbook-client/apis/TemplatesApi.ts

@@ -4,7 +4,7 @@
  * Commander Spellbook API
  * API for Commander Spellbook, the combo database engine for Magic: The Gathering.  ## Bulk data  Please do not use this API to export the whole dataset: consuming hundreds of result pages every time costs you time and us a ton of resources. Every variant, together with the variant aliases, is published as a single JSON document, refreshed periodically:  * [/variants.json.gz](/variants.json.gz) — gzipped, prefer this one * [/variants.json](/variants.json) — uncompressed  The document holds the `timestamp` it was built at, the `version` that built it, and the `variants` and `aliases` arrays, whose items have the very same shape as the `/variants/` and `/variant-aliases/` responses. Fetch it on a schedule of your own and read it locally.  ## Using this API  Make sparse, unauthenticated requests, with the general guideline of a few HTTP calls per user interaction with your tool.  * Name your service, optionally with a version, in the [User-Agent](https://developer.mozilla.org/en-US/docs/Web/HTTP/Reference/Headers/User-Agent#library_and_net_tool_ua_strings) header. * You may be rate limited: 80 requests per minute should be a safe rate, and clients should always   handle `429 Too Many Requests` responses. * Responses use camelCase keys. * A TypeScript client is published on npm as [`@space-cow-media/spellbook-client`](https://www.npmjs.com/package/@space-cow-media/spellbook-client).  Please credit us, and link back to []() where applicable. Thanks!
  *
- * The version of the OpenAPI document: 7.0.5
+ * The version of the OpenAPI document: 7.1.0
  * 
  *
  * NOTE: This class is auto generated by OpenAPI Generator (https://openapi-generator.tech).

package/spellbook-client/apis/TokenApi.ts

@@ -4,7 +4,7 @@
  * Commander Spellbook API
  * API for Commander Spellbook, the combo database engine for Magic: The Gathering.  ## Bulk data  Please do not use this API to export the whole dataset: consuming hundreds of result pages every time costs you time and us a ton of resources. Every variant, together with the variant aliases, is published as a single JSON document, refreshed periodically:  * [/variants.json.gz](/variants.json.gz) — gzipped, prefer this one * [/variants.json](/variants.json) — uncompressed  The document holds the `timestamp` it was built at, the `version` that built it, and the `variants` and `aliases` arrays, whose items have the very same shape as the `/variants/` and `/variant-aliases/` responses. Fetch it on a schedule of your own and read it locally.  ## Using this API  Make sparse, unauthenticated requests, with the general guideline of a few HTTP calls per user interaction with your tool.  * Name your service, optionally with a version, in the [User-Agent](https://developer.mozilla.org/en-US/docs/Web/HTTP/Reference/Headers/User-Agent#library_and_net_tool_ua_strings) header. * You may be rate limited: 80 requests per minute should be a safe rate, and clients should always   handle `429 Too Many Requests` responses. * Responses use camelCase keys. * A TypeScript client is published on npm as [`@space-cow-media/spellbook-client`](https://www.npmjs.com/package/@space-cow-media/spellbook-client).  Please credit us, and link back to []() where applicable. Thanks!
  *
- * The version of the OpenAPI document: 7.0.5
+ * The version of the OpenAPI document: 7.1.0
  * 
  *
  * NOTE: This class is auto generated by OpenAPI Generator (https://openapi-generator.tech).

package/spellbook-client/apis/UsersApi.ts

@@ -4,7 +4,7 @@
  * Commander Spellbook API
  * API for Commander Spellbook, the combo database engine for Magic: The Gathering.  ## Bulk data  Please do not use this API to export the whole dataset: consuming hundreds of result pages every time costs you time and us a ton of resources. Every variant, together with the variant aliases, is published as a single JSON document, refreshed periodically:  * [/variants.json.gz](/variants.json.gz) — gzipped, prefer this one * [/variants.json](/variants.json) — uncompressed  The document holds the `timestamp` it was built at, the `version` that built it, and the `variants` and `aliases` arrays, whose items have the very same shape as the `/variants/` and `/variant-aliases/` responses. Fetch it on a schedule of your own and read it locally.  ## Using this API  Make sparse, unauthenticated requests, with the general guideline of a few HTTP calls per user interaction with your tool.  * Name your service, optionally with a version, in the [User-Agent](https://developer.mozilla.org/en-US/docs/Web/HTTP/Reference/Headers/User-Agent#library_and_net_tool_ua_strings) header. * You may be rate limited: 80 requests per minute should be a safe rate, and clients should always   handle `429 Too Many Requests` responses. * Responses use camelCase keys. * A TypeScript client is published on npm as [`@space-cow-media/spellbook-client`](https://www.npmjs.com/package/@space-cow-media/spellbook-client).  Please credit us, and link back to []() where applicable. Thanks!
  *
- * The version of the OpenAPI document: 7.0.5
+ * The version of the OpenAPI document: 7.1.0
  * 
  *
  * NOTE: This class is auto generated by OpenAPI Generator (https://openapi-generator.tech).

package/spellbook-client/apis/VariantAliasesApi.ts

@@ -4,7 +4,7 @@
  * Commander Spellbook API
  * API for Commander Spellbook, the combo database engine for Magic: The Gathering.  ## Bulk data  Please do not use this API to export the whole dataset: consuming hundreds of result pages every time costs you time and us a ton of resources. Every variant, together with the variant aliases, is published as a single JSON document, refreshed periodically:  * [/variants.json.gz](/variants.json.gz) — gzipped, prefer this one * [/variants.json](/variants.json) — uncompressed  The document holds the `timestamp` it was built at, the `version` that built it, and the `variants` and `aliases` arrays, whose items have the very same shape as the `/variants/` and `/variant-aliases/` responses. Fetch it on a schedule of your own and read it locally.  ## Using this API  Make sparse, unauthenticated requests, with the general guideline of a few HTTP calls per user interaction with your tool.  * Name your service, optionally with a version, in the [User-Agent](https://developer.mozilla.org/en-US/docs/Web/HTTP/Reference/Headers/User-Agent#library_and_net_tool_ua_strings) header. * You may be rate limited: 80 requests per minute should be a safe rate, and clients should always   handle `429 Too Many Requests` responses. * Responses use camelCase keys. * A TypeScript client is published on npm as [`@space-cow-media/spellbook-client`](https://www.npmjs.com/package/@space-cow-media/spellbook-client).  Please credit us, and link back to []() where applicable. Thanks!
  *
- * The version of the OpenAPI document: 7.0.5
+ * The version of the OpenAPI document: 7.1.0
  * 
  *
  * NOTE: This class is auto generated by OpenAPI Generator (https://openapi-generator.tech).

package/spellbook-client/apis/VariantSuggestionsApi.ts

@@ -4,7 +4,7 @@
  * Commander Spellbook API
  * API for Commander Spellbook, the combo database engine for Magic: The Gathering.  ## Bulk data  Please do not use this API to export the whole dataset: consuming hundreds of result pages every time costs you time and us a ton of resources. Every variant, together with the variant aliases, is published as a single JSON document, refreshed periodically:  * [/variants.json.gz](/variants.json.gz) — gzipped, prefer this one * [/variants.json](/variants.json) — uncompressed  The document holds the `timestamp` it was built at, the `version` that built it, and the `variants` and `aliases` arrays, whose items have the very same shape as the `/variants/` and `/variant-aliases/` responses. Fetch it on a schedule of your own and read it locally.  ## Using this API  Make sparse, unauthenticated requests, with the general guideline of a few HTTP calls per user interaction with your tool.  * Name your service, optionally with a version, in the [User-Agent](https://developer.mozilla.org/en-US/docs/Web/HTTP/Reference/Headers/User-Agent#library_and_net_tool_ua_strings) header. * You may be rate limited: 80 requests per minute should be a safe rate, and clients should always   handle `429 Too Many Requests` responses. * Responses use camelCase keys. * A TypeScript client is published on npm as [`@space-cow-media/spellbook-client`](https://www.npmjs.com/package/@space-cow-media/spellbook-client).  Please credit us, and link back to []() where applicable. Thanks!
  *
- * The version of the OpenAPI document: 7.0.5
+ * The version of the OpenAPI document: 7.1.0
  * 
  *
  * NOTE: This class is auto generated by OpenAPI Generator (https://openapi-generator.tech).

package/spellbook-client/apis/VariantUpdateSuggestionsApi.ts

@@ -4,7 +4,7 @@
  * Commander Spellbook API
  * API for Commander Spellbook, the combo database engine for Magic: The Gathering.  ## Bulk data  Please do not use this API to export the whole dataset: consuming hundreds of result pages every time costs you time and us a ton of resources. Every variant, together with the variant aliases, is published as a single JSON document, refreshed periodically:  * [/variants.json.gz](/variants.json.gz) — gzipped, prefer this one * [/variants.json](/variants.json) — uncompressed  The document holds the `timestamp` it was built at, the `version` that built it, and the `variants` and `aliases` arrays, whose items have the very same shape as the `/variants/` and `/variant-aliases/` responses. Fetch it on a schedule of your own and read it locally.  ## Using this API  Make sparse, unauthenticated requests, with the general guideline of a few HTTP calls per user interaction with your tool.  * Name your service, optionally with a version, in the [User-Agent](https://developer.mozilla.org/en-US/docs/Web/HTTP/Reference/Headers/User-Agent#library_and_net_tool_ua_strings) header. * You may be rate limited: 80 requests per minute should be a safe rate, and clients should always   handle `429 Too Many Requests` responses. * Responses use camelCase keys. * A TypeScript client is published on npm as [`@space-cow-media/spellbook-client`](https://www.npmjs.com/package/@space-cow-media/spellbook-client).  Please credit us, and link back to []() where applicable. Thanks!
  *
- * The version of the OpenAPI document: 7.0.5
+ * The version of the OpenAPI document: 7.1.0
  * 
  *
  * NOTE: This class is auto generated by OpenAPI Generator (https://openapi-generator.tech).

package/spellbook-client/apis/VariantsApi.ts

@@ -4,7 +4,7 @@
  * Commander Spellbook API
  * API for Commander Spellbook, the combo database engine for Magic: The Gathering.  ## Bulk data  Please do not use this API to export the whole dataset: consuming hundreds of result pages every time costs you time and us a ton of resources. Every variant, together with the variant aliases, is published as a single JSON document, refreshed periodically:  * [/variants.json.gz](/variants.json.gz) — gzipped, prefer this one * [/variants.json](/variants.json) — uncompressed  The document holds the `timestamp` it was built at, the `version` that built it, and the `variants` and `aliases` arrays, whose items have the very same shape as the `/variants/` and `/variant-aliases/` responses. Fetch it on a schedule of your own and read it locally.  ## Using this API  Make sparse, unauthenticated requests, with the general guideline of a few HTTP calls per user interaction with your tool.  * Name your service, optionally with a version, in the [User-Agent](https://developer.mozilla.org/en-US/docs/Web/HTTP/Reference/Headers/User-Agent#library_and_net_tool_ua_strings) header. * You may be rate limited: 80 requests per minute should be a safe rate, and clients should always   handle `429 Too Many Requests` responses. * Responses use camelCase keys. * A TypeScript client is published on npm as [`@space-cow-media/spellbook-client`](https://www.npmjs.com/package/@space-cow-media/spellbook-client).  Please credit us, and link back to []() where applicable. Thanks!
  *
- * The version of the OpenAPI document: 7.0.5
+ * The version of the OpenAPI document: 7.1.0
  * 
  *
  * NOTE: This class is auto generated by OpenAPI Generator (https://openapi-generator.tech).

package/spellbook-client/apis/index.ts

@@ -9,6 +9,7 @@ export * from './ExplainQueryApi.js';
 export * from './FeaturesApi.js';
 export * from './FindMyCombosApi.js';
 export * from './PropertiesApi.js';
+export * from './SaltVotesApi.js';
 export * from './TemplatesApi.js';
 export * from './TokenApi.js';
 export * from './UsersApi.js';

package/spellbook-client/docs/PaginatedSaltVoteList.md

@@ -0,0 +1,40 @@
+
+# PaginatedSaltVoteList
+
+
+## Properties
+
+Name | Type
+------------ | -------------
+`count` | number
+`next` | string
+`previous` | string
+`results` | [Array<SaltVote>](SaltVote.md)
+
+## Example
+
+```typescript
+import type { PaginatedSaltVoteList } from ''
+
+// TODO: Update the object below with actual values
+const example = {
+  "count": 123,
+  "next": http://api.example.org/accounts/?offset=400&limit=100,
+  "previous": http://api.example.org/accounts/?offset=200&limit=100,
+  "results": null,
+} satisfies PaginatedSaltVoteList
+
+console.log(example)
+
+// Convert the instance to a JSON string
+const exampleJSON: string = JSON.stringify(example)
+console.log(exampleJSON)
+
+// Parse the JSON string back to an object
+const exampleParsed = JSON.parse(exampleJSON) as PaginatedSaltVoteList
+console.log(exampleParsed)
+```
+
+[[Back to top]](#) [[Back to API list]](../README.md#api-endpoints) [[Back to Model list]](../README.md#models) [[Back to README]](../README.md)
+
+

package/spellbook-client/docs/SaltVote.md

@@ -0,0 +1,44 @@
+
+# SaltVote
+
+
+## Properties
+
+Name | Type
+------------ | -------------
+`variant` | string
+`score` | number
+`created` | Date
+`updated` | Date
+`average` | number
+`voteCount` | number
+
+## Example
+
+```typescript
+import type { SaltVote } from ''
+
+// TODO: Update the object below with actual values
+const example = {
+  "variant": null,
+  "score": null,
+  "created": null,
+  "updated": null,
+  "average": null,
+  "voteCount": null,
+} satisfies SaltVote
+
+console.log(example)
+
+// Convert the instance to a JSON string
+const exampleJSON: string = JSON.stringify(example)
+console.log(exampleJSON)
+
+// Parse the JSON string back to an object
+const exampleParsed = JSON.parse(exampleJSON) as SaltVote
+console.log(exampleParsed)
+```
+
+[[Back to top]](#) [[Back to API list]](../README.md#api-endpoints) [[Back to Model list]](../README.md#models) [[Back to README]](../README.md)
+
+

package/spellbook-client/docs/SaltVoteRequest.md

@@ -0,0 +1,34 @@
+
+# SaltVoteRequest
+
+
+## Properties
+
+Name | Type
+------------ | -------------
+`score` | number
+
+## Example
+
+```typescript
+import type { SaltVoteRequest } from ''
+
+// TODO: Update the object below with actual values
+const example = {
+  "score": null,
+} satisfies SaltVoteRequest
+
+console.log(example)
+
+// Convert the instance to a JSON string
+const exampleJSON: string = JSON.stringify(example)
+console.log(exampleJSON)
+
+// Parse the JSON string back to an object
+const exampleParsed = JSON.parse(exampleJSON) as SaltVoteRequest
+console.log(exampleParsed)
+```
+
+[[Back to top]](#) [[Back to API list]](../README.md#api-endpoints) [[Back to Model list]](../README.md#models) [[Back to README]](../README.md)
+
+