zklighter-perps 1.0.335 → 1.0.337

package/apis/GuildApi.ts

@@ -17,8 +17,12 @@ import * as runtime from '../runtime';
 import type {
   Guild,
   RespGetGuild,
+  RespGetGuildDuel,
+  RespGetGuildDuelList,
   RespGetGuildList,
   RespGuildByReferralCode,
+  RespGuildDuelMetrics,
+  RespGuildDuelOptIn,
   RespGuildInviteCodes,
   RespGuildJoinRequest,
   RespGuildJoinRequests,
@@ -32,10 +36,18 @@ import {
     GuildToJSON,
     RespGetGuildFromJSON,
     RespGetGuildToJSON,
+    RespGetGuildDuelFromJSON,
+    RespGetGuildDuelToJSON,
+    RespGetGuildDuelListFromJSON,
+    RespGetGuildDuelListToJSON,
     RespGetGuildListFromJSON,
     RespGetGuildListToJSON,
     RespGuildByReferralCodeFromJSON,
     RespGuildByReferralCodeToJSON,
+    RespGuildDuelMetricsFromJSON,
+    RespGuildDuelMetricsToJSON,
+    RespGuildDuelOptInFromJSON,
+    RespGuildDuelOptInToJSON,
     RespGuildInviteCodesFromJSON,
     RespGuildInviteCodesToJSON,
     RespGuildJoinRequestFromJSON,
@@ -77,6 +89,90 @@ export interface GuildCreateRequest {
     max_members?: number;
 }
 
+export interface GuildDuelRequest {
+    duel_id: number;
+}
+
+export interface GuildDuelAcceptRequest {
+    account_index: number;
+    duel_id: number;
+    offer_id: number;
+    authorization?: string;
+    auth?: string;
+}
+
+export interface GuildDuelCancelRequest {
+    account_index: number;
+    duel_id: number;
+    authorization?: string;
+    auth?: string;
+}
+
+export interface GuildDuelChallengeRequest {
+    account_index: number;
+    target_guild_id: number;
+    metric: GuildDuelChallengeMetricEnum;
+    stake_amount: number;
+    start_time: number;
+    duration_secs: number;
+    min_members: number;
+    authorization?: string;
+    auth?: string;
+    message?: string;
+}
+
+export interface GuildDuelCounterRequest {
+    account_index: number;
+    duel_id: number;
+    offer_id: number;
+    metric: GuildDuelCounterMetricEnum;
+    stake_amount: number;
+    start_time: number;
+    duration_secs: number;
+    min_members: number;
+    authorization?: string;
+    auth?: string;
+    message?: string;
+}
+
+export interface GuildDuelDeclineRequest {
+    account_index: number;
+    duel_id: number;
+    offer_id: number;
+    authorization?: string;
+    auth?: string;
+}
+
+export interface GuildDuelListRequest {
+    limit: number;
+    guild_id?: number;
+    status?: GuildDuelListStatusEnum;
+    cursor?: string;
+}
+
+export interface GuildDuelOptInRequest {
+    account_index: number;
+    opt_in: boolean;
+    authorization?: string;
+    auth?: string;
+}
+
+export interface GuildDuelRosterRequest {
+    account_index: number;
+    duel_id: number;
+    authorization?: string;
+    auth?: string;
+    l1_addresses?: string;
+}
+
+export interface GuildDuelStakeRequest {
+    account_index: number;
+    duel_id: number;
+    tx_hash: string;
+    authorization?: string;
+    auth?: string;
+}
+
 export interface GuildInviteCodeCreateRequest {
     account_index: number;
     authorization?: string;
@@ -161,6 +257,22 @@ export interface GuildMembershipRequest {
     auth?: string;
 }
 
+export interface GuildMyDuelRequest {
+    account_index: number;
+    duel_id: number;
+    authorization?: string;
+    auth?: string;
+}
+
+export interface GuildMyDuelsRequest {
+    account_index: number;
+    limit: number;
+    authorization?: string;
+    auth?: string;
+    status?: GuildMyDuelsStatusEnum;
+    cursor?: string;
+}
+
 export interface GuildRequestsRequest {
     account_index: number;
     authorization?: string;
@@ -199,14 +311,798 @@ export interface GuildUpdateRequest {
 export class GuildApi extends runtime.BaseAPI {
 
     /**
-     * Public guild page: identity, leader, members
-     * guild
+     * Public guild page: identity, leader, members
+     * guild
+     */
+    async guildRaw(requestParameters: GuildRequest, initOverrides?: RequestInit | runtime.InitOverrideFunction): Promise<runtime.ApiResponse<RespGetGuild>> {
+        if (requestParameters['guild_id'] == null) {
+            throw new runtime.RequiredError(
+                'guild_id',
+                'Required parameter "guild_id" was null or undefined when calling guild().'
+            );
+        }
+
+        const queryParameters: any = {};
+
+        if (requestParameters['guild_id'] != null) {
+            queryParameters['guild_id'] = requestParameters['guild_id'];
+        }
+
+        if (requestParameters['include_positions'] != null) {
+            queryParameters['include_positions'] = requestParameters['include_positions'];
+        }
+
+        const headerParameters: runtime.HTTPHeaders = {};
+
+        const response = await this.request({
+            path: `/api/v1/guild`,
+            method: 'GET',
+            headers: headerParameters,
+            query: queryParameters,
+        }, initOverrides);
+
+        return new runtime.JSONApiResponse(response, (jsonValue) => RespGetGuildFromJSON(jsonValue));
+    }
+
+    /**
+     * Public guild page: identity, leader, members
+     * guild
+     */
+    async guild(requestParameters: GuildRequest, initOverrides?: RequestInit | runtime.InitOverrideFunction): Promise<RespGetGuild> {
+        const response = await this.guildRaw(requestParameters, initOverrides);
+        return await response.value();
+    }
+
+    /**
+     * Archive the caller\'s guild (leader only, no other members)
+     * guild_archive
+     */
+    async guildArchiveRaw(requestParameters: GuildArchiveRequest, initOverrides?: RequestInit | runtime.InitOverrideFunction): Promise<runtime.ApiResponse<ResultCode>> {
+        if (requestParameters['account_index'] == null) {
+            throw new runtime.RequiredError(
+                'account_index',
+                'Required parameter "account_index" was null or undefined when calling guildArchive().'
+            );
+        }
+
+        const queryParameters: any = {};
+
+        const headerParameters: runtime.HTTPHeaders = {};
+
+        if (requestParameters['authorization'] != null) {
+            headerParameters['authorization'] = String(requestParameters['authorization']);
+        }
+
+        const consumes: runtime.Consume[] = [
+            { contentType: 'multipart/form-data' },
+        ];
+        // @ts-ignore: canConsumeForm may be unused
+        const canConsumeForm = runtime.canConsumeForm(consumes);
+
+        let formParams: { append(param: string, value: any): any };
+        let useForm = false;
+        if (useForm) {
+            formParams = new FormData();
+        } else {
+            formParams = new URLSearchParams();
+        }
+
+        if (requestParameters['auth'] != null) {
+            formParams.append('auth', requestParameters['auth'] as any);
+        }
+
+        if (requestParameters['account_index'] != null) {
+            formParams.append('account_index', requestParameters['account_index'] as any);
+        }
+
+        const response = await this.request({
+            path: `/api/v1/guild/archive`,
+            method: 'POST',
+            headers: headerParameters,
+            query: queryParameters,
+            body: formParams,
+        }, initOverrides);
+
+        return new runtime.JSONApiResponse(response, (jsonValue) => ResultCodeFromJSON(jsonValue));
+    }
+
+    /**
+     * Archive the caller\'s guild (leader only, no other members)
+     * guild_archive
+     */
+    async guildArchive(requestParameters: GuildArchiveRequest, initOverrides?: RequestInit | runtime.InitOverrideFunction): Promise<ResultCode> {
+        const response = await this.guildArchiveRaw(requestParameters, initOverrides);
+        return await response.value();
+    }
+
+    /**
+     * Active guild of a referral code\'s owner, for the pre-redemption join prompt (empty if none)
+     * guild_byReferralCode
+     */
+    async guildByReferralCodeRaw(requestParameters: GuildByReferralCodeRequest, initOverrides?: RequestInit | runtime.InitOverrideFunction): Promise<runtime.ApiResponse<RespGuildByReferralCode>> {
+        if (requestParameters['code'] == null) {
+            throw new runtime.RequiredError(
+                'code',
+                'Required parameter "code" was null or undefined when calling guildByReferralCode().'
+            );
+        }
+
+        const queryParameters: any = {};
+
+        if (requestParameters['code'] != null) {
+            queryParameters['code'] = requestParameters['code'];
+        }
+
+        const headerParameters: runtime.HTTPHeaders = {};
+
+        const response = await this.request({
+            path: `/api/v1/guild/byReferralCode`,
+            method: 'GET',
+            headers: headerParameters,
+            query: queryParameters,
+        }, initOverrides);
+
+        return new runtime.JSONApiResponse(response, (jsonValue) => RespGuildByReferralCodeFromJSON(jsonValue));
+    }
+
+    /**
+     * Active guild of a referral code\'s owner, for the pre-redemption join prompt (empty if none)
+     * guild_byReferralCode
+     */
+    async guildByReferralCode(requestParameters: GuildByReferralCodeRequest, initOverrides?: RequestInit | runtime.InitOverrideFunction): Promise<RespGuildByReferralCode> {
+        const response = await this.guildByReferralCodeRaw(requestParameters, initOverrides);
+        return await response.value();
+    }
+
+    /**
+     * Create a guild (whitelisted creators only, one guild per creator)
+     * guild_create
+     */
+    async guildCreateRaw(requestParameters: GuildCreateRequest, initOverrides?: RequestInit | runtime.InitOverrideFunction): Promise<runtime.ApiResponse<Guild>> {
+        if (requestParameters['account_index'] == null) {
+            throw new runtime.RequiredError(
+                'account_index',
+                'Required parameter "account_index" was null or undefined when calling guildCreate().'
+            );
+        }
+
+        if (requestParameters['name'] == null) {
+            throw new runtime.RequiredError(
+                'name',
+                'Required parameter "name" was null or undefined when calling guildCreate().'
+            );
+        }
+
+        const queryParameters: any = {};
+
+        const headerParameters: runtime.HTTPHeaders = {};
+
+        if (requestParameters['authorization'] != null) {
+            headerParameters['authorization'] = String(requestParameters['authorization']);
+        }
+
+        const consumes: runtime.Consume[] = [
+            { contentType: 'multipart/form-data' },
+        ];
+        // @ts-ignore: canConsumeForm may be unused
+        const canConsumeForm = runtime.canConsumeForm(consumes);
+
+        let formParams: { append(param: string, value: any): any };
+        let useForm = false;
+        if (useForm) {
+            formParams = new FormData();
+        } else {
+            formParams = new URLSearchParams();
+        }
+
+        if (requestParameters['auth'] != null) {
+            formParams.append('auth', requestParameters['auth'] as any);
+        }
+
+        if (requestParameters['account_index'] != null) {
+            formParams.append('account_index', requestParameters['account_index'] as any);
+        }
+
+        if (requestParameters['name'] != null) {
+            formParams.append('name', requestParameters['name'] as any);
+        }
+
+        if (requestParameters['description'] != null) {
+            formParams.append('description', requestParameters['description'] as any);
+        }
+
+        if (requestParameters['accepts_join_requests'] != null) {
+            formParams.append('accepts_join_requests', requestParameters['accepts_join_requests'] as any);
+        }
+
+        if (requestParameters['max_members'] != null) {
+            formParams.append('max_members', requestParameters['max_members'] as any);
+        }
+
+        const response = await this.request({
+            path: `/api/v1/guild/create`,
+            method: 'POST',
+            headers: headerParameters,
+            query: queryParameters,
+            body: formParams,
+        }, initOverrides);
+
+        return new runtime.JSONApiResponse(response, (jsonValue) => GuildFromJSON(jsonValue));
+    }
+
+    /**
+     * Create a guild (whitelisted creators only, one guild per creator)
+     * guild_create
+     */
+    async guildCreate(requestParameters: GuildCreateRequest, initOverrides?: RequestInit | runtime.InitOverrideFunction): Promise<Guild> {
+        const response = await this.guildCreateRaw(requestParameters, initOverrides);
+        return await response.value();
+    }
+
+    /**
+     * Public duel detail (funded/live/finished/settled only): sides, terms, offer history, locked rosters
+     * guild_duel
+     */
+    async guildDuelRaw(requestParameters: GuildDuelRequest, initOverrides?: RequestInit | runtime.InitOverrideFunction): Promise<runtime.ApiResponse<RespGetGuildDuel>> {
+        if (requestParameters['duel_id'] == null) {
+            throw new runtime.RequiredError(
+                'duel_id',
+                'Required parameter "duel_id" was null or undefined when calling guildDuel().'
+            );
+        }
+
+        const queryParameters: any = {};
+
+        if (requestParameters['duel_id'] != null) {
+            queryParameters['duel_id'] = requestParameters['duel_id'];
+        }
+
+        const headerParameters: runtime.HTTPHeaders = {};
+
+        const response = await this.request({
+            path: `/api/v1/guild/duel`,
+            method: 'GET',
+            headers: headerParameters,
+            query: queryParameters,
+        }, initOverrides);
+
+        return new runtime.JSONApiResponse(response, (jsonValue) => RespGetGuildDuelFromJSON(jsonValue));
+    }
+
+    /**
+     * Public duel detail (funded/live/finished/settled only): sides, terms, offer history, locked rosters
+     * guild_duel
+     */
+    async guildDuel(requestParameters: GuildDuelRequest, initOverrides?: RequestInit | runtime.InitOverrideFunction): Promise<RespGetGuildDuel> {
+        const response = await this.guildDuelRaw(requestParameters, initOverrides);
+        return await response.value();
+    }
+
+    /**
+     * Accept the pending offer (leader of the side that did not author it)
+     * guild_duel_accept
+     */
+    async guildDuelAcceptRaw(requestParameters: GuildDuelAcceptRequest, initOverrides?: RequestInit | runtime.InitOverrideFunction): Promise<runtime.ApiResponse<RespGetGuildDuel>> {
+        if (requestParameters['account_index'] == null) {
+            throw new runtime.RequiredError(
+                'account_index',
+                'Required parameter "account_index" was null or undefined when calling guildDuelAccept().'
+            );
+        }
+
+        if (requestParameters['duel_id'] == null) {
+            throw new runtime.RequiredError(
+                'duel_id',
+                'Required parameter "duel_id" was null or undefined when calling guildDuelAccept().'
+            );
+        }
+
+        if (requestParameters['offer_id'] == null) {
+            throw new runtime.RequiredError(
+                'offer_id',
+                'Required parameter "offer_id" was null or undefined when calling guildDuelAccept().'
+            );
+        }
+
+        const queryParameters: any = {};
+
+        const headerParameters: runtime.HTTPHeaders = {};
+
+        if (requestParameters['authorization'] != null) {
+            headerParameters['authorization'] = String(requestParameters['authorization']);
+        }
+
+        const consumes: runtime.Consume[] = [
+            { contentType: 'multipart/form-data' },
+        ];
+        // @ts-ignore: canConsumeForm may be unused
+        const canConsumeForm = runtime.canConsumeForm(consumes);
+
+        let formParams: { append(param: string, value: any): any };
+        let useForm = false;
+        if (useForm) {
+            formParams = new FormData();
+        } else {
+            formParams = new URLSearchParams();
+        }
+
+        if (requestParameters['auth'] != null) {
+            formParams.append('auth', requestParameters['auth'] as any);
+        }
+
+        if (requestParameters['account_index'] != null) {
+            formParams.append('account_index', requestParameters['account_index'] as any);
+        }
+
+        if (requestParameters['duel_id'] != null) {
+            formParams.append('duel_id', requestParameters['duel_id'] as any);
+        }
+
+        if (requestParameters['offer_id'] != null) {
+            formParams.append('offer_id', requestParameters['offer_id'] as any);
+        }
+
+        const response = await this.request({
+            path: `/api/v1/guild/duel/accept`,
+            method: 'POST',
+            headers: headerParameters,
+            query: queryParameters,
+            body: formParams,
+        }, initOverrides);
+
+        return new runtime.JSONApiResponse(response, (jsonValue) => RespGetGuildDuelFromJSON(jsonValue));
+    }
+
+    /**
+     * Accept the pending offer (leader of the side that did not author it)
+     * guild_duel_accept
+     */
+    async guildDuelAccept(requestParameters: GuildDuelAcceptRequest, initOverrides?: RequestInit | runtime.InitOverrideFunction): Promise<RespGetGuildDuel> {
+        const response = await this.guildDuelAcceptRaw(requestParameters, initOverrides);
+        return await response.value();
+    }
+
+    /**
+     * Cancel: proposer while proposed; either leader while accepted
+     * guild_duel_cancel
+     */
+    async guildDuelCancelRaw(requestParameters: GuildDuelCancelRequest, initOverrides?: RequestInit | runtime.InitOverrideFunction): Promise<runtime.ApiResponse<RespGetGuildDuel>> {
+        if (requestParameters['account_index'] == null) {
+            throw new runtime.RequiredError(
+                'account_index',
+                'Required parameter "account_index" was null or undefined when calling guildDuelCancel().'
+            );
+        }
+
+        if (requestParameters['duel_id'] == null) {
+            throw new runtime.RequiredError(
+                'duel_id',
+                'Required parameter "duel_id" was null or undefined when calling guildDuelCancel().'
+            );
+        }
+
+        const queryParameters: any = {};
+
+        const headerParameters: runtime.HTTPHeaders = {};
+
+        if (requestParameters['authorization'] != null) {
+            headerParameters['authorization'] = String(requestParameters['authorization']);
+        }
+
+        const consumes: runtime.Consume[] = [
+            { contentType: 'multipart/form-data' },
+        ];
+        // @ts-ignore: canConsumeForm may be unused
+        const canConsumeForm = runtime.canConsumeForm(consumes);
+
+        let formParams: { append(param: string, value: any): any };
+        let useForm = false;
+        if (useForm) {
+            formParams = new FormData();
+        } else {
+            formParams = new URLSearchParams();
+        }
+
+        if (requestParameters['auth'] != null) {
+            formParams.append('auth', requestParameters['auth'] as any);
+        }
+
+        if (requestParameters['account_index'] != null) {
+            formParams.append('account_index', requestParameters['account_index'] as any);
+        }
+
+        if (requestParameters['duel_id'] != null) {
+            formParams.append('duel_id', requestParameters['duel_id'] as any);
+        }
+
+        const response = await this.request({
+            path: `/api/v1/guild/duel/cancel`,
+            method: 'POST',
+            headers: headerParameters,
+            query: queryParameters,
+            body: formParams,
+        }, initOverrides);
+
+        return new runtime.JSONApiResponse(response, (jsonValue) => RespGetGuildDuelFromJSON(jsonValue));
+    }
+
+    /**
+     * Cancel: proposer while proposed; either leader while accepted
+     * guild_duel_cancel
+     */
+    async guildDuelCancel(requestParameters: GuildDuelCancelRequest, initOverrides?: RequestInit | runtime.InitOverrideFunction): Promise<RespGetGuildDuel> {
+        const response = await this.guildDuelCancelRaw(requestParameters, initOverrides);
+        return await response.value();
+    }
+
+    /**
+     * Challenge another guild (leader only)
+     * guild_duel_challenge
+     */
+    async guildDuelChallengeRaw(requestParameters: GuildDuelChallengeRequest, initOverrides?: RequestInit | runtime.InitOverrideFunction): Promise<runtime.ApiResponse<RespGetGuildDuel>> {
+        if (requestParameters['account_index'] == null) {
+            throw new runtime.RequiredError(
+                'account_index',
+                'Required parameter "account_index" was null or undefined when calling guildDuelChallenge().'
+            );
+        }
+
+        if (requestParameters['target_guild_id'] == null) {
+            throw new runtime.RequiredError(
+                'target_guild_id',
+                'Required parameter "target_guild_id" was null or undefined when calling guildDuelChallenge().'
+            );
+        }
+
+        if (requestParameters['metric'] == null) {
+            throw new runtime.RequiredError(
+                'metric',
+                'Required parameter "metric" was null or undefined when calling guildDuelChallenge().'
+            );
+        }
+
+        if (requestParameters['stake_amount'] == null) {
+            throw new runtime.RequiredError(
+                'stake_amount',
+                'Required parameter "stake_amount" was null or undefined when calling guildDuelChallenge().'
+            );
+        }
+
+        if (requestParameters['start_time'] == null) {
+            throw new runtime.RequiredError(
+                'start_time',
+                'Required parameter "start_time" was null or undefined when calling guildDuelChallenge().'
+            );
+        }
+
+        if (requestParameters['duration_secs'] == null) {
+            throw new runtime.RequiredError(
+                'duration_secs',
+                'Required parameter "duration_secs" was null or undefined when calling guildDuelChallenge().'
+            );
+        }
+
+        if (requestParameters['min_members'] == null) {
+            throw new runtime.RequiredError(
+                'min_members',
+                'Required parameter "min_members" was null or undefined when calling guildDuelChallenge().'
+            );
+        }
+
+        const queryParameters: any = {};
+
+        const headerParameters: runtime.HTTPHeaders = {};
+
+        if (requestParameters['authorization'] != null) {
+            headerParameters['authorization'] = String(requestParameters['authorization']);
+        }
+
+        const consumes: runtime.Consume[] = [
+            { contentType: 'multipart/form-data' },
+        ];
+        // @ts-ignore: canConsumeForm may be unused
+        const canConsumeForm = runtime.canConsumeForm(consumes);
+
+        let formParams: { append(param: string, value: any): any };
+        let useForm = false;
+        if (useForm) {
+            formParams = new FormData();
+        } else {
+            formParams = new URLSearchParams();
+        }
+
+        if (requestParameters['auth'] != null) {
+            formParams.append('auth', requestParameters['auth'] as any);
+        }
+
+        if (requestParameters['account_index'] != null) {
+            formParams.append('account_index', requestParameters['account_index'] as any);
+        }
+
+        if (requestParameters['target_guild_id'] != null) {
+            formParams.append('target_guild_id', requestParameters['target_guild_id'] as any);
+        }
+
+        if (requestParameters['metric'] != null) {
+            formParams.append('metric', requestParameters['metric'] as any);
+        }
+
+        if (requestParameters['stake_amount'] != null) {
+            formParams.append('stake_amount', requestParameters['stake_amount'] as any);
+        }
+
+        if (requestParameters['start_time'] != null) {
+            formParams.append('start_time', requestParameters['start_time'] as any);
+        }
+
+        if (requestParameters['duration_secs'] != null) {
+            formParams.append('duration_secs', requestParameters['duration_secs'] as any);
+        }
+
+        if (requestParameters['min_members'] != null) {
+            formParams.append('min_members', requestParameters['min_members'] as any);
+        }
+
+        if (requestParameters['message'] != null) {
+            formParams.append('message', requestParameters['message'] as any);
+        }
+
+        const response = await this.request({
+            path: `/api/v1/guild/duel/challenge`,
+            method: 'POST',
+            headers: headerParameters,
+            query: queryParameters,
+            body: formParams,
+        }, initOverrides);
+
+        return new runtime.JSONApiResponse(response, (jsonValue) => RespGetGuildDuelFromJSON(jsonValue));
+    }
+
+    /**
+     * Challenge another guild (leader only)
+     * guild_duel_challenge
+     */
+    async guildDuelChallenge(requestParameters: GuildDuelChallengeRequest, initOverrides?: RequestInit | runtime.InitOverrideFunction): Promise<RespGetGuildDuel> {
+        const response = await this.guildDuelChallengeRaw(requestParameters, initOverrides);
+        return await response.value();
+    }
+
+    /**
+     * Counter the pending offer with new terms (leader of the side that did not author it)
+     * guild_duel_counter
+     */
+    async guildDuelCounterRaw(requestParameters: GuildDuelCounterRequest, initOverrides?: RequestInit | runtime.InitOverrideFunction): Promise<runtime.ApiResponse<RespGetGuildDuel>> {
+        if (requestParameters['account_index'] == null) {
+            throw new runtime.RequiredError(
+                'account_index',
+                'Required parameter "account_index" was null or undefined when calling guildDuelCounter().'
+            );
+        }
+
+        if (requestParameters['duel_id'] == null) {
+            throw new runtime.RequiredError(
+                'duel_id',
+                'Required parameter "duel_id" was null or undefined when calling guildDuelCounter().'
+            );
+        }
+
+        if (requestParameters['offer_id'] == null) {
+            throw new runtime.RequiredError(
+                'offer_id',
+                'Required parameter "offer_id" was null or undefined when calling guildDuelCounter().'
+            );
+        }
+
+        if (requestParameters['metric'] == null) {
+            throw new runtime.RequiredError(
+                'metric',
+                'Required parameter "metric" was null or undefined when calling guildDuelCounter().'
+            );
+        }
+
+        if (requestParameters['stake_amount'] == null) {
+            throw new runtime.RequiredError(
+                'stake_amount',
+                'Required parameter "stake_amount" was null or undefined when calling guildDuelCounter().'
+            );
+        }
+
+        if (requestParameters['start_time'] == null) {
+            throw new runtime.RequiredError(
+                'start_time',
+                'Required parameter "start_time" was null or undefined when calling guildDuelCounter().'
+            );
+        }
+
+        if (requestParameters['duration_secs'] == null) {
+            throw new runtime.RequiredError(
+                'duration_secs',
+                'Required parameter "duration_secs" was null or undefined when calling guildDuelCounter().'
+            );
+        }
+
+        if (requestParameters['min_members'] == null) {
+            throw new runtime.RequiredError(
+                'min_members',
+                'Required parameter "min_members" was null or undefined when calling guildDuelCounter().'
+            );
+        }
+
+        const queryParameters: any = {};
+
+        const headerParameters: runtime.HTTPHeaders = {};
+
+        if (requestParameters['authorization'] != null) {
+            headerParameters['authorization'] = String(requestParameters['authorization']);
+        }
+
+        const consumes: runtime.Consume[] = [
+            { contentType: 'multipart/form-data' },
+        ];
+        // @ts-ignore: canConsumeForm may be unused
+        const canConsumeForm = runtime.canConsumeForm(consumes);
+
+        let formParams: { append(param: string, value: any): any };
+        let useForm = false;
+        if (useForm) {
+            formParams = new FormData();
+        } else {
+            formParams = new URLSearchParams();
+        }
+
+        if (requestParameters['auth'] != null) {
+            formParams.append('auth', requestParameters['auth'] as any);
+        }
+
+        if (requestParameters['account_index'] != null) {
+            formParams.append('account_index', requestParameters['account_index'] as any);
+        }
+
+        if (requestParameters['duel_id'] != null) {
+            formParams.append('duel_id', requestParameters['duel_id'] as any);
+        }
+
+        if (requestParameters['offer_id'] != null) {
+            formParams.append('offer_id', requestParameters['offer_id'] as any);
+        }
+
+        if (requestParameters['metric'] != null) {
+            formParams.append('metric', requestParameters['metric'] as any);
+        }
+
+        if (requestParameters['stake_amount'] != null) {
+            formParams.append('stake_amount', requestParameters['stake_amount'] as any);
+        }
+
+        if (requestParameters['start_time'] != null) {
+            formParams.append('start_time', requestParameters['start_time'] as any);
+        }
+
+        if (requestParameters['duration_secs'] != null) {
+            formParams.append('duration_secs', requestParameters['duration_secs'] as any);
+        }
+
+        if (requestParameters['min_members'] != null) {
+            formParams.append('min_members', requestParameters['min_members'] as any);
+        }
+
+        if (requestParameters['message'] != null) {
+            formParams.append('message', requestParameters['message'] as any);
+        }
+
+        const response = await this.request({
+            path: `/api/v1/guild/duel/counter`,
+            method: 'POST',
+            headers: headerParameters,
+            query: queryParameters,
+            body: formParams,
+        }, initOverrides);
+
+        return new runtime.JSONApiResponse(response, (jsonValue) => RespGetGuildDuelFromJSON(jsonValue));
+    }
+
+    /**
+     * Counter the pending offer with new terms (leader of the side that did not author it)
+     * guild_duel_counter
+     */
+    async guildDuelCounter(requestParameters: GuildDuelCounterRequest, initOverrides?: RequestInit | runtime.InitOverrideFunction): Promise<RespGetGuildDuel> {
+        const response = await this.guildDuelCounterRaw(requestParameters, initOverrides);
+        return await response.value();
+    }
+
+    /**
+     * Decline the pending offer (leader of the side it was made to)
+     * guild_duel_decline
+     */
+    async guildDuelDeclineRaw(requestParameters: GuildDuelDeclineRequest, initOverrides?: RequestInit | runtime.InitOverrideFunction): Promise<runtime.ApiResponse<RespGetGuildDuel>> {
+        if (requestParameters['account_index'] == null) {
+            throw new runtime.RequiredError(
+                'account_index',
+                'Required parameter "account_index" was null or undefined when calling guildDuelDecline().'
+            );
+        }
+
+        if (requestParameters['duel_id'] == null) {
+            throw new runtime.RequiredError(
+                'duel_id',
+                'Required parameter "duel_id" was null or undefined when calling guildDuelDecline().'
+            );
+        }
+
+        if (requestParameters['offer_id'] == null) {
+            throw new runtime.RequiredError(
+                'offer_id',
+                'Required parameter "offer_id" was null or undefined when calling guildDuelDecline().'
+            );
+        }
+
+        const queryParameters: any = {};
+
+        const headerParameters: runtime.HTTPHeaders = {};
+
+        if (requestParameters['authorization'] != null) {
+            headerParameters['authorization'] = String(requestParameters['authorization']);
+        }
+
+        const consumes: runtime.Consume[] = [
+            { contentType: 'multipart/form-data' },
+        ];
+        // @ts-ignore: canConsumeForm may be unused
+        const canConsumeForm = runtime.canConsumeForm(consumes);
+
+        let formParams: { append(param: string, value: any): any };
+        let useForm = false;
+        if (useForm) {
+            formParams = new FormData();
+        } else {
+            formParams = new URLSearchParams();
+        }
+
+        if (requestParameters['auth'] != null) {
+            formParams.append('auth', requestParameters['auth'] as any);
+        }
+
+        if (requestParameters['account_index'] != null) {
+            formParams.append('account_index', requestParameters['account_index'] as any);
+        }
+
+        if (requestParameters['duel_id'] != null) {
+            formParams.append('duel_id', requestParameters['duel_id'] as any);
+        }
+
+        if (requestParameters['offer_id'] != null) {
+            formParams.append('offer_id', requestParameters['offer_id'] as any);
+        }
+
+        const response = await this.request({
+            path: `/api/v1/guild/duel/decline`,
+            method: 'POST',
+            headers: headerParameters,
+            query: queryParameters,
+            body: formParams,
+        }, initOverrides);
+
+        return new runtime.JSONApiResponse(response, (jsonValue) => RespGetGuildDuelFromJSON(jsonValue));
+    }
+
+    /**
+     * Decline the pending offer (leader of the side it was made to)
+     * guild_duel_decline
+     */
+    async guildDuelDecline(requestParameters: GuildDuelDeclineRequest, initOverrides?: RequestInit | runtime.InitOverrideFunction): Promise<RespGetGuildDuel> {
+        const response = await this.guildDuelDeclineRaw(requestParameters, initOverrides);
+        return await response.value();
+    }
+
+    /**
+     * Public duels (both stakes in escrow) of a guild or all, newest first; status=upcoming|live|finished|all
+     * guild_duel_list
      */
-    async guildRaw(requestParameters: GuildRequest, initOverrides?: RequestInit | runtime.InitOverrideFunction): Promise<runtime.ApiResponse<RespGetGuild>> {
-        if (requestParameters['guild_id'] == null) {
+    async guildDuelListRaw(requestParameters: GuildDuelListRequest, initOverrides?: RequestInit | runtime.InitOverrideFunction): Promise<runtime.ApiResponse<RespGetGuildDuelList>> {
+        if (requestParameters['limit'] == null) {
             throw new runtime.RequiredError(
-                'guild_id',
-                'Required parameter "guild_id" was null or undefined when calling guild().'
+                'limit',
+                'Required parameter "limit" was null or undefined when calling guildDuelList().'
             );
         }
 
@@ -216,40 +1112,83 @@ export class GuildApi extends runtime.BaseAPI {
             queryParameters['guild_id'] = requestParameters['guild_id'];
         }
 
-        if (requestParameters['include_positions'] != null) {
-            queryParameters['include_positions'] = requestParameters['include_positions'];
+        if (requestParameters['status'] != null) {
+            queryParameters['status'] = requestParameters['status'];
+        }
+
+        if (requestParameters['limit'] != null) {
+            queryParameters['limit'] = requestParameters['limit'];
+        }
+
+        if (requestParameters['cursor'] != null) {
+            queryParameters['cursor'] = requestParameters['cursor'];
         }
 
         const headerParameters: runtime.HTTPHeaders = {};
 
         const response = await this.request({
-            path: `/api/v1/guild`,
+            path: `/api/v1/guild/duel/list`,
             method: 'GET',
             headers: headerParameters,
             query: queryParameters,
         }, initOverrides);
 
-        return new runtime.JSONApiResponse(response, (jsonValue) => RespGetGuildFromJSON(jsonValue));
+        return new runtime.JSONApiResponse(response, (jsonValue) => RespGetGuildDuelListFromJSON(jsonValue));
     }
 
     /**
-     * Public guild page: identity, leader, members
-     * guild
+     * Public duels (both stakes in escrow) of a guild or all, newest first; status=upcoming|live|finished|all
+     * guild_duel_list
      */
-    async guild(requestParameters: GuildRequest, initOverrides?: RequestInit | runtime.InitOverrideFunction): Promise<RespGetGuild> {
-        const response = await this.guildRaw(requestParameters, initOverrides);
+    async guildDuelList(requestParameters: GuildDuelListRequest, initOverrides?: RequestInit | runtime.InitOverrideFunction): Promise<RespGetGuildDuelList> {
+        const response = await this.guildDuelListRaw(requestParameters, initOverrides);
         return await response.value();
     }
 
     /**
-     * Archive the caller\'s guild (leader only, no other members)
-     * guild_archive
+     * Metrics a guild duel can be scored on
+     * guild_duel_metrics
      */
-    async guildArchiveRaw(requestParameters: GuildArchiveRequest, initOverrides?: RequestInit | runtime.InitOverrideFunction): Promise<runtime.ApiResponse<ResultCode>> {
+    async guildDuelMetricsRaw(initOverrides?: RequestInit | runtime.InitOverrideFunction): Promise<runtime.ApiResponse<RespGuildDuelMetrics>> {
+        const queryParameters: any = {};
+
+        const headerParameters: runtime.HTTPHeaders = {};
+
+        const response = await this.request({
+            path: `/api/v1/guild/duel/metrics`,
+            method: 'GET',
+            headers: headerParameters,
+            query: queryParameters,
+        }, initOverrides);
+
+        return new runtime.JSONApiResponse(response, (jsonValue) => RespGuildDuelMetricsFromJSON(jsonValue));
+    }
+
+    /**
+     * Metrics a guild duel can be scored on
+     * guild_duel_metrics
+     */
+    async guildDuelMetrics(initOverrides?: RequestInit | runtime.InitOverrideFunction): Promise<RespGuildDuelMetrics> {
+        const response = await this.guildDuelMetricsRaw(initOverrides);
+        return await response.value();
+    }
+
+    /**
+     * Prefer (or stop preferring) to be auto-selected into your guild\'s duel rosters; a preference only: leaders may draft anyone and the top-up to min_members on accept picks opted-in members first, then the rest
+     * guild_duel_optIn
+     */
+    async guildDuelOptInRaw(requestParameters: GuildDuelOptInRequest, initOverrides?: RequestInit | runtime.InitOverrideFunction): Promise<runtime.ApiResponse<RespGuildDuelOptIn>> {
         if (requestParameters['account_index'] == null) {
             throw new runtime.RequiredError(
                 'account_index',
-                'Required parameter "account_index" was null or undefined when calling guildArchive().'
+                'Required parameter "account_index" was null or undefined when calling guildDuelOptIn().'
+            );
+        }
+
+        if (requestParameters['opt_in'] == null) {
+            throw new runtime.RequiredError(
+                'opt_in',
+                'Required parameter "opt_in" was null or undefined when calling guildDuelOptIn().'
             );
         }
 
@@ -283,81 +1222,130 @@ export class GuildApi extends runtime.BaseAPI {
             formParams.append('account_index', requestParameters['account_index'] as any);
         }
 
+        if (requestParameters['opt_in'] != null) {
+            formParams.append('opt_in', requestParameters['opt_in'] as any);
+        }
+
         const response = await this.request({
-            path: `/api/v1/guild/archive`,
+            path: `/api/v1/guild/duel/optIn`,
             method: 'POST',
             headers: headerParameters,
             query: queryParameters,
             body: formParams,
         }, initOverrides);
 
-        return new runtime.JSONApiResponse(response, (jsonValue) => ResultCodeFromJSON(jsonValue));
+        return new runtime.JSONApiResponse(response, (jsonValue) => RespGuildDuelOptInFromJSON(jsonValue));
     }
 
     /**
-     * Archive the caller\'s guild (leader only, no other members)
-     * guild_archive
+     * Prefer (or stop preferring) to be auto-selected into your guild\'s duel rosters; a preference only: leaders may draft anyone and the top-up to min_members on accept picks opted-in members first, then the rest
+     * guild_duel_optIn
      */
-    async guildArchive(requestParameters: GuildArchiveRequest, initOverrides?: RequestInit | runtime.InitOverrideFunction): Promise<ResultCode> {
-        const response = await this.guildArchiveRaw(requestParameters, initOverrides);
+    async guildDuelOptIn(requestParameters: GuildDuelOptInRequest, initOverrides?: RequestInit | runtime.InitOverrideFunction): Promise<RespGuildDuelOptIn> {
+        const response = await this.guildDuelOptInRaw(requestParameters, initOverrides);
         return await response.value();
     }
 
     /**
-     * Active guild of a referral code\'s owner, for the pre-redemption join prompt (empty if none)
-     * guild_byReferralCode
+     * Draft your side\'s roster from your guild\'s members while the duel is proposed (leader only); rosters lock on accept
+     * guild_duel_roster
      */
-    async guildByReferralCodeRaw(requestParameters: GuildByReferralCodeRequest, initOverrides?: RequestInit | runtime.InitOverrideFunction): Promise<runtime.ApiResponse<RespGuildByReferralCode>> {
-        if (requestParameters['code'] == null) {
+    async guildDuelRosterRaw(requestParameters: GuildDuelRosterRequest, initOverrides?: RequestInit | runtime.InitOverrideFunction): Promise<runtime.ApiResponse<RespGetGuildDuel>> {
+        if (requestParameters['account_index'] == null) {
             throw new runtime.RequiredError(
-                'code',
-                'Required parameter "code" was null or undefined when calling guildByReferralCode().'
+                'account_index',
+                'Required parameter "account_index" was null or undefined when calling guildDuelRoster().'
+            );
+        }
+
+        if (requestParameters['duel_id'] == null) {
+            throw new runtime.RequiredError(
+                'duel_id',
+                'Required parameter "duel_id" was null or undefined when calling guildDuelRoster().'
             );
         }
 
         const queryParameters: any = {};
 
-        if (requestParameters['code'] != null) {
-            queryParameters['code'] = requestParameters['code'];
+        const headerParameters: runtime.HTTPHeaders = {};
+
+        if (requestParameters['authorization'] != null) {
+            headerParameters['authorization'] = String(requestParameters['authorization']);
         }
 
-        const headerParameters: runtime.HTTPHeaders = {};
+        const consumes: runtime.Consume[] = [
+            { contentType: 'multipart/form-data' },
+        ];
+        // @ts-ignore: canConsumeForm may be unused
+        const canConsumeForm = runtime.canConsumeForm(consumes);
+
+        let formParams: { append(param: string, value: any): any };
+        let useForm = false;
+        if (useForm) {
+            formParams = new FormData();
+        } else {
+            formParams = new URLSearchParams();
+        }
+
+        if (requestParameters['auth'] != null) {
+            formParams.append('auth', requestParameters['auth'] as any);
+        }
+
+        if (requestParameters['account_index'] != null) {
+            formParams.append('account_index', requestParameters['account_index'] as any);
+        }
+
+        if (requestParameters['duel_id'] != null) {
+            formParams.append('duel_id', requestParameters['duel_id'] as any);
+        }
+
+        if (requestParameters['l1_addresses'] != null) {
+            formParams.append('l1_addresses', requestParameters['l1_addresses'] as any);
+        }
 
         const response = await this.request({
-            path: `/api/v1/guild/byReferralCode`,
-            method: 'GET',
+            path: `/api/v1/guild/duel/roster`,
+            method: 'POST',
             headers: headerParameters,
             query: queryParameters,
+            body: formParams,
         }, initOverrides);
 
-        return new runtime.JSONApiResponse(response, (jsonValue) => RespGuildByReferralCodeFromJSON(jsonValue));
+        return new runtime.JSONApiResponse(response, (jsonValue) => RespGetGuildDuelFromJSON(jsonValue));
     }
 
     /**
-     * Active guild of a referral code\'s owner, for the pre-redemption join prompt (empty if none)
-     * guild_byReferralCode
+     * Draft your side\'s roster from your guild\'s members while the duel is proposed (leader only); rosters lock on accept
+     * guild_duel_roster
      */
-    async guildByReferralCode(requestParameters: GuildByReferralCodeRequest, initOverrides?: RequestInit | runtime.InitOverrideFunction): Promise<RespGuildByReferralCode> {
-        const response = await this.guildByReferralCodeRaw(requestParameters, initOverrides);
+    async guildDuelRoster(requestParameters: GuildDuelRosterRequest, initOverrides?: RequestInit | runtime.InitOverrideFunction): Promise<RespGetGuildDuel> {
+        const response = await this.guildDuelRosterRaw(requestParameters, initOverrides);
         return await response.value();
     }
 
     /**
-     * Create a guild (whitelisted creators only, one guild per creator)
-     * guild_create
+     * Record your side\'s stake: the leader\'s executed L2 transfer of the exact stake to the escrow perps balance; only that guild\'s leader may report it, other members get 42009. A transfer to escrow with this duel\'s memo that cannot be the stake any more (wrong amount, deadline passed, duel no longer accepted, side already staked) is answered with 42040 and queued for a manual refund. While guild duels are disabled the endpoint answers 42038 and queues nothing, so a transfer that reached escrow just before the switch was turned off is reconciled by ops rather than refunded automatically
+     * guild_duel_stake
      */
-    async guildCreateRaw(requestParameters: GuildCreateRequest, initOverrides?: RequestInit | runtime.InitOverrideFunction): Promise<runtime.ApiResponse<Guild>> {
+    async guildDuelStakeRaw(requestParameters: GuildDuelStakeRequest, initOverrides?: RequestInit | runtime.InitOverrideFunction): Promise<runtime.ApiResponse<RespGetGuildDuel>> {
         if (requestParameters['account_index'] == null) {
             throw new runtime.RequiredError(
                 'account_index',
-                'Required parameter "account_index" was null or undefined when calling guildCreate().'
+                'Required parameter "account_index" was null or undefined when calling guildDuelStake().'
             );
         }
 
-        if (requestParameters['name'] == null) {
+        if (requestParameters['duel_id'] == null) {
             throw new runtime.RequiredError(
-                'name',
-                'Required parameter "name" was null or undefined when calling guildCreate().'
+                'duel_id',
+                'Required parameter "duel_id" was null or undefined when calling guildDuelStake().'
+            );
+        }
+
+        if (requestParameters['tx_hash'] == null) {
+            throw new runtime.RequiredError(
+                'tx_hash',
+                'Required parameter "tx_hash" was null or undefined when calling guildDuelStake().'
             );
         }
 
@@ -391,39 +1379,31 @@ export class GuildApi extends runtime.BaseAPI {
             formParams.append('account_index', requestParameters['account_index'] as any);
         }
 
-        if (requestParameters['name'] != null) {
-            formParams.append('name', requestParameters['name'] as any);
-        }
-
-        if (requestParameters['description'] != null) {
-            formParams.append('description', requestParameters['description'] as any);
-        }
-
-        if (requestParameters['accepts_join_requests'] != null) {
-            formParams.append('accepts_join_requests', requestParameters['accepts_join_requests'] as any);
+        if (requestParameters['duel_id'] != null) {
+            formParams.append('duel_id', requestParameters['duel_id'] as any);
         }
 
-        if (requestParameters['max_members'] != null) {
-            formParams.append('max_members', requestParameters['max_members'] as any);
+        if (requestParameters['tx_hash'] != null) {
+            formParams.append('tx_hash', requestParameters['tx_hash'] as any);
         }
 
         const response = await this.request({
-            path: `/api/v1/guild/create`,
+            path: `/api/v1/guild/duel/stake`,
             method: 'POST',
             headers: headerParameters,
             query: queryParameters,
             body: formParams,
         }, initOverrides);
 
-        return new runtime.JSONApiResponse(response, (jsonValue) => GuildFromJSON(jsonValue));
+        return new runtime.JSONApiResponse(response, (jsonValue) => RespGetGuildDuelFromJSON(jsonValue));
     }
 
     /**
-     * Create a guild (whitelisted creators only, one guild per creator)
-     * guild_create
+     * Record your side\'s stake: the leader\'s executed L2 transfer of the exact stake to the escrow perps balance; only that guild\'s leader may report it, other members get 42009. A transfer to escrow with this duel\'s memo that cannot be the stake any more (wrong amount, deadline passed, duel no longer accepted, side already staked) is answered with 42040 and queued for a manual refund. While guild duels are disabled the endpoint answers 42038 and queues nothing, so a transfer that reached escrow just before the switch was turned off is reconciled by ops rather than refunded automatically
+     * guild_duel_stake
      */
-    async guildCreate(requestParameters: GuildCreateRequest, initOverrides?: RequestInit | runtime.InitOverrideFunction): Promise<Guild> {
-        const response = await this.guildCreateRaw(requestParameters, initOverrides);
+    async guildDuelStake(requestParameters: GuildDuelStakeRequest, initOverrides?: RequestInit | runtime.InitOverrideFunction): Promise<RespGetGuildDuel> {
+        const response = await this.guildDuelStakeRaw(requestParameters, initOverrides);
         return await response.value();
     }
 
@@ -1222,6 +2202,130 @@ export class GuildApi extends runtime.BaseAPI {
         return await response.value();
     }
 
+    /**
+     * Detail of one duel of the caller\'s guild in any status (any member): sides, terms, offers, the caller\'s side\'s draft and every locked roster
+     * guild_myDuel
+     */
+    async guildMyDuelRaw(requestParameters: GuildMyDuelRequest, initOverrides?: RequestInit | runtime.InitOverrideFunction): Promise<runtime.ApiResponse<RespGetGuildDuel>> {
+        if (requestParameters['account_index'] == null) {
+            throw new runtime.RequiredError(
+                'account_index',
+                'Required parameter "account_index" was null or undefined when calling guildMyDuel().'
+            );
+        }
+
+        if (requestParameters['duel_id'] == null) {
+            throw new runtime.RequiredError(
+                'duel_id',
+                'Required parameter "duel_id" was null or undefined when calling guildMyDuel().'
+            );
+        }
+
+        const queryParameters: any = {};
+
+        if (requestParameters['auth'] != null) {
+            queryParameters['auth'] = requestParameters['auth'];
+        }
+
+        if (requestParameters['account_index'] != null) {
+            queryParameters['account_index'] = requestParameters['account_index'];
+        }
+
+        if (requestParameters['duel_id'] != null) {
+            queryParameters['duel_id'] = requestParameters['duel_id'];
+        }
+
+        const headerParameters: runtime.HTTPHeaders = {};
+
+        if (requestParameters['authorization'] != null) {
+            headerParameters['authorization'] = String(requestParameters['authorization']);
+        }
+
+        const response = await this.request({
+            path: `/api/v1/guild/myDuel`,
+            method: 'GET',
+            headers: headerParameters,
+            query: queryParameters,
+        }, initOverrides);
+
+        return new runtime.JSONApiResponse(response, (jsonValue) => RespGetGuildDuelFromJSON(jsonValue));
+    }
+
+    /**
+     * Detail of one duel of the caller\'s guild in any status (any member): sides, terms, offers, the caller\'s side\'s draft and every locked roster
+     * guild_myDuel
+     */
+    async guildMyDuel(requestParameters: GuildMyDuelRequest, initOverrides?: RequestInit | runtime.InitOverrideFunction): Promise<RespGetGuildDuel> {
+        const response = await this.guildMyDuelRaw(requestParameters, initOverrides);
+        return await response.value();
+    }
+
+    /**
+     * Duels of the caller\'s guild in every status incl. proposals (any member); status=active|live|finished|all
+     * guild_myDuels
+     */
+    async guildMyDuelsRaw(requestParameters: GuildMyDuelsRequest, initOverrides?: RequestInit | runtime.InitOverrideFunction): Promise<runtime.ApiResponse<RespGetGuildDuelList>> {
+        if (requestParameters['account_index'] == null) {
+            throw new runtime.RequiredError(
+                'account_index',
+                'Required parameter "account_index" was null or undefined when calling guildMyDuels().'
+            );
+        }
+
+        if (requestParameters['limit'] == null) {
+            throw new runtime.RequiredError(
+                'limit',
+                'Required parameter "limit" was null or undefined when calling guildMyDuels().'
+            );
+        }
+
+        const queryParameters: any = {};
+
+        if (requestParameters['auth'] != null) {
+            queryParameters['auth'] = requestParameters['auth'];
+        }
+
+        if (requestParameters['account_index'] != null) {
+            queryParameters['account_index'] = requestParameters['account_index'];
+        }
+
+        if (requestParameters['status'] != null) {
+            queryParameters['status'] = requestParameters['status'];
+        }
+
+        if (requestParameters['limit'] != null) {
+            queryParameters['limit'] = requestParameters['limit'];
+        }
+
+        if (requestParameters['cursor'] != null) {
+            queryParameters['cursor'] = requestParameters['cursor'];
+        }
+
+        const headerParameters: runtime.HTTPHeaders = {};
+
+        if (requestParameters['authorization'] != null) {
+            headerParameters['authorization'] = String(requestParameters['authorization']);
+        }
+
+        const response = await this.request({
+            path: `/api/v1/guild/myDuels`,
+            method: 'GET',
+            headers: headerParameters,
+            query: queryParameters,
+        }, initOverrides);
+
+        return new runtime.JSONApiResponse(response, (jsonValue) => RespGetGuildDuelListFromJSON(jsonValue));
+    }
+
+    /**
+     * Duels of the caller\'s guild in every status incl. proposals (any member); status=active|live|finished|all
+     * guild_myDuels
+     */
+    async guildMyDuels(requestParameters: GuildMyDuelsRequest, initOverrides?: RequestInit | runtime.InitOverrideFunction): Promise<RespGetGuildDuelList> {
+        const response = await this.guildMyDuelsRaw(requestParameters, initOverrides);
+        return await response.value();
+    }
+
     /**
      * Pending join requests for the caller\'s guild (leader/admin)
      * guild_requests
@@ -1538,6 +2642,38 @@ export class GuildApi extends runtime.BaseAPI {
 
 }
 
+/**
+ * @export
+ */
+export const GuildDuelChallengeMetricEnum = {
+    MedianRoi: 'median_roi',
+    GuildRoi: 'guild_roi',
+    Pnl: 'pnl',
+    Volume: 'volume',
+    RoiSqrtVolume: 'roi_sqrt_volume'
+} as const;
+export type GuildDuelChallengeMetricEnum = typeof GuildDuelChallengeMetricEnum[keyof typeof GuildDuelChallengeMetricEnum];
+/**
+ * @export
+ */
+export const GuildDuelCounterMetricEnum = {
+    MedianRoi: 'median_roi',
+    GuildRoi: 'guild_roi',
+    Pnl: 'pnl',
+    Volume: 'volume',
+    RoiSqrtVolume: 'roi_sqrt_volume'
+} as const;
+export type GuildDuelCounterMetricEnum = typeof GuildDuelCounterMetricEnum[keyof typeof GuildDuelCounterMetricEnum];
+/**
+ * @export
+ */
+export const GuildDuelListStatusEnum = {
+    Upcoming: 'upcoming',
+    Live: 'live',
+    Finished: 'finished',
+    All: 'all'
+} as const;
+export type GuildDuelListStatusEnum = typeof GuildDuelListStatusEnum[keyof typeof GuildDuelListStatusEnum];
 /**
  * @export
  */
@@ -1548,6 +2684,16 @@ export const GuildLeaderboardTimeWindowEnum = {
     All: 'all'
 } as const;
 export type GuildLeaderboardTimeWindowEnum = typeof GuildLeaderboardTimeWindowEnum[keyof typeof GuildLeaderboardTimeWindowEnum];
+/**
+ * @export
+ */
+export const GuildMyDuelsStatusEnum = {
+    Active: 'active',
+    Live: 'live',
+    Finished: 'finished',
+    All: 'all'
+} as const;
+export type GuildMyDuelsStatusEnum = typeof GuildMyDuelsStatusEnum[keyof typeof GuildMyDuelsStatusEnum];
 /**
  * @export
  */