import * as axios from 'axios';
import { AxiosRequestConfig, AxiosResponse, AxiosInstance } from 'axios';
import { CookieJar } from 'tough-cookie';
import * as zod from 'zod';
import { z } from 'zod';
import { IfAny, Merge, EmptyObject, Simplify, SetOptional, UnionToIntersection } from 'type-fest';

declare const valorantEndpointSchema: z.ZodEffects<z.ZodObject<{
    name: z.ZodString;
    description: z.ZodOptional<z.ZodString>;
    type: z.ZodEnum<["auth", "local", "pd", "glz", "shared"]>;
    method: z.ZodDefault<z.ZodEnum<["GET", "POST", "PUT", "DELETE"]>>;
    url: z.ZodString;
    headers: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodString>>;
    requirements: z.ZodDefault<z.ZodArray<z.ZodEnum<["ACCESS_TOKEN", "ENTITLEMENTS_TOKEN", "CLIENT_VERSION", "CLIENT_PLATFORM", "LOCAL_AUTH"]>, "many">>;
    body: z.ZodOptional<z.ZodType<z.ZodType<any, z.ZodTypeDef, any>, z.ZodTypeDef, z.ZodType<any, z.ZodTypeDef, any>>>;
    query: z.ZodOptional<z.ZodType<z.ZodType<any, z.ZodTypeDef, any>, z.ZodTypeDef, z.ZodType<any, z.ZodTypeDef, any>>>;
    responses: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodType<z.ZodType<any, z.ZodTypeDef, any>, z.ZodTypeDef, z.ZodType<any, z.ZodTypeDef, any>>>>;
}, "strip", z.ZodTypeAny, {
    type: "auth" | "local" | "pd" | "glz" | "shared";
    name: string;
    method: "PUT" | "GET" | "DELETE" | "POST";
    url: string;
    requirements: ("ACCESS_TOKEN" | "ENTITLEMENTS_TOKEN" | "CLIENT_VERSION" | "CLIENT_PLATFORM" | "LOCAL_AUTH")[];
    description?: string | undefined;
    headers?: Record<string, string> | undefined;
    body?: z.ZodType<any, z.ZodTypeDef, any> | undefined;
    query?: z.ZodType<any, z.ZodTypeDef, any> | undefined;
    responses?: Record<string, z.ZodType<any, z.ZodTypeDef, any>> | undefined;
}, {
    type: "auth" | "local" | "pd" | "glz" | "shared";
    name: string;
    url: string;
    description?: string | undefined;
    method?: "PUT" | "GET" | "DELETE" | "POST" | undefined;
    headers?: Record<string, string> | undefined;
    requirements?: ("ACCESS_TOKEN" | "ENTITLEMENTS_TOKEN" | "CLIENT_VERSION" | "CLIENT_PLATFORM" | "LOCAL_AUTH")[] | undefined;
    body?: z.ZodType<any, z.ZodTypeDef, any> | undefined;
    query?: z.ZodType<any, z.ZodTypeDef, any> | undefined;
    responses?: Record<string, z.ZodType<any, z.ZodTypeDef, any>> | undefined;
}>, {
    requirements: string[];
    type: "auth" | "local" | "pd" | "glz" | "shared";
    name: string;
    method: "PUT" | "GET" | "DELETE" | "POST";
    url: string;
    description?: string | undefined;
    headers?: Record<string, string> | undefined;
    body?: z.ZodType<any, z.ZodTypeDef, any> | undefined;
    query?: z.ZodType<any, z.ZodTypeDef, any> | undefined;
    responses?: Record<string, z.ZodType<any, z.ZodTypeDef, any>> | undefined;
}, {
    type: "auth" | "local" | "pd" | "glz" | "shared";
    name: string;
    url: string;
    description?: string | undefined;
    method?: "PUT" | "GET" | "DELETE" | "POST" | undefined;
    headers?: Record<string, string> | undefined;
    requirements?: ("ACCESS_TOKEN" | "ENTITLEMENTS_TOKEN" | "CLIENT_VERSION" | "CLIENT_PLATFORM" | "LOCAL_AUTH")[] | undefined;
    body?: z.ZodType<any, z.ZodTypeDef, any> | undefined;
    query?: z.ZodType<any, z.ZodTypeDef, any> | undefined;
    responses?: Record<string, z.ZodType<any, z.ZodTypeDef, any>> | undefined;
}>;
type ValorantEndpoint = z.output<typeof valorantEndpointSchema>;

declare const _default$1a: Omit<{
    requirements: string[];
    type: "auth" | "local" | "pd" | "glz" | "shared";
    name: string;
    method: "PUT" | "GET" | "DELETE" | "POST";
    url: string;
    description?: string | undefined;
    headers?: Record<string, string> | undefined;
    body?: z.ZodType<any, z.ZodTypeDef, any> | undefined;
    query?: z.ZodType<any, z.ZodTypeDef, any> | undefined;
    responses?: Record<string, z.ZodType<any, z.ZodTypeDef, any>> | undefined;
}, "type" | "name" | "url"> & Pick<{
    readonly name: "Auth Cookies";
    readonly description: "Prepare cookies for auth request";
    readonly type: "auth";
    readonly method: "POST";
    readonly url: "https://auth.riotgames.com/api/v1/authorization";
    readonly headers: {
        readonly "Content-Type": "application/json";
    };
    readonly body: z.ZodObject<{
        client_id: z.ZodLiteral<"play-valorant-web-prod">;
        nonce: z.ZodLiteral<"1">;
        redirect_uri: z.ZodLiteral<"https://playvalorant.com/opt_in">;
        response_type: z.ZodLiteral<"token id_token">;
        scope: z.ZodLiteral<"account openid">;
    }, "strip", z.ZodTypeAny, {
        client_id: "play-valorant-web-prod";
        nonce: "1";
        redirect_uri: "https://playvalorant.com/opt_in";
        response_type: "token id_token";
        scope: "account openid";
    }, {
        client_id: "play-valorant-web-prod";
        nonce: "1";
        redirect_uri: "https://playvalorant.com/opt_in";
        response_type: "token id_token";
        scope: "account openid";
    }>;
}, "type" | "name" | "url"> & {
    "~type": {
        readonly name: "Auth Cookies";
        readonly description: "Prepare cookies for auth request";
        readonly type: "auth";
        readonly method: "POST";
        readonly url: "https://auth.riotgames.com/api/v1/authorization";
        readonly headers: {
            readonly "Content-Type": "application/json";
        };
        readonly body: z.ZodObject<{
            client_id: z.ZodLiteral<"play-valorant-web-prod">;
            nonce: z.ZodLiteral<"1">;
            redirect_uri: z.ZodLiteral<"https://playvalorant.com/opt_in">;
            response_type: z.ZodLiteral<"token id_token">;
            scope: z.ZodLiteral<"account openid">;
        }, "strip", z.ZodTypeAny, {
            client_id: "play-valorant-web-prod";
            nonce: "1";
            redirect_uri: "https://playvalorant.com/opt_in";
            response_type: "token id_token";
            scope: "account openid";
        }, {
            client_id: "play-valorant-web-prod";
            nonce: "1";
            redirect_uri: "https://playvalorant.com/opt_in";
            response_type: "token id_token";
            scope: "account openid";
        }>;
    };
};

type IsPathParameter<Part extends string> = Part extends `:${infer Parameter}` ? Parameter : never;
type GetPathParameter<Path extends string> = Path extends `${infer A}/${infer B}` ? IsPathParameter<A> | GetPathParameter<B> : IsPathParameter<Path>;
type ResolvePath<Path extends string> = Simplify<{
    [Param in GetPathParameter<Path> as Param extends `${string}?` ? never : Param]: string;
} & {
    [Param in GetPathParameter<Path> as Param extends `${infer OptionalParam}?` ? OptionalParam : never]?: string;
}>;
type ResolveParams<Url extends string, Resolved = ResolvePath<Url>> = Resolved extends {
    puuid: any;
} ? SetOptional<Resolved, "puuid"> : Resolved;
type ResolveValue<Object, Key extends string, FallbackType = any> = Object extends {
    [key in Key]: infer Value;
} ? Value : FallbackType;
type ResolveData<Params, Body, Data = Merge<Params, IfAny<Body, EmptyObject, Body>>> = Data extends EmptyObject ? any : Data;
type ValorantAxiosRequestConfig<T = any, K extends string = IfAny<T, never, "data">> = AxiosRequestConfig<T> & {
    [key in K]: T;
};

type Params$1a = ResolveParams<(typeof _default$1a)["~type"]["url"]>;
type Body$1a = z.infer<ResolveValue<(typeof _default$1a)["~type"], "body">>;
type Data$1a = ResolveData<Params$1a, Body$1a>;
type Response$1a = z.infer<ResolveValue<(typeof _default$1a)["~type"], "responses">["200"]>;
interface AuthCookiesRequestConfig extends ValorantAxiosRequestConfig<Data$1a> {
}
declare class AuthCookiesEndpoint {
    /**
     * Prepare cookies for auth request
     *
     * @EndpointType auth
     */
    postAuthCookies<T = Response$1a>(this: AuthApiClient, config: AuthCookiesRequestConfig): Promise<AxiosResponse<T>>;
}

declare const AuthRequestResponseSchema: z.ZodDiscriminatedUnion<"type", [z.ZodObject<{
    type: z.ZodLiteral<"success">;
    success: z.ZodObject<{
        login_token: z.ZodString;
        redirect_url: z.ZodString;
        is_console_link_session: z.ZodBoolean;
        auth_method: z.ZodLiteral<"riot_identity">;
        puuid: z.ZodString;
    }, "strip", z.ZodTypeAny, {
        login_token: string;
        redirect_url: string;
        is_console_link_session: boolean;
        auth_method: "riot_identity";
        puuid: string;
    }, {
        login_token: string;
        redirect_url: string;
        is_console_link_session: boolean;
        auth_method: "riot_identity";
        puuid: string;
    }>;
    country: z.ZodString;
    platform: z.ZodString;
}, "strip", z.ZodTypeAny, {
    type: "success";
    success: {
        login_token: string;
        redirect_url: string;
        is_console_link_session: boolean;
        auth_method: "riot_identity";
        puuid: string;
    };
    country: string;
    platform: string;
}, {
    type: "success";
    success: {
        login_token: string;
        redirect_url: string;
        is_console_link_session: boolean;
        auth_method: "riot_identity";
        puuid: string;
    };
    country: string;
    platform: string;
}>, z.ZodObject<{
    type: z.ZodLiteral<"multifactor">;
    multifactor: z.ZodObject<{
        method: z.ZodLiteral<"email">;
        methods: z.ZodArray<z.ZodLiteral<"email">, "many">;
        email: z.ZodString;
        mode: z.ZodLiteral<"auth">;
        auth_method: z.ZodLiteral<"riot_identity">;
    }, "strip", z.ZodTypeAny, {
        method: "email";
        email: string;
        auth_method: "riot_identity";
        methods: "email"[];
        mode: "auth";
    }, {
        method: "email";
        email: string;
        auth_method: "riot_identity";
        methods: "email"[];
        mode: "auth";
    }>;
    country: z.ZodString;
    platform: z.ZodString;
    error: z.ZodOptional<z.ZodLiteral<"invalid_code">>;
}, "strip", z.ZodTypeAny, {
    type: "multifactor";
    country: string;
    platform: string;
    multifactor: {
        method: "email";
        email: string;
        auth_method: "riot_identity";
        methods: "email"[];
        mode: "auth";
    };
    error?: "invalid_code" | undefined;
}, {
    type: "multifactor";
    country: string;
    platform: string;
    multifactor: {
        method: "email";
        email: string;
        auth_method: "riot_identity";
        methods: "email"[];
        mode: "auth";
    };
    error?: "invalid_code" | undefined;
}>]>;
declare const _default$19: Omit<{
    requirements: string[];
    type: "auth" | "local" | "pd" | "glz" | "shared";
    name: string;
    method: "PUT" | "GET" | "DELETE" | "POST";
    url: string;
    description?: string | undefined;
    headers?: Record<string, string> | undefined;
    body?: z.ZodType<any, z.ZodTypeDef, any> | undefined;
    query?: z.ZodType<any, z.ZodTypeDef, any> | undefined;
    responses?: Record<string, z.ZodType<any, z.ZodTypeDef, any>> | undefined;
}, "type" | "name" | "url"> & Pick<{
    readonly name: "Auth Request";
    readonly description: string;
    readonly type: "auth";
    readonly method: "PUT";
    readonly url: "https://auth.riotgames.com/api/v1/authorization";
    readonly headers: {
        readonly "Content-Type": "application/json";
    };
    readonly body: z.ZodObject<{
        type: z.ZodLiteral<"auth">;
        language: z.ZodLiteral<"en_US">;
        remember: z.ZodBoolean;
        riot_identity: z.ZodObject<{
            captcha: z.ZodString;
            username: z.ZodString;
            password: z.ZodString;
        }, "strip", z.ZodTypeAny, {
            password: string;
            username: string;
            captcha: string;
        }, {
            password: string;
            username: string;
            captcha: string;
        }>;
    }, "strip", z.ZodTypeAny, {
        type: "auth";
        riot_identity: {
            password: string;
            username: string;
            captcha: string;
        };
        language: "en_US";
        remember: boolean;
    }, {
        type: "auth";
        riot_identity: {
            password: string;
            username: string;
            captcha: string;
        };
        language: "en_US";
        remember: boolean;
    }>;
    readonly responses: {
        readonly "200": z.ZodDiscriminatedUnion<"type", [z.ZodObject<{
            type: z.ZodLiteral<"success">;
            success: z.ZodObject<{
                login_token: z.ZodString;
                redirect_url: z.ZodString;
                is_console_link_session: z.ZodBoolean;
                auth_method: z.ZodLiteral<"riot_identity">;
                puuid: z.ZodString;
            }, "strip", z.ZodTypeAny, {
                login_token: string;
                redirect_url: string;
                is_console_link_session: boolean;
                auth_method: "riot_identity";
                puuid: string;
            }, {
                login_token: string;
                redirect_url: string;
                is_console_link_session: boolean;
                auth_method: "riot_identity";
                puuid: string;
            }>;
            country: z.ZodString;
            platform: z.ZodString;
        }, "strip", z.ZodTypeAny, {
            type: "success";
            success: {
                login_token: string;
                redirect_url: string;
                is_console_link_session: boolean;
                auth_method: "riot_identity";
                puuid: string;
            };
            country: string;
            platform: string;
        }, {
            type: "success";
            success: {
                login_token: string;
                redirect_url: string;
                is_console_link_session: boolean;
                auth_method: "riot_identity";
                puuid: string;
            };
            country: string;
            platform: string;
        }>, z.ZodObject<{
            type: z.ZodLiteral<"multifactor">;
            multifactor: z.ZodObject<{
                method: z.ZodLiteral<"email">;
                methods: z.ZodArray<z.ZodLiteral<"email">, "many">;
                email: z.ZodString;
                mode: z.ZodLiteral<"auth">;
                auth_method: z.ZodLiteral<"riot_identity">;
            }, "strip", z.ZodTypeAny, {
                method: "email";
                email: string;
                auth_method: "riot_identity";
                methods: "email"[];
                mode: "auth";
            }, {
                method: "email";
                email: string;
                auth_method: "riot_identity";
                methods: "email"[];
                mode: "auth";
            }>;
            country: z.ZodString;
            platform: z.ZodString;
            error: z.ZodOptional<z.ZodLiteral<"invalid_code">>;
        }, "strip", z.ZodTypeAny, {
            type: "multifactor";
            country: string;
            platform: string;
            multifactor: {
                method: "email";
                email: string;
                auth_method: "riot_identity";
                methods: "email"[];
                mode: "auth";
            };
            error?: "invalid_code" | undefined;
        }, {
            type: "multifactor";
            country: string;
            platform: string;
            multifactor: {
                method: "email";
                email: string;
                auth_method: "riot_identity";
                methods: "email"[];
                mode: "auth";
            };
            error?: "invalid_code" | undefined;
        }>]>;
    };
}, "type" | "name" | "url"> & {
    "~type": {
        readonly name: "Auth Request";
        readonly description: string;
        readonly type: "auth";
        readonly method: "PUT";
        readonly url: "https://auth.riotgames.com/api/v1/authorization";
        readonly headers: {
            readonly "Content-Type": "application/json";
        };
        readonly body: z.ZodObject<{
            type: z.ZodLiteral<"auth">;
            language: z.ZodLiteral<"en_US">;
            remember: z.ZodBoolean;
            riot_identity: z.ZodObject<{
                captcha: z.ZodString;
                username: z.ZodString;
                password: z.ZodString;
            }, "strip", z.ZodTypeAny, {
                password: string;
                username: string;
                captcha: string;
            }, {
                password: string;
                username: string;
                captcha: string;
            }>;
        }, "strip", z.ZodTypeAny, {
            type: "auth";
            riot_identity: {
                password: string;
                username: string;
                captcha: string;
            };
            language: "en_US";
            remember: boolean;
        }, {
            type: "auth";
            riot_identity: {
                password: string;
                username: string;
                captcha: string;
            };
            language: "en_US";
            remember: boolean;
        }>;
        readonly responses: {
            readonly "200": z.ZodDiscriminatedUnion<"type", [z.ZodObject<{
                type: z.ZodLiteral<"success">;
                success: z.ZodObject<{
                    login_token: z.ZodString;
                    redirect_url: z.ZodString;
                    is_console_link_session: z.ZodBoolean;
                    auth_method: z.ZodLiteral<"riot_identity">;
                    puuid: z.ZodString;
                }, "strip", z.ZodTypeAny, {
                    login_token: string;
                    redirect_url: string;
                    is_console_link_session: boolean;
                    auth_method: "riot_identity";
                    puuid: string;
                }, {
                    login_token: string;
                    redirect_url: string;
                    is_console_link_session: boolean;
                    auth_method: "riot_identity";
                    puuid: string;
                }>;
                country: z.ZodString;
                platform: z.ZodString;
            }, "strip", z.ZodTypeAny, {
                type: "success";
                success: {
                    login_token: string;
                    redirect_url: string;
                    is_console_link_session: boolean;
                    auth_method: "riot_identity";
                    puuid: string;
                };
                country: string;
                platform: string;
            }, {
                type: "success";
                success: {
                    login_token: string;
                    redirect_url: string;
                    is_console_link_session: boolean;
                    auth_method: "riot_identity";
                    puuid: string;
                };
                country: string;
                platform: string;
            }>, z.ZodObject<{
                type: z.ZodLiteral<"multifactor">;
                multifactor: z.ZodObject<{
                    method: z.ZodLiteral<"email">;
                    methods: z.ZodArray<z.ZodLiteral<"email">, "many">;
                    email: z.ZodString;
                    mode: z.ZodLiteral<"auth">;
                    auth_method: z.ZodLiteral<"riot_identity">;
                }, "strip", z.ZodTypeAny, {
                    method: "email";
                    email: string;
                    auth_method: "riot_identity";
                    methods: "email"[];
                    mode: "auth";
                }, {
                    method: "email";
                    email: string;
                    auth_method: "riot_identity";
                    methods: "email"[];
                    mode: "auth";
                }>;
                country: z.ZodString;
                platform: z.ZodString;
                error: z.ZodOptional<z.ZodLiteral<"invalid_code">>;
            }, "strip", z.ZodTypeAny, {
                type: "multifactor";
                country: string;
                platform: string;
                multifactor: {
                    method: "email";
                    email: string;
                    auth_method: "riot_identity";
                    methods: "email"[];
                    mode: "auth";
                };
                error?: "invalid_code" | undefined;
            }, {
                type: "multifactor";
                country: string;
                platform: string;
                multifactor: {
                    method: "email";
                    email: string;
                    auth_method: "riot_identity";
                    methods: "email"[];
                    mode: "auth";
                };
                error?: "invalid_code" | undefined;
            }>]>;
        };
    };
};

type Params$19 = ResolveParams<(typeof _default$19)["~type"]["url"]>;
type Body$19 = z.infer<ResolveValue<(typeof _default$19)["~type"], "body">>;
type Data$19 = ResolveData<Params$19, Body$19>;
type Response$19 = z.infer<ResolveValue<(typeof _default$19)["~type"], "responses">["200"]>;
interface AuthRequestRequestConfig extends ValorantAxiosRequestConfig<Data$19> {
}
declare class AuthRequestEndpoint {
    /**
     * Perform authorization request to get token
     *
     * Requires cookies from the [POST Auth Cookies] stage. If the user has multi-factor authentication enabled, the response will contain a `type` of `multifactor` and [PUT Multi-Factor Authentication] will need to be used.
     *
     * Note:
     * Authenticating directly is prone to breakage (captchas and cloudflare anti-bot) and does not support users who use alternative sign-in methods.
     * Consider using [GET Cookie Reauth] or opening a webview to the Riot login page and watching for redirects.
     *
     * @EndpointType auth
     */
    putAuthRequest<T = Response$19>(this: AuthApiClient, config: AuthRequestRequestConfig): Promise<AxiosResponse<T>>;
}

declare const _default$18: Omit<{
    requirements: string[];
    type: "auth" | "local" | "pd" | "glz" | "shared";
    name: string;
    method: "PUT" | "GET" | "DELETE" | "POST";
    url: string;
    description?: string | undefined;
    headers?: Record<string, string> | undefined;
    body?: zod.ZodType<any, zod.ZodTypeDef, any> | undefined;
    query?: zod.ZodType<any, zod.ZodTypeDef, any> | undefined;
    responses?: Record<string, zod.ZodType<any, zod.ZodTypeDef, any>> | undefined;
}, "type" | "name" | "url"> & Pick<{
    readonly name: "Cookie Reauth";
    readonly description: string;
    readonly type: "auth";
    readonly method: "PUT";
    readonly url: "https://auth.riotgames.com/authorize?redirect_uri=https%3A%2F%2Fplayvalorant.com%2Fopt_in&client_id=play-valorant-web-prod&response_type=token%20id_token&nonce=1&scope=account%20openid";
}, "type" | "name" | "url"> & {
    "~type": {
        readonly name: "Cookie Reauth";
        readonly description: string;
        readonly type: "auth";
        readonly method: "PUT";
        readonly url: "https://auth.riotgames.com/authorize?redirect_uri=https%3A%2F%2Fplayvalorant.com%2Fopt_in&client_id=play-valorant-web-prod&response_type=token%20id_token&nonce=1&scope=account%20openid";
    };
};

type Params$18 = ResolveParams<(typeof _default$18)["~type"]["url"]>;
type Body$18 = z.infer<ResolveValue<(typeof _default$18)["~type"], "body">>;
type Data$18 = ResolveData<Params$18, Body$18>;
type Response$18 = z.infer<ResolveValue<(typeof _default$18)["~type"], "responses">["200"]>;
interface CookieReauthRequestConfig extends ValorantAxiosRequestConfig<Data$18> {
}
declare class CookieReauthEndpoint {
    /**
     * Get a new token using the cookies from a previous authorization request
     * Use the saved cookies from [PUT Auth Request] (specifically the `ssid` cookie). The auth token and id token can be found from the url this request redirects to.
     *
     * It's recommended to use this endpoint instead of storing the password and sending it again.
     *
     * There are ongoing tests at documented at <https://github.com/techchrism/riot-auth-test> that test for auth lifespan using different cookie strategies.
     * Currently, it appears refreshing with just the `ssid` cookie is only stable for one week and refreshing with all auth cookies is stable for three weeks.
     *
     * On a successful response, the 301 redirect location header will be of the format:
     * > ```https://playvalorant.com/opt_in#access_token={access token}&scope=openid&iss=https%3A%2F%2Fauth.riotgames.com&id_token={id token}&token_type=Bearer&session_state={session state}&expires_in=3600```
     *
     * On an unsuccessful response, the 301 redirect location header will be of the format:
     * > ```https://authenticate.riotgames.com/login?client_id=play-valorant-web-prod&nonce=1&redirect_uri=https%3A%2F%2Fauth.riotgames.com%2Fauthorize%3Fclient_id%3Dplay-valorant-web-prod%26nonce%3D1%26redirect_uri%3Dhttps%253A%252F%252Fplayvalorant.com%252Fopt_in%26response_type%3Dtoken%2520id_token&response_type=token%20id_token&method=riot_identity```
     *
     *
     * @EndpointType auth
     */
    putCookieReauth<T = Response$18>(this: AuthApiClient, config?: CookieReauthRequestConfig): Promise<AxiosResponse<T>>;
}

declare const _default$17: Omit<{
    requirements: string[];
    type: "auth" | "local" | "pd" | "glz" | "shared";
    name: string;
    method: "PUT" | "GET" | "DELETE" | "POST";
    url: string;
    description?: string | undefined;
    headers?: Record<string, string> | undefined;
    body?: z.ZodType<any, z.ZodTypeDef, any> | undefined;
    query?: z.ZodType<any, z.ZodTypeDef, any> | undefined;
    responses?: Record<string, z.ZodType<any, z.ZodTypeDef, any>> | undefined;
}, "type" | "name" | "url"> & Pick<{
    readonly name: "Entitlements Token";
    readonly description: "Get entitlement for remote requests with a token";
    readonly type: "auth";
    readonly method: "POST";
    readonly url: "https://entitlements.auth.riotgames.com/api/token/v1";
    readonly requirements: ["ACCESS_TOKEN"];
    readonly headers: {
        readonly "Content-Type": "application/json";
    };
    readonly responses: {
        readonly "200": z.ZodObject<{
            entitlements_token: z.ZodString;
        }, "strip", z.ZodTypeAny, {
            entitlements_token: string;
        }, {
            entitlements_token: string;
        }>;
    };
}, "type" | "name" | "url"> & {
    "~type": {
        readonly name: "Entitlements Token";
        readonly description: "Get entitlement for remote requests with a token";
        readonly type: "auth";
        readonly method: "POST";
        readonly url: "https://entitlements.auth.riotgames.com/api/token/v1";
        readonly requirements: ["ACCESS_TOKEN"];
        readonly headers: {
            readonly "Content-Type": "application/json";
        };
        readonly responses: {
            readonly "200": z.ZodObject<{
                entitlements_token: z.ZodString;
            }, "strip", z.ZodTypeAny, {
                entitlements_token: string;
            }, {
                entitlements_token: string;
            }>;
        };
    };
};

type Params$17 = ResolveParams<(typeof _default$17)["~type"]["url"]>;
type Body$17 = z.infer<ResolveValue<(typeof _default$17)["~type"], "body">>;
type Data$17 = ResolveData<Params$17, Body$17>;
type Response$17 = z.infer<ResolveValue<(typeof _default$17)["~type"], "responses">["200"]>;
interface EntitlementsTokenRequestConfig$1 extends ValorantAxiosRequestConfig<Data$17> {
}
declare class EntitlementsTokenEndpoint$1 {
    /**
     * Get entitlement for remote requests with a token
     *
     * @EndpointType auth
     */
    postEntitlementsToken<T = Response$17>(this: AuthApiClient, config?: EntitlementsTokenRequestConfig$1): Promise<AxiosResponse<T>>;
}

declare const _default$16: Omit<{
    requirements: string[];
    type: "auth" | "local" | "pd" | "glz" | "shared";
    name: string;
    method: "PUT" | "GET" | "DELETE" | "POST";
    url: string;
    description?: string | undefined;
    headers?: Record<string, string> | undefined;
    body?: z.ZodType<any, z.ZodTypeDef, any> | undefined;
    query?: z.ZodType<any, z.ZodTypeDef, any> | undefined;
    responses?: Record<string, z.ZodType<any, z.ZodTypeDef, any>> | undefined;
}, "type" | "name" | "url"> & Pick<{
    readonly name: "MultiFactor Authentication";
    readonly description: "Submits a multi-factor authentication code for login";
    readonly type: "auth";
    readonly method: "PUT";
    readonly url: "https://auth.riotgames.com/api/v1/authorization";
    readonly headers: {
        readonly "Content-Type": "application/json";
    };
    readonly body: z.ZodObject<{
        type: z.ZodLiteral<"multifactor">;
        multifactor: z.ZodObject<{
            otp: z.ZodString;
            rememberDevice: z.ZodBoolean;
        }, "strip", z.ZodTypeAny, {
            otp: string;
            rememberDevice: boolean;
        }, {
            otp: string;
            rememberDevice: boolean;
        }>;
    }, "strip", z.ZodTypeAny, {
        type: "multifactor";
        multifactor: {
            otp: string;
            rememberDevice: boolean;
        };
    }, {
        type: "multifactor";
        multifactor: {
            otp: string;
            rememberDevice: boolean;
        };
    }>;
}, "type" | "name" | "url"> & {
    "~type": {
        readonly name: "MultiFactor Authentication";
        readonly description: "Submits a multi-factor authentication code for login";
        readonly type: "auth";
        readonly method: "PUT";
        readonly url: "https://auth.riotgames.com/api/v1/authorization";
        readonly headers: {
            readonly "Content-Type": "application/json";
        };
        readonly body: z.ZodObject<{
            type: z.ZodLiteral<"multifactor">;
            multifactor: z.ZodObject<{
                otp: z.ZodString;
                rememberDevice: z.ZodBoolean;
            }, "strip", z.ZodTypeAny, {
                otp: string;
                rememberDevice: boolean;
            }, {
                otp: string;
                rememberDevice: boolean;
            }>;
        }, "strip", z.ZodTypeAny, {
            type: "multifactor";
            multifactor: {
                otp: string;
                rememberDevice: boolean;
            };
        }, {
            type: "multifactor";
            multifactor: {
                otp: string;
                rememberDevice: boolean;
            };
        }>;
    };
};

type Params$16 = ResolveParams<(typeof _default$16)["~type"]["url"]>;
type Body$16 = z.infer<ResolveValue<(typeof _default$16)["~type"], "body">>;
type Data$16 = ResolveData<Params$16, Body$16>;
type Response$16 = z.infer<ResolveValue<(typeof _default$16)["~type"], "responses">["200"]>;
interface MultiFactorAuthenticationRequestConfig extends ValorantAxiosRequestConfig<Data$16> {
}
declare class MultiFactorAuthenticationEndpoint {
    /**
     * Submits a multi-factor authentication code for login
     *
     * @EndpointType auth
     */
    putMultiFactorAuthentication<T = Response$16>(this: AuthApiClient, config: MultiFactorAuthenticationRequestConfig): Promise<AxiosResponse<T>>;
}

declare const PasTokenResponseSchema: z.ZodString;
declare const _default$15: Omit<{
    requirements: string[];
    type: "auth" | "local" | "pd" | "glz" | "shared";
    name: string;
    method: "PUT" | "GET" | "DELETE" | "POST";
    url: string;
    description?: string | undefined;
    headers?: Record<string, string> | undefined;
    body?: z.ZodType<any, z.ZodTypeDef, any> | undefined;
    query?: z.ZodType<any, z.ZodTypeDef, any> | undefined;
    responses?: Record<string, z.ZodType<any, z.ZodTypeDef, any>> | undefined;
}, "type" | "name" | "url"> & Pick<{
    readonly name: "PAS Token";
    readonly description: "Get a PAS token using the auth token. The PAS token is a JWT that contains the affinity for the XMPP server.";
    readonly type: "auth";
    readonly url: "https://riot-geo.pas.si.riotgames.com/pas/v1/service/chat";
    readonly requirements: ["ACCESS_TOKEN"];
    readonly responses: {
        readonly "200": z.ZodString;
    };
}, "type" | "name" | "url"> & {
    "~type": {
        readonly name: "PAS Token";
        readonly description: "Get a PAS token using the auth token. The PAS token is a JWT that contains the affinity for the XMPP server.";
        readonly type: "auth";
        readonly url: "https://riot-geo.pas.si.riotgames.com/pas/v1/service/chat";
        readonly requirements: ["ACCESS_TOKEN"];
        readonly responses: {
            readonly "200": z.ZodString;
        };
    };
};

type Params$15 = ResolveParams<(typeof _default$15)["~type"]["url"]>;
type Body$15 = z.infer<ResolveValue<(typeof _default$15)["~type"], "body">>;
type Data$15 = ResolveData<Params$15, Body$15>;
type Response$15 = z.infer<ResolveValue<(typeof _default$15)["~type"], "responses">["200"]>;
interface PasTokenRequestConfig extends ValorantAxiosRequestConfig<Data$15> {
}
declare class PasTokenEndpoint {
    /**
     * Get a PAS token using the auth token. The PAS token is a JWT that contains the affinity for the XMPP server.
     *
     * @EndpointType auth
     */
    getPasToken<T = Response$15>(this: AuthApiClient, config?: PasTokenRequestConfig): Promise<AxiosResponse<T>>;
}

declare const PlayerInfoResponseSchema: z.ZodObject<{
    country: z.ZodString;
    sub: z.ZodString;
    email_verified: z.ZodBoolean;
    player_plocale: z.ZodNullable<z.ZodUnknown>;
    country_at: z.ZodNullable<z.ZodEffects<z.ZodNumber, Date, number>>;
    pw: z.ZodObject<{
        cng_at: z.ZodEffects<z.ZodNumber, Date, number>;
        reset: z.ZodBoolean;
        must_reset: z.ZodBoolean;
    }, "strip", z.ZodTypeAny, {
        cng_at: Date;
        reset: boolean;
        must_reset: boolean;
    }, {
        cng_at: number;
        reset: boolean;
        must_reset: boolean;
    }>;
    phone_number_verified: z.ZodBoolean;
    account_verified: z.ZodBoolean;
    ppid: z.ZodNullable<z.ZodUnknown>;
    federated_identity_providers: z.ZodArray<z.ZodString, "many">;
    player_locale: z.ZodNullable<z.ZodString>;
    acct: z.ZodObject<{
        type: z.ZodNumber;
        state: z.ZodString;
        adm: z.ZodBoolean;
        game_name: z.ZodString;
        tag_line: z.ZodString;
        created_at: z.ZodEffects<z.ZodNumber, Date, number>;
    }, "strip", z.ZodTypeAny, {
        type: number;
        state: string;
        adm: boolean;
        game_name: string;
        tag_line: string;
        created_at: Date;
    }, {
        type: number;
        state: string;
        adm: boolean;
        game_name: string;
        tag_line: string;
        created_at: number;
    }>;
    age: z.ZodNumber;
    jti: z.ZodString;
    affinity: z.ZodRecord<z.ZodString, z.ZodString>;
}, "strip", z.ZodTypeAny, {
    sub: string;
    country: string;
    email_verified: boolean;
    country_at: Date | null;
    pw: {
        cng_at: Date;
        reset: boolean;
        must_reset: boolean;
    };
    phone_number_verified: boolean;
    account_verified: boolean;
    federated_identity_providers: string[];
    player_locale: string | null;
    acct: {
        type: number;
        state: string;
        adm: boolean;
        game_name: string;
        tag_line: string;
        created_at: Date;
    };
    age: number;
    jti: string;
    affinity: Record<string, string>;
    player_plocale?: unknown;
    ppid?: unknown;
}, {
    sub: string;
    country: string;
    email_verified: boolean;
    country_at: number | null;
    pw: {
        cng_at: number;
        reset: boolean;
        must_reset: boolean;
    };
    phone_number_verified: boolean;
    account_verified: boolean;
    federated_identity_providers: string[];
    player_locale: string | null;
    acct: {
        type: number;
        state: string;
        adm: boolean;
        game_name: string;
        tag_line: string;
        created_at: number;
    };
    age: number;
    jti: string;
    affinity: Record<string, string>;
    player_plocale?: unknown;
    ppid?: unknown;
}>;
declare const _default$14: Omit<{
    requirements: string[];
    type: "auth" | "local" | "pd" | "glz" | "shared";
    name: string;
    method: "PUT" | "GET" | "DELETE" | "POST";
    url: string;
    description?: string | undefined;
    headers?: Record<string, string> | undefined;
    body?: z.ZodType<any, z.ZodTypeDef, any> | undefined;
    query?: z.ZodType<any, z.ZodTypeDef, any> | undefined;
    responses?: Record<string, z.ZodType<any, z.ZodTypeDef, any>> | undefined;
}, "type" | "name" | "url"> & Pick<{
    readonly name: "Player Info";
    readonly description: "Get the PUUID and other info from a token";
    readonly type: "auth";
    readonly url: "https://auth.riotgames.com/userinfo";
    readonly requirements: ["ACCESS_TOKEN"];
    readonly responses: {
        readonly "200": z.ZodObject<{
            country: z.ZodString;
            sub: z.ZodString;
            email_verified: z.ZodBoolean;
            player_plocale: z.ZodNullable<z.ZodUnknown>;
            country_at: z.ZodNullable<z.ZodEffects<z.ZodNumber, Date, number>>;
            pw: z.ZodObject<{
                cng_at: z.ZodEffects<z.ZodNumber, Date, number>;
                reset: z.ZodBoolean;
                must_reset: z.ZodBoolean;
            }, "strip", z.ZodTypeAny, {
                cng_at: Date;
                reset: boolean;
                must_reset: boolean;
            }, {
                cng_at: number;
                reset: boolean;
                must_reset: boolean;
            }>;
            phone_number_verified: z.ZodBoolean;
            account_verified: z.ZodBoolean;
            ppid: z.ZodNullable<z.ZodUnknown>;
            federated_identity_providers: z.ZodArray<z.ZodString, "many">;
            player_locale: z.ZodNullable<z.ZodString>;
            acct: z.ZodObject<{
                type: z.ZodNumber;
                state: z.ZodString;
                adm: z.ZodBoolean;
                game_name: z.ZodString;
                tag_line: z.ZodString;
                created_at: z.ZodEffects<z.ZodNumber, Date, number>;
            }, "strip", z.ZodTypeAny, {
                type: number;
                state: string;
                adm: boolean;
                game_name: string;
                tag_line: string;
                created_at: Date;
            }, {
                type: number;
                state: string;
                adm: boolean;
                game_name: string;
                tag_line: string;
                created_at: number;
            }>;
            age: z.ZodNumber;
            jti: z.ZodString;
            affinity: z.ZodRecord<z.ZodString, z.ZodString>;
        }, "strip", z.ZodTypeAny, {
            sub: string;
            country: string;
            email_verified: boolean;
            country_at: Date | null;
            pw: {
                cng_at: Date;
                reset: boolean;
                must_reset: boolean;
            };
            phone_number_verified: boolean;
            account_verified: boolean;
            federated_identity_providers: string[];
            player_locale: string | null;
            acct: {
                type: number;
                state: string;
                adm: boolean;
                game_name: string;
                tag_line: string;
                created_at: Date;
            };
            age: number;
            jti: string;
            affinity: Record<string, string>;
            player_plocale?: unknown;
            ppid?: unknown;
        }, {
            sub: string;
            country: string;
            email_verified: boolean;
            country_at: number | null;
            pw: {
                cng_at: number;
                reset: boolean;
                must_reset: boolean;
            };
            phone_number_verified: boolean;
            account_verified: boolean;
            federated_identity_providers: string[];
            player_locale: string | null;
            acct: {
                type: number;
                state: string;
                adm: boolean;
                game_name: string;
                tag_line: string;
                created_at: number;
            };
            age: number;
            jti: string;
            affinity: Record<string, string>;
            player_plocale?: unknown;
            ppid?: unknown;
        }>;
    };
}, "type" | "name" | "url"> & {
    "~type": {
        readonly name: "Player Info";
        readonly description: "Get the PUUID and other info from a token";
        readonly type: "auth";
        readonly url: "https://auth.riotgames.com/userinfo";
        readonly requirements: ["ACCESS_TOKEN"];
        readonly responses: {
            readonly "200": z.ZodObject<{
                country: z.ZodString;
                sub: z.ZodString;
                email_verified: z.ZodBoolean;
                player_plocale: z.ZodNullable<z.ZodUnknown>;
                country_at: z.ZodNullable<z.ZodEffects<z.ZodNumber, Date, number>>;
                pw: z.ZodObject<{
                    cng_at: z.ZodEffects<z.ZodNumber, Date, number>;
                    reset: z.ZodBoolean;
                    must_reset: z.ZodBoolean;
                }, "strip", z.ZodTypeAny, {
                    cng_at: Date;
                    reset: boolean;
                    must_reset: boolean;
                }, {
                    cng_at: number;
                    reset: boolean;
                    must_reset: boolean;
                }>;
                phone_number_verified: z.ZodBoolean;
                account_verified: z.ZodBoolean;
                ppid: z.ZodNullable<z.ZodUnknown>;
                federated_identity_providers: z.ZodArray<z.ZodString, "many">;
                player_locale: z.ZodNullable<z.ZodString>;
                acct: z.ZodObject<{
                    type: z.ZodNumber;
                    state: z.ZodString;
                    adm: z.ZodBoolean;
                    game_name: z.ZodString;
                    tag_line: z.ZodString;
                    created_at: z.ZodEffects<z.ZodNumber, Date, number>;
                }, "strip", z.ZodTypeAny, {
                    type: number;
                    state: string;
                    adm: boolean;
                    game_name: string;
                    tag_line: string;
                    created_at: Date;
                }, {
                    type: number;
                    state: string;
                    adm: boolean;
                    game_name: string;
                    tag_line: string;
                    created_at: number;
                }>;
                age: z.ZodNumber;
                jti: z.ZodString;
                affinity: z.ZodRecord<z.ZodString, z.ZodString>;
            }, "strip", z.ZodTypeAny, {
                sub: string;
                country: string;
                email_verified: boolean;
                country_at: Date | null;
                pw: {
                    cng_at: Date;
                    reset: boolean;
                    must_reset: boolean;
                };
                phone_number_verified: boolean;
                account_verified: boolean;
                federated_identity_providers: string[];
                player_locale: string | null;
                acct: {
                    type: number;
                    state: string;
                    adm: boolean;
                    game_name: string;
                    tag_line: string;
                    created_at: Date;
                };
                age: number;
                jti: string;
                affinity: Record<string, string>;
                player_plocale?: unknown;
                ppid?: unknown;
            }, {
                sub: string;
                country: string;
                email_verified: boolean;
                country_at: number | null;
                pw: {
                    cng_at: number;
                    reset: boolean;
                    must_reset: boolean;
                };
                phone_number_verified: boolean;
                account_verified: boolean;
                federated_identity_providers: string[];
                player_locale: string | null;
                acct: {
                    type: number;
                    state: string;
                    adm: boolean;
                    game_name: string;
                    tag_line: string;
                    created_at: number;
                };
                age: number;
                jti: string;
                affinity: Record<string, string>;
                player_plocale?: unknown;
                ppid?: unknown;
            }>;
        };
    };
};

type Params$14 = ResolveParams<(typeof _default$14)["~type"]["url"]>;
type Body$14 = z.infer<ResolveValue<(typeof _default$14)["~type"], "body">>;
type Data$14 = ResolveData<Params$14, Body$14>;
type Response$14 = z.infer<ResolveValue<(typeof _default$14)["~type"], "responses">["200"]>;
interface PlayerInfoRequestConfig extends ValorantAxiosRequestConfig<Data$14> {
}
declare class PlayerInfoEndpoint {
    /**
     * Get the PUUID and other info from a token
     *
     * @EndpointType auth
     */
    getPlayerInfo<T = Response$14>(this: AuthApiClient, config?: PlayerInfoRequestConfig): Promise<AxiosResponse<T>>;
}

declare const RiotClientConfigResponseSchema: z.ZodIntersection<z.ZodObject<{
    "chat.affinities": z.ZodRecord<z.ZodString, z.ZodString>;
    "chat.affinity_domains": z.ZodRecord<z.ZodString, z.ZodString>;
    "chat.port": z.ZodNumber;
}, "strip", z.ZodTypeAny, {
    "chat.affinities": Record<string, string>;
    "chat.affinity_domains": Record<string, string>;
    "chat.port": number;
}, {
    "chat.affinities": Record<string, string>;
    "chat.affinity_domains": Record<string, string>;
    "chat.port": number;
}>, z.ZodRecord<z.ZodString, z.ZodUnknown>>;
declare const _default$13: Omit<{
    requirements: string[];
    type: "auth" | "local" | "pd" | "glz" | "shared";
    name: string;
    method: "PUT" | "GET" | "DELETE" | "POST";
    url: string;
    description?: string | undefined;
    headers?: Record<string, string> | undefined;
    body?: z.ZodType<any, z.ZodTypeDef, any> | undefined;
    query?: z.ZodType<any, z.ZodTypeDef, any> | undefined;
    responses?: Record<string, z.ZodType<any, z.ZodTypeDef, any>> | undefined;
}, "type" | "name" | "url"> & Pick<{
    readonly name: "Riot Client Config";
    readonly description: "Gets the config file used by the Riot Client. This includes a ton of info, most of it undocumented.";
    readonly type: "auth";
    readonly url: "https://clientconfig.rpg.riotgames.com/api/v1/config/player?app=Riot%20Client";
    readonly requirements: ["ACCESS_TOKEN", "ENTITLEMENTS_TOKEN"];
    readonly responses: {
        readonly "200": z.ZodIntersection<z.ZodObject<{
            "chat.affinities": z.ZodRecord<z.ZodString, z.ZodString>;
            "chat.affinity_domains": z.ZodRecord<z.ZodString, z.ZodString>;
            "chat.port": z.ZodNumber;
        }, "strip", z.ZodTypeAny, {
            "chat.affinities": Record<string, string>;
            "chat.affinity_domains": Record<string, string>;
            "chat.port": number;
        }, {
            "chat.affinities": Record<string, string>;
            "chat.affinity_domains": Record<string, string>;
            "chat.port": number;
        }>, z.ZodRecord<z.ZodString, z.ZodUnknown>>;
    };
}, "type" | "name" | "url"> & {
    "~type": {
        readonly name: "Riot Client Config";
        readonly description: "Gets the config file used by the Riot Client. This includes a ton of info, most of it undocumented.";
        readonly type: "auth";
        readonly url: "https://clientconfig.rpg.riotgames.com/api/v1/config/player?app=Riot%20Client";
        readonly requirements: ["ACCESS_TOKEN", "ENTITLEMENTS_TOKEN"];
        readonly responses: {
            readonly "200": z.ZodIntersection<z.ZodObject<{
                "chat.affinities": z.ZodRecord<z.ZodString, z.ZodString>;
                "chat.affinity_domains": z.ZodRecord<z.ZodString, z.ZodString>;
                "chat.port": z.ZodNumber;
            }, "strip", z.ZodTypeAny, {
                "chat.affinities": Record<string, string>;
                "chat.affinity_domains": Record<string, string>;
                "chat.port": number;
            }, {
                "chat.affinities": Record<string, string>;
                "chat.affinity_domains": Record<string, string>;
                "chat.port": number;
            }>, z.ZodRecord<z.ZodString, z.ZodUnknown>>;
        };
    };
};

type Params$13 = ResolveParams<(typeof _default$13)["~type"]["url"]>;
type Body$13 = z.infer<ResolveValue<(typeof _default$13)["~type"], "body">>;
type Data$13 = ResolveData<Params$13, Body$13>;
type Response$13 = z.infer<ResolveValue<(typeof _default$13)["~type"], "responses">["200"]>;
interface RiotClientConfigRequestConfig extends ValorantAxiosRequestConfig<Data$13> {
}
declare class RiotClientConfigEndpoint {
    /**
     * Gets the config file used by the Riot Client. This includes a ton of info, most of it undocumented.
     *
     * @EndpointType auth
     */
    getRiotClientConfig<T = Response$13>(this: AuthApiClient, config?: RiotClientConfigRequestConfig): Promise<AxiosResponse<T>>;
}

declare const RiotGeoResponseSchema: z.ZodObject<{
    token: z.ZodString;
    affinities: z.ZodObject<{
        pbe: z.ZodString;
        live: z.ZodString;
    }, "strip", z.ZodTypeAny, {
        pbe: string;
        live: string;
    }, {
        pbe: string;
        live: string;
    }>;
}, "strip", z.ZodTypeAny, {
    token: string;
    affinities: {
        pbe: string;
        live: string;
    };
}, {
    token: string;
    affinities: {
        pbe: string;
        live: string;
    };
}>;
declare const _default$12: Omit<{
    requirements: string[];
    type: "auth" | "local" | "pd" | "glz" | "shared";
    name: string;
    method: "PUT" | "GET" | "DELETE" | "POST";
    url: string;
    description?: string | undefined;
    headers?: Record<string, string> | undefined;
    body?: z.ZodType<any, z.ZodTypeDef, any> | undefined;
    query?: z.ZodType<any, z.ZodTypeDef, any> | undefined;
    responses?: Record<string, z.ZodType<any, z.ZodTypeDef, any>> | undefined;
}, "type" | "name" | "url"> & Pick<{
    readonly name: "Riot Geo";
    readonly description: "Get the region for a given ID token and auth token. The ID token and auth token can be obtained from [PUT Cookie Reauth]";
    readonly type: "auth";
    readonly url: "https://riot-geo.pas.si.riotgames.com/pas/v1/product/valorant";
    readonly method: "PUT";
    readonly requirements: ["ACCESS_TOKEN"];
    readonly body: z.ZodObject<{
        id_token: z.ZodString;
    }, "strip", z.ZodTypeAny, {
        id_token: string;
    }, {
        id_token: string;
    }>;
    readonly responses: {
        readonly "200": z.ZodObject<{
            token: z.ZodString;
            affinities: z.ZodObject<{
                pbe: z.ZodString;
                live: z.ZodString;
            }, "strip", z.ZodTypeAny, {
                pbe: string;
                live: string;
            }, {
                pbe: string;
                live: string;
            }>;
        }, "strip", z.ZodTypeAny, {
            token: string;
            affinities: {
                pbe: string;
                live: string;
            };
        }, {
            token: string;
            affinities: {
                pbe: string;
                live: string;
            };
        }>;
    };
}, "type" | "name" | "url"> & {
    "~type": {
        readonly name: "Riot Geo";
        readonly description: "Get the region for a given ID token and auth token. The ID token and auth token can be obtained from [PUT Cookie Reauth]";
        readonly type: "auth";
        readonly url: "https://riot-geo.pas.si.riotgames.com/pas/v1/product/valorant";
        readonly method: "PUT";
        readonly requirements: ["ACCESS_TOKEN"];
        readonly body: z.ZodObject<{
            id_token: z.ZodString;
        }, "strip", z.ZodTypeAny, {
            id_token: string;
        }, {
            id_token: string;
        }>;
        readonly responses: {
            readonly "200": z.ZodObject<{
                token: z.ZodString;
                affinities: z.ZodObject<{
                    pbe: z.ZodString;
                    live: z.ZodString;
                }, "strip", z.ZodTypeAny, {
                    pbe: string;
                    live: string;
                }, {
                    pbe: string;
                    live: string;
                }>;
            }, "strip", z.ZodTypeAny, {
                token: string;
                affinities: {
                    pbe: string;
                    live: string;
                };
            }, {
                token: string;
                affinities: {
                    pbe: string;
                    live: string;
                };
            }>;
        };
    };
};

type Params$12 = ResolveParams<(typeof _default$12)["~type"]["url"]>;
type Body$12 = z.infer<ResolveValue<(typeof _default$12)["~type"], "body">>;
type Data$12 = ResolveData<Params$12, Body$12>;
type Response$12 = z.infer<ResolveValue<(typeof _default$12)["~type"], "responses">["200"]>;
interface RiotGeoRequestConfig extends ValorantAxiosRequestConfig<Data$12> {
}
declare class RiotGeoEndpoint {
    /**
     * Get the region for a given ID token and auth token. The ID token and auth token can be obtained from [PUT Cookie Reauth]
     *
     * @EndpointType auth
     */
    putRiotGeo<T = Response$12>(this: AuthApiClient, config: RiotGeoRequestConfig): Promise<AxiosResponse<T>>;
}

declare class AuthApiEndpoints {
}
interface AuthApiEndpoints extends AuthCookiesEndpoint, AuthRequestEndpoint, CookieReauthEndpoint, EntitlementsTokenEndpoint$1, MultiFactorAuthenticationEndpoint, PasTokenEndpoint, PlayerInfoEndpoint, RiotClientConfigEndpoint, RiotGeoEndpoint {
}

declare const authApiClientOptionsSchema: z.ZodObject<{
    clientVersion: z.ZodString;
    rsoUserAgent: z.ZodString;
    ciphers: z.ZodDefault<z.ZodArray<z.ZodString, "many">>;
    sigalgs: z.ZodDefault<z.ZodArray<z.ZodString, "many">>;
}, "strip", z.ZodTypeAny, {
    clientVersion: string;
    rsoUserAgent: string;
    ciphers: string[];
    sigalgs: string[];
}, {
    clientVersion: string;
    rsoUserAgent: string;
    ciphers?: string[] | undefined;
    sigalgs?: string[] | undefined;
}>;
type AuthApiClientOptions = z.input<typeof authApiClientOptionsSchema>;
declare function createAuthApiClient(options: AuthApiClientOptions): AuthApiClient;
declare class AuthApiClient {
    #private;
    constructor(options: AuthApiClientOptions);
    reinit(options: AuthApiClientOptions): void;
    get axios(): AxiosInstance;
    get cookieJar(): CookieJar;
    get options(): {
        clientVersion: string;
        rsoUserAgent: string;
        ciphers: string[];
        sigalgs: string[];
    };
    ["~request"]<T extends ValorantEndpoint, TConfig extends AxiosRequestConfig>(endpoint: T, config: TConfig): Promise<axios.AxiosResponse<any, any>>;
}
interface AuthApiClient extends AuthApiEndpoints {
}

declare const AccountAliasResponseSchema: z.ZodObject<{
    active: z.ZodBoolean;
    created_datetime: z.ZodEffects<z.ZodNumber, Date, number>;
    game_name: z.ZodString;
    summoner: z.ZodBoolean;
    tag_line: z.ZodString;
}, "strip", z.ZodTypeAny, {
    game_name: string;
    tag_line: string;
    active: boolean;
    created_datetime: Date;
    summoner: boolean;
}, {
    game_name: string;
    tag_line: string;
    active: boolean;
    created_datetime: number;
    summoner: boolean;
}>;
declare const _default$11: Omit<{
    requirements: string[];
    type: "auth" | "local" | "pd" | "glz" | "shared";
    name: string;
    method: "PUT" | "GET" | "DELETE" | "POST";
    url: string;
    description?: string | undefined;
    headers?: Record<string, string> | undefined;
    body?: z.ZodType<any, z.ZodTypeDef, any> | undefined;
    query?: z.ZodType<any, z.ZodTypeDef, any> | undefined;
    responses?: Record<string, z.ZodType<any, z.ZodTypeDef, any>> | undefined;
}, "type" | "name" | "url"> & Pick<{
    readonly name: "Account Alias";
    readonly description: "Gets the player username and tagline";
    readonly type: "local";
    readonly url: "player-account/aliases/v1/active";
    readonly responses: {
        readonly "200": z.ZodObject<{
            active: z.ZodBoolean;
            created_datetime: z.ZodEffects<z.ZodNumber, Date, number>;
            game_name: z.ZodString;
            summoner: z.ZodBoolean;
            tag_line: z.ZodString;
        }, "strip", z.ZodTypeAny, {
            game_name: string;
            tag_line: string;
            active: boolean;
            created_datetime: Date;
            summoner: boolean;
        }, {
            game_name: string;
            tag_line: string;
            active: boolean;
            created_datetime: number;
            summoner: boolean;
        }>;
    };
}, "type" | "name" | "url"> & {
    "~type": {
        readonly name: "Account Alias";
        readonly description: "Gets the player username and tagline";
        readonly type: "local";
        readonly url: "player-account/aliases/v1/active";
        readonly responses: {
            readonly "200": z.ZodObject<{
                active: z.ZodBoolean;
                created_datetime: z.ZodEffects<z.ZodNumber, Date, number>;
                game_name: z.ZodString;
                summoner: z.ZodBoolean;
                tag_line: z.ZodString;
            }, "strip", z.ZodTypeAny, {
                game_name: string;
                tag_line: string;
                active: boolean;
                created_datetime: Date;
                summoner: boolean;
            }, {
                game_name: string;
                tag_line: string;
                active: boolean;
                created_datetime: number;
                summoner: boolean;
            }>;
        };
    };
};

type Params$11 = ResolveParams<(typeof _default$11)["~type"]["url"]>;
type Body$11 = z.infer<ResolveValue<(typeof _default$11)["~type"], "body">>;
type Data$11 = ResolveData<Params$11, Body$11>;
type Response$11 = z.infer<ResolveValue<(typeof _default$11)["~type"], "responses">["200"]>;
interface AccountAliasRequestConfig extends ValorantAxiosRequestConfig<Data$11> {
}
declare class AccountAliasEndpoint {
    /**
     * Gets the player username and tagline
     *
     * @EndpointType local
     */
    getAccountAlias<T = Response$11>(this: LocalApiClient, config?: AccountAliasRequestConfig): Promise<AxiosResponse<T>>;
}

declare const _default$10: Omit<{
    requirements: string[];
    type: "auth" | "local" | "pd" | "glz" | "shared";
    name: string;
    method: "PUT" | "GET" | "DELETE" | "POST";
    url: string;
    description?: string | undefined;
    headers?: Record<string, string> | undefined;
    body?: zod.ZodType<any, zod.ZodTypeDef, any> | undefined;
    query?: zod.ZodType<any, zod.ZodTypeDef, any> | undefined;
    responses?: Record<string, zod.ZodType<any, zod.ZodTypeDef, any>> | undefined;
}, "type" | "name" | "url"> & Pick<{
    readonly name: "All Chat Info";
    readonly description: "Get information about all active conversations";
    readonly type: "local";
    readonly url: "chat/v6/conversations";
    readonly responses: {
        readonly "200": zod.ZodObject<{
            conversations: zod.ZodArray<zod.ZodObject<{
                cid: zod.ZodString;
                direct_messages: zod.ZodBoolean;
                global_readership: zod.ZodBoolean;
                message_history: zod.ZodBoolean;
                mid: zod.ZodString;
                muted: zod.ZodBoolean;
                mutedRestriction: zod.ZodBoolean;
                type: zod.ZodEnum<["groupchat", "chat"]>;
                uiState: zod.ZodObject<{
                    changedSinceHidden: zod.ZodBoolean;
                    hidden: zod.ZodBoolean;
                }, "strip", zod.ZodTypeAny, {
                    changedSinceHidden: boolean;
                    hidden: boolean;
                }, {
                    changedSinceHidden: boolean;
                    hidden: boolean;
                }>;
                unread_count: zod.ZodNumber;
            }, "strip", zod.ZodTypeAny, {
                type: "chat" | "groupchat";
                cid: string;
                muted: boolean;
                direct_messages: boolean;
                global_readership: boolean;
                message_history: boolean;
                mid: string;
                mutedRestriction: boolean;
                uiState: {
                    changedSinceHidden: boolean;
                    hidden: boolean;
                };
                unread_count: number;
            }, {
                type: "chat" | "groupchat";
                cid: string;
                muted: boolean;
                direct_messages: boolean;
                global_readership: boolean;
                message_history: boolean;
                mid: string;
                mutedRestriction: boolean;
                uiState: {
                    changedSinceHidden: boolean;
                    hidden: boolean;
                };
                unread_count: number;
            }>, "many">;
        }, "strip", zod.ZodTypeAny, {
            conversations: {
                type: "chat" | "groupchat";
                cid: string;
                muted: boolean;
                direct_messages: boolean;
                global_readership: boolean;
                message_history: boolean;
                mid: string;
                mutedRestriction: boolean;
                uiState: {
                    changedSinceHidden: boolean;
                    hidden: boolean;
                };
                unread_count: number;
            }[];
        }, {
            conversations: {
                type: "chat" | "groupchat";
                cid: string;
                muted: boolean;
                direct_messages: boolean;
                global_readership: boolean;
                message_history: boolean;
                mid: string;
                mutedRestriction: boolean;
                uiState: {
                    changedSinceHidden: boolean;
                    hidden: boolean;
                };
                unread_count: number;
            }[];
        }>;
    };
}, "type" | "name" | "url"> & {
    "~type": {
        readonly name: "All Chat Info";
        readonly description: "Get information about all active conversations";
        readonly type: "local";
        readonly url: "chat/v6/conversations";
        readonly responses: {
            readonly "200": zod.ZodObject<{
                conversations: zod.ZodArray<zod.ZodObject<{
                    cid: zod.ZodString;
                    direct_messages: zod.ZodBoolean;
                    global_readership: zod.ZodBoolean;
                    message_history: zod.ZodBoolean;
                    mid: zod.ZodString;
                    muted: zod.ZodBoolean;
                    mutedRestriction: zod.ZodBoolean;
                    type: zod.ZodEnum<["groupchat", "chat"]>;
                    uiState: zod.ZodObject<{
                        changedSinceHidden: zod.ZodBoolean;
                        hidden: zod.ZodBoolean;
                    }, "strip", zod.ZodTypeAny, {
                        changedSinceHidden: boolean;
                        hidden: boolean;
                    }, {
                        changedSinceHidden: boolean;
                        hidden: boolean;
                    }>;
                    unread_count: zod.ZodNumber;
                }, "strip", zod.ZodTypeAny, {
                    type: "chat" | "groupchat";
                    cid: string;
                    muted: boolean;
                    direct_messages: boolean;
                    global_readership: boolean;
                    message_history: boolean;
                    mid: string;
                    mutedRestriction: boolean;
                    uiState: {
                        changedSinceHidden: boolean;
                        hidden: boolean;
                    };
                    unread_count: number;
                }, {
                    type: "chat" | "groupchat";
                    cid: string;
                    muted: boolean;
                    direct_messages: boolean;
                    global_readership: boolean;
                    message_history: boolean;
                    mid: string;
                    mutedRestriction: boolean;
                    uiState: {
                        changedSinceHidden: boolean;
                        hidden: boolean;
                    };
                    unread_count: number;
                }>, "many">;
            }, "strip", zod.ZodTypeAny, {
                conversations: {
                    type: "chat" | "groupchat";
                    cid: string;
                    muted: boolean;
                    direct_messages: boolean;
                    global_readership: boolean;
                    message_history: boolean;
                    mid: string;
                    mutedRestriction: boolean;
                    uiState: {
                        changedSinceHidden: boolean;
                        hidden: boolean;
                    };
                    unread_count: number;
                }[];
            }, {
                conversations: {
                    type: "chat" | "groupchat";
                    cid: string;
                    muted: boolean;
                    direct_messages: boolean;
                    global_readership: boolean;
                    message_history: boolean;
                    mid: string;
                    mutedRestriction: boolean;
                    uiState: {
                        changedSinceHidden: boolean;
                        hidden: boolean;
                    };
                    unread_count: number;
                }[];
            }>;
        };
    };
};

type Params$10 = ResolveParams<(typeof _default$10)["~type"]["url"]>;
type Body$10 = z.infer<ResolveValue<(typeof _default$10)["~type"], "body">>;
type Data$10 = ResolveData<Params$10, Body$10>;
type Response$10 = z.infer<ResolveValue<(typeof _default$10)["~type"], "responses">["200"]>;
interface AllChatInfoRequestConfig extends ValorantAxiosRequestConfig<Data$10> {
}
declare class AllChatInfoEndpoint {
    /**
     * Get information about all active conversations
     *
     * @EndpointType local
     */
    getAllChatInfo<T = Response$10>(this: LocalApiClient, config?: AllChatInfoRequestConfig): Promise<AxiosResponse<T>>;
}

declare const _default$$: Omit<{
    requirements: string[];
    type: "auth" | "local" | "pd" | "glz" | "shared";
    name: string;
    method: "PUT" | "GET" | "DELETE" | "POST";
    url: string;
    description?: string | undefined;
    headers?: Record<string, string> | undefined;
    body?: z.ZodType<any, z.ZodTypeDef, any> | undefined;
    query?: z.ZodType<any, z.ZodTypeDef, any> | undefined;
    responses?: Record<string, z.ZodType<any, z.ZodTypeDef, any>> | undefined;
}, "type" | "name" | "url"> & Pick<{
    readonly name: "Chat History";
    readonly description: "Get chat history for all conversations or a specific conversation if the cid is provided";
    readonly type: "local";
    readonly url: "chat/v6/messages";
    readonly query: z.ZodObject<{
        cid: z.ZodOptional<z.ZodString>;
    }, "strip", z.ZodTypeAny, {
        cid?: string | undefined;
    }, {
        cid?: string | undefined;
    }>;
    readonly responses: {
        readonly "200": z.ZodObject<{
            messages: z.ZodArray<z.ZodObject<{
                body: z.ZodString;
                cid: z.ZodString;
                game_name: z.ZodString;
                game_tag: z.ZodString;
                id: z.ZodString;
                mid: z.ZodString;
                name: z.ZodString;
                pid: z.ZodString;
                puuid: z.ZodString;
                read: z.ZodBoolean;
                region: z.ZodString;
                time: z.ZodEffects<z.ZodString, Date, string>;
                type: z.ZodEnum<["chat", "groupchat"]>;
            }, "strip", z.ZodTypeAny, {
                pid: string;
                type: "chat" | "groupchat";
                name: string;
                body: string;
                time: Date;
                region: string;
                puuid: string;
                game_name: string;
                game_tag: string;
                cid: string;
                mid: string;
                id: string;
                read: boolean;
            }, {
                pid: string;
                type: "chat" | "groupchat";
                name: string;
                body: string;
                time: string;
                region: string;
                puuid: string;
                game_name: string;
                game_tag: string;
                cid: string;
                mid: string;
                id: string;
                read: boolean;
            }>, "many">;
        }, "strip", z.ZodTypeAny, {
            messages: {
                pid: string;
                type: "chat" | "groupchat";
                name: string;
                body: string;
                time: Date;
                region: string;
                puuid: string;
                game_name: string;
                game_tag: string;
                cid: string;
                mid: string;
                id: string;
                read: boolean;
            }[];
        }, {
            messages: {
                pid: string;
                type: "chat" | "groupchat";
                name: string;
                body: string;
                time: string;
                region: string;
                puuid: string;
                game_name: string;
                game_tag: string;
                cid: string;
                mid: string;
                id: string;
                read: boolean;
            }[];
        }>;
    };
}, "type" | "name" | "url"> & {
    "~type": {
        readonly name: "Chat History";
        readonly description: "Get chat history for all conversations or a specific conversation if the cid is provided";
        readonly type: "local";
        readonly url: "chat/v6/messages";
        readonly query: z.ZodObject<{
            cid: z.ZodOptional<z.ZodString>;
        }, "strip", z.ZodTypeAny, {
            cid?: string | undefined;
        }, {
            cid?: string | undefined;
        }>;
        readonly responses: {
            readonly "200": z.ZodObject<{
                messages: z.ZodArray<z.ZodObject<{
                    body: z.ZodString;
                    cid: z.ZodString;
                    game_name: z.ZodString;
                    game_tag: z.ZodString;
                    id: z.ZodString;
                    mid: z.ZodString;
                    name: z.ZodString;
                    pid: z.ZodString;
                    puuid: z.ZodString;
                    read: z.ZodBoolean;
                    region: z.ZodString;
                    time: z.ZodEffects<z.ZodString, Date, string>;
                    type: z.ZodEnum<["chat", "groupchat"]>;
                }, "strip", z.ZodTypeAny, {
                    pid: string;
                    type: "chat" | "groupchat";
                    name: string;
                    body: string;
                    time: Date;
                    region: string;
                    puuid: string;
                    game_name: string;
                    game_tag: string;
                    cid: string;
                    mid: string;
                    id: string;
                    read: boolean;
                }, {
                    pid: string;
                    type: "chat" | "groupchat";
                    name: string;
                    body: string;
                    time: string;
                    region: string;
                    puuid: string;
                    game_name: string;
                    game_tag: string;
                    cid: string;
                    mid: string;
                    id: string;
                    read: boolean;
                }>, "many">;
            }, "strip", z.ZodTypeAny, {
                messages: {
                    pid: string;
                    type: "chat" | "groupchat";
                    name: string;
                    body: string;
                    time: Date;
                    region: string;
                    puuid: string;
                    game_name: string;
                    game_tag: string;
                    cid: string;
                    mid: string;
                    id: string;
                    read: boolean;
                }[];
            }, {
                messages: {
                    pid: string;
                    type: "chat" | "groupchat";
                    name: string;
                    body: string;
                    time: string;
                    region: string;
                    puuid: string;
                    game_name: string;
                    game_tag: string;
                    cid: string;
                    mid: string;
                    id: string;
                    read: boolean;
                }[];
            }>;
        };
    };
};

type Params$$ = ResolveParams<(typeof _default$$)["~type"]["url"]>;
type Body$$ = z.infer<ResolveValue<(typeof _default$$)["~type"], "body">>;
type Data$$ = ResolveData<Params$$, Body$$>;
type Response$$ = z.infer<ResolveValue<(typeof _default$$)["~type"], "responses">["200"]>;
interface ChatHistoryRequestConfig extends ValorantAxiosRequestConfig<Data$$> {
}
declare class ChatHistoryEndpoint {
    /**
     * Get chat history for all conversations or a specific conversation if the cid is provided
     *
     * @EndpointType local
     */
    getChatHistory<T = Response$$>(this: LocalApiClient, config?: ChatHistoryRequestConfig): Promise<AxiosResponse<T>>;
}

declare const ChatParticipantsResponseSchema: z.ZodObject<{
    participants: z.ZodArray<z.ZodObject<{
        activePlatform: z.ZodNull;
        cid: z.ZodString;
        game_name: z.ZodString;
        game_tag: z.ZodString;
        muted: z.ZodBoolean;
        name: z.ZodString;
        pid: z.ZodString;
        puuid: z.ZodString;
        region: z.ZodString;
    }, "strip", z.ZodTypeAny, {
        pid: string;
        name: string;
        region: string;
        puuid: string;
        game_name: string;
        activePlatform: null;
        game_tag: string;
        cid: string;
        muted: boolean;
    }, {
        pid: string;
        name: string;
        region: string;
        puuid: string;
        game_name: string;
        activePlatform: null;
        game_tag: string;
        cid: string;
        muted: boolean;
    }>, "many">;
}, "strip", z.ZodTypeAny, {
    participants: {
        pid: string;
        name: string;
        region: string;
        puuid: string;
        game_name: string;
        activePlatform: null;
        game_tag: string;
        cid: string;
        muted: boolean;
    }[];
}, {
    participants: {
        pid: string;
        name: string;
        region: string;
        puuid: string;
        game_name: string;
        activePlatform: null;
        game_tag: string;
        cid: string;
        muted: boolean;
    }[];
}>;
declare const _default$_: Omit<{
    requirements: string[];
    type: "auth" | "local" | "pd" | "glz" | "shared";
    name: string;
    method: "PUT" | "GET" | "DELETE" | "POST";
    url: string;
    description?: string | undefined;
    headers?: Record<string, string> | undefined;
    body?: z.ZodType<any, z.ZodTypeDef, any> | undefined;
    query?: z.ZodType<any, z.ZodTypeDef, any> | undefined;
    responses?: Record<string, z.ZodType<any, z.ZodTypeDef, any>> | undefined;
}, "type" | "name" | "url"> & Pick<{
    readonly name: "Chat Participants";
    readonly description: "Get information about the participants of all active conversations or a specific conversation if a cid is provided";
    readonly type: "local";
    readonly url: "chat/v5/participants";
    readonly query: z.ZodObject<{
        cid: z.ZodOptional<z.ZodString>;
    }, "strip", z.ZodTypeAny, {
        cid?: string | undefined;
    }, {
        cid?: string | undefined;
    }>;
    readonly responses: {
        readonly "200": z.ZodObject<{
            participants: z.ZodArray<z.ZodObject<{
                activePlatform: z.ZodNull;
                cid: z.ZodString;
                game_name: z.ZodString;
                game_tag: z.ZodString;
                muted: z.ZodBoolean;
                name: z.ZodString;
                pid: z.ZodString;
                puuid: z.ZodString;
                region: z.ZodString;
            }, "strip", z.ZodTypeAny, {
                pid: string;
                name: string;
                region: string;
                puuid: string;
                game_name: string;
                activePlatform: null;
                game_tag: string;
                cid: string;
                muted: boolean;
            }, {
                pid: string;
                name: string;
                region: string;
                puuid: string;
                game_name: string;
                activePlatform: null;
                game_tag: string;
                cid: string;
                muted: boolean;
            }>, "many">;
        }, "strip", z.ZodTypeAny, {
            participants: {
                pid: string;
                name: string;
                region: string;
                puuid: string;
                game_name: string;
                activePlatform: null;
                game_tag: string;
                cid: string;
                muted: boolean;
            }[];
        }, {
            participants: {
                pid: string;
                name: string;
                region: string;
                puuid: string;
                game_name: string;
                activePlatform: null;
                game_tag: string;
                cid: string;
                muted: boolean;
            }[];
        }>;
    };
}, "type" | "name" | "url"> & {
    "~type": {
        readonly name: "Chat Participants";
        readonly description: "Get information about the participants of all active conversations or a specific conversation if a cid is provided";
        readonly type: "local";
        readonly url: "chat/v5/participants";
        readonly query: z.ZodObject<{
            cid: z.ZodOptional<z.ZodString>;
        }, "strip", z.ZodTypeAny, {
            cid?: string | undefined;
        }, {
            cid?: string | undefined;
        }>;
        readonly responses: {
            readonly "200": z.ZodObject<{
                participants: z.ZodArray<z.ZodObject<{
                    activePlatform: z.ZodNull;
                    cid: z.ZodString;
                    game_name: z.ZodString;
                    game_tag: z.ZodString;
                    muted: z.ZodBoolean;
                    name: z.ZodString;
                    pid: z.ZodString;
                    puuid: z.ZodString;
                    region: z.ZodString;
                }, "strip", z.ZodTypeAny, {
                    pid: string;
                    name: string;
                    region: string;
                    puuid: string;
                    game_name: string;
                    activePlatform: null;
                    game_tag: string;
                    cid: string;
                    muted: boolean;
                }, {
                    pid: string;
                    name: string;
                    region: string;
                    puuid: string;
                    game_name: string;
                    activePlatform: null;
                    game_tag: string;
                    cid: string;
                    muted: boolean;
                }>, "many">;
            }, "strip", z.ZodTypeAny, {
                participants: {
                    pid: string;
                    name: string;
                    region: string;
                    puuid: string;
                    game_name: string;
                    activePlatform: null;
                    game_tag: string;
                    cid: string;
                    muted: boolean;
                }[];
            }, {
                participants: {
                    pid: string;
                    name: string;
                    region: string;
                    puuid: string;
                    game_name: string;
                    activePlatform: null;
                    game_tag: string;
                    cid: string;
                    muted: boolean;
                }[];
            }>;
        };
    };
};

type Params$_ = ResolveParams<(typeof _default$_)["~type"]["url"]>;
type Body$_ = z.infer<ResolveValue<(typeof _default$_)["~type"], "body">>;
type Data$_ = ResolveData<Params$_, Body$_>;
type Response$_ = z.infer<ResolveValue<(typeof _default$_)["~type"], "responses">["200"]>;
interface ChatParticipantsRequestConfig extends ValorantAxiosRequestConfig<Data$_> {
}
declare class ChatParticipantsEndpoint {
    /**
     * Get information about the participants of all active conversations or a specific conversation if a cid is provided
     *
     * @EndpointType local
     */
    getChatParticipants<T = Response$_>(this: LocalApiClient, config?: ChatParticipantsRequestConfig): Promise<AxiosResponse<T>>;
}

declare const ChatSessionResponseSchema: z.ZodObject<{
    federated: z.ZodBoolean;
    game_name: z.ZodString;
    game_tag: z.ZodString;
    loaded: z.ZodBoolean;
    name: z.ZodString;
    pid: z.ZodString;
    puuid: z.ZodString;
    region: z.ZodString;
    resource: z.ZodString;
    state: z.ZodString;
}, "strip", z.ZodTypeAny, {
    pid: string;
    name: string;
    region: string;
    puuid: string;
    state: string;
    game_name: string;
    game_tag: string;
    federated: boolean;
    loaded: boolean;
    resource: string;
}, {
    pid: string;
    name: string;
    region: string;
    puuid: string;
    state: string;
    game_name: string;
    game_tag: string;
    federated: boolean;
    loaded: boolean;
    resource: string;
}>;
declare const _default$Z: Omit<{
    requirements: string[];
    type: "auth" | "local" | "pd" | "glz" | "shared";
    name: string;
    method: "PUT" | "GET" | "DELETE" | "POST";
    url: string;
    description?: string | undefined;
    headers?: Record<string, string> | undefined;
    body?: z.ZodType<any, z.ZodTypeDef, any> | undefined;
    query?: z.ZodType<any, z.ZodTypeDef, any> | undefined;
    responses?: Record<string, z.ZodType<any, z.ZodTypeDef, any>> | undefined;
}, "type" | "name" | "url"> & Pick<{
    readonly name: "Chat Session";
    readonly description: "Get the current session including player name and PUUID";
    readonly type: "local";
    readonly url: "chat/v1/session";
    readonly responses: {
        readonly "200": z.ZodObject<{
            federated: z.ZodBoolean;
            game_name: z.ZodString;
            game_tag: z.ZodString;
            loaded: z.ZodBoolean;
            name: z.ZodString;
            pid: z.ZodString;
            puuid: z.ZodString;
            region: z.ZodString;
            resource: z.ZodString;
            state: z.ZodString;
        }, "strip", z.ZodTypeAny, {
            pid: string;
            name: string;
            region: string;
            puuid: string;
            state: string;
            game_name: string;
            game_tag: string;
            federated: boolean;
            loaded: boolean;
            resource: string;
        }, {
            pid: string;
            name: string;
            region: string;
            puuid: string;
            state: string;
            game_name: string;
            game_tag: string;
            federated: boolean;
            loaded: boolean;
            resource: string;
        }>;
    };
}, "type" | "name" | "url"> & {
    "~type": {
        readonly name: "Chat Session";
        readonly description: "Get the current session including player name and PUUID";
        readonly type: "local";
        readonly url: "chat/v1/session";
        readonly responses: {
            readonly "200": z.ZodObject<{
                federated: z.ZodBoolean;
                game_name: z.ZodString;
                game_tag: z.ZodString;
                loaded: z.ZodBoolean;
                name: z.ZodString;
                pid: z.ZodString;
                puuid: z.ZodString;
                region: z.ZodString;
                resource: z.ZodString;
                state: z.ZodString;
            }, "strip", z.ZodTypeAny, {
                pid: string;
                name: string;
                region: string;
                puuid: string;
                state: string;
                game_name: string;
                game_tag: string;
                federated: boolean;
                loaded: boolean;
                resource: string;
            }, {
                pid: string;
                name: string;
                region: string;
                puuid: string;
                state: string;
                game_name: string;
                game_tag: string;
                federated: boolean;
                loaded: boolean;
                resource: string;
            }>;
        };
    };
};

type Params$Z = ResolveParams<(typeof _default$Z)["~type"]["url"]>;
type Body$Z = z.infer<ResolveValue<(typeof _default$Z)["~type"], "body">>;
type Data$Z = ResolveData<Params$Z, Body$Z>;
type Response$Z = z.infer<ResolveValue<(typeof _default$Z)["~type"], "responses">["200"]>;
interface ChatSessionRequestConfig extends ValorantAxiosRequestConfig<Data$Z> {
}
declare class ChatSessionEndpoint {
    /**
     * Get the current session including player name and PUUID
     *
     * @EndpointType local
     */
    getChatSession<T = Response$Z>(this: LocalApiClient, config?: ChatSessionRequestConfig): Promise<AxiosResponse<T>>;
}

declare const ChatRegionSchema: z.ZodObject<{
    locale: z.ZodString;
    region: z.ZodString;
    webLanguage: z.ZodString;
    webRegion: z.ZodString;
}, "strip", z.ZodTypeAny, {
    region: string;
    locale: string;
    webLanguage: string;
    webRegion: string;
}, {
    region: string;
    locale: string;
    webLanguage: string;
    webRegion: string;
}>;
declare const _default$Y: Omit<{
    requirements: string[];
    type: "auth" | "local" | "pd" | "glz" | "shared";
    name: string;
    method: "PUT" | "GET" | "DELETE" | "POST";
    url: string;
    description?: string | undefined;
    headers?: Record<string, string> | undefined;
    body?: z.ZodType<any, z.ZodTypeDef, any> | undefined;
    query?: z.ZodType<any, z.ZodTypeDef, any> | undefined;
    responses?: Record<string, z.ZodType<any, z.ZodTypeDef, any>> | undefined;
}, "type" | "name" | "url"> & Pick<{
    readonly name: "Client Region";
    readonly description: "Gets info about the region and locale from the Riot client";
    readonly type: "local";
    readonly url: "riotclient/region-locale";
    readonly responses: {
        readonly "200": z.ZodObject<{
            locale: z.ZodString;
            region: z.ZodString;
            webLanguage: z.ZodString;
            webRegion: z.ZodString;
        }, "strip", z.ZodTypeAny, {
            region: string;
            locale: string;
            webLanguage: string;
            webRegion: string;
        }, {
            region: string;
            locale: string;
            webLanguage: string;
            webRegion: string;
        }>;
    };
}, "type" | "name" | "url"> & {
    "~type": {
        readonly name: "Client Region";
        readonly description: "Gets info about the region and locale from the Riot client";
        readonly type: "local";
        readonly url: "riotclient/region-locale";
        readonly responses: {
            readonly "200": z.ZodObject<{
                locale: z.ZodString;
                region: z.ZodString;
                webLanguage: z.ZodString;
                webRegion: z.ZodString;
            }, "strip", z.ZodTypeAny, {
                region: string;
                locale: string;
                webLanguage: string;
                webRegion: string;
            }, {
                region: string;
                locale: string;
                webLanguage: string;
                webRegion: string;
            }>;
        };
    };
};

type Params$Y = ResolveParams<(typeof _default$Y)["~type"]["url"]>;
type Body$Y = z.infer<ResolveValue<(typeof _default$Y)["~type"], "body">>;
type Data$Y = ResolveData<Params$Y, Body$Y>;
type Response$Y = z.infer<ResolveValue<(typeof _default$Y)["~type"], "responses">["200"]>;
interface ClientRegionRequestConfig extends ValorantAxiosRequestConfig<Data$Y> {
}
declare class ClientRegionEndpoint {
    /**
     * Gets info about the region and locale from the Riot client
     *
     * @EndpointType local
     */
    getClientRegion<T = Response$Y>(this: LocalApiClient, config?: ClientRegionRequestConfig): Promise<AxiosResponse<T>>;
}

declare const _default$X: Omit<{
    requirements: string[];
    type: "auth" | "local" | "pd" | "glz" | "shared";
    name: string;
    method: "PUT" | "GET" | "DELETE" | "POST";
    url: string;
    description?: string | undefined;
    headers?: Record<string, string> | undefined;
    body?: zod.ZodType<any, zod.ZodTypeDef, any> | undefined;
    query?: zod.ZodType<any, zod.ZodTypeDef, any> | undefined;
    responses?: Record<string, zod.ZodType<any, zod.ZodTypeDef, any>> | undefined;
}, "type" | "name" | "url"> & Pick<{
    readonly name: "Current Game Chat Info";
    readonly description: "Get information about the current game chat";
    readonly type: "local";
    readonly url: "chat/v6/conversations/ares-coregame";
    readonly responses: {
        readonly "200": zod.ZodObject<{
            conversations: zod.ZodArray<zod.ZodObject<{
                cid: zod.ZodString;
                direct_messages: zod.ZodBoolean;
                global_readership: zod.ZodBoolean;
                message_history: zod.ZodBoolean;
                mid: zod.ZodString;
                muted: zod.ZodBoolean;
                mutedRestriction: zod.ZodBoolean;
                type: zod.ZodEnum<["groupchat", "chat"]>;
                uiState: zod.ZodObject<{
                    changedSinceHidden: zod.ZodBoolean;
                    hidden: zod.ZodBoolean;
                }, "strip", zod.ZodTypeAny, {
                    changedSinceHidden: boolean;
                    hidden: boolean;
                }, {
                    changedSinceHidden: boolean;
                    hidden: boolean;
                }>;
                unread_count: zod.ZodNumber;
            }, "strip", zod.ZodTypeAny, {
                type: "chat" | "groupchat";
                cid: string;
                muted: boolean;
                direct_messages: boolean;
                global_readership: boolean;
                message_history: boolean;
                mid: string;
                mutedRestriction: boolean;
                uiState: {
                    changedSinceHidden: boolean;
                    hidden: boolean;
                };
                unread_count: number;
            }, {
                type: "chat" | "groupchat";
                cid: string;
                muted: boolean;
                direct_messages: boolean;
                global_readership: boolean;
                message_history: boolean;
                mid: string;
                mutedRestriction: boolean;
                uiState: {
                    changedSinceHidden: boolean;
                    hidden: boolean;
                };
                unread_count: number;
            }>, "many">;
        }, "strip", zod.ZodTypeAny, {
            conversations: {
                type: "chat" | "groupchat";
                cid: string;
                muted: boolean;
                direct_messages: boolean;
                global_readership: boolean;
                message_history: boolean;
                mid: string;
                mutedRestriction: boolean;
                uiState: {
                    changedSinceHidden: boolean;
                    hidden: boolean;
                };
                unread_count: number;
            }[];
        }, {
            conversations: {
                type: "chat" | "groupchat";
                cid: string;
                muted: boolean;
                direct_messages: boolean;
                global_readership: boolean;
                message_history: boolean;
                mid: string;
                mutedRestriction: boolean;
                uiState: {
                    changedSinceHidden: boolean;
                    hidden: boolean;
                };
                unread_count: number;
            }[];
        }>;
    };
}, "type" | "name" | "url"> & {
    "~type": {
        readonly name: "Current Game Chat Info";
        readonly description: "Get information about the current game chat";
        readonly type: "local";
        readonly url: "chat/v6/conversations/ares-coregame";
        readonly responses: {
            readonly "200": zod.ZodObject<{
                conversations: zod.ZodArray<zod.ZodObject<{
                    cid: zod.ZodString;
                    direct_messages: zod.ZodBoolean;
                    global_readership: zod.ZodBoolean;
                    message_history: zod.ZodBoolean;
                    mid: zod.ZodString;
                    muted: zod.ZodBoolean;
                    mutedRestriction: zod.ZodBoolean;
                    type: zod.ZodEnum<["groupchat", "chat"]>;
                    uiState: zod.ZodObject<{
                        changedSinceHidden: zod.ZodBoolean;
                        hidden: zod.ZodBoolean;
                    }, "strip", zod.ZodTypeAny, {
                        changedSinceHidden: boolean;
                        hidden: boolean;
                    }, {
                        changedSinceHidden: boolean;
                        hidden: boolean;
                    }>;
                    unread_count: zod.ZodNumber;
                }, "strip", zod.ZodTypeAny, {
                    type: "chat" | "groupchat";
                    cid: string;
                    muted: boolean;
                    direct_messages: boolean;
                    global_readership: boolean;
                    message_history: boolean;
                    mid: string;
                    mutedRestriction: boolean;
                    uiState: {
                        changedSinceHidden: boolean;
                        hidden: boolean;
                    };
                    unread_count: number;
                }, {
                    type: "chat" | "groupchat";
                    cid: string;
                    muted: boolean;
                    direct_messages: boolean;
                    global_readership: boolean;
                    message_history: boolean;
                    mid: string;
                    mutedRestriction: boolean;
                    uiState: {
                        changedSinceHidden: boolean;
                        hidden: boolean;
                    };
                    unread_count: number;
                }>, "many">;
            }, "strip", zod.ZodTypeAny, {
                conversations: {
                    type: "chat" | "groupchat";
                    cid: string;
                    muted: boolean;
                    direct_messages: boolean;
                    global_readership: boolean;
                    message_history: boolean;
                    mid: string;
                    mutedRestriction: boolean;
                    uiState: {
                        changedSinceHidden: boolean;
                        hidden: boolean;
                    };
                    unread_count: number;
                }[];
            }, {
                conversations: {
                    type: "chat" | "groupchat";
                    cid: string;
                    muted: boolean;
                    direct_messages: boolean;
                    global_readership: boolean;
                    message_history: boolean;
                    mid: string;
                    mutedRestriction: boolean;
                    uiState: {
                        changedSinceHidden: boolean;
                        hidden: boolean;
                    };
                    unread_count: number;
                }[];
            }>;
        };
    };
};

type Params$X = ResolveParams<(typeof _default$X)["~type"]["url"]>;
type Body$X = z.infer<ResolveValue<(typeof _default$X)["~type"], "body">>;
type Data$X = ResolveData<Params$X, Body$X>;
type Response$X = z.infer<ResolveValue<(typeof _default$X)["~type"], "responses">["200"]>;
interface CurrentGameChatInfoRequestConfig extends ValorantAxiosRequestConfig<Data$X> {
}
declare class CurrentGameChatInfoEndpoint {
    /**
     * Get information about the current game chat
     *
     * @EndpointType local
     */
    getCurrentGameChatInfo<T = Response$X>(this: LocalApiClient, config?: CurrentGameChatInfoRequestConfig): Promise<AxiosResponse<T>>;
}

declare const EntitlementsTokenResponseSchema: z.ZodObject<{
    accessToken: z.ZodString;
    entitlements: z.ZodArray<z.ZodUnknown, "many">;
    issuer: z.ZodString;
    subject: z.ZodString;
    token: z.ZodString;
}, "strip", z.ZodTypeAny, {
    token: string;
    accessToken: string;
    entitlements: unknown[];
    issuer: string;
    subject: string;
}, {
    token: string;
    accessToken: string;
    entitlements: unknown[];
    issuer: string;
    subject: string;
}>;
declare const _default$W: Omit<{
    requirements: string[];
    type: "auth" | "local" | "pd" | "glz" | "shared";
    name: string;
    method: "PUT" | "GET" | "DELETE" | "POST";
    url: string;
    description?: string | undefined;
    headers?: Record<string, string> | undefined;
    body?: z.ZodType<any, z.ZodTypeDef, any> | undefined;
    query?: z.ZodType<any, z.ZodTypeDef, any> | undefined;
    responses?: Record<string, z.ZodType<any, z.ZodTypeDef, any>> | undefined;
}, "type" | "name" | "url"> & Pick<{
    readonly name: "Entitlements Token";
    readonly description: string;
    readonly type: "local";
    readonly url: "entitlements/v1/token";
    readonly responses: {
        readonly "200": z.ZodObject<{
            accessToken: z.ZodString;
            entitlements: z.ZodArray<z.ZodUnknown, "many">;
            issuer: z.ZodString;
            subject: z.ZodString;
            token: z.ZodString;
        }, "strip", z.ZodTypeAny, {
            token: string;
            accessToken: string;
            entitlements: unknown[];
            issuer: string;
            subject: string;
        }, {
            token: string;
            accessToken: string;
            entitlements: unknown[];
            issuer: string;
            subject: string;
        }>;
    };
}, "type" | "name" | "url"> & {
    "~type": {
        readonly name: "Entitlements Token";
        readonly description: string;
        readonly type: "local";
        readonly url: "entitlements/v1/token";
        readonly responses: {
            readonly "200": z.ZodObject<{
                accessToken: z.ZodString;
                entitlements: z.ZodArray<z.ZodUnknown, "many">;
                issuer: z.ZodString;
                subject: z.ZodString;
                token: z.ZodString;
            }, "strip", z.ZodTypeAny, {
                token: string;
                accessToken: string;
                entitlements: unknown[];
                issuer: string;
                subject: string;
            }, {
                token: string;
                accessToken: string;
                entitlements: unknown[];
                issuer: string;
                subject: string;
            }>;
        };
    };
};

type Params$W = ResolveParams<(typeof _default$W)["~type"]["url"]>;
type Body$W = z.infer<ResolveValue<(typeof _default$W)["~type"], "body">>;
type Data$W = ResolveData<Params$W, Body$W>;
type Response$W = z.infer<ResolveValue<(typeof _default$W)["~type"], "responses">["200"]>;
interface EntitlementsTokenRequestConfig extends ValorantAxiosRequestConfig<Data$W> {
}
declare class EntitlementsTokenEndpoint {
    /**
     * Gets both the token and entitlement for API usage
     *
     * `accessToken` is used as the token and `token` is used as the entitlement.
     *
     * @EndpointType local
     */
    getEntitlementsToken<T = Response$W>(this: LocalApiClient, config?: EntitlementsTokenRequestConfig): Promise<AxiosResponse<T>>;
}

declare const FriendRequestsResponseSchema: z.ZodObject<{
    requests: z.ZodArray<z.ZodObject<{
        game_name: z.ZodString;
        game_tag: z.ZodString;
        name: z.ZodString;
        note: z.ZodString;
        pid: z.ZodString;
        puuid: z.ZodString;
        region: z.ZodString;
        subscription: z.ZodEnum<["pending_out", "pending_in"]>;
    }, "strip", z.ZodTypeAny, {
        pid: string;
        name: string;
        region: string;
        puuid: string;
        game_name: string;
        game_tag: string;
        note: string;
        subscription: "pending_out" | "pending_in";
    }, {
        pid: string;
        name: string;
        region: string;
        puuid: string;
        game_name: string;
        game_tag: string;
        note: string;
        subscription: "pending_out" | "pending_in";
    }>, "many">;
}, "strip", z.ZodTypeAny, {
    requests: {
        pid: string;
        name: string;
        region: string;
        puuid: string;
        game_name: string;
        game_tag: string;
        note: string;
        subscription: "pending_out" | "pending_in";
    }[];
}, {
    requests: {
        pid: string;
        name: string;
        region: string;
        puuid: string;
        game_name: string;
        game_tag: string;
        note: string;
        subscription: "pending_out" | "pending_in";
    }[];
}>;
declare const _default$V: Omit<{
    requirements: string[];
    type: "auth" | "local" | "pd" | "glz" | "shared";
    name: string;
    method: "PUT" | "GET" | "DELETE" | "POST";
    url: string;
    description?: string | undefined;
    headers?: Record<string, string> | undefined;
    body?: z.ZodType<any, z.ZodTypeDef, any> | undefined;
    query?: z.ZodType<any, z.ZodTypeDef, any> | undefined;
    responses?: Record<string, z.ZodType<any, z.ZodTypeDef, any>> | undefined;
}, "type" | "name" | "url"> & Pick<{
    readonly name: "Friend Requests";
    readonly description: "Get a list of friend requests";
    readonly type: "local";
    readonly url: "chat/v4/friendrequests";
    readonly responses: {
        readonly "200": z.ZodObject<{
            requests: z.ZodArray<z.ZodObject<{
                game_name: z.ZodString;
                game_tag: z.ZodString;
                name: z.ZodString;
                note: z.ZodString;
                pid: z.ZodString;
                puuid: z.ZodString;
                region: z.ZodString;
                subscription: z.ZodEnum<["pending_out", "pending_in"]>;
            }, "strip", z.ZodTypeAny, {
                pid: string;
                name: string;
                region: string;
                puuid: string;
                game_name: string;
                game_tag: string;
                note: string;
                subscription: "pending_out" | "pending_in";
            }, {
                pid: string;
                name: string;
                region: string;
                puuid: string;
                game_name: string;
                game_tag: string;
                note: string;
                subscription: "pending_out" | "pending_in";
            }>, "many">;
        }, "strip", z.ZodTypeAny, {
            requests: {
                pid: string;
                name: string;
                region: string;
                puuid: string;
                game_name: string;
                game_tag: string;
                note: string;
                subscription: "pending_out" | "pending_in";
            }[];
        }, {
            requests: {
                pid: string;
                name: string;
                region: string;
                puuid: string;
                game_name: string;
                game_tag: string;
                note: string;
                subscription: "pending_out" | "pending_in";
            }[];
        }>;
    };
}, "type" | "name" | "url"> & {
    "~type": {
        readonly name: "Friend Requests";
        readonly description: "Get a list of friend requests";
        readonly type: "local";
        readonly url: "chat/v4/friendrequests";
        readonly responses: {
            readonly "200": z.ZodObject<{
                requests: z.ZodArray<z.ZodObject<{
                    game_name: z.ZodString;
                    game_tag: z.ZodString;
                    name: z.ZodString;
                    note: z.ZodString;
                    pid: z.ZodString;
                    puuid: z.ZodString;
                    region: z.ZodString;
                    subscription: z.ZodEnum<["pending_out", "pending_in"]>;
                }, "strip", z.ZodTypeAny, {
                    pid: string;
                    name: string;
                    region: string;
                    puuid: string;
                    game_name: string;
                    game_tag: string;
                    note: string;
                    subscription: "pending_out" | "pending_in";
                }, {
                    pid: string;
                    name: string;
                    region: string;
                    puuid: string;
                    game_name: string;
                    game_tag: string;
                    note: string;
                    subscription: "pending_out" | "pending_in";
                }>, "many">;
            }, "strip", z.ZodTypeAny, {
                requests: {
                    pid: string;
                    name: string;
                    region: string;
                    puuid: string;
                    game_name: string;
                    game_tag: string;
                    note: string;
                    subscription: "pending_out" | "pending_in";
                }[];
            }, {
                requests: {
                    pid: string;
                    name: string;
                    region: string;
                    puuid: string;
                    game_name: string;
                    game_tag: string;
                    note: string;
                    subscription: "pending_out" | "pending_in";
                }[];
            }>;
        };
    };
};

type Params$V = ResolveParams<(typeof _default$V)["~type"]["url"]>;
type Body$V = z.infer<ResolveValue<(typeof _default$V)["~type"], "body">>;
type Data$V = ResolveData<Params$V, Body$V>;
type Response$V = z.infer<ResolveValue<(typeof _default$V)["~type"], "responses">["200"]>;
interface FriendRequestsRequestConfig extends ValorantAxiosRequestConfig<Data$V> {
}
declare class FriendRequestsEndpoint {
    /**
     * Get a list of friend requests
     *
     * @EndpointType local
     */
    getFriendRequests<T = Response$V>(this: LocalApiClient, config?: FriendRequestsRequestConfig): Promise<AxiosResponse<T>>;
}

declare const FriendsResponseSchema: z.ZodObject<{
    friends: z.ZodArray<z.ZodObject<{
        activePlatform: z.ZodNullable<z.ZodString>;
        displayGroup: z.ZodString;
        game_name: z.ZodString;
        game_tag: z.ZodString;
        group: z.ZodString;
        last_online_ts: z.ZodNullable<z.ZodEffects<z.ZodNumber, Date, number>>;
        name: z.ZodString;
        note: z.ZodString;
        pid: z.ZodString;
        puuid: z.ZodString;
        region: z.ZodString;
    }, "strip", z.ZodTypeAny, {
        pid: string;
        name: string;
        region: string;
        puuid: string;
        game_name: string;
        activePlatform: string | null;
        displayGroup: string;
        game_tag: string;
        group: string;
        last_online_ts: Date | null;
        note: string;
    }, {
        pid: string;
        name: string;
        region: string;
        puuid: string;
        game_name: string;
        activePlatform: string | null;
        displayGroup: string;
        game_tag: string;
        group: string;
        last_online_ts: number | null;
        note: string;
    }>, "many">;
}, "strip", z.ZodTypeAny, {
    friends: {
        pid: string;
        name: string;
        region: string;
        puuid: string;
        game_name: string;
        activePlatform: string | null;
        displayGroup: string;
        game_tag: string;
        group: string;
        last_online_ts: Date | null;
        note: string;
    }[];
}, {
    friends: {
        pid: string;
        name: string;
        region: string;
        puuid: string;
        game_name: string;
        activePlatform: string | null;
        displayGroup: string;
        game_tag: string;
        group: string;
        last_online_ts: number | null;
        note: string;
    }[];
}>;
declare const _default$U: Omit<{
    requirements: string[];
    type: "auth" | "local" | "pd" | "glz" | "shared";
    name: string;
    method: "PUT" | "GET" | "DELETE" | "POST";
    url: string;
    description?: string | undefined;
    headers?: Record<string, string> | undefined;
    body?: z.ZodType<any, z.ZodTypeDef, any> | undefined;
    query?: z.ZodType<any, z.ZodTypeDef, any> | undefined;
    responses?: Record<string, z.ZodType<any, z.ZodTypeDef, any>> | undefined;
}, "type" | "name" | "url"> & Pick<{
    readonly name: "Friends";
    readonly description: "Get a list of friends";
    readonly type: "local";
    readonly url: "chat/v4/friends";
    readonly responses: {
        readonly "200": z.ZodObject<{
            friends: z.ZodArray<z.ZodObject<{
                activePlatform: z.ZodNullable<z.ZodString>;
                displayGroup: z.ZodString;
                game_name: z.ZodString;
                game_tag: z.ZodString;
                group: z.ZodString;
                last_online_ts: z.ZodNullable<z.ZodEffects<z.ZodNumber, Date, number>>;
                name: z.ZodString;
                note: z.ZodString;
                pid: z.ZodString;
                puuid: z.ZodString;
                region: z.ZodString;
            }, "strip", z.ZodTypeAny, {
                pid: string;
                name: string;
                region: string;
                puuid: string;
                game_name: string;
                activePlatform: string | null;
                displayGroup: string;
                game_tag: string;
                group: string;
                last_online_ts: Date | null;
                note: string;
            }, {
                pid: string;
                name: string;
                region: string;
                puuid: string;
                game_name: string;
                activePlatform: string | null;
                displayGroup: string;
                game_tag: string;
                group: string;
                last_online_ts: number | null;
                note: string;
            }>, "many">;
        }, "strip", z.ZodTypeAny, {
            friends: {
                pid: string;
                name: string;
                region: string;
                puuid: string;
                game_name: string;
                activePlatform: string | null;
                displayGroup: string;
                game_tag: string;
                group: string;
                last_online_ts: Date | null;
                note: string;
            }[];
        }, {
            friends: {
                pid: string;
                name: string;
                region: string;
                puuid: string;
                game_name: string;
                activePlatform: string | null;
                displayGroup: string;
                game_tag: string;
                group: string;
                last_online_ts: number | null;
                note: string;
            }[];
        }>;
    };
}, "type" | "name" | "url"> & {
    "~type": {
        readonly name: "Friends";
        readonly description: "Get a list of friends";
        readonly type: "local";
        readonly url: "chat/v4/friends";
        readonly responses: {
            readonly "200": z.ZodObject<{
                friends: z.ZodArray<z.ZodObject<{
                    activePlatform: z.ZodNullable<z.ZodString>;
                    displayGroup: z.ZodString;
                    game_name: z.ZodString;
                    game_tag: z.ZodString;
                    group: z.ZodString;
                    last_online_ts: z.ZodNullable<z.ZodEffects<z.ZodNumber, Date, number>>;
                    name: z.ZodString;
                    note: z.ZodString;
                    pid: z.ZodString;
                    puuid: z.ZodString;
                    region: z.ZodString;
                }, "strip", z.ZodTypeAny, {
                    pid: string;
                    name: string;
                    region: string;
                    puuid: string;
                    game_name: string;
                    activePlatform: string | null;
                    displayGroup: string;
                    game_tag: string;
                    group: string;
                    last_online_ts: Date | null;
                    note: string;
                }, {
                    pid: string;
                    name: string;
                    region: string;
                    puuid: string;
                    game_name: string;
                    activePlatform: string | null;
                    displayGroup: string;
                    game_tag: string;
                    group: string;
                    last_online_ts: number | null;
                    note: string;
                }>, "many">;
            }, "strip", z.ZodTypeAny, {
                friends: {
                    pid: string;
                    name: string;
                    region: string;
                    puuid: string;
                    game_name: string;
                    activePlatform: string | null;
                    displayGroup: string;
                    game_tag: string;
                    group: string;
                    last_online_ts: Date | null;
                    note: string;
                }[];
            }, {
                friends: {
                    pid: string;
                    name: string;
                    region: string;
                    puuid: string;
                    game_name: string;
                    activePlatform: string | null;
                    displayGroup: string;
                    game_tag: string;
                    group: string;
                    last_online_ts: number | null;
                    note: string;
                }[];
            }>;
        };
    };
};

type Params$U = ResolveParams<(typeof _default$U)["~type"]["url"]>;
type Body$U = z.infer<ResolveValue<(typeof _default$U)["~type"], "body">>;
type Data$U = ResolveData<Params$U, Body$U>;
type Response$U = z.infer<ResolveValue<(typeof _default$U)["~type"], "responses">["200"]>;
interface FriendsRequestConfig extends ValorantAxiosRequestConfig<Data$U> {
}
declare class FriendsEndpoint {
    /**
     * Get a list of friends
     *
     * @EndpointType local
     */
    getFriends<T = Response$U>(this: LocalApiClient, config?: FriendsRequestConfig): Promise<AxiosResponse<T>>;
}

declare const HelpResponseSchema: z.ZodObject<{
    events: z.ZodRecord<z.ZodString, z.ZodString>;
    functions: z.ZodRecord<z.ZodString, z.ZodString>;
    types: z.ZodRecord<z.ZodString, z.ZodString>;
}, "strip", z.ZodTypeAny, {
    events: Record<string, string>;
    functions: Record<string, string>;
    types: Record<string, string>;
}, {
    events: Record<string, string>;
    functions: Record<string, string>;
    types: Record<string, string>;
}>;
declare const _default$T: Omit<{
    requirements: string[];
    type: "auth" | "local" | "pd" | "glz" | "shared";
    name: string;
    method: "PUT" | "GET" | "DELETE" | "POST";
    url: string;
    description?: string | undefined;
    headers?: Record<string, string> | undefined;
    body?: z.ZodType<any, z.ZodTypeDef, any> | undefined;
    query?: z.ZodType<any, z.ZodTypeDef, any> | undefined;
    responses?: Record<string, z.ZodType<any, z.ZodTypeDef, any>> | undefined;
}, "type" | "name" | "url"> & Pick<{
    readonly name: "Help";
    readonly description: "Get help for the local client";
    readonly type: "local";
    readonly url: "help";
    readonly responses: {
        readonly "200": z.ZodObject<{
            events: z.ZodRecord<z.ZodString, z.ZodString>;
            functions: z.ZodRecord<z.ZodString, z.ZodString>;
            types: z.ZodRecord<z.ZodString, z.ZodString>;
        }, "strip", z.ZodTypeAny, {
            events: Record<string, string>;
            functions: Record<string, string>;
            types: Record<string, string>;
        }, {
            events: Record<string, string>;
            functions: Record<string, string>;
            types: Record<string, string>;
        }>;
    };
}, "type" | "name" | "url"> & {
    "~type": {
        readonly name: "Help";
        readonly description: "Get help for the local client";
        readonly type: "local";
        readonly url: "help";
        readonly responses: {
            readonly "200": z.ZodObject<{
                events: z.ZodRecord<z.ZodString, z.ZodString>;
                functions: z.ZodRecord<z.ZodString, z.ZodString>;
                types: z.ZodRecord<z.ZodString, z.ZodString>;
            }, "strip", z.ZodTypeAny, {
                events: Record<string, string>;
                functions: Record<string, string>;
                types: Record<string, string>;
            }, {
                events: Record<string, string>;
                functions: Record<string, string>;
                types: Record<string, string>;
            }>;
        };
    };
};

type Params$T = ResolveParams<(typeof _default$T)["~type"]["url"]>;
type Body$T = z.infer<ResolveValue<(typeof _default$T)["~type"], "body">>;
type Data$T = ResolveData<Params$T, Body$T>;
type Response$T = z.infer<ResolveValue<(typeof _default$T)["~type"], "responses">["200"]>;
interface HelpRequestConfig extends ValorantAxiosRequestConfig<Data$T> {
}
declare class HelpEndpoint {
    /**
     * Get help for the local client
     *
     * @EndpointType local
     */
    getHelp<T = Response$T>(this: LocalApiClient, config?: HelpRequestConfig): Promise<AxiosResponse<T>>;
}

declare const _default$S: Omit<{
    requirements: string[];
    type: "auth" | "local" | "pd" | "glz" | "shared";
    name: string;
    method: "PUT" | "GET" | "DELETE" | "POST";
    url: string;
    description?: string | undefined;
    headers?: Record<string, string> | undefined;
    body?: zod.ZodType<any, zod.ZodTypeDef, any> | undefined;
    query?: zod.ZodType<any, zod.ZodTypeDef, any> | undefined;
    responses?: Record<string, zod.ZodType<any, zod.ZodTypeDef, any>> | undefined;
}, "type" | "name" | "url"> & Pick<{
    readonly name: "Party Chat Info";
    readonly description: "Get information about the party chat";
    readonly type: "local";
    readonly url: "chat/v6/conversations/ares-parties";
    readonly responses: {
        readonly "200": zod.ZodObject<{
            conversations: zod.ZodArray<zod.ZodObject<{
                cid: zod.ZodString;
                direct_messages: zod.ZodBoolean;
                global_readership: zod.ZodBoolean;
                message_history: zod.ZodBoolean;
                mid: zod.ZodString;
                muted: zod.ZodBoolean;
                mutedRestriction: zod.ZodBoolean;
                type: zod.ZodEnum<["groupchat", "chat"]>;
                uiState: zod.ZodObject<{
                    changedSinceHidden: zod.ZodBoolean;
                    hidden: zod.ZodBoolean;
                }, "strip", zod.ZodTypeAny, {
                    changedSinceHidden: boolean;
                    hidden: boolean;
                }, {
                    changedSinceHidden: boolean;
                    hidden: boolean;
                }>;
                unread_count: zod.ZodNumber;
            }, "strip", zod.ZodTypeAny, {
                type: "chat" | "groupchat";
                cid: string;
                muted: boolean;
                direct_messages: boolean;
                global_readership: boolean;
                message_history: boolean;
                mid: string;
                mutedRestriction: boolean;
                uiState: {
                    changedSinceHidden: boolean;
                    hidden: boolean;
                };
                unread_count: number;
            }, {
                type: "chat" | "groupchat";
                cid: string;
                muted: boolean;
                direct_messages: boolean;
                global_readership: boolean;
                message_history: boolean;
                mid: string;
                mutedRestriction: boolean;
                uiState: {
                    changedSinceHidden: boolean;
                    hidden: boolean;
                };
                unread_count: number;
            }>, "many">;
        }, "strip", zod.ZodTypeAny, {
            conversations: {
                type: "chat" | "groupchat";
                cid: string;
                muted: boolean;
                direct_messages: boolean;
                global_readership: boolean;
                message_history: boolean;
                mid: string;
                mutedRestriction: boolean;
                uiState: {
                    changedSinceHidden: boolean;
                    hidden: boolean;
                };
                unread_count: number;
            }[];
        }, {
            conversations: {
                type: "chat" | "groupchat";
                cid: string;
                muted: boolean;
                direct_messages: boolean;
                global_readership: boolean;
                message_history: boolean;
                mid: string;
                mutedRestriction: boolean;
                uiState: {
                    changedSinceHidden: boolean;
                    hidden: boolean;
                };
                unread_count: number;
            }[];
        }>;
    };
}, "type" | "name" | "url"> & {
    "~type": {
        readonly name: "Party Chat Info";
        readonly description: "Get information about the party chat";
        readonly type: "local";
        readonly url: "chat/v6/conversations/ares-parties";
        readonly responses: {
            readonly "200": zod.ZodObject<{
                conversations: zod.ZodArray<zod.ZodObject<{
                    cid: zod.ZodString;
                    direct_messages: zod.ZodBoolean;
                    global_readership: zod.ZodBoolean;
                    message_history: zod.ZodBoolean;
                    mid: zod.ZodString;
                    muted: zod.ZodBoolean;
                    mutedRestriction: zod.ZodBoolean;
                    type: zod.ZodEnum<["groupchat", "chat"]>;
                    uiState: zod.ZodObject<{
                        changedSinceHidden: zod.ZodBoolean;
                        hidden: zod.ZodBoolean;
                    }, "strip", zod.ZodTypeAny, {
                        changedSinceHidden: boolean;
                        hidden: boolean;
                    }, {
                        changedSinceHidden: boolean;
                        hidden: boolean;
                    }>;
                    unread_count: zod.ZodNumber;
                }, "strip", zod.ZodTypeAny, {
                    type: "chat" | "groupchat";
                    cid: string;
                    muted: boolean;
                    direct_messages: boolean;
                    global_readership: boolean;
                    message_history: boolean;
                    mid: string;
                    mutedRestriction: boolean;
                    uiState: {
                        changedSinceHidden: boolean;
                        hidden: boolean;
                    };
                    unread_count: number;
                }, {
                    type: "chat" | "groupchat";
                    cid: string;
                    muted: boolean;
                    direct_messages: boolean;
                    global_readership: boolean;
                    message_history: boolean;
                    mid: string;
                    mutedRestriction: boolean;
                    uiState: {
                        changedSinceHidden: boolean;
                        hidden: boolean;
                    };
                    unread_count: number;
                }>, "many">;
            }, "strip", zod.ZodTypeAny, {
                conversations: {
                    type: "chat" | "groupchat";
                    cid: string;
                    muted: boolean;
                    direct_messages: boolean;
                    global_readership: boolean;
                    message_history: boolean;
                    mid: string;
                    mutedRestriction: boolean;
                    uiState: {
                        changedSinceHidden: boolean;
                        hidden: boolean;
                    };
                    unread_count: number;
                }[];
            }, {
                conversations: {
                    type: "chat" | "groupchat";
                    cid: string;
                    muted: boolean;
                    direct_messages: boolean;
                    global_readership: boolean;
                    message_history: boolean;
                    mid: string;
                    mutedRestriction: boolean;
                    uiState: {
                        changedSinceHidden: boolean;
                        hidden: boolean;
                    };
                    unread_count: number;
                }[];
            }>;
        };
    };
};

type Params$S = ResolveParams<(typeof _default$S)["~type"]["url"]>;
type Body$S = z.infer<ResolveValue<(typeof _default$S)["~type"], "body">>;
type Data$S = ResolveData<Params$S, Body$S>;
type Response$S = z.infer<ResolveValue<(typeof _default$S)["~type"], "responses">["200"]>;
interface PartyChatInfoRequestConfig extends ValorantAxiosRequestConfig<Data$S> {
}
declare class PartyChatInfoEndpoint {
    /**
     * Get information about the party chat
     *
     * @EndpointType local
     */
    getPartyChatInfo<T = Response$S>(this: LocalApiClient, config?: PartyChatInfoRequestConfig): Promise<AxiosResponse<T>>;
}

declare const _default$R: Omit<{
    requirements: string[];
    type: "auth" | "local" | "pd" | "glz" | "shared";
    name: string;
    method: "PUT" | "GET" | "DELETE" | "POST";
    url: string;
    description?: string | undefined;
    headers?: Record<string, string> | undefined;
    body?: zod.ZodType<any, zod.ZodTypeDef, any> | undefined;
    query?: zod.ZodType<any, zod.ZodTypeDef, any> | undefined;
    responses?: Record<string, zod.ZodType<any, zod.ZodTypeDef, any>> | undefined;
}, "type" | "name" | "url"> & Pick<{
    readonly name: "Pre-Game Chat Info";
    readonly description: "Get information about the pre-game chat";
    readonly type: "local";
    readonly url: "chat/v6/conversations/ares-pregame";
    readonly responses: {
        readonly "200": zod.ZodObject<{
            conversations: zod.ZodArray<zod.ZodObject<{
                cid: zod.ZodString;
                direct_messages: zod.ZodBoolean;
                global_readership: zod.ZodBoolean;
                message_history: zod.ZodBoolean;
                mid: zod.ZodString;
                muted: zod.ZodBoolean;
                mutedRestriction: zod.ZodBoolean;
                type: zod.ZodEnum<["groupchat", "chat"]>;
                uiState: zod.ZodObject<{
                    changedSinceHidden: zod.ZodBoolean;
                    hidden: zod.ZodBoolean;
                }, "strip", zod.ZodTypeAny, {
                    changedSinceHidden: boolean;
                    hidden: boolean;
                }, {
                    changedSinceHidden: boolean;
                    hidden: boolean;
                }>;
                unread_count: zod.ZodNumber;
            }, "strip", zod.ZodTypeAny, {
                type: "chat" | "groupchat";
                cid: string;
                muted: boolean;
                direct_messages: boolean;
                global_readership: boolean;
                message_history: boolean;
                mid: string;
                mutedRestriction: boolean;
                uiState: {
                    changedSinceHidden: boolean;
                    hidden: boolean;
                };
                unread_count: number;
            }, {
                type: "chat" | "groupchat";
                cid: string;
                muted: boolean;
                direct_messages: boolean;
                global_readership: boolean;
                message_history: boolean;
                mid: string;
                mutedRestriction: boolean;
                uiState: {
                    changedSinceHidden: boolean;
                    hidden: boolean;
                };
                unread_count: number;
            }>, "many">;
        }, "strip", zod.ZodTypeAny, {
            conversations: {
                type: "chat" | "groupchat";
                cid: string;
                muted: boolean;
                direct_messages: boolean;
                global_readership: boolean;
                message_history: boolean;
                mid: string;
                mutedRestriction: boolean;
                uiState: {
                    changedSinceHidden: boolean;
                    hidden: boolean;
                };
                unread_count: number;
            }[];
        }, {
            conversations: {
                type: "chat" | "groupchat";
                cid: string;
                muted: boolean;
                direct_messages: boolean;
                global_readership: boolean;
                message_history: boolean;
                mid: string;
                mutedRestriction: boolean;
                uiState: {
                    changedSinceHidden: boolean;
                    hidden: boolean;
                };
                unread_count: number;
            }[];
        }>;
    };
}, "type" | "name" | "url"> & {
    "~type": {
        readonly name: "Pre-Game Chat Info";
        readonly description: "Get information about the pre-game chat";
        readonly type: "local";
        readonly url: "chat/v6/conversations/ares-pregame";
        readonly responses: {
            readonly "200": zod.ZodObject<{
                conversations: zod.ZodArray<zod.ZodObject<{
                    cid: zod.ZodString;
                    direct_messages: zod.ZodBoolean;
                    global_readership: zod.ZodBoolean;
                    message_history: zod.ZodBoolean;
                    mid: zod.ZodString;
                    muted: zod.ZodBoolean;
                    mutedRestriction: zod.ZodBoolean;
                    type: zod.ZodEnum<["groupchat", "chat"]>;
                    uiState: zod.ZodObject<{
                        changedSinceHidden: zod.ZodBoolean;
                        hidden: zod.ZodBoolean;
                    }, "strip", zod.ZodTypeAny, {
                        changedSinceHidden: boolean;
                        hidden: boolean;
                    }, {
                        changedSinceHidden: boolean;
                        hidden: boolean;
                    }>;
                    unread_count: zod.ZodNumber;
                }, "strip", zod.ZodTypeAny, {
                    type: "chat" | "groupchat";
                    cid: string;
                    muted: boolean;
                    direct_messages: boolean;
                    global_readership: boolean;
                    message_history: boolean;
                    mid: string;
                    mutedRestriction: boolean;
                    uiState: {
                        changedSinceHidden: boolean;
                        hidden: boolean;
                    };
                    unread_count: number;
                }, {
                    type: "chat" | "groupchat";
                    cid: string;
                    muted: boolean;
                    direct_messages: boolean;
                    global_readership: boolean;
                    message_history: boolean;
                    mid: string;
                    mutedRestriction: boolean;
                    uiState: {
                        changedSinceHidden: boolean;
                        hidden: boolean;
                    };
                    unread_count: number;
                }>, "many">;
            }, "strip", zod.ZodTypeAny, {
                conversations: {
                    type: "chat" | "groupchat";
                    cid: string;
                    muted: boolean;
                    direct_messages: boolean;
                    global_readership: boolean;
                    message_history: boolean;
                    mid: string;
                    mutedRestriction: boolean;
                    uiState: {
                        changedSinceHidden: boolean;
                        hidden: boolean;
                    };
                    unread_count: number;
                }[];
            }, {
                conversations: {
                    type: "chat" | "groupchat";
                    cid: string;
                    muted: boolean;
                    direct_messages: boolean;
                    global_readership: boolean;
                    message_history: boolean;
                    mid: string;
                    mutedRestriction: boolean;
                    uiState: {
                        changedSinceHidden: boolean;
                        hidden: boolean;
                    };
                    unread_count: number;
                }[];
            }>;
        };
    };
};

type Params$R = ResolveParams<(typeof _default$R)["~type"]["url"]>;
type Body$R = z.infer<ResolveValue<(typeof _default$R)["~type"], "body">>;
type Data$R = ResolveData<Params$R, Body$R>;
type Response$R = z.infer<ResolveValue<(typeof _default$R)["~type"], "responses">["200"]>;
interface PreGameChatInfoRequestConfig extends ValorantAxiosRequestConfig<Data$R> {
}
declare class PreGameChatInfoEndpoint {
    /**
     * Get information about the pre-game chat
     *
     * @EndpointType local
     */
    getPreGameChatInfo<T = Response$R>(this: LocalApiClient, config?: PreGameChatInfoRequestConfig): Promise<AxiosResponse<T>>;
}

declare const leagueOfLegendsPresenceSchema: z.ZodObject<{
    bannerIdSelected: z.ZodString;
    challengeCrystalSelected: z.ZodString;
    challengeTitleSelected: z.ZodString;
    challengeTokensSelected: z.ZodEffects<z.ZodString, number[], string>;
    championId: z.ZodString;
    companionId: z.ZodString;
    damageSkinId: z.ZodString;
    gameId: z.ZodString;
    gameMode: z.ZodString;
    gameQueueType: z.ZodString;
    gameStatus: z.ZodString;
    iconOverride: z.ZodString;
    isObservable: z.ZodString;
    level: z.ZodString;
    mapId: z.ZodString;
    mapSkinId: z.ZodString;
    masteryScore: z.ZodString;
    profileIcon: z.ZodString;
    pty: z.ZodString;
    puuid: z.ZodString;
    queueId: z.ZodString;
    rankedLeagueDivision: z.ZodString;
    rankedLeagueQueue: z.ZodString;
    rankedLeagueTier: z.ZodString;
    rankedLosses: z.ZodString;
    rankedPrevSeasonDivision: z.ZodString;
    rankedPrevSeasonTier: z.ZodString;
    rankedSplitRewardLevel: z.ZodString;
    rankedWins: z.ZodString;
    regalia: z.ZodString;
    skinVariant: z.ZodString;
    skinname: z.ZodString;
    timeStamp: z.ZodString;
}, "strip", z.ZodTypeAny, {
    puuid: string;
    bannerIdSelected: string;
    challengeCrystalSelected: string;
    challengeTitleSelected: string;
    challengeTokensSelected: number[];
    championId: string;
    companionId: string;
    damageSkinId: string;
    gameId: string;
    gameMode: string;
    gameQueueType: string;
    gameStatus: string;
    iconOverride: string;
    isObservable: string;
    level: string;
    mapId: string;
    mapSkinId: string;
    masteryScore: string;
    profileIcon: string;
    pty: string;
    queueId: string;
    rankedLeagueDivision: string;
    rankedLeagueQueue: string;
    rankedLeagueTier: string;
    rankedLosses: string;
    rankedPrevSeasonDivision: string;
    rankedPrevSeasonTier: string;
    rankedSplitRewardLevel: string;
    rankedWins: string;
    regalia: string;
    skinVariant: string;
    skinname: string;
    timeStamp: string;
}, {
    puuid: string;
    bannerIdSelected: string;
    challengeCrystalSelected: string;
    challengeTitleSelected: string;
    challengeTokensSelected: string;
    championId: string;
    companionId: string;
    damageSkinId: string;
    gameId: string;
    gameMode: string;
    gameQueueType: string;
    gameStatus: string;
    iconOverride: string;
    isObservable: string;
    level: string;
    mapId: string;
    mapSkinId: string;
    masteryScore: string;
    profileIcon: string;
    pty: string;
    queueId: string;
    rankedLeagueDivision: string;
    rankedLeagueQueue: string;
    rankedLeagueTier: string;
    rankedLosses: string;
    rankedPrevSeasonDivision: string;
    rankedPrevSeasonTier: string;
    rankedSplitRewardLevel: string;
    rankedWins: string;
    regalia: string;
    skinVariant: string;
    skinname: string;
    timeStamp: string;
}>;
declare const valorantPresenceSchema: z.ZodObject<{
    isValid: z.ZodBoolean;
    sessionLoopState: z.ZodString;
    partyOwnerSessionLoopState: z.ZodString;
    customGameName: z.ZodString;
    customGameTeam: z.ZodString;
    partyOwnerMatchMap: z.ZodString;
    partyOwnerMatchCurrentTeam: z.ZodString;
    partyOwnerMatchScoreAllyTeam: z.ZodNumber;
    partyOwnerMatchScoreEnemyTeam: z.ZodNumber;
    partyOwnerProvisioningFlow: z.ZodString;
    matchMap: z.ZodString;
    partyId: z.ZodString;
    isPartyOwner: z.ZodBoolean;
    partyState: z.ZodString;
    partyAccessibility: z.ZodEnum<["OPEN", "CLOSED"]>;
    maxPartySize: z.ZodNumber;
    queueId: z.ZodString;
    partyLFM: z.ZodBoolean;
    partyClientVersion: z.ZodString;
    partySize: z.ZodNumber;
    tournamentId: z.ZodString;
    rosterId: z.ZodString;
    partyVersion: z.ZodEffects<z.ZodNumber, Date, number>;
    queueEntryTime: z.ZodString;
    playerCardId: z.ZodString;
    playerTitleId: z.ZodString;
    preferredLevelBorderId: z.ZodUnion<[z.ZodString, z.ZodLiteral<"">]>;
    accountLevel: z.ZodNumber;
    competitiveTier: z.ZodNumber;
    leaderboardPosition: z.ZodNumber;
    isIdle: z.ZodBoolean;
}, "strip", z.ZodTypeAny, {
    queueId: string;
    isValid: boolean;
    sessionLoopState: string;
    partyOwnerSessionLoopState: string;
    customGameName: string;
    customGameTeam: string;
    partyOwnerMatchMap: string;
    partyOwnerMatchCurrentTeam: string;
    partyOwnerMatchScoreAllyTeam: number;
    partyOwnerMatchScoreEnemyTeam: number;
    partyOwnerProvisioningFlow: string;
    matchMap: string;
    partyId: string;
    isPartyOwner: boolean;
    partyState: string;
    partyAccessibility: "OPEN" | "CLOSED";
    maxPartySize: number;
    partyLFM: boolean;
    partyClientVersion: string;
    partySize: number;
    tournamentId: string;
    rosterId: string;
    partyVersion: Date;
    queueEntryTime: string;
    playerCardId: string;
    playerTitleId: string;
    preferredLevelBorderId: string;
    accountLevel: number;
    competitiveTier: number;
    leaderboardPosition: number;
    isIdle: boolean;
}, {
    queueId: string;
    isValid: boolean;
    sessionLoopState: string;
    partyOwnerSessionLoopState: string;
    customGameName: string;
    customGameTeam: string;
    partyOwnerMatchMap: string;
    partyOwnerMatchCurrentTeam: string;
    partyOwnerMatchScoreAllyTeam: number;
    partyOwnerMatchScoreEnemyTeam: number;
    partyOwnerProvisioningFlow: string;
    matchMap: string;
    partyId: string;
    isPartyOwner: boolean;
    partyState: string;
    partyAccessibility: "OPEN" | "CLOSED";
    maxPartySize: number;
    partyLFM: boolean;
    partyClientVersion: string;
    partySize: number;
    tournamentId: string;
    rosterId: string;
    partyVersion: number;
    queueEntryTime: string;
    playerCardId: string;
    playerTitleId: string;
    preferredLevelBorderId: string;
    accountLevel: number;
    competitiveTier: number;
    leaderboardPosition: number;
    isIdle: boolean;
}>;
declare const PresenceResponseSchema: z.ZodObject<{
    presences: z.ZodArray<z.ZodObject<{
        actor: z.ZodNullable<z.ZodUnknown>;
        basic: z.ZodString;
        details: z.ZodNullable<z.ZodUnknown>;
        game_name: z.ZodString;
        game_tag: z.ZodString;
        location: z.ZodNullable<z.ZodUnknown>;
        msg: z.ZodNullable<z.ZodUnknown>;
        name: z.ZodString;
        patchline: z.ZodNullable<z.ZodUnknown>;
        pid: z.ZodString;
        platform: z.ZodNullable<z.ZodUnknown>;
        private: z.ZodEffects<z.ZodNullable<z.ZodString>, {
            puuid: string;
            bannerIdSelected: string;
            challengeCrystalSelected: string;
            challengeTitleSelected: string;
            challengeTokensSelected: number[];
            championId: string;
            companionId: string;
            damageSkinId: string;
            gameId: string;
            gameMode: string;
            gameQueueType: string;
            gameStatus: string;
            iconOverride: string;
            isObservable: string;
            level: string;
            mapId: string;
            mapSkinId: string;
            masteryScore: string;
            profileIcon: string;
            pty: string;
            queueId: string;
            rankedLeagueDivision: string;
            rankedLeagueQueue: string;
            rankedLeagueTier: string;
            rankedLosses: string;
            rankedPrevSeasonDivision: string;
            rankedPrevSeasonTier: string;
            rankedSplitRewardLevel: string;
            rankedWins: string;
            regalia: string;
            skinVariant: string;
            skinname: string;
            timeStamp: string;
        } | {
            queueId: string;
            isValid: boolean;
            sessionLoopState: string;
            partyOwnerSessionLoopState: string;
            customGameName: string;
            customGameTeam: string;
            partyOwnerMatchMap: string;
            partyOwnerMatchCurrentTeam: string;
            partyOwnerMatchScoreAllyTeam: number;
            partyOwnerMatchScoreEnemyTeam: number;
            partyOwnerProvisioningFlow: string;
            matchMap: string;
            partyId: string;
            isPartyOwner: boolean;
            partyState: string;
            partyAccessibility: "OPEN" | "CLOSED";
            maxPartySize: number;
            partyLFM: boolean;
            partyClientVersion: string;
            partySize: number;
            tournamentId: string;
            rosterId: string;
            partyVersion: Date;
            queueEntryTime: string;
            playerCardId: string;
            playerTitleId: string;
            preferredLevelBorderId: string;
            accountLevel: number;
            competitiveTier: number;
            leaderboardPosition: number;
            isIdle: boolean;
        } | null, string | null>;
        privateJwt: z.ZodNullable<z.ZodUnknown>;
        product: z.ZodEnum<["valorant", "league_of_legends"]>;
        puuid: z.ZodString;
        region: z.ZodString;
        resource: z.ZodString;
        state: z.ZodEnum<["mobile", "dnd", "away", "chat"]>;
        summary: z.ZodString;
        time: z.ZodEffects<z.ZodNumber, Date, number>;
    }, "strip", z.ZodTypeAny, {
        pid: string;
        name: string;
        time: Date;
        region: string;
        puuid: string;
        state: "mobile" | "dnd" | "away" | "chat";
        game_name: string;
        game_tag: string;
        resource: string;
        basic: string;
        private: {
            puuid: string;
            bannerIdSelected: string;
            challengeCrystalSelected: string;
            challengeTitleSelected: string;
            challengeTokensSelected: number[];
            championId: string;
            companionId: string;
            damageSkinId: string;
            gameId: string;
            gameMode: string;
            gameQueueType: string;
            gameStatus: string;
            iconOverride: string;
            isObservable: string;
            level: string;
            mapId: string;
            mapSkinId: string;
            masteryScore: string;
            profileIcon: string;
            pty: string;
            queueId: string;
            rankedLeagueDivision: string;
            rankedLeagueQueue: string;
            rankedLeagueTier: string;
            rankedLosses: string;
            rankedPrevSeasonDivision: string;
            rankedPrevSeasonTier: string;
            rankedSplitRewardLevel: string;
            rankedWins: string;
            regalia: string;
            skinVariant: string;
            skinname: string;
            timeStamp: string;
        } | {
            queueId: string;
            isValid: boolean;
            sessionLoopState: string;
            partyOwnerSessionLoopState: string;
            customGameName: string;
            customGameTeam: string;
            partyOwnerMatchMap: string;
            partyOwnerMatchCurrentTeam: string;
            partyOwnerMatchScoreAllyTeam: number;
            partyOwnerMatchScoreEnemyTeam: number;
            partyOwnerProvisioningFlow: string;
            matchMap: string;
            partyId: string;
            isPartyOwner: boolean;
            partyState: string;
            partyAccessibility: "OPEN" | "CLOSED";
            maxPartySize: number;
            partyLFM: boolean;
            partyClientVersion: string;
            partySize: number;
            tournamentId: string;
            rosterId: string;
            partyVersion: Date;
            queueEntryTime: string;
            playerCardId: string;
            playerTitleId: string;
            preferredLevelBorderId: string;
            accountLevel: number;
            competitiveTier: number;
            leaderboardPosition: number;
            isIdle: boolean;
        } | null;
        product: "valorant" | "league_of_legends";
        summary: string;
        platform?: unknown;
        actor?: unknown;
        details?: unknown;
        location?: unknown;
        msg?: unknown;
        patchline?: unknown;
        privateJwt?: unknown;
    }, {
        pid: string;
        name: string;
        time: number;
        region: string;
        puuid: string;
        state: "mobile" | "dnd" | "away" | "chat";
        game_name: string;
        game_tag: string;
        resource: string;
        basic: string;
        private: string | null;
        product: "valorant" | "league_of_legends";
        summary: string;
        platform?: unknown;
        actor?: unknown;
        details?: unknown;
        location?: unknown;
        msg?: unknown;
        patchline?: unknown;
        privateJwt?: unknown;
    }>, "many">;
}, "strip", z.ZodTypeAny, {
    presences: {
        pid: string;
        name: string;
        time: Date;
        region: string;
        puuid: string;
        state: "mobile" | "dnd" | "away" | "chat";
        game_name: string;
        game_tag: string;
        resource: string;
        basic: string;
        private: {
            puuid: string;
            bannerIdSelected: string;
            challengeCrystalSelected: string;
            challengeTitleSelected: string;
            challengeTokensSelected: number[];
            championId: string;
            companionId: string;
            damageSkinId: string;
            gameId: string;
            gameMode: string;
            gameQueueType: string;
            gameStatus: string;
            iconOverride: string;
            isObservable: string;
            level: string;
            mapId: string;
            mapSkinId: string;
            masteryScore: string;
            profileIcon: string;
            pty: string;
            queueId: string;
            rankedLeagueDivision: string;
            rankedLeagueQueue: string;
            rankedLeagueTier: string;
            rankedLosses: string;
            rankedPrevSeasonDivision: string;
            rankedPrevSeasonTier: string;
            rankedSplitRewardLevel: string;
            rankedWins: string;
            regalia: string;
            skinVariant: string;
            skinname: string;
            timeStamp: string;
        } | {
            queueId: string;
            isValid: boolean;
            sessionLoopState: string;
            partyOwnerSessionLoopState: string;
            customGameName: string;
            customGameTeam: string;
            partyOwnerMatchMap: string;
            partyOwnerMatchCurrentTeam: string;
            partyOwnerMatchScoreAllyTeam: number;
            partyOwnerMatchScoreEnemyTeam: number;
            partyOwnerProvisioningFlow: string;
            matchMap: string;
            partyId: string;
            isPartyOwner: boolean;
            partyState: string;
            partyAccessibility: "OPEN" | "CLOSED";
            maxPartySize: number;
            partyLFM: boolean;
            partyClientVersion: string;
            partySize: number;
            tournamentId: string;
            rosterId: string;
            partyVersion: Date;
            queueEntryTime: string;
            playerCardId: string;
            playerTitleId: string;
            preferredLevelBorderId: string;
            accountLevel: number;
            competitiveTier: number;
            leaderboardPosition: number;
            isIdle: boolean;
        } | null;
        product: "valorant" | "league_of_legends";
        summary: string;
        platform?: unknown;
        actor?: unknown;
        details?: unknown;
        location?: unknown;
        msg?: unknown;
        patchline?: unknown;
        privateJwt?: unknown;
    }[];
}, {
    presences: {
        pid: string;
        name: string;
        time: number;
        region: string;
        puuid: string;
        state: "mobile" | "dnd" | "away" | "chat";
        game_name: string;
        game_tag: string;
        resource: string;
        basic: string;
        private: string | null;
        product: "valorant" | "league_of_legends";
        summary: string;
        platform?: unknown;
        actor?: unknown;
        details?: unknown;
        location?: unknown;
        msg?: unknown;
        patchline?: unknown;
        privateJwt?: unknown;
    }[];
}>;
declare const _default$Q: Omit<{
    requirements: string[];
    type: "auth" | "local" | "pd" | "glz" | "shared";
    name: string;
    method: "PUT" | "GET" | "DELETE" | "POST";
    url: string;
    description?: string | undefined;
    headers?: Record<string, string> | undefined;
    body?: z.ZodType<any, z.ZodTypeDef, any> | undefined;
    query?: z.ZodType<any, z.ZodTypeDef, any> | undefined;
    responses?: Record<string, z.ZodType<any, z.ZodTypeDef, any>> | undefined;
}, "type" | "name" | "url"> & Pick<{
    readonly name: "Presence";
    readonly description: string;
    readonly type: "local";
    readonly url: "chat/v4/presences";
    readonly responses: {
        readonly "200": z.ZodObject<{
            presences: z.ZodArray<z.ZodObject<{
                actor: z.ZodNullable<z.ZodUnknown>;
                basic: z.ZodString;
                details: z.ZodNullable<z.ZodUnknown>;
                game_name: z.ZodString;
                game_tag: z.ZodString;
                location: z.ZodNullable<z.ZodUnknown>;
                msg: z.ZodNullable<z.ZodUnknown>;
                name: z.ZodString;
                patchline: z.ZodNullable<z.ZodUnknown>;
                pid: z.ZodString;
                platform: z.ZodNullable<z.ZodUnknown>;
                private: z.ZodEffects<z.ZodNullable<z.ZodString>, {
                    puuid: string;
                    bannerIdSelected: string;
                    challengeCrystalSelected: string;
                    challengeTitleSelected: string;
                    challengeTokensSelected: number[];
                    championId: string;
                    companionId: string;
                    damageSkinId: string;
                    gameId: string;
                    gameMode: string;
                    gameQueueType: string;
                    gameStatus: string;
                    iconOverride: string;
                    isObservable: string;
                    level: string;
                    mapId: string;
                    mapSkinId: string;
                    masteryScore: string;
                    profileIcon: string;
                    pty: string;
                    queueId: string;
                    rankedLeagueDivision: string;
                    rankedLeagueQueue: string;
                    rankedLeagueTier: string;
                    rankedLosses: string;
                    rankedPrevSeasonDivision: string;
                    rankedPrevSeasonTier: string;
                    rankedSplitRewardLevel: string;
                    rankedWins: string;
                    regalia: string;
                    skinVariant: string;
                    skinname: string;
                    timeStamp: string;
                } | {
                    queueId: string;
                    isValid: boolean;
                    sessionLoopState: string;
                    partyOwnerSessionLoopState: string;
                    customGameName: string;
                    customGameTeam: string;
                    partyOwnerMatchMap: string;
                    partyOwnerMatchCurrentTeam: string;
                    partyOwnerMatchScoreAllyTeam: number;
                    partyOwnerMatchScoreEnemyTeam: number;
                    partyOwnerProvisioningFlow: string;
                    matchMap: string;
                    partyId: string;
                    isPartyOwner: boolean;
                    partyState: string;
                    partyAccessibility: "OPEN" | "CLOSED";
                    maxPartySize: number;
                    partyLFM: boolean;
                    partyClientVersion: string;
                    partySize: number;
                    tournamentId: string;
                    rosterId: string;
                    partyVersion: Date;
                    queueEntryTime: string;
                    playerCardId: string;
                    playerTitleId: string;
                    preferredLevelBorderId: string;
                    accountLevel: number;
                    competitiveTier: number;
                    leaderboardPosition: number;
                    isIdle: boolean;
                } | null, string | null>;
                privateJwt: z.ZodNullable<z.ZodUnknown>;
                product: z.ZodEnum<["valorant", "league_of_legends"]>;
                puuid: z.ZodString;
                region: z.ZodString;
                resource: z.ZodString;
                state: z.ZodEnum<["mobile", "dnd", "away", "chat"]>;
                summary: z.ZodString;
                time: z.ZodEffects<z.ZodNumber, Date, number>;
            }, "strip", z.ZodTypeAny, {
                pid: string;
                name: string;
                time: Date;
                region: string;
                puuid: string;
                state: "mobile" | "dnd" | "away" | "chat";
                game_name: string;
                game_tag: string;
                resource: string;
                basic: string;
                private: {
                    puuid: string;
                    bannerIdSelected: string;
                    challengeCrystalSelected: string;
                    challengeTitleSelected: string;
                    challengeTokensSelected: number[];
                    championId: string;
                    companionId: string;
                    damageSkinId: string;
                    gameId: string;
                    gameMode: string;
                    gameQueueType: string;
                    gameStatus: string;
                    iconOverride: string;
                    isObservable: string;
                    level: string;
                    mapId: string;
                    mapSkinId: string;
                    masteryScore: string;
                    profileIcon: string;
                    pty: string;
                    queueId: string;
                    rankedLeagueDivision: string;
                    rankedLeagueQueue: string;
                    rankedLeagueTier: string;
                    rankedLosses: string;
                    rankedPrevSeasonDivision: string;
                    rankedPrevSeasonTier: string;
                    rankedSplitRewardLevel: string;
                    rankedWins: string;
                    regalia: string;
                    skinVariant: string;
                    skinname: string;
                    timeStamp: string;
                } | {
                    queueId: string;
                    isValid: boolean;
                    sessionLoopState: string;
                    partyOwnerSessionLoopState: string;
                    customGameName: string;
                    customGameTeam: string;
                    partyOwnerMatchMap: string;
                    partyOwnerMatchCurrentTeam: string;
                    partyOwnerMatchScoreAllyTeam: number;
                    partyOwnerMatchScoreEnemyTeam: number;
                    partyOwnerProvisioningFlow: string;
                    matchMap: string;
                    partyId: string;
                    isPartyOwner: boolean;
                    partyState: string;
                    partyAccessibility: "OPEN" | "CLOSED";
                    maxPartySize: number;
                    partyLFM: boolean;
                    partyClientVersion: string;
                    partySize: number;
                    tournamentId: string;
                    rosterId: string;
                    partyVersion: Date;
                    queueEntryTime: string;
                    playerCardId: string;
                    playerTitleId: string;
                    preferredLevelBorderId: string;
                    accountLevel: number;
                    competitiveTier: number;
                    leaderboardPosition: number;
                    isIdle: boolean;
                } | null;
                product: "valorant" | "league_of_legends";
                summary: string;
                platform?: unknown;
                actor?: unknown;
                details?: unknown;
                location?: unknown;
                msg?: unknown;
                patchline?: unknown;
                privateJwt?: unknown;
            }, {
                pid: string;
                name: string;
                time: number;
                region: string;
                puuid: string;
                state: "mobile" | "dnd" | "away" | "chat";
                game_name: string;
                game_tag: string;
                resource: string;
                basic: string;
                private: string | null;
                product: "valorant" | "league_of_legends";
                summary: string;
                platform?: unknown;
                actor?: unknown;
                details?: unknown;
                location?: unknown;
                msg?: unknown;
                patchline?: unknown;
                privateJwt?: unknown;
            }>, "many">;
        }, "strip", z.ZodTypeAny, {
            presences: {
                pid: string;
                name: string;
                time: Date;
                region: string;
                puuid: string;
                state: "mobile" | "dnd" | "away" | "chat";
                game_name: string;
                game_tag: string;
                resource: string;
                basic: string;
                private: {
                    puuid: string;
                    bannerIdSelected: string;
                    challengeCrystalSelected: string;
                    challengeTitleSelected: string;
                    challengeTokensSelected: number[];
                    championId: string;
                    companionId: string;
                    damageSkinId: string;
                    gameId: string;
                    gameMode: string;
                    gameQueueType: string;
                    gameStatus: string;
                    iconOverride: string;
                    isObservable: string;
                    level: string;
                    mapId: string;
                    mapSkinId: string;
                    masteryScore: string;
                    profileIcon: string;
                    pty: string;
                    queueId: string;
                    rankedLeagueDivision: string;
                    rankedLeagueQueue: string;
                    rankedLeagueTier: string;
                    rankedLosses: string;
                    rankedPrevSeasonDivision: string;
                    rankedPrevSeasonTier: string;
                    rankedSplitRewardLevel: string;
                    rankedWins: string;
                    regalia: string;
                    skinVariant: string;
                    skinname: string;
                    timeStamp: string;
                } | {
                    queueId: string;
                    isValid: boolean;
                    sessionLoopState: string;
                    partyOwnerSessionLoopState: string;
                    customGameName: string;
                    customGameTeam: string;
                    partyOwnerMatchMap: string;
                    partyOwnerMatchCurrentTeam: string;
                    partyOwnerMatchScoreAllyTeam: number;
                    partyOwnerMatchScoreEnemyTeam: number;
                    partyOwnerProvisioningFlow: string;
                    matchMap: string;
                    partyId: string;
                    isPartyOwner: boolean;
                    partyState: string;
                    partyAccessibility: "OPEN" | "CLOSED";
                    maxPartySize: number;
                    partyLFM: boolean;
                    partyClientVersion: string;
                    partySize: number;
                    tournamentId: string;
                    rosterId: string;
                    partyVersion: Date;
                    queueEntryTime: string;
                    playerCardId: string;
                    playerTitleId: string;
                    preferredLevelBorderId: string;
                    accountLevel: number;
                    competitiveTier: number;
                    leaderboardPosition: number;
                    isIdle: boolean;
                } | null;
                product: "valorant" | "league_of_legends";
                summary: string;
                platform?: unknown;
                actor?: unknown;
                details?: unknown;
                location?: unknown;
                msg?: unknown;
                patchline?: unknown;
                privateJwt?: unknown;
            }[];
        }, {
            presences: {
                pid: string;
                name: string;
                time: number;
                region: string;
                puuid: string;
                state: "mobile" | "dnd" | "away" | "chat";
                game_name: string;
                game_tag: string;
                resource: string;
                basic: string;
                private: string | null;
                product: "valorant" | "league_of_legends";
                summary: string;
                platform?: unknown;
                actor?: unknown;
                details?: unknown;
                location?: unknown;
                msg?: unknown;
                patchline?: unknown;
                privateJwt?: unknown;
            }[];
        }>;
    };
}, "type" | "name" | "url"> & {
    "~type": {
        readonly name: "Presence";
        readonly description: string;
        readonly type: "local";
        readonly url: "chat/v4/presences";
        readonly responses: {
            readonly "200": z.ZodObject<{
                presences: z.ZodArray<z.ZodObject<{
                    actor: z.ZodNullable<z.ZodUnknown>;
                    basic: z.ZodString;
                    details: z.ZodNullable<z.ZodUnknown>;
                    game_name: z.ZodString;
                    game_tag: z.ZodString;
                    location: z.ZodNullable<z.ZodUnknown>;
                    msg: z.ZodNullable<z.ZodUnknown>;
                    name: z.ZodString;
                    patchline: z.ZodNullable<z.ZodUnknown>;
                    pid: z.ZodString;
                    platform: z.ZodNullable<z.ZodUnknown>;
                    private: z.ZodEffects<z.ZodNullable<z.ZodString>, {
                        puuid: string;
                        bannerIdSelected: string;
                        challengeCrystalSelected: string;
                        challengeTitleSelected: string;
                        challengeTokensSelected: number[];
                        championId: string;
                        companionId: string;
                        damageSkinId: string;
                        gameId: string;
                        gameMode: string;
                        gameQueueType: string;
                        gameStatus: string;
                        iconOverride: string;
                        isObservable: string;
                        level: string;
                        mapId: string;
                        mapSkinId: string;
                        masteryScore: string;
                        profileIcon: string;
                        pty: string;
                        queueId: string;
                        rankedLeagueDivision: string;
                        rankedLeagueQueue: string;
                        rankedLeagueTier: string;
                        rankedLosses: string;
                        rankedPrevSeasonDivision: string;
                        rankedPrevSeasonTier: string;
                        rankedSplitRewardLevel: string;
                        rankedWins: string;
                        regalia: string;
                        skinVariant: string;
                        skinname: string;
                        timeStamp: string;
                    } | {
                        queueId: string;
                        isValid: boolean;
                        sessionLoopState: string;
                        partyOwnerSessionLoopState: string;
                        customGameName: string;
                        customGameTeam: string;
                        partyOwnerMatchMap: string;
                        partyOwnerMatchCurrentTeam: string;
                        partyOwnerMatchScoreAllyTeam: number;
                        partyOwnerMatchScoreEnemyTeam: number;
                        partyOwnerProvisioningFlow: string;
                        matchMap: string;
                        partyId: string;
                        isPartyOwner: boolean;
                        partyState: string;
                        partyAccessibility: "OPEN" | "CLOSED";
                        maxPartySize: number;
                        partyLFM: boolean;
                        partyClientVersion: string;
                        partySize: number;
                        tournamentId: string;
                        rosterId: string;
                        partyVersion: Date;
                        queueEntryTime: string;
                        playerCardId: string;
                        playerTitleId: string;
                        preferredLevelBorderId: string;
                        accountLevel: number;
                        competitiveTier: number;
                        leaderboardPosition: number;
                        isIdle: boolean;
                    } | null, string | null>;
                    privateJwt: z.ZodNullable<z.ZodUnknown>;
                    product: z.ZodEnum<["valorant", "league_of_legends"]>;
                    puuid: z.ZodString;
                    region: z.ZodString;
                    resource: z.ZodString;
                    state: z.ZodEnum<["mobile", "dnd", "away", "chat"]>;
                    summary: z.ZodString;
                    time: z.ZodEffects<z.ZodNumber, Date, number>;
                }, "strip", z.ZodTypeAny, {
                    pid: string;
                    name: string;
                    time: Date;
                    region: string;
                    puuid: string;
                    state: "mobile" | "dnd" | "away" | "chat";
                    game_name: string;
                    game_tag: string;
                    resource: string;
                    basic: string;
                    private: {
                        puuid: string;
                        bannerIdSelected: string;
                        challengeCrystalSelected: string;
                        challengeTitleSelected: string;
                        challengeTokensSelected: number[];
                        championId: string;
                        companionId: string;
                        damageSkinId: string;
                        gameId: string;
                        gameMode: string;
                        gameQueueType: string;
                        gameStatus: string;
                        iconOverride: string;
                        isObservable: string;
                        level: string;
                        mapId: string;
                        mapSkinId: string;
                        masteryScore: string;
                        profileIcon: string;
                        pty: string;
                        queueId: string;
                        rankedLeagueDivision: string;
                        rankedLeagueQueue: string;
                        rankedLeagueTier: string;
                        rankedLosses: string;
                        rankedPrevSeasonDivision: string;
                        rankedPrevSeasonTier: string;
                        rankedSplitRewardLevel: string;
                        rankedWins: string;
                        regalia: string;
                        skinVariant: string;
                        skinname: string;
                        timeStamp: string;
                    } | {
                        queueId: string;
                        isValid: boolean;
                        sessionLoopState: string;
                        partyOwnerSessionLoopState: string;
                        customGameName: string;
                        customGameTeam: string;
                        partyOwnerMatchMap: string;
                        partyOwnerMatchCurrentTeam: string;
                        partyOwnerMatchScoreAllyTeam: number;
                        partyOwnerMatchScoreEnemyTeam: number;
                        partyOwnerProvisioningFlow: string;
                        matchMap: string;
                        partyId: string;
                        isPartyOwner: boolean;
                        partyState: string;
                        partyAccessibility: "OPEN" | "CLOSED";
                        maxPartySize: number;
                        partyLFM: boolean;
                        partyClientVersion: string;
                        partySize: number;
                        tournamentId: string;
                        rosterId: string;
                        partyVersion: Date;
                        queueEntryTime: string;
                        playerCardId: string;
                        playerTitleId: string;
                        preferredLevelBorderId: string;
                        accountLevel: number;
                        competitiveTier: number;
                        leaderboardPosition: number;
                        isIdle: boolean;
                    } | null;
                    product: "valorant" | "league_of_legends";
                    summary: string;
                    platform?: unknown;
                    actor?: unknown;
                    details?: unknown;
                    location?: unknown;
                    msg?: unknown;
                    patchline?: unknown;
                    privateJwt?: unknown;
                }, {
                    pid: string;
                    name: string;
                    time: number;
                    region: string;
                    puuid: string;
                    state: "mobile" | "dnd" | "away" | "chat";
                    game_name: string;
                    game_tag: string;
                    resource: string;
                    basic: string;
                    private: string | null;
                    product: "valorant" | "league_of_legends";
                    summary: string;
                    platform?: unknown;
                    actor?: unknown;
                    details?: unknown;
                    location?: unknown;
                    msg?: unknown;
                    patchline?: unknown;
                    privateJwt?: unknown;
                }>, "many">;
            }, "strip", z.ZodTypeAny, {
                presences: {
                    pid: string;
                    name: string;
                    time: Date;
                    region: string;
                    puuid: string;
                    state: "mobile" | "dnd" | "away" | "chat";
                    game_name: string;
                    game_tag: string;
                    resource: string;
                    basic: string;
                    private: {
                        puuid: string;
                        bannerIdSelected: string;
                        challengeCrystalSelected: string;
                        challengeTitleSelected: string;
                        challengeTokensSelected: number[];
                        championId: string;
                        companionId: string;
                        damageSkinId: string;
                        gameId: string;
                        gameMode: string;
                        gameQueueType: string;
                        gameStatus: string;
                        iconOverride: string;
                        isObservable: string;
                        level: string;
                        mapId: string;
                        mapSkinId: string;
                        masteryScore: string;
                        profileIcon: string;
                        pty: string;
                        queueId: string;
                        rankedLeagueDivision: string;
                        rankedLeagueQueue: string;
                        rankedLeagueTier: string;
                        rankedLosses: string;
                        rankedPrevSeasonDivision: string;
                        rankedPrevSeasonTier: string;
                        rankedSplitRewardLevel: string;
                        rankedWins: string;
                        regalia: string;
                        skinVariant: string;
                        skinname: string;
                        timeStamp: string;
                    } | {
                        queueId: string;
                        isValid: boolean;
                        sessionLoopState: string;
                        partyOwnerSessionLoopState: string;
                        customGameName: string;
                        customGameTeam: string;
                        partyOwnerMatchMap: string;
                        partyOwnerMatchCurrentTeam: string;
                        partyOwnerMatchScoreAllyTeam: number;
                        partyOwnerMatchScoreEnemyTeam: number;
                        partyOwnerProvisioningFlow: string;
                        matchMap: string;
                        partyId: string;
                        isPartyOwner: boolean;
                        partyState: string;
                        partyAccessibility: "OPEN" | "CLOSED";
                        maxPartySize: number;
                        partyLFM: boolean;
                        partyClientVersion: string;
                        partySize: number;
                        tournamentId: string;
                        rosterId: string;
                        partyVersion: Date;
                        queueEntryTime: string;
                        playerCardId: string;
                        playerTitleId: string;
                        preferredLevelBorderId: string;
                        accountLevel: number;
                        competitiveTier: number;
                        leaderboardPosition: number;
                        isIdle: boolean;
                    } | null;
                    product: "valorant" | "league_of_legends";
                    summary: string;
                    platform?: unknown;
                    actor?: unknown;
                    details?: unknown;
                    location?: unknown;
                    msg?: unknown;
                    patchline?: unknown;
                    privateJwt?: unknown;
                }[];
            }, {
                presences: {
                    pid: string;
                    name: string;
                    time: number;
                    region: string;
                    puuid: string;
                    state: "mobile" | "dnd" | "away" | "chat";
                    game_name: string;
                    game_tag: string;
                    resource: string;
                    basic: string;
                    private: string | null;
                    product: "valorant" | "league_of_legends";
                    summary: string;
                    platform?: unknown;
                    actor?: unknown;
                    details?: unknown;
                    location?: unknown;
                    msg?: unknown;
                    patchline?: unknown;
                    privateJwt?: unknown;
                }[];
            }>;
        };
    };
};

type Params$Q = ResolveParams<(typeof _default$Q)["~type"]["url"]>;
type Body$Q = z.infer<ResolveValue<(typeof _default$Q)["~type"], "body">>;
type Data$Q = ResolveData<Params$Q, Body$Q>;
type Response$Q = z.infer<ResolveValue<(typeof _default$Q)["~type"], "responses">["200"]>;
interface PresenceRequestConfig extends ValorantAxiosRequestConfig<Data$Q> {
}
declare class PresenceEndpoint {
    /**
     * Get a list of online friends and their activity
     * If the player is playing Valorant, `private` is a base64-encoded JSON string that contains useful information such as party and in-progress game score.
     *
     * @EndpointType local
     */
    getPresence<T = Response$Q>(this: LocalApiClient, config?: PresenceRequestConfig): Promise<AxiosResponse<T>>;
}

declare const _default$P: Omit<{
    requirements: string[];
    type: "auth" | "local" | "pd" | "glz" | "shared";
    name: string;
    method: "PUT" | "GET" | "DELETE" | "POST";
    url: string;
    description?: string | undefined;
    headers?: Record<string, string> | undefined;
    body?: z.ZodType<any, z.ZodTypeDef, any> | undefined;
    query?: z.ZodType<any, z.ZodTypeDef, any> | undefined;
    responses?: Record<string, z.ZodType<any, z.ZodTypeDef, any>> | undefined;
}, "type" | "name" | "url"> & Pick<{
    readonly name: "Remove Friend Request";
    readonly description: "Removes an outgoing friend request";
    readonly type: "local";
    readonly method: "DELETE";
    readonly url: "chat/v4/friendrequests";
    readonly body: z.ZodObject<{
        puuid: z.ZodString;
    }, "strip", z.ZodTypeAny, {
        puuid: string;
    }, {
        puuid: string;
    }>;
    readonly responses: {
        readonly "204": z.ZodUndefined;
    };
}, "type" | "name" | "url"> & {
    "~type": {
        readonly name: "Remove Friend Request";
        readonly description: "Removes an outgoing friend request";
        readonly type: "local";
        readonly method: "DELETE";
        readonly url: "chat/v4/friendrequests";
        readonly body: z.ZodObject<{
            puuid: z.ZodString;
        }, "strip", z.ZodTypeAny, {
            puuid: string;
        }, {
            puuid: string;
        }>;
        readonly responses: {
            readonly "204": z.ZodUndefined;
        };
    };
};

type Params$P = ResolveParams<(typeof _default$P)["~type"]["url"]>;
type Body$P = z.infer<ResolveValue<(typeof _default$P)["~type"], "body">>;
type Data$P = ResolveData<Params$P, Body$P>;
type Response$P = z.infer<ResolveValue<(typeof _default$P)["~type"], "responses">["204"]>;
interface RemoveFriendRequestRequestConfig extends ValorantAxiosRequestConfig<Data$P> {
}
declare class RemoveFriendRequestEndpoint {
    /**
     * Removes an outgoing friend request
     *
     * @EndpointType local
     */
    deleteRemoveFriendRequest<T = Response$P>(this: LocalApiClient, config: RemoveFriendRequestRequestConfig): Promise<AxiosResponse<T>>;
}

declare const _default$O: Omit<{
    requirements: string[];
    type: "auth" | "local" | "pd" | "glz" | "shared";
    name: string;
    method: "PUT" | "GET" | "DELETE" | "POST";
    url: string;
    description?: string | undefined;
    headers?: Record<string, string> | undefined;
    body?: z.ZodType<any, z.ZodTypeDef, any> | undefined;
    query?: z.ZodType<any, z.ZodTypeDef, any> | undefined;
    responses?: Record<string, z.ZodType<any, z.ZodTypeDef, any>> | undefined;
}, "type" | "name" | "url"> & Pick<{
    readonly name: "RSO User Info";
    readonly description: "Get RSO user info";
    readonly type: "local";
    readonly url: "rso-auth/v1/authorization/userinfo";
    readonly responses: {
        readonly "200": z.ZodObject<{
            userInfo: z.ZodEffects<z.ZodString, {
                username: string;
                sub: string;
                country: string;
                email_verified: boolean;
                country_at: Date;
                pw: {
                    cng_at: Date;
                    reset: boolean;
                    must_reset: boolean;
                };
                phone_number_verified: boolean;
                player_locale: string;
                acct: {
                    type: number;
                    state: string;
                    adm: boolean;
                    game_name: string;
                    tag_line: string;
                    created_at: Date;
                };
                jti: string;
                ban: {
                    restrictions: unknown[];
                    code?: unknown;
                    desc?: string | undefined;
                    exp?: unknown;
                };
                lol_region: unknown[];
                preferred_username: string;
                player_plocale?: unknown;
                ppid?: unknown;
                lol?: unknown;
                original_account_id?: unknown;
                original_platform_id?: unknown;
                pvpnet_account_id?: unknown;
            }, string>;
        }, "strip", z.ZodTypeAny, {
            userInfo: {
                username: string;
                sub: string;
                country: string;
                email_verified: boolean;
                country_at: Date;
                pw: {
                    cng_at: Date;
                    reset: boolean;
                    must_reset: boolean;
                };
                phone_number_verified: boolean;
                player_locale: string;
                acct: {
                    type: number;
                    state: string;
                    adm: boolean;
                    game_name: string;
                    tag_line: string;
                    created_at: Date;
                };
                jti: string;
                ban: {
                    restrictions: unknown[];
                    code?: unknown;
                    desc?: string | undefined;
                    exp?: unknown;
                };
                lol_region: unknown[];
                preferred_username: string;
                player_plocale?: unknown;
                ppid?: unknown;
                lol?: unknown;
                original_account_id?: unknown;
                original_platform_id?: unknown;
                pvpnet_account_id?: unknown;
            };
        }, {
            userInfo: string;
        }>;
    };
}, "type" | "name" | "url"> & {
    "~type": {
        readonly name: "RSO User Info";
        readonly description: "Get RSO user info";
        readonly type: "local";
        readonly url: "rso-auth/v1/authorization/userinfo";
        readonly responses: {
            readonly "200": z.ZodObject<{
                userInfo: z.ZodEffects<z.ZodString, {
                    username: string;
                    sub: string;
                    country: string;
                    email_verified: boolean;
                    country_at: Date;
                    pw: {
                        cng_at: Date;
                        reset: boolean;
                        must_reset: boolean;
                    };
                    phone_number_verified: boolean;
                    player_locale: string;
                    acct: {
                        type: number;
                        state: string;
                        adm: boolean;
                        game_name: string;
                        tag_line: string;
                        created_at: Date;
                    };
                    jti: string;
                    ban: {
                        restrictions: unknown[];
                        code?: unknown;
                        desc?: string | undefined;
                        exp?: unknown;
                    };
                    lol_region: unknown[];
                    preferred_username: string;
                    player_plocale?: unknown;
                    ppid?: unknown;
                    lol?: unknown;
                    original_account_id?: unknown;
                    original_platform_id?: unknown;
                    pvpnet_account_id?: unknown;
                }, string>;
            }, "strip", z.ZodTypeAny, {
                userInfo: {
                    username: string;
                    sub: string;
                    country: string;
                    email_verified: boolean;
                    country_at: Date;
                    pw: {
                        cng_at: Date;
                        reset: boolean;
                        must_reset: boolean;
                    };
                    phone_number_verified: boolean;
                    player_locale: string;
                    acct: {
                        type: number;
                        state: string;
                        adm: boolean;
                        game_name: string;
                        tag_line: string;
                        created_at: Date;
                    };
                    jti: string;
                    ban: {
                        restrictions: unknown[];
                        code?: unknown;
                        desc?: string | undefined;
                        exp?: unknown;
                    };
                    lol_region: unknown[];
                    preferred_username: string;
                    player_plocale?: unknown;
                    ppid?: unknown;
                    lol?: unknown;
                    original_account_id?: unknown;
                    original_platform_id?: unknown;
                    pvpnet_account_id?: unknown;
                };
            }, {
                userInfo: string;
            }>;
        };
    };
};

type Params$O = ResolveParams<(typeof _default$O)["~type"]["url"]>;
type Body$O = z.infer<ResolveValue<(typeof _default$O)["~type"], "body">>;
type Data$O = ResolveData<Params$O, Body$O>;
type Response$O = z.infer<ResolveValue<(typeof _default$O)["~type"], "responses">["200"]>;
interface RsoUserInfoRequestConfig extends ValorantAxiosRequestConfig<Data$O> {
}
declare class RsoUserInfoEndpoint {
    /**
     * Get RSO user info
     *
     * @EndpointType local
     */
    getRsoUserInfo<T = Response$O>(this: LocalApiClient, config?: RsoUserInfoRequestConfig): Promise<AxiosResponse<T>>;
}

declare const _default$N: Omit<{
    requirements: string[];
    type: "auth" | "local" | "pd" | "glz" | "shared";
    name: string;
    method: "PUT" | "GET" | "DELETE" | "POST";
    url: string;
    description?: string | undefined;
    headers?: Record<string, string> | undefined;
    body?: z.ZodType<any, z.ZodTypeDef, any> | undefined;
    query?: z.ZodType<any, z.ZodTypeDef, any> | undefined;
    responses?: Record<string, z.ZodType<any, z.ZodTypeDef, any>> | undefined;
}, "type" | "name" | "url"> & Pick<{
    readonly name: "Send Chat Message";
    readonly description: "Send a message to the specified group";
    readonly type: "local";
    readonly url: "chat/v6/messages";
    readonly method: "POST";
    readonly body: z.ZodObject<{
        cid: z.ZodString;
        message: z.ZodString;
        type: z.ZodEnum<["groupchat", "chat", "system"]>;
    }, "strip", z.ZodTypeAny, {
        message: string;
        type: "chat" | "groupchat" | "system";
        cid: string;
    }, {
        message: string;
        type: "chat" | "groupchat" | "system";
        cid: string;
    }>;
    readonly riotRequirements: {
        readonly localAuth: true;
    };
    readonly responses: {
        readonly "200": z.ZodObject<{
            messages: z.ZodArray<z.ZodObject<{
                body: z.ZodString;
                cid: z.ZodString;
                game_name: z.ZodString;
                game_tag: z.ZodString;
                id: z.ZodString;
                mid: z.ZodString;
                name: z.ZodString;
                pid: z.ZodString;
                puuid: z.ZodString;
                read: z.ZodBoolean;
                region: z.ZodString;
                time: z.ZodEffects<z.ZodString, Date, string>;
                type: z.ZodEnum<["chat", "groupchat"]>;
            }, "strip", z.ZodTypeAny, {
                pid: string;
                type: "chat" | "groupchat";
                name: string;
                body: string;
                time: Date;
                region: string;
                puuid: string;
                game_name: string;
                game_tag: string;
                cid: string;
                mid: string;
                id: string;
                read: boolean;
            }, {
                pid: string;
                type: "chat" | "groupchat";
                name: string;
                body: string;
                time: string;
                region: string;
                puuid: string;
                game_name: string;
                game_tag: string;
                cid: string;
                mid: string;
                id: string;
                read: boolean;
            }>, "many">;
        }, "strip", z.ZodTypeAny, {
            messages: {
                pid: string;
                type: "chat" | "groupchat";
                name: string;
                body: string;
                time: Date;
                region: string;
                puuid: string;
                game_name: string;
                game_tag: string;
                cid: string;
                mid: string;
                id: string;
                read: boolean;
            }[];
        }, {
            messages: {
                pid: string;
                type: "chat" | "groupchat";
                name: string;
                body: string;
                time: string;
                region: string;
                puuid: string;
                game_name: string;
                game_tag: string;
                cid: string;
                mid: string;
                id: string;
                read: boolean;
            }[];
        }>;
    };
}, "type" | "name" | "url"> & {
    "~type": {
        readonly name: "Send Chat Message";
        readonly description: "Send a message to the specified group";
        readonly type: "local";
        readonly url: "chat/v6/messages";
        readonly method: "POST";
        readonly body: z.ZodObject<{
            cid: z.ZodString;
            message: z.ZodString;
            type: z.ZodEnum<["groupchat", "chat", "system"]>;
        }, "strip", z.ZodTypeAny, {
            message: string;
            type: "chat" | "groupchat" | "system";
            cid: string;
        }, {
            message: string;
            type: "chat" | "groupchat" | "system";
            cid: string;
        }>;
        readonly riotRequirements: {
            readonly localAuth: true;
        };
        readonly responses: {
            readonly "200": z.ZodObject<{
                messages: z.ZodArray<z.ZodObject<{
                    body: z.ZodString;
                    cid: z.ZodString;
                    game_name: z.ZodString;
                    game_tag: z.ZodString;
                    id: z.ZodString;
                    mid: z.ZodString;
                    name: z.ZodString;
                    pid: z.ZodString;
                    puuid: z.ZodString;
                    read: z.ZodBoolean;
                    region: z.ZodString;
                    time: z.ZodEffects<z.ZodString, Date, string>;
                    type: z.ZodEnum<["chat", "groupchat"]>;
                }, "strip", z.ZodTypeAny, {
                    pid: string;
                    type: "chat" | "groupchat";
                    name: string;
                    body: string;
                    time: Date;
                    region: string;
                    puuid: string;
                    game_name: string;
                    game_tag: string;
                    cid: string;
                    mid: string;
                    id: string;
                    read: boolean;
                }, {
                    pid: string;
                    type: "chat" | "groupchat";
                    name: string;
                    body: string;
                    time: string;
                    region: string;
                    puuid: string;
                    game_name: string;
                    game_tag: string;
                    cid: string;
                    mid: string;
                    id: string;
                    read: boolean;
                }>, "many">;
            }, "strip", z.ZodTypeAny, {
                messages: {
                    pid: string;
                    type: "chat" | "groupchat";
                    name: string;
                    body: string;
                    time: Date;
                    region: string;
                    puuid: string;
                    game_name: string;
                    game_tag: string;
                    cid: string;
                    mid: string;
                    id: string;
                    read: boolean;
                }[];
            }, {
                messages: {
                    pid: string;
                    type: "chat" | "groupchat";
                    name: string;
                    body: string;
                    time: string;
                    region: string;
                    puuid: string;
                    game_name: string;
                    game_tag: string;
                    cid: string;
                    mid: string;
                    id: string;
                    read: boolean;
                }[];
            }>;
        };
    };
};

type Params$N = ResolveParams<(typeof _default$N)["~type"]["url"]>;
type Body$N = z.infer<ResolveValue<(typeof _default$N)["~type"], "body">>;
type Data$N = ResolveData<Params$N, Body$N>;
type Response$N = z.infer<ResolveValue<(typeof _default$N)["~type"], "responses">["200"]>;
interface SendChatMessageRequestConfig extends ValorantAxiosRequestConfig<Data$N> {
}
declare class SendChatMessageEndpoint {
    /**
     * Send a message to the specified group
     *
     * @EndpointType local
     */
    postSendChatMessage<T = Response$N>(this: LocalApiClient, config: SendChatMessageRequestConfig): Promise<AxiosResponse<T>>;
}

declare const _default$M: Omit<{
    requirements: string[];
    type: "auth" | "local" | "pd" | "glz" | "shared";
    name: string;
    method: "PUT" | "GET" | "DELETE" | "POST";
    url: string;
    description?: string | undefined;
    headers?: Record<string, string> | undefined;
    body?: z.ZodType<any, z.ZodTypeDef, any> | undefined;
    query?: z.ZodType<any, z.ZodTypeDef, any> | undefined;
    responses?: Record<string, z.ZodType<any, z.ZodTypeDef, any>> | undefined;
}, "type" | "name" | "url"> & Pick<{
    readonly name: "Send Friend Request";
    readonly description: "Sends a friend request to a player. Can be used in conjunction with [GET Friend Requests] and [DELETE Remove Friend Request] to determine a player's PUUID from their game name.";
    readonly type: "local";
    readonly method: "POST";
    readonly url: "chat/v4/friendrequests";
    readonly body: z.ZodObject<{
        game_name: z.ZodString;
        game_tag: z.ZodString;
    }, "strip", z.ZodTypeAny, {
        game_name: string;
        game_tag: string;
    }, {
        game_name: string;
        game_tag: string;
    }>;
    readonly responses: {
        readonly "200": z.ZodObject<{
            requests: z.ZodArray<z.ZodAny, "many">;
        }, "strip", z.ZodTypeAny, {
            requests: any[];
        }, {
            requests: any[];
        }>;
    };
}, "type" | "name" | "url"> & {
    "~type": {
        readonly name: "Send Friend Request";
        readonly description: "Sends a friend request to a player. Can be used in conjunction with [GET Friend Requests] and [DELETE Remove Friend Request] to determine a player's PUUID from their game name.";
        readonly type: "local";
        readonly method: "POST";
        readonly url: "chat/v4/friendrequests";
        readonly body: z.ZodObject<{
            game_name: z.ZodString;
            game_tag: z.ZodString;
        }, "strip", z.ZodTypeAny, {
            game_name: string;
            game_tag: string;
        }, {
            game_name: string;
            game_tag: string;
        }>;
        readonly responses: {
            readonly "200": z.ZodObject<{
                requests: z.ZodArray<z.ZodAny, "many">;
            }, "strip", z.ZodTypeAny, {
                requests: any[];
            }, {
                requests: any[];
            }>;
        };
    };
};

type Params$M = ResolveParams<(typeof _default$M)["~type"]["url"]>;
type Body$M = z.infer<ResolveValue<(typeof _default$M)["~type"], "body">>;
type Data$M = ResolveData<Params$M, Body$M>;
type Response$M = z.infer<ResolveValue<(typeof _default$M)["~type"], "responses">["200"]>;
interface SendFriendRequestRequestConfig extends ValorantAxiosRequestConfig<Data$M> {
}
declare class SendFriendRequestEndpoint {
    /**
     * Sends a friend request to a player. Can be used in conjunction with [GET Friend Requests] and [DELETE Remove Friend Request] to determine a player's PUUID from their game name.
     *
     * @EndpointType local
     */
    postSendFriendRequest<T = Response$M>(this: LocalApiClient, config: SendFriendRequestRequestConfig): Promise<AxiosResponse<T>>;
}

declare const SessionsResponseSchema: z.ZodRecord<z.ZodString, z.ZodObject<{
    exitCode: z.ZodNumber;
    exitReason: z.ZodNull;
    isInternal: z.ZodBoolean;
    launchConfiguration: z.ZodObject<{
        arguments: z.ZodArray<z.ZodString, "many">;
        executable: z.ZodString;
        locale: z.ZodNullable<z.ZodString>;
        voiceLocale: z.ZodNull;
        workingDirectory: z.ZodString;
    }, "strip", z.ZodTypeAny, {
        locale: string | null;
        arguments: string[];
        executable: string;
        voiceLocale: null;
        workingDirectory: string;
    }, {
        locale: string | null;
        arguments: string[];
        executable: string;
        voiceLocale: null;
        workingDirectory: string;
    }>;
    patchlineFullName: z.ZodEnum<["VALORANT", "riot_client"]>;
    patchlineId: z.ZodEnum<["", "live", "pbe"]>;
    phase: z.ZodString;
    productId: z.ZodEnum<["valorant", "riot_client"]>;
    version: z.ZodString;
}, "strip", z.ZodTypeAny, {
    exitCode: number;
    exitReason: null;
    isInternal: boolean;
    launchConfiguration: {
        locale: string | null;
        arguments: string[];
        executable: string;
        voiceLocale: null;
        workingDirectory: string;
    };
    patchlineFullName: "VALORANT" | "riot_client";
    patchlineId: "" | "pbe" | "live";
    phase: string;
    productId: "riot_client" | "valorant";
    version: string;
}, {
    exitCode: number;
    exitReason: null;
    isInternal: boolean;
    launchConfiguration: {
        locale: string | null;
        arguments: string[];
        executable: string;
        voiceLocale: null;
        workingDirectory: string;
    };
    patchlineFullName: "VALORANT" | "riot_client";
    patchlineId: "" | "pbe" | "live";
    phase: string;
    productId: "riot_client" | "valorant";
    version: string;
}>>;
declare const _default$L: Omit<{
    requirements: string[];
    type: "auth" | "local" | "pd" | "glz" | "shared";
    name: string;
    method: "PUT" | "GET" | "DELETE" | "POST";
    url: string;
    description?: string | undefined;
    headers?: Record<string, string> | undefined;
    body?: z.ZodType<any, z.ZodTypeDef, any> | undefined;
    query?: z.ZodType<any, z.ZodTypeDef, any> | undefined;
    responses?: Record<string, z.ZodType<any, z.ZodTypeDef, any>> | undefined;
}, "type" | "name" | "url"> & Pick<{
    readonly name: "Sessions";
    readonly description: string;
    readonly type: "local";
    readonly url: "product-session/v1/external-sessions";
    readonly responses: {
        readonly "200": z.ZodRecord<z.ZodString, z.ZodObject<{
            exitCode: z.ZodNumber;
            exitReason: z.ZodNull;
            isInternal: z.ZodBoolean;
            launchConfiguration: z.ZodObject<{
                arguments: z.ZodArray<z.ZodString, "many">;
                executable: z.ZodString;
                locale: z.ZodNullable<z.ZodString>;
                voiceLocale: z.ZodNull;
                workingDirectory: z.ZodString;
            }, "strip", z.ZodTypeAny, {
                locale: string | null;
                arguments: string[];
                executable: string;
                voiceLocale: null;
                workingDirectory: string;
            }, {
                locale: string | null;
                arguments: string[];
                executable: string;
                voiceLocale: null;
                workingDirectory: string;
            }>;
            patchlineFullName: z.ZodEnum<["VALORANT", "riot_client"]>;
            patchlineId: z.ZodEnum<["", "live", "pbe"]>;
            phase: z.ZodString;
            productId: z.ZodEnum<["valorant", "riot_client"]>;
            version: z.ZodString;
        }, "strip", z.ZodTypeAny, {
            exitCode: number;
            exitReason: null;
            isInternal: boolean;
            launchConfiguration: {
                locale: string | null;
                arguments: string[];
                executable: string;
                voiceLocale: null;
                workingDirectory: string;
            };
            patchlineFullName: "VALORANT" | "riot_client";
            patchlineId: "" | "pbe" | "live";
            phase: string;
            productId: "riot_client" | "valorant";
            version: string;
        }, {
            exitCode: number;
            exitReason: null;
            isInternal: boolean;
            launchConfiguration: {
                locale: string | null;
                arguments: string[];
                executable: string;
                voiceLocale: null;
                workingDirectory: string;
            };
            patchlineFullName: "VALORANT" | "riot_client";
            patchlineId: "" | "pbe" | "live";
            phase: string;
            productId: "riot_client" | "valorant";
            version: string;
        }>>;
    };
}, "type" | "name" | "url"> & {
    "~type": {
        readonly name: "Sessions";
        readonly description: string;
        readonly type: "local";
        readonly url: "product-session/v1/external-sessions";
        readonly responses: {
            readonly "200": z.ZodRecord<z.ZodString, z.ZodObject<{
                exitCode: z.ZodNumber;
                exitReason: z.ZodNull;
                isInternal: z.ZodBoolean;
                launchConfiguration: z.ZodObject<{
                    arguments: z.ZodArray<z.ZodString, "many">;
                    executable: z.ZodString;
                    locale: z.ZodNullable<z.ZodString>;
                    voiceLocale: z.ZodNull;
                    workingDirectory: z.ZodString;
                }, "strip", z.ZodTypeAny, {
                    locale: string | null;
                    arguments: string[];
                    executable: string;
                    voiceLocale: null;
                    workingDirectory: string;
                }, {
                    locale: string | null;
                    arguments: string[];
                    executable: string;
                    voiceLocale: null;
                    workingDirectory: string;
                }>;
                patchlineFullName: z.ZodEnum<["VALORANT", "riot_client"]>;
                patchlineId: z.ZodEnum<["", "live", "pbe"]>;
                phase: z.ZodString;
                productId: z.ZodEnum<["valorant", "riot_client"]>;
                version: z.ZodString;
            }, "strip", z.ZodTypeAny, {
                exitCode: number;
                exitReason: null;
                isInternal: boolean;
                launchConfiguration: {
                    locale: string | null;
                    arguments: string[];
                    executable: string;
                    voiceLocale: null;
                    workingDirectory: string;
                };
                patchlineFullName: "VALORANT" | "riot_client";
                patchlineId: "" | "pbe" | "live";
                phase: string;
                productId: "riot_client" | "valorant";
                version: string;
            }, {
                exitCode: number;
                exitReason: null;
                isInternal: boolean;
                launchConfiguration: {
                    locale: string | null;
                    arguments: string[];
                    executable: string;
                    voiceLocale: null;
                    workingDirectory: string;
                };
                patchlineFullName: "VALORANT" | "riot_client";
                patchlineId: "" | "pbe" | "live";
                phase: string;
                productId: "riot_client" | "valorant";
                version: string;
            }>>;
        };
    };
};

type Params$L = ResolveParams<(typeof _default$L)["~type"]["url"]>;
type Body$L = z.infer<ResolveValue<(typeof _default$L)["~type"], "body">>;
type Data$L = ResolveData<Params$L, Body$L>;
type Response$L = z.infer<ResolveValue<(typeof _default$L)["~type"], "responses">["200"]>;
interface SessionsRequestConfig extends ValorantAxiosRequestConfig<Data$L> {
}
declare class SessionsEndpoint {
    /**
     * Gets info about the running Valorant process including start arguments
     * Can be used to get shard, region, and puuid by parsing launch args.
     *
     * @EndpointType local
     */
    getSessions<T = Response$L>(this: LocalApiClient, config?: SessionsRequestConfig): Promise<AxiosResponse<T>>;
}

declare const SettingsResponseSchema: z.ZodObject<{
    data: z.ZodObject<{
        actionMappings: z.ZodArray<z.ZodObject<{
            alt: z.ZodBoolean;
            bindIndex: z.ZodNumber;
            characterName: z.ZodString;
            cmd: z.ZodBoolean;
            ctrl: z.ZodBoolean;
            key: z.ZodString;
            name: z.ZodString;
            shift: z.ZodBoolean;
        }, "strip", z.ZodTypeAny, {
            shift: boolean;
            name: string;
            alt: boolean;
            bindIndex: number;
            characterName: string;
            cmd: boolean;
            ctrl: boolean;
            key: string;
        }, {
            shift: boolean;
            name: string;
            alt: boolean;
            bindIndex: number;
            characterName: string;
            cmd: boolean;
            ctrl: boolean;
            key: string;
        }>, "many">;
        axisMappings: z.ZodArray<z.ZodUnknown, "many">;
        boolSettings: z.ZodArray<z.ZodObject<{
            settingEnum: z.ZodString;
            value: z.ZodBoolean;
        }, "strip", z.ZodTypeAny, {
            value: boolean;
            settingEnum: string;
        }, {
            value: boolean;
            settingEnum: string;
        }>, "many">;
        floatSettings: z.ZodArray<z.ZodObject<{
            settingEnum: z.ZodString;
            value: z.ZodNumber;
        }, "strip", z.ZodTypeAny, {
            value: number;
            settingEnum: string;
        }, {
            value: number;
            settingEnum: string;
        }>, "many">;
        intSettings: z.ZodArray<z.ZodObject<{
            settingEnum: z.ZodString;
            value: z.ZodNumber;
        }, "strip", z.ZodTypeAny, {
            value: number;
            settingEnum: string;
        }, {
            value: number;
            settingEnum: string;
        }>, "many">;
        roamingSetttingsVersion: z.ZodNumber;
        settingsProfiles: z.ZodArray<z.ZodUnknown, "many">;
        stringSettings: z.ZodArray<z.ZodObject<{
            settingEnum: z.ZodString;
            value: z.ZodString;
        }, "strip", z.ZodTypeAny, {
            value: string;
            settingEnum: string;
        }, {
            value: string;
            settingEnum: string;
        }>, "many">;
    }, "strip", z.ZodTypeAny, {
        actionMappings: {
            shift: boolean;
            name: string;
            alt: boolean;
            bindIndex: number;
            characterName: string;
            cmd: boolean;
            ctrl: boolean;
            key: string;
        }[];
        axisMappings: unknown[];
        boolSettings: {
            value: boolean;
            settingEnum: string;
        }[];
        floatSettings: {
            value: number;
            settingEnum: string;
        }[];
        intSettings: {
            value: number;
            settingEnum: string;
        }[];
        roamingSetttingsVersion: number;
        settingsProfiles: unknown[];
        stringSettings: {
            value: string;
            settingEnum: string;
        }[];
    }, {
        actionMappings: {
            shift: boolean;
            name: string;
            alt: boolean;
            bindIndex: number;
            characterName: string;
            cmd: boolean;
            ctrl: boolean;
            key: string;
        }[];
        axisMappings: unknown[];
        boolSettings: {
            value: boolean;
            settingEnum: string;
        }[];
        floatSettings: {
            value: number;
            settingEnum: string;
        }[];
        intSettings: {
            value: number;
            settingEnum: string;
        }[];
        roamingSetttingsVersion: number;
        settingsProfiles: unknown[];
        stringSettings: {
            value: string;
            settingEnum: string;
        }[];
    }>;
    modified: z.ZodNumber;
    type: z.ZodLiteral<"Ares.PlayerSettings">;
}, "strip", z.ZodTypeAny, {
    type: "Ares.PlayerSettings";
    data: {
        actionMappings: {
            shift: boolean;
            name: string;
            alt: boolean;
            bindIndex: number;
            characterName: string;
            cmd: boolean;
            ctrl: boolean;
            key: string;
        }[];
        axisMappings: unknown[];
        boolSettings: {
            value: boolean;
            settingEnum: string;
        }[];
        floatSettings: {
            value: number;
            settingEnum: string;
        }[];
        intSettings: {
            value: number;
            settingEnum: string;
        }[];
        roamingSetttingsVersion: number;
        settingsProfiles: unknown[];
        stringSettings: {
            value: string;
            settingEnum: string;
        }[];
    };
    modified: number;
}, {
    type: "Ares.PlayerSettings";
    data: {
        actionMappings: {
            shift: boolean;
            name: string;
            alt: boolean;
            bindIndex: number;
            characterName: string;
            cmd: boolean;
            ctrl: boolean;
            key: string;
        }[];
        axisMappings: unknown[];
        boolSettings: {
            value: boolean;
            settingEnum: string;
        }[];
        floatSettings: {
            value: number;
            settingEnum: string;
        }[];
        intSettings: {
            value: number;
            settingEnum: string;
        }[];
        roamingSetttingsVersion: number;
        settingsProfiles: unknown[];
        stringSettings: {
            value: string;
            settingEnum: string;
        }[];
    };
    modified: number;
}>;
declare const _default$K: Omit<{
    requirements: string[];
    type: "auth" | "local" | "pd" | "glz" | "shared";
    name: string;
    method: "PUT" | "GET" | "DELETE" | "POST";
    url: string;
    description?: string | undefined;
    headers?: Record<string, string> | undefined;
    body?: z.ZodType<any, z.ZodTypeDef, any> | undefined;
    query?: z.ZodType<any, z.ZodTypeDef, any> | undefined;
    responses?: Record<string, z.ZodType<any, z.ZodTypeDef, any>> | undefined;
}, "type" | "name" | "url"> & Pick<{
    readonly name: "Settings";
    readonly description: "Get a list of client settings";
    readonly type: "local";
    readonly url: "player-preferences/v1/data-json/Ares.PlayerSettings";
    readonly responses: {
        readonly "200": z.ZodObject<{
            data: z.ZodObject<{
                actionMappings: z.ZodArray<z.ZodObject<{
                    alt: z.ZodBoolean;
                    bindIndex: z.ZodNumber;
                    characterName: z.ZodString;
                    cmd: z.ZodBoolean;
                    ctrl: z.ZodBoolean;
                    key: z.ZodString;
                    name: z.ZodString;
                    shift: z.ZodBoolean;
                }, "strip", z.ZodTypeAny, {
                    shift: boolean;
                    name: string;
                    alt: boolean;
                    bindIndex: number;
                    characterName: string;
                    cmd: boolean;
                    ctrl: boolean;
                    key: string;
                }, {
                    shift: boolean;
                    name: string;
                    alt: boolean;
                    bindIndex: number;
                    characterName: string;
                    cmd: boolean;
                    ctrl: boolean;
                    key: string;
                }>, "many">;
                axisMappings: z.ZodArray<z.ZodUnknown, "many">;
                boolSettings: z.ZodArray<z.ZodObject<{
                    settingEnum: z.ZodString;
                    value: z.ZodBoolean;
                }, "strip", z.ZodTypeAny, {
                    value: boolean;
                    settingEnum: string;
                }, {
                    value: boolean;
                    settingEnum: string;
                }>, "many">;
                floatSettings: z.ZodArray<z.ZodObject<{
                    settingEnum: z.ZodString;
                    value: z.ZodNumber;
                }, "strip", z.ZodTypeAny, {
                    value: number;
                    settingEnum: string;
                }, {
                    value: number;
                    settingEnum: string;
                }>, "many">;
                intSettings: z.ZodArray<z.ZodObject<{
                    settingEnum: z.ZodString;
                    value: z.ZodNumber;
                }, "strip", z.ZodTypeAny, {
                    value: number;
                    settingEnum: string;
                }, {
                    value: number;
                    settingEnum: string;
                }>, "many">;
                roamingSetttingsVersion: z.ZodNumber;
                settingsProfiles: z.ZodArray<z.ZodUnknown, "many">;
                stringSettings: z.ZodArray<z.ZodObject<{
                    settingEnum: z.ZodString;
                    value: z.ZodString;
                }, "strip", z.ZodTypeAny, {
                    value: string;
                    settingEnum: string;
                }, {
                    value: string;
                    settingEnum: string;
                }>, "many">;
            }, "strip", z.ZodTypeAny, {
                actionMappings: {
                    shift: boolean;
                    name: string;
                    alt: boolean;
                    bindIndex: number;
                    characterName: string;
                    cmd: boolean;
                    ctrl: boolean;
                    key: string;
                }[];
                axisMappings: unknown[];
                boolSettings: {
                    value: boolean;
                    settingEnum: string;
                }[];
                floatSettings: {
                    value: number;
                    settingEnum: string;
                }[];
                intSettings: {
                    value: number;
                    settingEnum: string;
                }[];
                roamingSetttingsVersion: number;
                settingsProfiles: unknown[];
                stringSettings: {
                    value: string;
                    settingEnum: string;
                }[];
            }, {
                actionMappings: {
                    shift: boolean;
                    name: string;
                    alt: boolean;
                    bindIndex: number;
                    characterName: string;
                    cmd: boolean;
                    ctrl: boolean;
                    key: string;
                }[];
                axisMappings: unknown[];
                boolSettings: {
                    value: boolean;
                    settingEnum: string;
                }[];
                floatSettings: {
                    value: number;
                    settingEnum: string;
                }[];
                intSettings: {
                    value: number;
                    settingEnum: string;
                }[];
                roamingSetttingsVersion: number;
                settingsProfiles: unknown[];
                stringSettings: {
                    value: string;
                    settingEnum: string;
                }[];
            }>;
            modified: z.ZodNumber;
            type: z.ZodLiteral<"Ares.PlayerSettings">;
        }, "strip", z.ZodTypeAny, {
            type: "Ares.PlayerSettings";
            data: {
                actionMappings: {
                    shift: boolean;
                    name: string;
                    alt: boolean;
                    bindIndex: number;
                    characterName: string;
                    cmd: boolean;
                    ctrl: boolean;
                    key: string;
                }[];
                axisMappings: unknown[];
                boolSettings: {
                    value: boolean;
                    settingEnum: string;
                }[];
                floatSettings: {
                    value: number;
                    settingEnum: string;
                }[];
                intSettings: {
                    value: number;
                    settingEnum: string;
                }[];
                roamingSetttingsVersion: number;
                settingsProfiles: unknown[];
                stringSettings: {
                    value: string;
                    settingEnum: string;
                }[];
            };
            modified: number;
        }, {
            type: "Ares.PlayerSettings";
            data: {
                actionMappings: {
                    shift: boolean;
                    name: string;
                    alt: boolean;
                    bindIndex: number;
                    characterName: string;
                    cmd: boolean;
                    ctrl: boolean;
                    key: string;
                }[];
                axisMappings: unknown[];
                boolSettings: {
                    value: boolean;
                    settingEnum: string;
                }[];
                floatSettings: {
                    value: number;
                    settingEnum: string;
                }[];
                intSettings: {
                    value: number;
                    settingEnum: string;
                }[];
                roamingSetttingsVersion: number;
                settingsProfiles: unknown[];
                stringSettings: {
                    value: string;
                    settingEnum: string;
                }[];
            };
            modified: number;
        }>;
    };
}, "type" | "name" | "url"> & {
    "~type": {
        readonly name: "Settings";
        readonly description: "Get a list of client settings";
        readonly type: "local";
        readonly url: "player-preferences/v1/data-json/Ares.PlayerSettings";
        readonly responses: {
            readonly "200": z.ZodObject<{
                data: z.ZodObject<{
                    actionMappings: z.ZodArray<z.ZodObject<{
                        alt: z.ZodBoolean;
                        bindIndex: z.ZodNumber;
                        characterName: z.ZodString;
                        cmd: z.ZodBoolean;
                        ctrl: z.ZodBoolean;
                        key: z.ZodString;
                        name: z.ZodString;
                        shift: z.ZodBoolean;
                    }, "strip", z.ZodTypeAny, {
                        shift: boolean;
                        name: string;
                        alt: boolean;
                        bindIndex: number;
                        characterName: string;
                        cmd: boolean;
                        ctrl: boolean;
                        key: string;
                    }, {
                        shift: boolean;
                        name: string;
                        alt: boolean;
                        bindIndex: number;
                        characterName: string;
                        cmd: boolean;
                        ctrl: boolean;
                        key: string;
                    }>, "many">;
                    axisMappings: z.ZodArray<z.ZodUnknown, "many">;
                    boolSettings: z.ZodArray<z.ZodObject<{
                        settingEnum: z.ZodString;
                        value: z.ZodBoolean;
                    }, "strip", z.ZodTypeAny, {
                        value: boolean;
                        settingEnum: string;
                    }, {
                        value: boolean;
                        settingEnum: string;
                    }>, "many">;
                    floatSettings: z.ZodArray<z.ZodObject<{
                        settingEnum: z.ZodString;
                        value: z.ZodNumber;
                    }, "strip", z.ZodTypeAny, {
                        value: number;
                        settingEnum: string;
                    }, {
                        value: number;
                        settingEnum: string;
                    }>, "many">;
                    intSettings: z.ZodArray<z.ZodObject<{
                        settingEnum: z.ZodString;
                        value: z.ZodNumber;
                    }, "strip", z.ZodTypeAny, {
                        value: number;
                        settingEnum: string;
                    }, {
                        value: number;
                        settingEnum: string;
                    }>, "many">;
                    roamingSetttingsVersion: z.ZodNumber;
                    settingsProfiles: z.ZodArray<z.ZodUnknown, "many">;
                    stringSettings: z.ZodArray<z.ZodObject<{
                        settingEnum: z.ZodString;
                        value: z.ZodString;
                    }, "strip", z.ZodTypeAny, {
                        value: string;
                        settingEnum: string;
                    }, {
                        value: string;
                        settingEnum: string;
                    }>, "many">;
                }, "strip", z.ZodTypeAny, {
                    actionMappings: {
                        shift: boolean;
                        name: string;
                        alt: boolean;
                        bindIndex: number;
                        characterName: string;
                        cmd: boolean;
                        ctrl: boolean;
                        key: string;
                    }[];
                    axisMappings: unknown[];
                    boolSettings: {
                        value: boolean;
                        settingEnum: string;
                    }[];
                    floatSettings: {
                        value: number;
                        settingEnum: string;
                    }[];
                    intSettings: {
                        value: number;
                        settingEnum: string;
                    }[];
                    roamingSetttingsVersion: number;
                    settingsProfiles: unknown[];
                    stringSettings: {
                        value: string;
                        settingEnum: string;
                    }[];
                }, {
                    actionMappings: {
                        shift: boolean;
                        name: string;
                        alt: boolean;
                        bindIndex: number;
                        characterName: string;
                        cmd: boolean;
                        ctrl: boolean;
                        key: string;
                    }[];
                    axisMappings: unknown[];
                    boolSettings: {
                        value: boolean;
                        settingEnum: string;
                    }[];
                    floatSettings: {
                        value: number;
                        settingEnum: string;
                    }[];
                    intSettings: {
                        value: number;
                        settingEnum: string;
                    }[];
                    roamingSetttingsVersion: number;
                    settingsProfiles: unknown[];
                    stringSettings: {
                        value: string;
                        settingEnum: string;
                    }[];
                }>;
                modified: z.ZodNumber;
                type: z.ZodLiteral<"Ares.PlayerSettings">;
            }, "strip", z.ZodTypeAny, {
                type: "Ares.PlayerSettings";
                data: {
                    actionMappings: {
                        shift: boolean;
                        name: string;
                        alt: boolean;
                        bindIndex: number;
                        characterName: string;
                        cmd: boolean;
                        ctrl: boolean;
                        key: string;
                    }[];
                    axisMappings: unknown[];
                    boolSettings: {
                        value: boolean;
                        settingEnum: string;
                    }[];
                    floatSettings: {
                        value: number;
                        settingEnum: string;
                    }[];
                    intSettings: {
                        value: number;
                        settingEnum: string;
                    }[];
                    roamingSetttingsVersion: number;
                    settingsProfiles: unknown[];
                    stringSettings: {
                        value: string;
                        settingEnum: string;
                    }[];
                };
                modified: number;
            }, {
                type: "Ares.PlayerSettings";
                data: {
                    actionMappings: {
                        shift: boolean;
                        name: string;
                        alt: boolean;
                        bindIndex: number;
                        characterName: string;
                        cmd: boolean;
                        ctrl: boolean;
                        key: string;
                    }[];
                    axisMappings: unknown[];
                    boolSettings: {
                        value: boolean;
                        settingEnum: string;
                    }[];
                    floatSettings: {
                        value: number;
                        settingEnum: string;
                    }[];
                    intSettings: {
                        value: number;
                        settingEnum: string;
                    }[];
                    roamingSetttingsVersion: number;
                    settingsProfiles: unknown[];
                    stringSettings: {
                        value: string;
                        settingEnum: string;
                    }[];
                };
                modified: number;
            }>;
        };
    };
};

type Params$K = ResolveParams<(typeof _default$K)["~type"]["url"]>;
type Body$K = z.infer<ResolveValue<(typeof _default$K)["~type"], "body">>;
type Data$K = ResolveData<Params$K, Body$K>;
type Response$K = z.infer<ResolveValue<(typeof _default$K)["~type"], "responses">["200"]>;
interface SettingsRequestConfig extends ValorantAxiosRequestConfig<Data$K> {
}
declare class SettingsEndpoint {
    /**
     * Get a list of client settings
     *
     * @EndpointType local
     */
    getSettings<T = Response$K>(this: LocalApiClient, config?: SettingsRequestConfig): Promise<AxiosResponse<T>>;
}

declare const _default$J: Omit<{
    requirements: string[];
    type: "auth" | "local" | "pd" | "glz" | "shared";
    name: string;
    method: "PUT" | "GET" | "DELETE" | "POST";
    url: string;
    description?: string | undefined;
    headers?: Record<string, string> | undefined;
    body?: z.ZodType<any, z.ZodTypeDef, any> | undefined;
    query?: z.ZodType<any, z.ZodTypeDef, any> | undefined;
    responses?: Record<string, z.ZodType<any, z.ZodTypeDef, any>> | undefined;
}, "type" | "name" | "url"> & Pick<{
    readonly name: "Swagger Docs";
    readonly description: "Fetches json Swagger docs for local endpoints. Can be imported into Swagger or Insomnia.";
    readonly type: "local";
    readonly url: "swagger/v3/openapi.json";
    readonly responses: {
        readonly "200": z.ZodUnknown;
    };
}, "type" | "name" | "url"> & {
    "~type": {
        readonly name: "Swagger Docs";
        readonly description: "Fetches json Swagger docs for local endpoints. Can be imported into Swagger or Insomnia.";
        readonly type: "local";
        readonly url: "swagger/v3/openapi.json";
        readonly responses: {
            readonly "200": z.ZodUnknown;
        };
    };
};

type Params$J = ResolveParams<(typeof _default$J)["~type"]["url"]>;
type Body$J = z.infer<ResolveValue<(typeof _default$J)["~type"], "body">>;
type Data$J = ResolveData<Params$J, Body$J>;
type Response$J = z.infer<ResolveValue<(typeof _default$J)["~type"], "responses">["200"]>;
interface SwaggerDocsRequestConfig extends ValorantAxiosRequestConfig<Data$J> {
}
declare class SwaggerDocsEndpoint {
    /**
     * Fetches json Swagger docs for local endpoints. Can be imported into Swagger or Insomnia.
     *
     * @EndpointType local
     */
    getSwaggerDocs<T = Response$J>(this: LocalApiClient, config?: SwaggerDocsRequestConfig): Promise<AxiosResponse<T>>;
}

declare class LocalApiEndpoints {
}
interface LocalApiEndpoints extends AccountAliasEndpoint, AllChatInfoEndpoint, ChatHistoryEndpoint, ChatParticipantsEndpoint, ChatSessionEndpoint, ClientRegionEndpoint, CurrentGameChatInfoEndpoint, EntitlementsTokenEndpoint, FriendRequestsEndpoint, FriendsEndpoint, HelpEndpoint, PartyChatInfoEndpoint, PreGameChatInfoEndpoint, PresenceEndpoint, RemoveFriendRequestEndpoint, RsoUserInfoEndpoint, SendChatMessageEndpoint, SendFriendRequestEndpoint, SessionsEndpoint, SettingsEndpoint, SwaggerDocsEndpoint {
}

declare const localApiClientOptionsSchema: z.ZodObject<{
    port: z.ZodString;
    username: z.ZodDefault<z.ZodString>;
    password: z.ZodString;
}, "strip", z.ZodTypeAny, {
    port: string;
    password: string;
    username: string;
}, {
    port: string;
    password: string;
    username?: string | undefined;
}>;
type LocalApiClientOptions = z.input<typeof localApiClientOptionsSchema>;
declare function createLocalApiClient(options: LocalApiClientOptions): LocalApiClient;
declare class LocalApiClient {
    #private;
    constructor(options: LocalApiClientOptions);
    reinit(options: LocalApiClientOptions): void;
    get axios(): AxiosInstance;
    get options(): {
        port: string;
        password: string;
        username: string;
    };
    ["~request"]<T extends ValorantEndpoint & {
        type: "local";
    }, TConfig extends AxiosRequestConfig>(endpoint: T, config: TConfig): Promise<axios.AxiosResponse<any, any>>;
}
interface LocalApiClient extends LocalApiEndpoints {
}

declare const REMOTE_SERVER_TYPES: readonly ["glz", "pd", "shared"];
type RemoteServerType = (typeof REMOTE_SERVER_TYPES)[number];
type RemoteServerOptions = {
    type: RemoteServerType;
    shard: string;
    region?: string;
};
type LocalServerOptions = {
    type: "local";
    port: string;
};
type ServerOptions = LocalServerOptions | RemoteServerOptions;
declare function getServerUrl(options: ServerOptions): string;
declare function getRegionAndShardFromGlzServer(glzServer: string): {
    region: string;
    shard: string;
};

declare const FetchContentResponseSchema: z.ZodObject<{
    DisabledIDs: z.ZodArray<z.ZodUnknown, "many">;
    Seasons: z.ZodArray<z.ZodObject<{
        ID: z.ZodString;
        Name: z.ZodString;
        Type: z.ZodEnum<["episode", "act"]>;
        StartTime: z.ZodEffects<z.ZodString, Date, string>;
        EndTime: z.ZodEffects<z.ZodString, Date, string>;
        IsActive: z.ZodBoolean;
    }, "strip", z.ZodTypeAny, {
        ID: string;
        StartTime: Date;
        Name: string;
        Type: "episode" | "act";
        EndTime: Date;
        IsActive: boolean;
    }, {
        ID: string;
        StartTime: string;
        Name: string;
        Type: "episode" | "act";
        EndTime: string;
        IsActive: boolean;
    }>, "many">;
    Events: z.ZodArray<z.ZodObject<{
        ID: z.ZodString;
        Name: z.ZodString;
        StartTime: z.ZodEffects<z.ZodString, Date, string>;
        EndTime: z.ZodEffects<z.ZodString, Date, string>;
        IsActive: z.ZodBoolean;
    }, "strip", z.ZodTypeAny, {
        ID: string;
        StartTime: Date;
        Name: string;
        EndTime: Date;
        IsActive: boolean;
    }, {
        ID: string;
        StartTime: string;
        Name: string;
        EndTime: string;
        IsActive: boolean;
    }>, "many">;
}, "strip", z.ZodTypeAny, {
    DisabledIDs: unknown[];
    Seasons: {
        ID: string;
        StartTime: Date;
        Name: string;
        Type: "episode" | "act";
        EndTime: Date;
        IsActive: boolean;
    }[];
    Events: {
        ID: string;
        StartTime: Date;
        Name: string;
        EndTime: Date;
        IsActive: boolean;
    }[];
}, {
    DisabledIDs: unknown[];
    Seasons: {
        ID: string;
        StartTime: string;
        Name: string;
        Type: "episode" | "act";
        EndTime: string;
        IsActive: boolean;
    }[];
    Events: {
        ID: string;
        StartTime: string;
        Name: string;
        EndTime: string;
        IsActive: boolean;
    }[];
}>;
declare const _default$I: Omit<{
    requirements: string[];
    type: "auth" | "local" | "pd" | "glz" | "shared";
    name: string;
    method: "PUT" | "GET" | "DELETE" | "POST";
    url: string;
    description?: string | undefined;
    headers?: Record<string, string> | undefined;
    body?: z.ZodType<any, z.ZodTypeDef, any> | undefined;
    query?: z.ZodType<any, z.ZodTypeDef, any> | undefined;
    responses?: Record<string, z.ZodType<any, z.ZodTypeDef, any>> | undefined;
}, "type" | "name" | "url"> & Pick<{
    readonly name: "Fetch Content";
    readonly description: "Get a list of seasons, acts, and events";
    readonly type: "shared";
    readonly url: "content-service/v3/content";
    readonly responses: {
        readonly "200": z.ZodObject<{
            DisabledIDs: z.ZodArray<z.ZodUnknown, "many">;
            Seasons: z.ZodArray<z.ZodObject<{
                ID: z.ZodString;
                Name: z.ZodString;
                Type: z.ZodEnum<["episode", "act"]>;
                StartTime: z.ZodEffects<z.ZodString, Date, string>;
                EndTime: z.ZodEffects<z.ZodString, Date, string>;
                IsActive: z.ZodBoolean;
            }, "strip", z.ZodTypeAny, {
                ID: string;
                StartTime: Date;
                Name: string;
                Type: "episode" | "act";
                EndTime: Date;
                IsActive: boolean;
            }, {
                ID: string;
                StartTime: string;
                Name: string;
                Type: "episode" | "act";
                EndTime: string;
                IsActive: boolean;
            }>, "many">;
            Events: z.ZodArray<z.ZodObject<{
                ID: z.ZodString;
                Name: z.ZodString;
                StartTime: z.ZodEffects<z.ZodString, Date, string>;
                EndTime: z.ZodEffects<z.ZodString, Date, string>;
                IsActive: z.ZodBoolean;
            }, "strip", z.ZodTypeAny, {
                ID: string;
                StartTime: Date;
                Name: string;
                EndTime: Date;
                IsActive: boolean;
            }, {
                ID: string;
                StartTime: string;
                Name: string;
                EndTime: string;
                IsActive: boolean;
            }>, "many">;
        }, "strip", z.ZodTypeAny, {
            DisabledIDs: unknown[];
            Seasons: {
                ID: string;
                StartTime: Date;
                Name: string;
                Type: "episode" | "act";
                EndTime: Date;
                IsActive: boolean;
            }[];
            Events: {
                ID: string;
                StartTime: Date;
                Name: string;
                EndTime: Date;
                IsActive: boolean;
            }[];
        }, {
            DisabledIDs: unknown[];
            Seasons: {
                ID: string;
                StartTime: string;
                Name: string;
                Type: "episode" | "act";
                EndTime: string;
                IsActive: boolean;
            }[];
            Events: {
                ID: string;
                StartTime: string;
                Name: string;
                EndTime: string;
                IsActive: boolean;
            }[];
        }>;
    };
}, "type" | "name" | "url"> & {
    "~type": {
        readonly name: "Fetch Content";
        readonly description: "Get a list of seasons, acts, and events";
        readonly type: "shared";
        readonly url: "content-service/v3/content";
        readonly responses: {
            readonly "200": z.ZodObject<{
                DisabledIDs: z.ZodArray<z.ZodUnknown, "many">;
                Seasons: z.ZodArray<z.ZodObject<{
                    ID: z.ZodString;
                    Name: z.ZodString;
                    Type: z.ZodEnum<["episode", "act"]>;
                    StartTime: z.ZodEffects<z.ZodString, Date, string>;
                    EndTime: z.ZodEffects<z.ZodString, Date, string>;
                    IsActive: z.ZodBoolean;
                }, "strip", z.ZodTypeAny, {
                    ID: string;
                    StartTime: Date;
                    Name: string;
                    Type: "episode" | "act";
                    EndTime: Date;
                    IsActive: boolean;
                }, {
                    ID: string;
                    StartTime: string;
                    Name: string;
                    Type: "episode" | "act";
                    EndTime: string;
                    IsActive: boolean;
                }>, "many">;
                Events: z.ZodArray<z.ZodObject<{
                    ID: z.ZodString;
                    Name: z.ZodString;
                    StartTime: z.ZodEffects<z.ZodString, Date, string>;
                    EndTime: z.ZodEffects<z.ZodString, Date, string>;
                    IsActive: z.ZodBoolean;
                }, "strip", z.ZodTypeAny, {
                    ID: string;
                    StartTime: Date;
                    Name: string;
                    EndTime: Date;
                    IsActive: boolean;
                }, {
                    ID: string;
                    StartTime: string;
                    Name: string;
                    EndTime: string;
                    IsActive: boolean;
                }>, "many">;
            }, "strip", z.ZodTypeAny, {
                DisabledIDs: unknown[];
                Seasons: {
                    ID: string;
                    StartTime: Date;
                    Name: string;
                    Type: "episode" | "act";
                    EndTime: Date;
                    IsActive: boolean;
                }[];
                Events: {
                    ID: string;
                    StartTime: Date;
                    Name: string;
                    EndTime: Date;
                    IsActive: boolean;
                }[];
            }, {
                DisabledIDs: unknown[];
                Seasons: {
                    ID: string;
                    StartTime: string;
                    Name: string;
                    Type: "episode" | "act";
                    EndTime: string;
                    IsActive: boolean;
                }[];
                Events: {
                    ID: string;
                    StartTime: string;
                    Name: string;
                    EndTime: string;
                    IsActive: boolean;
                }[];
            }>;
        };
    };
};

type Params$I = ResolveParams<(typeof _default$I)["~type"]["url"]>;
type Body$I = z.infer<ResolveValue<(typeof _default$I)["~type"], "body">>;
type Data$I = ResolveData<Params$I, Body$I>;
type Response$I = z.infer<ResolveValue<(typeof _default$I)["~type"], "responses">["200"]>;
interface FetchContentRequestConfig extends ValorantAxiosRequestConfig<Data$I> {
}
declare class FetchContentEndpoint {
    /**
     * Get a list of seasons, acts, and events
     *
     * @EndpointType shared
     */
    getFetchContent<T = Response$I>(this: RemoteApiClient, config?: FetchContentRequestConfig): Promise<AxiosResponse<T>>;
}

declare const accountXpResponseSchema: z.ZodObject<{
    Version: z.ZodNumber;
    Subject: z.ZodString;
    Progress: z.ZodObject<{
        Level: z.ZodNumber;
        XP: z.ZodNumber;
    }, "strip", z.ZodTypeAny, {
        Level: number;
        XP: number;
    }, {
        Level: number;
        XP: number;
    }>;
    History: z.ZodArray<z.ZodObject<{
        ID: z.ZodString;
        MatchStart: z.ZodEffects<z.ZodString, Date, string>;
        StartProgress: z.ZodObject<{
            Level: z.ZodNumber;
            XP: z.ZodNumber;
        }, "strip", z.ZodTypeAny, {
            Level: number;
            XP: number;
        }, {
            Level: number;
            XP: number;
        }>;
        EndProgress: z.ZodObject<{
            Level: z.ZodNumber;
            XP: z.ZodNumber;
        }, "strip", z.ZodTypeAny, {
            Level: number;
            XP: number;
        }, {
            Level: number;
            XP: number;
        }>;
        XPDelta: z.ZodNumber;
        XPSources: z.ZodArray<z.ZodObject<{
            ID: z.ZodEnum<["time-played", "match-win", "first-win-of-the-day"]>;
            Amount: z.ZodNumber;
        }, "strip", z.ZodTypeAny, {
            ID: "time-played" | "match-win" | "first-win-of-the-day";
            Amount: number;
        }, {
            ID: "time-played" | "match-win" | "first-win-of-the-day";
            Amount: number;
        }>, "many">;
        XPMultipliers: z.ZodArray<z.ZodUnknown, "many">;
    }, "strip", z.ZodTypeAny, {
        ID: string;
        MatchStart: Date;
        StartProgress: {
            Level: number;
            XP: number;
        };
        EndProgress: {
            Level: number;
            XP: number;
        };
        XPDelta: number;
        XPSources: {
            ID: "time-played" | "match-win" | "first-win-of-the-day";
            Amount: number;
        }[];
        XPMultipliers: unknown[];
    }, {
        ID: string;
        MatchStart: string;
        StartProgress: {
            Level: number;
            XP: number;
        };
        EndProgress: {
            Level: number;
            XP: number;
        };
        XPDelta: number;
        XPSources: {
            ID: "time-played" | "match-win" | "first-win-of-the-day";
            Amount: number;
        }[];
        XPMultipliers: unknown[];
    }>, "many">;
    LastTimeGrantedFirstWin: z.ZodEffects<z.ZodString, Date, string>;
    NextTimeFirstWinAvailable: z.ZodEffects<z.ZodString, Date, string>;
}, "strip", z.ZodTypeAny, {
    Subject: string;
    Version: number;
    History: {
        ID: string;
        MatchStart: Date;
        StartProgress: {
            Level: number;
            XP: number;
        };
        EndProgress: {
            Level: number;
            XP: number;
        };
        XPDelta: number;
        XPSources: {
            ID: "time-played" | "match-win" | "first-win-of-the-day";
            Amount: number;
        }[];
        XPMultipliers: unknown[];
    }[];
    Progress: {
        Level: number;
        XP: number;
    };
    LastTimeGrantedFirstWin: Date;
    NextTimeFirstWinAvailable: Date;
}, {
    Subject: string;
    Version: number;
    History: {
        ID: string;
        MatchStart: string;
        StartProgress: {
            Level: number;
            XP: number;
        };
        EndProgress: {
            Level: number;
            XP: number;
        };
        XPDelta: number;
        XPSources: {
            ID: "time-played" | "match-win" | "first-win-of-the-day";
            Amount: number;
        }[];
        XPMultipliers: unknown[];
    }[];
    Progress: {
        Level: number;
        XP: number;
    };
    LastTimeGrantedFirstWin: string;
    NextTimeFirstWinAvailable: string;
}>;
declare const _default$H: Omit<{
    requirements: string[];
    type: "auth" | "local" | "pd" | "glz" | "shared";
    name: string;
    method: "PUT" | "GET" | "DELETE" | "POST";
    url: string;
    description?: string | undefined;
    headers?: Record<string, string> | undefined;
    body?: z.ZodType<any, z.ZodTypeDef, any> | undefined;
    query?: z.ZodType<any, z.ZodTypeDef, any> | undefined;
    responses?: Record<string, z.ZodType<any, z.ZodTypeDef, any>> | undefined;
}, "type" | "name" | "url"> & Pick<{
    readonly name: "Account XP";
    readonly description: "Get the account level, XP, and XP history for the current player. This endpoint only works with the authenticated player's PUUID.";
    readonly type: "pd";
    readonly url: "account-xp/v1/players/:puuid";
    readonly responses: {
        readonly "200": z.ZodObject<{
            Version: z.ZodNumber;
            Subject: z.ZodString;
            Progress: z.ZodObject<{
                Level: z.ZodNumber;
                XP: z.ZodNumber;
            }, "strip", z.ZodTypeAny, {
                Level: number;
                XP: number;
            }, {
                Level: number;
                XP: number;
            }>;
            History: z.ZodArray<z.ZodObject<{
                ID: z.ZodString;
                MatchStart: z.ZodEffects<z.ZodString, Date, string>;
                StartProgress: z.ZodObject<{
                    Level: z.ZodNumber;
                    XP: z.ZodNumber;
                }, "strip", z.ZodTypeAny, {
                    Level: number;
                    XP: number;
                }, {
                    Level: number;
                    XP: number;
                }>;
                EndProgress: z.ZodObject<{
                    Level: z.ZodNumber;
                    XP: z.ZodNumber;
                }, "strip", z.ZodTypeAny, {
                    Level: number;
                    XP: number;
                }, {
                    Level: number;
                    XP: number;
                }>;
                XPDelta: z.ZodNumber;
                XPSources: z.ZodArray<z.ZodObject<{
                    ID: z.ZodEnum<["time-played", "match-win", "first-win-of-the-day"]>;
                    Amount: z.ZodNumber;
                }, "strip", z.ZodTypeAny, {
                    ID: "time-played" | "match-win" | "first-win-of-the-day";
                    Amount: number;
                }, {
                    ID: "time-played" | "match-win" | "first-win-of-the-day";
                    Amount: number;
                }>, "many">;
                XPMultipliers: z.ZodArray<z.ZodUnknown, "many">;
            }, "strip", z.ZodTypeAny, {
                ID: string;
                MatchStart: Date;
                StartProgress: {
                    Level: number;
                    XP: number;
                };
                EndProgress: {
                    Level: number;
                    XP: number;
                };
                XPDelta: number;
                XPSources: {
                    ID: "time-played" | "match-win" | "first-win-of-the-day";
                    Amount: number;
                }[];
                XPMultipliers: unknown[];
            }, {
                ID: string;
                MatchStart: string;
                StartProgress: {
                    Level: number;
                    XP: number;
                };
                EndProgress: {
                    Level: number;
                    XP: number;
                };
                XPDelta: number;
                XPSources: {
                    ID: "time-played" | "match-win" | "first-win-of-the-day";
                    Amount: number;
                }[];
                XPMultipliers: unknown[];
            }>, "many">;
            LastTimeGrantedFirstWin: z.ZodEffects<z.ZodString, Date, string>;
            NextTimeFirstWinAvailable: z.ZodEffects<z.ZodString, Date, string>;
        }, "strip", z.ZodTypeAny, {
            Subject: string;
            Version: number;
            History: {
                ID: string;
                MatchStart: Date;
                StartProgress: {
                    Level: number;
                    XP: number;
                };
                EndProgress: {
                    Level: number;
                    XP: number;
                };
                XPDelta: number;
                XPSources: {
                    ID: "time-played" | "match-win" | "first-win-of-the-day";
                    Amount: number;
                }[];
                XPMultipliers: unknown[];
            }[];
            Progress: {
                Level: number;
                XP: number;
            };
            LastTimeGrantedFirstWin: Date;
            NextTimeFirstWinAvailable: Date;
        }, {
            Subject: string;
            Version: number;
            History: {
                ID: string;
                MatchStart: string;
                StartProgress: {
                    Level: number;
                    XP: number;
                };
                EndProgress: {
                    Level: number;
                    XP: number;
                };
                XPDelta: number;
                XPSources: {
                    ID: "time-played" | "match-win" | "first-win-of-the-day";
                    Amount: number;
                }[];
                XPMultipliers: unknown[];
            }[];
            Progress: {
                Level: number;
                XP: number;
            };
            LastTimeGrantedFirstWin: string;
            NextTimeFirstWinAvailable: string;
        }>;
    };
}, "type" | "name" | "url"> & {
    "~type": {
        readonly name: "Account XP";
        readonly description: "Get the account level, XP, and XP history for the current player. This endpoint only works with the authenticated player's PUUID.";
        readonly type: "pd";
        readonly url: "account-xp/v1/players/:puuid";
        readonly responses: {
            readonly "200": z.ZodObject<{
                Version: z.ZodNumber;
                Subject: z.ZodString;
                Progress: z.ZodObject<{
                    Level: z.ZodNumber;
                    XP: z.ZodNumber;
                }, "strip", z.ZodTypeAny, {
                    Level: number;
                    XP: number;
                }, {
                    Level: number;
                    XP: number;
                }>;
                History: z.ZodArray<z.ZodObject<{
                    ID: z.ZodString;
                    MatchStart: z.ZodEffects<z.ZodString, Date, string>;
                    StartProgress: z.ZodObject<{
                        Level: z.ZodNumber;
                        XP: z.ZodNumber;
                    }, "strip", z.ZodTypeAny, {
                        Level: number;
                        XP: number;
                    }, {
                        Level: number;
                        XP: number;
                    }>;
                    EndProgress: z.ZodObject<{
                        Level: z.ZodNumber;
                        XP: z.ZodNumber;
                    }, "strip", z.ZodTypeAny, {
                        Level: number;
                        XP: number;
                    }, {
                        Level: number;
                        XP: number;
                    }>;
                    XPDelta: z.ZodNumber;
                    XPSources: z.ZodArray<z.ZodObject<{
                        ID: z.ZodEnum<["time-played", "match-win", "first-win-of-the-day"]>;
                        Amount: z.ZodNumber;
                    }, "strip", z.ZodTypeAny, {
                        ID: "time-played" | "match-win" | "first-win-of-the-day";
                        Amount: number;
                    }, {
                        ID: "time-played" | "match-win" | "first-win-of-the-day";
                        Amount: number;
                    }>, "many">;
                    XPMultipliers: z.ZodArray<z.ZodUnknown, "many">;
                }, "strip", z.ZodTypeAny, {
                    ID: string;
                    MatchStart: Date;
                    StartProgress: {
                        Level: number;
                        XP: number;
                    };
                    EndProgress: {
                        Level: number;
                        XP: number;
                    };
                    XPDelta: number;
                    XPSources: {
                        ID: "time-played" | "match-win" | "first-win-of-the-day";
                        Amount: number;
                    }[];
                    XPMultipliers: unknown[];
                }, {
                    ID: string;
                    MatchStart: string;
                    StartProgress: {
                        Level: number;
                        XP: number;
                    };
                    EndProgress: {
                        Level: number;
                        XP: number;
                    };
                    XPDelta: number;
                    XPSources: {
                        ID: "time-played" | "match-win" | "first-win-of-the-day";
                        Amount: number;
                    }[];
                    XPMultipliers: unknown[];
                }>, "many">;
                LastTimeGrantedFirstWin: z.ZodEffects<z.ZodString, Date, string>;
                NextTimeFirstWinAvailable: z.ZodEffects<z.ZodString, Date, string>;
            }, "strip", z.ZodTypeAny, {
                Subject: string;
                Version: number;
                History: {
                    ID: string;
                    MatchStart: Date;
                    StartProgress: {
                        Level: number;
                        XP: number;
                    };
                    EndProgress: {
                        Level: number;
                        XP: number;
                    };
                    XPDelta: number;
                    XPSources: {
                        ID: "time-played" | "match-win" | "first-win-of-the-day";
                        Amount: number;
                    }[];
                    XPMultipliers: unknown[];
                }[];
                Progress: {
                    Level: number;
                    XP: number;
                };
                LastTimeGrantedFirstWin: Date;
                NextTimeFirstWinAvailable: Date;
            }, {
                Subject: string;
                Version: number;
                History: {
                    ID: string;
                    MatchStart: string;
                    StartProgress: {
                        Level: number;
                        XP: number;
                    };
                    EndProgress: {
                        Level: number;
                        XP: number;
                    };
                    XPDelta: number;
                    XPSources: {
                        ID: "time-played" | "match-win" | "first-win-of-the-day";
                        Amount: number;
                    }[];
                    XPMultipliers: unknown[];
                }[];
                Progress: {
                    Level: number;
                    XP: number;
                };
                LastTimeGrantedFirstWin: string;
                NextTimeFirstWinAvailable: string;
            }>;
        };
    };
};

type Params$H = ResolveParams<(typeof _default$H)["~type"]["url"]>;
type Body$H = z.infer<ResolveValue<(typeof _default$H)["~type"], "body">>;
type Data$H = ResolveData<Params$H, Body$H>;
type Response$H = z.infer<ResolveValue<(typeof _default$H)["~type"], "responses">["200"]>;
interface AccountXpRequestConfig extends ValorantAxiosRequestConfig<Data$H> {
}
declare class AccountXpEndpoint {
    /**
     * Get the account level, XP, and XP history for the current player. This endpoint only works with the authenticated player's PUUID.
     *
     * @EndpointType pd
     */
    getAccountXp<T = Response$H>(this: RemoteApiClient, config?: AccountXpRequestConfig): Promise<AxiosResponse<T>>;
}

declare const _default$G: Omit<{
    requirements: string[];
    type: "auth" | "local" | "pd" | "glz" | "shared";
    name: string;
    method: "PUT" | "GET" | "DELETE" | "POST";
    url: string;
    description?: string | undefined;
    headers?: Record<string, string> | undefined;
    body?: zod.ZodType<any, zod.ZodTypeDef, any> | undefined;
    query?: zod.ZodType<any, zod.ZodTypeDef, any> | undefined;
    responses?: Record<string, zod.ZodType<any, zod.ZodTypeDef, any>> | undefined;
}, "type" | "name" | "url"> & Pick<{
    readonly name: "Activate Contract";
    readonly description: "Activate a specific contract by ID";
    readonly type: "pd";
    readonly url: "contracts/v1/contracts/:puuid/special/:contractId";
    readonly method: "POST";
    readonly responses: {
        readonly "200": zod.ZodObject<{
            Version: zod.ZodNumber;
            Subject: zod.ZodString;
            Contracts: zod.ZodArray<zod.ZodObject<{
                ContractDefinitionID: zod.ZodString;
                ContractProgression: zod.ZodObject<{
                    TotalProgressionEarned: zod.ZodNumber;
                    TotalProgressionEarnedVersion: zod.ZodNumber;
                    HighestRewardedLevel: zod.ZodRecord<zod.ZodString, zod.ZodObject<{
                        Amount: zod.ZodNumber;
                        Version: zod.ZodNumber;
                    }, "strip", zod.ZodTypeAny, {
                        Version: number;
                        Amount: number;
                    }, {
                        Version: number;
                        Amount: number;
                    }>>;
                }, "strip", zod.ZodTypeAny, {
                    TotalProgressionEarned: number;
                    TotalProgressionEarnedVersion: number;
                    HighestRewardedLevel: Record<string, {
                        Version: number;
                        Amount: number;
                    }>;
                }, {
                    TotalProgressionEarned: number;
                    TotalProgressionEarnedVersion: number;
                    HighestRewardedLevel: Record<string, {
                        Version: number;
                        Amount: number;
                    }>;
                }>;
                ProgressionLevelReached: zod.ZodNumber;
                ProgressionTowardsNextLevel: zod.ZodNumber;
            }, "strip", zod.ZodTypeAny, {
                ContractDefinitionID: string;
                ContractProgression: {
                    TotalProgressionEarned: number;
                    TotalProgressionEarnedVersion: number;
                    HighestRewardedLevel: Record<string, {
                        Version: number;
                        Amount: number;
                    }>;
                };
                ProgressionLevelReached: number;
                ProgressionTowardsNextLevel: number;
            }, {
                ContractDefinitionID: string;
                ContractProgression: {
                    TotalProgressionEarned: number;
                    TotalProgressionEarnedVersion: number;
                    HighestRewardedLevel: Record<string, {
                        Version: number;
                        Amount: number;
                    }>;
                };
                ProgressionLevelReached: number;
                ProgressionTowardsNextLevel: number;
            }>, "many">;
            ProcessedMatches: zod.ZodArray<zod.ZodObject<{
                ID: zod.ZodString;
                StartTime: zod.ZodEffects<zod.ZodNumber, Date, number>;
                XPGrants: zod.ZodNullable<zod.ZodObject<{
                    GamePlayed: zod.ZodNumber;
                    GameWon: zod.ZodNumber;
                    RoundPlayed: zod.ZodNumber;
                    RoundWon: zod.ZodNumber;
                    Missions: zod.ZodObject<{}, "strip", zod.ZodTypeAny, {}, {}>;
                    Modifier: zod.ZodObject<{
                        Value: zod.ZodNumber;
                        BaseMultiplierValue: zod.ZodNumber;
                        Modifiers: zod.ZodArray<zod.ZodObject<{
                            Value: zod.ZodNumber;
                            Name: zod.ZodEnum<["RESTRICTIONS_XP", "PREMIUM_CONTRACT_XP"]>;
                            BaseOnly: zod.ZodBoolean;
                        }, "strip", zod.ZodTypeAny, {
                            Value: number;
                            Name: "RESTRICTIONS_XP" | "PREMIUM_CONTRACT_XP";
                            BaseOnly: boolean;
                        }, {
                            Value: number;
                            Name: "RESTRICTIONS_XP" | "PREMIUM_CONTRACT_XP";
                            BaseOnly: boolean;
                        }>, "many">;
                    }, "strip", zod.ZodTypeAny, {
                        Value: number;
                        BaseMultiplierValue: number;
                        Modifiers: {
                            Value: number;
                            Name: "RESTRICTIONS_XP" | "PREMIUM_CONTRACT_XP";
                            BaseOnly: boolean;
                        }[];
                    }, {
                        Value: number;
                        BaseMultiplierValue: number;
                        Modifiers: {
                            Value: number;
                            Name: "RESTRICTIONS_XP" | "PREMIUM_CONTRACT_XP";
                            BaseOnly: boolean;
                        }[];
                    }>;
                    NumAFKRounds: zod.ZodNumber;
                }, "strip", zod.ZodTypeAny, {
                    GamePlayed: number;
                    GameWon: number;
                    RoundPlayed: number;
                    RoundWon: number;
                    Missions: {};
                    Modifier: {
                        Value: number;
                        BaseMultiplierValue: number;
                        Modifiers: {
                            Value: number;
                            Name: "RESTRICTIONS_XP" | "PREMIUM_CONTRACT_XP";
                            BaseOnly: boolean;
                        }[];
                    };
                    NumAFKRounds: number;
                }, {
                    GamePlayed: number;
                    GameWon: number;
                    RoundPlayed: number;
                    RoundWon: number;
                    Missions: {};
                    Modifier: {
                        Value: number;
                        BaseMultiplierValue: number;
                        Modifiers: {
                            Value: number;
                            Name: "RESTRICTIONS_XP" | "PREMIUM_CONTRACT_XP";
                            BaseOnly: boolean;
                        }[];
                    };
                    NumAFKRounds: number;
                }>>;
                RewardGrants: zod.ZodNullable<zod.ZodObject<{}, "strip", zod.ZodTypeAny, {}, {}>>;
                MissionDeltas: zod.ZodNullable<zod.ZodRecord<zod.ZodString, zod.ZodObject<{
                    ID: zod.ZodString;
                    Objectives: zod.ZodRecord<zod.ZodString, zod.ZodNumber>;
                    ObjectiveDeltas: zod.ZodRecord<zod.ZodString, zod.ZodObject<{
                        ID: zod.ZodString;
                        ProgressBefore: zod.ZodNumber;
                        ProgressAfter: zod.ZodNumber;
                    }, "strip", zod.ZodTypeAny, {
                        ID: string;
                        ProgressBefore: number;
                        ProgressAfter: number;
                    }, {
                        ID: string;
                        ProgressBefore: number;
                        ProgressAfter: number;
                    }>>;
                }, "strip", zod.ZodTypeAny, {
                    ID: string;
                    Objectives: Record<string, number>;
                    ObjectiveDeltas: Record<string, {
                        ID: string;
                        ProgressBefore: number;
                        ProgressAfter: number;
                    }>;
                }, {
                    ID: string;
                    Objectives: Record<string, number>;
                    ObjectiveDeltas: Record<string, {
                        ID: string;
                        ProgressBefore: number;
                        ProgressAfter: number;
                    }>;
                }>>>;
                ContractDeltas: zod.ZodNullable<zod.ZodRecord<zod.ZodString, zod.ZodObject<{
                    ID: zod.ZodString;
                    TotalXPBefore: zod.ZodNumber;
                    TotalXPAfter: zod.ZodNumber;
                }, "strip", zod.ZodTypeAny, {
                    ID: string;
                    TotalXPBefore: number;
                    TotalXPAfter: number;
                }, {
                    ID: string;
                    TotalXPBefore: number;
                    TotalXPAfter: number;
                }>>>;
                CouldProgressMissions: zod.ZodBoolean;
            }, "strip", zod.ZodTypeAny, {
                ID: string;
                StartTime: Date;
                XPGrants: {
                    GamePlayed: number;
                    GameWon: number;
                    RoundPlayed: number;
                    RoundWon: number;
                    Missions: {};
                    Modifier: {
                        Value: number;
                        BaseMultiplierValue: number;
                        Modifiers: {
                            Value: number;
                            Name: "RESTRICTIONS_XP" | "PREMIUM_CONTRACT_XP";
                            BaseOnly: boolean;
                        }[];
                    };
                    NumAFKRounds: number;
                } | null;
                RewardGrants: {} | null;
                MissionDeltas: Record<string, {
                    ID: string;
                    Objectives: Record<string, number>;
                    ObjectiveDeltas: Record<string, {
                        ID: string;
                        ProgressBefore: number;
                        ProgressAfter: number;
                    }>;
                }> | null;
                ContractDeltas: Record<string, {
                    ID: string;
                    TotalXPBefore: number;
                    TotalXPAfter: number;
                }> | null;
                CouldProgressMissions: boolean;
            }, {
                ID: string;
                StartTime: number;
                XPGrants: {
                    GamePlayed: number;
                    GameWon: number;
                    RoundPlayed: number;
                    RoundWon: number;
                    Missions: {};
                    Modifier: {
                        Value: number;
                        BaseMultiplierValue: number;
                        Modifiers: {
                            Value: number;
                            Name: "RESTRICTIONS_XP" | "PREMIUM_CONTRACT_XP";
                            BaseOnly: boolean;
                        }[];
                    };
                    NumAFKRounds: number;
                } | null;
                RewardGrants: {} | null;
                MissionDeltas: Record<string, {
                    ID: string;
                    Objectives: Record<string, number>;
                    ObjectiveDeltas: Record<string, {
                        ID: string;
                        ProgressBefore: number;
                        ProgressAfter: number;
                    }>;
                }> | null;
                ContractDeltas: Record<string, {
                    ID: string;
                    TotalXPBefore: number;
                    TotalXPAfter: number;
                }> | null;
                CouldProgressMissions: boolean;
            }>, "many">;
            ActiveSpecialContract: zod.ZodString;
            Missions: zod.ZodArray<zod.ZodObject<{
                ID: zod.ZodString;
                Objectives: zod.ZodRecord<zod.ZodString, zod.ZodNumber>;
                Complete: zod.ZodBoolean;
                ExpirationTime: zod.ZodEffects<zod.ZodString, Date, string>;
            }, "strip", zod.ZodTypeAny, {
                ID: string;
                Objectives: Record<string, number>;
                Complete: boolean;
                ExpirationTime: Date;
            }, {
                ID: string;
                Objectives: Record<string, number>;
                Complete: boolean;
                ExpirationTime: string;
            }>, "many">;
            MissionMetadata: zod.ZodObject<{
                NPECompleted: zod.ZodBoolean;
                WeeklyCheckpoint: zod.ZodEffects<zod.ZodString, Date, string>;
                WeeklyRefillTime: zod.ZodEffects<zod.ZodString, Date, string>;
            }, "strip", zod.ZodTypeAny, {
                NPECompleted: boolean;
                WeeklyCheckpoint: Date;
                WeeklyRefillTime: Date;
            }, {
                NPECompleted: boolean;
                WeeklyCheckpoint: string;
                WeeklyRefillTime: string;
            }>;
        }, "strip", zod.ZodTypeAny, {
            Subject: string;
            Version: number;
            Contracts: {
                ContractDefinitionID: string;
                ContractProgression: {
                    TotalProgressionEarned: number;
                    TotalProgressionEarnedVersion: number;
                    HighestRewardedLevel: Record<string, {
                        Version: number;
                        Amount: number;
                    }>;
                };
                ProgressionLevelReached: number;
                ProgressionTowardsNextLevel: number;
            }[];
            ProcessedMatches: {
                ID: string;
                StartTime: Date;
                XPGrants: {
                    GamePlayed: number;
                    GameWon: number;
                    RoundPlayed: number;
                    RoundWon: number;
                    Missions: {};
                    Modifier: {
                        Value: number;
                        BaseMultiplierValue: number;
                        Modifiers: {
                            Value: number;
                            Name: "RESTRICTIONS_XP" | "PREMIUM_CONTRACT_XP";
                            BaseOnly: boolean;
                        }[];
                    };
                    NumAFKRounds: number;
                } | null;
                RewardGrants: {} | null;
                MissionDeltas: Record<string, {
                    ID: string;
                    Objectives: Record<string, number>;
                    ObjectiveDeltas: Record<string, {
                        ID: string;
                        ProgressBefore: number;
                        ProgressAfter: number;
                    }>;
                }> | null;
                ContractDeltas: Record<string, {
                    ID: string;
                    TotalXPBefore: number;
                    TotalXPAfter: number;
                }> | null;
                CouldProgressMissions: boolean;
            }[];
            Missions: {
                ID: string;
                Objectives: Record<string, number>;
                Complete: boolean;
                ExpirationTime: Date;
            }[];
            ActiveSpecialContract: string;
            MissionMetadata: {
                NPECompleted: boolean;
                WeeklyCheckpoint: Date;
                WeeklyRefillTime: Date;
            };
        }, {
            Subject: string;
            Version: number;
            Contracts: {
                ContractDefinitionID: string;
                ContractProgression: {
                    TotalProgressionEarned: number;
                    TotalProgressionEarnedVersion: number;
                    HighestRewardedLevel: Record<string, {
                        Version: number;
                        Amount: number;
                    }>;
                };
                ProgressionLevelReached: number;
                ProgressionTowardsNextLevel: number;
            }[];
            ProcessedMatches: {
                ID: string;
                StartTime: number;
                XPGrants: {
                    GamePlayed: number;
                    GameWon: number;
                    RoundPlayed: number;
                    RoundWon: number;
                    Missions: {};
                    Modifier: {
                        Value: number;
                        BaseMultiplierValue: number;
                        Modifiers: {
                            Value: number;
                            Name: "RESTRICTIONS_XP" | "PREMIUM_CONTRACT_XP";
                            BaseOnly: boolean;
                        }[];
                    };
                    NumAFKRounds: number;
                } | null;
                RewardGrants: {} | null;
                MissionDeltas: Record<string, {
                    ID: string;
                    Objectives: Record<string, number>;
                    ObjectiveDeltas: Record<string, {
                        ID: string;
                        ProgressBefore: number;
                        ProgressAfter: number;
                    }>;
                }> | null;
                ContractDeltas: Record<string, {
                    ID: string;
                    TotalXPBefore: number;
                    TotalXPAfter: number;
                }> | null;
                CouldProgressMissions: boolean;
            }[];
            Missions: {
                ID: string;
                Objectives: Record<string, number>;
                Complete: boolean;
                ExpirationTime: string;
            }[];
            ActiveSpecialContract: string;
            MissionMetadata: {
                NPECompleted: boolean;
                WeeklyCheckpoint: string;
                WeeklyRefillTime: string;
            };
        }>;
    };
}, "type" | "name" | "url"> & {
    "~type": {
        readonly name: "Activate Contract";
        readonly description: "Activate a specific contract by ID";
        readonly type: "pd";
        readonly url: "contracts/v1/contracts/:puuid/special/:contractId";
        readonly method: "POST";
        readonly responses: {
            readonly "200": zod.ZodObject<{
                Version: zod.ZodNumber;
                Subject: zod.ZodString;
                Contracts: zod.ZodArray<zod.ZodObject<{
                    ContractDefinitionID: zod.ZodString;
                    ContractProgression: zod.ZodObject<{
                        TotalProgressionEarned: zod.ZodNumber;
                        TotalProgressionEarnedVersion: zod.ZodNumber;
                        HighestRewardedLevel: zod.ZodRecord<zod.ZodString, zod.ZodObject<{
                            Amount: zod.ZodNumber;
                            Version: zod.ZodNumber;
                        }, "strip", zod.ZodTypeAny, {
                            Version: number;
                            Amount: number;
                        }, {
                            Version: number;
                            Amount: number;
                        }>>;
                    }, "strip", zod.ZodTypeAny, {
                        TotalProgressionEarned: number;
                        TotalProgressionEarnedVersion: number;
                        HighestRewardedLevel: Record<string, {
                            Version: number;
                            Amount: number;
                        }>;
                    }, {
                        TotalProgressionEarned: number;
                        TotalProgressionEarnedVersion: number;
                        HighestRewardedLevel: Record<string, {
                            Version: number;
                            Amount: number;
                        }>;
                    }>;
                    ProgressionLevelReached: zod.ZodNumber;
                    ProgressionTowardsNextLevel: zod.ZodNumber;
                }, "strip", zod.ZodTypeAny, {
                    ContractDefinitionID: string;
                    ContractProgression: {
                        TotalProgressionEarned: number;
                        TotalProgressionEarnedVersion: number;
                        HighestRewardedLevel: Record<string, {
                            Version: number;
                            Amount: number;
                        }>;
                    };
                    ProgressionLevelReached: number;
                    ProgressionTowardsNextLevel: number;
                }, {
                    ContractDefinitionID: string;
                    ContractProgression: {
                        TotalProgressionEarned: number;
                        TotalProgressionEarnedVersion: number;
                        HighestRewardedLevel: Record<string, {
                            Version: number;
                            Amount: number;
                        }>;
                    };
                    ProgressionLevelReached: number;
                    ProgressionTowardsNextLevel: number;
                }>, "many">;
                ProcessedMatches: zod.ZodArray<zod.ZodObject<{
                    ID: zod.ZodString;
                    StartTime: zod.ZodEffects<zod.ZodNumber, Date, number>;
                    XPGrants: zod.ZodNullable<zod.ZodObject<{
                        GamePlayed: zod.ZodNumber;
                        GameWon: zod.ZodNumber;
                        RoundPlayed: zod.ZodNumber;
                        RoundWon: zod.ZodNumber;
                        Missions: zod.ZodObject<{}, "strip", zod.ZodTypeAny, {}, {}>;
                        Modifier: zod.ZodObject<{
                            Value: zod.ZodNumber;
                            BaseMultiplierValue: zod.ZodNumber;
                            Modifiers: zod.ZodArray<zod.ZodObject<{
                                Value: zod.ZodNumber;
                                Name: zod.ZodEnum<["RESTRICTIONS_XP", "PREMIUM_CONTRACT_XP"]>;
                                BaseOnly: zod.ZodBoolean;
                            }, "strip", zod.ZodTypeAny, {
                                Value: number;
                                Name: "RESTRICTIONS_XP" | "PREMIUM_CONTRACT_XP";
                                BaseOnly: boolean;
                            }, {
                                Value: number;
                                Name: "RESTRICTIONS_XP" | "PREMIUM_CONTRACT_XP";
                                BaseOnly: boolean;
                            }>, "many">;
                        }, "strip", zod.ZodTypeAny, {
                            Value: number;
                            BaseMultiplierValue: number;
                            Modifiers: {
                                Value: number;
                                Name: "RESTRICTIONS_XP" | "PREMIUM_CONTRACT_XP";
                                BaseOnly: boolean;
                            }[];
                        }, {
                            Value: number;
                            BaseMultiplierValue: number;
                            Modifiers: {
                                Value: number;
                                Name: "RESTRICTIONS_XP" | "PREMIUM_CONTRACT_XP";
                                BaseOnly: boolean;
                            }[];
                        }>;
                        NumAFKRounds: zod.ZodNumber;
                    }, "strip", zod.ZodTypeAny, {
                        GamePlayed: number;
                        GameWon: number;
                        RoundPlayed: number;
                        RoundWon: number;
                        Missions: {};
                        Modifier: {
                            Value: number;
                            BaseMultiplierValue: number;
                            Modifiers: {
                                Value: number;
                                Name: "RESTRICTIONS_XP" | "PREMIUM_CONTRACT_XP";
                                BaseOnly: boolean;
                            }[];
                        };
                        NumAFKRounds: number;
                    }, {
                        GamePlayed: number;
                        GameWon: number;
                        RoundPlayed: number;
                        RoundWon: number;
                        Missions: {};
                        Modifier: {
                            Value: number;
                            BaseMultiplierValue: number;
                            Modifiers: {
                                Value: number;
                                Name: "RESTRICTIONS_XP" | "PREMIUM_CONTRACT_XP";
                                BaseOnly: boolean;
                            }[];
                        };
                        NumAFKRounds: number;
                    }>>;
                    RewardGrants: zod.ZodNullable<zod.ZodObject<{}, "strip", zod.ZodTypeAny, {}, {}>>;
                    MissionDeltas: zod.ZodNullable<zod.ZodRecord<zod.ZodString, zod.ZodObject<{
                        ID: zod.ZodString;
                        Objectives: zod.ZodRecord<zod.ZodString, zod.ZodNumber>;
                        ObjectiveDeltas: zod.ZodRecord<zod.ZodString, zod.ZodObject<{
                            ID: zod.ZodString;
                            ProgressBefore: zod.ZodNumber;
                            ProgressAfter: zod.ZodNumber;
                        }, "strip", zod.ZodTypeAny, {
                            ID: string;
                            ProgressBefore: number;
                            ProgressAfter: number;
                        }, {
                            ID: string;
                            ProgressBefore: number;
                            ProgressAfter: number;
                        }>>;
                    }, "strip", zod.ZodTypeAny, {
                        ID: string;
                        Objectives: Record<string, number>;
                        ObjectiveDeltas: Record<string, {
                            ID: string;
                            ProgressBefore: number;
                            ProgressAfter: number;
                        }>;
                    }, {
                        ID: string;
                        Objectives: Record<string, number>;
                        ObjectiveDeltas: Record<string, {
                            ID: string;
                            ProgressBefore: number;
                            ProgressAfter: number;
                        }>;
                    }>>>;
                    ContractDeltas: zod.ZodNullable<zod.ZodRecord<zod.ZodString, zod.ZodObject<{
                        ID: zod.ZodString;
                        TotalXPBefore: zod.ZodNumber;
                        TotalXPAfter: zod.ZodNumber;
                    }, "strip", zod.ZodTypeAny, {
                        ID: string;
                        TotalXPBefore: number;
                        TotalXPAfter: number;
                    }, {
                        ID: string;
                        TotalXPBefore: number;
                        TotalXPAfter: number;
                    }>>>;
                    CouldProgressMissions: zod.ZodBoolean;
                }, "strip", zod.ZodTypeAny, {
                    ID: string;
                    StartTime: Date;
                    XPGrants: {
                        GamePlayed: number;
                        GameWon: number;
                        RoundPlayed: number;
                        RoundWon: number;
                        Missions: {};
                        Modifier: {
                            Value: number;
                            BaseMultiplierValue: number;
                            Modifiers: {
                                Value: number;
                                Name: "RESTRICTIONS_XP" | "PREMIUM_CONTRACT_XP";
                                BaseOnly: boolean;
                            }[];
                        };
                        NumAFKRounds: number;
                    } | null;
                    RewardGrants: {} | null;
                    MissionDeltas: Record<string, {
                        ID: string;
                        Objectives: Record<string, number>;
                        ObjectiveDeltas: Record<string, {
                            ID: string;
                            ProgressBefore: number;
                            ProgressAfter: number;
                        }>;
                    }> | null;
                    ContractDeltas: Record<string, {
                        ID: string;
                        TotalXPBefore: number;
                        TotalXPAfter: number;
                    }> | null;
                    CouldProgressMissions: boolean;
                }, {
                    ID: string;
                    StartTime: number;
                    XPGrants: {
                        GamePlayed: number;
                        GameWon: number;
                        RoundPlayed: number;
                        RoundWon: number;
                        Missions: {};
                        Modifier: {
                            Value: number;
                            BaseMultiplierValue: number;
                            Modifiers: {
                                Value: number;
                                Name: "RESTRICTIONS_XP" | "PREMIUM_CONTRACT_XP";
                                BaseOnly: boolean;
                            }[];
                        };
                        NumAFKRounds: number;
                    } | null;
                    RewardGrants: {} | null;
                    MissionDeltas: Record<string, {
                        ID: string;
                        Objectives: Record<string, number>;
                        ObjectiveDeltas: Record<string, {
                            ID: string;
                            ProgressBefore: number;
                            ProgressAfter: number;
                        }>;
                    }> | null;
                    ContractDeltas: Record<string, {
                        ID: string;
                        TotalXPBefore: number;
                        TotalXPAfter: number;
                    }> | null;
                    CouldProgressMissions: boolean;
                }>, "many">;
                ActiveSpecialContract: zod.ZodString;
                Missions: zod.ZodArray<zod.ZodObject<{
                    ID: zod.ZodString;
                    Objectives: zod.ZodRecord<zod.ZodString, zod.ZodNumber>;
                    Complete: zod.ZodBoolean;
                    ExpirationTime: zod.ZodEffects<zod.ZodString, Date, string>;
                }, "strip", zod.ZodTypeAny, {
                    ID: string;
                    Objectives: Record<string, number>;
                    Complete: boolean;
                    ExpirationTime: Date;
                }, {
                    ID: string;
                    Objectives: Record<string, number>;
                    Complete: boolean;
                    ExpirationTime: string;
                }>, "many">;
                MissionMetadata: zod.ZodObject<{
                    NPECompleted: zod.ZodBoolean;
                    WeeklyCheckpoint: zod.ZodEffects<zod.ZodString, Date, string>;
                    WeeklyRefillTime: zod.ZodEffects<zod.ZodString, Date, string>;
                }, "strip", zod.ZodTypeAny, {
                    NPECompleted: boolean;
                    WeeklyCheckpoint: Date;
                    WeeklyRefillTime: Date;
                }, {
                    NPECompleted: boolean;
                    WeeklyCheckpoint: string;
                    WeeklyRefillTime: string;
                }>;
            }, "strip", zod.ZodTypeAny, {
                Subject: string;
                Version: number;
                Contracts: {
                    ContractDefinitionID: string;
                    ContractProgression: {
                        TotalProgressionEarned: number;
                        TotalProgressionEarnedVersion: number;
                        HighestRewardedLevel: Record<string, {
                            Version: number;
                            Amount: number;
                        }>;
                    };
                    ProgressionLevelReached: number;
                    ProgressionTowardsNextLevel: number;
                }[];
                ProcessedMatches: {
                    ID: string;
                    StartTime: Date;
                    XPGrants: {
                        GamePlayed: number;
                        GameWon: number;
                        RoundPlayed: number;
                        RoundWon: number;
                        Missions: {};
                        Modifier: {
                            Value: number;
                            BaseMultiplierValue: number;
                            Modifiers: {
                                Value: number;
                                Name: "RESTRICTIONS_XP" | "PREMIUM_CONTRACT_XP";
                                BaseOnly: boolean;
                            }[];
                        };
                        NumAFKRounds: number;
                    } | null;
                    RewardGrants: {} | null;
                    MissionDeltas: Record<string, {
                        ID: string;
                        Objectives: Record<string, number>;
                        ObjectiveDeltas: Record<string, {
                            ID: string;
                            ProgressBefore: number;
                            ProgressAfter: number;
                        }>;
                    }> | null;
                    ContractDeltas: Record<string, {
                        ID: string;
                        TotalXPBefore: number;
                        TotalXPAfter: number;
                    }> | null;
                    CouldProgressMissions: boolean;
                }[];
                Missions: {
                    ID: string;
                    Objectives: Record<string, number>;
                    Complete: boolean;
                    ExpirationTime: Date;
                }[];
                ActiveSpecialContract: string;
                MissionMetadata: {
                    NPECompleted: boolean;
                    WeeklyCheckpoint: Date;
                    WeeklyRefillTime: Date;
                };
            }, {
                Subject: string;
                Version: number;
                Contracts: {
                    ContractDefinitionID: string;
                    ContractProgression: {
                        TotalProgressionEarned: number;
                        TotalProgressionEarnedVersion: number;
                        HighestRewardedLevel: Record<string, {
                            Version: number;
                            Amount: number;
                        }>;
                    };
                    ProgressionLevelReached: number;
                    ProgressionTowardsNextLevel: number;
                }[];
                ProcessedMatches: {
                    ID: string;
                    StartTime: number;
                    XPGrants: {
                        GamePlayed: number;
                        GameWon: number;
                        RoundPlayed: number;
                        RoundWon: number;
                        Missions: {};
                        Modifier: {
                            Value: number;
                            BaseMultiplierValue: number;
                            Modifiers: {
                                Value: number;
                                Name: "RESTRICTIONS_XP" | "PREMIUM_CONTRACT_XP";
                                BaseOnly: boolean;
                            }[];
                        };
                        NumAFKRounds: number;
                    } | null;
                    RewardGrants: {} | null;
                    MissionDeltas: Record<string, {
                        ID: string;
                        Objectives: Record<string, number>;
                        ObjectiveDeltas: Record<string, {
                            ID: string;
                            ProgressBefore: number;
                            ProgressAfter: number;
                        }>;
                    }> | null;
                    ContractDeltas: Record<string, {
                        ID: string;
                        TotalXPBefore: number;
                        TotalXPAfter: number;
                    }> | null;
                    CouldProgressMissions: boolean;
                }[];
                Missions: {
                    ID: string;
                    Objectives: Record<string, number>;
                    Complete: boolean;
                    ExpirationTime: string;
                }[];
                ActiveSpecialContract: string;
                MissionMetadata: {
                    NPECompleted: boolean;
                    WeeklyCheckpoint: string;
                    WeeklyRefillTime: string;
                };
            }>;
        };
    };
};

type Params$G = ResolveParams<(typeof _default$G)["~type"]["url"]>;
type Body$G = z.infer<ResolveValue<(typeof _default$G)["~type"], "body">>;
type Data$G = ResolveData<Params$G, Body$G>;
type Response$G = z.infer<ResolveValue<(typeof _default$G)["~type"], "responses">["200"]>;
interface ActivateContractRequestConfig extends ValorantAxiosRequestConfig<Data$G> {
}
declare class ActivateContractEndpoint {
    /**
     * Activate a specific contract by ID
     *
     * @EndpointType pd
     */
    postActivateContract<T = Response$G>(this: RemoteApiClient, config: ActivateContractRequestConfig): Promise<AxiosResponse<T>>;
}

declare const competitiveUpdatesResponseSchema: z.ZodObject<{
    Version: z.ZodNumber;
    Subject: z.ZodString;
    Matches: z.ZodArray<z.ZodObject<{
        MatchID: z.ZodString;
        MapID: z.ZodString;
        SeasonID: z.ZodString;
        MatchStartTime: z.ZodEffects<z.ZodNumber, Date, number>;
        TierAfterUpdate: z.ZodNumber;
        TierBeforeUpdate: z.ZodNumber;
        RankedRatingAfterUpdate: z.ZodNumber;
        RankedRatingBeforeUpdate: z.ZodNumber;
        RankedRatingEarned: z.ZodNumber;
        RankedRatingPerformanceBonus: z.ZodNumber;
        CompetitiveMovement: z.ZodLiteral<"MOVEMENT_UNKNOWN">;
        AFKPenalty: z.ZodNumber;
    }, "strip", z.ZodTypeAny, {
        MatchID: string;
        MapID: string;
        SeasonID: string;
        MatchStartTime: Date;
        TierAfterUpdate: number;
        TierBeforeUpdate: number;
        RankedRatingAfterUpdate: number;
        RankedRatingBeforeUpdate: number;
        RankedRatingEarned: number;
        RankedRatingPerformanceBonus: number;
        CompetitiveMovement: "MOVEMENT_UNKNOWN";
        AFKPenalty: number;
    }, {
        MatchID: string;
        MapID: string;
        SeasonID: string;
        MatchStartTime: number;
        TierAfterUpdate: number;
        TierBeforeUpdate: number;
        RankedRatingAfterUpdate: number;
        RankedRatingBeforeUpdate: number;
        RankedRatingEarned: number;
        RankedRatingPerformanceBonus: number;
        CompetitiveMovement: "MOVEMENT_UNKNOWN";
        AFKPenalty: number;
    }>, "many">;
}, "strip", z.ZodTypeAny, {
    Subject: string;
    Version: number;
    Matches: {
        MatchID: string;
        MapID: string;
        SeasonID: string;
        MatchStartTime: Date;
        TierAfterUpdate: number;
        TierBeforeUpdate: number;
        RankedRatingAfterUpdate: number;
        RankedRatingBeforeUpdate: number;
        RankedRatingEarned: number;
        RankedRatingPerformanceBonus: number;
        CompetitiveMovement: "MOVEMENT_UNKNOWN";
        AFKPenalty: number;
    }[];
}, {
    Subject: string;
    Version: number;
    Matches: {
        MatchID: string;
        MapID: string;
        SeasonID: string;
        MatchStartTime: number;
        TierAfterUpdate: number;
        TierBeforeUpdate: number;
        RankedRatingAfterUpdate: number;
        RankedRatingBeforeUpdate: number;
        RankedRatingEarned: number;
        RankedRatingPerformanceBonus: number;
        CompetitiveMovement: "MOVEMENT_UNKNOWN";
        AFKPenalty: number;
    }[];
}>;
declare const _default$F: Omit<{
    requirements: string[];
    type: "auth" | "local" | "pd" | "glz" | "shared";
    name: string;
    method: "PUT" | "GET" | "DELETE" | "POST";
    url: string;
    description?: string | undefined;
    headers?: Record<string, string> | undefined;
    body?: z.ZodType<any, z.ZodTypeDef, any> | undefined;
    query?: z.ZodType<any, z.ZodTypeDef, any> | undefined;
    responses?: Record<string, z.ZodType<any, z.ZodTypeDef, any>> | undefined;
}, "type" | "name" | "url"> & Pick<{
    readonly name: "Competitive Updates";
    readonly description: "Get recent games and how they changed ranking";
    readonly queryName: "MMR_FetchCompetitiveUpdates";
    readonly category: "PVP Endpoints";
    readonly type: "pd";
    readonly url: "mmr/v1/players/:puuid/competitiveupdates";
    readonly query: z.ZodObject<{
        startIndex: z.ZodOptional<z.ZodNumber>;
        endIndex: z.ZodOptional<z.ZodNumber>;
        queue: z.ZodOptional<z.ZodString>;
    }, "strip", z.ZodTypeAny, {
        startIndex?: number | undefined;
        endIndex?: number | undefined;
        queue?: string | undefined;
    }, {
        startIndex?: number | undefined;
        endIndex?: number | undefined;
        queue?: string | undefined;
    }>;
    readonly responses: {
        readonly "200": z.ZodObject<{
            Version: z.ZodNumber;
            Subject: z.ZodString;
            Matches: z.ZodArray<z.ZodObject<{
                MatchID: z.ZodString;
                MapID: z.ZodString;
                SeasonID: z.ZodString;
                MatchStartTime: z.ZodEffects<z.ZodNumber, Date, number>;
                TierAfterUpdate: z.ZodNumber;
                TierBeforeUpdate: z.ZodNumber;
                RankedRatingAfterUpdate: z.ZodNumber;
                RankedRatingBeforeUpdate: z.ZodNumber;
                RankedRatingEarned: z.ZodNumber;
                RankedRatingPerformanceBonus: z.ZodNumber;
                CompetitiveMovement: z.ZodLiteral<"MOVEMENT_UNKNOWN">;
                AFKPenalty: z.ZodNumber;
            }, "strip", z.ZodTypeAny, {
                MatchID: string;
                MapID: string;
                SeasonID: string;
                MatchStartTime: Date;
                TierAfterUpdate: number;
                TierBeforeUpdate: number;
                RankedRatingAfterUpdate: number;
                RankedRatingBeforeUpdate: number;
                RankedRatingEarned: number;
                RankedRatingPerformanceBonus: number;
                CompetitiveMovement: "MOVEMENT_UNKNOWN";
                AFKPenalty: number;
            }, {
                MatchID: string;
                MapID: string;
                SeasonID: string;
                MatchStartTime: number;
                TierAfterUpdate: number;
                TierBeforeUpdate: number;
                RankedRatingAfterUpdate: number;
                RankedRatingBeforeUpdate: number;
                RankedRatingEarned: number;
                RankedRatingPerformanceBonus: number;
                CompetitiveMovement: "MOVEMENT_UNKNOWN";
                AFKPenalty: number;
            }>, "many">;
        }, "strip", z.ZodTypeAny, {
            Subject: string;
            Version: number;
            Matches: {
                MatchID: string;
                MapID: string;
                SeasonID: string;
                MatchStartTime: Date;
                TierAfterUpdate: number;
                TierBeforeUpdate: number;
                RankedRatingAfterUpdate: number;
                RankedRatingBeforeUpdate: number;
                RankedRatingEarned: number;
                RankedRatingPerformanceBonus: number;
                CompetitiveMovement: "MOVEMENT_UNKNOWN";
                AFKPenalty: number;
            }[];
        }, {
            Subject: string;
            Version: number;
            Matches: {
                MatchID: string;
                MapID: string;
                SeasonID: string;
                MatchStartTime: number;
                TierAfterUpdate: number;
                TierBeforeUpdate: number;
                RankedRatingAfterUpdate: number;
                RankedRatingBeforeUpdate: number;
                RankedRatingEarned: number;
                RankedRatingPerformanceBonus: number;
                CompetitiveMovement: "MOVEMENT_UNKNOWN";
                AFKPenalty: number;
            }[];
        }>;
    };
}, "type" | "name" | "url"> & {
    "~type": {
        readonly name: "Competitive Updates";
        readonly description: "Get recent games and how they changed ranking";
        readonly queryName: "MMR_FetchCompetitiveUpdates";
        readonly category: "PVP Endpoints";
        readonly type: "pd";
        readonly url: "mmr/v1/players/:puuid/competitiveupdates";
        readonly query: z.ZodObject<{
            startIndex: z.ZodOptional<z.ZodNumber>;
            endIndex: z.ZodOptional<z.ZodNumber>;
            queue: z.ZodOptional<z.ZodString>;
        }, "strip", z.ZodTypeAny, {
            startIndex?: number | undefined;
            endIndex?: number | undefined;
            queue?: string | undefined;
        }, {
            startIndex?: number | undefined;
            endIndex?: number | undefined;
            queue?: string | undefined;
        }>;
        readonly responses: {
            readonly "200": z.ZodObject<{
                Version: z.ZodNumber;
                Subject: z.ZodString;
                Matches: z.ZodArray<z.ZodObject<{
                    MatchID: z.ZodString;
                    MapID: z.ZodString;
                    SeasonID: z.ZodString;
                    MatchStartTime: z.ZodEffects<z.ZodNumber, Date, number>;
                    TierAfterUpdate: z.ZodNumber;
                    TierBeforeUpdate: z.ZodNumber;
                    RankedRatingAfterUpdate: z.ZodNumber;
                    RankedRatingBeforeUpdate: z.ZodNumber;
                    RankedRatingEarned: z.ZodNumber;
                    RankedRatingPerformanceBonus: z.ZodNumber;
                    CompetitiveMovement: z.ZodLiteral<"MOVEMENT_UNKNOWN">;
                    AFKPenalty: z.ZodNumber;
                }, "strip", z.ZodTypeAny, {
                    MatchID: string;
                    MapID: string;
                    SeasonID: string;
                    MatchStartTime: Date;
                    TierAfterUpdate: number;
                    TierBeforeUpdate: number;
                    RankedRatingAfterUpdate: number;
                    RankedRatingBeforeUpdate: number;
                    RankedRatingEarned: number;
                    RankedRatingPerformanceBonus: number;
                    CompetitiveMovement: "MOVEMENT_UNKNOWN";
                    AFKPenalty: number;
                }, {
                    MatchID: string;
                    MapID: string;
                    SeasonID: string;
                    MatchStartTime: number;
                    TierAfterUpdate: number;
                    TierBeforeUpdate: number;
                    RankedRatingAfterUpdate: number;
                    RankedRatingBeforeUpdate: number;
                    RankedRatingEarned: number;
                    RankedRatingPerformanceBonus: number;
                    CompetitiveMovement: "MOVEMENT_UNKNOWN";
                    AFKPenalty: number;
                }>, "many">;
            }, "strip", z.ZodTypeAny, {
                Subject: string;
                Version: number;
                Matches: {
                    MatchID: string;
                    MapID: string;
                    SeasonID: string;
                    MatchStartTime: Date;
                    TierAfterUpdate: number;
                    TierBeforeUpdate: number;
                    RankedRatingAfterUpdate: number;
                    RankedRatingBeforeUpdate: number;
                    RankedRatingEarned: number;
                    RankedRatingPerformanceBonus: number;
                    CompetitiveMovement: "MOVEMENT_UNKNOWN";
                    AFKPenalty: number;
                }[];
            }, {
                Subject: string;
                Version: number;
                Matches: {
                    MatchID: string;
                    MapID: string;
                    SeasonID: string;
                    MatchStartTime: number;
                    TierAfterUpdate: number;
                    TierBeforeUpdate: number;
                    RankedRatingAfterUpdate: number;
                    RankedRatingBeforeUpdate: number;
                    RankedRatingEarned: number;
                    RankedRatingPerformanceBonus: number;
                    CompetitiveMovement: "MOVEMENT_UNKNOWN";
                    AFKPenalty: number;
                }[];
            }>;
        };
    };
};

type Params$F = ResolveParams<(typeof _default$F)["~type"]["url"]>;
type Body$F = z.infer<ResolveValue<(typeof _default$F)["~type"], "body">>;
type Data$F = ResolveData<Params$F, Body$F>;
type Response$F = z.infer<ResolveValue<(typeof _default$F)["~type"], "responses">["200"]>;
interface CompetitiveUpdatesRequestConfig extends ValorantAxiosRequestConfig<Data$F> {
}
declare class CompetitiveUpdatesEndpoint {
    /**
     * Get recent games and how they changed ranking
     *
     * @EndpointType pd
     */
    getCompetitiveUpdates<T = Response$F>(this: RemoteApiClient, config?: CompetitiveUpdatesRequestConfig): Promise<AxiosResponse<T>>;
}

declare const configResponseSchema: z.ZodObject<{
    LastApplication: z.ZodEffects<z.ZodString, Date, string>;
    Collapsed: z.ZodObject<{
        ARES_MOC_ENTITLEMENT: z.ZodString;
        "CLIENT.ICONS.ENABLED": z.ZodEffects<z.ZodString, boolean, string>;
        CLIENT_LEADERBOARDS_ENABLED: z.ZodEffects<z.ZodString, boolean, string>;
        GAME_ALLOW_CONSOLE: z.ZodEffects<z.ZodString, boolean, string>;
        GAME_ALLOW_DEVELOPER_MENU: z.ZodEffects<z.ZodString, boolean, string>;
        GAME_DISABLED_DEATHCAM: z.ZodEffects<z.ZodString, boolean, string>;
        GAME_DISABLED_SKINS_WEAPONS: z.ZodEffects<z.ZodString, string[], string>;
        GAME_PERFREPORTING_ENABLED: z.ZodEffects<z.ZodString, boolean, string>;
        GAME_REMOTE_MOVE_INTERP_ENABLED: z.ZodEffects<z.ZodString, boolean, string>;
        GAME_ROAMINGSETTINGS_ENABLED: z.ZodEffects<z.ZodString, boolean, string>;
        GAME_ROAMINGSETTINGS_KEY: z.ZodString;
        GAME_ROAMINGSETTINGS_STORAGEURL: z.ZodString;
        MAP_PRELOADING_ENABLED: z.ZodEffects<z.ZodString, boolean, string>;
        NAMECHECK_PLATFORM_REGION: z.ZodString;
        NAMECHECK_PLATFORM_URL: z.ZodString;
        ROSTER_REALM: z.ZodString;
        SECURITY_WATERMARK_ENABLED: z.ZodEffects<z.ZodString, boolean, string>;
        SECURITY_WATERMARK_MAX_OPACITY: z.ZodEffects<z.ZodString, number, string>;
        SECURITY_WATERMARK_MIN_OPACITY: z.ZodEffects<z.ZodString, number, string>;
        SECURITY_WATERMARK_TILING_FACTOR: z.ZodEffects<z.ZodString, number, string>;
        SERVICEURL_ACCOUNT_XP: z.ZodString;
        SERVICEURL_AGGSTATS: z.ZodString;
        SERVICEURL_AVS: z.ZodString;
        SERVICEURL_CONTENT: z.ZodString;
        SERVICEURL_CONTRACTS: z.ZodString;
        SERVICEURL_CONTRACT_DEFINITIONS: z.ZodString;
        SERVICEURL_COREGAME: z.ZodString;
        SERVICEURL_DAILY_TICKET: z.ZodString;
        SERVICEURL_FAVORITES: z.ZodString;
        SERVICEURL_GALBS_QUERY: z.ZodString;
        SERVICEURL_LATENCY: z.ZodString;
        SERVICEURL_LOGINQUEUE: z.ZodString;
        SERVICEURL_MASS_REWARDS: z.ZodString;
        SERVICEURL_MATCHDETAILS: z.ZodString;
        SERVICEURL_MATCHHISTORY: z.ZodString;
        SERVICEURL_MATCHMAKING: z.ZodString;
        SERVICEURL_MMR: z.ZodString;
        SERVICEURL_NAME: z.ZodString;
        SERVICEURL_PARTY: z.ZodString;
        SERVICEURL_PATCHNOTES: z.ZodString;
        SERVICEURL_PERSONALIZATION: z.ZodString;
        SERVICEURL_PLAYERFEEDBACK: z.ZodString;
        SERVICEURL_PREGAME: z.ZodString;
        SERVICEURL_PREMIER: z.ZodString;
        SERVICEURL_PROGRESSION: z.ZodString;
        SERVICEURL_PURCHASEMERCHANT: z.ZodString;
        SERVICEURL_REPLAY_CATALOG: z.ZodString;
        SERVICEURL_RESTRICTIONS: z.ZodString;
        SERVICEURL_SESSION: z.ZodString;
        SERVICEURL_STORE: z.ZodString;
        SERVICEURL_TOURNAMENTS: z.ZodString;
        SERVICE_TICKER_MESSAGE: z.ZodString;
        "SERVICE_TICKER_MESSAGE.de-DE": z.ZodString;
        "SERVICE_TICKER_MESSAGE.es-MX": z.ZodString;
        "SERVICE_TICKER_MESSAGE.fr-FR": z.ZodString;
        "SERVICE_TICKER_MESSAGE.it-IT": z.ZodString;
        "SERVICE_TICKER_MESSAGE.pl-PL": z.ZodString;
        "SERVICE_TICKER_MESSAGE.pt-BR": z.ZodString;
        "SERVICE_TICKER_MESSAGE.ru-RU": z.ZodString;
        "SERVICE_TICKER_MESSAGE.tr-TR": z.ZodString;
        SERVICE_TICKER_SEVERITY: z.ZodString;
        STORESCREEN_OFFERREFRESH_MAXDELAY_MILLISECONDS: z.ZodEffects<z.ZodString, number, string>;
        "avs.enabled": z.ZodEffects<z.ZodString, boolean, string>;
        "cap.location": z.ZodString;
        "characterselect.debugwidgets.hide": z.ZodEffects<z.ZodString, boolean, string>;
        "chat.mutedwords.enabled": z.ZodEffects<z.ZodString, boolean, string>;
        "chat.v3.enabled": z.ZodEffects<z.ZodString, boolean, string>;
        "collection.characters.enabled": z.ZodEffects<z.ZodString, boolean, string>;
        competitiveSeasonOffsetEndTime: z.ZodEffects<z.ZodString, number, string>;
        "config.client.telemetry.samplerate": z.ZodEffects<z.ZodString, number, string>;
        "content.filter.enabled": z.ZodEffects<z.ZodString, boolean, string>;
        "content.maps.disabled": z.ZodString;
        "eog.wip": z.ZodEffects<z.ZodString, boolean, string>;
        "friends.enabled": z.ZodEffects<z.ZodString, boolean, string>;
        "game.umgchat.enabled": z.ZodEffects<z.ZodString, boolean, string>;
        "homescreen.featuredQueues": z.ZodString;
        "homescreen.patchnotes.baseURL": z.ZodString;
        "homescreen.promo.enabled": z.ZodEffects<z.ZodString, boolean, string>;
        "homescreen.promo.key": z.ZodString;
        "homescreen.webtile.baseURL": z.ZodString;
        "loginqueue.region": z.ZodString;
        "mainmenubar.collections.enabled": z.ZodEffects<z.ZodString, boolean, string>;
        "mainmenubar.debug.enabled": z.ZodEffects<z.ZodString, boolean, string>;
        "mainmenubar.profile.enabled": z.ZodEffects<z.ZodString, boolean, string>;
        "mainmenubar.progression.enabled": z.ZodEffects<z.ZodString, boolean, string>;
        "mainmenubar.shootingrange.enabled": z.ZodEffects<z.ZodString, boolean, string>;
        "mainmenubar.store.enabled": z.ZodEffects<z.ZodString, boolean, string>;
        "match.details.delay": z.ZodEffects<z.ZodString, number, string>;
        "notifications.enabled": z.ZodEffects<z.ZodString, boolean, string>;
        "parties.auto.balance.enabled": z.ZodEffects<z.ZodString, boolean, string>;
        "party.observers.enabled": z.ZodEffects<z.ZodString, boolean, string>;
        "partyinvites.enabled": z.ZodEffects<z.ZodString, boolean, string>;
        "patchavailability.enabled": z.ZodEffects<z.ZodString, boolean, string>;
        "personalization.equipAnyLevel.enabled": z.ZodEffects<z.ZodString, boolean, string>;
        "personalization.useWidePlayerIdentityV2": z.ZodEffects<z.ZodString, boolean, string>;
        "ping.update.interval": z.ZodEffects<z.ZodString, number, string>;
        "ping.useGamePodsFromParties": z.ZodEffects<z.ZodString, boolean, string>;
        "platformFaulted.level": z.ZodString;
        "playerfeedbacktool.accessurl": z.ZodString;
        "playerfeedbacktool.locale": z.ZodString;
        "playerfeedbacktool.shard": z.ZodString;
        "playerfeedbacktool.show": z.ZodEffects<z.ZodString, boolean, string>;
        "playerfeedbacktool.survey_request_rate_float": z.ZodEffects<z.ZodString, number, string>;
        "playscreen.partywidget.enabled": z.ZodEffects<z.ZodString, boolean, string>;
        "playscreen.partywidget.matchmaking.maxsize": z.ZodEffects<z.ZodString, number, string>;
        "playscreen.premier.enabled": z.ZodEffects<z.ZodString, boolean, string>;
        "premier.conferences.fetch.enabled": z.ZodEffects<z.ZodString, boolean, string>;
        "premier.leaderboardTab.enabled": z.ZodEffects<z.ZodString, boolean, string>;
        "premier.matchHistoryTab.enabled": z.ZodEffects<z.ZodString, boolean, string>;
        "premier.playscreenflow.enabled": z.ZodEffects<z.ZodString, boolean, string>;
        "premier.rosterEligibilityCheck.enabled": z.ZodEffects<z.ZodString, boolean, string>;
        "premier.seasons.activeseason.enabled": z.ZodEffects<z.ZodString, boolean, string>;
        "premier.seasons.fetch.enabled": z.ZodEffects<z.ZodString, boolean, string>;
        "queue.status.enabled": z.ZodEffects<z.ZodString, boolean, string>;
        "rchat.ingame.enabled": z.ZodEffects<z.ZodString, boolean, string>;
        "reporterfeedback.fetch.enabled": z.ZodEffects<z.ZodString, boolean, string>;
        "reporterfeedback.notifications.enabled": z.ZodEffects<z.ZodString, boolean, string>;
        "restrictions.v2.fetch.enabled": z.ZodEffects<z.ZodString, boolean, string>;
        "restrictions.v2.warnings.enabled": z.ZodEffects<z.ZodString, boolean, string>;
        "riotwarning.fetch.enabled": z.ZodEffects<z.ZodString, boolean, string>;
        "riotwarning.notifications.enabled": z.ZodEffects<z.ZodString, boolean, string>;
        "rnet.useAuthenticatedVoice": z.ZodEffects<z.ZodString, boolean, string>;
        "russia.voice.enabled": z.ZodEffects<z.ZodString, boolean, string>;
        "settings.livediagnostics.allowedplayers": z.ZodEffects<z.ZodString, string[], string>;
        "shootingtest.enabled": z.ZodEffects<z.ZodString, boolean, string>;
        "skillrating.enabled": z.ZodEffects<z.ZodString, boolean, string>;
        "skillrating.inGame.enabled": z.ZodEffects<z.ZodString, boolean, string>;
        "skillrating.preGame.enabled": z.ZodEffects<z.ZodString, boolean, string>;
        "social.panel.v6.enabled": z.ZodEffects<z.ZodString, boolean, string>;
        "socialviewcontroller.enabled": z.ZodEffects<z.ZodString, boolean, string>;
        "socialviewcontroller.v2.enabled": z.ZodEffects<z.ZodString, boolean, string>;
        "store.isXgpDisabled": z.ZodEffects<z.ZodString, boolean, string>;
        "store.use_currency_inventory_models": z.ZodEffects<z.ZodString, boolean, string>;
        "store.use_platform_bundle_discounted_prices": z.ZodEffects<z.ZodString, boolean, string>;
        "telemetry.rtp.eventendpoint": z.ZodString;
        "telemetry.rtp.rfc190scope": z.ZodString;
        "temp.voice.allowmuting": z.ZodEffects<z.ZodString, boolean, string>;
        "tournaments.enabled": z.ZodEffects<z.ZodString, boolean, string>;
        "tournaments.pregame.enabled": z.ZodEffects<z.ZodString, boolean, string>;
        "vanguard.accessurl": z.ZodString;
        "vanguard.netrequired": z.ZodEffects<z.ZodString, boolean, string>;
        "voice.clutchmute.enabled": z.ZodEffects<z.ZodString, boolean, string>;
        "voice.clutchmute.prompt.enabled": z.ZodEffects<z.ZodString, boolean, string>;
        "voice.provider": z.ZodString;
        "whisper.enabled": z.ZodEffects<z.ZodString, boolean, string>;
    }, "strip", z.ZodTypeAny, {
        ARES_MOC_ENTITLEMENT: string;
        "CLIENT.ICONS.ENABLED": boolean;
        CLIENT_LEADERBOARDS_ENABLED: boolean;
        GAME_ALLOW_CONSOLE: boolean;
        GAME_ALLOW_DEVELOPER_MENU: boolean;
        GAME_DISABLED_DEATHCAM: boolean;
        GAME_DISABLED_SKINS_WEAPONS: string[];
        GAME_PERFREPORTING_ENABLED: boolean;
        GAME_REMOTE_MOVE_INTERP_ENABLED: boolean;
        GAME_ROAMINGSETTINGS_ENABLED: boolean;
        GAME_ROAMINGSETTINGS_KEY: string;
        GAME_ROAMINGSETTINGS_STORAGEURL: string;
        MAP_PRELOADING_ENABLED: boolean;
        NAMECHECK_PLATFORM_REGION: string;
        NAMECHECK_PLATFORM_URL: string;
        ROSTER_REALM: string;
        SECURITY_WATERMARK_ENABLED: boolean;
        SECURITY_WATERMARK_MAX_OPACITY: number;
        SECURITY_WATERMARK_MIN_OPACITY: number;
        SECURITY_WATERMARK_TILING_FACTOR: number;
        SERVICEURL_ACCOUNT_XP: string;
        SERVICEURL_AGGSTATS: string;
        SERVICEURL_AVS: string;
        SERVICEURL_CONTENT: string;
        SERVICEURL_CONTRACTS: string;
        SERVICEURL_CONTRACT_DEFINITIONS: string;
        SERVICEURL_COREGAME: string;
        SERVICEURL_DAILY_TICKET: string;
        SERVICEURL_FAVORITES: string;
        SERVICEURL_GALBS_QUERY: string;
        SERVICEURL_LATENCY: string;
        SERVICEURL_LOGINQUEUE: string;
        SERVICEURL_MASS_REWARDS: string;
        SERVICEURL_MATCHDETAILS: string;
        SERVICEURL_MATCHHISTORY: string;
        SERVICEURL_MATCHMAKING: string;
        SERVICEURL_MMR: string;
        SERVICEURL_NAME: string;
        SERVICEURL_PARTY: string;
        SERVICEURL_PATCHNOTES: string;
        SERVICEURL_PERSONALIZATION: string;
        SERVICEURL_PLAYERFEEDBACK: string;
        SERVICEURL_PREGAME: string;
        SERVICEURL_PREMIER: string;
        SERVICEURL_PROGRESSION: string;
        SERVICEURL_PURCHASEMERCHANT: string;
        SERVICEURL_REPLAY_CATALOG: string;
        SERVICEURL_RESTRICTIONS: string;
        SERVICEURL_SESSION: string;
        SERVICEURL_STORE: string;
        SERVICEURL_TOURNAMENTS: string;
        SERVICE_TICKER_MESSAGE: string;
        "SERVICE_TICKER_MESSAGE.de-DE": string;
        "SERVICE_TICKER_MESSAGE.es-MX": string;
        "SERVICE_TICKER_MESSAGE.fr-FR": string;
        "SERVICE_TICKER_MESSAGE.it-IT": string;
        "SERVICE_TICKER_MESSAGE.pl-PL": string;
        "SERVICE_TICKER_MESSAGE.pt-BR": string;
        "SERVICE_TICKER_MESSAGE.ru-RU": string;
        "SERVICE_TICKER_MESSAGE.tr-TR": string;
        SERVICE_TICKER_SEVERITY: string;
        STORESCREEN_OFFERREFRESH_MAXDELAY_MILLISECONDS: number;
        "avs.enabled": boolean;
        "cap.location": string;
        "characterselect.debugwidgets.hide": boolean;
        "chat.mutedwords.enabled": boolean;
        "chat.v3.enabled": boolean;
        "collection.characters.enabled": boolean;
        competitiveSeasonOffsetEndTime: number;
        "config.client.telemetry.samplerate": number;
        "content.filter.enabled": boolean;
        "content.maps.disabled": string;
        "eog.wip": boolean;
        "friends.enabled": boolean;
        "game.umgchat.enabled": boolean;
        "homescreen.featuredQueues": string;
        "homescreen.patchnotes.baseURL": string;
        "homescreen.promo.enabled": boolean;
        "homescreen.promo.key": string;
        "homescreen.webtile.baseURL": string;
        "loginqueue.region": string;
        "mainmenubar.collections.enabled": boolean;
        "mainmenubar.debug.enabled": boolean;
        "mainmenubar.profile.enabled": boolean;
        "mainmenubar.progression.enabled": boolean;
        "mainmenubar.shootingrange.enabled": boolean;
        "mainmenubar.store.enabled": boolean;
        "match.details.delay": number;
        "notifications.enabled": boolean;
        "parties.auto.balance.enabled": boolean;
        "party.observers.enabled": boolean;
        "partyinvites.enabled": boolean;
        "patchavailability.enabled": boolean;
        "personalization.equipAnyLevel.enabled": boolean;
        "personalization.useWidePlayerIdentityV2": boolean;
        "ping.update.interval": number;
        "ping.useGamePodsFromParties": boolean;
        "platformFaulted.level": string;
        "playerfeedbacktool.accessurl": string;
        "playerfeedbacktool.locale": string;
        "playerfeedbacktool.shard": string;
        "playerfeedbacktool.show": boolean;
        "playerfeedbacktool.survey_request_rate_float": number;
        "playscreen.partywidget.enabled": boolean;
        "playscreen.partywidget.matchmaking.maxsize": number;
        "playscreen.premier.enabled": boolean;
        "premier.conferences.fetch.enabled": boolean;
        "premier.leaderboardTab.enabled": boolean;
        "premier.matchHistoryTab.enabled": boolean;
        "premier.playscreenflow.enabled": boolean;
        "premier.rosterEligibilityCheck.enabled": boolean;
        "premier.seasons.activeseason.enabled": boolean;
        "premier.seasons.fetch.enabled": boolean;
        "queue.status.enabled": boolean;
        "rchat.ingame.enabled": boolean;
        "reporterfeedback.fetch.enabled": boolean;
        "reporterfeedback.notifications.enabled": boolean;
        "restrictions.v2.fetch.enabled": boolean;
        "restrictions.v2.warnings.enabled": boolean;
        "riotwarning.fetch.enabled": boolean;
        "riotwarning.notifications.enabled": boolean;
        "rnet.useAuthenticatedVoice": boolean;
        "russia.voice.enabled": boolean;
        "settings.livediagnostics.allowedplayers": string[];
        "shootingtest.enabled": boolean;
        "skillrating.enabled": boolean;
        "skillrating.inGame.enabled": boolean;
        "skillrating.preGame.enabled": boolean;
        "social.panel.v6.enabled": boolean;
        "socialviewcontroller.enabled": boolean;
        "socialviewcontroller.v2.enabled": boolean;
        "store.isXgpDisabled": boolean;
        "store.use_currency_inventory_models": boolean;
        "store.use_platform_bundle_discounted_prices": boolean;
        "telemetry.rtp.eventendpoint": string;
        "telemetry.rtp.rfc190scope": string;
        "temp.voice.allowmuting": boolean;
        "tournaments.enabled": boolean;
        "tournaments.pregame.enabled": boolean;
        "vanguard.accessurl": string;
        "vanguard.netrequired": boolean;
        "voice.clutchmute.enabled": boolean;
        "voice.clutchmute.prompt.enabled": boolean;
        "voice.provider": string;
        "whisper.enabled": boolean;
    }, {
        ARES_MOC_ENTITLEMENT: string;
        "CLIENT.ICONS.ENABLED": string;
        CLIENT_LEADERBOARDS_ENABLED: string;
        GAME_ALLOW_CONSOLE: string;
        GAME_ALLOW_DEVELOPER_MENU: string;
        GAME_DISABLED_DEATHCAM: string;
        GAME_DISABLED_SKINS_WEAPONS: string;
        GAME_PERFREPORTING_ENABLED: string;
        GAME_REMOTE_MOVE_INTERP_ENABLED: string;
        GAME_ROAMINGSETTINGS_ENABLED: string;
        GAME_ROAMINGSETTINGS_KEY: string;
        GAME_ROAMINGSETTINGS_STORAGEURL: string;
        MAP_PRELOADING_ENABLED: string;
        NAMECHECK_PLATFORM_REGION: string;
        NAMECHECK_PLATFORM_URL: string;
        ROSTER_REALM: string;
        SECURITY_WATERMARK_ENABLED: string;
        SECURITY_WATERMARK_MAX_OPACITY: string;
        SECURITY_WATERMARK_MIN_OPACITY: string;
        SECURITY_WATERMARK_TILING_FACTOR: string;
        SERVICEURL_ACCOUNT_XP: string;
        SERVICEURL_AGGSTATS: string;
        SERVICEURL_AVS: string;
        SERVICEURL_CONTENT: string;
        SERVICEURL_CONTRACTS: string;
        SERVICEURL_CONTRACT_DEFINITIONS: string;
        SERVICEURL_COREGAME: string;
        SERVICEURL_DAILY_TICKET: string;
        SERVICEURL_FAVORITES: string;
        SERVICEURL_GALBS_QUERY: string;
        SERVICEURL_LATENCY: string;
        SERVICEURL_LOGINQUEUE: string;
        SERVICEURL_MASS_REWARDS: string;
        SERVICEURL_MATCHDETAILS: string;
        SERVICEURL_MATCHHISTORY: string;
        SERVICEURL_MATCHMAKING: string;
        SERVICEURL_MMR: string;
        SERVICEURL_NAME: string;
        SERVICEURL_PARTY: string;
        SERVICEURL_PATCHNOTES: string;
        SERVICEURL_PERSONALIZATION: string;
        SERVICEURL_PLAYERFEEDBACK: string;
        SERVICEURL_PREGAME: string;
        SERVICEURL_PREMIER: string;
        SERVICEURL_PROGRESSION: string;
        SERVICEURL_PURCHASEMERCHANT: string;
        SERVICEURL_REPLAY_CATALOG: string;
        SERVICEURL_RESTRICTIONS: string;
        SERVICEURL_SESSION: string;
        SERVICEURL_STORE: string;
        SERVICEURL_TOURNAMENTS: string;
        SERVICE_TICKER_MESSAGE: string;
        "SERVICE_TICKER_MESSAGE.de-DE": string;
        "SERVICE_TICKER_MESSAGE.es-MX": string;
        "SERVICE_TICKER_MESSAGE.fr-FR": string;
        "SERVICE_TICKER_MESSAGE.it-IT": string;
        "SERVICE_TICKER_MESSAGE.pl-PL": string;
        "SERVICE_TICKER_MESSAGE.pt-BR": string;
        "SERVICE_TICKER_MESSAGE.ru-RU": string;
        "SERVICE_TICKER_MESSAGE.tr-TR": string;
        SERVICE_TICKER_SEVERITY: string;
        STORESCREEN_OFFERREFRESH_MAXDELAY_MILLISECONDS: string;
        "avs.enabled": string;
        "cap.location": string;
        "characterselect.debugwidgets.hide": string;
        "chat.mutedwords.enabled": string;
        "chat.v3.enabled": string;
        "collection.characters.enabled": string;
        competitiveSeasonOffsetEndTime: string;
        "config.client.telemetry.samplerate": string;
        "content.filter.enabled": string;
        "content.maps.disabled": string;
        "eog.wip": string;
        "friends.enabled": string;
        "game.umgchat.enabled": string;
        "homescreen.featuredQueues": string;
        "homescreen.patchnotes.baseURL": string;
        "homescreen.promo.enabled": string;
        "homescreen.promo.key": string;
        "homescreen.webtile.baseURL": string;
        "loginqueue.region": string;
        "mainmenubar.collections.enabled": string;
        "mainmenubar.debug.enabled": string;
        "mainmenubar.profile.enabled": string;
        "mainmenubar.progression.enabled": string;
        "mainmenubar.shootingrange.enabled": string;
        "mainmenubar.store.enabled": string;
        "match.details.delay": string;
        "notifications.enabled": string;
        "parties.auto.balance.enabled": string;
        "party.observers.enabled": string;
        "partyinvites.enabled": string;
        "patchavailability.enabled": string;
        "personalization.equipAnyLevel.enabled": string;
        "personalization.useWidePlayerIdentityV2": string;
        "ping.update.interval": string;
        "ping.useGamePodsFromParties": string;
        "platformFaulted.level": string;
        "playerfeedbacktool.accessurl": string;
        "playerfeedbacktool.locale": string;
        "playerfeedbacktool.shard": string;
        "playerfeedbacktool.show": string;
        "playerfeedbacktool.survey_request_rate_float": string;
        "playscreen.partywidget.enabled": string;
        "playscreen.partywidget.matchmaking.maxsize": string;
        "playscreen.premier.enabled": string;
        "premier.conferences.fetch.enabled": string;
        "premier.leaderboardTab.enabled": string;
        "premier.matchHistoryTab.enabled": string;
        "premier.playscreenflow.enabled": string;
        "premier.rosterEligibilityCheck.enabled": string;
        "premier.seasons.activeseason.enabled": string;
        "premier.seasons.fetch.enabled": string;
        "queue.status.enabled": string;
        "rchat.ingame.enabled": string;
        "reporterfeedback.fetch.enabled": string;
        "reporterfeedback.notifications.enabled": string;
        "restrictions.v2.fetch.enabled": string;
        "restrictions.v2.warnings.enabled": string;
        "riotwarning.fetch.enabled": string;
        "riotwarning.notifications.enabled": string;
        "rnet.useAuthenticatedVoice": string;
        "russia.voice.enabled": string;
        "settings.livediagnostics.allowedplayers": string;
        "shootingtest.enabled": string;
        "skillrating.enabled": string;
        "skillrating.inGame.enabled": string;
        "skillrating.preGame.enabled": string;
        "social.panel.v6.enabled": string;
        "socialviewcontroller.enabled": string;
        "socialviewcontroller.v2.enabled": string;
        "store.isXgpDisabled": string;
        "store.use_currency_inventory_models": string;
        "store.use_platform_bundle_discounted_prices": string;
        "telemetry.rtp.eventendpoint": string;
        "telemetry.rtp.rfc190scope": string;
        "temp.voice.allowmuting": string;
        "tournaments.enabled": string;
        "tournaments.pregame.enabled": string;
        "vanguard.accessurl": string;
        "vanguard.netrequired": string;
        "voice.clutchmute.enabled": string;
        "voice.clutchmute.prompt.enabled": string;
        "voice.provider": string;
        "whisper.enabled": string;
    }>;
}, "strip", z.ZodTypeAny, {
    LastApplication: Date;
    Collapsed: {
        ARES_MOC_ENTITLEMENT: string;
        "CLIENT.ICONS.ENABLED": boolean;
        CLIENT_LEADERBOARDS_ENABLED: boolean;
        GAME_ALLOW_CONSOLE: boolean;
        GAME_ALLOW_DEVELOPER_MENU: boolean;
        GAME_DISABLED_DEATHCAM: boolean;
        GAME_DISABLED_SKINS_WEAPONS: string[];
        GAME_PERFREPORTING_ENABLED: boolean;
        GAME_REMOTE_MOVE_INTERP_ENABLED: boolean;
        GAME_ROAMINGSETTINGS_ENABLED: boolean;
        GAME_ROAMINGSETTINGS_KEY: string;
        GAME_ROAMINGSETTINGS_STORAGEURL: string;
        MAP_PRELOADING_ENABLED: boolean;
        NAMECHECK_PLATFORM_REGION: string;
        NAMECHECK_PLATFORM_URL: string;
        ROSTER_REALM: string;
        SECURITY_WATERMARK_ENABLED: boolean;
        SECURITY_WATERMARK_MAX_OPACITY: number;
        SECURITY_WATERMARK_MIN_OPACITY: number;
        SECURITY_WATERMARK_TILING_FACTOR: number;
        SERVICEURL_ACCOUNT_XP: string;
        SERVICEURL_AGGSTATS: string;
        SERVICEURL_AVS: string;
        SERVICEURL_CONTENT: string;
        SERVICEURL_CONTRACTS: string;
        SERVICEURL_CONTRACT_DEFINITIONS: string;
        SERVICEURL_COREGAME: string;
        SERVICEURL_DAILY_TICKET: string;
        SERVICEURL_FAVORITES: string;
        SERVICEURL_GALBS_QUERY: string;
        SERVICEURL_LATENCY: string;
        SERVICEURL_LOGINQUEUE: string;
        SERVICEURL_MASS_REWARDS: string;
        SERVICEURL_MATCHDETAILS: string;
        SERVICEURL_MATCHHISTORY: string;
        SERVICEURL_MATCHMAKING: string;
        SERVICEURL_MMR: string;
        SERVICEURL_NAME: string;
        SERVICEURL_PARTY: string;
        SERVICEURL_PATCHNOTES: string;
        SERVICEURL_PERSONALIZATION: string;
        SERVICEURL_PLAYERFEEDBACK: string;
        SERVICEURL_PREGAME: string;
        SERVICEURL_PREMIER: string;
        SERVICEURL_PROGRESSION: string;
        SERVICEURL_PURCHASEMERCHANT: string;
        SERVICEURL_REPLAY_CATALOG: string;
        SERVICEURL_RESTRICTIONS: string;
        SERVICEURL_SESSION: string;
        SERVICEURL_STORE: string;
        SERVICEURL_TOURNAMENTS: string;
        SERVICE_TICKER_MESSAGE: string;
        "SERVICE_TICKER_MESSAGE.de-DE": string;
        "SERVICE_TICKER_MESSAGE.es-MX": string;
        "SERVICE_TICKER_MESSAGE.fr-FR": string;
        "SERVICE_TICKER_MESSAGE.it-IT": string;
        "SERVICE_TICKER_MESSAGE.pl-PL": string;
        "SERVICE_TICKER_MESSAGE.pt-BR": string;
        "SERVICE_TICKER_MESSAGE.ru-RU": string;
        "SERVICE_TICKER_MESSAGE.tr-TR": string;
        SERVICE_TICKER_SEVERITY: string;
        STORESCREEN_OFFERREFRESH_MAXDELAY_MILLISECONDS: number;
        "avs.enabled": boolean;
        "cap.location": string;
        "characterselect.debugwidgets.hide": boolean;
        "chat.mutedwords.enabled": boolean;
        "chat.v3.enabled": boolean;
        "collection.characters.enabled": boolean;
        competitiveSeasonOffsetEndTime: number;
        "config.client.telemetry.samplerate": number;
        "content.filter.enabled": boolean;
        "content.maps.disabled": string;
        "eog.wip": boolean;
        "friends.enabled": boolean;
        "game.umgchat.enabled": boolean;
        "homescreen.featuredQueues": string;
        "homescreen.patchnotes.baseURL": string;
        "homescreen.promo.enabled": boolean;
        "homescreen.promo.key": string;
        "homescreen.webtile.baseURL": string;
        "loginqueue.region": string;
        "mainmenubar.collections.enabled": boolean;
        "mainmenubar.debug.enabled": boolean;
        "mainmenubar.profile.enabled": boolean;
        "mainmenubar.progression.enabled": boolean;
        "mainmenubar.shootingrange.enabled": boolean;
        "mainmenubar.store.enabled": boolean;
        "match.details.delay": number;
        "notifications.enabled": boolean;
        "parties.auto.balance.enabled": boolean;
        "party.observers.enabled": boolean;
        "partyinvites.enabled": boolean;
        "patchavailability.enabled": boolean;
        "personalization.equipAnyLevel.enabled": boolean;
        "personalization.useWidePlayerIdentityV2": boolean;
        "ping.update.interval": number;
        "ping.useGamePodsFromParties": boolean;
        "platformFaulted.level": string;
        "playerfeedbacktool.accessurl": string;
        "playerfeedbacktool.locale": string;
        "playerfeedbacktool.shard": string;
        "playerfeedbacktool.show": boolean;
        "playerfeedbacktool.survey_request_rate_float": number;
        "playscreen.partywidget.enabled": boolean;
        "playscreen.partywidget.matchmaking.maxsize": number;
        "playscreen.premier.enabled": boolean;
        "premier.conferences.fetch.enabled": boolean;
        "premier.leaderboardTab.enabled": boolean;
        "premier.matchHistoryTab.enabled": boolean;
        "premier.playscreenflow.enabled": boolean;
        "premier.rosterEligibilityCheck.enabled": boolean;
        "premier.seasons.activeseason.enabled": boolean;
        "premier.seasons.fetch.enabled": boolean;
        "queue.status.enabled": boolean;
        "rchat.ingame.enabled": boolean;
        "reporterfeedback.fetch.enabled": boolean;
        "reporterfeedback.notifications.enabled": boolean;
        "restrictions.v2.fetch.enabled": boolean;
        "restrictions.v2.warnings.enabled": boolean;
        "riotwarning.fetch.enabled": boolean;
        "riotwarning.notifications.enabled": boolean;
        "rnet.useAuthenticatedVoice": boolean;
        "russia.voice.enabled": boolean;
        "settings.livediagnostics.allowedplayers": string[];
        "shootingtest.enabled": boolean;
        "skillrating.enabled": boolean;
        "skillrating.inGame.enabled": boolean;
        "skillrating.preGame.enabled": boolean;
        "social.panel.v6.enabled": boolean;
        "socialviewcontroller.enabled": boolean;
        "socialviewcontroller.v2.enabled": boolean;
        "store.isXgpDisabled": boolean;
        "store.use_currency_inventory_models": boolean;
        "store.use_platform_bundle_discounted_prices": boolean;
        "telemetry.rtp.eventendpoint": string;
        "telemetry.rtp.rfc190scope": string;
        "temp.voice.allowmuting": boolean;
        "tournaments.enabled": boolean;
        "tournaments.pregame.enabled": boolean;
        "vanguard.accessurl": string;
        "vanguard.netrequired": boolean;
        "voice.clutchmute.enabled": boolean;
        "voice.clutchmute.prompt.enabled": boolean;
        "voice.provider": string;
        "whisper.enabled": boolean;
    };
}, {
    LastApplication: string;
    Collapsed: {
        ARES_MOC_ENTITLEMENT: string;
        "CLIENT.ICONS.ENABLED": string;
        CLIENT_LEADERBOARDS_ENABLED: string;
        GAME_ALLOW_CONSOLE: string;
        GAME_ALLOW_DEVELOPER_MENU: string;
        GAME_DISABLED_DEATHCAM: string;
        GAME_DISABLED_SKINS_WEAPONS: string;
        GAME_PERFREPORTING_ENABLED: string;
        GAME_REMOTE_MOVE_INTERP_ENABLED: string;
        GAME_ROAMINGSETTINGS_ENABLED: string;
        GAME_ROAMINGSETTINGS_KEY: string;
        GAME_ROAMINGSETTINGS_STORAGEURL: string;
        MAP_PRELOADING_ENABLED: string;
        NAMECHECK_PLATFORM_REGION: string;
        NAMECHECK_PLATFORM_URL: string;
        ROSTER_REALM: string;
        SECURITY_WATERMARK_ENABLED: string;
        SECURITY_WATERMARK_MAX_OPACITY: string;
        SECURITY_WATERMARK_MIN_OPACITY: string;
        SECURITY_WATERMARK_TILING_FACTOR: string;
        SERVICEURL_ACCOUNT_XP: string;
        SERVICEURL_AGGSTATS: string;
        SERVICEURL_AVS: string;
        SERVICEURL_CONTENT: string;
        SERVICEURL_CONTRACTS: string;
        SERVICEURL_CONTRACT_DEFINITIONS: string;
        SERVICEURL_COREGAME: string;
        SERVICEURL_DAILY_TICKET: string;
        SERVICEURL_FAVORITES: string;
        SERVICEURL_GALBS_QUERY: string;
        SERVICEURL_LATENCY: string;
        SERVICEURL_LOGINQUEUE: string;
        SERVICEURL_MASS_REWARDS: string;
        SERVICEURL_MATCHDETAILS: string;
        SERVICEURL_MATCHHISTORY: string;
        SERVICEURL_MATCHMAKING: string;
        SERVICEURL_MMR: string;
        SERVICEURL_NAME: string;
        SERVICEURL_PARTY: string;
        SERVICEURL_PATCHNOTES: string;
        SERVICEURL_PERSONALIZATION: string;
        SERVICEURL_PLAYERFEEDBACK: string;
        SERVICEURL_PREGAME: string;
        SERVICEURL_PREMIER: string;
        SERVICEURL_PROGRESSION: string;
        SERVICEURL_PURCHASEMERCHANT: string;
        SERVICEURL_REPLAY_CATALOG: string;
        SERVICEURL_RESTRICTIONS: string;
        SERVICEURL_SESSION: string;
        SERVICEURL_STORE: string;
        SERVICEURL_TOURNAMENTS: string;
        SERVICE_TICKER_MESSAGE: string;
        "SERVICE_TICKER_MESSAGE.de-DE": string;
        "SERVICE_TICKER_MESSAGE.es-MX": string;
        "SERVICE_TICKER_MESSAGE.fr-FR": string;
        "SERVICE_TICKER_MESSAGE.it-IT": string;
        "SERVICE_TICKER_MESSAGE.pl-PL": string;
        "SERVICE_TICKER_MESSAGE.pt-BR": string;
        "SERVICE_TICKER_MESSAGE.ru-RU": string;
        "SERVICE_TICKER_MESSAGE.tr-TR": string;
        SERVICE_TICKER_SEVERITY: string;
        STORESCREEN_OFFERREFRESH_MAXDELAY_MILLISECONDS: string;
        "avs.enabled": string;
        "cap.location": string;
        "characterselect.debugwidgets.hide": string;
        "chat.mutedwords.enabled": string;
        "chat.v3.enabled": string;
        "collection.characters.enabled": string;
        competitiveSeasonOffsetEndTime: string;
        "config.client.telemetry.samplerate": string;
        "content.filter.enabled": string;
        "content.maps.disabled": string;
        "eog.wip": string;
        "friends.enabled": string;
        "game.umgchat.enabled": string;
        "homescreen.featuredQueues": string;
        "homescreen.patchnotes.baseURL": string;
        "homescreen.promo.enabled": string;
        "homescreen.promo.key": string;
        "homescreen.webtile.baseURL": string;
        "loginqueue.region": string;
        "mainmenubar.collections.enabled": string;
        "mainmenubar.debug.enabled": string;
        "mainmenubar.profile.enabled": string;
        "mainmenubar.progression.enabled": string;
        "mainmenubar.shootingrange.enabled": string;
        "mainmenubar.store.enabled": string;
        "match.details.delay": string;
        "notifications.enabled": string;
        "parties.auto.balance.enabled": string;
        "party.observers.enabled": string;
        "partyinvites.enabled": string;
        "patchavailability.enabled": string;
        "personalization.equipAnyLevel.enabled": string;
        "personalization.useWidePlayerIdentityV2": string;
        "ping.update.interval": string;
        "ping.useGamePodsFromParties": string;
        "platformFaulted.level": string;
        "playerfeedbacktool.accessurl": string;
        "playerfeedbacktool.locale": string;
        "playerfeedbacktool.shard": string;
        "playerfeedbacktool.show": string;
        "playerfeedbacktool.survey_request_rate_float": string;
        "playscreen.partywidget.enabled": string;
        "playscreen.partywidget.matchmaking.maxsize": string;
        "playscreen.premier.enabled": string;
        "premier.conferences.fetch.enabled": string;
        "premier.leaderboardTab.enabled": string;
        "premier.matchHistoryTab.enabled": string;
        "premier.playscreenflow.enabled": string;
        "premier.rosterEligibilityCheck.enabled": string;
        "premier.seasons.activeseason.enabled": string;
        "premier.seasons.fetch.enabled": string;
        "queue.status.enabled": string;
        "rchat.ingame.enabled": string;
        "reporterfeedback.fetch.enabled": string;
        "reporterfeedback.notifications.enabled": string;
        "restrictions.v2.fetch.enabled": string;
        "restrictions.v2.warnings.enabled": string;
        "riotwarning.fetch.enabled": string;
        "riotwarning.notifications.enabled": string;
        "rnet.useAuthenticatedVoice": string;
        "russia.voice.enabled": string;
        "settings.livediagnostics.allowedplayers": string;
        "shootingtest.enabled": string;
        "skillrating.enabled": string;
        "skillrating.inGame.enabled": string;
        "skillrating.preGame.enabled": string;
        "social.panel.v6.enabled": string;
        "socialviewcontroller.enabled": string;
        "socialviewcontroller.v2.enabled": string;
        "store.isXgpDisabled": string;
        "store.use_currency_inventory_models": string;
        "store.use_platform_bundle_discounted_prices": string;
        "telemetry.rtp.eventendpoint": string;
        "telemetry.rtp.rfc190scope": string;
        "temp.voice.allowmuting": string;
        "tournaments.enabled": string;
        "tournaments.pregame.enabled": string;
        "vanguard.accessurl": string;
        "vanguard.netrequired": string;
        "voice.clutchmute.enabled": string;
        "voice.clutchmute.prompt.enabled": string;
        "voice.provider": string;
        "whisper.enabled": string;
    };
}>;
declare const _default$E: Omit<{
    requirements: string[];
    type: "auth" | "local" | "pd" | "glz" | "shared";
    name: string;
    method: "PUT" | "GET" | "DELETE" | "POST";
    url: string;
    description?: string | undefined;
    headers?: Record<string, string> | undefined;
    body?: z.ZodType<any, z.ZodTypeDef, any> | undefined;
    query?: z.ZodType<any, z.ZodTypeDef, any> | undefined;
    responses?: Record<string, z.ZodType<any, z.ZodTypeDef, any>> | undefined;
}, "type" | "name" | "url"> & Pick<{
    readonly name: "Config";
    readonly description: "Get the config for the given player";
    readonly type: "pd";
    readonly url: "v1/config/:region";
    readonly responses: {
        readonly "200": z.ZodObject<{
            LastApplication: z.ZodEffects<z.ZodString, Date, string>;
            Collapsed: z.ZodObject<{
                ARES_MOC_ENTITLEMENT: z.ZodString;
                "CLIENT.ICONS.ENABLED": z.ZodEffects<z.ZodString, boolean, string>;
                CLIENT_LEADERBOARDS_ENABLED: z.ZodEffects<z.ZodString, boolean, string>;
                GAME_ALLOW_CONSOLE: z.ZodEffects<z.ZodString, boolean, string>;
                GAME_ALLOW_DEVELOPER_MENU: z.ZodEffects<z.ZodString, boolean, string>;
                GAME_DISABLED_DEATHCAM: z.ZodEffects<z.ZodString, boolean, string>;
                GAME_DISABLED_SKINS_WEAPONS: z.ZodEffects<z.ZodString, string[], string>;
                GAME_PERFREPORTING_ENABLED: z.ZodEffects<z.ZodString, boolean, string>;
                GAME_REMOTE_MOVE_INTERP_ENABLED: z.ZodEffects<z.ZodString, boolean, string>;
                GAME_ROAMINGSETTINGS_ENABLED: z.ZodEffects<z.ZodString, boolean, string>;
                GAME_ROAMINGSETTINGS_KEY: z.ZodString;
                GAME_ROAMINGSETTINGS_STORAGEURL: z.ZodString;
                MAP_PRELOADING_ENABLED: z.ZodEffects<z.ZodString, boolean, string>;
                NAMECHECK_PLATFORM_REGION: z.ZodString;
                NAMECHECK_PLATFORM_URL: z.ZodString;
                ROSTER_REALM: z.ZodString;
                SECURITY_WATERMARK_ENABLED: z.ZodEffects<z.ZodString, boolean, string>;
                SECURITY_WATERMARK_MAX_OPACITY: z.ZodEffects<z.ZodString, number, string>;
                SECURITY_WATERMARK_MIN_OPACITY: z.ZodEffects<z.ZodString, number, string>;
                SECURITY_WATERMARK_TILING_FACTOR: z.ZodEffects<z.ZodString, number, string>;
                SERVICEURL_ACCOUNT_XP: z.ZodString;
                SERVICEURL_AGGSTATS: z.ZodString;
                SERVICEURL_AVS: z.ZodString;
                SERVICEURL_CONTENT: z.ZodString;
                SERVICEURL_CONTRACTS: z.ZodString;
                SERVICEURL_CONTRACT_DEFINITIONS: z.ZodString;
                SERVICEURL_COREGAME: z.ZodString;
                SERVICEURL_DAILY_TICKET: z.ZodString;
                SERVICEURL_FAVORITES: z.ZodString;
                SERVICEURL_GALBS_QUERY: z.ZodString;
                SERVICEURL_LATENCY: z.ZodString;
                SERVICEURL_LOGINQUEUE: z.ZodString;
                SERVICEURL_MASS_REWARDS: z.ZodString;
                SERVICEURL_MATCHDETAILS: z.ZodString;
                SERVICEURL_MATCHHISTORY: z.ZodString;
                SERVICEURL_MATCHMAKING: z.ZodString;
                SERVICEURL_MMR: z.ZodString;
                SERVICEURL_NAME: z.ZodString;
                SERVICEURL_PARTY: z.ZodString;
                SERVICEURL_PATCHNOTES: z.ZodString;
                SERVICEURL_PERSONALIZATION: z.ZodString;
                SERVICEURL_PLAYERFEEDBACK: z.ZodString;
                SERVICEURL_PREGAME: z.ZodString;
                SERVICEURL_PREMIER: z.ZodString;
                SERVICEURL_PROGRESSION: z.ZodString;
                SERVICEURL_PURCHASEMERCHANT: z.ZodString;
                SERVICEURL_REPLAY_CATALOG: z.ZodString;
                SERVICEURL_RESTRICTIONS: z.ZodString;
                SERVICEURL_SESSION: z.ZodString;
                SERVICEURL_STORE: z.ZodString;
                SERVICEURL_TOURNAMENTS: z.ZodString;
                SERVICE_TICKER_MESSAGE: z.ZodString;
                "SERVICE_TICKER_MESSAGE.de-DE": z.ZodString;
                "SERVICE_TICKER_MESSAGE.es-MX": z.ZodString;
                "SERVICE_TICKER_MESSAGE.fr-FR": z.ZodString;
                "SERVICE_TICKER_MESSAGE.it-IT": z.ZodString;
                "SERVICE_TICKER_MESSAGE.pl-PL": z.ZodString;
                "SERVICE_TICKER_MESSAGE.pt-BR": z.ZodString;
                "SERVICE_TICKER_MESSAGE.ru-RU": z.ZodString;
                "SERVICE_TICKER_MESSAGE.tr-TR": z.ZodString;
                SERVICE_TICKER_SEVERITY: z.ZodString;
                STORESCREEN_OFFERREFRESH_MAXDELAY_MILLISECONDS: z.ZodEffects<z.ZodString, number, string>;
                "avs.enabled": z.ZodEffects<z.ZodString, boolean, string>;
                "cap.location": z.ZodString;
                "characterselect.debugwidgets.hide": z.ZodEffects<z.ZodString, boolean, string>;
                "chat.mutedwords.enabled": z.ZodEffects<z.ZodString, boolean, string>;
                "chat.v3.enabled": z.ZodEffects<z.ZodString, boolean, string>;
                "collection.characters.enabled": z.ZodEffects<z.ZodString, boolean, string>;
                competitiveSeasonOffsetEndTime: z.ZodEffects<z.ZodString, number, string>;
                "config.client.telemetry.samplerate": z.ZodEffects<z.ZodString, number, string>;
                "content.filter.enabled": z.ZodEffects<z.ZodString, boolean, string>;
                "content.maps.disabled": z.ZodString;
                "eog.wip": z.ZodEffects<z.ZodString, boolean, string>;
                "friends.enabled": z.ZodEffects<z.ZodString, boolean, string>;
                "game.umgchat.enabled": z.ZodEffects<z.ZodString, boolean, string>;
                "homescreen.featuredQueues": z.ZodString;
                "homescreen.patchnotes.baseURL": z.ZodString;
                "homescreen.promo.enabled": z.ZodEffects<z.ZodString, boolean, string>;
                "homescreen.promo.key": z.ZodString;
                "homescreen.webtile.baseURL": z.ZodString;
                "loginqueue.region": z.ZodString;
                "mainmenubar.collections.enabled": z.ZodEffects<z.ZodString, boolean, string>;
                "mainmenubar.debug.enabled": z.ZodEffects<z.ZodString, boolean, string>;
                "mainmenubar.profile.enabled": z.ZodEffects<z.ZodString, boolean, string>;
                "mainmenubar.progression.enabled": z.ZodEffects<z.ZodString, boolean, string>;
                "mainmenubar.shootingrange.enabled": z.ZodEffects<z.ZodString, boolean, string>;
                "mainmenubar.store.enabled": z.ZodEffects<z.ZodString, boolean, string>;
                "match.details.delay": z.ZodEffects<z.ZodString, number, string>;
                "notifications.enabled": z.ZodEffects<z.ZodString, boolean, string>;
                "parties.auto.balance.enabled": z.ZodEffects<z.ZodString, boolean, string>;
                "party.observers.enabled": z.ZodEffects<z.ZodString, boolean, string>;
                "partyinvites.enabled": z.ZodEffects<z.ZodString, boolean, string>;
                "patchavailability.enabled": z.ZodEffects<z.ZodString, boolean, string>;
                "personalization.equipAnyLevel.enabled": z.ZodEffects<z.ZodString, boolean, string>;
                "personalization.useWidePlayerIdentityV2": z.ZodEffects<z.ZodString, boolean, string>;
                "ping.update.interval": z.ZodEffects<z.ZodString, number, string>;
                "ping.useGamePodsFromParties": z.ZodEffects<z.ZodString, boolean, string>;
                "platformFaulted.level": z.ZodString;
                "playerfeedbacktool.accessurl": z.ZodString;
                "playerfeedbacktool.locale": z.ZodString;
                "playerfeedbacktool.shard": z.ZodString;
                "playerfeedbacktool.show": z.ZodEffects<z.ZodString, boolean, string>;
                "playerfeedbacktool.survey_request_rate_float": z.ZodEffects<z.ZodString, number, string>;
                "playscreen.partywidget.enabled": z.ZodEffects<z.ZodString, boolean, string>;
                "playscreen.partywidget.matchmaking.maxsize": z.ZodEffects<z.ZodString, number, string>;
                "playscreen.premier.enabled": z.ZodEffects<z.ZodString, boolean, string>;
                "premier.conferences.fetch.enabled": z.ZodEffects<z.ZodString, boolean, string>;
                "premier.leaderboardTab.enabled": z.ZodEffects<z.ZodString, boolean, string>;
                "premier.matchHistoryTab.enabled": z.ZodEffects<z.ZodString, boolean, string>;
                "premier.playscreenflow.enabled": z.ZodEffects<z.ZodString, boolean, string>;
                "premier.rosterEligibilityCheck.enabled": z.ZodEffects<z.ZodString, boolean, string>;
                "premier.seasons.activeseason.enabled": z.ZodEffects<z.ZodString, boolean, string>;
                "premier.seasons.fetch.enabled": z.ZodEffects<z.ZodString, boolean, string>;
                "queue.status.enabled": z.ZodEffects<z.ZodString, boolean, string>;
                "rchat.ingame.enabled": z.ZodEffects<z.ZodString, boolean, string>;
                "reporterfeedback.fetch.enabled": z.ZodEffects<z.ZodString, boolean, string>;
                "reporterfeedback.notifications.enabled": z.ZodEffects<z.ZodString, boolean, string>;
                "restrictions.v2.fetch.enabled": z.ZodEffects<z.ZodString, boolean, string>;
                "restrictions.v2.warnings.enabled": z.ZodEffects<z.ZodString, boolean, string>;
                "riotwarning.fetch.enabled": z.ZodEffects<z.ZodString, boolean, string>;
                "riotwarning.notifications.enabled": z.ZodEffects<z.ZodString, boolean, string>;
                "rnet.useAuthenticatedVoice": z.ZodEffects<z.ZodString, boolean, string>;
                "russia.voice.enabled": z.ZodEffects<z.ZodString, boolean, string>;
                "settings.livediagnostics.allowedplayers": z.ZodEffects<z.ZodString, string[], string>;
                "shootingtest.enabled": z.ZodEffects<z.ZodString, boolean, string>;
                "skillrating.enabled": z.ZodEffects<z.ZodString, boolean, string>;
                "skillrating.inGame.enabled": z.ZodEffects<z.ZodString, boolean, string>;
                "skillrating.preGame.enabled": z.ZodEffects<z.ZodString, boolean, string>;
                "social.panel.v6.enabled": z.ZodEffects<z.ZodString, boolean, string>;
                "socialviewcontroller.enabled": z.ZodEffects<z.ZodString, boolean, string>;
                "socialviewcontroller.v2.enabled": z.ZodEffects<z.ZodString, boolean, string>;
                "store.isXgpDisabled": z.ZodEffects<z.ZodString, boolean, string>;
                "store.use_currency_inventory_models": z.ZodEffects<z.ZodString, boolean, string>;
                "store.use_platform_bundle_discounted_prices": z.ZodEffects<z.ZodString, boolean, string>;
                "telemetry.rtp.eventendpoint": z.ZodString;
                "telemetry.rtp.rfc190scope": z.ZodString;
                "temp.voice.allowmuting": z.ZodEffects<z.ZodString, boolean, string>;
                "tournaments.enabled": z.ZodEffects<z.ZodString, boolean, string>;
                "tournaments.pregame.enabled": z.ZodEffects<z.ZodString, boolean, string>;
                "vanguard.accessurl": z.ZodString;
                "vanguard.netrequired": z.ZodEffects<z.ZodString, boolean, string>;
                "voice.clutchmute.enabled": z.ZodEffects<z.ZodString, boolean, string>;
                "voice.clutchmute.prompt.enabled": z.ZodEffects<z.ZodString, boolean, string>;
                "voice.provider": z.ZodString;
                "whisper.enabled": z.ZodEffects<z.ZodString, boolean, string>;
            }, "strip", z.ZodTypeAny, {
                ARES_MOC_ENTITLEMENT: string;
                "CLIENT.ICONS.ENABLED": boolean;
                CLIENT_LEADERBOARDS_ENABLED: boolean;
                GAME_ALLOW_CONSOLE: boolean;
                GAME_ALLOW_DEVELOPER_MENU: boolean;
                GAME_DISABLED_DEATHCAM: boolean;
                GAME_DISABLED_SKINS_WEAPONS: string[];
                GAME_PERFREPORTING_ENABLED: boolean;
                GAME_REMOTE_MOVE_INTERP_ENABLED: boolean;
                GAME_ROAMINGSETTINGS_ENABLED: boolean;
                GAME_ROAMINGSETTINGS_KEY: string;
                GAME_ROAMINGSETTINGS_STORAGEURL: string;
                MAP_PRELOADING_ENABLED: boolean;
                NAMECHECK_PLATFORM_REGION: string;
                NAMECHECK_PLATFORM_URL: string;
                ROSTER_REALM: string;
                SECURITY_WATERMARK_ENABLED: boolean;
                SECURITY_WATERMARK_MAX_OPACITY: number;
                SECURITY_WATERMARK_MIN_OPACITY: number;
                SECURITY_WATERMARK_TILING_FACTOR: number;
                SERVICEURL_ACCOUNT_XP: string;
                SERVICEURL_AGGSTATS: string;
                SERVICEURL_AVS: string;
                SERVICEURL_CONTENT: string;
                SERVICEURL_CONTRACTS: string;
                SERVICEURL_CONTRACT_DEFINITIONS: string;
                SERVICEURL_COREGAME: string;
                SERVICEURL_DAILY_TICKET: string;
                SERVICEURL_FAVORITES: string;
                SERVICEURL_GALBS_QUERY: string;
                SERVICEURL_LATENCY: string;
                SERVICEURL_LOGINQUEUE: string;
                SERVICEURL_MASS_REWARDS: string;
                SERVICEURL_MATCHDETAILS: string;
                SERVICEURL_MATCHHISTORY: string;
                SERVICEURL_MATCHMAKING: string;
                SERVICEURL_MMR: string;
                SERVICEURL_NAME: string;
                SERVICEURL_PARTY: string;
                SERVICEURL_PATCHNOTES: string;
                SERVICEURL_PERSONALIZATION: string;
                SERVICEURL_PLAYERFEEDBACK: string;
                SERVICEURL_PREGAME: string;
                SERVICEURL_PREMIER: string;
                SERVICEURL_PROGRESSION: string;
                SERVICEURL_PURCHASEMERCHANT: string;
                SERVICEURL_REPLAY_CATALOG: string;
                SERVICEURL_RESTRICTIONS: string;
                SERVICEURL_SESSION: string;
                SERVICEURL_STORE: string;
                SERVICEURL_TOURNAMENTS: string;
                SERVICE_TICKER_MESSAGE: string;
                "SERVICE_TICKER_MESSAGE.de-DE": string;
                "SERVICE_TICKER_MESSAGE.es-MX": string;
                "SERVICE_TICKER_MESSAGE.fr-FR": string;
                "SERVICE_TICKER_MESSAGE.it-IT": string;
                "SERVICE_TICKER_MESSAGE.pl-PL": string;
                "SERVICE_TICKER_MESSAGE.pt-BR": string;
                "SERVICE_TICKER_MESSAGE.ru-RU": string;
                "SERVICE_TICKER_MESSAGE.tr-TR": string;
                SERVICE_TICKER_SEVERITY: string;
                STORESCREEN_OFFERREFRESH_MAXDELAY_MILLISECONDS: number;
                "avs.enabled": boolean;
                "cap.location": string;
                "characterselect.debugwidgets.hide": boolean;
                "chat.mutedwords.enabled": boolean;
                "chat.v3.enabled": boolean;
                "collection.characters.enabled": boolean;
                competitiveSeasonOffsetEndTime: number;
                "config.client.telemetry.samplerate": number;
                "content.filter.enabled": boolean;
                "content.maps.disabled": string;
                "eog.wip": boolean;
                "friends.enabled": boolean;
                "game.umgchat.enabled": boolean;
                "homescreen.featuredQueues": string;
                "homescreen.patchnotes.baseURL": string;
                "homescreen.promo.enabled": boolean;
                "homescreen.promo.key": string;
                "homescreen.webtile.baseURL": string;
                "loginqueue.region": string;
                "mainmenubar.collections.enabled": boolean;
                "mainmenubar.debug.enabled": boolean;
                "mainmenubar.profile.enabled": boolean;
                "mainmenubar.progression.enabled": boolean;
                "mainmenubar.shootingrange.enabled": boolean;
                "mainmenubar.store.enabled": boolean;
                "match.details.delay": number;
                "notifications.enabled": boolean;
                "parties.auto.balance.enabled": boolean;
                "party.observers.enabled": boolean;
                "partyinvites.enabled": boolean;
                "patchavailability.enabled": boolean;
                "personalization.equipAnyLevel.enabled": boolean;
                "personalization.useWidePlayerIdentityV2": boolean;
                "ping.update.interval": number;
                "ping.useGamePodsFromParties": boolean;
                "platformFaulted.level": string;
                "playerfeedbacktool.accessurl": string;
                "playerfeedbacktool.locale": string;
                "playerfeedbacktool.shard": string;
                "playerfeedbacktool.show": boolean;
                "playerfeedbacktool.survey_request_rate_float": number;
                "playscreen.partywidget.enabled": boolean;
                "playscreen.partywidget.matchmaking.maxsize": number;
                "playscreen.premier.enabled": boolean;
                "premier.conferences.fetch.enabled": boolean;
                "premier.leaderboardTab.enabled": boolean;
                "premier.matchHistoryTab.enabled": boolean;
                "premier.playscreenflow.enabled": boolean;
                "premier.rosterEligibilityCheck.enabled": boolean;
                "premier.seasons.activeseason.enabled": boolean;
                "premier.seasons.fetch.enabled": boolean;
                "queue.status.enabled": boolean;
                "rchat.ingame.enabled": boolean;
                "reporterfeedback.fetch.enabled": boolean;
                "reporterfeedback.notifications.enabled": boolean;
                "restrictions.v2.fetch.enabled": boolean;
                "restrictions.v2.warnings.enabled": boolean;
                "riotwarning.fetch.enabled": boolean;
                "riotwarning.notifications.enabled": boolean;
                "rnet.useAuthenticatedVoice": boolean;
                "russia.voice.enabled": boolean;
                "settings.livediagnostics.allowedplayers": string[];
                "shootingtest.enabled": boolean;
                "skillrating.enabled": boolean;
                "skillrating.inGame.enabled": boolean;
                "skillrating.preGame.enabled": boolean;
                "social.panel.v6.enabled": boolean;
                "socialviewcontroller.enabled": boolean;
                "socialviewcontroller.v2.enabled": boolean;
                "store.isXgpDisabled": boolean;
                "store.use_currency_inventory_models": boolean;
                "store.use_platform_bundle_discounted_prices": boolean;
                "telemetry.rtp.eventendpoint": string;
                "telemetry.rtp.rfc190scope": string;
                "temp.voice.allowmuting": boolean;
                "tournaments.enabled": boolean;
                "tournaments.pregame.enabled": boolean;
                "vanguard.accessurl": string;
                "vanguard.netrequired": boolean;
                "voice.clutchmute.enabled": boolean;
                "voice.clutchmute.prompt.enabled": boolean;
                "voice.provider": string;
                "whisper.enabled": boolean;
            }, {
                ARES_MOC_ENTITLEMENT: string;
                "CLIENT.ICONS.ENABLED": string;
                CLIENT_LEADERBOARDS_ENABLED: string;
                GAME_ALLOW_CONSOLE: string;
                GAME_ALLOW_DEVELOPER_MENU: string;
                GAME_DISABLED_DEATHCAM: string;
                GAME_DISABLED_SKINS_WEAPONS: string;
                GAME_PERFREPORTING_ENABLED: string;
                GAME_REMOTE_MOVE_INTERP_ENABLED: string;
                GAME_ROAMINGSETTINGS_ENABLED: string;
                GAME_ROAMINGSETTINGS_KEY: string;
                GAME_ROAMINGSETTINGS_STORAGEURL: string;
                MAP_PRELOADING_ENABLED: string;
                NAMECHECK_PLATFORM_REGION: string;
                NAMECHECK_PLATFORM_URL: string;
                ROSTER_REALM: string;
                SECURITY_WATERMARK_ENABLED: string;
                SECURITY_WATERMARK_MAX_OPACITY: string;
                SECURITY_WATERMARK_MIN_OPACITY: string;
                SECURITY_WATERMARK_TILING_FACTOR: string;
                SERVICEURL_ACCOUNT_XP: string;
                SERVICEURL_AGGSTATS: string;
                SERVICEURL_AVS: string;
                SERVICEURL_CONTENT: string;
                SERVICEURL_CONTRACTS: string;
                SERVICEURL_CONTRACT_DEFINITIONS: string;
                SERVICEURL_COREGAME: string;
                SERVICEURL_DAILY_TICKET: string;
                SERVICEURL_FAVORITES: string;
                SERVICEURL_GALBS_QUERY: string;
                SERVICEURL_LATENCY: string;
                SERVICEURL_LOGINQUEUE: string;
                SERVICEURL_MASS_REWARDS: string;
                SERVICEURL_MATCHDETAILS: string;
                SERVICEURL_MATCHHISTORY: string;
                SERVICEURL_MATCHMAKING: string;
                SERVICEURL_MMR: string;
                SERVICEURL_NAME: string;
                SERVICEURL_PARTY: string;
                SERVICEURL_PATCHNOTES: string;
                SERVICEURL_PERSONALIZATION: string;
                SERVICEURL_PLAYERFEEDBACK: string;
                SERVICEURL_PREGAME: string;
                SERVICEURL_PREMIER: string;
                SERVICEURL_PROGRESSION: string;
                SERVICEURL_PURCHASEMERCHANT: string;
                SERVICEURL_REPLAY_CATALOG: string;
                SERVICEURL_RESTRICTIONS: string;
                SERVICEURL_SESSION: string;
                SERVICEURL_STORE: string;
                SERVICEURL_TOURNAMENTS: string;
                SERVICE_TICKER_MESSAGE: string;
                "SERVICE_TICKER_MESSAGE.de-DE": string;
                "SERVICE_TICKER_MESSAGE.es-MX": string;
                "SERVICE_TICKER_MESSAGE.fr-FR": string;
                "SERVICE_TICKER_MESSAGE.it-IT": string;
                "SERVICE_TICKER_MESSAGE.pl-PL": string;
                "SERVICE_TICKER_MESSAGE.pt-BR": string;
                "SERVICE_TICKER_MESSAGE.ru-RU": string;
                "SERVICE_TICKER_MESSAGE.tr-TR": string;
                SERVICE_TICKER_SEVERITY: string;
                STORESCREEN_OFFERREFRESH_MAXDELAY_MILLISECONDS: string;
                "avs.enabled": string;
                "cap.location": string;
                "characterselect.debugwidgets.hide": string;
                "chat.mutedwords.enabled": string;
                "chat.v3.enabled": string;
                "collection.characters.enabled": string;
                competitiveSeasonOffsetEndTime: string;
                "config.client.telemetry.samplerate": string;
                "content.filter.enabled": string;
                "content.maps.disabled": string;
                "eog.wip": string;
                "friends.enabled": string;
                "game.umgchat.enabled": string;
                "homescreen.featuredQueues": string;
                "homescreen.patchnotes.baseURL": string;
                "homescreen.promo.enabled": string;
                "homescreen.promo.key": string;
                "homescreen.webtile.baseURL": string;
                "loginqueue.region": string;
                "mainmenubar.collections.enabled": string;
                "mainmenubar.debug.enabled": string;
                "mainmenubar.profile.enabled": string;
                "mainmenubar.progression.enabled": string;
                "mainmenubar.shootingrange.enabled": string;
                "mainmenubar.store.enabled": string;
                "match.details.delay": string;
                "notifications.enabled": string;
                "parties.auto.balance.enabled": string;
                "party.observers.enabled": string;
                "partyinvites.enabled": string;
                "patchavailability.enabled": string;
                "personalization.equipAnyLevel.enabled": string;
                "personalization.useWidePlayerIdentityV2": string;
                "ping.update.interval": string;
                "ping.useGamePodsFromParties": string;
                "platformFaulted.level": string;
                "playerfeedbacktool.accessurl": string;
                "playerfeedbacktool.locale": string;
                "playerfeedbacktool.shard": string;
                "playerfeedbacktool.show": string;
                "playerfeedbacktool.survey_request_rate_float": string;
                "playscreen.partywidget.enabled": string;
                "playscreen.partywidget.matchmaking.maxsize": string;
                "playscreen.premier.enabled": string;
                "premier.conferences.fetch.enabled": string;
                "premier.leaderboardTab.enabled": string;
                "premier.matchHistoryTab.enabled": string;
                "premier.playscreenflow.enabled": string;
                "premier.rosterEligibilityCheck.enabled": string;
                "premier.seasons.activeseason.enabled": string;
                "premier.seasons.fetch.enabled": string;
                "queue.status.enabled": string;
                "rchat.ingame.enabled": string;
                "reporterfeedback.fetch.enabled": string;
                "reporterfeedback.notifications.enabled": string;
                "restrictions.v2.fetch.enabled": string;
                "restrictions.v2.warnings.enabled": string;
                "riotwarning.fetch.enabled": string;
                "riotwarning.notifications.enabled": string;
                "rnet.useAuthenticatedVoice": string;
                "russia.voice.enabled": string;
                "settings.livediagnostics.allowedplayers": string;
                "shootingtest.enabled": string;
                "skillrating.enabled": string;
                "skillrating.inGame.enabled": string;
                "skillrating.preGame.enabled": string;
                "social.panel.v6.enabled": string;
                "socialviewcontroller.enabled": string;
                "socialviewcontroller.v2.enabled": string;
                "store.isXgpDisabled": string;
                "store.use_currency_inventory_models": string;
                "store.use_platform_bundle_discounted_prices": string;
                "telemetry.rtp.eventendpoint": string;
                "telemetry.rtp.rfc190scope": string;
                "temp.voice.allowmuting": string;
                "tournaments.enabled": string;
                "tournaments.pregame.enabled": string;
                "vanguard.accessurl": string;
                "vanguard.netrequired": string;
                "voice.clutchmute.enabled": string;
                "voice.clutchmute.prompt.enabled": string;
                "voice.provider": string;
                "whisper.enabled": string;
            }>;
        }, "strip", z.ZodTypeAny, {
            LastApplication: Date;
            Collapsed: {
                ARES_MOC_ENTITLEMENT: string;
                "CLIENT.ICONS.ENABLED": boolean;
                CLIENT_LEADERBOARDS_ENABLED: boolean;
                GAME_ALLOW_CONSOLE: boolean;
                GAME_ALLOW_DEVELOPER_MENU: boolean;
                GAME_DISABLED_DEATHCAM: boolean;
                GAME_DISABLED_SKINS_WEAPONS: string[];
                GAME_PERFREPORTING_ENABLED: boolean;
                GAME_REMOTE_MOVE_INTERP_ENABLED: boolean;
                GAME_ROAMINGSETTINGS_ENABLED: boolean;
                GAME_ROAMINGSETTINGS_KEY: string;
                GAME_ROAMINGSETTINGS_STORAGEURL: string;
                MAP_PRELOADING_ENABLED: boolean;
                NAMECHECK_PLATFORM_REGION: string;
                NAMECHECK_PLATFORM_URL: string;
                ROSTER_REALM: string;
                SECURITY_WATERMARK_ENABLED: boolean;
                SECURITY_WATERMARK_MAX_OPACITY: number;
                SECURITY_WATERMARK_MIN_OPACITY: number;
                SECURITY_WATERMARK_TILING_FACTOR: number;
                SERVICEURL_ACCOUNT_XP: string;
                SERVICEURL_AGGSTATS: string;
                SERVICEURL_AVS: string;
                SERVICEURL_CONTENT: string;
                SERVICEURL_CONTRACTS: string;
                SERVICEURL_CONTRACT_DEFINITIONS: string;
                SERVICEURL_COREGAME: string;
                SERVICEURL_DAILY_TICKET: string;
                SERVICEURL_FAVORITES: string;
                SERVICEURL_GALBS_QUERY: string;
                SERVICEURL_LATENCY: string;
                SERVICEURL_LOGINQUEUE: string;
                SERVICEURL_MASS_REWARDS: string;
                SERVICEURL_MATCHDETAILS: string;
                SERVICEURL_MATCHHISTORY: string;
                SERVICEURL_MATCHMAKING: string;
                SERVICEURL_MMR: string;
                SERVICEURL_NAME: string;
                SERVICEURL_PARTY: string;
                SERVICEURL_PATCHNOTES: string;
                SERVICEURL_PERSONALIZATION: string;
                SERVICEURL_PLAYERFEEDBACK: string;
                SERVICEURL_PREGAME: string;
                SERVICEURL_PREMIER: string;
                SERVICEURL_PROGRESSION: string;
                SERVICEURL_PURCHASEMERCHANT: string;
                SERVICEURL_REPLAY_CATALOG: string;
                SERVICEURL_RESTRICTIONS: string;
                SERVICEURL_SESSION: string;
                SERVICEURL_STORE: string;
                SERVICEURL_TOURNAMENTS: string;
                SERVICE_TICKER_MESSAGE: string;
                "SERVICE_TICKER_MESSAGE.de-DE": string;
                "SERVICE_TICKER_MESSAGE.es-MX": string;
                "SERVICE_TICKER_MESSAGE.fr-FR": string;
                "SERVICE_TICKER_MESSAGE.it-IT": string;
                "SERVICE_TICKER_MESSAGE.pl-PL": string;
                "SERVICE_TICKER_MESSAGE.pt-BR": string;
                "SERVICE_TICKER_MESSAGE.ru-RU": string;
                "SERVICE_TICKER_MESSAGE.tr-TR": string;
                SERVICE_TICKER_SEVERITY: string;
                STORESCREEN_OFFERREFRESH_MAXDELAY_MILLISECONDS: number;
                "avs.enabled": boolean;
                "cap.location": string;
                "characterselect.debugwidgets.hide": boolean;
                "chat.mutedwords.enabled": boolean;
                "chat.v3.enabled": boolean;
                "collection.characters.enabled": boolean;
                competitiveSeasonOffsetEndTime: number;
                "config.client.telemetry.samplerate": number;
                "content.filter.enabled": boolean;
                "content.maps.disabled": string;
                "eog.wip": boolean;
                "friends.enabled": boolean;
                "game.umgchat.enabled": boolean;
                "homescreen.featuredQueues": string;
                "homescreen.patchnotes.baseURL": string;
                "homescreen.promo.enabled": boolean;
                "homescreen.promo.key": string;
                "homescreen.webtile.baseURL": string;
                "loginqueue.region": string;
                "mainmenubar.collections.enabled": boolean;
                "mainmenubar.debug.enabled": boolean;
                "mainmenubar.profile.enabled": boolean;
                "mainmenubar.progression.enabled": boolean;
                "mainmenubar.shootingrange.enabled": boolean;
                "mainmenubar.store.enabled": boolean;
                "match.details.delay": number;
                "notifications.enabled": boolean;
                "parties.auto.balance.enabled": boolean;
                "party.observers.enabled": boolean;
                "partyinvites.enabled": boolean;
                "patchavailability.enabled": boolean;
                "personalization.equipAnyLevel.enabled": boolean;
                "personalization.useWidePlayerIdentityV2": boolean;
                "ping.update.interval": number;
                "ping.useGamePodsFromParties": boolean;
                "platformFaulted.level": string;
                "playerfeedbacktool.accessurl": string;
                "playerfeedbacktool.locale": string;
                "playerfeedbacktool.shard": string;
                "playerfeedbacktool.show": boolean;
                "playerfeedbacktool.survey_request_rate_float": number;
                "playscreen.partywidget.enabled": boolean;
                "playscreen.partywidget.matchmaking.maxsize": number;
                "playscreen.premier.enabled": boolean;
                "premier.conferences.fetch.enabled": boolean;
                "premier.leaderboardTab.enabled": boolean;
                "premier.matchHistoryTab.enabled": boolean;
                "premier.playscreenflow.enabled": boolean;
                "premier.rosterEligibilityCheck.enabled": boolean;
                "premier.seasons.activeseason.enabled": boolean;
                "premier.seasons.fetch.enabled": boolean;
                "queue.status.enabled": boolean;
                "rchat.ingame.enabled": boolean;
                "reporterfeedback.fetch.enabled": boolean;
                "reporterfeedback.notifications.enabled": boolean;
                "restrictions.v2.fetch.enabled": boolean;
                "restrictions.v2.warnings.enabled": boolean;
                "riotwarning.fetch.enabled": boolean;
                "riotwarning.notifications.enabled": boolean;
                "rnet.useAuthenticatedVoice": boolean;
                "russia.voice.enabled": boolean;
                "settings.livediagnostics.allowedplayers": string[];
                "shootingtest.enabled": boolean;
                "skillrating.enabled": boolean;
                "skillrating.inGame.enabled": boolean;
                "skillrating.preGame.enabled": boolean;
                "social.panel.v6.enabled": boolean;
                "socialviewcontroller.enabled": boolean;
                "socialviewcontroller.v2.enabled": boolean;
                "store.isXgpDisabled": boolean;
                "store.use_currency_inventory_models": boolean;
                "store.use_platform_bundle_discounted_prices": boolean;
                "telemetry.rtp.eventendpoint": string;
                "telemetry.rtp.rfc190scope": string;
                "temp.voice.allowmuting": boolean;
                "tournaments.enabled": boolean;
                "tournaments.pregame.enabled": boolean;
                "vanguard.accessurl": string;
                "vanguard.netrequired": boolean;
                "voice.clutchmute.enabled": boolean;
                "voice.clutchmute.prompt.enabled": boolean;
                "voice.provider": string;
                "whisper.enabled": boolean;
            };
        }, {
            LastApplication: string;
            Collapsed: {
                ARES_MOC_ENTITLEMENT: string;
                "CLIENT.ICONS.ENABLED": string;
                CLIENT_LEADERBOARDS_ENABLED: string;
                GAME_ALLOW_CONSOLE: string;
                GAME_ALLOW_DEVELOPER_MENU: string;
                GAME_DISABLED_DEATHCAM: string;
                GAME_DISABLED_SKINS_WEAPONS: string;
                GAME_PERFREPORTING_ENABLED: string;
                GAME_REMOTE_MOVE_INTERP_ENABLED: string;
                GAME_ROAMINGSETTINGS_ENABLED: string;
                GAME_ROAMINGSETTINGS_KEY: string;
                GAME_ROAMINGSETTINGS_STORAGEURL: string;
                MAP_PRELOADING_ENABLED: string;
                NAMECHECK_PLATFORM_REGION: string;
                NAMECHECK_PLATFORM_URL: string;
                ROSTER_REALM: string;
                SECURITY_WATERMARK_ENABLED: string;
                SECURITY_WATERMARK_MAX_OPACITY: string;
                SECURITY_WATERMARK_MIN_OPACITY: string;
                SECURITY_WATERMARK_TILING_FACTOR: string;
                SERVICEURL_ACCOUNT_XP: string;
                SERVICEURL_AGGSTATS: string;
                SERVICEURL_AVS: string;
                SERVICEURL_CONTENT: string;
                SERVICEURL_CONTRACTS: string;
                SERVICEURL_CONTRACT_DEFINITIONS: string;
                SERVICEURL_COREGAME: string;
                SERVICEURL_DAILY_TICKET: string;
                SERVICEURL_FAVORITES: string;
                SERVICEURL_GALBS_QUERY: string;
                SERVICEURL_LATENCY: string;
                SERVICEURL_LOGINQUEUE: string;
                SERVICEURL_MASS_REWARDS: string;
                SERVICEURL_MATCHDETAILS: string;
                SERVICEURL_MATCHHISTORY: string;
                SERVICEURL_MATCHMAKING: string;
                SERVICEURL_MMR: string;
                SERVICEURL_NAME: string;
                SERVICEURL_PARTY: string;
                SERVICEURL_PATCHNOTES: string;
                SERVICEURL_PERSONALIZATION: string;
                SERVICEURL_PLAYERFEEDBACK: string;
                SERVICEURL_PREGAME: string;
                SERVICEURL_PREMIER: string;
                SERVICEURL_PROGRESSION: string;
                SERVICEURL_PURCHASEMERCHANT: string;
                SERVICEURL_REPLAY_CATALOG: string;
                SERVICEURL_RESTRICTIONS: string;
                SERVICEURL_SESSION: string;
                SERVICEURL_STORE: string;
                SERVICEURL_TOURNAMENTS: string;
                SERVICE_TICKER_MESSAGE: string;
                "SERVICE_TICKER_MESSAGE.de-DE": string;
                "SERVICE_TICKER_MESSAGE.es-MX": string;
                "SERVICE_TICKER_MESSAGE.fr-FR": string;
                "SERVICE_TICKER_MESSAGE.it-IT": string;
                "SERVICE_TICKER_MESSAGE.pl-PL": string;
                "SERVICE_TICKER_MESSAGE.pt-BR": string;
                "SERVICE_TICKER_MESSAGE.ru-RU": string;
                "SERVICE_TICKER_MESSAGE.tr-TR": string;
                SERVICE_TICKER_SEVERITY: string;
                STORESCREEN_OFFERREFRESH_MAXDELAY_MILLISECONDS: string;
                "avs.enabled": string;
                "cap.location": string;
                "characterselect.debugwidgets.hide": string;
                "chat.mutedwords.enabled": string;
                "chat.v3.enabled": string;
                "collection.characters.enabled": string;
                competitiveSeasonOffsetEndTime: string;
                "config.client.telemetry.samplerate": string;
                "content.filter.enabled": string;
                "content.maps.disabled": string;
                "eog.wip": string;
                "friends.enabled": string;
                "game.umgchat.enabled": string;
                "homescreen.featuredQueues": string;
                "homescreen.patchnotes.baseURL": string;
                "homescreen.promo.enabled": string;
                "homescreen.promo.key": string;
                "homescreen.webtile.baseURL": string;
                "loginqueue.region": string;
                "mainmenubar.collections.enabled": string;
                "mainmenubar.debug.enabled": string;
                "mainmenubar.profile.enabled": string;
                "mainmenubar.progression.enabled": string;
                "mainmenubar.shootingrange.enabled": string;
                "mainmenubar.store.enabled": string;
                "match.details.delay": string;
                "notifications.enabled": string;
                "parties.auto.balance.enabled": string;
                "party.observers.enabled": string;
                "partyinvites.enabled": string;
                "patchavailability.enabled": string;
                "personalization.equipAnyLevel.enabled": string;
                "personalization.useWidePlayerIdentityV2": string;
                "ping.update.interval": string;
                "ping.useGamePodsFromParties": string;
                "platformFaulted.level": string;
                "playerfeedbacktool.accessurl": string;
                "playerfeedbacktool.locale": string;
                "playerfeedbacktool.shard": string;
                "playerfeedbacktool.show": string;
                "playerfeedbacktool.survey_request_rate_float": string;
                "playscreen.partywidget.enabled": string;
                "playscreen.partywidget.matchmaking.maxsize": string;
                "playscreen.premier.enabled": string;
                "premier.conferences.fetch.enabled": string;
                "premier.leaderboardTab.enabled": string;
                "premier.matchHistoryTab.enabled": string;
                "premier.playscreenflow.enabled": string;
                "premier.rosterEligibilityCheck.enabled": string;
                "premier.seasons.activeseason.enabled": string;
                "premier.seasons.fetch.enabled": string;
                "queue.status.enabled": string;
                "rchat.ingame.enabled": string;
                "reporterfeedback.fetch.enabled": string;
                "reporterfeedback.notifications.enabled": string;
                "restrictions.v2.fetch.enabled": string;
                "restrictions.v2.warnings.enabled": string;
                "riotwarning.fetch.enabled": string;
                "riotwarning.notifications.enabled": string;
                "rnet.useAuthenticatedVoice": string;
                "russia.voice.enabled": string;
                "settings.livediagnostics.allowedplayers": string;
                "shootingtest.enabled": string;
                "skillrating.enabled": string;
                "skillrating.inGame.enabled": string;
                "skillrating.preGame.enabled": string;
                "social.panel.v6.enabled": string;
                "socialviewcontroller.enabled": string;
                "socialviewcontroller.v2.enabled": string;
                "store.isXgpDisabled": string;
                "store.use_currency_inventory_models": string;
                "store.use_platform_bundle_discounted_prices": string;
                "telemetry.rtp.eventendpoint": string;
                "telemetry.rtp.rfc190scope": string;
                "temp.voice.allowmuting": string;
                "tournaments.enabled": string;
                "tournaments.pregame.enabled": string;
                "vanguard.accessurl": string;
                "vanguard.netrequired": string;
                "voice.clutchmute.enabled": string;
                "voice.clutchmute.prompt.enabled": string;
                "voice.provider": string;
                "whisper.enabled": string;
            };
        }>;
    };
}, "type" | "name" | "url"> & {
    "~type": {
        readonly name: "Config";
        readonly description: "Get the config for the given player";
        readonly type: "pd";
        readonly url: "v1/config/:region";
        readonly responses: {
            readonly "200": z.ZodObject<{
                LastApplication: z.ZodEffects<z.ZodString, Date, string>;
                Collapsed: z.ZodObject<{
                    ARES_MOC_ENTITLEMENT: z.ZodString;
                    "CLIENT.ICONS.ENABLED": z.ZodEffects<z.ZodString, boolean, string>;
                    CLIENT_LEADERBOARDS_ENABLED: z.ZodEffects<z.ZodString, boolean, string>;
                    GAME_ALLOW_CONSOLE: z.ZodEffects<z.ZodString, boolean, string>;
                    GAME_ALLOW_DEVELOPER_MENU: z.ZodEffects<z.ZodString, boolean, string>;
                    GAME_DISABLED_DEATHCAM: z.ZodEffects<z.ZodString, boolean, string>;
                    GAME_DISABLED_SKINS_WEAPONS: z.ZodEffects<z.ZodString, string[], string>;
                    GAME_PERFREPORTING_ENABLED: z.ZodEffects<z.ZodString, boolean, string>;
                    GAME_REMOTE_MOVE_INTERP_ENABLED: z.ZodEffects<z.ZodString, boolean, string>;
                    GAME_ROAMINGSETTINGS_ENABLED: z.ZodEffects<z.ZodString, boolean, string>;
                    GAME_ROAMINGSETTINGS_KEY: z.ZodString;
                    GAME_ROAMINGSETTINGS_STORAGEURL: z.ZodString;
                    MAP_PRELOADING_ENABLED: z.ZodEffects<z.ZodString, boolean, string>;
                    NAMECHECK_PLATFORM_REGION: z.ZodString;
                    NAMECHECK_PLATFORM_URL: z.ZodString;
                    ROSTER_REALM: z.ZodString;
                    SECURITY_WATERMARK_ENABLED: z.ZodEffects<z.ZodString, boolean, string>;
                    SECURITY_WATERMARK_MAX_OPACITY: z.ZodEffects<z.ZodString, number, string>;
                    SECURITY_WATERMARK_MIN_OPACITY: z.ZodEffects<z.ZodString, number, string>;
                    SECURITY_WATERMARK_TILING_FACTOR: z.ZodEffects<z.ZodString, number, string>;
                    SERVICEURL_ACCOUNT_XP: z.ZodString;
                    SERVICEURL_AGGSTATS: z.ZodString;
                    SERVICEURL_AVS: z.ZodString;
                    SERVICEURL_CONTENT: z.ZodString;
                    SERVICEURL_CONTRACTS: z.ZodString;
                    SERVICEURL_CONTRACT_DEFINITIONS: z.ZodString;
                    SERVICEURL_COREGAME: z.ZodString;
                    SERVICEURL_DAILY_TICKET: z.ZodString;
                    SERVICEURL_FAVORITES: z.ZodString;
                    SERVICEURL_GALBS_QUERY: z.ZodString;
                    SERVICEURL_LATENCY: z.ZodString;
                    SERVICEURL_LOGINQUEUE: z.ZodString;
                    SERVICEURL_MASS_REWARDS: z.ZodString;
                    SERVICEURL_MATCHDETAILS: z.ZodString;
                    SERVICEURL_MATCHHISTORY: z.ZodString;
                    SERVICEURL_MATCHMAKING: z.ZodString;
                    SERVICEURL_MMR: z.ZodString;
                    SERVICEURL_NAME: z.ZodString;
                    SERVICEURL_PARTY: z.ZodString;
                    SERVICEURL_PATCHNOTES: z.ZodString;
                    SERVICEURL_PERSONALIZATION: z.ZodString;
                    SERVICEURL_PLAYERFEEDBACK: z.ZodString;
                    SERVICEURL_PREGAME: z.ZodString;
                    SERVICEURL_PREMIER: z.ZodString;
                    SERVICEURL_PROGRESSION: z.ZodString;
                    SERVICEURL_PURCHASEMERCHANT: z.ZodString;
                    SERVICEURL_REPLAY_CATALOG: z.ZodString;
                    SERVICEURL_RESTRICTIONS: z.ZodString;
                    SERVICEURL_SESSION: z.ZodString;
                    SERVICEURL_STORE: z.ZodString;
                    SERVICEURL_TOURNAMENTS: z.ZodString;
                    SERVICE_TICKER_MESSAGE: z.ZodString;
                    "SERVICE_TICKER_MESSAGE.de-DE": z.ZodString;
                    "SERVICE_TICKER_MESSAGE.es-MX": z.ZodString;
                    "SERVICE_TICKER_MESSAGE.fr-FR": z.ZodString;
                    "SERVICE_TICKER_MESSAGE.it-IT": z.ZodString;
                    "SERVICE_TICKER_MESSAGE.pl-PL": z.ZodString;
                    "SERVICE_TICKER_MESSAGE.pt-BR": z.ZodString;
                    "SERVICE_TICKER_MESSAGE.ru-RU": z.ZodString;
                    "SERVICE_TICKER_MESSAGE.tr-TR": z.ZodString;
                    SERVICE_TICKER_SEVERITY: z.ZodString;
                    STORESCREEN_OFFERREFRESH_MAXDELAY_MILLISECONDS: z.ZodEffects<z.ZodString, number, string>;
                    "avs.enabled": z.ZodEffects<z.ZodString, boolean, string>;
                    "cap.location": z.ZodString;
                    "characterselect.debugwidgets.hide": z.ZodEffects<z.ZodString, boolean, string>;
                    "chat.mutedwords.enabled": z.ZodEffects<z.ZodString, boolean, string>;
                    "chat.v3.enabled": z.ZodEffects<z.ZodString, boolean, string>;
                    "collection.characters.enabled": z.ZodEffects<z.ZodString, boolean, string>;
                    competitiveSeasonOffsetEndTime: z.ZodEffects<z.ZodString, number, string>;
                    "config.client.telemetry.samplerate": z.ZodEffects<z.ZodString, number, string>;
                    "content.filter.enabled": z.ZodEffects<z.ZodString, boolean, string>;
                    "content.maps.disabled": z.ZodString;
                    "eog.wip": z.ZodEffects<z.ZodString, boolean, string>;
                    "friends.enabled": z.ZodEffects<z.ZodString, boolean, string>;
                    "game.umgchat.enabled": z.ZodEffects<z.ZodString, boolean, string>;
                    "homescreen.featuredQueues": z.ZodString;
                    "homescreen.patchnotes.baseURL": z.ZodString;
                    "homescreen.promo.enabled": z.ZodEffects<z.ZodString, boolean, string>;
                    "homescreen.promo.key": z.ZodString;
                    "homescreen.webtile.baseURL": z.ZodString;
                    "loginqueue.region": z.ZodString;
                    "mainmenubar.collections.enabled": z.ZodEffects<z.ZodString, boolean, string>;
                    "mainmenubar.debug.enabled": z.ZodEffects<z.ZodString, boolean, string>;
                    "mainmenubar.profile.enabled": z.ZodEffects<z.ZodString, boolean, string>;
                    "mainmenubar.progression.enabled": z.ZodEffects<z.ZodString, boolean, string>;
                    "mainmenubar.shootingrange.enabled": z.ZodEffects<z.ZodString, boolean, string>;
                    "mainmenubar.store.enabled": z.ZodEffects<z.ZodString, boolean, string>;
                    "match.details.delay": z.ZodEffects<z.ZodString, number, string>;
                    "notifications.enabled": z.ZodEffects<z.ZodString, boolean, string>;
                    "parties.auto.balance.enabled": z.ZodEffects<z.ZodString, boolean, string>;
                    "party.observers.enabled": z.ZodEffects<z.ZodString, boolean, string>;
                    "partyinvites.enabled": z.ZodEffects<z.ZodString, boolean, string>;
                    "patchavailability.enabled": z.ZodEffects<z.ZodString, boolean, string>;
                    "personalization.equipAnyLevel.enabled": z.ZodEffects<z.ZodString, boolean, string>;
                    "personalization.useWidePlayerIdentityV2": z.ZodEffects<z.ZodString, boolean, string>;
                    "ping.update.interval": z.ZodEffects<z.ZodString, number, string>;
                    "ping.useGamePodsFromParties": z.ZodEffects<z.ZodString, boolean, string>;
                    "platformFaulted.level": z.ZodString;
                    "playerfeedbacktool.accessurl": z.ZodString;
                    "playerfeedbacktool.locale": z.ZodString;
                    "playerfeedbacktool.shard": z.ZodString;
                    "playerfeedbacktool.show": z.ZodEffects<z.ZodString, boolean, string>;
                    "playerfeedbacktool.survey_request_rate_float": z.ZodEffects<z.ZodString, number, string>;
                    "playscreen.partywidget.enabled": z.ZodEffects<z.ZodString, boolean, string>;
                    "playscreen.partywidget.matchmaking.maxsize": z.ZodEffects<z.ZodString, number, string>;
                    "playscreen.premier.enabled": z.ZodEffects<z.ZodString, boolean, string>;
                    "premier.conferences.fetch.enabled": z.ZodEffects<z.ZodString, boolean, string>;
                    "premier.leaderboardTab.enabled": z.ZodEffects<z.ZodString, boolean, string>;
                    "premier.matchHistoryTab.enabled": z.ZodEffects<z.ZodString, boolean, string>;
                    "premier.playscreenflow.enabled": z.ZodEffects<z.ZodString, boolean, string>;
                    "premier.rosterEligibilityCheck.enabled": z.ZodEffects<z.ZodString, boolean, string>;
                    "premier.seasons.activeseason.enabled": z.ZodEffects<z.ZodString, boolean, string>;
                    "premier.seasons.fetch.enabled": z.ZodEffects<z.ZodString, boolean, string>;
                    "queue.status.enabled": z.ZodEffects<z.ZodString, boolean, string>;
                    "rchat.ingame.enabled": z.ZodEffects<z.ZodString, boolean, string>;
                    "reporterfeedback.fetch.enabled": z.ZodEffects<z.ZodString, boolean, string>;
                    "reporterfeedback.notifications.enabled": z.ZodEffects<z.ZodString, boolean, string>;
                    "restrictions.v2.fetch.enabled": z.ZodEffects<z.ZodString, boolean, string>;
                    "restrictions.v2.warnings.enabled": z.ZodEffects<z.ZodString, boolean, string>;
                    "riotwarning.fetch.enabled": z.ZodEffects<z.ZodString, boolean, string>;
                    "riotwarning.notifications.enabled": z.ZodEffects<z.ZodString, boolean, string>;
                    "rnet.useAuthenticatedVoice": z.ZodEffects<z.ZodString, boolean, string>;
                    "russia.voice.enabled": z.ZodEffects<z.ZodString, boolean, string>;
                    "settings.livediagnostics.allowedplayers": z.ZodEffects<z.ZodString, string[], string>;
                    "shootingtest.enabled": z.ZodEffects<z.ZodString, boolean, string>;
                    "skillrating.enabled": z.ZodEffects<z.ZodString, boolean, string>;
                    "skillrating.inGame.enabled": z.ZodEffects<z.ZodString, boolean, string>;
                    "skillrating.preGame.enabled": z.ZodEffects<z.ZodString, boolean, string>;
                    "social.panel.v6.enabled": z.ZodEffects<z.ZodString, boolean, string>;
                    "socialviewcontroller.enabled": z.ZodEffects<z.ZodString, boolean, string>;
                    "socialviewcontroller.v2.enabled": z.ZodEffects<z.ZodString, boolean, string>;
                    "store.isXgpDisabled": z.ZodEffects<z.ZodString, boolean, string>;
                    "store.use_currency_inventory_models": z.ZodEffects<z.ZodString, boolean, string>;
                    "store.use_platform_bundle_discounted_prices": z.ZodEffects<z.ZodString, boolean, string>;
                    "telemetry.rtp.eventendpoint": z.ZodString;
                    "telemetry.rtp.rfc190scope": z.ZodString;
                    "temp.voice.allowmuting": z.ZodEffects<z.ZodString, boolean, string>;
                    "tournaments.enabled": z.ZodEffects<z.ZodString, boolean, string>;
                    "tournaments.pregame.enabled": z.ZodEffects<z.ZodString, boolean, string>;
                    "vanguard.accessurl": z.ZodString;
                    "vanguard.netrequired": z.ZodEffects<z.ZodString, boolean, string>;
                    "voice.clutchmute.enabled": z.ZodEffects<z.ZodString, boolean, string>;
                    "voice.clutchmute.prompt.enabled": z.ZodEffects<z.ZodString, boolean, string>;
                    "voice.provider": z.ZodString;
                    "whisper.enabled": z.ZodEffects<z.ZodString, boolean, string>;
                }, "strip", z.ZodTypeAny, {
                    ARES_MOC_ENTITLEMENT: string;
                    "CLIENT.ICONS.ENABLED": boolean;
                    CLIENT_LEADERBOARDS_ENABLED: boolean;
                    GAME_ALLOW_CONSOLE: boolean;
                    GAME_ALLOW_DEVELOPER_MENU: boolean;
                    GAME_DISABLED_DEATHCAM: boolean;
                    GAME_DISABLED_SKINS_WEAPONS: string[];
                    GAME_PERFREPORTING_ENABLED: boolean;
                    GAME_REMOTE_MOVE_INTERP_ENABLED: boolean;
                    GAME_ROAMINGSETTINGS_ENABLED: boolean;
                    GAME_ROAMINGSETTINGS_KEY: string;
                    GAME_ROAMINGSETTINGS_STORAGEURL: string;
                    MAP_PRELOADING_ENABLED: boolean;
                    NAMECHECK_PLATFORM_REGION: string;
                    NAMECHECK_PLATFORM_URL: string;
                    ROSTER_REALM: string;
                    SECURITY_WATERMARK_ENABLED: boolean;
                    SECURITY_WATERMARK_MAX_OPACITY: number;
                    SECURITY_WATERMARK_MIN_OPACITY: number;
                    SECURITY_WATERMARK_TILING_FACTOR: number;
                    SERVICEURL_ACCOUNT_XP: string;
                    SERVICEURL_AGGSTATS: string;
                    SERVICEURL_AVS: string;
                    SERVICEURL_CONTENT: string;
                    SERVICEURL_CONTRACTS: string;
                    SERVICEURL_CONTRACT_DEFINITIONS: string;
                    SERVICEURL_COREGAME: string;
                    SERVICEURL_DAILY_TICKET: string;
                    SERVICEURL_FAVORITES: string;
                    SERVICEURL_GALBS_QUERY: string;
                    SERVICEURL_LATENCY: string;
                    SERVICEURL_LOGINQUEUE: string;
                    SERVICEURL_MASS_REWARDS: string;
                    SERVICEURL_MATCHDETAILS: string;
                    SERVICEURL_MATCHHISTORY: string;
                    SERVICEURL_MATCHMAKING: string;
                    SERVICEURL_MMR: string;
                    SERVICEURL_NAME: string;
                    SERVICEURL_PARTY: string;
                    SERVICEURL_PATCHNOTES: string;
                    SERVICEURL_PERSONALIZATION: string;
                    SERVICEURL_PLAYERFEEDBACK: string;
                    SERVICEURL_PREGAME: string;
                    SERVICEURL_PREMIER: string;
                    SERVICEURL_PROGRESSION: string;
                    SERVICEURL_PURCHASEMERCHANT: string;
                    SERVICEURL_REPLAY_CATALOG: string;
                    SERVICEURL_RESTRICTIONS: string;
                    SERVICEURL_SESSION: string;
                    SERVICEURL_STORE: string;
                    SERVICEURL_TOURNAMENTS: string;
                    SERVICE_TICKER_MESSAGE: string;
                    "SERVICE_TICKER_MESSAGE.de-DE": string;
                    "SERVICE_TICKER_MESSAGE.es-MX": string;
                    "SERVICE_TICKER_MESSAGE.fr-FR": string;
                    "SERVICE_TICKER_MESSAGE.it-IT": string;
                    "SERVICE_TICKER_MESSAGE.pl-PL": string;
                    "SERVICE_TICKER_MESSAGE.pt-BR": string;
                    "SERVICE_TICKER_MESSAGE.ru-RU": string;
                    "SERVICE_TICKER_MESSAGE.tr-TR": string;
                    SERVICE_TICKER_SEVERITY: string;
                    STORESCREEN_OFFERREFRESH_MAXDELAY_MILLISECONDS: number;
                    "avs.enabled": boolean;
                    "cap.location": string;
                    "characterselect.debugwidgets.hide": boolean;
                    "chat.mutedwords.enabled": boolean;
                    "chat.v3.enabled": boolean;
                    "collection.characters.enabled": boolean;
                    competitiveSeasonOffsetEndTime: number;
                    "config.client.telemetry.samplerate": number;
                    "content.filter.enabled": boolean;
                    "content.maps.disabled": string;
                    "eog.wip": boolean;
                    "friends.enabled": boolean;
                    "game.umgchat.enabled": boolean;
                    "homescreen.featuredQueues": string;
                    "homescreen.patchnotes.baseURL": string;
                    "homescreen.promo.enabled": boolean;
                    "homescreen.promo.key": string;
                    "homescreen.webtile.baseURL": string;
                    "loginqueue.region": string;
                    "mainmenubar.collections.enabled": boolean;
                    "mainmenubar.debug.enabled": boolean;
                    "mainmenubar.profile.enabled": boolean;
                    "mainmenubar.progression.enabled": boolean;
                    "mainmenubar.shootingrange.enabled": boolean;
                    "mainmenubar.store.enabled": boolean;
                    "match.details.delay": number;
                    "notifications.enabled": boolean;
                    "parties.auto.balance.enabled": boolean;
                    "party.observers.enabled": boolean;
                    "partyinvites.enabled": boolean;
                    "patchavailability.enabled": boolean;
                    "personalization.equipAnyLevel.enabled": boolean;
                    "personalization.useWidePlayerIdentityV2": boolean;
                    "ping.update.interval": number;
                    "ping.useGamePodsFromParties": boolean;
                    "platformFaulted.level": string;
                    "playerfeedbacktool.accessurl": string;
                    "playerfeedbacktool.locale": string;
                    "playerfeedbacktool.shard": string;
                    "playerfeedbacktool.show": boolean;
                    "playerfeedbacktool.survey_request_rate_float": number;
                    "playscreen.partywidget.enabled": boolean;
                    "playscreen.partywidget.matchmaking.maxsize": number;
                    "playscreen.premier.enabled": boolean;
                    "premier.conferences.fetch.enabled": boolean;
                    "premier.leaderboardTab.enabled": boolean;
                    "premier.matchHistoryTab.enabled": boolean;
                    "premier.playscreenflow.enabled": boolean;
                    "premier.rosterEligibilityCheck.enabled": boolean;
                    "premier.seasons.activeseason.enabled": boolean;
                    "premier.seasons.fetch.enabled": boolean;
                    "queue.status.enabled": boolean;
                    "rchat.ingame.enabled": boolean;
                    "reporterfeedback.fetch.enabled": boolean;
                    "reporterfeedback.notifications.enabled": boolean;
                    "restrictions.v2.fetch.enabled": boolean;
                    "restrictions.v2.warnings.enabled": boolean;
                    "riotwarning.fetch.enabled": boolean;
                    "riotwarning.notifications.enabled": boolean;
                    "rnet.useAuthenticatedVoice": boolean;
                    "russia.voice.enabled": boolean;
                    "settings.livediagnostics.allowedplayers": string[];
                    "shootingtest.enabled": boolean;
                    "skillrating.enabled": boolean;
                    "skillrating.inGame.enabled": boolean;
                    "skillrating.preGame.enabled": boolean;
                    "social.panel.v6.enabled": boolean;
                    "socialviewcontroller.enabled": boolean;
                    "socialviewcontroller.v2.enabled": boolean;
                    "store.isXgpDisabled": boolean;
                    "store.use_currency_inventory_models": boolean;
                    "store.use_platform_bundle_discounted_prices": boolean;
                    "telemetry.rtp.eventendpoint": string;
                    "telemetry.rtp.rfc190scope": string;
                    "temp.voice.allowmuting": boolean;
                    "tournaments.enabled": boolean;
                    "tournaments.pregame.enabled": boolean;
                    "vanguard.accessurl": string;
                    "vanguard.netrequired": boolean;
                    "voice.clutchmute.enabled": boolean;
                    "voice.clutchmute.prompt.enabled": boolean;
                    "voice.provider": string;
                    "whisper.enabled": boolean;
                }, {
                    ARES_MOC_ENTITLEMENT: string;
                    "CLIENT.ICONS.ENABLED": string;
                    CLIENT_LEADERBOARDS_ENABLED: string;
                    GAME_ALLOW_CONSOLE: string;
                    GAME_ALLOW_DEVELOPER_MENU: string;
                    GAME_DISABLED_DEATHCAM: string;
                    GAME_DISABLED_SKINS_WEAPONS: string;
                    GAME_PERFREPORTING_ENABLED: string;
                    GAME_REMOTE_MOVE_INTERP_ENABLED: string;
                    GAME_ROAMINGSETTINGS_ENABLED: string;
                    GAME_ROAMINGSETTINGS_KEY: string;
                    GAME_ROAMINGSETTINGS_STORAGEURL: string;
                    MAP_PRELOADING_ENABLED: string;
                    NAMECHECK_PLATFORM_REGION: string;
                    NAMECHECK_PLATFORM_URL: string;
                    ROSTER_REALM: string;
                    SECURITY_WATERMARK_ENABLED: string;
                    SECURITY_WATERMARK_MAX_OPACITY: string;
                    SECURITY_WATERMARK_MIN_OPACITY: string;
                    SECURITY_WATERMARK_TILING_FACTOR: string;
                    SERVICEURL_ACCOUNT_XP: string;
                    SERVICEURL_AGGSTATS: string;
                    SERVICEURL_AVS: string;
                    SERVICEURL_CONTENT: string;
                    SERVICEURL_CONTRACTS: string;
                    SERVICEURL_CONTRACT_DEFINITIONS: string;
                    SERVICEURL_COREGAME: string;
                    SERVICEURL_DAILY_TICKET: string;
                    SERVICEURL_FAVORITES: string;
                    SERVICEURL_GALBS_QUERY: string;
                    SERVICEURL_LATENCY: string;
                    SERVICEURL_LOGINQUEUE: string;
                    SERVICEURL_MASS_REWARDS: string;
                    SERVICEURL_MATCHDETAILS: string;
                    SERVICEURL_MATCHHISTORY: string;
                    SERVICEURL_MATCHMAKING: string;
                    SERVICEURL_MMR: string;
                    SERVICEURL_NAME: string;
                    SERVICEURL_PARTY: string;
                    SERVICEURL_PATCHNOTES: string;
                    SERVICEURL_PERSONALIZATION: string;
                    SERVICEURL_PLAYERFEEDBACK: string;
                    SERVICEURL_PREGAME: string;
                    SERVICEURL_PREMIER: string;
                    SERVICEURL_PROGRESSION: string;
                    SERVICEURL_PURCHASEMERCHANT: string;
                    SERVICEURL_REPLAY_CATALOG: string;
                    SERVICEURL_RESTRICTIONS: string;
                    SERVICEURL_SESSION: string;
                    SERVICEURL_STORE: string;
                    SERVICEURL_TOURNAMENTS: string;
                    SERVICE_TICKER_MESSAGE: string;
                    "SERVICE_TICKER_MESSAGE.de-DE": string;
                    "SERVICE_TICKER_MESSAGE.es-MX": string;
                    "SERVICE_TICKER_MESSAGE.fr-FR": string;
                    "SERVICE_TICKER_MESSAGE.it-IT": string;
                    "SERVICE_TICKER_MESSAGE.pl-PL": string;
                    "SERVICE_TICKER_MESSAGE.pt-BR": string;
                    "SERVICE_TICKER_MESSAGE.ru-RU": string;
                    "SERVICE_TICKER_MESSAGE.tr-TR": string;
                    SERVICE_TICKER_SEVERITY: string;
                    STORESCREEN_OFFERREFRESH_MAXDELAY_MILLISECONDS: string;
                    "avs.enabled": string;
                    "cap.location": string;
                    "characterselect.debugwidgets.hide": string;
                    "chat.mutedwords.enabled": string;
                    "chat.v3.enabled": string;
                    "collection.characters.enabled": string;
                    competitiveSeasonOffsetEndTime: string;
                    "config.client.telemetry.samplerate": string;
                    "content.filter.enabled": string;
                    "content.maps.disabled": string;
                    "eog.wip": string;
                    "friends.enabled": string;
                    "game.umgchat.enabled": string;
                    "homescreen.featuredQueues": string;
                    "homescreen.patchnotes.baseURL": string;
                    "homescreen.promo.enabled": string;
                    "homescreen.promo.key": string;
                    "homescreen.webtile.baseURL": string;
                    "loginqueue.region": string;
                    "mainmenubar.collections.enabled": string;
                    "mainmenubar.debug.enabled": string;
                    "mainmenubar.profile.enabled": string;
                    "mainmenubar.progression.enabled": string;
                    "mainmenubar.shootingrange.enabled": string;
                    "mainmenubar.store.enabled": string;
                    "match.details.delay": string;
                    "notifications.enabled": string;
                    "parties.auto.balance.enabled": string;
                    "party.observers.enabled": string;
                    "partyinvites.enabled": string;
                    "patchavailability.enabled": string;
                    "personalization.equipAnyLevel.enabled": string;
                    "personalization.useWidePlayerIdentityV2": string;
                    "ping.update.interval": string;
                    "ping.useGamePodsFromParties": string;
                    "platformFaulted.level": string;
                    "playerfeedbacktool.accessurl": string;
                    "playerfeedbacktool.locale": string;
                    "playerfeedbacktool.shard": string;
                    "playerfeedbacktool.show": string;
                    "playerfeedbacktool.survey_request_rate_float": string;
                    "playscreen.partywidget.enabled": string;
                    "playscreen.partywidget.matchmaking.maxsize": string;
                    "playscreen.premier.enabled": string;
                    "premier.conferences.fetch.enabled": string;
                    "premier.leaderboardTab.enabled": string;
                    "premier.matchHistoryTab.enabled": string;
                    "premier.playscreenflow.enabled": string;
                    "premier.rosterEligibilityCheck.enabled": string;
                    "premier.seasons.activeseason.enabled": string;
                    "premier.seasons.fetch.enabled": string;
                    "queue.status.enabled": string;
                    "rchat.ingame.enabled": string;
                    "reporterfeedback.fetch.enabled": string;
                    "reporterfeedback.notifications.enabled": string;
                    "restrictions.v2.fetch.enabled": string;
                    "restrictions.v2.warnings.enabled": string;
                    "riotwarning.fetch.enabled": string;
                    "riotwarning.notifications.enabled": string;
                    "rnet.useAuthenticatedVoice": string;
                    "russia.voice.enabled": string;
                    "settings.livediagnostics.allowedplayers": string;
                    "shootingtest.enabled": string;
                    "skillrating.enabled": string;
                    "skillrating.inGame.enabled": string;
                    "skillrating.preGame.enabled": string;
                    "social.panel.v6.enabled": string;
                    "socialviewcontroller.enabled": string;
                    "socialviewcontroller.v2.enabled": string;
                    "store.isXgpDisabled": string;
                    "store.use_currency_inventory_models": string;
                    "store.use_platform_bundle_discounted_prices": string;
                    "telemetry.rtp.eventendpoint": string;
                    "telemetry.rtp.rfc190scope": string;
                    "temp.voice.allowmuting": string;
                    "tournaments.enabled": string;
                    "tournaments.pregame.enabled": string;
                    "vanguard.accessurl": string;
                    "vanguard.netrequired": string;
                    "voice.clutchmute.enabled": string;
                    "voice.clutchmute.prompt.enabled": string;
                    "voice.provider": string;
                    "whisper.enabled": string;
                }>;
            }, "strip", z.ZodTypeAny, {
                LastApplication: Date;
                Collapsed: {
                    ARES_MOC_ENTITLEMENT: string;
                    "CLIENT.ICONS.ENABLED": boolean;
                    CLIENT_LEADERBOARDS_ENABLED: boolean;
                    GAME_ALLOW_CONSOLE: boolean;
                    GAME_ALLOW_DEVELOPER_MENU: boolean;
                    GAME_DISABLED_DEATHCAM: boolean;
                    GAME_DISABLED_SKINS_WEAPONS: string[];
                    GAME_PERFREPORTING_ENABLED: boolean;
                    GAME_REMOTE_MOVE_INTERP_ENABLED: boolean;
                    GAME_ROAMINGSETTINGS_ENABLED: boolean;
                    GAME_ROAMINGSETTINGS_KEY: string;
                    GAME_ROAMINGSETTINGS_STORAGEURL: string;
                    MAP_PRELOADING_ENABLED: boolean;
                    NAMECHECK_PLATFORM_REGION: string;
                    NAMECHECK_PLATFORM_URL: string;
                    ROSTER_REALM: string;
                    SECURITY_WATERMARK_ENABLED: boolean;
                    SECURITY_WATERMARK_MAX_OPACITY: number;
                    SECURITY_WATERMARK_MIN_OPACITY: number;
                    SECURITY_WATERMARK_TILING_FACTOR: number;
                    SERVICEURL_ACCOUNT_XP: string;
                    SERVICEURL_AGGSTATS: string;
                    SERVICEURL_AVS: string;
                    SERVICEURL_CONTENT: string;
                    SERVICEURL_CONTRACTS: string;
                    SERVICEURL_CONTRACT_DEFINITIONS: string;
                    SERVICEURL_COREGAME: string;
                    SERVICEURL_DAILY_TICKET: string;
                    SERVICEURL_FAVORITES: string;
                    SERVICEURL_GALBS_QUERY: string;
                    SERVICEURL_LATENCY: string;
                    SERVICEURL_LOGINQUEUE: string;
                    SERVICEURL_MASS_REWARDS: string;
                    SERVICEURL_MATCHDETAILS: string;
                    SERVICEURL_MATCHHISTORY: string;
                    SERVICEURL_MATCHMAKING: string;
                    SERVICEURL_MMR: string;
                    SERVICEURL_NAME: string;
                    SERVICEURL_PARTY: string;
                    SERVICEURL_PATCHNOTES: string;
                    SERVICEURL_PERSONALIZATION: string;
                    SERVICEURL_PLAYERFEEDBACK: string;
                    SERVICEURL_PREGAME: string;
                    SERVICEURL_PREMIER: string;
                    SERVICEURL_PROGRESSION: string;
                    SERVICEURL_PURCHASEMERCHANT: string;
                    SERVICEURL_REPLAY_CATALOG: string;
                    SERVICEURL_RESTRICTIONS: string;
                    SERVICEURL_SESSION: string;
                    SERVICEURL_STORE: string;
                    SERVICEURL_TOURNAMENTS: string;
                    SERVICE_TICKER_MESSAGE: string;
                    "SERVICE_TICKER_MESSAGE.de-DE": string;
                    "SERVICE_TICKER_MESSAGE.es-MX": string;
                    "SERVICE_TICKER_MESSAGE.fr-FR": string;
                    "SERVICE_TICKER_MESSAGE.it-IT": string;
                    "SERVICE_TICKER_MESSAGE.pl-PL": string;
                    "SERVICE_TICKER_MESSAGE.pt-BR": string;
                    "SERVICE_TICKER_MESSAGE.ru-RU": string;
                    "SERVICE_TICKER_MESSAGE.tr-TR": string;
                    SERVICE_TICKER_SEVERITY: string;
                    STORESCREEN_OFFERREFRESH_MAXDELAY_MILLISECONDS: number;
                    "avs.enabled": boolean;
                    "cap.location": string;
                    "characterselect.debugwidgets.hide": boolean;
                    "chat.mutedwords.enabled": boolean;
                    "chat.v3.enabled": boolean;
                    "collection.characters.enabled": boolean;
                    competitiveSeasonOffsetEndTime: number;
                    "config.client.telemetry.samplerate": number;
                    "content.filter.enabled": boolean;
                    "content.maps.disabled": string;
                    "eog.wip": boolean;
                    "friends.enabled": boolean;
                    "game.umgchat.enabled": boolean;
                    "homescreen.featuredQueues": string;
                    "homescreen.patchnotes.baseURL": string;
                    "homescreen.promo.enabled": boolean;
                    "homescreen.promo.key": string;
                    "homescreen.webtile.baseURL": string;
                    "loginqueue.region": string;
                    "mainmenubar.collections.enabled": boolean;
                    "mainmenubar.debug.enabled": boolean;
                    "mainmenubar.profile.enabled": boolean;
                    "mainmenubar.progression.enabled": boolean;
                    "mainmenubar.shootingrange.enabled": boolean;
                    "mainmenubar.store.enabled": boolean;
                    "match.details.delay": number;
                    "notifications.enabled": boolean;
                    "parties.auto.balance.enabled": boolean;
                    "party.observers.enabled": boolean;
                    "partyinvites.enabled": boolean;
                    "patchavailability.enabled": boolean;
                    "personalization.equipAnyLevel.enabled": boolean;
                    "personalization.useWidePlayerIdentityV2": boolean;
                    "ping.update.interval": number;
                    "ping.useGamePodsFromParties": boolean;
                    "platformFaulted.level": string;
                    "playerfeedbacktool.accessurl": string;
                    "playerfeedbacktool.locale": string;
                    "playerfeedbacktool.shard": string;
                    "playerfeedbacktool.show": boolean;
                    "playerfeedbacktool.survey_request_rate_float": number;
                    "playscreen.partywidget.enabled": boolean;
                    "playscreen.partywidget.matchmaking.maxsize": number;
                    "playscreen.premier.enabled": boolean;
                    "premier.conferences.fetch.enabled": boolean;
                    "premier.leaderboardTab.enabled": boolean;
                    "premier.matchHistoryTab.enabled": boolean;
                    "premier.playscreenflow.enabled": boolean;
                    "premier.rosterEligibilityCheck.enabled": boolean;
                    "premier.seasons.activeseason.enabled": boolean;
                    "premier.seasons.fetch.enabled": boolean;
                    "queue.status.enabled": boolean;
                    "rchat.ingame.enabled": boolean;
                    "reporterfeedback.fetch.enabled": boolean;
                    "reporterfeedback.notifications.enabled": boolean;
                    "restrictions.v2.fetch.enabled": boolean;
                    "restrictions.v2.warnings.enabled": boolean;
                    "riotwarning.fetch.enabled": boolean;
                    "riotwarning.notifications.enabled": boolean;
                    "rnet.useAuthenticatedVoice": boolean;
                    "russia.voice.enabled": boolean;
                    "settings.livediagnostics.allowedplayers": string[];
                    "shootingtest.enabled": boolean;
                    "skillrating.enabled": boolean;
                    "skillrating.inGame.enabled": boolean;
                    "skillrating.preGame.enabled": boolean;
                    "social.panel.v6.enabled": boolean;
                    "socialviewcontroller.enabled": boolean;
                    "socialviewcontroller.v2.enabled": boolean;
                    "store.isXgpDisabled": boolean;
                    "store.use_currency_inventory_models": boolean;
                    "store.use_platform_bundle_discounted_prices": boolean;
                    "telemetry.rtp.eventendpoint": string;
                    "telemetry.rtp.rfc190scope": string;
                    "temp.voice.allowmuting": boolean;
                    "tournaments.enabled": boolean;
                    "tournaments.pregame.enabled": boolean;
                    "vanguard.accessurl": string;
                    "vanguard.netrequired": boolean;
                    "voice.clutchmute.enabled": boolean;
                    "voice.clutchmute.prompt.enabled": boolean;
                    "voice.provider": string;
                    "whisper.enabled": boolean;
                };
            }, {
                LastApplication: string;
                Collapsed: {
                    ARES_MOC_ENTITLEMENT: string;
                    "CLIENT.ICONS.ENABLED": string;
                    CLIENT_LEADERBOARDS_ENABLED: string;
                    GAME_ALLOW_CONSOLE: string;
                    GAME_ALLOW_DEVELOPER_MENU: string;
                    GAME_DISABLED_DEATHCAM: string;
                    GAME_DISABLED_SKINS_WEAPONS: string;
                    GAME_PERFREPORTING_ENABLED: string;
                    GAME_REMOTE_MOVE_INTERP_ENABLED: string;
                    GAME_ROAMINGSETTINGS_ENABLED: string;
                    GAME_ROAMINGSETTINGS_KEY: string;
                    GAME_ROAMINGSETTINGS_STORAGEURL: string;
                    MAP_PRELOADING_ENABLED: string;
                    NAMECHECK_PLATFORM_REGION: string;
                    NAMECHECK_PLATFORM_URL: string;
                    ROSTER_REALM: string;
                    SECURITY_WATERMARK_ENABLED: string;
                    SECURITY_WATERMARK_MAX_OPACITY: string;
                    SECURITY_WATERMARK_MIN_OPACITY: string;
                    SECURITY_WATERMARK_TILING_FACTOR: string;
                    SERVICEURL_ACCOUNT_XP: string;
                    SERVICEURL_AGGSTATS: string;
                    SERVICEURL_AVS: string;
                    SERVICEURL_CONTENT: string;
                    SERVICEURL_CONTRACTS: string;
                    SERVICEURL_CONTRACT_DEFINITIONS: string;
                    SERVICEURL_COREGAME: string;
                    SERVICEURL_DAILY_TICKET: string;
                    SERVICEURL_FAVORITES: string;
                    SERVICEURL_GALBS_QUERY: string;
                    SERVICEURL_LATENCY: string;
                    SERVICEURL_LOGINQUEUE: string;
                    SERVICEURL_MASS_REWARDS: string;
                    SERVICEURL_MATCHDETAILS: string;
                    SERVICEURL_MATCHHISTORY: string;
                    SERVICEURL_MATCHMAKING: string;
                    SERVICEURL_MMR: string;
                    SERVICEURL_NAME: string;
                    SERVICEURL_PARTY: string;
                    SERVICEURL_PATCHNOTES: string;
                    SERVICEURL_PERSONALIZATION: string;
                    SERVICEURL_PLAYERFEEDBACK: string;
                    SERVICEURL_PREGAME: string;
                    SERVICEURL_PREMIER: string;
                    SERVICEURL_PROGRESSION: string;
                    SERVICEURL_PURCHASEMERCHANT: string;
                    SERVICEURL_REPLAY_CATALOG: string;
                    SERVICEURL_RESTRICTIONS: string;
                    SERVICEURL_SESSION: string;
                    SERVICEURL_STORE: string;
                    SERVICEURL_TOURNAMENTS: string;
                    SERVICE_TICKER_MESSAGE: string;
                    "SERVICE_TICKER_MESSAGE.de-DE": string;
                    "SERVICE_TICKER_MESSAGE.es-MX": string;
                    "SERVICE_TICKER_MESSAGE.fr-FR": string;
                    "SERVICE_TICKER_MESSAGE.it-IT": string;
                    "SERVICE_TICKER_MESSAGE.pl-PL": string;
                    "SERVICE_TICKER_MESSAGE.pt-BR": string;
                    "SERVICE_TICKER_MESSAGE.ru-RU": string;
                    "SERVICE_TICKER_MESSAGE.tr-TR": string;
                    SERVICE_TICKER_SEVERITY: string;
                    STORESCREEN_OFFERREFRESH_MAXDELAY_MILLISECONDS: string;
                    "avs.enabled": string;
                    "cap.location": string;
                    "characterselect.debugwidgets.hide": string;
                    "chat.mutedwords.enabled": string;
                    "chat.v3.enabled": string;
                    "collection.characters.enabled": string;
                    competitiveSeasonOffsetEndTime: string;
                    "config.client.telemetry.samplerate": string;
                    "content.filter.enabled": string;
                    "content.maps.disabled": string;
                    "eog.wip": string;
                    "friends.enabled": string;
                    "game.umgchat.enabled": string;
                    "homescreen.featuredQueues": string;
                    "homescreen.patchnotes.baseURL": string;
                    "homescreen.promo.enabled": string;
                    "homescreen.promo.key": string;
                    "homescreen.webtile.baseURL": string;
                    "loginqueue.region": string;
                    "mainmenubar.collections.enabled": string;
                    "mainmenubar.debug.enabled": string;
                    "mainmenubar.profile.enabled": string;
                    "mainmenubar.progression.enabled": string;
                    "mainmenubar.shootingrange.enabled": string;
                    "mainmenubar.store.enabled": string;
                    "match.details.delay": string;
                    "notifications.enabled": string;
                    "parties.auto.balance.enabled": string;
                    "party.observers.enabled": string;
                    "partyinvites.enabled": string;
                    "patchavailability.enabled": string;
                    "personalization.equipAnyLevel.enabled": string;
                    "personalization.useWidePlayerIdentityV2": string;
                    "ping.update.interval": string;
                    "ping.useGamePodsFromParties": string;
                    "platformFaulted.level": string;
                    "playerfeedbacktool.accessurl": string;
                    "playerfeedbacktool.locale": string;
                    "playerfeedbacktool.shard": string;
                    "playerfeedbacktool.show": string;
                    "playerfeedbacktool.survey_request_rate_float": string;
                    "playscreen.partywidget.enabled": string;
                    "playscreen.partywidget.matchmaking.maxsize": string;
                    "playscreen.premier.enabled": string;
                    "premier.conferences.fetch.enabled": string;
                    "premier.leaderboardTab.enabled": string;
                    "premier.matchHistoryTab.enabled": string;
                    "premier.playscreenflow.enabled": string;
                    "premier.rosterEligibilityCheck.enabled": string;
                    "premier.seasons.activeseason.enabled": string;
                    "premier.seasons.fetch.enabled": string;
                    "queue.status.enabled": string;
                    "rchat.ingame.enabled": string;
                    "reporterfeedback.fetch.enabled": string;
                    "reporterfeedback.notifications.enabled": string;
                    "restrictions.v2.fetch.enabled": string;
                    "restrictions.v2.warnings.enabled": string;
                    "riotwarning.fetch.enabled": string;
                    "riotwarning.notifications.enabled": string;
                    "rnet.useAuthenticatedVoice": string;
                    "russia.voice.enabled": string;
                    "settings.livediagnostics.allowedplayers": string;
                    "shootingtest.enabled": string;
                    "skillrating.enabled": string;
                    "skillrating.inGame.enabled": string;
                    "skillrating.preGame.enabled": string;
                    "social.panel.v6.enabled": string;
                    "socialviewcontroller.enabled": string;
                    "socialviewcontroller.v2.enabled": string;
                    "store.isXgpDisabled": string;
                    "store.use_currency_inventory_models": string;
                    "store.use_platform_bundle_discounted_prices": string;
                    "telemetry.rtp.eventendpoint": string;
                    "telemetry.rtp.rfc190scope": string;
                    "temp.voice.allowmuting": string;
                    "tournaments.enabled": string;
                    "tournaments.pregame.enabled": string;
                    "vanguard.accessurl": string;
                    "vanguard.netrequired": string;
                    "voice.clutchmute.enabled": string;
                    "voice.clutchmute.prompt.enabled": string;
                    "voice.provider": string;
                    "whisper.enabled": string;
                };
            }>;
        };
    };
};

type Params$E = ResolveParams<(typeof _default$E)["~type"]["url"]>;
type Body$E = z.infer<ResolveValue<(typeof _default$E)["~type"], "body">>;
type Data$E = ResolveData<Params$E, Body$E>;
type Response$E = z.infer<ResolveValue<(typeof _default$E)["~type"], "responses">["200"]>;
interface ConfigRequestConfig extends ValorantAxiosRequestConfig<Data$E> {
}
declare class ConfigEndpoint {
    /**
     * Get the config for the given player
     *
     * @EndpointType pd
     */
    getConfig<T = Response$E>(this: RemoteApiClient, config: ConfigRequestConfig): Promise<AxiosResponse<T>>;
}

declare const _default$D: Omit<{
    requirements: string[];
    type: "auth" | "local" | "pd" | "glz" | "shared";
    name: string;
    method: "PUT" | "GET" | "DELETE" | "POST";
    url: string;
    description?: string | undefined;
    headers?: Record<string, string> | undefined;
    body?: zod.ZodType<any, zod.ZodTypeDef, any> | undefined;
    query?: zod.ZodType<any, zod.ZodTypeDef, any> | undefined;
    responses?: Record<string, zod.ZodType<any, zod.ZodTypeDef, any>> | undefined;
}, "type" | "name" | "url"> & Pick<{
    readonly name: "Contracts";
    readonly description: "Get contract details including agents, battlepass, missions, and recent games";
    readonly type: "pd";
    readonly url: "contracts/v1/contracts/:puuid";
    readonly responses: {
        readonly "200": zod.ZodObject<{
            Version: zod.ZodNumber;
            Subject: zod.ZodString;
            Contracts: zod.ZodArray<zod.ZodObject<{
                ContractDefinitionID: zod.ZodString;
                ContractProgression: zod.ZodObject<{
                    TotalProgressionEarned: zod.ZodNumber;
                    TotalProgressionEarnedVersion: zod.ZodNumber;
                    HighestRewardedLevel: zod.ZodRecord<zod.ZodString, zod.ZodObject<{
                        Amount: zod.ZodNumber;
                        Version: zod.ZodNumber;
                    }, "strip", zod.ZodTypeAny, {
                        Version: number;
                        Amount: number;
                    }, {
                        Version: number;
                        Amount: number;
                    }>>;
                }, "strip", zod.ZodTypeAny, {
                    TotalProgressionEarned: number;
                    TotalProgressionEarnedVersion: number;
                    HighestRewardedLevel: Record<string, {
                        Version: number;
                        Amount: number;
                    }>;
                }, {
                    TotalProgressionEarned: number;
                    TotalProgressionEarnedVersion: number;
                    HighestRewardedLevel: Record<string, {
                        Version: number;
                        Amount: number;
                    }>;
                }>;
                ProgressionLevelReached: zod.ZodNumber;
                ProgressionTowardsNextLevel: zod.ZodNumber;
            }, "strip", zod.ZodTypeAny, {
                ContractDefinitionID: string;
                ContractProgression: {
                    TotalProgressionEarned: number;
                    TotalProgressionEarnedVersion: number;
                    HighestRewardedLevel: Record<string, {
                        Version: number;
                        Amount: number;
                    }>;
                };
                ProgressionLevelReached: number;
                ProgressionTowardsNextLevel: number;
            }, {
                ContractDefinitionID: string;
                ContractProgression: {
                    TotalProgressionEarned: number;
                    TotalProgressionEarnedVersion: number;
                    HighestRewardedLevel: Record<string, {
                        Version: number;
                        Amount: number;
                    }>;
                };
                ProgressionLevelReached: number;
                ProgressionTowardsNextLevel: number;
            }>, "many">;
            ProcessedMatches: zod.ZodArray<zod.ZodObject<{
                ID: zod.ZodString;
                StartTime: zod.ZodEffects<zod.ZodNumber, Date, number>;
                XPGrants: zod.ZodNullable<zod.ZodObject<{
                    GamePlayed: zod.ZodNumber;
                    GameWon: zod.ZodNumber;
                    RoundPlayed: zod.ZodNumber;
                    RoundWon: zod.ZodNumber;
                    Missions: zod.ZodObject<{}, "strip", zod.ZodTypeAny, {}, {}>;
                    Modifier: zod.ZodObject<{
                        Value: zod.ZodNumber;
                        BaseMultiplierValue: zod.ZodNumber;
                        Modifiers: zod.ZodArray<zod.ZodObject<{
                            Value: zod.ZodNumber;
                            Name: zod.ZodEnum<["RESTRICTIONS_XP", "PREMIUM_CONTRACT_XP"]>;
                            BaseOnly: zod.ZodBoolean;
                        }, "strip", zod.ZodTypeAny, {
                            Value: number;
                            Name: "RESTRICTIONS_XP" | "PREMIUM_CONTRACT_XP";
                            BaseOnly: boolean;
                        }, {
                            Value: number;
                            Name: "RESTRICTIONS_XP" | "PREMIUM_CONTRACT_XP";
                            BaseOnly: boolean;
                        }>, "many">;
                    }, "strip", zod.ZodTypeAny, {
                        Value: number;
                        BaseMultiplierValue: number;
                        Modifiers: {
                            Value: number;
                            Name: "RESTRICTIONS_XP" | "PREMIUM_CONTRACT_XP";
                            BaseOnly: boolean;
                        }[];
                    }, {
                        Value: number;
                        BaseMultiplierValue: number;
                        Modifiers: {
                            Value: number;
                            Name: "RESTRICTIONS_XP" | "PREMIUM_CONTRACT_XP";
                            BaseOnly: boolean;
                        }[];
                    }>;
                    NumAFKRounds: zod.ZodNumber;
                }, "strip", zod.ZodTypeAny, {
                    GamePlayed: number;
                    GameWon: number;
                    RoundPlayed: number;
                    RoundWon: number;
                    Missions: {};
                    Modifier: {
                        Value: number;
                        BaseMultiplierValue: number;
                        Modifiers: {
                            Value: number;
                            Name: "RESTRICTIONS_XP" | "PREMIUM_CONTRACT_XP";
                            BaseOnly: boolean;
                        }[];
                    };
                    NumAFKRounds: number;
                }, {
                    GamePlayed: number;
                    GameWon: number;
                    RoundPlayed: number;
                    RoundWon: number;
                    Missions: {};
                    Modifier: {
                        Value: number;
                        BaseMultiplierValue: number;
                        Modifiers: {
                            Value: number;
                            Name: "RESTRICTIONS_XP" | "PREMIUM_CONTRACT_XP";
                            BaseOnly: boolean;
                        }[];
                    };
                    NumAFKRounds: number;
                }>>;
                RewardGrants: zod.ZodNullable<zod.ZodObject<{}, "strip", zod.ZodTypeAny, {}, {}>>;
                MissionDeltas: zod.ZodNullable<zod.ZodRecord<zod.ZodString, zod.ZodObject<{
                    ID: zod.ZodString;
                    Objectives: zod.ZodRecord<zod.ZodString, zod.ZodNumber>;
                    ObjectiveDeltas: zod.ZodRecord<zod.ZodString, zod.ZodObject<{
                        ID: zod.ZodString;
                        ProgressBefore: zod.ZodNumber;
                        ProgressAfter: zod.ZodNumber;
                    }, "strip", zod.ZodTypeAny, {
                        ID: string;
                        ProgressBefore: number;
                        ProgressAfter: number;
                    }, {
                        ID: string;
                        ProgressBefore: number;
                        ProgressAfter: number;
                    }>>;
                }, "strip", zod.ZodTypeAny, {
                    ID: string;
                    Objectives: Record<string, number>;
                    ObjectiveDeltas: Record<string, {
                        ID: string;
                        ProgressBefore: number;
                        ProgressAfter: number;
                    }>;
                }, {
                    ID: string;
                    Objectives: Record<string, number>;
                    ObjectiveDeltas: Record<string, {
                        ID: string;
                        ProgressBefore: number;
                        ProgressAfter: number;
                    }>;
                }>>>;
                ContractDeltas: zod.ZodNullable<zod.ZodRecord<zod.ZodString, zod.ZodObject<{
                    ID: zod.ZodString;
                    TotalXPBefore: zod.ZodNumber;
                    TotalXPAfter: zod.ZodNumber;
                }, "strip", zod.ZodTypeAny, {
                    ID: string;
                    TotalXPBefore: number;
                    TotalXPAfter: number;
                }, {
                    ID: string;
                    TotalXPBefore: number;
                    TotalXPAfter: number;
                }>>>;
                CouldProgressMissions: zod.ZodBoolean;
            }, "strip", zod.ZodTypeAny, {
                ID: string;
                StartTime: Date;
                XPGrants: {
                    GamePlayed: number;
                    GameWon: number;
                    RoundPlayed: number;
                    RoundWon: number;
                    Missions: {};
                    Modifier: {
                        Value: number;
                        BaseMultiplierValue: number;
                        Modifiers: {
                            Value: number;
                            Name: "RESTRICTIONS_XP" | "PREMIUM_CONTRACT_XP";
                            BaseOnly: boolean;
                        }[];
                    };
                    NumAFKRounds: number;
                } | null;
                RewardGrants: {} | null;
                MissionDeltas: Record<string, {
                    ID: string;
                    Objectives: Record<string, number>;
                    ObjectiveDeltas: Record<string, {
                        ID: string;
                        ProgressBefore: number;
                        ProgressAfter: number;
                    }>;
                }> | null;
                ContractDeltas: Record<string, {
                    ID: string;
                    TotalXPBefore: number;
                    TotalXPAfter: number;
                }> | null;
                CouldProgressMissions: boolean;
            }, {
                ID: string;
                StartTime: number;
                XPGrants: {
                    GamePlayed: number;
                    GameWon: number;
                    RoundPlayed: number;
                    RoundWon: number;
                    Missions: {};
                    Modifier: {
                        Value: number;
                        BaseMultiplierValue: number;
                        Modifiers: {
                            Value: number;
                            Name: "RESTRICTIONS_XP" | "PREMIUM_CONTRACT_XP";
                            BaseOnly: boolean;
                        }[];
                    };
                    NumAFKRounds: number;
                } | null;
                RewardGrants: {} | null;
                MissionDeltas: Record<string, {
                    ID: string;
                    Objectives: Record<string, number>;
                    ObjectiveDeltas: Record<string, {
                        ID: string;
                        ProgressBefore: number;
                        ProgressAfter: number;
                    }>;
                }> | null;
                ContractDeltas: Record<string, {
                    ID: string;
                    TotalXPBefore: number;
                    TotalXPAfter: number;
                }> | null;
                CouldProgressMissions: boolean;
            }>, "many">;
            ActiveSpecialContract: zod.ZodString;
            Missions: zod.ZodArray<zod.ZodObject<{
                ID: zod.ZodString;
                Objectives: zod.ZodRecord<zod.ZodString, zod.ZodNumber>;
                Complete: zod.ZodBoolean;
                ExpirationTime: zod.ZodEffects<zod.ZodString, Date, string>;
            }, "strip", zod.ZodTypeAny, {
                ID: string;
                Objectives: Record<string, number>;
                Complete: boolean;
                ExpirationTime: Date;
            }, {
                ID: string;
                Objectives: Record<string, number>;
                Complete: boolean;
                ExpirationTime: string;
            }>, "many">;
            MissionMetadata: zod.ZodObject<{
                NPECompleted: zod.ZodBoolean;
                WeeklyCheckpoint: zod.ZodEffects<zod.ZodString, Date, string>;
                WeeklyRefillTime: zod.ZodEffects<zod.ZodString, Date, string>;
            }, "strip", zod.ZodTypeAny, {
                NPECompleted: boolean;
                WeeklyCheckpoint: Date;
                WeeklyRefillTime: Date;
            }, {
                NPECompleted: boolean;
                WeeklyCheckpoint: string;
                WeeklyRefillTime: string;
            }>;
        }, "strip", zod.ZodTypeAny, {
            Subject: string;
            Version: number;
            Contracts: {
                ContractDefinitionID: string;
                ContractProgression: {
                    TotalProgressionEarned: number;
                    TotalProgressionEarnedVersion: number;
                    HighestRewardedLevel: Record<string, {
                        Version: number;
                        Amount: number;
                    }>;
                };
                ProgressionLevelReached: number;
                ProgressionTowardsNextLevel: number;
            }[];
            ProcessedMatches: {
                ID: string;
                StartTime: Date;
                XPGrants: {
                    GamePlayed: number;
                    GameWon: number;
                    RoundPlayed: number;
                    RoundWon: number;
                    Missions: {};
                    Modifier: {
                        Value: number;
                        BaseMultiplierValue: number;
                        Modifiers: {
                            Value: number;
                            Name: "RESTRICTIONS_XP" | "PREMIUM_CONTRACT_XP";
                            BaseOnly: boolean;
                        }[];
                    };
                    NumAFKRounds: number;
                } | null;
                RewardGrants: {} | null;
                MissionDeltas: Record<string, {
                    ID: string;
                    Objectives: Record<string, number>;
                    ObjectiveDeltas: Record<string, {
                        ID: string;
                        ProgressBefore: number;
                        ProgressAfter: number;
                    }>;
                }> | null;
                ContractDeltas: Record<string, {
                    ID: string;
                    TotalXPBefore: number;
                    TotalXPAfter: number;
                }> | null;
                CouldProgressMissions: boolean;
            }[];
            Missions: {
                ID: string;
                Objectives: Record<string, number>;
                Complete: boolean;
                ExpirationTime: Date;
            }[];
            ActiveSpecialContract: string;
            MissionMetadata: {
                NPECompleted: boolean;
                WeeklyCheckpoint: Date;
                WeeklyRefillTime: Date;
            };
        }, {
            Subject: string;
            Version: number;
            Contracts: {
                ContractDefinitionID: string;
                ContractProgression: {
                    TotalProgressionEarned: number;
                    TotalProgressionEarnedVersion: number;
                    HighestRewardedLevel: Record<string, {
                        Version: number;
                        Amount: number;
                    }>;
                };
                ProgressionLevelReached: number;
                ProgressionTowardsNextLevel: number;
            }[];
            ProcessedMatches: {
                ID: string;
                StartTime: number;
                XPGrants: {
                    GamePlayed: number;
                    GameWon: number;
                    RoundPlayed: number;
                    RoundWon: number;
                    Missions: {};
                    Modifier: {
                        Value: number;
                        BaseMultiplierValue: number;
                        Modifiers: {
                            Value: number;
                            Name: "RESTRICTIONS_XP" | "PREMIUM_CONTRACT_XP";
                            BaseOnly: boolean;
                        }[];
                    };
                    NumAFKRounds: number;
                } | null;
                RewardGrants: {} | null;
                MissionDeltas: Record<string, {
                    ID: string;
                    Objectives: Record<string, number>;
                    ObjectiveDeltas: Record<string, {
                        ID: string;
                        ProgressBefore: number;
                        ProgressAfter: number;
                    }>;
                }> | null;
                ContractDeltas: Record<string, {
                    ID: string;
                    TotalXPBefore: number;
                    TotalXPAfter: number;
                }> | null;
                CouldProgressMissions: boolean;
            }[];
            Missions: {
                ID: string;
                Objectives: Record<string, number>;
                Complete: boolean;
                ExpirationTime: string;
            }[];
            ActiveSpecialContract: string;
            MissionMetadata: {
                NPECompleted: boolean;
                WeeklyCheckpoint: string;
                WeeklyRefillTime: string;
            };
        }>;
    };
}, "type" | "name" | "url"> & {
    "~type": {
        readonly name: "Contracts";
        readonly description: "Get contract details including agents, battlepass, missions, and recent games";
        readonly type: "pd";
        readonly url: "contracts/v1/contracts/:puuid";
        readonly responses: {
            readonly "200": zod.ZodObject<{
                Version: zod.ZodNumber;
                Subject: zod.ZodString;
                Contracts: zod.ZodArray<zod.ZodObject<{
                    ContractDefinitionID: zod.ZodString;
                    ContractProgression: zod.ZodObject<{
                        TotalProgressionEarned: zod.ZodNumber;
                        TotalProgressionEarnedVersion: zod.ZodNumber;
                        HighestRewardedLevel: zod.ZodRecord<zod.ZodString, zod.ZodObject<{
                            Amount: zod.ZodNumber;
                            Version: zod.ZodNumber;
                        }, "strip", zod.ZodTypeAny, {
                            Version: number;
                            Amount: number;
                        }, {
                            Version: number;
                            Amount: number;
                        }>>;
                    }, "strip", zod.ZodTypeAny, {
                        TotalProgressionEarned: number;
                        TotalProgressionEarnedVersion: number;
                        HighestRewardedLevel: Record<string, {
                            Version: number;
                            Amount: number;
                        }>;
                    }, {
                        TotalProgressionEarned: number;
                        TotalProgressionEarnedVersion: number;
                        HighestRewardedLevel: Record<string, {
                            Version: number;
                            Amount: number;
                        }>;
                    }>;
                    ProgressionLevelReached: zod.ZodNumber;
                    ProgressionTowardsNextLevel: zod.ZodNumber;
                }, "strip", zod.ZodTypeAny, {
                    ContractDefinitionID: string;
                    ContractProgression: {
                        TotalProgressionEarned: number;
                        TotalProgressionEarnedVersion: number;
                        HighestRewardedLevel: Record<string, {
                            Version: number;
                            Amount: number;
                        }>;
                    };
                    ProgressionLevelReached: number;
                    ProgressionTowardsNextLevel: number;
                }, {
                    ContractDefinitionID: string;
                    ContractProgression: {
                        TotalProgressionEarned: number;
                        TotalProgressionEarnedVersion: number;
                        HighestRewardedLevel: Record<string, {
                            Version: number;
                            Amount: number;
                        }>;
                    };
                    ProgressionLevelReached: number;
                    ProgressionTowardsNextLevel: number;
                }>, "many">;
                ProcessedMatches: zod.ZodArray<zod.ZodObject<{
                    ID: zod.ZodString;
                    StartTime: zod.ZodEffects<zod.ZodNumber, Date, number>;
                    XPGrants: zod.ZodNullable<zod.ZodObject<{
                        GamePlayed: zod.ZodNumber;
                        GameWon: zod.ZodNumber;
                        RoundPlayed: zod.ZodNumber;
                        RoundWon: zod.ZodNumber;
                        Missions: zod.ZodObject<{}, "strip", zod.ZodTypeAny, {}, {}>;
                        Modifier: zod.ZodObject<{
                            Value: zod.ZodNumber;
                            BaseMultiplierValue: zod.ZodNumber;
                            Modifiers: zod.ZodArray<zod.ZodObject<{
                                Value: zod.ZodNumber;
                                Name: zod.ZodEnum<["RESTRICTIONS_XP", "PREMIUM_CONTRACT_XP"]>;
                                BaseOnly: zod.ZodBoolean;
                            }, "strip", zod.ZodTypeAny, {
                                Value: number;
                                Name: "RESTRICTIONS_XP" | "PREMIUM_CONTRACT_XP";
                                BaseOnly: boolean;
                            }, {
                                Value: number;
                                Name: "RESTRICTIONS_XP" | "PREMIUM_CONTRACT_XP";
                                BaseOnly: boolean;
                            }>, "many">;
                        }, "strip", zod.ZodTypeAny, {
                            Value: number;
                            BaseMultiplierValue: number;
                            Modifiers: {
                                Value: number;
                                Name: "RESTRICTIONS_XP" | "PREMIUM_CONTRACT_XP";
                                BaseOnly: boolean;
                            }[];
                        }, {
                            Value: number;
                            BaseMultiplierValue: number;
                            Modifiers: {
                                Value: number;
                                Name: "RESTRICTIONS_XP" | "PREMIUM_CONTRACT_XP";
                                BaseOnly: boolean;
                            }[];
                        }>;
                        NumAFKRounds: zod.ZodNumber;
                    }, "strip", zod.ZodTypeAny, {
                        GamePlayed: number;
                        GameWon: number;
                        RoundPlayed: number;
                        RoundWon: number;
                        Missions: {};
                        Modifier: {
                            Value: number;
                            BaseMultiplierValue: number;
                            Modifiers: {
                                Value: number;
                                Name: "RESTRICTIONS_XP" | "PREMIUM_CONTRACT_XP";
                                BaseOnly: boolean;
                            }[];
                        };
                        NumAFKRounds: number;
                    }, {
                        GamePlayed: number;
                        GameWon: number;
                        RoundPlayed: number;
                        RoundWon: number;
                        Missions: {};
                        Modifier: {
                            Value: number;
                            BaseMultiplierValue: number;
                            Modifiers: {
                                Value: number;
                                Name: "RESTRICTIONS_XP" | "PREMIUM_CONTRACT_XP";
                                BaseOnly: boolean;
                            }[];
                        };
                        NumAFKRounds: number;
                    }>>;
                    RewardGrants: zod.ZodNullable<zod.ZodObject<{}, "strip", zod.ZodTypeAny, {}, {}>>;
                    MissionDeltas: zod.ZodNullable<zod.ZodRecord<zod.ZodString, zod.ZodObject<{
                        ID: zod.ZodString;
                        Objectives: zod.ZodRecord<zod.ZodString, zod.ZodNumber>;
                        ObjectiveDeltas: zod.ZodRecord<zod.ZodString, zod.ZodObject<{
                            ID: zod.ZodString;
                            ProgressBefore: zod.ZodNumber;
                            ProgressAfter: zod.ZodNumber;
                        }, "strip", zod.ZodTypeAny, {
                            ID: string;
                            ProgressBefore: number;
                            ProgressAfter: number;
                        }, {
                            ID: string;
                            ProgressBefore: number;
                            ProgressAfter: number;
                        }>>;
                    }, "strip", zod.ZodTypeAny, {
                        ID: string;
                        Objectives: Record<string, number>;
                        ObjectiveDeltas: Record<string, {
                            ID: string;
                            ProgressBefore: number;
                            ProgressAfter: number;
                        }>;
                    }, {
                        ID: string;
                        Objectives: Record<string, number>;
                        ObjectiveDeltas: Record<string, {
                            ID: string;
                            ProgressBefore: number;
                            ProgressAfter: number;
                        }>;
                    }>>>;
                    ContractDeltas: zod.ZodNullable<zod.ZodRecord<zod.ZodString, zod.ZodObject<{
                        ID: zod.ZodString;
                        TotalXPBefore: zod.ZodNumber;
                        TotalXPAfter: zod.ZodNumber;
                    }, "strip", zod.ZodTypeAny, {
                        ID: string;
                        TotalXPBefore: number;
                        TotalXPAfter: number;
                    }, {
                        ID: string;
                        TotalXPBefore: number;
                        TotalXPAfter: number;
                    }>>>;
                    CouldProgressMissions: zod.ZodBoolean;
                }, "strip", zod.ZodTypeAny, {
                    ID: string;
                    StartTime: Date;
                    XPGrants: {
                        GamePlayed: number;
                        GameWon: number;
                        RoundPlayed: number;
                        RoundWon: number;
                        Missions: {};
                        Modifier: {
                            Value: number;
                            BaseMultiplierValue: number;
                            Modifiers: {
                                Value: number;
                                Name: "RESTRICTIONS_XP" | "PREMIUM_CONTRACT_XP";
                                BaseOnly: boolean;
                            }[];
                        };
                        NumAFKRounds: number;
                    } | null;
                    RewardGrants: {} | null;
                    MissionDeltas: Record<string, {
                        ID: string;
                        Objectives: Record<string, number>;
                        ObjectiveDeltas: Record<string, {
                            ID: string;
                            ProgressBefore: number;
                            ProgressAfter: number;
                        }>;
                    }> | null;
                    ContractDeltas: Record<string, {
                        ID: string;
                        TotalXPBefore: number;
                        TotalXPAfter: number;
                    }> | null;
                    CouldProgressMissions: boolean;
                }, {
                    ID: string;
                    StartTime: number;
                    XPGrants: {
                        GamePlayed: number;
                        GameWon: number;
                        RoundPlayed: number;
                        RoundWon: number;
                        Missions: {};
                        Modifier: {
                            Value: number;
                            BaseMultiplierValue: number;
                            Modifiers: {
                                Value: number;
                                Name: "RESTRICTIONS_XP" | "PREMIUM_CONTRACT_XP";
                                BaseOnly: boolean;
                            }[];
                        };
                        NumAFKRounds: number;
                    } | null;
                    RewardGrants: {} | null;
                    MissionDeltas: Record<string, {
                        ID: string;
                        Objectives: Record<string, number>;
                        ObjectiveDeltas: Record<string, {
                            ID: string;
                            ProgressBefore: number;
                            ProgressAfter: number;
                        }>;
                    }> | null;
                    ContractDeltas: Record<string, {
                        ID: string;
                        TotalXPBefore: number;
                        TotalXPAfter: number;
                    }> | null;
                    CouldProgressMissions: boolean;
                }>, "many">;
                ActiveSpecialContract: zod.ZodString;
                Missions: zod.ZodArray<zod.ZodObject<{
                    ID: zod.ZodString;
                    Objectives: zod.ZodRecord<zod.ZodString, zod.ZodNumber>;
                    Complete: zod.ZodBoolean;
                    ExpirationTime: zod.ZodEffects<zod.ZodString, Date, string>;
                }, "strip", zod.ZodTypeAny, {
                    ID: string;
                    Objectives: Record<string, number>;
                    Complete: boolean;
                    ExpirationTime: Date;
                }, {
                    ID: string;
                    Objectives: Record<string, number>;
                    Complete: boolean;
                    ExpirationTime: string;
                }>, "many">;
                MissionMetadata: zod.ZodObject<{
                    NPECompleted: zod.ZodBoolean;
                    WeeklyCheckpoint: zod.ZodEffects<zod.ZodString, Date, string>;
                    WeeklyRefillTime: zod.ZodEffects<zod.ZodString, Date, string>;
                }, "strip", zod.ZodTypeAny, {
                    NPECompleted: boolean;
                    WeeklyCheckpoint: Date;
                    WeeklyRefillTime: Date;
                }, {
                    NPECompleted: boolean;
                    WeeklyCheckpoint: string;
                    WeeklyRefillTime: string;
                }>;
            }, "strip", zod.ZodTypeAny, {
                Subject: string;
                Version: number;
                Contracts: {
                    ContractDefinitionID: string;
                    ContractProgression: {
                        TotalProgressionEarned: number;
                        TotalProgressionEarnedVersion: number;
                        HighestRewardedLevel: Record<string, {
                            Version: number;
                            Amount: number;
                        }>;
                    };
                    ProgressionLevelReached: number;
                    ProgressionTowardsNextLevel: number;
                }[];
                ProcessedMatches: {
                    ID: string;
                    StartTime: Date;
                    XPGrants: {
                        GamePlayed: number;
                        GameWon: number;
                        RoundPlayed: number;
                        RoundWon: number;
                        Missions: {};
                        Modifier: {
                            Value: number;
                            BaseMultiplierValue: number;
                            Modifiers: {
                                Value: number;
                                Name: "RESTRICTIONS_XP" | "PREMIUM_CONTRACT_XP";
                                BaseOnly: boolean;
                            }[];
                        };
                        NumAFKRounds: number;
                    } | null;
                    RewardGrants: {} | null;
                    MissionDeltas: Record<string, {
                        ID: string;
                        Objectives: Record<string, number>;
                        ObjectiveDeltas: Record<string, {
                            ID: string;
                            ProgressBefore: number;
                            ProgressAfter: number;
                        }>;
                    }> | null;
                    ContractDeltas: Record<string, {
                        ID: string;
                        TotalXPBefore: number;
                        TotalXPAfter: number;
                    }> | null;
                    CouldProgressMissions: boolean;
                }[];
                Missions: {
                    ID: string;
                    Objectives: Record<string, number>;
                    Complete: boolean;
                    ExpirationTime: Date;
                }[];
                ActiveSpecialContract: string;
                MissionMetadata: {
                    NPECompleted: boolean;
                    WeeklyCheckpoint: Date;
                    WeeklyRefillTime: Date;
                };
            }, {
                Subject: string;
                Version: number;
                Contracts: {
                    ContractDefinitionID: string;
                    ContractProgression: {
                        TotalProgressionEarned: number;
                        TotalProgressionEarnedVersion: number;
                        HighestRewardedLevel: Record<string, {
                            Version: number;
                            Amount: number;
                        }>;
                    };
                    ProgressionLevelReached: number;
                    ProgressionTowardsNextLevel: number;
                }[];
                ProcessedMatches: {
                    ID: string;
                    StartTime: number;
                    XPGrants: {
                        GamePlayed: number;
                        GameWon: number;
                        RoundPlayed: number;
                        RoundWon: number;
                        Missions: {};
                        Modifier: {
                            Value: number;
                            BaseMultiplierValue: number;
                            Modifiers: {
                                Value: number;
                                Name: "RESTRICTIONS_XP" | "PREMIUM_CONTRACT_XP";
                                BaseOnly: boolean;
                            }[];
                        };
                        NumAFKRounds: number;
                    } | null;
                    RewardGrants: {} | null;
                    MissionDeltas: Record<string, {
                        ID: string;
                        Objectives: Record<string, number>;
                        ObjectiveDeltas: Record<string, {
                            ID: string;
                            ProgressBefore: number;
                            ProgressAfter: number;
                        }>;
                    }> | null;
                    ContractDeltas: Record<string, {
                        ID: string;
                        TotalXPBefore: number;
                        TotalXPAfter: number;
                    }> | null;
                    CouldProgressMissions: boolean;
                }[];
                Missions: {
                    ID: string;
                    Objectives: Record<string, number>;
                    Complete: boolean;
                    ExpirationTime: string;
                }[];
                ActiveSpecialContract: string;
                MissionMetadata: {
                    NPECompleted: boolean;
                    WeeklyCheckpoint: string;
                    WeeklyRefillTime: string;
                };
            }>;
        };
    };
};

type Params$D = ResolveParams<(typeof _default$D)["~type"]["url"]>;
type Body$D = z.infer<ResolveValue<(typeof _default$D)["~type"], "body">>;
type Data$D = ResolveData<Params$D, Body$D>;
type Response$D = z.infer<ResolveValue<(typeof _default$D)["~type"], "responses">["200"]>;
interface ContractsRequestConfig extends ValorantAxiosRequestConfig<Data$D> {
}
declare class ContractsEndpoint {
    /**
     * Get contract details including agents, battlepass, missions, and recent games
     *
     * @EndpointType pd
     */
    getContracts<T = Response$D>(this: RemoteApiClient, config?: ContractsRequestConfig): Promise<AxiosResponse<T>>;
}

declare const itemUpgradesResponseSchema: z.ZodObject<{
    Definitions: z.ZodArray<z.ZodObject<{
        ID: z.ZodString;
        Item: z.ZodObject<{
            ItemTypeID: z.ZodString;
            ItemID: z.ZodString;
        }, "strip", z.ZodTypeAny, {
            ItemTypeID: string;
            ItemID: string;
        }, {
            ItemTypeID: string;
            ItemID: string;
        }>;
        RequiredEntitlement: z.ZodObject<{
            ItemTypeID: z.ZodString;
            ItemID: z.ZodString;
        }, "strip", z.ZodTypeAny, {
            ItemTypeID: string;
            ItemID: string;
        }, {
            ItemTypeID: string;
            ItemID: string;
        }>;
        ProgressionSchedule: z.ZodObject<{
            Name: z.ZodString;
            ProgressionCurrencyID: z.ZodString;
            ProgressionDeltaPerLevel: z.ZodNullable<z.ZodArray<z.ZodNumber, "many">>;
        }, "strip", z.ZodTypeAny, {
            Name: string;
            ProgressionCurrencyID: string;
            ProgressionDeltaPerLevel: number[] | null;
        }, {
            Name: string;
            ProgressionCurrencyID: string;
            ProgressionDeltaPerLevel: number[] | null;
        }>;
        RewardSchedule: z.ZodObject<{
            ID: z.ZodString;
            Name: z.ZodString;
            Prerequisites: z.ZodNull;
            RewardsPerLevel: z.ZodNullable<z.ZodArray<z.ZodObject<{
                EntitlementRewards: z.ZodArray<z.ZodObject<{
                    Amount: z.ZodNumber;
                } & {
                    ItemTypeID: z.ZodString;
                    ItemID: z.ZodString;
                }, "strip", z.ZodTypeAny, {
                    ItemTypeID: string;
                    ItemID: string;
                    Amount: number;
                }, {
                    ItemTypeID: string;
                    ItemID: string;
                    Amount: number;
                }>, "many">;
                WalletRewards: z.ZodNull;
                CounterRewards: z.ZodNull;
            }, "strip", z.ZodTypeAny, {
                EntitlementRewards: {
                    ItemTypeID: string;
                    ItemID: string;
                    Amount: number;
                }[];
                WalletRewards: null;
                CounterRewards: null;
            }, {
                EntitlementRewards: {
                    ItemTypeID: string;
                    ItemID: string;
                    Amount: number;
                }[];
                WalletRewards: null;
                CounterRewards: null;
            }>, "many">>;
        }, "strip", z.ZodTypeAny, {
            ID: string;
            Name: string;
            Prerequisites: null;
            RewardsPerLevel: {
                EntitlementRewards: {
                    ItemTypeID: string;
                    ItemID: string;
                    Amount: number;
                }[];
                WalletRewards: null;
                CounterRewards: null;
            }[] | null;
        }, {
            ID: string;
            Name: string;
            Prerequisites: null;
            RewardsPerLevel: {
                EntitlementRewards: {
                    ItemTypeID: string;
                    ItemID: string;
                    Amount: number;
                }[];
                WalletRewards: null;
                CounterRewards: null;
            }[] | null;
        }>;
        Sidegrades: z.ZodNullable<z.ZodArray<z.ZodObject<{
            SidegradeID: z.ZodString;
            Options: z.ZodArray<z.ZodObject<{
                OptionID: z.ZodString;
                Cost: z.ZodObject<{
                    WalletCosts: z.ZodArray<z.ZodObject<{
                        CurrencyID: z.ZodString;
                        AmountToDeduct: z.ZodNumber;
                    }, "strip", z.ZodTypeAny, {
                        CurrencyID: string;
                        AmountToDeduct: number;
                    }, {
                        CurrencyID: string;
                        AmountToDeduct: number;
                    }>, "many">;
                }, "strip", z.ZodTypeAny, {
                    WalletCosts: {
                        CurrencyID: string;
                        AmountToDeduct: number;
                    }[];
                }, {
                    WalletCosts: {
                        CurrencyID: string;
                        AmountToDeduct: number;
                    }[];
                }>;
                Rewards: z.ZodArray<z.ZodObject<{
                    Amount: z.ZodNumber;
                } & {
                    ItemTypeID: z.ZodString;
                    ItemID: z.ZodString;
                }, "strip", z.ZodTypeAny, {
                    ItemTypeID: string;
                    ItemID: string;
                    Amount: number;
                }, {
                    ItemTypeID: string;
                    ItemID: string;
                    Amount: number;
                }>, "many">;
            }, "strip", z.ZodTypeAny, {
                Cost: {
                    WalletCosts: {
                        CurrencyID: string;
                        AmountToDeduct: number;
                    }[];
                };
                Rewards: {
                    ItemTypeID: string;
                    ItemID: string;
                    Amount: number;
                }[];
                OptionID: string;
            }, {
                Cost: {
                    WalletCosts: {
                        CurrencyID: string;
                        AmountToDeduct: number;
                    }[];
                };
                Rewards: {
                    ItemTypeID: string;
                    ItemID: string;
                    Amount: number;
                }[];
                OptionID: string;
            }>, "many">;
            Prerequisites: z.ZodObject<{
                RequiredEntitlements: z.ZodArray<z.ZodObject<{
                    ItemTypeID: z.ZodString;
                    ItemID: z.ZodString;
                }, "strip", z.ZodTypeAny, {
                    ItemTypeID: string;
                    ItemID: string;
                }, {
                    ItemTypeID: string;
                    ItemID: string;
                }>, "many">;
            }, "strip", z.ZodTypeAny, {
                RequiredEntitlements: {
                    ItemTypeID: string;
                    ItemID: string;
                }[];
            }, {
                RequiredEntitlements: {
                    ItemTypeID: string;
                    ItemID: string;
                }[];
            }>;
        }, "strip", z.ZodTypeAny, {
            Prerequisites: {
                RequiredEntitlements: {
                    ItemTypeID: string;
                    ItemID: string;
                }[];
            };
            SidegradeID: string;
            Options: {
                Cost: {
                    WalletCosts: {
                        CurrencyID: string;
                        AmountToDeduct: number;
                    }[];
                };
                Rewards: {
                    ItemTypeID: string;
                    ItemID: string;
                    Amount: number;
                }[];
                OptionID: string;
            }[];
        }, {
            Prerequisites: {
                RequiredEntitlements: {
                    ItemTypeID: string;
                    ItemID: string;
                }[];
            };
            SidegradeID: string;
            Options: {
                Cost: {
                    WalletCosts: {
                        CurrencyID: string;
                        AmountToDeduct: number;
                    }[];
                };
                Rewards: {
                    ItemTypeID: string;
                    ItemID: string;
                    Amount: number;
                }[];
                OptionID: string;
            }[];
        }>, "many">>;
    }, "strip", z.ZodTypeAny, {
        ID: string;
        Item: {
            ItemTypeID: string;
            ItemID: string;
        };
        RequiredEntitlement: {
            ItemTypeID: string;
            ItemID: string;
        };
        ProgressionSchedule: {
            Name: string;
            ProgressionCurrencyID: string;
            ProgressionDeltaPerLevel: number[] | null;
        };
        RewardSchedule: {
            ID: string;
            Name: string;
            Prerequisites: null;
            RewardsPerLevel: {
                EntitlementRewards: {
                    ItemTypeID: string;
                    ItemID: string;
                    Amount: number;
                }[];
                WalletRewards: null;
                CounterRewards: null;
            }[] | null;
        };
        Sidegrades: {
            Prerequisites: {
                RequiredEntitlements: {
                    ItemTypeID: string;
                    ItemID: string;
                }[];
            };
            SidegradeID: string;
            Options: {
                Cost: {
                    WalletCosts: {
                        CurrencyID: string;
                        AmountToDeduct: number;
                    }[];
                };
                Rewards: {
                    ItemTypeID: string;
                    ItemID: string;
                    Amount: number;
                }[];
                OptionID: string;
            }[];
        }[] | null;
    }, {
        ID: string;
        Item: {
            ItemTypeID: string;
            ItemID: string;
        };
        RequiredEntitlement: {
            ItemTypeID: string;
            ItemID: string;
        };
        ProgressionSchedule: {
            Name: string;
            ProgressionCurrencyID: string;
            ProgressionDeltaPerLevel: number[] | null;
        };
        RewardSchedule: {
            ID: string;
            Name: string;
            Prerequisites: null;
            RewardsPerLevel: {
                EntitlementRewards: {
                    ItemTypeID: string;
                    ItemID: string;
                    Amount: number;
                }[];
                WalletRewards: null;
                CounterRewards: null;
            }[] | null;
        };
        Sidegrades: {
            Prerequisites: {
                RequiredEntitlements: {
                    ItemTypeID: string;
                    ItemID: string;
                }[];
            };
            SidegradeID: string;
            Options: {
                Cost: {
                    WalletCosts: {
                        CurrencyID: string;
                        AmountToDeduct: number;
                    }[];
                };
                Rewards: {
                    ItemTypeID: string;
                    ItemID: string;
                    Amount: number;
                }[];
                OptionID: string;
            }[];
        }[] | null;
    }>, "many">;
}, "strip", z.ZodTypeAny, {
    Definitions: {
        ID: string;
        Item: {
            ItemTypeID: string;
            ItemID: string;
        };
        RequiredEntitlement: {
            ItemTypeID: string;
            ItemID: string;
        };
        ProgressionSchedule: {
            Name: string;
            ProgressionCurrencyID: string;
            ProgressionDeltaPerLevel: number[] | null;
        };
        RewardSchedule: {
            ID: string;
            Name: string;
            Prerequisites: null;
            RewardsPerLevel: {
                EntitlementRewards: {
                    ItemTypeID: string;
                    ItemID: string;
                    Amount: number;
                }[];
                WalletRewards: null;
                CounterRewards: null;
            }[] | null;
        };
        Sidegrades: {
            Prerequisites: {
                RequiredEntitlements: {
                    ItemTypeID: string;
                    ItemID: string;
                }[];
            };
            SidegradeID: string;
            Options: {
                Cost: {
                    WalletCosts: {
                        CurrencyID: string;
                        AmountToDeduct: number;
                    }[];
                };
                Rewards: {
                    ItemTypeID: string;
                    ItemID: string;
                    Amount: number;
                }[];
                OptionID: string;
            }[];
        }[] | null;
    }[];
}, {
    Definitions: {
        ID: string;
        Item: {
            ItemTypeID: string;
            ItemID: string;
        };
        RequiredEntitlement: {
            ItemTypeID: string;
            ItemID: string;
        };
        ProgressionSchedule: {
            Name: string;
            ProgressionCurrencyID: string;
            ProgressionDeltaPerLevel: number[] | null;
        };
        RewardSchedule: {
            ID: string;
            Name: string;
            Prerequisites: null;
            RewardsPerLevel: {
                EntitlementRewards: {
                    ItemTypeID: string;
                    ItemID: string;
                    Amount: number;
                }[];
                WalletRewards: null;
                CounterRewards: null;
            }[] | null;
        };
        Sidegrades: {
            Prerequisites: {
                RequiredEntitlements: {
                    ItemTypeID: string;
                    ItemID: string;
                }[];
            };
            SidegradeID: string;
            Options: {
                Cost: {
                    WalletCosts: {
                        CurrencyID: string;
                        AmountToDeduct: number;
                    }[];
                };
                Rewards: {
                    ItemTypeID: string;
                    ItemID: string;
                    Amount: number;
                }[];
                OptionID: string;
            }[];
        }[] | null;
    }[];
}>;
declare const _default$C: Omit<{
    requirements: string[];
    type: "auth" | "local" | "pd" | "glz" | "shared";
    name: string;
    method: "PUT" | "GET" | "DELETE" | "POST";
    url: string;
    description?: string | undefined;
    headers?: Record<string, string> | undefined;
    body?: z.ZodType<any, z.ZodTypeDef, any> | undefined;
    query?: z.ZodType<any, z.ZodTypeDef, any> | undefined;
    responses?: Record<string, z.ZodType<any, z.ZodTypeDef, any>> | undefined;
}, "type" | "name" | "url"> & Pick<{
    readonly name: "Item Upgrades";
    readonly description: "Get details for item upgrades";
    readonly type: "pd";
    readonly url: "contract-definitions/v3/item-upgrades";
    readonly responses: {
        readonly "200": z.ZodObject<{
            Definitions: z.ZodArray<z.ZodObject<{
                ID: z.ZodString;
                Item: z.ZodObject<{
                    ItemTypeID: z.ZodString;
                    ItemID: z.ZodString;
                }, "strip", z.ZodTypeAny, {
                    ItemTypeID: string;
                    ItemID: string;
                }, {
                    ItemTypeID: string;
                    ItemID: string;
                }>;
                RequiredEntitlement: z.ZodObject<{
                    ItemTypeID: z.ZodString;
                    ItemID: z.ZodString;
                }, "strip", z.ZodTypeAny, {
                    ItemTypeID: string;
                    ItemID: string;
                }, {
                    ItemTypeID: string;
                    ItemID: string;
                }>;
                ProgressionSchedule: z.ZodObject<{
                    Name: z.ZodString;
                    ProgressionCurrencyID: z.ZodString;
                    ProgressionDeltaPerLevel: z.ZodNullable<z.ZodArray<z.ZodNumber, "many">>;
                }, "strip", z.ZodTypeAny, {
                    Name: string;
                    ProgressionCurrencyID: string;
                    ProgressionDeltaPerLevel: number[] | null;
                }, {
                    Name: string;
                    ProgressionCurrencyID: string;
                    ProgressionDeltaPerLevel: number[] | null;
                }>;
                RewardSchedule: z.ZodObject<{
                    ID: z.ZodString;
                    Name: z.ZodString;
                    Prerequisites: z.ZodNull;
                    RewardsPerLevel: z.ZodNullable<z.ZodArray<z.ZodObject<{
                        EntitlementRewards: z.ZodArray<z.ZodObject<{
                            Amount: z.ZodNumber;
                        } & {
                            ItemTypeID: z.ZodString;
                            ItemID: z.ZodString;
                        }, "strip", z.ZodTypeAny, {
                            ItemTypeID: string;
                            ItemID: string;
                            Amount: number;
                        }, {
                            ItemTypeID: string;
                            ItemID: string;
                            Amount: number;
                        }>, "many">;
                        WalletRewards: z.ZodNull;
                        CounterRewards: z.ZodNull;
                    }, "strip", z.ZodTypeAny, {
                        EntitlementRewards: {
                            ItemTypeID: string;
                            ItemID: string;
                            Amount: number;
                        }[];
                        WalletRewards: null;
                        CounterRewards: null;
                    }, {
                        EntitlementRewards: {
                            ItemTypeID: string;
                            ItemID: string;
                            Amount: number;
                        }[];
                        WalletRewards: null;
                        CounterRewards: null;
                    }>, "many">>;
                }, "strip", z.ZodTypeAny, {
                    ID: string;
                    Name: string;
                    Prerequisites: null;
                    RewardsPerLevel: {
                        EntitlementRewards: {
                            ItemTypeID: string;
                            ItemID: string;
                            Amount: number;
                        }[];
                        WalletRewards: null;
                        CounterRewards: null;
                    }[] | null;
                }, {
                    ID: string;
                    Name: string;
                    Prerequisites: null;
                    RewardsPerLevel: {
                        EntitlementRewards: {
                            ItemTypeID: string;
                            ItemID: string;
                            Amount: number;
                        }[];
                        WalletRewards: null;
                        CounterRewards: null;
                    }[] | null;
                }>;
                Sidegrades: z.ZodNullable<z.ZodArray<z.ZodObject<{
                    SidegradeID: z.ZodString;
                    Options: z.ZodArray<z.ZodObject<{
                        OptionID: z.ZodString;
                        Cost: z.ZodObject<{
                            WalletCosts: z.ZodArray<z.ZodObject<{
                                CurrencyID: z.ZodString;
                                AmountToDeduct: z.ZodNumber;
                            }, "strip", z.ZodTypeAny, {
                                CurrencyID: string;
                                AmountToDeduct: number;
                            }, {
                                CurrencyID: string;
                                AmountToDeduct: number;
                            }>, "many">;
                        }, "strip", z.ZodTypeAny, {
                            WalletCosts: {
                                CurrencyID: string;
                                AmountToDeduct: number;
                            }[];
                        }, {
                            WalletCosts: {
                                CurrencyID: string;
                                AmountToDeduct: number;
                            }[];
                        }>;
                        Rewards: z.ZodArray<z.ZodObject<{
                            Amount: z.ZodNumber;
                        } & {
                            ItemTypeID: z.ZodString;
                            ItemID: z.ZodString;
                        }, "strip", z.ZodTypeAny, {
                            ItemTypeID: string;
                            ItemID: string;
                            Amount: number;
                        }, {
                            ItemTypeID: string;
                            ItemID: string;
                            Amount: number;
                        }>, "many">;
                    }, "strip", z.ZodTypeAny, {
                        Cost: {
                            WalletCosts: {
                                CurrencyID: string;
                                AmountToDeduct: number;
                            }[];
                        };
                        Rewards: {
                            ItemTypeID: string;
                            ItemID: string;
                            Amount: number;
                        }[];
                        OptionID: string;
                    }, {
                        Cost: {
                            WalletCosts: {
                                CurrencyID: string;
                                AmountToDeduct: number;
                            }[];
                        };
                        Rewards: {
                            ItemTypeID: string;
                            ItemID: string;
                            Amount: number;
                        }[];
                        OptionID: string;
                    }>, "many">;
                    Prerequisites: z.ZodObject<{
                        RequiredEntitlements: z.ZodArray<z.ZodObject<{
                            ItemTypeID: z.ZodString;
                            ItemID: z.ZodString;
                        }, "strip", z.ZodTypeAny, {
                            ItemTypeID: string;
                            ItemID: string;
                        }, {
                            ItemTypeID: string;
                            ItemID: string;
                        }>, "many">;
                    }, "strip", z.ZodTypeAny, {
                        RequiredEntitlements: {
                            ItemTypeID: string;
                            ItemID: string;
                        }[];
                    }, {
                        RequiredEntitlements: {
                            ItemTypeID: string;
                            ItemID: string;
                        }[];
                    }>;
                }, "strip", z.ZodTypeAny, {
                    Prerequisites: {
                        RequiredEntitlements: {
                            ItemTypeID: string;
                            ItemID: string;
                        }[];
                    };
                    SidegradeID: string;
                    Options: {
                        Cost: {
                            WalletCosts: {
                                CurrencyID: string;
                                AmountToDeduct: number;
                            }[];
                        };
                        Rewards: {
                            ItemTypeID: string;
                            ItemID: string;
                            Amount: number;
                        }[];
                        OptionID: string;
                    }[];
                }, {
                    Prerequisites: {
                        RequiredEntitlements: {
                            ItemTypeID: string;
                            ItemID: string;
                        }[];
                    };
                    SidegradeID: string;
                    Options: {
                        Cost: {
                            WalletCosts: {
                                CurrencyID: string;
                                AmountToDeduct: number;
                            }[];
                        };
                        Rewards: {
                            ItemTypeID: string;
                            ItemID: string;
                            Amount: number;
                        }[];
                        OptionID: string;
                    }[];
                }>, "many">>;
            }, "strip", z.ZodTypeAny, {
                ID: string;
                Item: {
                    ItemTypeID: string;
                    ItemID: string;
                };
                RequiredEntitlement: {
                    ItemTypeID: string;
                    ItemID: string;
                };
                ProgressionSchedule: {
                    Name: string;
                    ProgressionCurrencyID: string;
                    ProgressionDeltaPerLevel: number[] | null;
                };
                RewardSchedule: {
                    ID: string;
                    Name: string;
                    Prerequisites: null;
                    RewardsPerLevel: {
                        EntitlementRewards: {
                            ItemTypeID: string;
                            ItemID: string;
                            Amount: number;
                        }[];
                        WalletRewards: null;
                        CounterRewards: null;
                    }[] | null;
                };
                Sidegrades: {
                    Prerequisites: {
                        RequiredEntitlements: {
                            ItemTypeID: string;
                            ItemID: string;
                        }[];
                    };
                    SidegradeID: string;
                    Options: {
                        Cost: {
                            WalletCosts: {
                                CurrencyID: string;
                                AmountToDeduct: number;
                            }[];
                        };
                        Rewards: {
                            ItemTypeID: string;
                            ItemID: string;
                            Amount: number;
                        }[];
                        OptionID: string;
                    }[];
                }[] | null;
            }, {
                ID: string;
                Item: {
                    ItemTypeID: string;
                    ItemID: string;
                };
                RequiredEntitlement: {
                    ItemTypeID: string;
                    ItemID: string;
                };
                ProgressionSchedule: {
                    Name: string;
                    ProgressionCurrencyID: string;
                    ProgressionDeltaPerLevel: number[] | null;
                };
                RewardSchedule: {
                    ID: string;
                    Name: string;
                    Prerequisites: null;
                    RewardsPerLevel: {
                        EntitlementRewards: {
                            ItemTypeID: string;
                            ItemID: string;
                            Amount: number;
                        }[];
                        WalletRewards: null;
                        CounterRewards: null;
                    }[] | null;
                };
                Sidegrades: {
                    Prerequisites: {
                        RequiredEntitlements: {
                            ItemTypeID: string;
                            ItemID: string;
                        }[];
                    };
                    SidegradeID: string;
                    Options: {
                        Cost: {
                            WalletCosts: {
                                CurrencyID: string;
                                AmountToDeduct: number;
                            }[];
                        };
                        Rewards: {
                            ItemTypeID: string;
                            ItemID: string;
                            Amount: number;
                        }[];
                        OptionID: string;
                    }[];
                }[] | null;
            }>, "many">;
        }, "strip", z.ZodTypeAny, {
            Definitions: {
                ID: string;
                Item: {
                    ItemTypeID: string;
                    ItemID: string;
                };
                RequiredEntitlement: {
                    ItemTypeID: string;
                    ItemID: string;
                };
                ProgressionSchedule: {
                    Name: string;
                    ProgressionCurrencyID: string;
                    ProgressionDeltaPerLevel: number[] | null;
                };
                RewardSchedule: {
                    ID: string;
                    Name: string;
                    Prerequisites: null;
                    RewardsPerLevel: {
                        EntitlementRewards: {
                            ItemTypeID: string;
                            ItemID: string;
                            Amount: number;
                        }[];
                        WalletRewards: null;
                        CounterRewards: null;
                    }[] | null;
                };
                Sidegrades: {
                    Prerequisites: {
                        RequiredEntitlements: {
                            ItemTypeID: string;
                            ItemID: string;
                        }[];
                    };
                    SidegradeID: string;
                    Options: {
                        Cost: {
                            WalletCosts: {
                                CurrencyID: string;
                                AmountToDeduct: number;
                            }[];
                        };
                        Rewards: {
                            ItemTypeID: string;
                            ItemID: string;
                            Amount: number;
                        }[];
                        OptionID: string;
                    }[];
                }[] | null;
            }[];
        }, {
            Definitions: {
                ID: string;
                Item: {
                    ItemTypeID: string;
                    ItemID: string;
                };
                RequiredEntitlement: {
                    ItemTypeID: string;
                    ItemID: string;
                };
                ProgressionSchedule: {
                    Name: string;
                    ProgressionCurrencyID: string;
                    ProgressionDeltaPerLevel: number[] | null;
                };
                RewardSchedule: {
                    ID: string;
                    Name: string;
                    Prerequisites: null;
                    RewardsPerLevel: {
                        EntitlementRewards: {
                            ItemTypeID: string;
                            ItemID: string;
                            Amount: number;
                        }[];
                        WalletRewards: null;
                        CounterRewards: null;
                    }[] | null;
                };
                Sidegrades: {
                    Prerequisites: {
                        RequiredEntitlements: {
                            ItemTypeID: string;
                            ItemID: string;
                        }[];
                    };
                    SidegradeID: string;
                    Options: {
                        Cost: {
                            WalletCosts: {
                                CurrencyID: string;
                                AmountToDeduct: number;
                            }[];
                        };
                        Rewards: {
                            ItemTypeID: string;
                            ItemID: string;
                            Amount: number;
                        }[];
                        OptionID: string;
                    }[];
                }[] | null;
            }[];
        }>;
    };
}, "type" | "name" | "url"> & {
    "~type": {
        readonly name: "Item Upgrades";
        readonly description: "Get details for item upgrades";
        readonly type: "pd";
        readonly url: "contract-definitions/v3/item-upgrades";
        readonly responses: {
            readonly "200": z.ZodObject<{
                Definitions: z.ZodArray<z.ZodObject<{
                    ID: z.ZodString;
                    Item: z.ZodObject<{
                        ItemTypeID: z.ZodString;
                        ItemID: z.ZodString;
                    }, "strip", z.ZodTypeAny, {
                        ItemTypeID: string;
                        ItemID: string;
                    }, {
                        ItemTypeID: string;
                        ItemID: string;
                    }>;
                    RequiredEntitlement: z.ZodObject<{
                        ItemTypeID: z.ZodString;
                        ItemID: z.ZodString;
                    }, "strip", z.ZodTypeAny, {
                        ItemTypeID: string;
                        ItemID: string;
                    }, {
                        ItemTypeID: string;
                        ItemID: string;
                    }>;
                    ProgressionSchedule: z.ZodObject<{
                        Name: z.ZodString;
                        ProgressionCurrencyID: z.ZodString;
                        ProgressionDeltaPerLevel: z.ZodNullable<z.ZodArray<z.ZodNumber, "many">>;
                    }, "strip", z.ZodTypeAny, {
                        Name: string;
                        ProgressionCurrencyID: string;
                        ProgressionDeltaPerLevel: number[] | null;
                    }, {
                        Name: string;
                        ProgressionCurrencyID: string;
                        ProgressionDeltaPerLevel: number[] | null;
                    }>;
                    RewardSchedule: z.ZodObject<{
                        ID: z.ZodString;
                        Name: z.ZodString;
                        Prerequisites: z.ZodNull;
                        RewardsPerLevel: z.ZodNullable<z.ZodArray<z.ZodObject<{
                            EntitlementRewards: z.ZodArray<z.ZodObject<{
                                Amount: z.ZodNumber;
                            } & {
                                ItemTypeID: z.ZodString;
                                ItemID: z.ZodString;
                            }, "strip", z.ZodTypeAny, {
                                ItemTypeID: string;
                                ItemID: string;
                                Amount: number;
                            }, {
                                ItemTypeID: string;
                                ItemID: string;
                                Amount: number;
                            }>, "many">;
                            WalletRewards: z.ZodNull;
                            CounterRewards: z.ZodNull;
                        }, "strip", z.ZodTypeAny, {
                            EntitlementRewards: {
                                ItemTypeID: string;
                                ItemID: string;
                                Amount: number;
                            }[];
                            WalletRewards: null;
                            CounterRewards: null;
                        }, {
                            EntitlementRewards: {
                                ItemTypeID: string;
                                ItemID: string;
                                Amount: number;
                            }[];
                            WalletRewards: null;
                            CounterRewards: null;
                        }>, "many">>;
                    }, "strip", z.ZodTypeAny, {
                        ID: string;
                        Name: string;
                        Prerequisites: null;
                        RewardsPerLevel: {
                            EntitlementRewards: {
                                ItemTypeID: string;
                                ItemID: string;
                                Amount: number;
                            }[];
                            WalletRewards: null;
                            CounterRewards: null;
                        }[] | null;
                    }, {
                        ID: string;
                        Name: string;
                        Prerequisites: null;
                        RewardsPerLevel: {
                            EntitlementRewards: {
                                ItemTypeID: string;
                                ItemID: string;
                                Amount: number;
                            }[];
                            WalletRewards: null;
                            CounterRewards: null;
                        }[] | null;
                    }>;
                    Sidegrades: z.ZodNullable<z.ZodArray<z.ZodObject<{
                        SidegradeID: z.ZodString;
                        Options: z.ZodArray<z.ZodObject<{
                            OptionID: z.ZodString;
                            Cost: z.ZodObject<{
                                WalletCosts: z.ZodArray<z.ZodObject<{
                                    CurrencyID: z.ZodString;
                                    AmountToDeduct: z.ZodNumber;
                                }, "strip", z.ZodTypeAny, {
                                    CurrencyID: string;
                                    AmountToDeduct: number;
                                }, {
                                    CurrencyID: string;
                                    AmountToDeduct: number;
                                }>, "many">;
                            }, "strip", z.ZodTypeAny, {
                                WalletCosts: {
                                    CurrencyID: string;
                                    AmountToDeduct: number;
                                }[];
                            }, {
                                WalletCosts: {
                                    CurrencyID: string;
                                    AmountToDeduct: number;
                                }[];
                            }>;
                            Rewards: z.ZodArray<z.ZodObject<{
                                Amount: z.ZodNumber;
                            } & {
                                ItemTypeID: z.ZodString;
                                ItemID: z.ZodString;
                            }, "strip", z.ZodTypeAny, {
                                ItemTypeID: string;
                                ItemID: string;
                                Amount: number;
                            }, {
                                ItemTypeID: string;
                                ItemID: string;
                                Amount: number;
                            }>, "many">;
                        }, "strip", z.ZodTypeAny, {
                            Cost: {
                                WalletCosts: {
                                    CurrencyID: string;
                                    AmountToDeduct: number;
                                }[];
                            };
                            Rewards: {
                                ItemTypeID: string;
                                ItemID: string;
                                Amount: number;
                            }[];
                            OptionID: string;
                        }, {
                            Cost: {
                                WalletCosts: {
                                    CurrencyID: string;
                                    AmountToDeduct: number;
                                }[];
                            };
                            Rewards: {
                                ItemTypeID: string;
                                ItemID: string;
                                Amount: number;
                            }[];
                            OptionID: string;
                        }>, "many">;
                        Prerequisites: z.ZodObject<{
                            RequiredEntitlements: z.ZodArray<z.ZodObject<{
                                ItemTypeID: z.ZodString;
                                ItemID: z.ZodString;
                            }, "strip", z.ZodTypeAny, {
                                ItemTypeID: string;
                                ItemID: string;
                            }, {
                                ItemTypeID: string;
                                ItemID: string;
                            }>, "many">;
                        }, "strip", z.ZodTypeAny, {
                            RequiredEntitlements: {
                                ItemTypeID: string;
                                ItemID: string;
                            }[];
                        }, {
                            RequiredEntitlements: {
                                ItemTypeID: string;
                                ItemID: string;
                            }[];
                        }>;
                    }, "strip", z.ZodTypeAny, {
                        Prerequisites: {
                            RequiredEntitlements: {
                                ItemTypeID: string;
                                ItemID: string;
                            }[];
                        };
                        SidegradeID: string;
                        Options: {
                            Cost: {
                                WalletCosts: {
                                    CurrencyID: string;
                                    AmountToDeduct: number;
                                }[];
                            };
                            Rewards: {
                                ItemTypeID: string;
                                ItemID: string;
                                Amount: number;
                            }[];
                            OptionID: string;
                        }[];
                    }, {
                        Prerequisites: {
                            RequiredEntitlements: {
                                ItemTypeID: string;
                                ItemID: string;
                            }[];
                        };
                        SidegradeID: string;
                        Options: {
                            Cost: {
                                WalletCosts: {
                                    CurrencyID: string;
                                    AmountToDeduct: number;
                                }[];
                            };
                            Rewards: {
                                ItemTypeID: string;
                                ItemID: string;
                                Amount: number;
                            }[];
                            OptionID: string;
                        }[];
                    }>, "many">>;
                }, "strip", z.ZodTypeAny, {
                    ID: string;
                    Item: {
                        ItemTypeID: string;
                        ItemID: string;
                    };
                    RequiredEntitlement: {
                        ItemTypeID: string;
                        ItemID: string;
                    };
                    ProgressionSchedule: {
                        Name: string;
                        ProgressionCurrencyID: string;
                        ProgressionDeltaPerLevel: number[] | null;
                    };
                    RewardSchedule: {
                        ID: string;
                        Name: string;
                        Prerequisites: null;
                        RewardsPerLevel: {
                            EntitlementRewards: {
                                ItemTypeID: string;
                                ItemID: string;
                                Amount: number;
                            }[];
                            WalletRewards: null;
                            CounterRewards: null;
                        }[] | null;
                    };
                    Sidegrades: {
                        Prerequisites: {
                            RequiredEntitlements: {
                                ItemTypeID: string;
                                ItemID: string;
                            }[];
                        };
                        SidegradeID: string;
                        Options: {
                            Cost: {
                                WalletCosts: {
                                    CurrencyID: string;
                                    AmountToDeduct: number;
                                }[];
                            };
                            Rewards: {
                                ItemTypeID: string;
                                ItemID: string;
                                Amount: number;
                            }[];
                            OptionID: string;
                        }[];
                    }[] | null;
                }, {
                    ID: string;
                    Item: {
                        ItemTypeID: string;
                        ItemID: string;
                    };
                    RequiredEntitlement: {
                        ItemTypeID: string;
                        ItemID: string;
                    };
                    ProgressionSchedule: {
                        Name: string;
                        ProgressionCurrencyID: string;
                        ProgressionDeltaPerLevel: number[] | null;
                    };
                    RewardSchedule: {
                        ID: string;
                        Name: string;
                        Prerequisites: null;
                        RewardsPerLevel: {
                            EntitlementRewards: {
                                ItemTypeID: string;
                                ItemID: string;
                                Amount: number;
                            }[];
                            WalletRewards: null;
                            CounterRewards: null;
                        }[] | null;
                    };
                    Sidegrades: {
                        Prerequisites: {
                            RequiredEntitlements: {
                                ItemTypeID: string;
                                ItemID: string;
                            }[];
                        };
                        SidegradeID: string;
                        Options: {
                            Cost: {
                                WalletCosts: {
                                    CurrencyID: string;
                                    AmountToDeduct: number;
                                }[];
                            };
                            Rewards: {
                                ItemTypeID: string;
                                ItemID: string;
                                Amount: number;
                            }[];
                            OptionID: string;
                        }[];
                    }[] | null;
                }>, "many">;
            }, "strip", z.ZodTypeAny, {
                Definitions: {
                    ID: string;
                    Item: {
                        ItemTypeID: string;
                        ItemID: string;
                    };
                    RequiredEntitlement: {
                        ItemTypeID: string;
                        ItemID: string;
                    };
                    ProgressionSchedule: {
                        Name: string;
                        ProgressionCurrencyID: string;
                        ProgressionDeltaPerLevel: number[] | null;
                    };
                    RewardSchedule: {
                        ID: string;
                        Name: string;
                        Prerequisites: null;
                        RewardsPerLevel: {
                            EntitlementRewards: {
                                ItemTypeID: string;
                                ItemID: string;
                                Amount: number;
                            }[];
                            WalletRewards: null;
                            CounterRewards: null;
                        }[] | null;
                    };
                    Sidegrades: {
                        Prerequisites: {
                            RequiredEntitlements: {
                                ItemTypeID: string;
                                ItemID: string;
                            }[];
                        };
                        SidegradeID: string;
                        Options: {
                            Cost: {
                                WalletCosts: {
                                    CurrencyID: string;
                                    AmountToDeduct: number;
                                }[];
                            };
                            Rewards: {
                                ItemTypeID: string;
                                ItemID: string;
                                Amount: number;
                            }[];
                            OptionID: string;
                        }[];
                    }[] | null;
                }[];
            }, {
                Definitions: {
                    ID: string;
                    Item: {
                        ItemTypeID: string;
                        ItemID: string;
                    };
                    RequiredEntitlement: {
                        ItemTypeID: string;
                        ItemID: string;
                    };
                    ProgressionSchedule: {
                        Name: string;
                        ProgressionCurrencyID: string;
                        ProgressionDeltaPerLevel: number[] | null;
                    };
                    RewardSchedule: {
                        ID: string;
                        Name: string;
                        Prerequisites: null;
                        RewardsPerLevel: {
                            EntitlementRewards: {
                                ItemTypeID: string;
                                ItemID: string;
                                Amount: number;
                            }[];
                            WalletRewards: null;
                            CounterRewards: null;
                        }[] | null;
                    };
                    Sidegrades: {
                        Prerequisites: {
                            RequiredEntitlements: {
                                ItemTypeID: string;
                                ItemID: string;
                            }[];
                        };
                        SidegradeID: string;
                        Options: {
                            Cost: {
                                WalletCosts: {
                                    CurrencyID: string;
                                    AmountToDeduct: number;
                                }[];
                            };
                            Rewards: {
                                ItemTypeID: string;
                                ItemID: string;
                                Amount: number;
                            }[];
                            OptionID: string;
                        }[];
                    }[] | null;
                }[];
            }>;
        };
    };
};

type Params$C = ResolveParams<(typeof _default$C)["~type"]["url"]>;
type Body$C = z.infer<ResolveValue<(typeof _default$C)["~type"], "body">>;
type Data$C = ResolveData<Params$C, Body$C>;
type Response$C = z.infer<ResolveValue<(typeof _default$C)["~type"], "responses">["200"]>;
interface ItemUpgradesRequestConfig extends ValorantAxiosRequestConfig<Data$C> {
}
declare class ItemUpgradesEndpoint {
    /**
     * Get details for item upgrades
     *
     * @EndpointType pd
     */
    getItemUpgrades<T = Response$C>(this: RemoteApiClient, config?: ItemUpgradesRequestConfig): Promise<AxiosResponse<T>>;
}

declare const matchInfoSchema: z.ZodObject<{
    matchId: z.ZodString;
    mapId: z.ZodString;
    gamePodId: z.ZodString;
    gameLoopZone: z.ZodString;
    gameServerAddress: z.ZodString;
    gameVersion: z.ZodString;
    gameLengthMillis: z.ZodEffects<z.ZodNumber, Date, number>;
    gameStartMillis: z.ZodEffects<z.ZodNumber, Date, number>;
    provisioningFlowID: z.ZodEnum<["Matchmaking", "CustomGame"]>;
    isCompleted: z.ZodBoolean;
    customGameName: z.ZodString;
    forcePostProcessing: z.ZodBoolean;
    queueID: z.ZodString;
    gameMode: z.ZodString;
    isRanked: z.ZodBoolean;
    isMatchSampled: z.ZodBoolean;
    seasonId: z.ZodString;
    completionState: z.ZodEnum<["Surrendered", "Completed", "VoteDraw", ""]>;
    platformType: z.ZodString;
    premierMatchInfo: z.ZodObject<{}, "strip", z.ZodTypeAny, {}, {}>;
    partyRRPenalties: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodNumber>>;
    shouldMatchDisablePenalties: z.ZodBoolean;
}, "strip", z.ZodTypeAny, {
    platformType: string;
    gameMode: string;
    mapId: string;
    customGameName: string;
    matchId: string;
    gamePodId: string;
    gameLoopZone: string;
    gameServerAddress: string;
    gameVersion: string;
    gameLengthMillis: Date;
    gameStartMillis: Date;
    provisioningFlowID: "Matchmaking" | "CustomGame";
    isCompleted: boolean;
    forcePostProcessing: boolean;
    queueID: string;
    isRanked: boolean;
    isMatchSampled: boolean;
    seasonId: string;
    completionState: "" | "Surrendered" | "Completed" | "VoteDraw";
    premierMatchInfo: {};
    shouldMatchDisablePenalties: boolean;
    partyRRPenalties?: Record<string, number> | undefined;
}, {
    platformType: string;
    gameMode: string;
    mapId: string;
    customGameName: string;
    matchId: string;
    gamePodId: string;
    gameLoopZone: string;
    gameServerAddress: string;
    gameVersion: string;
    gameLengthMillis: number;
    gameStartMillis: number;
    provisioningFlowID: "Matchmaking" | "CustomGame";
    isCompleted: boolean;
    forcePostProcessing: boolean;
    queueID: string;
    isRanked: boolean;
    isMatchSampled: boolean;
    seasonId: string;
    completionState: "" | "Surrendered" | "Completed" | "VoteDraw";
    premierMatchInfo: {};
    shouldMatchDisablePenalties: boolean;
    partyRRPenalties?: Record<string, number> | undefined;
}>;
declare const matchPlayerSchema: z.ZodObject<{
    subject: z.ZodString;
    gameName: z.ZodString;
    tagLine: z.ZodString;
    platformInfo: z.ZodObject<{
        platformType: z.ZodString;
        platformOS: z.ZodString;
        platformOSVersion: z.ZodString;
        platformChipset: z.ZodString;
    }, "strip", z.ZodTypeAny, {
        platformType: string;
        platformOS: string;
        platformOSVersion: string;
        platformChipset: string;
    }, {
        platformType: string;
        platformOS: string;
        platformOSVersion: string;
        platformChipset: string;
    }>;
    teamId: z.ZodEnum<["Blue", "Red"]>;
    partyId: z.ZodString;
    characterId: z.ZodString;
    stats: z.ZodObject<{
        score: z.ZodNumber;
        roundsPlayed: z.ZodNumber;
        kills: z.ZodNumber;
        deaths: z.ZodNumber;
        assists: z.ZodNumber;
        playtimeMillis: z.ZodEffects<z.ZodNumber, Date, number>;
        abilityCasts: z.ZodOptional<z.ZodNullable<z.ZodObject<{
            grenadeCasts: z.ZodNumber;
            ability1Casts: z.ZodNumber;
            ability2Casts: z.ZodNumber;
            ultimateCasts: z.ZodNumber;
        }, "strip", z.ZodTypeAny, {
            grenadeCasts: number;
            ability1Casts: number;
            ability2Casts: number;
            ultimateCasts: number;
        }, {
            grenadeCasts: number;
            ability1Casts: number;
            ability2Casts: number;
            ultimateCasts: number;
        }>>>;
    }, "strip", z.ZodTypeAny, {
        score: number;
        roundsPlayed: number;
        kills: number;
        deaths: number;
        assists: number;
        playtimeMillis: Date;
        abilityCasts?: {
            grenadeCasts: number;
            ability1Casts: number;
            ability2Casts: number;
            ultimateCasts: number;
        } | null | undefined;
    }, {
        score: number;
        roundsPlayed: number;
        kills: number;
        deaths: number;
        assists: number;
        playtimeMillis: number;
        abilityCasts?: {
            grenadeCasts: number;
            ability1Casts: number;
            ability2Casts: number;
            ultimateCasts: number;
        } | null | undefined;
    }>;
    roundDamage: z.ZodArray<z.ZodObject<{
        round: z.ZodNumber;
        receiver: z.ZodString;
        damage: z.ZodNumber;
    }, "strip", z.ZodTypeAny, {
        round: number;
        receiver: string;
        damage: number;
    }, {
        round: number;
        receiver: string;
        damage: number;
    }>, "many">;
    competitiveTier: z.ZodNumber;
    isObserver: z.ZodBoolean;
    playerCard: z.ZodString;
    playerTitle: z.ZodString;
    preferredLevelBorder: z.ZodOptional<z.ZodString>;
    accountLevel: z.ZodNumber;
    sessionPlaytimeMinutes: z.ZodOptional<z.ZodNumber>;
    xpModifications: z.ZodOptional<z.ZodArray<z.ZodObject<{
        Value: z.ZodNumber;
        ID: z.ZodString;
    }, "strip", z.ZodTypeAny, {
        ID: string;
        Value: number;
    }, {
        ID: string;
        Value: number;
    }>, "many">>;
    behaviorFactors: z.ZodOptional<z.ZodObject<{
        afkRounds: z.ZodNumber;
        collisions: z.ZodOptional<z.ZodNumber>;
        commsRatingRecovery: z.ZodNumber;
        damageParticipationOutgoing: z.ZodNumber;
        friendlyFireIncoming: z.ZodOptional<z.ZodNumber>;
        friendlyFireOutgoing: z.ZodOptional<z.ZodNumber>;
        mouseMovement: z.ZodOptional<z.ZodNumber>;
        stayedInSpawnRounds: z.ZodOptional<z.ZodNumber>;
    }, "strip", z.ZodTypeAny, {
        afkRounds: number;
        commsRatingRecovery: number;
        damageParticipationOutgoing: number;
        collisions?: number | undefined;
        friendlyFireIncoming?: number | undefined;
        friendlyFireOutgoing?: number | undefined;
        mouseMovement?: number | undefined;
        stayedInSpawnRounds?: number | undefined;
    }, {
        afkRounds: number;
        commsRatingRecovery: number;
        damageParticipationOutgoing: number;
        collisions?: number | undefined;
        friendlyFireIncoming?: number | undefined;
        friendlyFireOutgoing?: number | undefined;
        mouseMovement?: number | undefined;
        stayedInSpawnRounds?: number | undefined;
    }>>;
    newPlayerExperienceDetails: z.ZodOptional<z.ZodObject<{
        basicMovement: z.ZodObject<{
            idleTimeMillis: z.ZodNumber;
            objectiveCompleteTimeMillis: z.ZodNumber;
        }, "strip", z.ZodTypeAny, {
            idleTimeMillis: number;
            objectiveCompleteTimeMillis: number;
        }, {
            idleTimeMillis: number;
            objectiveCompleteTimeMillis: number;
        }>;
        basicGunSkill: z.ZodObject<{
            idleTimeMillis: z.ZodNumber;
            objectiveCompleteTimeMillis: z.ZodNumber;
        }, "strip", z.ZodTypeAny, {
            idleTimeMillis: number;
            objectiveCompleteTimeMillis: number;
        }, {
            idleTimeMillis: number;
            objectiveCompleteTimeMillis: number;
        }>;
        adaptiveBots: z.ZodObject<{
            adaptiveBotAverageDurationMillisAllAttempts: z.ZodNumber;
            adaptiveBotAverageDurationMillisFirstAttempt: z.ZodNumber;
            killDetailsFirstAttempt: z.ZodNull;
            idleTimeMillis: z.ZodNumber;
            objectiveCompleteTimeMillis: z.ZodNumber;
        }, "strip", z.ZodTypeAny, {
            idleTimeMillis: number;
            objectiveCompleteTimeMillis: number;
            adaptiveBotAverageDurationMillisAllAttempts: number;
            adaptiveBotAverageDurationMillisFirstAttempt: number;
            killDetailsFirstAttempt: null;
        }, {
            idleTimeMillis: number;
            objectiveCompleteTimeMillis: number;
            adaptiveBotAverageDurationMillisAllAttempts: number;
            adaptiveBotAverageDurationMillisFirstAttempt: number;
            killDetailsFirstAttempt: null;
        }>;
        ability: z.ZodObject<{
            idleTimeMillis: z.ZodNumber;
            objectiveCompleteTimeMillis: z.ZodNumber;
        }, "strip", z.ZodTypeAny, {
            idleTimeMillis: number;
            objectiveCompleteTimeMillis: number;
        }, {
            idleTimeMillis: number;
            objectiveCompleteTimeMillis: number;
        }>;
        bombPlant: z.ZodObject<{
            idleTimeMillis: z.ZodNumber;
            objectiveCompleteTimeMillis: z.ZodNumber;
        }, "strip", z.ZodTypeAny, {
            idleTimeMillis: number;
            objectiveCompleteTimeMillis: number;
        }, {
            idleTimeMillis: number;
            objectiveCompleteTimeMillis: number;
        }>;
        defendBombSite: z.ZodObject<{
            success: z.ZodBoolean;
            idleTimeMillis: z.ZodNumber;
            objectiveCompleteTimeMillis: z.ZodNumber;
        }, "strip", z.ZodTypeAny, {
            success: boolean;
            idleTimeMillis: number;
            objectiveCompleteTimeMillis: number;
        }, {
            success: boolean;
            idleTimeMillis: number;
            objectiveCompleteTimeMillis: number;
        }>;
        settingStatus: z.ZodObject<{
            isMouseSensitivityDefault: z.ZodBoolean;
            isCrosshairDefault: z.ZodBoolean;
        }, "strip", z.ZodTypeAny, {
            isMouseSensitivityDefault: boolean;
            isCrosshairDefault: boolean;
        }, {
            isMouseSensitivityDefault: boolean;
            isCrosshairDefault: boolean;
        }>;
        versionString: z.ZodString;
    }, "strip", z.ZodTypeAny, {
        basicMovement: {
            idleTimeMillis: number;
            objectiveCompleteTimeMillis: number;
        };
        basicGunSkill: {
            idleTimeMillis: number;
            objectiveCompleteTimeMillis: number;
        };
        adaptiveBots: {
            idleTimeMillis: number;
            objectiveCompleteTimeMillis: number;
            adaptiveBotAverageDurationMillisAllAttempts: number;
            adaptiveBotAverageDurationMillisFirstAttempt: number;
            killDetailsFirstAttempt: null;
        };
        ability: {
            idleTimeMillis: number;
            objectiveCompleteTimeMillis: number;
        };
        bombPlant: {
            idleTimeMillis: number;
            objectiveCompleteTimeMillis: number;
        };
        defendBombSite: {
            success: boolean;
            idleTimeMillis: number;
            objectiveCompleteTimeMillis: number;
        };
        settingStatus: {
            isMouseSensitivityDefault: boolean;
            isCrosshairDefault: boolean;
        };
        versionString: string;
    }, {
        basicMovement: {
            idleTimeMillis: number;
            objectiveCompleteTimeMillis: number;
        };
        basicGunSkill: {
            idleTimeMillis: number;
            objectiveCompleteTimeMillis: number;
        };
        adaptiveBots: {
            idleTimeMillis: number;
            objectiveCompleteTimeMillis: number;
            adaptiveBotAverageDurationMillisAllAttempts: number;
            adaptiveBotAverageDurationMillisFirstAttempt: number;
            killDetailsFirstAttempt: null;
        };
        ability: {
            idleTimeMillis: number;
            objectiveCompleteTimeMillis: number;
        };
        bombPlant: {
            idleTimeMillis: number;
            objectiveCompleteTimeMillis: number;
        };
        defendBombSite: {
            success: boolean;
            idleTimeMillis: number;
            objectiveCompleteTimeMillis: number;
        };
        settingStatus: {
            isMouseSensitivityDefault: boolean;
            isCrosshairDefault: boolean;
        };
        versionString: string;
    }>>;
}, "strip", z.ZodTypeAny, {
    platformInfo: {
        platformType: string;
        platformOS: string;
        platformOSVersion: string;
        platformChipset: string;
    };
    subject: string;
    partyId: string;
    accountLevel: number;
    competitiveTier: number;
    gameName: string;
    tagLine: string;
    teamId: "Blue" | "Red";
    characterId: string;
    stats: {
        score: number;
        roundsPlayed: number;
        kills: number;
        deaths: number;
        assists: number;
        playtimeMillis: Date;
        abilityCasts?: {
            grenadeCasts: number;
            ability1Casts: number;
            ability2Casts: number;
            ultimateCasts: number;
        } | null | undefined;
    };
    roundDamage: {
        round: number;
        receiver: string;
        damage: number;
    }[];
    isObserver: boolean;
    playerCard: string;
    playerTitle: string;
    preferredLevelBorder?: string | undefined;
    sessionPlaytimeMinutes?: number | undefined;
    xpModifications?: {
        ID: string;
        Value: number;
    }[] | undefined;
    behaviorFactors?: {
        afkRounds: number;
        commsRatingRecovery: number;
        damageParticipationOutgoing: number;
        collisions?: number | undefined;
        friendlyFireIncoming?: number | undefined;
        friendlyFireOutgoing?: number | undefined;
        mouseMovement?: number | undefined;
        stayedInSpawnRounds?: number | undefined;
    } | undefined;
    newPlayerExperienceDetails?: {
        basicMovement: {
            idleTimeMillis: number;
            objectiveCompleteTimeMillis: number;
        };
        basicGunSkill: {
            idleTimeMillis: number;
            objectiveCompleteTimeMillis: number;
        };
        adaptiveBots: {
            idleTimeMillis: number;
            objectiveCompleteTimeMillis: number;
            adaptiveBotAverageDurationMillisAllAttempts: number;
            adaptiveBotAverageDurationMillisFirstAttempt: number;
            killDetailsFirstAttempt: null;
        };
        ability: {
            idleTimeMillis: number;
            objectiveCompleteTimeMillis: number;
        };
        bombPlant: {
            idleTimeMillis: number;
            objectiveCompleteTimeMillis: number;
        };
        defendBombSite: {
            success: boolean;
            idleTimeMillis: number;
            objectiveCompleteTimeMillis: number;
        };
        settingStatus: {
            isMouseSensitivityDefault: boolean;
            isCrosshairDefault: boolean;
        };
        versionString: string;
    } | undefined;
}, {
    platformInfo: {
        platformType: string;
        platformOS: string;
        platformOSVersion: string;
        platformChipset: string;
    };
    subject: string;
    partyId: string;
    accountLevel: number;
    competitiveTier: number;
    gameName: string;
    tagLine: string;
    teamId: "Blue" | "Red";
    characterId: string;
    stats: {
        score: number;
        roundsPlayed: number;
        kills: number;
        deaths: number;
        assists: number;
        playtimeMillis: number;
        abilityCasts?: {
            grenadeCasts: number;
            ability1Casts: number;
            ability2Casts: number;
            ultimateCasts: number;
        } | null | undefined;
    };
    roundDamage: {
        round: number;
        receiver: string;
        damage: number;
    }[];
    isObserver: boolean;
    playerCard: string;
    playerTitle: string;
    preferredLevelBorder?: string | undefined;
    sessionPlaytimeMinutes?: number | undefined;
    xpModifications?: {
        ID: string;
        Value: number;
    }[] | undefined;
    behaviorFactors?: {
        afkRounds: number;
        commsRatingRecovery: number;
        damageParticipationOutgoing: number;
        collisions?: number | undefined;
        friendlyFireIncoming?: number | undefined;
        friendlyFireOutgoing?: number | undefined;
        mouseMovement?: number | undefined;
        stayedInSpawnRounds?: number | undefined;
    } | undefined;
    newPlayerExperienceDetails?: {
        basicMovement: {
            idleTimeMillis: number;
            objectiveCompleteTimeMillis: number;
        };
        basicGunSkill: {
            idleTimeMillis: number;
            objectiveCompleteTimeMillis: number;
        };
        adaptiveBots: {
            idleTimeMillis: number;
            objectiveCompleteTimeMillis: number;
            adaptiveBotAverageDurationMillisAllAttempts: number;
            adaptiveBotAverageDurationMillisFirstAttempt: number;
            killDetailsFirstAttempt: null;
        };
        ability: {
            idleTimeMillis: number;
            objectiveCompleteTimeMillis: number;
        };
        bombPlant: {
            idleTimeMillis: number;
            objectiveCompleteTimeMillis: number;
        };
        defendBombSite: {
            success: boolean;
            idleTimeMillis: number;
            objectiveCompleteTimeMillis: number;
        };
        settingStatus: {
            isMouseSensitivityDefault: boolean;
            isCrosshairDefault: boolean;
        };
        versionString: string;
    } | undefined;
}>;
declare const matchDetailsResponseSchema: z.ZodObject<{
    matchInfo: z.ZodObject<{
        matchId: z.ZodString;
        mapId: z.ZodString;
        gamePodId: z.ZodString;
        gameLoopZone: z.ZodString;
        gameServerAddress: z.ZodString;
        gameVersion: z.ZodString;
        gameLengthMillis: z.ZodEffects<z.ZodNumber, Date, number>;
        gameStartMillis: z.ZodEffects<z.ZodNumber, Date, number>;
        provisioningFlowID: z.ZodEnum<["Matchmaking", "CustomGame"]>;
        isCompleted: z.ZodBoolean;
        customGameName: z.ZodString;
        forcePostProcessing: z.ZodBoolean;
        queueID: z.ZodString;
        gameMode: z.ZodString;
        isRanked: z.ZodBoolean;
        isMatchSampled: z.ZodBoolean;
        seasonId: z.ZodString;
        completionState: z.ZodEnum<["Surrendered", "Completed", "VoteDraw", ""]>;
        platformType: z.ZodString;
        premierMatchInfo: z.ZodObject<{}, "strip", z.ZodTypeAny, {}, {}>;
        partyRRPenalties: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodNumber>>;
        shouldMatchDisablePenalties: z.ZodBoolean;
    }, "strip", z.ZodTypeAny, {
        platformType: string;
        gameMode: string;
        mapId: string;
        customGameName: string;
        matchId: string;
        gamePodId: string;
        gameLoopZone: string;
        gameServerAddress: string;
        gameVersion: string;
        gameLengthMillis: Date;
        gameStartMillis: Date;
        provisioningFlowID: "Matchmaking" | "CustomGame";
        isCompleted: boolean;
        forcePostProcessing: boolean;
        queueID: string;
        isRanked: boolean;
        isMatchSampled: boolean;
        seasonId: string;
        completionState: "" | "Surrendered" | "Completed" | "VoteDraw";
        premierMatchInfo: {};
        shouldMatchDisablePenalties: boolean;
        partyRRPenalties?: Record<string, number> | undefined;
    }, {
        platformType: string;
        gameMode: string;
        mapId: string;
        customGameName: string;
        matchId: string;
        gamePodId: string;
        gameLoopZone: string;
        gameServerAddress: string;
        gameVersion: string;
        gameLengthMillis: number;
        gameStartMillis: number;
        provisioningFlowID: "Matchmaking" | "CustomGame";
        isCompleted: boolean;
        forcePostProcessing: boolean;
        queueID: string;
        isRanked: boolean;
        isMatchSampled: boolean;
        seasonId: string;
        completionState: "" | "Surrendered" | "Completed" | "VoteDraw";
        premierMatchInfo: {};
        shouldMatchDisablePenalties: boolean;
        partyRRPenalties?: Record<string, number> | undefined;
    }>;
    players: z.ZodArray<z.ZodObject<{
        subject: z.ZodString;
        gameName: z.ZodString;
        tagLine: z.ZodString;
        platformInfo: z.ZodObject<{
            platformType: z.ZodString;
            platformOS: z.ZodString;
            platformOSVersion: z.ZodString;
            platformChipset: z.ZodString;
        }, "strip", z.ZodTypeAny, {
            platformType: string;
            platformOS: string;
            platformOSVersion: string;
            platformChipset: string;
        }, {
            platformType: string;
            platformOS: string;
            platformOSVersion: string;
            platformChipset: string;
        }>;
        teamId: z.ZodEnum<["Blue", "Red"]>;
        partyId: z.ZodString;
        characterId: z.ZodString;
        stats: z.ZodObject<{
            score: z.ZodNumber;
            roundsPlayed: z.ZodNumber;
            kills: z.ZodNumber;
            deaths: z.ZodNumber;
            assists: z.ZodNumber;
            playtimeMillis: z.ZodEffects<z.ZodNumber, Date, number>;
            abilityCasts: z.ZodOptional<z.ZodNullable<z.ZodObject<{
                grenadeCasts: z.ZodNumber;
                ability1Casts: z.ZodNumber;
                ability2Casts: z.ZodNumber;
                ultimateCasts: z.ZodNumber;
            }, "strip", z.ZodTypeAny, {
                grenadeCasts: number;
                ability1Casts: number;
                ability2Casts: number;
                ultimateCasts: number;
            }, {
                grenadeCasts: number;
                ability1Casts: number;
                ability2Casts: number;
                ultimateCasts: number;
            }>>>;
        }, "strip", z.ZodTypeAny, {
            score: number;
            roundsPlayed: number;
            kills: number;
            deaths: number;
            assists: number;
            playtimeMillis: Date;
            abilityCasts?: {
                grenadeCasts: number;
                ability1Casts: number;
                ability2Casts: number;
                ultimateCasts: number;
            } | null | undefined;
        }, {
            score: number;
            roundsPlayed: number;
            kills: number;
            deaths: number;
            assists: number;
            playtimeMillis: number;
            abilityCasts?: {
                grenadeCasts: number;
                ability1Casts: number;
                ability2Casts: number;
                ultimateCasts: number;
            } | null | undefined;
        }>;
        roundDamage: z.ZodArray<z.ZodObject<{
            round: z.ZodNumber;
            receiver: z.ZodString;
            damage: z.ZodNumber;
        }, "strip", z.ZodTypeAny, {
            round: number;
            receiver: string;
            damage: number;
        }, {
            round: number;
            receiver: string;
            damage: number;
        }>, "many">;
        competitiveTier: z.ZodNumber;
        isObserver: z.ZodBoolean;
        playerCard: z.ZodString;
        playerTitle: z.ZodString;
        preferredLevelBorder: z.ZodOptional<z.ZodString>;
        accountLevel: z.ZodNumber;
        sessionPlaytimeMinutes: z.ZodOptional<z.ZodNumber>;
        xpModifications: z.ZodOptional<z.ZodArray<z.ZodObject<{
            Value: z.ZodNumber;
            ID: z.ZodString;
        }, "strip", z.ZodTypeAny, {
            ID: string;
            Value: number;
        }, {
            ID: string;
            Value: number;
        }>, "many">>;
        behaviorFactors: z.ZodOptional<z.ZodObject<{
            afkRounds: z.ZodNumber;
            collisions: z.ZodOptional<z.ZodNumber>;
            commsRatingRecovery: z.ZodNumber;
            damageParticipationOutgoing: z.ZodNumber;
            friendlyFireIncoming: z.ZodOptional<z.ZodNumber>;
            friendlyFireOutgoing: z.ZodOptional<z.ZodNumber>;
            mouseMovement: z.ZodOptional<z.ZodNumber>;
            stayedInSpawnRounds: z.ZodOptional<z.ZodNumber>;
        }, "strip", z.ZodTypeAny, {
            afkRounds: number;
            commsRatingRecovery: number;
            damageParticipationOutgoing: number;
            collisions?: number | undefined;
            friendlyFireIncoming?: number | undefined;
            friendlyFireOutgoing?: number | undefined;
            mouseMovement?: number | undefined;
            stayedInSpawnRounds?: number | undefined;
        }, {
            afkRounds: number;
            commsRatingRecovery: number;
            damageParticipationOutgoing: number;
            collisions?: number | undefined;
            friendlyFireIncoming?: number | undefined;
            friendlyFireOutgoing?: number | undefined;
            mouseMovement?: number | undefined;
            stayedInSpawnRounds?: number | undefined;
        }>>;
        newPlayerExperienceDetails: z.ZodOptional<z.ZodObject<{
            basicMovement: z.ZodObject<{
                idleTimeMillis: z.ZodNumber;
                objectiveCompleteTimeMillis: z.ZodNumber;
            }, "strip", z.ZodTypeAny, {
                idleTimeMillis: number;
                objectiveCompleteTimeMillis: number;
            }, {
                idleTimeMillis: number;
                objectiveCompleteTimeMillis: number;
            }>;
            basicGunSkill: z.ZodObject<{
                idleTimeMillis: z.ZodNumber;
                objectiveCompleteTimeMillis: z.ZodNumber;
            }, "strip", z.ZodTypeAny, {
                idleTimeMillis: number;
                objectiveCompleteTimeMillis: number;
            }, {
                idleTimeMillis: number;
                objectiveCompleteTimeMillis: number;
            }>;
            adaptiveBots: z.ZodObject<{
                adaptiveBotAverageDurationMillisAllAttempts: z.ZodNumber;
                adaptiveBotAverageDurationMillisFirstAttempt: z.ZodNumber;
                killDetailsFirstAttempt: z.ZodNull;
                idleTimeMillis: z.ZodNumber;
                objectiveCompleteTimeMillis: z.ZodNumber;
            }, "strip", z.ZodTypeAny, {
                idleTimeMillis: number;
                objectiveCompleteTimeMillis: number;
                adaptiveBotAverageDurationMillisAllAttempts: number;
                adaptiveBotAverageDurationMillisFirstAttempt: number;
                killDetailsFirstAttempt: null;
            }, {
                idleTimeMillis: number;
                objectiveCompleteTimeMillis: number;
                adaptiveBotAverageDurationMillisAllAttempts: number;
                adaptiveBotAverageDurationMillisFirstAttempt: number;
                killDetailsFirstAttempt: null;
            }>;
            ability: z.ZodObject<{
                idleTimeMillis: z.ZodNumber;
                objectiveCompleteTimeMillis: z.ZodNumber;
            }, "strip", z.ZodTypeAny, {
                idleTimeMillis: number;
                objectiveCompleteTimeMillis: number;
            }, {
                idleTimeMillis: number;
                objectiveCompleteTimeMillis: number;
            }>;
            bombPlant: z.ZodObject<{
                idleTimeMillis: z.ZodNumber;
                objectiveCompleteTimeMillis: z.ZodNumber;
            }, "strip", z.ZodTypeAny, {
                idleTimeMillis: number;
                objectiveCompleteTimeMillis: number;
            }, {
                idleTimeMillis: number;
                objectiveCompleteTimeMillis: number;
            }>;
            defendBombSite: z.ZodObject<{
                success: z.ZodBoolean;
                idleTimeMillis: z.ZodNumber;
                objectiveCompleteTimeMillis: z.ZodNumber;
            }, "strip", z.ZodTypeAny, {
                success: boolean;
                idleTimeMillis: number;
                objectiveCompleteTimeMillis: number;
            }, {
                success: boolean;
                idleTimeMillis: number;
                objectiveCompleteTimeMillis: number;
            }>;
            settingStatus: z.ZodObject<{
                isMouseSensitivityDefault: z.ZodBoolean;
                isCrosshairDefault: z.ZodBoolean;
            }, "strip", z.ZodTypeAny, {
                isMouseSensitivityDefault: boolean;
                isCrosshairDefault: boolean;
            }, {
                isMouseSensitivityDefault: boolean;
                isCrosshairDefault: boolean;
            }>;
            versionString: z.ZodString;
        }, "strip", z.ZodTypeAny, {
            basicMovement: {
                idleTimeMillis: number;
                objectiveCompleteTimeMillis: number;
            };
            basicGunSkill: {
                idleTimeMillis: number;
                objectiveCompleteTimeMillis: number;
            };
            adaptiveBots: {
                idleTimeMillis: number;
                objectiveCompleteTimeMillis: number;
                adaptiveBotAverageDurationMillisAllAttempts: number;
                adaptiveBotAverageDurationMillisFirstAttempt: number;
                killDetailsFirstAttempt: null;
            };
            ability: {
                idleTimeMillis: number;
                objectiveCompleteTimeMillis: number;
            };
            bombPlant: {
                idleTimeMillis: number;
                objectiveCompleteTimeMillis: number;
            };
            defendBombSite: {
                success: boolean;
                idleTimeMillis: number;
                objectiveCompleteTimeMillis: number;
            };
            settingStatus: {
                isMouseSensitivityDefault: boolean;
                isCrosshairDefault: boolean;
            };
            versionString: string;
        }, {
            basicMovement: {
                idleTimeMillis: number;
                objectiveCompleteTimeMillis: number;
            };
            basicGunSkill: {
                idleTimeMillis: number;
                objectiveCompleteTimeMillis: number;
            };
            adaptiveBots: {
                idleTimeMillis: number;
                objectiveCompleteTimeMillis: number;
                adaptiveBotAverageDurationMillisAllAttempts: number;
                adaptiveBotAverageDurationMillisFirstAttempt: number;
                killDetailsFirstAttempt: null;
            };
            ability: {
                idleTimeMillis: number;
                objectiveCompleteTimeMillis: number;
            };
            bombPlant: {
                idleTimeMillis: number;
                objectiveCompleteTimeMillis: number;
            };
            defendBombSite: {
                success: boolean;
                idleTimeMillis: number;
                objectiveCompleteTimeMillis: number;
            };
            settingStatus: {
                isMouseSensitivityDefault: boolean;
                isCrosshairDefault: boolean;
            };
            versionString: string;
        }>>;
    }, "strip", z.ZodTypeAny, {
        platformInfo: {
            platformType: string;
            platformOS: string;
            platformOSVersion: string;
            platformChipset: string;
        };
        subject: string;
        partyId: string;
        accountLevel: number;
        competitiveTier: number;
        gameName: string;
        tagLine: string;
        teamId: "Blue" | "Red";
        characterId: string;
        stats: {
            score: number;
            roundsPlayed: number;
            kills: number;
            deaths: number;
            assists: number;
            playtimeMillis: Date;
            abilityCasts?: {
                grenadeCasts: number;
                ability1Casts: number;
                ability2Casts: number;
                ultimateCasts: number;
            } | null | undefined;
        };
        roundDamage: {
            round: number;
            receiver: string;
            damage: number;
        }[];
        isObserver: boolean;
        playerCard: string;
        playerTitle: string;
        preferredLevelBorder?: string | undefined;
        sessionPlaytimeMinutes?: number | undefined;
        xpModifications?: {
            ID: string;
            Value: number;
        }[] | undefined;
        behaviorFactors?: {
            afkRounds: number;
            commsRatingRecovery: number;
            damageParticipationOutgoing: number;
            collisions?: number | undefined;
            friendlyFireIncoming?: number | undefined;
            friendlyFireOutgoing?: number | undefined;
            mouseMovement?: number | undefined;
            stayedInSpawnRounds?: number | undefined;
        } | undefined;
        newPlayerExperienceDetails?: {
            basicMovement: {
                idleTimeMillis: number;
                objectiveCompleteTimeMillis: number;
            };
            basicGunSkill: {
                idleTimeMillis: number;
                objectiveCompleteTimeMillis: number;
            };
            adaptiveBots: {
                idleTimeMillis: number;
                objectiveCompleteTimeMillis: number;
                adaptiveBotAverageDurationMillisAllAttempts: number;
                adaptiveBotAverageDurationMillisFirstAttempt: number;
                killDetailsFirstAttempt: null;
            };
            ability: {
                idleTimeMillis: number;
                objectiveCompleteTimeMillis: number;
            };
            bombPlant: {
                idleTimeMillis: number;
                objectiveCompleteTimeMillis: number;
            };
            defendBombSite: {
                success: boolean;
                idleTimeMillis: number;
                objectiveCompleteTimeMillis: number;
            };
            settingStatus: {
                isMouseSensitivityDefault: boolean;
                isCrosshairDefault: boolean;
            };
            versionString: string;
        } | undefined;
    }, {
        platformInfo: {
            platformType: string;
            platformOS: string;
            platformOSVersion: string;
            platformChipset: string;
        };
        subject: string;
        partyId: string;
        accountLevel: number;
        competitiveTier: number;
        gameName: string;
        tagLine: string;
        teamId: "Blue" | "Red";
        characterId: string;
        stats: {
            score: number;
            roundsPlayed: number;
            kills: number;
            deaths: number;
            assists: number;
            playtimeMillis: number;
            abilityCasts?: {
                grenadeCasts: number;
                ability1Casts: number;
                ability2Casts: number;
                ultimateCasts: number;
            } | null | undefined;
        };
        roundDamage: {
            round: number;
            receiver: string;
            damage: number;
        }[];
        isObserver: boolean;
        playerCard: string;
        playerTitle: string;
        preferredLevelBorder?: string | undefined;
        sessionPlaytimeMinutes?: number | undefined;
        xpModifications?: {
            ID: string;
            Value: number;
        }[] | undefined;
        behaviorFactors?: {
            afkRounds: number;
            commsRatingRecovery: number;
            damageParticipationOutgoing: number;
            collisions?: number | undefined;
            friendlyFireIncoming?: number | undefined;
            friendlyFireOutgoing?: number | undefined;
            mouseMovement?: number | undefined;
            stayedInSpawnRounds?: number | undefined;
        } | undefined;
        newPlayerExperienceDetails?: {
            basicMovement: {
                idleTimeMillis: number;
                objectiveCompleteTimeMillis: number;
            };
            basicGunSkill: {
                idleTimeMillis: number;
                objectiveCompleteTimeMillis: number;
            };
            adaptiveBots: {
                idleTimeMillis: number;
                objectiveCompleteTimeMillis: number;
                adaptiveBotAverageDurationMillisAllAttempts: number;
                adaptiveBotAverageDurationMillisFirstAttempt: number;
                killDetailsFirstAttempt: null;
            };
            ability: {
                idleTimeMillis: number;
                objectiveCompleteTimeMillis: number;
            };
            bombPlant: {
                idleTimeMillis: number;
                objectiveCompleteTimeMillis: number;
            };
            defendBombSite: {
                success: boolean;
                idleTimeMillis: number;
                objectiveCompleteTimeMillis: number;
            };
            settingStatus: {
                isMouseSensitivityDefault: boolean;
                isCrosshairDefault: boolean;
            };
            versionString: string;
        } | undefined;
    }>, "many">;
    bots: z.ZodArray<z.ZodUnknown, "many">;
    coaches: z.ZodArray<z.ZodObject<{
        subject: z.ZodString;
        teamId: z.ZodEnum<["Blue", "Red"]>;
    }, "strip", z.ZodTypeAny, {
        subject: string;
        teamId: "Blue" | "Red";
    }, {
        subject: string;
        teamId: "Blue" | "Red";
    }>, "many">;
    teams: z.ZodOptional<z.ZodArray<z.ZodObject<{
        teamId: z.ZodEnum<["Blue", "Red"]>;
        won: z.ZodBoolean;
        roundsPlayed: z.ZodNumber;
        roundsWon: z.ZodNumber;
        numPoints: z.ZodNumber;
    }, "strip", z.ZodTypeAny, {
        teamId: "Blue" | "Red";
        roundsPlayed: number;
        won: boolean;
        roundsWon: number;
        numPoints: number;
    }, {
        teamId: "Blue" | "Red";
        roundsPlayed: number;
        won: boolean;
        roundsWon: number;
        numPoints: number;
    }>, "many">>;
    roundResults: z.ZodArray<z.ZodObject<{
        roundNum: z.ZodNumber;
        roundResult: z.ZodEnum<["Eliminated", "Bomb detonated", "Bomb defused", "Surrendered", "Round timer expired"]>;
        roundCeremony: z.ZodEnum<["CeremonyDefault", "CeremonyTeamAce", "CeremonyFlawless", "CeremonyCloser", "CeremonyClutch", "CeremonyThrifty", "CeremonyAce", ""]>;
        winningTeam: z.ZodEnum<["Blue", "Red"]>;
        bombPlanter: z.ZodOptional<z.ZodString>;
        bombDefuser: z.ZodEnum<["Blue", "Red"]>;
        plantRoundTime: z.ZodOptional<z.ZodNumber>;
        plantPlayerLocations: z.ZodOptional<z.ZodArray<z.ZodObject<{
            subject: z.ZodString;
            viewRadians: z.ZodNumber;
            location: z.ZodObject<{
                x: z.ZodNumber;
                y: z.ZodNumber;
            }, "strip", z.ZodTypeAny, {
                x: number;
                y: number;
            }, {
                x: number;
                y: number;
            }>;
        }, "strip", z.ZodTypeAny, {
            subject: string;
            location: {
                x: number;
                y: number;
            };
            viewRadians: number;
        }, {
            subject: string;
            location: {
                x: number;
                y: number;
            };
            viewRadians: number;
        }>, "many">>;
        plantLocation: z.ZodObject<{
            x: z.ZodNumber;
            y: z.ZodNumber;
        }, "strip", z.ZodTypeAny, {
            x: number;
            y: number;
        }, {
            x: number;
            y: number;
        }>;
        plantSite: z.ZodEnum<["A", "B", "C", ""]>;
        defuseRoundTime: z.ZodOptional<z.ZodNumber>;
        defusePlayerLocations: z.ZodOptional<z.ZodArray<z.ZodObject<{
            subject: z.ZodString;
            viewRadians: z.ZodNumber;
            location: z.ZodObject<{
                x: z.ZodNumber;
                y: z.ZodNumber;
            }, "strip", z.ZodTypeAny, {
                x: number;
                y: number;
            }, {
                x: number;
                y: number;
            }>;
        }, "strip", z.ZodTypeAny, {
            subject: string;
            location: {
                x: number;
                y: number;
            };
            viewRadians: number;
        }, {
            subject: string;
            location: {
                x: number;
                y: number;
            };
            viewRadians: number;
        }>, "many">>;
        defuseLocation: z.ZodObject<{
            x: z.ZodNumber;
            y: z.ZodNumber;
        }, "strip", z.ZodTypeAny, {
            x: number;
            y: number;
        }, {
            x: number;
            y: number;
        }>;
        playerStats: z.ZodArray<z.ZodObject<{
            subject: z.ZodString;
            kills: z.ZodArray<z.ZodObject<{
                gameTime: z.ZodEffects<z.ZodNumber, Date, number>;
                roundTime: z.ZodEffects<z.ZodNumber, Date, number>;
                killer: z.ZodString;
                victim: z.ZodString;
                victimLocation: z.ZodObject<{
                    x: z.ZodNumber;
                    y: z.ZodNumber;
                }, "strip", z.ZodTypeAny, {
                    x: number;
                    y: number;
                }, {
                    x: number;
                    y: number;
                }>;
                assistants: z.ZodArray<z.ZodString, "many">;
                playerLocations: z.ZodArray<z.ZodObject<{
                    subject: z.ZodString;
                    viewRadians: z.ZodNumber;
                    location: z.ZodObject<{
                        x: z.ZodNumber;
                        y: z.ZodNumber;
                    }, "strip", z.ZodTypeAny, {
                        x: number;
                        y: number;
                    }, {
                        x: number;
                        y: number;
                    }>;
                }, "strip", z.ZodTypeAny, {
                    subject: string;
                    location: {
                        x: number;
                        y: number;
                    };
                    viewRadians: number;
                }, {
                    subject: string;
                    location: {
                        x: number;
                        y: number;
                    };
                    viewRadians: number;
                }>, "many">;
                finishingDamage: z.ZodObject<{
                    damageType: z.ZodEnum<["Weapon", "Bomb", "Ability", "Fall", "Melee", "Invalid", ""]>;
                    damageItem: z.ZodUnion<[z.ZodLiteral<"">, z.ZodLiteral<"Ultimate">, z.ZodLiteral<"Ability1">, z.ZodLiteral<"Ability2">, z.ZodLiteral<"GrenadeAbility">, z.ZodLiteral<"Primary">, z.ZodString]>;
                    isSecondaryFireMode: z.ZodBoolean;
                }, "strip", z.ZodTypeAny, {
                    damageType: "" | "Weapon" | "Bomb" | "Ability" | "Fall" | "Melee" | "Invalid";
                    damageItem: string;
                    isSecondaryFireMode: boolean;
                }, {
                    damageType: "" | "Weapon" | "Bomb" | "Ability" | "Fall" | "Melee" | "Invalid";
                    damageItem: string;
                    isSecondaryFireMode: boolean;
                }>;
            }, "strip", z.ZodTypeAny, {
                gameTime: Date;
                roundTime: Date;
                killer: string;
                victim: string;
                victimLocation: {
                    x: number;
                    y: number;
                };
                assistants: string[];
                playerLocations: {
                    subject: string;
                    location: {
                        x: number;
                        y: number;
                    };
                    viewRadians: number;
                }[];
                finishingDamage: {
                    damageType: "" | "Weapon" | "Bomb" | "Ability" | "Fall" | "Melee" | "Invalid";
                    damageItem: string;
                    isSecondaryFireMode: boolean;
                };
            }, {
                gameTime: number;
                roundTime: number;
                killer: string;
                victim: string;
                victimLocation: {
                    x: number;
                    y: number;
                };
                assistants: string[];
                playerLocations: {
                    subject: string;
                    location: {
                        x: number;
                        y: number;
                    };
                    viewRadians: number;
                }[];
                finishingDamage: {
                    damageType: "" | "Weapon" | "Bomb" | "Ability" | "Fall" | "Melee" | "Invalid";
                    damageItem: string;
                    isSecondaryFireMode: boolean;
                };
            }>, "many">;
            damage: z.ZodArray<z.ZodObject<{
                receiver: z.ZodString;
                damage: z.ZodNumber;
                legshots: z.ZodNumber;
                bodyshots: z.ZodNumber;
                headshots: z.ZodNumber;
            }, "strip", z.ZodTypeAny, {
                receiver: string;
                damage: number;
                legshots: number;
                bodyshots: number;
                headshots: number;
            }, {
                receiver: string;
                damage: number;
                legshots: number;
                bodyshots: number;
                headshots: number;
            }>, "many">;
            score: z.ZodNumber;
            economy: z.ZodObject<{
                loadoutValue: z.ZodNumber;
                weapon: z.ZodString;
                armor: z.ZodString;
                remaining: z.ZodNumber;
                spent: z.ZodNumber;
            }, "strip", z.ZodTypeAny, {
                loadoutValue: number;
                weapon: string;
                armor: string;
                remaining: number;
                spent: number;
            }, {
                loadoutValue: number;
                weapon: string;
                armor: string;
                remaining: number;
                spent: number;
            }>;
            ability: z.ZodObject<{
                grenadeEffects: z.ZodNull;
                ability1Effects: z.ZodNull;
                ability2Effects: z.ZodNull;
                ultimateEffects: z.ZodNull;
            }, "strip", z.ZodTypeAny, {
                grenadeEffects: null;
                ability1Effects: null;
                ability2Effects: null;
                ultimateEffects: null;
            }, {
                grenadeEffects: null;
                ability1Effects: null;
                ability2Effects: null;
                ultimateEffects: null;
            }>;
            wasAfk: z.ZodBoolean;
            wasPenalized: z.ZodBoolean;
            stayedInSpawn: z.ZodBoolean;
        }, "strip", z.ZodTypeAny, {
            subject: string;
            score: number;
            kills: {
                gameTime: Date;
                roundTime: Date;
                killer: string;
                victim: string;
                victimLocation: {
                    x: number;
                    y: number;
                };
                assistants: string[];
                playerLocations: {
                    subject: string;
                    location: {
                        x: number;
                        y: number;
                    };
                    viewRadians: number;
                }[];
                finishingDamage: {
                    damageType: "" | "Weapon" | "Bomb" | "Ability" | "Fall" | "Melee" | "Invalid";
                    damageItem: string;
                    isSecondaryFireMode: boolean;
                };
            }[];
            damage: {
                receiver: string;
                damage: number;
                legshots: number;
                bodyshots: number;
                headshots: number;
            }[];
            ability: {
                grenadeEffects: null;
                ability1Effects: null;
                ability2Effects: null;
                ultimateEffects: null;
            };
            economy: {
                loadoutValue: number;
                weapon: string;
                armor: string;
                remaining: number;
                spent: number;
            };
            wasAfk: boolean;
            wasPenalized: boolean;
            stayedInSpawn: boolean;
        }, {
            subject: string;
            score: number;
            kills: {
                gameTime: number;
                roundTime: number;
                killer: string;
                victim: string;
                victimLocation: {
                    x: number;
                    y: number;
                };
                assistants: string[];
                playerLocations: {
                    subject: string;
                    location: {
                        x: number;
                        y: number;
                    };
                    viewRadians: number;
                }[];
                finishingDamage: {
                    damageType: "" | "Weapon" | "Bomb" | "Ability" | "Fall" | "Melee" | "Invalid";
                    damageItem: string;
                    isSecondaryFireMode: boolean;
                };
            }[];
            damage: {
                receiver: string;
                damage: number;
                legshots: number;
                bodyshots: number;
                headshots: number;
            }[];
            ability: {
                grenadeEffects: null;
                ability1Effects: null;
                ability2Effects: null;
                ultimateEffects: null;
            };
            economy: {
                loadoutValue: number;
                weapon: string;
                armor: string;
                remaining: number;
                spent: number;
            };
            wasAfk: boolean;
            wasPenalized: boolean;
            stayedInSpawn: boolean;
        }>, "many">;
        roundResultCode: z.ZodEnum<["Elimination", "Detonate", "Defuse", "Surrendered", ""]>;
        playerEconomies: z.ZodArray<z.ZodObject<{
            subject: z.ZodString;
            loadoutValue: z.ZodNumber;
            weapon: z.ZodString;
            armor: z.ZodString;
            remaining: z.ZodNumber;
            spent: z.ZodNumber;
        }, "strip", z.ZodTypeAny, {
            subject: string;
            loadoutValue: number;
            weapon: string;
            armor: string;
            remaining: number;
            spent: number;
        }, {
            subject: string;
            loadoutValue: number;
            weapon: string;
            armor: string;
            remaining: number;
            spent: number;
        }>, "many">;
        playerScores: z.ZodArray<z.ZodObject<{
            subject: z.ZodString;
            score: z.ZodNumber;
        }, "strip", z.ZodTypeAny, {
            subject: string;
            score: number;
        }, {
            subject: string;
            score: number;
        }>, "many">;
    }, "strip", z.ZodTypeAny, {
        roundNum: number;
        roundResult: "Surrendered" | "Eliminated" | "Bomb detonated" | "Bomb defused" | "Round timer expired";
        roundCeremony: "" | "CeremonyDefault" | "CeremonyTeamAce" | "CeremonyFlawless" | "CeremonyCloser" | "CeremonyClutch" | "CeremonyThrifty" | "CeremonyAce";
        winningTeam: "Blue" | "Red";
        bombDefuser: "Blue" | "Red";
        plantLocation: {
            x: number;
            y: number;
        };
        plantSite: "" | "A" | "B" | "C";
        defuseLocation: {
            x: number;
            y: number;
        };
        playerStats: {
            subject: string;
            score: number;
            kills: {
                gameTime: Date;
                roundTime: Date;
                killer: string;
                victim: string;
                victimLocation: {
                    x: number;
                    y: number;
                };
                assistants: string[];
                playerLocations: {
                    subject: string;
                    location: {
                        x: number;
                        y: number;
                    };
                    viewRadians: number;
                }[];
                finishingDamage: {
                    damageType: "" | "Weapon" | "Bomb" | "Ability" | "Fall" | "Melee" | "Invalid";
                    damageItem: string;
                    isSecondaryFireMode: boolean;
                };
            }[];
            damage: {
                receiver: string;
                damage: number;
                legshots: number;
                bodyshots: number;
                headshots: number;
            }[];
            ability: {
                grenadeEffects: null;
                ability1Effects: null;
                ability2Effects: null;
                ultimateEffects: null;
            };
            economy: {
                loadoutValue: number;
                weapon: string;
                armor: string;
                remaining: number;
                spent: number;
            };
            wasAfk: boolean;
            wasPenalized: boolean;
            stayedInSpawn: boolean;
        }[];
        roundResultCode: "" | "Surrendered" | "Elimination" | "Detonate" | "Defuse";
        playerEconomies: {
            subject: string;
            loadoutValue: number;
            weapon: string;
            armor: string;
            remaining: number;
            spent: number;
        }[];
        playerScores: {
            subject: string;
            score: number;
        }[];
        bombPlanter?: string | undefined;
        plantRoundTime?: number | undefined;
        plantPlayerLocations?: {
            subject: string;
            location: {
                x: number;
                y: number;
            };
            viewRadians: number;
        }[] | undefined;
        defuseRoundTime?: number | undefined;
        defusePlayerLocations?: {
            subject: string;
            location: {
                x: number;
                y: number;
            };
            viewRadians: number;
        }[] | undefined;
    }, {
        roundNum: number;
        roundResult: "Surrendered" | "Eliminated" | "Bomb detonated" | "Bomb defused" | "Round timer expired";
        roundCeremony: "" | "CeremonyDefault" | "CeremonyTeamAce" | "CeremonyFlawless" | "CeremonyCloser" | "CeremonyClutch" | "CeremonyThrifty" | "CeremonyAce";
        winningTeam: "Blue" | "Red";
        bombDefuser: "Blue" | "Red";
        plantLocation: {
            x: number;
            y: number;
        };
        plantSite: "" | "A" | "B" | "C";
        defuseLocation: {
            x: number;
            y: number;
        };
        playerStats: {
            subject: string;
            score: number;
            kills: {
                gameTime: number;
                roundTime: number;
                killer: string;
                victim: string;
                victimLocation: {
                    x: number;
                    y: number;
                };
                assistants: string[];
                playerLocations: {
                    subject: string;
                    location: {
                        x: number;
                        y: number;
                    };
                    viewRadians: number;
                }[];
                finishingDamage: {
                    damageType: "" | "Weapon" | "Bomb" | "Ability" | "Fall" | "Melee" | "Invalid";
                    damageItem: string;
                    isSecondaryFireMode: boolean;
                };
            }[];
            damage: {
                receiver: string;
                damage: number;
                legshots: number;
                bodyshots: number;
                headshots: number;
            }[];
            ability: {
                grenadeEffects: null;
                ability1Effects: null;
                ability2Effects: null;
                ultimateEffects: null;
            };
            economy: {
                loadoutValue: number;
                weapon: string;
                armor: string;
                remaining: number;
                spent: number;
            };
            wasAfk: boolean;
            wasPenalized: boolean;
            stayedInSpawn: boolean;
        }[];
        roundResultCode: "" | "Surrendered" | "Elimination" | "Detonate" | "Defuse";
        playerEconomies: {
            subject: string;
            loadoutValue: number;
            weapon: string;
            armor: string;
            remaining: number;
            spent: number;
        }[];
        playerScores: {
            subject: string;
            score: number;
        }[];
        bombPlanter?: string | undefined;
        plantRoundTime?: number | undefined;
        plantPlayerLocations?: {
            subject: string;
            location: {
                x: number;
                y: number;
            };
            viewRadians: number;
        }[] | undefined;
        defuseRoundTime?: number | undefined;
        defusePlayerLocations?: {
            subject: string;
            location: {
                x: number;
                y: number;
            };
            viewRadians: number;
        }[] | undefined;
    }>, "many">;
    kills: z.ZodArray<z.ZodObject<{
        gameTime: z.ZodEffects<z.ZodNumber, Date, number>;
        roundTime: z.ZodEffects<z.ZodNumber, Date, number>;
        killer: z.ZodString;
        victim: z.ZodString;
        victimLocation: z.ZodObject<{
            x: z.ZodNumber;
            y: z.ZodNumber;
        }, "strip", z.ZodTypeAny, {
            x: number;
            y: number;
        }, {
            x: number;
            y: number;
        }>;
        assistants: z.ZodArray<z.ZodString, "many">;
        playerLocations: z.ZodArray<z.ZodObject<{
            subject: z.ZodString;
            viewRadians: z.ZodNumber;
            location: z.ZodObject<{
                x: z.ZodNumber;
                y: z.ZodNumber;
            }, "strip", z.ZodTypeAny, {
                x: number;
                y: number;
            }, {
                x: number;
                y: number;
            }>;
        }, "strip", z.ZodTypeAny, {
            subject: string;
            location: {
                x: number;
                y: number;
            };
            viewRadians: number;
        }, {
            subject: string;
            location: {
                x: number;
                y: number;
            };
            viewRadians: number;
        }>, "many">;
        finishingDamage: z.ZodObject<{
            damageType: z.ZodEnum<["Weapon", "Bomb", "Ability", "Fall", "Melee", "Invalid", ""]>;
            damageItem: z.ZodUnion<[z.ZodLiteral<"">, z.ZodLiteral<"Ultimate">, z.ZodLiteral<"Ability1">, z.ZodLiteral<"Ability2">, z.ZodLiteral<"GrenadeAbility">, z.ZodLiteral<"Primary">, z.ZodString]>;
            isSecondaryFireMode: z.ZodBoolean;
        }, "strip", z.ZodTypeAny, {
            damageType: "" | "Weapon" | "Bomb" | "Ability" | "Fall" | "Melee" | "Invalid";
            damageItem: string;
            isSecondaryFireMode: boolean;
        }, {
            damageType: "" | "Weapon" | "Bomb" | "Ability" | "Fall" | "Melee" | "Invalid";
            damageItem: string;
            isSecondaryFireMode: boolean;
        }>;
        round: z.ZodNumber;
    }, "strip", z.ZodTypeAny, {
        round: number;
        gameTime: Date;
        roundTime: Date;
        killer: string;
        victim: string;
        victimLocation: {
            x: number;
            y: number;
        };
        assistants: string[];
        playerLocations: {
            subject: string;
            location: {
                x: number;
                y: number;
            };
            viewRadians: number;
        }[];
        finishingDamage: {
            damageType: "" | "Weapon" | "Bomb" | "Ability" | "Fall" | "Melee" | "Invalid";
            damageItem: string;
            isSecondaryFireMode: boolean;
        };
    }, {
        round: number;
        gameTime: number;
        roundTime: number;
        killer: string;
        victim: string;
        victimLocation: {
            x: number;
            y: number;
        };
        assistants: string[];
        playerLocations: {
            subject: string;
            location: {
                x: number;
                y: number;
            };
            viewRadians: number;
        }[];
        finishingDamage: {
            damageType: "" | "Weapon" | "Bomb" | "Ability" | "Fall" | "Melee" | "Invalid";
            damageItem: string;
            isSecondaryFireMode: boolean;
        };
    }>, "many">;
}, "strip", z.ZodTypeAny, {
    kills: {
        round: number;
        gameTime: Date;
        roundTime: Date;
        killer: string;
        victim: string;
        victimLocation: {
            x: number;
            y: number;
        };
        assistants: string[];
        playerLocations: {
            subject: string;
            location: {
                x: number;
                y: number;
            };
            viewRadians: number;
        }[];
        finishingDamage: {
            damageType: "" | "Weapon" | "Bomb" | "Ability" | "Fall" | "Melee" | "Invalid";
            damageItem: string;
            isSecondaryFireMode: boolean;
        };
    }[];
    matchInfo: {
        platformType: string;
        gameMode: string;
        mapId: string;
        customGameName: string;
        matchId: string;
        gamePodId: string;
        gameLoopZone: string;
        gameServerAddress: string;
        gameVersion: string;
        gameLengthMillis: Date;
        gameStartMillis: Date;
        provisioningFlowID: "Matchmaking" | "CustomGame";
        isCompleted: boolean;
        forcePostProcessing: boolean;
        queueID: string;
        isRanked: boolean;
        isMatchSampled: boolean;
        seasonId: string;
        completionState: "" | "Surrendered" | "Completed" | "VoteDraw";
        premierMatchInfo: {};
        shouldMatchDisablePenalties: boolean;
        partyRRPenalties?: Record<string, number> | undefined;
    };
    players: {
        platformInfo: {
            platformType: string;
            platformOS: string;
            platformOSVersion: string;
            platformChipset: string;
        };
        subject: string;
        partyId: string;
        accountLevel: number;
        competitiveTier: number;
        gameName: string;
        tagLine: string;
        teamId: "Blue" | "Red";
        characterId: string;
        stats: {
            score: number;
            roundsPlayed: number;
            kills: number;
            deaths: number;
            assists: number;
            playtimeMillis: Date;
            abilityCasts?: {
                grenadeCasts: number;
                ability1Casts: number;
                ability2Casts: number;
                ultimateCasts: number;
            } | null | undefined;
        };
        roundDamage: {
            round: number;
            receiver: string;
            damage: number;
        }[];
        isObserver: boolean;
        playerCard: string;
        playerTitle: string;
        preferredLevelBorder?: string | undefined;
        sessionPlaytimeMinutes?: number | undefined;
        xpModifications?: {
            ID: string;
            Value: number;
        }[] | undefined;
        behaviorFactors?: {
            afkRounds: number;
            commsRatingRecovery: number;
            damageParticipationOutgoing: number;
            collisions?: number | undefined;
            friendlyFireIncoming?: number | undefined;
            friendlyFireOutgoing?: number | undefined;
            mouseMovement?: number | undefined;
            stayedInSpawnRounds?: number | undefined;
        } | undefined;
        newPlayerExperienceDetails?: {
            basicMovement: {
                idleTimeMillis: number;
                objectiveCompleteTimeMillis: number;
            };
            basicGunSkill: {
                idleTimeMillis: number;
                objectiveCompleteTimeMillis: number;
            };
            adaptiveBots: {
                idleTimeMillis: number;
                objectiveCompleteTimeMillis: number;
                adaptiveBotAverageDurationMillisAllAttempts: number;
                adaptiveBotAverageDurationMillisFirstAttempt: number;
                killDetailsFirstAttempt: null;
            };
            ability: {
                idleTimeMillis: number;
                objectiveCompleteTimeMillis: number;
            };
            bombPlant: {
                idleTimeMillis: number;
                objectiveCompleteTimeMillis: number;
            };
            defendBombSite: {
                success: boolean;
                idleTimeMillis: number;
                objectiveCompleteTimeMillis: number;
            };
            settingStatus: {
                isMouseSensitivityDefault: boolean;
                isCrosshairDefault: boolean;
            };
            versionString: string;
        } | undefined;
    }[];
    bots: unknown[];
    coaches: {
        subject: string;
        teamId: "Blue" | "Red";
    }[];
    roundResults: {
        roundNum: number;
        roundResult: "Surrendered" | "Eliminated" | "Bomb detonated" | "Bomb defused" | "Round timer expired";
        roundCeremony: "" | "CeremonyDefault" | "CeremonyTeamAce" | "CeremonyFlawless" | "CeremonyCloser" | "CeremonyClutch" | "CeremonyThrifty" | "CeremonyAce";
        winningTeam: "Blue" | "Red";
        bombDefuser: "Blue" | "Red";
        plantLocation: {
            x: number;
            y: number;
        };
        plantSite: "" | "A" | "B" | "C";
        defuseLocation: {
            x: number;
            y: number;
        };
        playerStats: {
            subject: string;
            score: number;
            kills: {
                gameTime: Date;
                roundTime: Date;
                killer: string;
                victim: string;
                victimLocation: {
                    x: number;
                    y: number;
                };
                assistants: string[];
                playerLocations: {
                    subject: string;
                    location: {
                        x: number;
                        y: number;
                    };
                    viewRadians: number;
                }[];
                finishingDamage: {
                    damageType: "" | "Weapon" | "Bomb" | "Ability" | "Fall" | "Melee" | "Invalid";
                    damageItem: string;
                    isSecondaryFireMode: boolean;
                };
            }[];
            damage: {
                receiver: string;
                damage: number;
                legshots: number;
                bodyshots: number;
                headshots: number;
            }[];
            ability: {
                grenadeEffects: null;
                ability1Effects: null;
                ability2Effects: null;
                ultimateEffects: null;
            };
            economy: {
                loadoutValue: number;
                weapon: string;
                armor: string;
                remaining: number;
                spent: number;
            };
            wasAfk: boolean;
            wasPenalized: boolean;
            stayedInSpawn: boolean;
        }[];
        roundResultCode: "" | "Surrendered" | "Elimination" | "Detonate" | "Defuse";
        playerEconomies: {
            subject: string;
            loadoutValue: number;
            weapon: string;
            armor: string;
            remaining: number;
            spent: number;
        }[];
        playerScores: {
            subject: string;
            score: number;
        }[];
        bombPlanter?: string | undefined;
        plantRoundTime?: number | undefined;
        plantPlayerLocations?: {
            subject: string;
            location: {
                x: number;
                y: number;
            };
            viewRadians: number;
        }[] | undefined;
        defuseRoundTime?: number | undefined;
        defusePlayerLocations?: {
            subject: string;
            location: {
                x: number;
                y: number;
            };
            viewRadians: number;
        }[] | undefined;
    }[];
    teams?: {
        teamId: "Blue" | "Red";
        roundsPlayed: number;
        won: boolean;
        roundsWon: number;
        numPoints: number;
    }[] | undefined;
}, {
    kills: {
        round: number;
        gameTime: number;
        roundTime: number;
        killer: string;
        victim: string;
        victimLocation: {
            x: number;
            y: number;
        };
        assistants: string[];
        playerLocations: {
            subject: string;
            location: {
                x: number;
                y: number;
            };
            viewRadians: number;
        }[];
        finishingDamage: {
            damageType: "" | "Weapon" | "Bomb" | "Ability" | "Fall" | "Melee" | "Invalid";
            damageItem: string;
            isSecondaryFireMode: boolean;
        };
    }[];
    matchInfo: {
        platformType: string;
        gameMode: string;
        mapId: string;
        customGameName: string;
        matchId: string;
        gamePodId: string;
        gameLoopZone: string;
        gameServerAddress: string;
        gameVersion: string;
        gameLengthMillis: number;
        gameStartMillis: number;
        provisioningFlowID: "Matchmaking" | "CustomGame";
        isCompleted: boolean;
        forcePostProcessing: boolean;
        queueID: string;
        isRanked: boolean;
        isMatchSampled: boolean;
        seasonId: string;
        completionState: "" | "Surrendered" | "Completed" | "VoteDraw";
        premierMatchInfo: {};
        shouldMatchDisablePenalties: boolean;
        partyRRPenalties?: Record<string, number> | undefined;
    };
    players: {
        platformInfo: {
            platformType: string;
            platformOS: string;
            platformOSVersion: string;
            platformChipset: string;
        };
        subject: string;
        partyId: string;
        accountLevel: number;
        competitiveTier: number;
        gameName: string;
        tagLine: string;
        teamId: "Blue" | "Red";
        characterId: string;
        stats: {
            score: number;
            roundsPlayed: number;
            kills: number;
            deaths: number;
            assists: number;
            playtimeMillis: number;
            abilityCasts?: {
                grenadeCasts: number;
                ability1Casts: number;
                ability2Casts: number;
                ultimateCasts: number;
            } | null | undefined;
        };
        roundDamage: {
            round: number;
            receiver: string;
            damage: number;
        }[];
        isObserver: boolean;
        playerCard: string;
        playerTitle: string;
        preferredLevelBorder?: string | undefined;
        sessionPlaytimeMinutes?: number | undefined;
        xpModifications?: {
            ID: string;
            Value: number;
        }[] | undefined;
        behaviorFactors?: {
            afkRounds: number;
            commsRatingRecovery: number;
            damageParticipationOutgoing: number;
            collisions?: number | undefined;
            friendlyFireIncoming?: number | undefined;
            friendlyFireOutgoing?: number | undefined;
            mouseMovement?: number | undefined;
            stayedInSpawnRounds?: number | undefined;
        } | undefined;
        newPlayerExperienceDetails?: {
            basicMovement: {
                idleTimeMillis: number;
                objectiveCompleteTimeMillis: number;
            };
            basicGunSkill: {
                idleTimeMillis: number;
                objectiveCompleteTimeMillis: number;
            };
            adaptiveBots: {
                idleTimeMillis: number;
                objectiveCompleteTimeMillis: number;
                adaptiveBotAverageDurationMillisAllAttempts: number;
                adaptiveBotAverageDurationMillisFirstAttempt: number;
                killDetailsFirstAttempt: null;
            };
            ability: {
                idleTimeMillis: number;
                objectiveCompleteTimeMillis: number;
            };
            bombPlant: {
                idleTimeMillis: number;
                objectiveCompleteTimeMillis: number;
            };
            defendBombSite: {
                success: boolean;
                idleTimeMillis: number;
                objectiveCompleteTimeMillis: number;
            };
            settingStatus: {
                isMouseSensitivityDefault: boolean;
                isCrosshairDefault: boolean;
            };
            versionString: string;
        } | undefined;
    }[];
    bots: unknown[];
    coaches: {
        subject: string;
        teamId: "Blue" | "Red";
    }[];
    roundResults: {
        roundNum: number;
        roundResult: "Surrendered" | "Eliminated" | "Bomb detonated" | "Bomb defused" | "Round timer expired";
        roundCeremony: "" | "CeremonyDefault" | "CeremonyTeamAce" | "CeremonyFlawless" | "CeremonyCloser" | "CeremonyClutch" | "CeremonyThrifty" | "CeremonyAce";
        winningTeam: "Blue" | "Red";
        bombDefuser: "Blue" | "Red";
        plantLocation: {
            x: number;
            y: number;
        };
        plantSite: "" | "A" | "B" | "C";
        defuseLocation: {
            x: number;
            y: number;
        };
        playerStats: {
            subject: string;
            score: number;
            kills: {
                gameTime: number;
                roundTime: number;
                killer: string;
                victim: string;
                victimLocation: {
                    x: number;
                    y: number;
                };
                assistants: string[];
                playerLocations: {
                    subject: string;
                    location: {
                        x: number;
                        y: number;
                    };
                    viewRadians: number;
                }[];
                finishingDamage: {
                    damageType: "" | "Weapon" | "Bomb" | "Ability" | "Fall" | "Melee" | "Invalid";
                    damageItem: string;
                    isSecondaryFireMode: boolean;
                };
            }[];
            damage: {
                receiver: string;
                damage: number;
                legshots: number;
                bodyshots: number;
                headshots: number;
            }[];
            ability: {
                grenadeEffects: null;
                ability1Effects: null;
                ability2Effects: null;
                ultimateEffects: null;
            };
            economy: {
                loadoutValue: number;
                weapon: string;
                armor: string;
                remaining: number;
                spent: number;
            };
            wasAfk: boolean;
            wasPenalized: boolean;
            stayedInSpawn: boolean;
        }[];
        roundResultCode: "" | "Surrendered" | "Elimination" | "Detonate" | "Defuse";
        playerEconomies: {
            subject: string;
            loadoutValue: number;
            weapon: string;
            armor: string;
            remaining: number;
            spent: number;
        }[];
        playerScores: {
            subject: string;
            score: number;
        }[];
        bombPlanter?: string | undefined;
        plantRoundTime?: number | undefined;
        plantPlayerLocations?: {
            subject: string;
            location: {
                x: number;
                y: number;
            };
            viewRadians: number;
        }[] | undefined;
        defuseRoundTime?: number | undefined;
        defusePlayerLocations?: {
            subject: string;
            location: {
                x: number;
                y: number;
            };
            viewRadians: number;
        }[] | undefined;
    }[];
    teams?: {
        teamId: "Blue" | "Red";
        roundsPlayed: number;
        won: boolean;
        roundsWon: number;
        numPoints: number;
    }[] | undefined;
}>;
declare const _default$B: Omit<{
    requirements: string[];
    type: "auth" | "local" | "pd" | "glz" | "shared";
    name: string;
    method: "PUT" | "GET" | "DELETE" | "POST";
    url: string;
    description?: string | undefined;
    headers?: Record<string, string> | undefined;
    body?: z.ZodType<any, z.ZodTypeDef, any> | undefined;
    query?: z.ZodType<any, z.ZodTypeDef, any> | undefined;
    responses?: Record<string, z.ZodType<any, z.ZodTypeDef, any>> | undefined;
}, "type" | "name" | "url"> & Pick<{
    readonly name: "Match Details";
    readonly description: "Get the details of a match after it ends";
    readonly type: "pd";
    readonly url: "match-details/v1/matches/:matchID";
    readonly responses: {
        readonly "200": z.ZodObject<{
            matchInfo: z.ZodObject<{
                matchId: z.ZodString;
                mapId: z.ZodString;
                gamePodId: z.ZodString;
                gameLoopZone: z.ZodString;
                gameServerAddress: z.ZodString;
                gameVersion: z.ZodString;
                gameLengthMillis: z.ZodEffects<z.ZodNumber, Date, number>;
                gameStartMillis: z.ZodEffects<z.ZodNumber, Date, number>;
                provisioningFlowID: z.ZodEnum<["Matchmaking", "CustomGame"]>;
                isCompleted: z.ZodBoolean;
                customGameName: z.ZodString;
                forcePostProcessing: z.ZodBoolean;
                queueID: z.ZodString;
                gameMode: z.ZodString;
                isRanked: z.ZodBoolean;
                isMatchSampled: z.ZodBoolean;
                seasonId: z.ZodString;
                completionState: z.ZodEnum<["Surrendered", "Completed", "VoteDraw", ""]>;
                platformType: z.ZodString;
                premierMatchInfo: z.ZodObject<{}, "strip", z.ZodTypeAny, {}, {}>;
                partyRRPenalties: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodNumber>>;
                shouldMatchDisablePenalties: z.ZodBoolean;
            }, "strip", z.ZodTypeAny, {
                platformType: string;
                gameMode: string;
                mapId: string;
                customGameName: string;
                matchId: string;
                gamePodId: string;
                gameLoopZone: string;
                gameServerAddress: string;
                gameVersion: string;
                gameLengthMillis: Date;
                gameStartMillis: Date;
                provisioningFlowID: "Matchmaking" | "CustomGame";
                isCompleted: boolean;
                forcePostProcessing: boolean;
                queueID: string;
                isRanked: boolean;
                isMatchSampled: boolean;
                seasonId: string;
                completionState: "" | "Surrendered" | "Completed" | "VoteDraw";
                premierMatchInfo: {};
                shouldMatchDisablePenalties: boolean;
                partyRRPenalties?: Record<string, number> | undefined;
            }, {
                platformType: string;
                gameMode: string;
                mapId: string;
                customGameName: string;
                matchId: string;
                gamePodId: string;
                gameLoopZone: string;
                gameServerAddress: string;
                gameVersion: string;
                gameLengthMillis: number;
                gameStartMillis: number;
                provisioningFlowID: "Matchmaking" | "CustomGame";
                isCompleted: boolean;
                forcePostProcessing: boolean;
                queueID: string;
                isRanked: boolean;
                isMatchSampled: boolean;
                seasonId: string;
                completionState: "" | "Surrendered" | "Completed" | "VoteDraw";
                premierMatchInfo: {};
                shouldMatchDisablePenalties: boolean;
                partyRRPenalties?: Record<string, number> | undefined;
            }>;
            players: z.ZodArray<z.ZodObject<{
                subject: z.ZodString;
                gameName: z.ZodString;
                tagLine: z.ZodString;
                platformInfo: z.ZodObject<{
                    platformType: z.ZodString;
                    platformOS: z.ZodString;
                    platformOSVersion: z.ZodString;
                    platformChipset: z.ZodString;
                }, "strip", z.ZodTypeAny, {
                    platformType: string;
                    platformOS: string;
                    platformOSVersion: string;
                    platformChipset: string;
                }, {
                    platformType: string;
                    platformOS: string;
                    platformOSVersion: string;
                    platformChipset: string;
                }>;
                teamId: z.ZodEnum<["Blue", "Red"]>;
                partyId: z.ZodString;
                characterId: z.ZodString;
                stats: z.ZodObject<{
                    score: z.ZodNumber;
                    roundsPlayed: z.ZodNumber;
                    kills: z.ZodNumber;
                    deaths: z.ZodNumber;
                    assists: z.ZodNumber;
                    playtimeMillis: z.ZodEffects<z.ZodNumber, Date, number>;
                    abilityCasts: z.ZodOptional<z.ZodNullable<z.ZodObject<{
                        grenadeCasts: z.ZodNumber;
                        ability1Casts: z.ZodNumber;
                        ability2Casts: z.ZodNumber;
                        ultimateCasts: z.ZodNumber;
                    }, "strip", z.ZodTypeAny, {
                        grenadeCasts: number;
                        ability1Casts: number;
                        ability2Casts: number;
                        ultimateCasts: number;
                    }, {
                        grenadeCasts: number;
                        ability1Casts: number;
                        ability2Casts: number;
                        ultimateCasts: number;
                    }>>>;
                }, "strip", z.ZodTypeAny, {
                    score: number;
                    roundsPlayed: number;
                    kills: number;
                    deaths: number;
                    assists: number;
                    playtimeMillis: Date;
                    abilityCasts?: {
                        grenadeCasts: number;
                        ability1Casts: number;
                        ability2Casts: number;
                        ultimateCasts: number;
                    } | null | undefined;
                }, {
                    score: number;
                    roundsPlayed: number;
                    kills: number;
                    deaths: number;
                    assists: number;
                    playtimeMillis: number;
                    abilityCasts?: {
                        grenadeCasts: number;
                        ability1Casts: number;
                        ability2Casts: number;
                        ultimateCasts: number;
                    } | null | undefined;
                }>;
                roundDamage: z.ZodArray<z.ZodObject<{
                    round: z.ZodNumber;
                    receiver: z.ZodString;
                    damage: z.ZodNumber;
                }, "strip", z.ZodTypeAny, {
                    round: number;
                    receiver: string;
                    damage: number;
                }, {
                    round: number;
                    receiver: string;
                    damage: number;
                }>, "many">;
                competitiveTier: z.ZodNumber;
                isObserver: z.ZodBoolean;
                playerCard: z.ZodString;
                playerTitle: z.ZodString;
                preferredLevelBorder: z.ZodOptional<z.ZodString>;
                accountLevel: z.ZodNumber;
                sessionPlaytimeMinutes: z.ZodOptional<z.ZodNumber>;
                xpModifications: z.ZodOptional<z.ZodArray<z.ZodObject<{
                    Value: z.ZodNumber;
                    ID: z.ZodString;
                }, "strip", z.ZodTypeAny, {
                    ID: string;
                    Value: number;
                }, {
                    ID: string;
                    Value: number;
                }>, "many">>;
                behaviorFactors: z.ZodOptional<z.ZodObject<{
                    afkRounds: z.ZodNumber;
                    collisions: z.ZodOptional<z.ZodNumber>;
                    commsRatingRecovery: z.ZodNumber;
                    damageParticipationOutgoing: z.ZodNumber;
                    friendlyFireIncoming: z.ZodOptional<z.ZodNumber>;
                    friendlyFireOutgoing: z.ZodOptional<z.ZodNumber>;
                    mouseMovement: z.ZodOptional<z.ZodNumber>;
                    stayedInSpawnRounds: z.ZodOptional<z.ZodNumber>;
                }, "strip", z.ZodTypeAny, {
                    afkRounds: number;
                    commsRatingRecovery: number;
                    damageParticipationOutgoing: number;
                    collisions?: number | undefined;
                    friendlyFireIncoming?: number | undefined;
                    friendlyFireOutgoing?: number | undefined;
                    mouseMovement?: number | undefined;
                    stayedInSpawnRounds?: number | undefined;
                }, {
                    afkRounds: number;
                    commsRatingRecovery: number;
                    damageParticipationOutgoing: number;
                    collisions?: number | undefined;
                    friendlyFireIncoming?: number | undefined;
                    friendlyFireOutgoing?: number | undefined;
                    mouseMovement?: number | undefined;
                    stayedInSpawnRounds?: number | undefined;
                }>>;
                newPlayerExperienceDetails: z.ZodOptional<z.ZodObject<{
                    basicMovement: z.ZodObject<{
                        idleTimeMillis: z.ZodNumber;
                        objectiveCompleteTimeMillis: z.ZodNumber;
                    }, "strip", z.ZodTypeAny, {
                        idleTimeMillis: number;
                        objectiveCompleteTimeMillis: number;
                    }, {
                        idleTimeMillis: number;
                        objectiveCompleteTimeMillis: number;
                    }>;
                    basicGunSkill: z.ZodObject<{
                        idleTimeMillis: z.ZodNumber;
                        objectiveCompleteTimeMillis: z.ZodNumber;
                    }, "strip", z.ZodTypeAny, {
                        idleTimeMillis: number;
                        objectiveCompleteTimeMillis: number;
                    }, {
                        idleTimeMillis: number;
                        objectiveCompleteTimeMillis: number;
                    }>;
                    adaptiveBots: z.ZodObject<{
                        adaptiveBotAverageDurationMillisAllAttempts: z.ZodNumber;
                        adaptiveBotAverageDurationMillisFirstAttempt: z.ZodNumber;
                        killDetailsFirstAttempt: z.ZodNull;
                        idleTimeMillis: z.ZodNumber;
                        objectiveCompleteTimeMillis: z.ZodNumber;
                    }, "strip", z.ZodTypeAny, {
                        idleTimeMillis: number;
                        objectiveCompleteTimeMillis: number;
                        adaptiveBotAverageDurationMillisAllAttempts: number;
                        adaptiveBotAverageDurationMillisFirstAttempt: number;
                        killDetailsFirstAttempt: null;
                    }, {
                        idleTimeMillis: number;
                        objectiveCompleteTimeMillis: number;
                        adaptiveBotAverageDurationMillisAllAttempts: number;
                        adaptiveBotAverageDurationMillisFirstAttempt: number;
                        killDetailsFirstAttempt: null;
                    }>;
                    ability: z.ZodObject<{
                        idleTimeMillis: z.ZodNumber;
                        objectiveCompleteTimeMillis: z.ZodNumber;
                    }, "strip", z.ZodTypeAny, {
                        idleTimeMillis: number;
                        objectiveCompleteTimeMillis: number;
                    }, {
                        idleTimeMillis: number;
                        objectiveCompleteTimeMillis: number;
                    }>;
                    bombPlant: z.ZodObject<{
                        idleTimeMillis: z.ZodNumber;
                        objectiveCompleteTimeMillis: z.ZodNumber;
                    }, "strip", z.ZodTypeAny, {
                        idleTimeMillis: number;
                        objectiveCompleteTimeMillis: number;
                    }, {
                        idleTimeMillis: number;
                        objectiveCompleteTimeMillis: number;
                    }>;
                    defendBombSite: z.ZodObject<{
                        success: z.ZodBoolean;
                        idleTimeMillis: z.ZodNumber;
                        objectiveCompleteTimeMillis: z.ZodNumber;
                    }, "strip", z.ZodTypeAny, {
                        success: boolean;
                        idleTimeMillis: number;
                        objectiveCompleteTimeMillis: number;
                    }, {
                        success: boolean;
                        idleTimeMillis: number;
                        objectiveCompleteTimeMillis: number;
                    }>;
                    settingStatus: z.ZodObject<{
                        isMouseSensitivityDefault: z.ZodBoolean;
                        isCrosshairDefault: z.ZodBoolean;
                    }, "strip", z.ZodTypeAny, {
                        isMouseSensitivityDefault: boolean;
                        isCrosshairDefault: boolean;
                    }, {
                        isMouseSensitivityDefault: boolean;
                        isCrosshairDefault: boolean;
                    }>;
                    versionString: z.ZodString;
                }, "strip", z.ZodTypeAny, {
                    basicMovement: {
                        idleTimeMillis: number;
                        objectiveCompleteTimeMillis: number;
                    };
                    basicGunSkill: {
                        idleTimeMillis: number;
                        objectiveCompleteTimeMillis: number;
                    };
                    adaptiveBots: {
                        idleTimeMillis: number;
                        objectiveCompleteTimeMillis: number;
                        adaptiveBotAverageDurationMillisAllAttempts: number;
                        adaptiveBotAverageDurationMillisFirstAttempt: number;
                        killDetailsFirstAttempt: null;
                    };
                    ability: {
                        idleTimeMillis: number;
                        objectiveCompleteTimeMillis: number;
                    };
                    bombPlant: {
                        idleTimeMillis: number;
                        objectiveCompleteTimeMillis: number;
                    };
                    defendBombSite: {
                        success: boolean;
                        idleTimeMillis: number;
                        objectiveCompleteTimeMillis: number;
                    };
                    settingStatus: {
                        isMouseSensitivityDefault: boolean;
                        isCrosshairDefault: boolean;
                    };
                    versionString: string;
                }, {
                    basicMovement: {
                        idleTimeMillis: number;
                        objectiveCompleteTimeMillis: number;
                    };
                    basicGunSkill: {
                        idleTimeMillis: number;
                        objectiveCompleteTimeMillis: number;
                    };
                    adaptiveBots: {
                        idleTimeMillis: number;
                        objectiveCompleteTimeMillis: number;
                        adaptiveBotAverageDurationMillisAllAttempts: number;
                        adaptiveBotAverageDurationMillisFirstAttempt: number;
                        killDetailsFirstAttempt: null;
                    };
                    ability: {
                        idleTimeMillis: number;
                        objectiveCompleteTimeMillis: number;
                    };
                    bombPlant: {
                        idleTimeMillis: number;
                        objectiveCompleteTimeMillis: number;
                    };
                    defendBombSite: {
                        success: boolean;
                        idleTimeMillis: number;
                        objectiveCompleteTimeMillis: number;
                    };
                    settingStatus: {
                        isMouseSensitivityDefault: boolean;
                        isCrosshairDefault: boolean;
                    };
                    versionString: string;
                }>>;
            }, "strip", z.ZodTypeAny, {
                platformInfo: {
                    platformType: string;
                    platformOS: string;
                    platformOSVersion: string;
                    platformChipset: string;
                };
                subject: string;
                partyId: string;
                accountLevel: number;
                competitiveTier: number;
                gameName: string;
                tagLine: string;
                teamId: "Blue" | "Red";
                characterId: string;
                stats: {
                    score: number;
                    roundsPlayed: number;
                    kills: number;
                    deaths: number;
                    assists: number;
                    playtimeMillis: Date;
                    abilityCasts?: {
                        grenadeCasts: number;
                        ability1Casts: number;
                        ability2Casts: number;
                        ultimateCasts: number;
                    } | null | undefined;
                };
                roundDamage: {
                    round: number;
                    receiver: string;
                    damage: number;
                }[];
                isObserver: boolean;
                playerCard: string;
                playerTitle: string;
                preferredLevelBorder?: string | undefined;
                sessionPlaytimeMinutes?: number | undefined;
                xpModifications?: {
                    ID: string;
                    Value: number;
                }[] | undefined;
                behaviorFactors?: {
                    afkRounds: number;
                    commsRatingRecovery: number;
                    damageParticipationOutgoing: number;
                    collisions?: number | undefined;
                    friendlyFireIncoming?: number | undefined;
                    friendlyFireOutgoing?: number | undefined;
                    mouseMovement?: number | undefined;
                    stayedInSpawnRounds?: number | undefined;
                } | undefined;
                newPlayerExperienceDetails?: {
                    basicMovement: {
                        idleTimeMillis: number;
                        objectiveCompleteTimeMillis: number;
                    };
                    basicGunSkill: {
                        idleTimeMillis: number;
                        objectiveCompleteTimeMillis: number;
                    };
                    adaptiveBots: {
                        idleTimeMillis: number;
                        objectiveCompleteTimeMillis: number;
                        adaptiveBotAverageDurationMillisAllAttempts: number;
                        adaptiveBotAverageDurationMillisFirstAttempt: number;
                        killDetailsFirstAttempt: null;
                    };
                    ability: {
                        idleTimeMillis: number;
                        objectiveCompleteTimeMillis: number;
                    };
                    bombPlant: {
                        idleTimeMillis: number;
                        objectiveCompleteTimeMillis: number;
                    };
                    defendBombSite: {
                        success: boolean;
                        idleTimeMillis: number;
                        objectiveCompleteTimeMillis: number;
                    };
                    settingStatus: {
                        isMouseSensitivityDefault: boolean;
                        isCrosshairDefault: boolean;
                    };
                    versionString: string;
                } | undefined;
            }, {
                platformInfo: {
                    platformType: string;
                    platformOS: string;
                    platformOSVersion: string;
                    platformChipset: string;
                };
                subject: string;
                partyId: string;
                accountLevel: number;
                competitiveTier: number;
                gameName: string;
                tagLine: string;
                teamId: "Blue" | "Red";
                characterId: string;
                stats: {
                    score: number;
                    roundsPlayed: number;
                    kills: number;
                    deaths: number;
                    assists: number;
                    playtimeMillis: number;
                    abilityCasts?: {
                        grenadeCasts: number;
                        ability1Casts: number;
                        ability2Casts: number;
                        ultimateCasts: number;
                    } | null | undefined;
                };
                roundDamage: {
                    round: number;
                    receiver: string;
                    damage: number;
                }[];
                isObserver: boolean;
                playerCard: string;
                playerTitle: string;
                preferredLevelBorder?: string | undefined;
                sessionPlaytimeMinutes?: number | undefined;
                xpModifications?: {
                    ID: string;
                    Value: number;
                }[] | undefined;
                behaviorFactors?: {
                    afkRounds: number;
                    commsRatingRecovery: number;
                    damageParticipationOutgoing: number;
                    collisions?: number | undefined;
                    friendlyFireIncoming?: number | undefined;
                    friendlyFireOutgoing?: number | undefined;
                    mouseMovement?: number | undefined;
                    stayedInSpawnRounds?: number | undefined;
                } | undefined;
                newPlayerExperienceDetails?: {
                    basicMovement: {
                        idleTimeMillis: number;
                        objectiveCompleteTimeMillis: number;
                    };
                    basicGunSkill: {
                        idleTimeMillis: number;
                        objectiveCompleteTimeMillis: number;
                    };
                    adaptiveBots: {
                        idleTimeMillis: number;
                        objectiveCompleteTimeMillis: number;
                        adaptiveBotAverageDurationMillisAllAttempts: number;
                        adaptiveBotAverageDurationMillisFirstAttempt: number;
                        killDetailsFirstAttempt: null;
                    };
                    ability: {
                        idleTimeMillis: number;
                        objectiveCompleteTimeMillis: number;
                    };
                    bombPlant: {
                        idleTimeMillis: number;
                        objectiveCompleteTimeMillis: number;
                    };
                    defendBombSite: {
                        success: boolean;
                        idleTimeMillis: number;
                        objectiveCompleteTimeMillis: number;
                    };
                    settingStatus: {
                        isMouseSensitivityDefault: boolean;
                        isCrosshairDefault: boolean;
                    };
                    versionString: string;
                } | undefined;
            }>, "many">;
            bots: z.ZodArray<z.ZodUnknown, "many">;
            coaches: z.ZodArray<z.ZodObject<{
                subject: z.ZodString;
                teamId: z.ZodEnum<["Blue", "Red"]>;
            }, "strip", z.ZodTypeAny, {
                subject: string;
                teamId: "Blue" | "Red";
            }, {
                subject: string;
                teamId: "Blue" | "Red";
            }>, "many">;
            teams: z.ZodOptional<z.ZodArray<z.ZodObject<{
                teamId: z.ZodEnum<["Blue", "Red"]>;
                won: z.ZodBoolean;
                roundsPlayed: z.ZodNumber;
                roundsWon: z.ZodNumber;
                numPoints: z.ZodNumber;
            }, "strip", z.ZodTypeAny, {
                teamId: "Blue" | "Red";
                roundsPlayed: number;
                won: boolean;
                roundsWon: number;
                numPoints: number;
            }, {
                teamId: "Blue" | "Red";
                roundsPlayed: number;
                won: boolean;
                roundsWon: number;
                numPoints: number;
            }>, "many">>;
            roundResults: z.ZodArray<z.ZodObject<{
                roundNum: z.ZodNumber;
                roundResult: z.ZodEnum<["Eliminated", "Bomb detonated", "Bomb defused", "Surrendered", "Round timer expired"]>;
                roundCeremony: z.ZodEnum<["CeremonyDefault", "CeremonyTeamAce", "CeremonyFlawless", "CeremonyCloser", "CeremonyClutch", "CeremonyThrifty", "CeremonyAce", ""]>;
                winningTeam: z.ZodEnum<["Blue", "Red"]>;
                bombPlanter: z.ZodOptional<z.ZodString>;
                bombDefuser: z.ZodEnum<["Blue", "Red"]>;
                plantRoundTime: z.ZodOptional<z.ZodNumber>;
                plantPlayerLocations: z.ZodOptional<z.ZodArray<z.ZodObject<{
                    subject: z.ZodString;
                    viewRadians: z.ZodNumber;
                    location: z.ZodObject<{
                        x: z.ZodNumber;
                        y: z.ZodNumber;
                    }, "strip", z.ZodTypeAny, {
                        x: number;
                        y: number;
                    }, {
                        x: number;
                        y: number;
                    }>;
                }, "strip", z.ZodTypeAny, {
                    subject: string;
                    location: {
                        x: number;
                        y: number;
                    };
                    viewRadians: number;
                }, {
                    subject: string;
                    location: {
                        x: number;
                        y: number;
                    };
                    viewRadians: number;
                }>, "many">>;
                plantLocation: z.ZodObject<{
                    x: z.ZodNumber;
                    y: z.ZodNumber;
                }, "strip", z.ZodTypeAny, {
                    x: number;
                    y: number;
                }, {
                    x: number;
                    y: number;
                }>;
                plantSite: z.ZodEnum<["A", "B", "C", ""]>;
                defuseRoundTime: z.ZodOptional<z.ZodNumber>;
                defusePlayerLocations: z.ZodOptional<z.ZodArray<z.ZodObject<{
                    subject: z.ZodString;
                    viewRadians: z.ZodNumber;
                    location: z.ZodObject<{
                        x: z.ZodNumber;
                        y: z.ZodNumber;
                    }, "strip", z.ZodTypeAny, {
                        x: number;
                        y: number;
                    }, {
                        x: number;
                        y: number;
                    }>;
                }, "strip", z.ZodTypeAny, {
                    subject: string;
                    location: {
                        x: number;
                        y: number;
                    };
                    viewRadians: number;
                }, {
                    subject: string;
                    location: {
                        x: number;
                        y: number;
                    };
                    viewRadians: number;
                }>, "many">>;
                defuseLocation: z.ZodObject<{
                    x: z.ZodNumber;
                    y: z.ZodNumber;
                }, "strip", z.ZodTypeAny, {
                    x: number;
                    y: number;
                }, {
                    x: number;
                    y: number;
                }>;
                playerStats: z.ZodArray<z.ZodObject<{
                    subject: z.ZodString;
                    kills: z.ZodArray<z.ZodObject<{
                        gameTime: z.ZodEffects<z.ZodNumber, Date, number>;
                        roundTime: z.ZodEffects<z.ZodNumber, Date, number>;
                        killer: z.ZodString;
                        victim: z.ZodString;
                        victimLocation: z.ZodObject<{
                            x: z.ZodNumber;
                            y: z.ZodNumber;
                        }, "strip", z.ZodTypeAny, {
                            x: number;
                            y: number;
                        }, {
                            x: number;
                            y: number;
                        }>;
                        assistants: z.ZodArray<z.ZodString, "many">;
                        playerLocations: z.ZodArray<z.ZodObject<{
                            subject: z.ZodString;
                            viewRadians: z.ZodNumber;
                            location: z.ZodObject<{
                                x: z.ZodNumber;
                                y: z.ZodNumber;
                            }, "strip", z.ZodTypeAny, {
                                x: number;
                                y: number;
                            }, {
                                x: number;
                                y: number;
                            }>;
                        }, "strip", z.ZodTypeAny, {
                            subject: string;
                            location: {
                                x: number;
                                y: number;
                            };
                            viewRadians: number;
                        }, {
                            subject: string;
                            location: {
                                x: number;
                                y: number;
                            };
                            viewRadians: number;
                        }>, "many">;
                        finishingDamage: z.ZodObject<{
                            damageType: z.ZodEnum<["Weapon", "Bomb", "Ability", "Fall", "Melee", "Invalid", ""]>;
                            damageItem: z.ZodUnion<[z.ZodLiteral<"">, z.ZodLiteral<"Ultimate">, z.ZodLiteral<"Ability1">, z.ZodLiteral<"Ability2">, z.ZodLiteral<"GrenadeAbility">, z.ZodLiteral<"Primary">, z.ZodString]>;
                            isSecondaryFireMode: z.ZodBoolean;
                        }, "strip", z.ZodTypeAny, {
                            damageType: "" | "Weapon" | "Bomb" | "Ability" | "Fall" | "Melee" | "Invalid";
                            damageItem: string;
                            isSecondaryFireMode: boolean;
                        }, {
                            damageType: "" | "Weapon" | "Bomb" | "Ability" | "Fall" | "Melee" | "Invalid";
                            damageItem: string;
                            isSecondaryFireMode: boolean;
                        }>;
                    }, "strip", z.ZodTypeAny, {
                        gameTime: Date;
                        roundTime: Date;
                        killer: string;
                        victim: string;
                        victimLocation: {
                            x: number;
                            y: number;
                        };
                        assistants: string[];
                        playerLocations: {
                            subject: string;
                            location: {
                                x: number;
                                y: number;
                            };
                            viewRadians: number;
                        }[];
                        finishingDamage: {
                            damageType: "" | "Weapon" | "Bomb" | "Ability" | "Fall" | "Melee" | "Invalid";
                            damageItem: string;
                            isSecondaryFireMode: boolean;
                        };
                    }, {
                        gameTime: number;
                        roundTime: number;
                        killer: string;
                        victim: string;
                        victimLocation: {
                            x: number;
                            y: number;
                        };
                        assistants: string[];
                        playerLocations: {
                            subject: string;
                            location: {
                                x: number;
                                y: number;
                            };
                            viewRadians: number;
                        }[];
                        finishingDamage: {
                            damageType: "" | "Weapon" | "Bomb" | "Ability" | "Fall" | "Melee" | "Invalid";
                            damageItem: string;
                            isSecondaryFireMode: boolean;
                        };
                    }>, "many">;
                    damage: z.ZodArray<z.ZodObject<{
                        receiver: z.ZodString;
                        damage: z.ZodNumber;
                        legshots: z.ZodNumber;
                        bodyshots: z.ZodNumber;
                        headshots: z.ZodNumber;
                    }, "strip", z.ZodTypeAny, {
                        receiver: string;
                        damage: number;
                        legshots: number;
                        bodyshots: number;
                        headshots: number;
                    }, {
                        receiver: string;
                        damage: number;
                        legshots: number;
                        bodyshots: number;
                        headshots: number;
                    }>, "many">;
                    score: z.ZodNumber;
                    economy: z.ZodObject<{
                        loadoutValue: z.ZodNumber;
                        weapon: z.ZodString;
                        armor: z.ZodString;
                        remaining: z.ZodNumber;
                        spent: z.ZodNumber;
                    }, "strip", z.ZodTypeAny, {
                        loadoutValue: number;
                        weapon: string;
                        armor: string;
                        remaining: number;
                        spent: number;
                    }, {
                        loadoutValue: number;
                        weapon: string;
                        armor: string;
                        remaining: number;
                        spent: number;
                    }>;
                    ability: z.ZodObject<{
                        grenadeEffects: z.ZodNull;
                        ability1Effects: z.ZodNull;
                        ability2Effects: z.ZodNull;
                        ultimateEffects: z.ZodNull;
                    }, "strip", z.ZodTypeAny, {
                        grenadeEffects: null;
                        ability1Effects: null;
                        ability2Effects: null;
                        ultimateEffects: null;
                    }, {
                        grenadeEffects: null;
                        ability1Effects: null;
                        ability2Effects: null;
                        ultimateEffects: null;
                    }>;
                    wasAfk: z.ZodBoolean;
                    wasPenalized: z.ZodBoolean;
                    stayedInSpawn: z.ZodBoolean;
                }, "strip", z.ZodTypeAny, {
                    subject: string;
                    score: number;
                    kills: {
                        gameTime: Date;
                        roundTime: Date;
                        killer: string;
                        victim: string;
                        victimLocation: {
                            x: number;
                            y: number;
                        };
                        assistants: string[];
                        playerLocations: {
                            subject: string;
                            location: {
                                x: number;
                                y: number;
                            };
                            viewRadians: number;
                        }[];
                        finishingDamage: {
                            damageType: "" | "Weapon" | "Bomb" | "Ability" | "Fall" | "Melee" | "Invalid";
                            damageItem: string;
                            isSecondaryFireMode: boolean;
                        };
                    }[];
                    damage: {
                        receiver: string;
                        damage: number;
                        legshots: number;
                        bodyshots: number;
                        headshots: number;
                    }[];
                    ability: {
                        grenadeEffects: null;
                        ability1Effects: null;
                        ability2Effects: null;
                        ultimateEffects: null;
                    };
                    economy: {
                        loadoutValue: number;
                        weapon: string;
                        armor: string;
                        remaining: number;
                        spent: number;
                    };
                    wasAfk: boolean;
                    wasPenalized: boolean;
                    stayedInSpawn: boolean;
                }, {
                    subject: string;
                    score: number;
                    kills: {
                        gameTime: number;
                        roundTime: number;
                        killer: string;
                        victim: string;
                        victimLocation: {
                            x: number;
                            y: number;
                        };
                        assistants: string[];
                        playerLocations: {
                            subject: string;
                            location: {
                                x: number;
                                y: number;
                            };
                            viewRadians: number;
                        }[];
                        finishingDamage: {
                            damageType: "" | "Weapon" | "Bomb" | "Ability" | "Fall" | "Melee" | "Invalid";
                            damageItem: string;
                            isSecondaryFireMode: boolean;
                        };
                    }[];
                    damage: {
                        receiver: string;
                        damage: number;
                        legshots: number;
                        bodyshots: number;
                        headshots: number;
                    }[];
                    ability: {
                        grenadeEffects: null;
                        ability1Effects: null;
                        ability2Effects: null;
                        ultimateEffects: null;
                    };
                    economy: {
                        loadoutValue: number;
                        weapon: string;
                        armor: string;
                        remaining: number;
                        spent: number;
                    };
                    wasAfk: boolean;
                    wasPenalized: boolean;
                    stayedInSpawn: boolean;
                }>, "many">;
                roundResultCode: z.ZodEnum<["Elimination", "Detonate", "Defuse", "Surrendered", ""]>;
                playerEconomies: z.ZodArray<z.ZodObject<{
                    subject: z.ZodString;
                    loadoutValue: z.ZodNumber;
                    weapon: z.ZodString;
                    armor: z.ZodString;
                    remaining: z.ZodNumber;
                    spent: z.ZodNumber;
                }, "strip", z.ZodTypeAny, {
                    subject: string;
                    loadoutValue: number;
                    weapon: string;
                    armor: string;
                    remaining: number;
                    spent: number;
                }, {
                    subject: string;
                    loadoutValue: number;
                    weapon: string;
                    armor: string;
                    remaining: number;
                    spent: number;
                }>, "many">;
                playerScores: z.ZodArray<z.ZodObject<{
                    subject: z.ZodString;
                    score: z.ZodNumber;
                }, "strip", z.ZodTypeAny, {
                    subject: string;
                    score: number;
                }, {
                    subject: string;
                    score: number;
                }>, "many">;
            }, "strip", z.ZodTypeAny, {
                roundNum: number;
                roundResult: "Surrendered" | "Eliminated" | "Bomb detonated" | "Bomb defused" | "Round timer expired";
                roundCeremony: "" | "CeremonyDefault" | "CeremonyTeamAce" | "CeremonyFlawless" | "CeremonyCloser" | "CeremonyClutch" | "CeremonyThrifty" | "CeremonyAce";
                winningTeam: "Blue" | "Red";
                bombDefuser: "Blue" | "Red";
                plantLocation: {
                    x: number;
                    y: number;
                };
                plantSite: "" | "A" | "B" | "C";
                defuseLocation: {
                    x: number;
                    y: number;
                };
                playerStats: {
                    subject: string;
                    score: number;
                    kills: {
                        gameTime: Date;
                        roundTime: Date;
                        killer: string;
                        victim: string;
                        victimLocation: {
                            x: number;
                            y: number;
                        };
                        assistants: string[];
                        playerLocations: {
                            subject: string;
                            location: {
                                x: number;
                                y: number;
                            };
                            viewRadians: number;
                        }[];
                        finishingDamage: {
                            damageType: "" | "Weapon" | "Bomb" | "Ability" | "Fall" | "Melee" | "Invalid";
                            damageItem: string;
                            isSecondaryFireMode: boolean;
                        };
                    }[];
                    damage: {
                        receiver: string;
                        damage: number;
                        legshots: number;
                        bodyshots: number;
                        headshots: number;
                    }[];
                    ability: {
                        grenadeEffects: null;
                        ability1Effects: null;
                        ability2Effects: null;
                        ultimateEffects: null;
                    };
                    economy: {
                        loadoutValue: number;
                        weapon: string;
                        armor: string;
                        remaining: number;
                        spent: number;
                    };
                    wasAfk: boolean;
                    wasPenalized: boolean;
                    stayedInSpawn: boolean;
                }[];
                roundResultCode: "" | "Surrendered" | "Elimination" | "Detonate" | "Defuse";
                playerEconomies: {
                    subject: string;
                    loadoutValue: number;
                    weapon: string;
                    armor: string;
                    remaining: number;
                    spent: number;
                }[];
                playerScores: {
                    subject: string;
                    score: number;
                }[];
                bombPlanter?: string | undefined;
                plantRoundTime?: number | undefined;
                plantPlayerLocations?: {
                    subject: string;
                    location: {
                        x: number;
                        y: number;
                    };
                    viewRadians: number;
                }[] | undefined;
                defuseRoundTime?: number | undefined;
                defusePlayerLocations?: {
                    subject: string;
                    location: {
                        x: number;
                        y: number;
                    };
                    viewRadians: number;
                }[] | undefined;
            }, {
                roundNum: number;
                roundResult: "Surrendered" | "Eliminated" | "Bomb detonated" | "Bomb defused" | "Round timer expired";
                roundCeremony: "" | "CeremonyDefault" | "CeremonyTeamAce" | "CeremonyFlawless" | "CeremonyCloser" | "CeremonyClutch" | "CeremonyThrifty" | "CeremonyAce";
                winningTeam: "Blue" | "Red";
                bombDefuser: "Blue" | "Red";
                plantLocation: {
                    x: number;
                    y: number;
                };
                plantSite: "" | "A" | "B" | "C";
                defuseLocation: {
                    x: number;
                    y: number;
                };
                playerStats: {
                    subject: string;
                    score: number;
                    kills: {
                        gameTime: number;
                        roundTime: number;
                        killer: string;
                        victim: string;
                        victimLocation: {
                            x: number;
                            y: number;
                        };
                        assistants: string[];
                        playerLocations: {
                            subject: string;
                            location: {
                                x: number;
                                y: number;
                            };
                            viewRadians: number;
                        }[];
                        finishingDamage: {
                            damageType: "" | "Weapon" | "Bomb" | "Ability" | "Fall" | "Melee" | "Invalid";
                            damageItem: string;
                            isSecondaryFireMode: boolean;
                        };
                    }[];
                    damage: {
                        receiver: string;
                        damage: number;
                        legshots: number;
                        bodyshots: number;
                        headshots: number;
                    }[];
                    ability: {
                        grenadeEffects: null;
                        ability1Effects: null;
                        ability2Effects: null;
                        ultimateEffects: null;
                    };
                    economy: {
                        loadoutValue: number;
                        weapon: string;
                        armor: string;
                        remaining: number;
                        spent: number;
                    };
                    wasAfk: boolean;
                    wasPenalized: boolean;
                    stayedInSpawn: boolean;
                }[];
                roundResultCode: "" | "Surrendered" | "Elimination" | "Detonate" | "Defuse";
                playerEconomies: {
                    subject: string;
                    loadoutValue: number;
                    weapon: string;
                    armor: string;
                    remaining: number;
                    spent: number;
                }[];
                playerScores: {
                    subject: string;
                    score: number;
                }[];
                bombPlanter?: string | undefined;
                plantRoundTime?: number | undefined;
                plantPlayerLocations?: {
                    subject: string;
                    location: {
                        x: number;
                        y: number;
                    };
                    viewRadians: number;
                }[] | undefined;
                defuseRoundTime?: number | undefined;
                defusePlayerLocations?: {
                    subject: string;
                    location: {
                        x: number;
                        y: number;
                    };
                    viewRadians: number;
                }[] | undefined;
            }>, "many">;
            kills: z.ZodArray<z.ZodObject<{
                gameTime: z.ZodEffects<z.ZodNumber, Date, number>;
                roundTime: z.ZodEffects<z.ZodNumber, Date, number>;
                killer: z.ZodString;
                victim: z.ZodString;
                victimLocation: z.ZodObject<{
                    x: z.ZodNumber;
                    y: z.ZodNumber;
                }, "strip", z.ZodTypeAny, {
                    x: number;
                    y: number;
                }, {
                    x: number;
                    y: number;
                }>;
                assistants: z.ZodArray<z.ZodString, "many">;
                playerLocations: z.ZodArray<z.ZodObject<{
                    subject: z.ZodString;
                    viewRadians: z.ZodNumber;
                    location: z.ZodObject<{
                        x: z.ZodNumber;
                        y: z.ZodNumber;
                    }, "strip", z.ZodTypeAny, {
                        x: number;
                        y: number;
                    }, {
                        x: number;
                        y: number;
                    }>;
                }, "strip", z.ZodTypeAny, {
                    subject: string;
                    location: {
                        x: number;
                        y: number;
                    };
                    viewRadians: number;
                }, {
                    subject: string;
                    location: {
                        x: number;
                        y: number;
                    };
                    viewRadians: number;
                }>, "many">;
                finishingDamage: z.ZodObject<{
                    damageType: z.ZodEnum<["Weapon", "Bomb", "Ability", "Fall", "Melee", "Invalid", ""]>;
                    damageItem: z.ZodUnion<[z.ZodLiteral<"">, z.ZodLiteral<"Ultimate">, z.ZodLiteral<"Ability1">, z.ZodLiteral<"Ability2">, z.ZodLiteral<"GrenadeAbility">, z.ZodLiteral<"Primary">, z.ZodString]>;
                    isSecondaryFireMode: z.ZodBoolean;
                }, "strip", z.ZodTypeAny, {
                    damageType: "" | "Weapon" | "Bomb" | "Ability" | "Fall" | "Melee" | "Invalid";
                    damageItem: string;
                    isSecondaryFireMode: boolean;
                }, {
                    damageType: "" | "Weapon" | "Bomb" | "Ability" | "Fall" | "Melee" | "Invalid";
                    damageItem: string;
                    isSecondaryFireMode: boolean;
                }>;
                round: z.ZodNumber;
            }, "strip", z.ZodTypeAny, {
                round: number;
                gameTime: Date;
                roundTime: Date;
                killer: string;
                victim: string;
                victimLocation: {
                    x: number;
                    y: number;
                };
                assistants: string[];
                playerLocations: {
                    subject: string;
                    location: {
                        x: number;
                        y: number;
                    };
                    viewRadians: number;
                }[];
                finishingDamage: {
                    damageType: "" | "Weapon" | "Bomb" | "Ability" | "Fall" | "Melee" | "Invalid";
                    damageItem: string;
                    isSecondaryFireMode: boolean;
                };
            }, {
                round: number;
                gameTime: number;
                roundTime: number;
                killer: string;
                victim: string;
                victimLocation: {
                    x: number;
                    y: number;
                };
                assistants: string[];
                playerLocations: {
                    subject: string;
                    location: {
                        x: number;
                        y: number;
                    };
                    viewRadians: number;
                }[];
                finishingDamage: {
                    damageType: "" | "Weapon" | "Bomb" | "Ability" | "Fall" | "Melee" | "Invalid";
                    damageItem: string;
                    isSecondaryFireMode: boolean;
                };
            }>, "many">;
        }, "strip", z.ZodTypeAny, {
            kills: {
                round: number;
                gameTime: Date;
                roundTime: Date;
                killer: string;
                victim: string;
                victimLocation: {
                    x: number;
                    y: number;
                };
                assistants: string[];
                playerLocations: {
                    subject: string;
                    location: {
                        x: number;
                        y: number;
                    };
                    viewRadians: number;
                }[];
                finishingDamage: {
                    damageType: "" | "Weapon" | "Bomb" | "Ability" | "Fall" | "Melee" | "Invalid";
                    damageItem: string;
                    isSecondaryFireMode: boolean;
                };
            }[];
            matchInfo: {
                platformType: string;
                gameMode: string;
                mapId: string;
                customGameName: string;
                matchId: string;
                gamePodId: string;
                gameLoopZone: string;
                gameServerAddress: string;
                gameVersion: string;
                gameLengthMillis: Date;
                gameStartMillis: Date;
                provisioningFlowID: "Matchmaking" | "CustomGame";
                isCompleted: boolean;
                forcePostProcessing: boolean;
                queueID: string;
                isRanked: boolean;
                isMatchSampled: boolean;
                seasonId: string;
                completionState: "" | "Surrendered" | "Completed" | "VoteDraw";
                premierMatchInfo: {};
                shouldMatchDisablePenalties: boolean;
                partyRRPenalties?: Record<string, number> | undefined;
            };
            players: {
                platformInfo: {
                    platformType: string;
                    platformOS: string;
                    platformOSVersion: string;
                    platformChipset: string;
                };
                subject: string;
                partyId: string;
                accountLevel: number;
                competitiveTier: number;
                gameName: string;
                tagLine: string;
                teamId: "Blue" | "Red";
                characterId: string;
                stats: {
                    score: number;
                    roundsPlayed: number;
                    kills: number;
                    deaths: number;
                    assists: number;
                    playtimeMillis: Date;
                    abilityCasts?: {
                        grenadeCasts: number;
                        ability1Casts: number;
                        ability2Casts: number;
                        ultimateCasts: number;
                    } | null | undefined;
                };
                roundDamage: {
                    round: number;
                    receiver: string;
                    damage: number;
                }[];
                isObserver: boolean;
                playerCard: string;
                playerTitle: string;
                preferredLevelBorder?: string | undefined;
                sessionPlaytimeMinutes?: number | undefined;
                xpModifications?: {
                    ID: string;
                    Value: number;
                }[] | undefined;
                behaviorFactors?: {
                    afkRounds: number;
                    commsRatingRecovery: number;
                    damageParticipationOutgoing: number;
                    collisions?: number | undefined;
                    friendlyFireIncoming?: number | undefined;
                    friendlyFireOutgoing?: number | undefined;
                    mouseMovement?: number | undefined;
                    stayedInSpawnRounds?: number | undefined;
                } | undefined;
                newPlayerExperienceDetails?: {
                    basicMovement: {
                        idleTimeMillis: number;
                        objectiveCompleteTimeMillis: number;
                    };
                    basicGunSkill: {
                        idleTimeMillis: number;
                        objectiveCompleteTimeMillis: number;
                    };
                    adaptiveBots: {
                        idleTimeMillis: number;
                        objectiveCompleteTimeMillis: number;
                        adaptiveBotAverageDurationMillisAllAttempts: number;
                        adaptiveBotAverageDurationMillisFirstAttempt: number;
                        killDetailsFirstAttempt: null;
                    };
                    ability: {
                        idleTimeMillis: number;
                        objectiveCompleteTimeMillis: number;
                    };
                    bombPlant: {
                        idleTimeMillis: number;
                        objectiveCompleteTimeMillis: number;
                    };
                    defendBombSite: {
                        success: boolean;
                        idleTimeMillis: number;
                        objectiveCompleteTimeMillis: number;
                    };
                    settingStatus: {
                        isMouseSensitivityDefault: boolean;
                        isCrosshairDefault: boolean;
                    };
                    versionString: string;
                } | undefined;
            }[];
            bots: unknown[];
            coaches: {
                subject: string;
                teamId: "Blue" | "Red";
            }[];
            roundResults: {
                roundNum: number;
                roundResult: "Surrendered" | "Eliminated" | "Bomb detonated" | "Bomb defused" | "Round timer expired";
                roundCeremony: "" | "CeremonyDefault" | "CeremonyTeamAce" | "CeremonyFlawless" | "CeremonyCloser" | "CeremonyClutch" | "CeremonyThrifty" | "CeremonyAce";
                winningTeam: "Blue" | "Red";
                bombDefuser: "Blue" | "Red";
                plantLocation: {
                    x: number;
                    y: number;
                };
                plantSite: "" | "A" | "B" | "C";
                defuseLocation: {
                    x: number;
                    y: number;
                };
                playerStats: {
                    subject: string;
                    score: number;
                    kills: {
                        gameTime: Date;
                        roundTime: Date;
                        killer: string;
                        victim: string;
                        victimLocation: {
                            x: number;
                            y: number;
                        };
                        assistants: string[];
                        playerLocations: {
                            subject: string;
                            location: {
                                x: number;
                                y: number;
                            };
                            viewRadians: number;
                        }[];
                        finishingDamage: {
                            damageType: "" | "Weapon" | "Bomb" | "Ability" | "Fall" | "Melee" | "Invalid";
                            damageItem: string;
                            isSecondaryFireMode: boolean;
                        };
                    }[];
                    damage: {
                        receiver: string;
                        damage: number;
                        legshots: number;
                        bodyshots: number;
                        headshots: number;
                    }[];
                    ability: {
                        grenadeEffects: null;
                        ability1Effects: null;
                        ability2Effects: null;
                        ultimateEffects: null;
                    };
                    economy: {
                        loadoutValue: number;
                        weapon: string;
                        armor: string;
                        remaining: number;
                        spent: number;
                    };
                    wasAfk: boolean;
                    wasPenalized: boolean;
                    stayedInSpawn: boolean;
                }[];
                roundResultCode: "" | "Surrendered" | "Elimination" | "Detonate" | "Defuse";
                playerEconomies: {
                    subject: string;
                    loadoutValue: number;
                    weapon: string;
                    armor: string;
                    remaining: number;
                    spent: number;
                }[];
                playerScores: {
                    subject: string;
                    score: number;
                }[];
                bombPlanter?: string | undefined;
                plantRoundTime?: number | undefined;
                plantPlayerLocations?: {
                    subject: string;
                    location: {
                        x: number;
                        y: number;
                    };
                    viewRadians: number;
                }[] | undefined;
                defuseRoundTime?: number | undefined;
                defusePlayerLocations?: {
                    subject: string;
                    location: {
                        x: number;
                        y: number;
                    };
                    viewRadians: number;
                }[] | undefined;
            }[];
            teams?: {
                teamId: "Blue" | "Red";
                roundsPlayed: number;
                won: boolean;
                roundsWon: number;
                numPoints: number;
            }[] | undefined;
        }, {
            kills: {
                round: number;
                gameTime: number;
                roundTime: number;
                killer: string;
                victim: string;
                victimLocation: {
                    x: number;
                    y: number;
                };
                assistants: string[];
                playerLocations: {
                    subject: string;
                    location: {
                        x: number;
                        y: number;
                    };
                    viewRadians: number;
                }[];
                finishingDamage: {
                    damageType: "" | "Weapon" | "Bomb" | "Ability" | "Fall" | "Melee" | "Invalid";
                    damageItem: string;
                    isSecondaryFireMode: boolean;
                };
            }[];
            matchInfo: {
                platformType: string;
                gameMode: string;
                mapId: string;
                customGameName: string;
                matchId: string;
                gamePodId: string;
                gameLoopZone: string;
                gameServerAddress: string;
                gameVersion: string;
                gameLengthMillis: number;
                gameStartMillis: number;
                provisioningFlowID: "Matchmaking" | "CustomGame";
                isCompleted: boolean;
                forcePostProcessing: boolean;
                queueID: string;
                isRanked: boolean;
                isMatchSampled: boolean;
                seasonId: string;
                completionState: "" | "Surrendered" | "Completed" | "VoteDraw";
                premierMatchInfo: {};
                shouldMatchDisablePenalties: boolean;
                partyRRPenalties?: Record<string, number> | undefined;
            };
            players: {
                platformInfo: {
                    platformType: string;
                    platformOS: string;
                    platformOSVersion: string;
                    platformChipset: string;
                };
                subject: string;
                partyId: string;
                accountLevel: number;
                competitiveTier: number;
                gameName: string;
                tagLine: string;
                teamId: "Blue" | "Red";
                characterId: string;
                stats: {
                    score: number;
                    roundsPlayed: number;
                    kills: number;
                    deaths: number;
                    assists: number;
                    playtimeMillis: number;
                    abilityCasts?: {
                        grenadeCasts: number;
                        ability1Casts: number;
                        ability2Casts: number;
                        ultimateCasts: number;
                    } | null | undefined;
                };
                roundDamage: {
                    round: number;
                    receiver: string;
                    damage: number;
                }[];
                isObserver: boolean;
                playerCard: string;
                playerTitle: string;
                preferredLevelBorder?: string | undefined;
                sessionPlaytimeMinutes?: number | undefined;
                xpModifications?: {
                    ID: string;
                    Value: number;
                }[] | undefined;
                behaviorFactors?: {
                    afkRounds: number;
                    commsRatingRecovery: number;
                    damageParticipationOutgoing: number;
                    collisions?: number | undefined;
                    friendlyFireIncoming?: number | undefined;
                    friendlyFireOutgoing?: number | undefined;
                    mouseMovement?: number | undefined;
                    stayedInSpawnRounds?: number | undefined;
                } | undefined;
                newPlayerExperienceDetails?: {
                    basicMovement: {
                        idleTimeMillis: number;
                        objectiveCompleteTimeMillis: number;
                    };
                    basicGunSkill: {
                        idleTimeMillis: number;
                        objectiveCompleteTimeMillis: number;
                    };
                    adaptiveBots: {
                        idleTimeMillis: number;
                        objectiveCompleteTimeMillis: number;
                        adaptiveBotAverageDurationMillisAllAttempts: number;
                        adaptiveBotAverageDurationMillisFirstAttempt: number;
                        killDetailsFirstAttempt: null;
                    };
                    ability: {
                        idleTimeMillis: number;
                        objectiveCompleteTimeMillis: number;
                    };
                    bombPlant: {
                        idleTimeMillis: number;
                        objectiveCompleteTimeMillis: number;
                    };
                    defendBombSite: {
                        success: boolean;
                        idleTimeMillis: number;
                        objectiveCompleteTimeMillis: number;
                    };
                    settingStatus: {
                        isMouseSensitivityDefault: boolean;
                        isCrosshairDefault: boolean;
                    };
                    versionString: string;
                } | undefined;
            }[];
            bots: unknown[];
            coaches: {
                subject: string;
                teamId: "Blue" | "Red";
            }[];
            roundResults: {
                roundNum: number;
                roundResult: "Surrendered" | "Eliminated" | "Bomb detonated" | "Bomb defused" | "Round timer expired";
                roundCeremony: "" | "CeremonyDefault" | "CeremonyTeamAce" | "CeremonyFlawless" | "CeremonyCloser" | "CeremonyClutch" | "CeremonyThrifty" | "CeremonyAce";
                winningTeam: "Blue" | "Red";
                bombDefuser: "Blue" | "Red";
                plantLocation: {
                    x: number;
                    y: number;
                };
                plantSite: "" | "A" | "B" | "C";
                defuseLocation: {
                    x: number;
                    y: number;
                };
                playerStats: {
                    subject: string;
                    score: number;
                    kills: {
                        gameTime: number;
                        roundTime: number;
                        killer: string;
                        victim: string;
                        victimLocation: {
                            x: number;
                            y: number;
                        };
                        assistants: string[];
                        playerLocations: {
                            subject: string;
                            location: {
                                x: number;
                                y: number;
                            };
                            viewRadians: number;
                        }[];
                        finishingDamage: {
                            damageType: "" | "Weapon" | "Bomb" | "Ability" | "Fall" | "Melee" | "Invalid";
                            damageItem: string;
                            isSecondaryFireMode: boolean;
                        };
                    }[];
                    damage: {
                        receiver: string;
                        damage: number;
                        legshots: number;
                        bodyshots: number;
                        headshots: number;
                    }[];
                    ability: {
                        grenadeEffects: null;
                        ability1Effects: null;
                        ability2Effects: null;
                        ultimateEffects: null;
                    };
                    economy: {
                        loadoutValue: number;
                        weapon: string;
                        armor: string;
                        remaining: number;
                        spent: number;
                    };
                    wasAfk: boolean;
                    wasPenalized: boolean;
                    stayedInSpawn: boolean;
                }[];
                roundResultCode: "" | "Surrendered" | "Elimination" | "Detonate" | "Defuse";
                playerEconomies: {
                    subject: string;
                    loadoutValue: number;
                    weapon: string;
                    armor: string;
                    remaining: number;
                    spent: number;
                }[];
                playerScores: {
                    subject: string;
                    score: number;
                }[];
                bombPlanter?: string | undefined;
                plantRoundTime?: number | undefined;
                plantPlayerLocations?: {
                    subject: string;
                    location: {
                        x: number;
                        y: number;
                    };
                    viewRadians: number;
                }[] | undefined;
                defuseRoundTime?: number | undefined;
                defusePlayerLocations?: {
                    subject: string;
                    location: {
                        x: number;
                        y: number;
                    };
                    viewRadians: number;
                }[] | undefined;
            }[];
            teams?: {
                teamId: "Blue" | "Red";
                roundsPlayed: number;
                won: boolean;
                roundsWon: number;
                numPoints: number;
            }[] | undefined;
        }>;
    };
}, "type" | "name" | "url"> & {
    "~type": {
        readonly name: "Match Details";
        readonly description: "Get the details of a match after it ends";
        readonly type: "pd";
        readonly url: "match-details/v1/matches/:matchID";
        readonly responses: {
            readonly "200": z.ZodObject<{
                matchInfo: z.ZodObject<{
                    matchId: z.ZodString;
                    mapId: z.ZodString;
                    gamePodId: z.ZodString;
                    gameLoopZone: z.ZodString;
                    gameServerAddress: z.ZodString;
                    gameVersion: z.ZodString;
                    gameLengthMillis: z.ZodEffects<z.ZodNumber, Date, number>;
                    gameStartMillis: z.ZodEffects<z.ZodNumber, Date, number>;
                    provisioningFlowID: z.ZodEnum<["Matchmaking", "CustomGame"]>;
                    isCompleted: z.ZodBoolean;
                    customGameName: z.ZodString;
                    forcePostProcessing: z.ZodBoolean;
                    queueID: z.ZodString;
                    gameMode: z.ZodString;
                    isRanked: z.ZodBoolean;
                    isMatchSampled: z.ZodBoolean;
                    seasonId: z.ZodString;
                    completionState: z.ZodEnum<["Surrendered", "Completed", "VoteDraw", ""]>;
                    platformType: z.ZodString;
                    premierMatchInfo: z.ZodObject<{}, "strip", z.ZodTypeAny, {}, {}>;
                    partyRRPenalties: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodNumber>>;
                    shouldMatchDisablePenalties: z.ZodBoolean;
                }, "strip", z.ZodTypeAny, {
                    platformType: string;
                    gameMode: string;
                    mapId: string;
                    customGameName: string;
                    matchId: string;
                    gamePodId: string;
                    gameLoopZone: string;
                    gameServerAddress: string;
                    gameVersion: string;
                    gameLengthMillis: Date;
                    gameStartMillis: Date;
                    provisioningFlowID: "Matchmaking" | "CustomGame";
                    isCompleted: boolean;
                    forcePostProcessing: boolean;
                    queueID: string;
                    isRanked: boolean;
                    isMatchSampled: boolean;
                    seasonId: string;
                    completionState: "" | "Surrendered" | "Completed" | "VoteDraw";
                    premierMatchInfo: {};
                    shouldMatchDisablePenalties: boolean;
                    partyRRPenalties?: Record<string, number> | undefined;
                }, {
                    platformType: string;
                    gameMode: string;
                    mapId: string;
                    customGameName: string;
                    matchId: string;
                    gamePodId: string;
                    gameLoopZone: string;
                    gameServerAddress: string;
                    gameVersion: string;
                    gameLengthMillis: number;
                    gameStartMillis: number;
                    provisioningFlowID: "Matchmaking" | "CustomGame";
                    isCompleted: boolean;
                    forcePostProcessing: boolean;
                    queueID: string;
                    isRanked: boolean;
                    isMatchSampled: boolean;
                    seasonId: string;
                    completionState: "" | "Surrendered" | "Completed" | "VoteDraw";
                    premierMatchInfo: {};
                    shouldMatchDisablePenalties: boolean;
                    partyRRPenalties?: Record<string, number> | undefined;
                }>;
                players: z.ZodArray<z.ZodObject<{
                    subject: z.ZodString;
                    gameName: z.ZodString;
                    tagLine: z.ZodString;
                    platformInfo: z.ZodObject<{
                        platformType: z.ZodString;
                        platformOS: z.ZodString;
                        platformOSVersion: z.ZodString;
                        platformChipset: z.ZodString;
                    }, "strip", z.ZodTypeAny, {
                        platformType: string;
                        platformOS: string;
                        platformOSVersion: string;
                        platformChipset: string;
                    }, {
                        platformType: string;
                        platformOS: string;
                        platformOSVersion: string;
                        platformChipset: string;
                    }>;
                    teamId: z.ZodEnum<["Blue", "Red"]>;
                    partyId: z.ZodString;
                    characterId: z.ZodString;
                    stats: z.ZodObject<{
                        score: z.ZodNumber;
                        roundsPlayed: z.ZodNumber;
                        kills: z.ZodNumber;
                        deaths: z.ZodNumber;
                        assists: z.ZodNumber;
                        playtimeMillis: z.ZodEffects<z.ZodNumber, Date, number>;
                        abilityCasts: z.ZodOptional<z.ZodNullable<z.ZodObject<{
                            grenadeCasts: z.ZodNumber;
                            ability1Casts: z.ZodNumber;
                            ability2Casts: z.ZodNumber;
                            ultimateCasts: z.ZodNumber;
                        }, "strip", z.ZodTypeAny, {
                            grenadeCasts: number;
                            ability1Casts: number;
                            ability2Casts: number;
                            ultimateCasts: number;
                        }, {
                            grenadeCasts: number;
                            ability1Casts: number;
                            ability2Casts: number;
                            ultimateCasts: number;
                        }>>>;
                    }, "strip", z.ZodTypeAny, {
                        score: number;
                        roundsPlayed: number;
                        kills: number;
                        deaths: number;
                        assists: number;
                        playtimeMillis: Date;
                        abilityCasts?: {
                            grenadeCasts: number;
                            ability1Casts: number;
                            ability2Casts: number;
                            ultimateCasts: number;
                        } | null | undefined;
                    }, {
                        score: number;
                        roundsPlayed: number;
                        kills: number;
                        deaths: number;
                        assists: number;
                        playtimeMillis: number;
                        abilityCasts?: {
                            grenadeCasts: number;
                            ability1Casts: number;
                            ability2Casts: number;
                            ultimateCasts: number;
                        } | null | undefined;
                    }>;
                    roundDamage: z.ZodArray<z.ZodObject<{
                        round: z.ZodNumber;
                        receiver: z.ZodString;
                        damage: z.ZodNumber;
                    }, "strip", z.ZodTypeAny, {
                        round: number;
                        receiver: string;
                        damage: number;
                    }, {
                        round: number;
                        receiver: string;
                        damage: number;
                    }>, "many">;
                    competitiveTier: z.ZodNumber;
                    isObserver: z.ZodBoolean;
                    playerCard: z.ZodString;
                    playerTitle: z.ZodString;
                    preferredLevelBorder: z.ZodOptional<z.ZodString>;
                    accountLevel: z.ZodNumber;
                    sessionPlaytimeMinutes: z.ZodOptional<z.ZodNumber>;
                    xpModifications: z.ZodOptional<z.ZodArray<z.ZodObject<{
                        Value: z.ZodNumber;
                        ID: z.ZodString;
                    }, "strip", z.ZodTypeAny, {
                        ID: string;
                        Value: number;
                    }, {
                        ID: string;
                        Value: number;
                    }>, "many">>;
                    behaviorFactors: z.ZodOptional<z.ZodObject<{
                        afkRounds: z.ZodNumber;
                        collisions: z.ZodOptional<z.ZodNumber>;
                        commsRatingRecovery: z.ZodNumber;
                        damageParticipationOutgoing: z.ZodNumber;
                        friendlyFireIncoming: z.ZodOptional<z.ZodNumber>;
                        friendlyFireOutgoing: z.ZodOptional<z.ZodNumber>;
                        mouseMovement: z.ZodOptional<z.ZodNumber>;
                        stayedInSpawnRounds: z.ZodOptional<z.ZodNumber>;
                    }, "strip", z.ZodTypeAny, {
                        afkRounds: number;
                        commsRatingRecovery: number;
                        damageParticipationOutgoing: number;
                        collisions?: number | undefined;
                        friendlyFireIncoming?: number | undefined;
                        friendlyFireOutgoing?: number | undefined;
                        mouseMovement?: number | undefined;
                        stayedInSpawnRounds?: number | undefined;
                    }, {
                        afkRounds: number;
                        commsRatingRecovery: number;
                        damageParticipationOutgoing: number;
                        collisions?: number | undefined;
                        friendlyFireIncoming?: number | undefined;
                        friendlyFireOutgoing?: number | undefined;
                        mouseMovement?: number | undefined;
                        stayedInSpawnRounds?: number | undefined;
                    }>>;
                    newPlayerExperienceDetails: z.ZodOptional<z.ZodObject<{
                        basicMovement: z.ZodObject<{
                            idleTimeMillis: z.ZodNumber;
                            objectiveCompleteTimeMillis: z.ZodNumber;
                        }, "strip", z.ZodTypeAny, {
                            idleTimeMillis: number;
                            objectiveCompleteTimeMillis: number;
                        }, {
                            idleTimeMillis: number;
                            objectiveCompleteTimeMillis: number;
                        }>;
                        basicGunSkill: z.ZodObject<{
                            idleTimeMillis: z.ZodNumber;
                            objectiveCompleteTimeMillis: z.ZodNumber;
                        }, "strip", z.ZodTypeAny, {
                            idleTimeMillis: number;
                            objectiveCompleteTimeMillis: number;
                        }, {
                            idleTimeMillis: number;
                            objectiveCompleteTimeMillis: number;
                        }>;
                        adaptiveBots: z.ZodObject<{
                            adaptiveBotAverageDurationMillisAllAttempts: z.ZodNumber;
                            adaptiveBotAverageDurationMillisFirstAttempt: z.ZodNumber;
                            killDetailsFirstAttempt: z.ZodNull;
                            idleTimeMillis: z.ZodNumber;
                            objectiveCompleteTimeMillis: z.ZodNumber;
                        }, "strip", z.ZodTypeAny, {
                            idleTimeMillis: number;
                            objectiveCompleteTimeMillis: number;
                            adaptiveBotAverageDurationMillisAllAttempts: number;
                            adaptiveBotAverageDurationMillisFirstAttempt: number;
                            killDetailsFirstAttempt: null;
                        }, {
                            idleTimeMillis: number;
                            objectiveCompleteTimeMillis: number;
                            adaptiveBotAverageDurationMillisAllAttempts: number;
                            adaptiveBotAverageDurationMillisFirstAttempt: number;
                            killDetailsFirstAttempt: null;
                        }>;
                        ability: z.ZodObject<{
                            idleTimeMillis: z.ZodNumber;
                            objectiveCompleteTimeMillis: z.ZodNumber;
                        }, "strip", z.ZodTypeAny, {
                            idleTimeMillis: number;
                            objectiveCompleteTimeMillis: number;
                        }, {
                            idleTimeMillis: number;
                            objectiveCompleteTimeMillis: number;
                        }>;
                        bombPlant: z.ZodObject<{
                            idleTimeMillis: z.ZodNumber;
                            objectiveCompleteTimeMillis: z.ZodNumber;
                        }, "strip", z.ZodTypeAny, {
                            idleTimeMillis: number;
                            objectiveCompleteTimeMillis: number;
                        }, {
                            idleTimeMillis: number;
                            objectiveCompleteTimeMillis: number;
                        }>;
                        defendBombSite: z.ZodObject<{
                            success: z.ZodBoolean;
                            idleTimeMillis: z.ZodNumber;
                            objectiveCompleteTimeMillis: z.ZodNumber;
                        }, "strip", z.ZodTypeAny, {
                            success: boolean;
                            idleTimeMillis: number;
                            objectiveCompleteTimeMillis: number;
                        }, {
                            success: boolean;
                            idleTimeMillis: number;
                            objectiveCompleteTimeMillis: number;
                        }>;
                        settingStatus: z.ZodObject<{
                            isMouseSensitivityDefault: z.ZodBoolean;
                            isCrosshairDefault: z.ZodBoolean;
                        }, "strip", z.ZodTypeAny, {
                            isMouseSensitivityDefault: boolean;
                            isCrosshairDefault: boolean;
                        }, {
                            isMouseSensitivityDefault: boolean;
                            isCrosshairDefault: boolean;
                        }>;
                        versionString: z.ZodString;
                    }, "strip", z.ZodTypeAny, {
                        basicMovement: {
                            idleTimeMillis: number;
                            objectiveCompleteTimeMillis: number;
                        };
                        basicGunSkill: {
                            idleTimeMillis: number;
                            objectiveCompleteTimeMillis: number;
                        };
                        adaptiveBots: {
                            idleTimeMillis: number;
                            objectiveCompleteTimeMillis: number;
                            adaptiveBotAverageDurationMillisAllAttempts: number;
                            adaptiveBotAverageDurationMillisFirstAttempt: number;
                            killDetailsFirstAttempt: null;
                        };
                        ability: {
                            idleTimeMillis: number;
                            objectiveCompleteTimeMillis: number;
                        };
                        bombPlant: {
                            idleTimeMillis: number;
                            objectiveCompleteTimeMillis: number;
                        };
                        defendBombSite: {
                            success: boolean;
                            idleTimeMillis: number;
                            objectiveCompleteTimeMillis: number;
                        };
                        settingStatus: {
                            isMouseSensitivityDefault: boolean;
                            isCrosshairDefault: boolean;
                        };
                        versionString: string;
                    }, {
                        basicMovement: {
                            idleTimeMillis: number;
                            objectiveCompleteTimeMillis: number;
                        };
                        basicGunSkill: {
                            idleTimeMillis: number;
                            objectiveCompleteTimeMillis: number;
                        };
                        adaptiveBots: {
                            idleTimeMillis: number;
                            objectiveCompleteTimeMillis: number;
                            adaptiveBotAverageDurationMillisAllAttempts: number;
                            adaptiveBotAverageDurationMillisFirstAttempt: number;
                            killDetailsFirstAttempt: null;
                        };
                        ability: {
                            idleTimeMillis: number;
                            objectiveCompleteTimeMillis: number;
                        };
                        bombPlant: {
                            idleTimeMillis: number;
                            objectiveCompleteTimeMillis: number;
                        };
                        defendBombSite: {
                            success: boolean;
                            idleTimeMillis: number;
                            objectiveCompleteTimeMillis: number;
                        };
                        settingStatus: {
                            isMouseSensitivityDefault: boolean;
                            isCrosshairDefault: boolean;
                        };
                        versionString: string;
                    }>>;
                }, "strip", z.ZodTypeAny, {
                    platformInfo: {
                        platformType: string;
                        platformOS: string;
                        platformOSVersion: string;
                        platformChipset: string;
                    };
                    subject: string;
                    partyId: string;
                    accountLevel: number;
                    competitiveTier: number;
                    gameName: string;
                    tagLine: string;
                    teamId: "Blue" | "Red";
                    characterId: string;
                    stats: {
                        score: number;
                        roundsPlayed: number;
                        kills: number;
                        deaths: number;
                        assists: number;
                        playtimeMillis: Date;
                        abilityCasts?: {
                            grenadeCasts: number;
                            ability1Casts: number;
                            ability2Casts: number;
                            ultimateCasts: number;
                        } | null | undefined;
                    };
                    roundDamage: {
                        round: number;
                        receiver: string;
                        damage: number;
                    }[];
                    isObserver: boolean;
                    playerCard: string;
                    playerTitle: string;
                    preferredLevelBorder?: string | undefined;
                    sessionPlaytimeMinutes?: number | undefined;
                    xpModifications?: {
                        ID: string;
                        Value: number;
                    }[] | undefined;
                    behaviorFactors?: {
                        afkRounds: number;
                        commsRatingRecovery: number;
                        damageParticipationOutgoing: number;
                        collisions?: number | undefined;
                        friendlyFireIncoming?: number | undefined;
                        friendlyFireOutgoing?: number | undefined;
                        mouseMovement?: number | undefined;
                        stayedInSpawnRounds?: number | undefined;
                    } | undefined;
                    newPlayerExperienceDetails?: {
                        basicMovement: {
                            idleTimeMillis: number;
                            objectiveCompleteTimeMillis: number;
                        };
                        basicGunSkill: {
                            idleTimeMillis: number;
                            objectiveCompleteTimeMillis: number;
                        };
                        adaptiveBots: {
                            idleTimeMillis: number;
                            objectiveCompleteTimeMillis: number;
                            adaptiveBotAverageDurationMillisAllAttempts: number;
                            adaptiveBotAverageDurationMillisFirstAttempt: number;
                            killDetailsFirstAttempt: null;
                        };
                        ability: {
                            idleTimeMillis: number;
                            objectiveCompleteTimeMillis: number;
                        };
                        bombPlant: {
                            idleTimeMillis: number;
                            objectiveCompleteTimeMillis: number;
                        };
                        defendBombSite: {
                            success: boolean;
                            idleTimeMillis: number;
                            objectiveCompleteTimeMillis: number;
                        };
                        settingStatus: {
                            isMouseSensitivityDefault: boolean;
                            isCrosshairDefault: boolean;
                        };
                        versionString: string;
                    } | undefined;
                }, {
                    platformInfo: {
                        platformType: string;
                        platformOS: string;
                        platformOSVersion: string;
                        platformChipset: string;
                    };
                    subject: string;
                    partyId: string;
                    accountLevel: number;
                    competitiveTier: number;
                    gameName: string;
                    tagLine: string;
                    teamId: "Blue" | "Red";
                    characterId: string;
                    stats: {
                        score: number;
                        roundsPlayed: number;
                        kills: number;
                        deaths: number;
                        assists: number;
                        playtimeMillis: number;
                        abilityCasts?: {
                            grenadeCasts: number;
                            ability1Casts: number;
                            ability2Casts: number;
                            ultimateCasts: number;
                        } | null | undefined;
                    };
                    roundDamage: {
                        round: number;
                        receiver: string;
                        damage: number;
                    }[];
                    isObserver: boolean;
                    playerCard: string;
                    playerTitle: string;
                    preferredLevelBorder?: string | undefined;
                    sessionPlaytimeMinutes?: number | undefined;
                    xpModifications?: {
                        ID: string;
                        Value: number;
                    }[] | undefined;
                    behaviorFactors?: {
                        afkRounds: number;
                        commsRatingRecovery: number;
                        damageParticipationOutgoing: number;
                        collisions?: number | undefined;
                        friendlyFireIncoming?: number | undefined;
                        friendlyFireOutgoing?: number | undefined;
                        mouseMovement?: number | undefined;
                        stayedInSpawnRounds?: number | undefined;
                    } | undefined;
                    newPlayerExperienceDetails?: {
                        basicMovement: {
                            idleTimeMillis: number;
                            objectiveCompleteTimeMillis: number;
                        };
                        basicGunSkill: {
                            idleTimeMillis: number;
                            objectiveCompleteTimeMillis: number;
                        };
                        adaptiveBots: {
                            idleTimeMillis: number;
                            objectiveCompleteTimeMillis: number;
                            adaptiveBotAverageDurationMillisAllAttempts: number;
                            adaptiveBotAverageDurationMillisFirstAttempt: number;
                            killDetailsFirstAttempt: null;
                        };
                        ability: {
                            idleTimeMillis: number;
                            objectiveCompleteTimeMillis: number;
                        };
                        bombPlant: {
                            idleTimeMillis: number;
                            objectiveCompleteTimeMillis: number;
                        };
                        defendBombSite: {
                            success: boolean;
                            idleTimeMillis: number;
                            objectiveCompleteTimeMillis: number;
                        };
                        settingStatus: {
                            isMouseSensitivityDefault: boolean;
                            isCrosshairDefault: boolean;
                        };
                        versionString: string;
                    } | undefined;
                }>, "many">;
                bots: z.ZodArray<z.ZodUnknown, "many">;
                coaches: z.ZodArray<z.ZodObject<{
                    subject: z.ZodString;
                    teamId: z.ZodEnum<["Blue", "Red"]>;
                }, "strip", z.ZodTypeAny, {
                    subject: string;
                    teamId: "Blue" | "Red";
                }, {
                    subject: string;
                    teamId: "Blue" | "Red";
                }>, "many">;
                teams: z.ZodOptional<z.ZodArray<z.ZodObject<{
                    teamId: z.ZodEnum<["Blue", "Red"]>;
                    won: z.ZodBoolean;
                    roundsPlayed: z.ZodNumber;
                    roundsWon: z.ZodNumber;
                    numPoints: z.ZodNumber;
                }, "strip", z.ZodTypeAny, {
                    teamId: "Blue" | "Red";
                    roundsPlayed: number;
                    won: boolean;
                    roundsWon: number;
                    numPoints: number;
                }, {
                    teamId: "Blue" | "Red";
                    roundsPlayed: number;
                    won: boolean;
                    roundsWon: number;
                    numPoints: number;
                }>, "many">>;
                roundResults: z.ZodArray<z.ZodObject<{
                    roundNum: z.ZodNumber;
                    roundResult: z.ZodEnum<["Eliminated", "Bomb detonated", "Bomb defused", "Surrendered", "Round timer expired"]>;
                    roundCeremony: z.ZodEnum<["CeremonyDefault", "CeremonyTeamAce", "CeremonyFlawless", "CeremonyCloser", "CeremonyClutch", "CeremonyThrifty", "CeremonyAce", ""]>;
                    winningTeam: z.ZodEnum<["Blue", "Red"]>;
                    bombPlanter: z.ZodOptional<z.ZodString>;
                    bombDefuser: z.ZodEnum<["Blue", "Red"]>;
                    plantRoundTime: z.ZodOptional<z.ZodNumber>;
                    plantPlayerLocations: z.ZodOptional<z.ZodArray<z.ZodObject<{
                        subject: z.ZodString;
                        viewRadians: z.ZodNumber;
                        location: z.ZodObject<{
                            x: z.ZodNumber;
                            y: z.ZodNumber;
                        }, "strip", z.ZodTypeAny, {
                            x: number;
                            y: number;
                        }, {
                            x: number;
                            y: number;
                        }>;
                    }, "strip", z.ZodTypeAny, {
                        subject: string;
                        location: {
                            x: number;
                            y: number;
                        };
                        viewRadians: number;
                    }, {
                        subject: string;
                        location: {
                            x: number;
                            y: number;
                        };
                        viewRadians: number;
                    }>, "many">>;
                    plantLocation: z.ZodObject<{
                        x: z.ZodNumber;
                        y: z.ZodNumber;
                    }, "strip", z.ZodTypeAny, {
                        x: number;
                        y: number;
                    }, {
                        x: number;
                        y: number;
                    }>;
                    plantSite: z.ZodEnum<["A", "B", "C", ""]>;
                    defuseRoundTime: z.ZodOptional<z.ZodNumber>;
                    defusePlayerLocations: z.ZodOptional<z.ZodArray<z.ZodObject<{
                        subject: z.ZodString;
                        viewRadians: z.ZodNumber;
                        location: z.ZodObject<{
                            x: z.ZodNumber;
                            y: z.ZodNumber;
                        }, "strip", z.ZodTypeAny, {
                            x: number;
                            y: number;
                        }, {
                            x: number;
                            y: number;
                        }>;
                    }, "strip", z.ZodTypeAny, {
                        subject: string;
                        location: {
                            x: number;
                            y: number;
                        };
                        viewRadians: number;
                    }, {
                        subject: string;
                        location: {
                            x: number;
                            y: number;
                        };
                        viewRadians: number;
                    }>, "many">>;
                    defuseLocation: z.ZodObject<{
                        x: z.ZodNumber;
                        y: z.ZodNumber;
                    }, "strip", z.ZodTypeAny, {
                        x: number;
                        y: number;
                    }, {
                        x: number;
                        y: number;
                    }>;
                    playerStats: z.ZodArray<z.ZodObject<{
                        subject: z.ZodString;
                        kills: z.ZodArray<z.ZodObject<{
                            gameTime: z.ZodEffects<z.ZodNumber, Date, number>;
                            roundTime: z.ZodEffects<z.ZodNumber, Date, number>;
                            killer: z.ZodString;
                            victim: z.ZodString;
                            victimLocation: z.ZodObject<{
                                x: z.ZodNumber;
                                y: z.ZodNumber;
                            }, "strip", z.ZodTypeAny, {
                                x: number;
                                y: number;
                            }, {
                                x: number;
                                y: number;
                            }>;
                            assistants: z.ZodArray<z.ZodString, "many">;
                            playerLocations: z.ZodArray<z.ZodObject<{
                                subject: z.ZodString;
                                viewRadians: z.ZodNumber;
                                location: z.ZodObject<{
                                    x: z.ZodNumber;
                                    y: z.ZodNumber;
                                }, "strip", z.ZodTypeAny, {
                                    x: number;
                                    y: number;
                                }, {
                                    x: number;
                                    y: number;
                                }>;
                            }, "strip", z.ZodTypeAny, {
                                subject: string;
                                location: {
                                    x: number;
                                    y: number;
                                };
                                viewRadians: number;
                            }, {
                                subject: string;
                                location: {
                                    x: number;
                                    y: number;
                                };
                                viewRadians: number;
                            }>, "many">;
                            finishingDamage: z.ZodObject<{
                                damageType: z.ZodEnum<["Weapon", "Bomb", "Ability", "Fall", "Melee", "Invalid", ""]>;
                                damageItem: z.ZodUnion<[z.ZodLiteral<"">, z.ZodLiteral<"Ultimate">, z.ZodLiteral<"Ability1">, z.ZodLiteral<"Ability2">, z.ZodLiteral<"GrenadeAbility">, z.ZodLiteral<"Primary">, z.ZodString]>;
                                isSecondaryFireMode: z.ZodBoolean;
                            }, "strip", z.ZodTypeAny, {
                                damageType: "" | "Weapon" | "Bomb" | "Ability" | "Fall" | "Melee" | "Invalid";
                                damageItem: string;
                                isSecondaryFireMode: boolean;
                            }, {
                                damageType: "" | "Weapon" | "Bomb" | "Ability" | "Fall" | "Melee" | "Invalid";
                                damageItem: string;
                                isSecondaryFireMode: boolean;
                            }>;
                        }, "strip", z.ZodTypeAny, {
                            gameTime: Date;
                            roundTime: Date;
                            killer: string;
                            victim: string;
                            victimLocation: {
                                x: number;
                                y: number;
                            };
                            assistants: string[];
                            playerLocations: {
                                subject: string;
                                location: {
                                    x: number;
                                    y: number;
                                };
                                viewRadians: number;
                            }[];
                            finishingDamage: {
                                damageType: "" | "Weapon" | "Bomb" | "Ability" | "Fall" | "Melee" | "Invalid";
                                damageItem: string;
                                isSecondaryFireMode: boolean;
                            };
                        }, {
                            gameTime: number;
                            roundTime: number;
                            killer: string;
                            victim: string;
                            victimLocation: {
                                x: number;
                                y: number;
                            };
                            assistants: string[];
                            playerLocations: {
                                subject: string;
                                location: {
                                    x: number;
                                    y: number;
                                };
                                viewRadians: number;
                            }[];
                            finishingDamage: {
                                damageType: "" | "Weapon" | "Bomb" | "Ability" | "Fall" | "Melee" | "Invalid";
                                damageItem: string;
                                isSecondaryFireMode: boolean;
                            };
                        }>, "many">;
                        damage: z.ZodArray<z.ZodObject<{
                            receiver: z.ZodString;
                            damage: z.ZodNumber;
                            legshots: z.ZodNumber;
                            bodyshots: z.ZodNumber;
                            headshots: z.ZodNumber;
                        }, "strip", z.ZodTypeAny, {
                            receiver: string;
                            damage: number;
                            legshots: number;
                            bodyshots: number;
                            headshots: number;
                        }, {
                            receiver: string;
                            damage: number;
                            legshots: number;
                            bodyshots: number;
                            headshots: number;
                        }>, "many">;
                        score: z.ZodNumber;
                        economy: z.ZodObject<{
                            loadoutValue: z.ZodNumber;
                            weapon: z.ZodString;
                            armor: z.ZodString;
                            remaining: z.ZodNumber;
                            spent: z.ZodNumber;
                        }, "strip", z.ZodTypeAny, {
                            loadoutValue: number;
                            weapon: string;
                            armor: string;
                            remaining: number;
                            spent: number;
                        }, {
                            loadoutValue: number;
                            weapon: string;
                            armor: string;
                            remaining: number;
                            spent: number;
                        }>;
                        ability: z.ZodObject<{
                            grenadeEffects: z.ZodNull;
                            ability1Effects: z.ZodNull;
                            ability2Effects: z.ZodNull;
                            ultimateEffects: z.ZodNull;
                        }, "strip", z.ZodTypeAny, {
                            grenadeEffects: null;
                            ability1Effects: null;
                            ability2Effects: null;
                            ultimateEffects: null;
                        }, {
                            grenadeEffects: null;
                            ability1Effects: null;
                            ability2Effects: null;
                            ultimateEffects: null;
                        }>;
                        wasAfk: z.ZodBoolean;
                        wasPenalized: z.ZodBoolean;
                        stayedInSpawn: z.ZodBoolean;
                    }, "strip", z.ZodTypeAny, {
                        subject: string;
                        score: number;
                        kills: {
                            gameTime: Date;
                            roundTime: Date;
                            killer: string;
                            victim: string;
                            victimLocation: {
                                x: number;
                                y: number;
                            };
                            assistants: string[];
                            playerLocations: {
                                subject: string;
                                location: {
                                    x: number;
                                    y: number;
                                };
                                viewRadians: number;
                            }[];
                            finishingDamage: {
                                damageType: "" | "Weapon" | "Bomb" | "Ability" | "Fall" | "Melee" | "Invalid";
                                damageItem: string;
                                isSecondaryFireMode: boolean;
                            };
                        }[];
                        damage: {
                            receiver: string;
                            damage: number;
                            legshots: number;
                            bodyshots: number;
                            headshots: number;
                        }[];
                        ability: {
                            grenadeEffects: null;
                            ability1Effects: null;
                            ability2Effects: null;
                            ultimateEffects: null;
                        };
                        economy: {
                            loadoutValue: number;
                            weapon: string;
                            armor: string;
                            remaining: number;
                            spent: number;
                        };
                        wasAfk: boolean;
                        wasPenalized: boolean;
                        stayedInSpawn: boolean;
                    }, {
                        subject: string;
                        score: number;
                        kills: {
                            gameTime: number;
                            roundTime: number;
                            killer: string;
                            victim: string;
                            victimLocation: {
                                x: number;
                                y: number;
                            };
                            assistants: string[];
                            playerLocations: {
                                subject: string;
                                location: {
                                    x: number;
                                    y: number;
                                };
                                viewRadians: number;
                            }[];
                            finishingDamage: {
                                damageType: "" | "Weapon" | "Bomb" | "Ability" | "Fall" | "Melee" | "Invalid";
                                damageItem: string;
                                isSecondaryFireMode: boolean;
                            };
                        }[];
                        damage: {
                            receiver: string;
                            damage: number;
                            legshots: number;
                            bodyshots: number;
                            headshots: number;
                        }[];
                        ability: {
                            grenadeEffects: null;
                            ability1Effects: null;
                            ability2Effects: null;
                            ultimateEffects: null;
                        };
                        economy: {
                            loadoutValue: number;
                            weapon: string;
                            armor: string;
                            remaining: number;
                            spent: number;
                        };
                        wasAfk: boolean;
                        wasPenalized: boolean;
                        stayedInSpawn: boolean;
                    }>, "many">;
                    roundResultCode: z.ZodEnum<["Elimination", "Detonate", "Defuse", "Surrendered", ""]>;
                    playerEconomies: z.ZodArray<z.ZodObject<{
                        subject: z.ZodString;
                        loadoutValue: z.ZodNumber;
                        weapon: z.ZodString;
                        armor: z.ZodString;
                        remaining: z.ZodNumber;
                        spent: z.ZodNumber;
                    }, "strip", z.ZodTypeAny, {
                        subject: string;
                        loadoutValue: number;
                        weapon: string;
                        armor: string;
                        remaining: number;
                        spent: number;
                    }, {
                        subject: string;
                        loadoutValue: number;
                        weapon: string;
                        armor: string;
                        remaining: number;
                        spent: number;
                    }>, "many">;
                    playerScores: z.ZodArray<z.ZodObject<{
                        subject: z.ZodString;
                        score: z.ZodNumber;
                    }, "strip", z.ZodTypeAny, {
                        subject: string;
                        score: number;
                    }, {
                        subject: string;
                        score: number;
                    }>, "many">;
                }, "strip", z.ZodTypeAny, {
                    roundNum: number;
                    roundResult: "Surrendered" | "Eliminated" | "Bomb detonated" | "Bomb defused" | "Round timer expired";
                    roundCeremony: "" | "CeremonyDefault" | "CeremonyTeamAce" | "CeremonyFlawless" | "CeremonyCloser" | "CeremonyClutch" | "CeremonyThrifty" | "CeremonyAce";
                    winningTeam: "Blue" | "Red";
                    bombDefuser: "Blue" | "Red";
                    plantLocation: {
                        x: number;
                        y: number;
                    };
                    plantSite: "" | "A" | "B" | "C";
                    defuseLocation: {
                        x: number;
                        y: number;
                    };
                    playerStats: {
                        subject: string;
                        score: number;
                        kills: {
                            gameTime: Date;
                            roundTime: Date;
                            killer: string;
                            victim: string;
                            victimLocation: {
                                x: number;
                                y: number;
                            };
                            assistants: string[];
                            playerLocations: {
                                subject: string;
                                location: {
                                    x: number;
                                    y: number;
                                };
                                viewRadians: number;
                            }[];
                            finishingDamage: {
                                damageType: "" | "Weapon" | "Bomb" | "Ability" | "Fall" | "Melee" | "Invalid";
                                damageItem: string;
                                isSecondaryFireMode: boolean;
                            };
                        }[];
                        damage: {
                            receiver: string;
                            damage: number;
                            legshots: number;
                            bodyshots: number;
                            headshots: number;
                        }[];
                        ability: {
                            grenadeEffects: null;
                            ability1Effects: null;
                            ability2Effects: null;
                            ultimateEffects: null;
                        };
                        economy: {
                            loadoutValue: number;
                            weapon: string;
                            armor: string;
                            remaining: number;
                            spent: number;
                        };
                        wasAfk: boolean;
                        wasPenalized: boolean;
                        stayedInSpawn: boolean;
                    }[];
                    roundResultCode: "" | "Surrendered" | "Elimination" | "Detonate" | "Defuse";
                    playerEconomies: {
                        subject: string;
                        loadoutValue: number;
                        weapon: string;
                        armor: string;
                        remaining: number;
                        spent: number;
                    }[];
                    playerScores: {
                        subject: string;
                        score: number;
                    }[];
                    bombPlanter?: string | undefined;
                    plantRoundTime?: number | undefined;
                    plantPlayerLocations?: {
                        subject: string;
                        location: {
                            x: number;
                            y: number;
                        };
                        viewRadians: number;
                    }[] | undefined;
                    defuseRoundTime?: number | undefined;
                    defusePlayerLocations?: {
                        subject: string;
                        location: {
                            x: number;
                            y: number;
                        };
                        viewRadians: number;
                    }[] | undefined;
                }, {
                    roundNum: number;
                    roundResult: "Surrendered" | "Eliminated" | "Bomb detonated" | "Bomb defused" | "Round timer expired";
                    roundCeremony: "" | "CeremonyDefault" | "CeremonyTeamAce" | "CeremonyFlawless" | "CeremonyCloser" | "CeremonyClutch" | "CeremonyThrifty" | "CeremonyAce";
                    winningTeam: "Blue" | "Red";
                    bombDefuser: "Blue" | "Red";
                    plantLocation: {
                        x: number;
                        y: number;
                    };
                    plantSite: "" | "A" | "B" | "C";
                    defuseLocation: {
                        x: number;
                        y: number;
                    };
                    playerStats: {
                        subject: string;
                        score: number;
                        kills: {
                            gameTime: number;
                            roundTime: number;
                            killer: string;
                            victim: string;
                            victimLocation: {
                                x: number;
                                y: number;
                            };
                            assistants: string[];
                            playerLocations: {
                                subject: string;
                                location: {
                                    x: number;
                                    y: number;
                                };
                                viewRadians: number;
                            }[];
                            finishingDamage: {
                                damageType: "" | "Weapon" | "Bomb" | "Ability" | "Fall" | "Melee" | "Invalid";
                                damageItem: string;
                                isSecondaryFireMode: boolean;
                            };
                        }[];
                        damage: {
                            receiver: string;
                            damage: number;
                            legshots: number;
                            bodyshots: number;
                            headshots: number;
                        }[];
                        ability: {
                            grenadeEffects: null;
                            ability1Effects: null;
                            ability2Effects: null;
                            ultimateEffects: null;
                        };
                        economy: {
                            loadoutValue: number;
                            weapon: string;
                            armor: string;
                            remaining: number;
                            spent: number;
                        };
                        wasAfk: boolean;
                        wasPenalized: boolean;
                        stayedInSpawn: boolean;
                    }[];
                    roundResultCode: "" | "Surrendered" | "Elimination" | "Detonate" | "Defuse";
                    playerEconomies: {
                        subject: string;
                        loadoutValue: number;
                        weapon: string;
                        armor: string;
                        remaining: number;
                        spent: number;
                    }[];
                    playerScores: {
                        subject: string;
                        score: number;
                    }[];
                    bombPlanter?: string | undefined;
                    plantRoundTime?: number | undefined;
                    plantPlayerLocations?: {
                        subject: string;
                        location: {
                            x: number;
                            y: number;
                        };
                        viewRadians: number;
                    }[] | undefined;
                    defuseRoundTime?: number | undefined;
                    defusePlayerLocations?: {
                        subject: string;
                        location: {
                            x: number;
                            y: number;
                        };
                        viewRadians: number;
                    }[] | undefined;
                }>, "many">;
                kills: z.ZodArray<z.ZodObject<{
                    gameTime: z.ZodEffects<z.ZodNumber, Date, number>;
                    roundTime: z.ZodEffects<z.ZodNumber, Date, number>;
                    killer: z.ZodString;
                    victim: z.ZodString;
                    victimLocation: z.ZodObject<{
                        x: z.ZodNumber;
                        y: z.ZodNumber;
                    }, "strip", z.ZodTypeAny, {
                        x: number;
                        y: number;
                    }, {
                        x: number;
                        y: number;
                    }>;
                    assistants: z.ZodArray<z.ZodString, "many">;
                    playerLocations: z.ZodArray<z.ZodObject<{
                        subject: z.ZodString;
                        viewRadians: z.ZodNumber;
                        location: z.ZodObject<{
                            x: z.ZodNumber;
                            y: z.ZodNumber;
                        }, "strip", z.ZodTypeAny, {
                            x: number;
                            y: number;
                        }, {
                            x: number;
                            y: number;
                        }>;
                    }, "strip", z.ZodTypeAny, {
                        subject: string;
                        location: {
                            x: number;
                            y: number;
                        };
                        viewRadians: number;
                    }, {
                        subject: string;
                        location: {
                            x: number;
                            y: number;
                        };
                        viewRadians: number;
                    }>, "many">;
                    finishingDamage: z.ZodObject<{
                        damageType: z.ZodEnum<["Weapon", "Bomb", "Ability", "Fall", "Melee", "Invalid", ""]>;
                        damageItem: z.ZodUnion<[z.ZodLiteral<"">, z.ZodLiteral<"Ultimate">, z.ZodLiteral<"Ability1">, z.ZodLiteral<"Ability2">, z.ZodLiteral<"GrenadeAbility">, z.ZodLiteral<"Primary">, z.ZodString]>;
                        isSecondaryFireMode: z.ZodBoolean;
                    }, "strip", z.ZodTypeAny, {
                        damageType: "" | "Weapon" | "Bomb" | "Ability" | "Fall" | "Melee" | "Invalid";
                        damageItem: string;
                        isSecondaryFireMode: boolean;
                    }, {
                        damageType: "" | "Weapon" | "Bomb" | "Ability" | "Fall" | "Melee" | "Invalid";
                        damageItem: string;
                        isSecondaryFireMode: boolean;
                    }>;
                    round: z.ZodNumber;
                }, "strip", z.ZodTypeAny, {
                    round: number;
                    gameTime: Date;
                    roundTime: Date;
                    killer: string;
                    victim: string;
                    victimLocation: {
                        x: number;
                        y: number;
                    };
                    assistants: string[];
                    playerLocations: {
                        subject: string;
                        location: {
                            x: number;
                            y: number;
                        };
                        viewRadians: number;
                    }[];
                    finishingDamage: {
                        damageType: "" | "Weapon" | "Bomb" | "Ability" | "Fall" | "Melee" | "Invalid";
                        damageItem: string;
                        isSecondaryFireMode: boolean;
                    };
                }, {
                    round: number;
                    gameTime: number;
                    roundTime: number;
                    killer: string;
                    victim: string;
                    victimLocation: {
                        x: number;
                        y: number;
                    };
                    assistants: string[];
                    playerLocations: {
                        subject: string;
                        location: {
                            x: number;
                            y: number;
                        };
                        viewRadians: number;
                    }[];
                    finishingDamage: {
                        damageType: "" | "Weapon" | "Bomb" | "Ability" | "Fall" | "Melee" | "Invalid";
                        damageItem: string;
                        isSecondaryFireMode: boolean;
                    };
                }>, "many">;
            }, "strip", z.ZodTypeAny, {
                kills: {
                    round: number;
                    gameTime: Date;
                    roundTime: Date;
                    killer: string;
                    victim: string;
                    victimLocation: {
                        x: number;
                        y: number;
                    };
                    assistants: string[];
                    playerLocations: {
                        subject: string;
                        location: {
                            x: number;
                            y: number;
                        };
                        viewRadians: number;
                    }[];
                    finishingDamage: {
                        damageType: "" | "Weapon" | "Bomb" | "Ability" | "Fall" | "Melee" | "Invalid";
                        damageItem: string;
                        isSecondaryFireMode: boolean;
                    };
                }[];
                matchInfo: {
                    platformType: string;
                    gameMode: string;
                    mapId: string;
                    customGameName: string;
                    matchId: string;
                    gamePodId: string;
                    gameLoopZone: string;
                    gameServerAddress: string;
                    gameVersion: string;
                    gameLengthMillis: Date;
                    gameStartMillis: Date;
                    provisioningFlowID: "Matchmaking" | "CustomGame";
                    isCompleted: boolean;
                    forcePostProcessing: boolean;
                    queueID: string;
                    isRanked: boolean;
                    isMatchSampled: boolean;
                    seasonId: string;
                    completionState: "" | "Surrendered" | "Completed" | "VoteDraw";
                    premierMatchInfo: {};
                    shouldMatchDisablePenalties: boolean;
                    partyRRPenalties?: Record<string, number> | undefined;
                };
                players: {
                    platformInfo: {
                        platformType: string;
                        platformOS: string;
                        platformOSVersion: string;
                        platformChipset: string;
                    };
                    subject: string;
                    partyId: string;
                    accountLevel: number;
                    competitiveTier: number;
                    gameName: string;
                    tagLine: string;
                    teamId: "Blue" | "Red";
                    characterId: string;
                    stats: {
                        score: number;
                        roundsPlayed: number;
                        kills: number;
                        deaths: number;
                        assists: number;
                        playtimeMillis: Date;
                        abilityCasts?: {
                            grenadeCasts: number;
                            ability1Casts: number;
                            ability2Casts: number;
                            ultimateCasts: number;
                        } | null | undefined;
                    };
                    roundDamage: {
                        round: number;
                        receiver: string;
                        damage: number;
                    }[];
                    isObserver: boolean;
                    playerCard: string;
                    playerTitle: string;
                    preferredLevelBorder?: string | undefined;
                    sessionPlaytimeMinutes?: number | undefined;
                    xpModifications?: {
                        ID: string;
                        Value: number;
                    }[] | undefined;
                    behaviorFactors?: {
                        afkRounds: number;
                        commsRatingRecovery: number;
                        damageParticipationOutgoing: number;
                        collisions?: number | undefined;
                        friendlyFireIncoming?: number | undefined;
                        friendlyFireOutgoing?: number | undefined;
                        mouseMovement?: number | undefined;
                        stayedInSpawnRounds?: number | undefined;
                    } | undefined;
                    newPlayerExperienceDetails?: {
                        basicMovement: {
                            idleTimeMillis: number;
                            objectiveCompleteTimeMillis: number;
                        };
                        basicGunSkill: {
                            idleTimeMillis: number;
                            objectiveCompleteTimeMillis: number;
                        };
                        adaptiveBots: {
                            idleTimeMillis: number;
                            objectiveCompleteTimeMillis: number;
                            adaptiveBotAverageDurationMillisAllAttempts: number;
                            adaptiveBotAverageDurationMillisFirstAttempt: number;
                            killDetailsFirstAttempt: null;
                        };
                        ability: {
                            idleTimeMillis: number;
                            objectiveCompleteTimeMillis: number;
                        };
                        bombPlant: {
                            idleTimeMillis: number;
                            objectiveCompleteTimeMillis: number;
                        };
                        defendBombSite: {
                            success: boolean;
                            idleTimeMillis: number;
                            objectiveCompleteTimeMillis: number;
                        };
                        settingStatus: {
                            isMouseSensitivityDefault: boolean;
                            isCrosshairDefault: boolean;
                        };
                        versionString: string;
                    } | undefined;
                }[];
                bots: unknown[];
                coaches: {
                    subject: string;
                    teamId: "Blue" | "Red";
                }[];
                roundResults: {
                    roundNum: number;
                    roundResult: "Surrendered" | "Eliminated" | "Bomb detonated" | "Bomb defused" | "Round timer expired";
                    roundCeremony: "" | "CeremonyDefault" | "CeremonyTeamAce" | "CeremonyFlawless" | "CeremonyCloser" | "CeremonyClutch" | "CeremonyThrifty" | "CeremonyAce";
                    winningTeam: "Blue" | "Red";
                    bombDefuser: "Blue" | "Red";
                    plantLocation: {
                        x: number;
                        y: number;
                    };
                    plantSite: "" | "A" | "B" | "C";
                    defuseLocation: {
                        x: number;
                        y: number;
                    };
                    playerStats: {
                        subject: string;
                        score: number;
                        kills: {
                            gameTime: Date;
                            roundTime: Date;
                            killer: string;
                            victim: string;
                            victimLocation: {
                                x: number;
                                y: number;
                            };
                            assistants: string[];
                            playerLocations: {
                                subject: string;
                                location: {
                                    x: number;
                                    y: number;
                                };
                                viewRadians: number;
                            }[];
                            finishingDamage: {
                                damageType: "" | "Weapon" | "Bomb" | "Ability" | "Fall" | "Melee" | "Invalid";
                                damageItem: string;
                                isSecondaryFireMode: boolean;
                            };
                        }[];
                        damage: {
                            receiver: string;
                            damage: number;
                            legshots: number;
                            bodyshots: number;
                            headshots: number;
                        }[];
                        ability: {
                            grenadeEffects: null;
                            ability1Effects: null;
                            ability2Effects: null;
                            ultimateEffects: null;
                        };
                        economy: {
                            loadoutValue: number;
                            weapon: string;
                            armor: string;
                            remaining: number;
                            spent: number;
                        };
                        wasAfk: boolean;
                        wasPenalized: boolean;
                        stayedInSpawn: boolean;
                    }[];
                    roundResultCode: "" | "Surrendered" | "Elimination" | "Detonate" | "Defuse";
                    playerEconomies: {
                        subject: string;
                        loadoutValue: number;
                        weapon: string;
                        armor: string;
                        remaining: number;
                        spent: number;
                    }[];
                    playerScores: {
                        subject: string;
                        score: number;
                    }[];
                    bombPlanter?: string | undefined;
                    plantRoundTime?: number | undefined;
                    plantPlayerLocations?: {
                        subject: string;
                        location: {
                            x: number;
                            y: number;
                        };
                        viewRadians: number;
                    }[] | undefined;
                    defuseRoundTime?: number | undefined;
                    defusePlayerLocations?: {
                        subject: string;
                        location: {
                            x: number;
                            y: number;
                        };
                        viewRadians: number;
                    }[] | undefined;
                }[];
                teams?: {
                    teamId: "Blue" | "Red";
                    roundsPlayed: number;
                    won: boolean;
                    roundsWon: number;
                    numPoints: number;
                }[] | undefined;
            }, {
                kills: {
                    round: number;
                    gameTime: number;
                    roundTime: number;
                    killer: string;
                    victim: string;
                    victimLocation: {
                        x: number;
                        y: number;
                    };
                    assistants: string[];
                    playerLocations: {
                        subject: string;
                        location: {
                            x: number;
                            y: number;
                        };
                        viewRadians: number;
                    }[];
                    finishingDamage: {
                        damageType: "" | "Weapon" | "Bomb" | "Ability" | "Fall" | "Melee" | "Invalid";
                        damageItem: string;
                        isSecondaryFireMode: boolean;
                    };
                }[];
                matchInfo: {
                    platformType: string;
                    gameMode: string;
                    mapId: string;
                    customGameName: string;
                    matchId: string;
                    gamePodId: string;
                    gameLoopZone: string;
                    gameServerAddress: string;
                    gameVersion: string;
                    gameLengthMillis: number;
                    gameStartMillis: number;
                    provisioningFlowID: "Matchmaking" | "CustomGame";
                    isCompleted: boolean;
                    forcePostProcessing: boolean;
                    queueID: string;
                    isRanked: boolean;
                    isMatchSampled: boolean;
                    seasonId: string;
                    completionState: "" | "Surrendered" | "Completed" | "VoteDraw";
                    premierMatchInfo: {};
                    shouldMatchDisablePenalties: boolean;
                    partyRRPenalties?: Record<string, number> | undefined;
                };
                players: {
                    platformInfo: {
                        platformType: string;
                        platformOS: string;
                        platformOSVersion: string;
                        platformChipset: string;
                    };
                    subject: string;
                    partyId: string;
                    accountLevel: number;
                    competitiveTier: number;
                    gameName: string;
                    tagLine: string;
                    teamId: "Blue" | "Red";
                    characterId: string;
                    stats: {
                        score: number;
                        roundsPlayed: number;
                        kills: number;
                        deaths: number;
                        assists: number;
                        playtimeMillis: number;
                        abilityCasts?: {
                            grenadeCasts: number;
                            ability1Casts: number;
                            ability2Casts: number;
                            ultimateCasts: number;
                        } | null | undefined;
                    };
                    roundDamage: {
                        round: number;
                        receiver: string;
                        damage: number;
                    }[];
                    isObserver: boolean;
                    playerCard: string;
                    playerTitle: string;
                    preferredLevelBorder?: string | undefined;
                    sessionPlaytimeMinutes?: number | undefined;
                    xpModifications?: {
                        ID: string;
                        Value: number;
                    }[] | undefined;
                    behaviorFactors?: {
                        afkRounds: number;
                        commsRatingRecovery: number;
                        damageParticipationOutgoing: number;
                        collisions?: number | undefined;
                        friendlyFireIncoming?: number | undefined;
                        friendlyFireOutgoing?: number | undefined;
                        mouseMovement?: number | undefined;
                        stayedInSpawnRounds?: number | undefined;
                    } | undefined;
                    newPlayerExperienceDetails?: {
                        basicMovement: {
                            idleTimeMillis: number;
                            objectiveCompleteTimeMillis: number;
                        };
                        basicGunSkill: {
                            idleTimeMillis: number;
                            objectiveCompleteTimeMillis: number;
                        };
                        adaptiveBots: {
                            idleTimeMillis: number;
                            objectiveCompleteTimeMillis: number;
                            adaptiveBotAverageDurationMillisAllAttempts: number;
                            adaptiveBotAverageDurationMillisFirstAttempt: number;
                            killDetailsFirstAttempt: null;
                        };
                        ability: {
                            idleTimeMillis: number;
                            objectiveCompleteTimeMillis: number;
                        };
                        bombPlant: {
                            idleTimeMillis: number;
                            objectiveCompleteTimeMillis: number;
                        };
                        defendBombSite: {
                            success: boolean;
                            idleTimeMillis: number;
                            objectiveCompleteTimeMillis: number;
                        };
                        settingStatus: {
                            isMouseSensitivityDefault: boolean;
                            isCrosshairDefault: boolean;
                        };
                        versionString: string;
                    } | undefined;
                }[];
                bots: unknown[];
                coaches: {
                    subject: string;
                    teamId: "Blue" | "Red";
                }[];
                roundResults: {
                    roundNum: number;
                    roundResult: "Surrendered" | "Eliminated" | "Bomb detonated" | "Bomb defused" | "Round timer expired";
                    roundCeremony: "" | "CeremonyDefault" | "CeremonyTeamAce" | "CeremonyFlawless" | "CeremonyCloser" | "CeremonyClutch" | "CeremonyThrifty" | "CeremonyAce";
                    winningTeam: "Blue" | "Red";
                    bombDefuser: "Blue" | "Red";
                    plantLocation: {
                        x: number;
                        y: number;
                    };
                    plantSite: "" | "A" | "B" | "C";
                    defuseLocation: {
                        x: number;
                        y: number;
                    };
                    playerStats: {
                        subject: string;
                        score: number;
                        kills: {
                            gameTime: number;
                            roundTime: number;
                            killer: string;
                            victim: string;
                            victimLocation: {
                                x: number;
                                y: number;
                            };
                            assistants: string[];
                            playerLocations: {
                                subject: string;
                                location: {
                                    x: number;
                                    y: number;
                                };
                                viewRadians: number;
                            }[];
                            finishingDamage: {
                                damageType: "" | "Weapon" | "Bomb" | "Ability" | "Fall" | "Melee" | "Invalid";
                                damageItem: string;
                                isSecondaryFireMode: boolean;
                            };
                        }[];
                        damage: {
                            receiver: string;
                            damage: number;
                            legshots: number;
                            bodyshots: number;
                            headshots: number;
                        }[];
                        ability: {
                            grenadeEffects: null;
                            ability1Effects: null;
                            ability2Effects: null;
                            ultimateEffects: null;
                        };
                        economy: {
                            loadoutValue: number;
                            weapon: string;
                            armor: string;
                            remaining: number;
                            spent: number;
                        };
                        wasAfk: boolean;
                        wasPenalized: boolean;
                        stayedInSpawn: boolean;
                    }[];
                    roundResultCode: "" | "Surrendered" | "Elimination" | "Detonate" | "Defuse";
                    playerEconomies: {
                        subject: string;
                        loadoutValue: number;
                        weapon: string;
                        armor: string;
                        remaining: number;
                        spent: number;
                    }[];
                    playerScores: {
                        subject: string;
                        score: number;
                    }[];
                    bombPlanter?: string | undefined;
                    plantRoundTime?: number | undefined;
                    plantPlayerLocations?: {
                        subject: string;
                        location: {
                            x: number;
                            y: number;
                        };
                        viewRadians: number;
                    }[] | undefined;
                    defuseRoundTime?: number | undefined;
                    defusePlayerLocations?: {
                        subject: string;
                        location: {
                            x: number;
                            y: number;
                        };
                        viewRadians: number;
                    }[] | undefined;
                }[];
                teams?: {
                    teamId: "Blue" | "Red";
                    roundsPlayed: number;
                    won: boolean;
                    roundsWon: number;
                    numPoints: number;
                }[] | undefined;
            }>;
        };
    };
};

type Params$B = ResolveParams<(typeof _default$B)["~type"]["url"]>;
type Body$B = z.infer<ResolveValue<(typeof _default$B)["~type"], "body">>;
type Data$B = ResolveData<Params$B, Body$B>;
type Response$B = z.infer<ResolveValue<(typeof _default$B)["~type"], "responses">["200"]>;
interface MatchDetailsRequestConfig extends ValorantAxiosRequestConfig<Data$B> {
}
declare class MatchDetailsEndpoint {
    /**
     * Get the details of a match after it ends
     *
     * @EndpointType pd
     */
    getMatchDetails<T = Response$B>(this: RemoteApiClient, config: MatchDetailsRequestConfig): Promise<AxiosResponse<T>>;
}

declare const matchHistoryResponseSchema: z.ZodObject<{
    Subject: z.ZodString;
    BeginIndex: z.ZodNumber;
    EndIndex: z.ZodNumber;
    Total: z.ZodNumber;
    History: z.ZodArray<z.ZodObject<{
        MatchID: z.ZodString;
        GameStartTime: z.ZodEffects<z.ZodNumber, Date, number>;
        QueueID: z.ZodString;
    }, "strip", z.ZodTypeAny, {
        MatchID: string;
        QueueID: string;
        GameStartTime: Date;
    }, {
        MatchID: string;
        QueueID: string;
        GameStartTime: number;
    }>, "many">;
}, "strip", z.ZodTypeAny, {
    Subject: string;
    BeginIndex: number;
    EndIndex: number;
    Total: number;
    History: {
        MatchID: string;
        QueueID: string;
        GameStartTime: Date;
    }[];
}, {
    Subject: string;
    BeginIndex: number;
    EndIndex: number;
    Total: number;
    History: {
        MatchID: string;
        QueueID: string;
        GameStartTime: number;
    }[];
}>;
declare const _default$A: Omit<{
    requirements: string[];
    type: "auth" | "local" | "pd" | "glz" | "shared";
    name: string;
    method: "PUT" | "GET" | "DELETE" | "POST";
    url: string;
    description?: string | undefined;
    headers?: Record<string, string> | undefined;
    body?: z.ZodType<any, z.ZodTypeDef, any> | undefined;
    query?: z.ZodType<any, z.ZodTypeDef, any> | undefined;
    responses?: Record<string, z.ZodType<any, z.ZodTypeDef, any>> | undefined;
}, "type" | "name" | "url"> & Pick<{
    readonly name: "Match History";
    readonly description: "Get the match history for the given player";
    readonly type: "pd";
    readonly url: "match-history/v1/history/:puuid";
    readonly query: z.ZodObject<{
        startIndex: z.ZodOptional<z.ZodNumber>;
        endIndex: z.ZodOptional<z.ZodNumber>;
        queue: z.ZodOptional<z.ZodString>;
    }, "strip", z.ZodTypeAny, {
        startIndex?: number | undefined;
        endIndex?: number | undefined;
        queue?: string | undefined;
    }, {
        startIndex?: number | undefined;
        endIndex?: number | undefined;
        queue?: string | undefined;
    }>;
    readonly responses: {
        readonly "200": z.ZodObject<{
            Subject: z.ZodString;
            BeginIndex: z.ZodNumber;
            EndIndex: z.ZodNumber;
            Total: z.ZodNumber;
            History: z.ZodArray<z.ZodObject<{
                MatchID: z.ZodString;
                GameStartTime: z.ZodEffects<z.ZodNumber, Date, number>;
                QueueID: z.ZodString;
            }, "strip", z.ZodTypeAny, {
                MatchID: string;
                QueueID: string;
                GameStartTime: Date;
            }, {
                MatchID: string;
                QueueID: string;
                GameStartTime: number;
            }>, "many">;
        }, "strip", z.ZodTypeAny, {
            Subject: string;
            BeginIndex: number;
            EndIndex: number;
            Total: number;
            History: {
                MatchID: string;
                QueueID: string;
                GameStartTime: Date;
            }[];
        }, {
            Subject: string;
            BeginIndex: number;
            EndIndex: number;
            Total: number;
            History: {
                MatchID: string;
                QueueID: string;
                GameStartTime: number;
            }[];
        }>;
    };
}, "type" | "name" | "url"> & {
    "~type": {
        readonly name: "Match History";
        readonly description: "Get the match history for the given player";
        readonly type: "pd";
        readonly url: "match-history/v1/history/:puuid";
        readonly query: z.ZodObject<{
            startIndex: z.ZodOptional<z.ZodNumber>;
            endIndex: z.ZodOptional<z.ZodNumber>;
            queue: z.ZodOptional<z.ZodString>;
        }, "strip", z.ZodTypeAny, {
            startIndex?: number | undefined;
            endIndex?: number | undefined;
            queue?: string | undefined;
        }, {
            startIndex?: number | undefined;
            endIndex?: number | undefined;
            queue?: string | undefined;
        }>;
        readonly responses: {
            readonly "200": z.ZodObject<{
                Subject: z.ZodString;
                BeginIndex: z.ZodNumber;
                EndIndex: z.ZodNumber;
                Total: z.ZodNumber;
                History: z.ZodArray<z.ZodObject<{
                    MatchID: z.ZodString;
                    GameStartTime: z.ZodEffects<z.ZodNumber, Date, number>;
                    QueueID: z.ZodString;
                }, "strip", z.ZodTypeAny, {
                    MatchID: string;
                    QueueID: string;
                    GameStartTime: Date;
                }, {
                    MatchID: string;
                    QueueID: string;
                    GameStartTime: number;
                }>, "many">;
            }, "strip", z.ZodTypeAny, {
                Subject: string;
                BeginIndex: number;
                EndIndex: number;
                Total: number;
                History: {
                    MatchID: string;
                    QueueID: string;
                    GameStartTime: Date;
                }[];
            }, {
                Subject: string;
                BeginIndex: number;
                EndIndex: number;
                Total: number;
                History: {
                    MatchID: string;
                    QueueID: string;
                    GameStartTime: number;
                }[];
            }>;
        };
    };
};

type Params$A = ResolveParams<(typeof _default$A)["~type"]["url"]>;
type Body$A = z.infer<ResolveValue<(typeof _default$A)["~type"], "body">>;
type Data$A = ResolveData<Params$A, Body$A>;
type Response$A = z.infer<ResolveValue<(typeof _default$A)["~type"], "responses">["200"]>;
interface MatchHistoryRequestConfig extends ValorantAxiosRequestConfig<Data$A> {
}
declare class MatchHistoryEndpoint {
    /**
     * Get the match history for the given player
     *
     * @EndpointType pd
     */
    getMatchHistory<T = Response$A>(this: RemoteApiClient, config?: MatchHistoryRequestConfig): Promise<AxiosResponse<T>>;
}

declare const ownedItemsResponseSchema: z.ZodObject<{
    EntitlementsByTypes: z.ZodArray<z.ZodObject<{
        ItemTypeID: z.ZodString;
        Entitlements: z.ZodArray<z.ZodObject<{
            TypeID: z.ZodString;
            ItemID: z.ZodString;
            InstanceID: z.ZodOptional<z.ZodString>;
        }, "strip", z.ZodTypeAny, {
            TypeID: string;
            ItemID: string;
            InstanceID?: string | undefined;
        }, {
            TypeID: string;
            ItemID: string;
            InstanceID?: string | undefined;
        }>, "many">;
    }, "strip", z.ZodTypeAny, {
        ItemTypeID: string;
        Entitlements: {
            TypeID: string;
            ItemID: string;
            InstanceID?: string | undefined;
        }[];
    }, {
        ItemTypeID: string;
        Entitlements: {
            TypeID: string;
            ItemID: string;
            InstanceID?: string | undefined;
        }[];
    }>, "many">;
}, "strip", z.ZodTypeAny, {
    EntitlementsByTypes: {
        ItemTypeID: string;
        Entitlements: {
            TypeID: string;
            ItemID: string;
            InstanceID?: string | undefined;
        }[];
    }[];
}, {
    EntitlementsByTypes: {
        ItemTypeID: string;
        Entitlements: {
            TypeID: string;
            ItemID: string;
            InstanceID?: string | undefined;
        }[];
    }[];
}>;
declare const _default$z: Omit<{
    requirements: string[];
    type: "auth" | "local" | "pd" | "glz" | "shared";
    name: string;
    method: "PUT" | "GET" | "DELETE" | "POST";
    url: string;
    description?: string | undefined;
    headers?: Record<string, string> | undefined;
    body?: z.ZodType<any, z.ZodTypeDef, any> | undefined;
    query?: z.ZodType<any, z.ZodTypeDef, any> | undefined;
    responses?: Record<string, z.ZodType<any, z.ZodTypeDef, any>> | undefined;
}, "type" | "name" | "url"> & Pick<{
    readonly name: "Owned Items";
    readonly description: "List what the player owns (agents, skins, buddies, ect.)";
    readonly type: "pd";
    readonly url: "store/v1/entitlements/:puuid/:itemTypeId";
    readonly responses: {
        readonly "200": z.ZodObject<{
            EntitlementsByTypes: z.ZodArray<z.ZodObject<{
                ItemTypeID: z.ZodString;
                Entitlements: z.ZodArray<z.ZodObject<{
                    TypeID: z.ZodString;
                    ItemID: z.ZodString;
                    InstanceID: z.ZodOptional<z.ZodString>;
                }, "strip", z.ZodTypeAny, {
                    TypeID: string;
                    ItemID: string;
                    InstanceID?: string | undefined;
                }, {
                    TypeID: string;
                    ItemID: string;
                    InstanceID?: string | undefined;
                }>, "many">;
            }, "strip", z.ZodTypeAny, {
                ItemTypeID: string;
                Entitlements: {
                    TypeID: string;
                    ItemID: string;
                    InstanceID?: string | undefined;
                }[];
            }, {
                ItemTypeID: string;
                Entitlements: {
                    TypeID: string;
                    ItemID: string;
                    InstanceID?: string | undefined;
                }[];
            }>, "many">;
        }, "strip", z.ZodTypeAny, {
            EntitlementsByTypes: {
                ItemTypeID: string;
                Entitlements: {
                    TypeID: string;
                    ItemID: string;
                    InstanceID?: string | undefined;
                }[];
            }[];
        }, {
            EntitlementsByTypes: {
                ItemTypeID: string;
                Entitlements: {
                    TypeID: string;
                    ItemID: string;
                    InstanceID?: string | undefined;
                }[];
            }[];
        }>;
    };
}, "type" | "name" | "url"> & {
    "~type": {
        readonly name: "Owned Items";
        readonly description: "List what the player owns (agents, skins, buddies, ect.)";
        readonly type: "pd";
        readonly url: "store/v1/entitlements/:puuid/:itemTypeId";
        readonly responses: {
            readonly "200": z.ZodObject<{
                EntitlementsByTypes: z.ZodArray<z.ZodObject<{
                    ItemTypeID: z.ZodString;
                    Entitlements: z.ZodArray<z.ZodObject<{
                        TypeID: z.ZodString;
                        ItemID: z.ZodString;
                        InstanceID: z.ZodOptional<z.ZodString>;
                    }, "strip", z.ZodTypeAny, {
                        TypeID: string;
                        ItemID: string;
                        InstanceID?: string | undefined;
                    }, {
                        TypeID: string;
                        ItemID: string;
                        InstanceID?: string | undefined;
                    }>, "many">;
                }, "strip", z.ZodTypeAny, {
                    ItemTypeID: string;
                    Entitlements: {
                        TypeID: string;
                        ItemID: string;
                        InstanceID?: string | undefined;
                    }[];
                }, {
                    ItemTypeID: string;
                    Entitlements: {
                        TypeID: string;
                        ItemID: string;
                        InstanceID?: string | undefined;
                    }[];
                }>, "many">;
            }, "strip", z.ZodTypeAny, {
                EntitlementsByTypes: {
                    ItemTypeID: string;
                    Entitlements: {
                        TypeID: string;
                        ItemID: string;
                        InstanceID?: string | undefined;
                    }[];
                }[];
            }, {
                EntitlementsByTypes: {
                    ItemTypeID: string;
                    Entitlements: {
                        TypeID: string;
                        ItemID: string;
                        InstanceID?: string | undefined;
                    }[];
                }[];
            }>;
        };
    };
};

type Params$z = ResolveParams<(typeof _default$z)["~type"]["url"]>;
type Body$z = z.infer<ResolveValue<(typeof _default$z)["~type"], "body">>;
type Data$z = ResolveData<Params$z, Body$z>;
type Response$z = z.infer<ResolveValue<(typeof _default$z)["~type"], "responses">["200"]>;
interface OwnedItemsRequestConfig extends ValorantAxiosRequestConfig<Data$z> {
}
declare class OwnedItemsEndpoint {
    /**
     * List what the player owns (agents, skins, buddies, ect.)
     *
     * @EndpointType pd
     */
    getOwnedItems<T = Response$z>(this: RemoteApiClient, config: OwnedItemsRequestConfig): Promise<AxiosResponse<T>>;
}

declare const pricesResponseSchema: z.ZodObject<{
    Offers: z.ZodArray<z.ZodObject<{
        OfferID: z.ZodString;
        IsDirectPurchase: z.ZodBoolean;
        StartDate: z.ZodEffects<z.ZodString, Date, string>;
        Cost: z.ZodRecord<z.ZodString, z.ZodNumber>;
        Rewards: z.ZodArray<z.ZodObject<{
            ItemTypeID: z.ZodString;
            ItemID: z.ZodString;
            Quantity: z.ZodNumber;
        }, "strip", z.ZodTypeAny, {
            ItemTypeID: string;
            ItemID: string;
            Quantity: number;
        }, {
            ItemTypeID: string;
            ItemID: string;
            Quantity: number;
        }>, "many">;
    }, "strip", z.ZodTypeAny, {
        OfferID: string;
        IsDirectPurchase: boolean;
        StartDate: Date;
        Cost: Record<string, number>;
        Rewards: {
            ItemTypeID: string;
            ItemID: string;
            Quantity: number;
        }[];
    }, {
        OfferID: string;
        IsDirectPurchase: boolean;
        StartDate: string;
        Cost: Record<string, number>;
        Rewards: {
            ItemTypeID: string;
            ItemID: string;
            Quantity: number;
        }[];
    }>, "many">;
}, "strip", z.ZodTypeAny, {
    Offers: {
        OfferID: string;
        IsDirectPurchase: boolean;
        StartDate: Date;
        Cost: Record<string, number>;
        Rewards: {
            ItemTypeID: string;
            ItemID: string;
            Quantity: number;
        }[];
    }[];
}, {
    Offers: {
        OfferID: string;
        IsDirectPurchase: boolean;
        StartDate: string;
        Cost: Record<string, number>;
        Rewards: {
            ItemTypeID: string;
            ItemID: string;
            Quantity: number;
        }[];
    }[];
}>;
declare const _default$y: Omit<{
    requirements: string[];
    type: "auth" | "local" | "pd" | "glz" | "shared";
    name: string;
    method: "PUT" | "GET" | "DELETE" | "POST";
    url: string;
    description?: string | undefined;
    headers?: Record<string, string> | undefined;
    body?: z.ZodType<any, z.ZodTypeDef, any> | undefined;
    query?: z.ZodType<any, z.ZodTypeDef, any> | undefined;
    responses?: Record<string, z.ZodType<any, z.ZodTypeDef, any>> | undefined;
}, "type" | "name" | "url"> & Pick<{
    readonly name: "Prices";
    readonly description: "Get the current store prices for all items";
    readonly type: "pd";
    readonly url: "store/v1/offers/";
    readonly responses: {
        readonly "200": z.ZodObject<{
            Offers: z.ZodArray<z.ZodObject<{
                OfferID: z.ZodString;
                IsDirectPurchase: z.ZodBoolean;
                StartDate: z.ZodEffects<z.ZodString, Date, string>;
                Cost: z.ZodRecord<z.ZodString, z.ZodNumber>;
                Rewards: z.ZodArray<z.ZodObject<{
                    ItemTypeID: z.ZodString;
                    ItemID: z.ZodString;
                    Quantity: z.ZodNumber;
                }, "strip", z.ZodTypeAny, {
                    ItemTypeID: string;
                    ItemID: string;
                    Quantity: number;
                }, {
                    ItemTypeID: string;
                    ItemID: string;
                    Quantity: number;
                }>, "many">;
            }, "strip", z.ZodTypeAny, {
                OfferID: string;
                IsDirectPurchase: boolean;
                StartDate: Date;
                Cost: Record<string, number>;
                Rewards: {
                    ItemTypeID: string;
                    ItemID: string;
                    Quantity: number;
                }[];
            }, {
                OfferID: string;
                IsDirectPurchase: boolean;
                StartDate: string;
                Cost: Record<string, number>;
                Rewards: {
                    ItemTypeID: string;
                    ItemID: string;
                    Quantity: number;
                }[];
            }>, "many">;
        }, "strip", z.ZodTypeAny, {
            Offers: {
                OfferID: string;
                IsDirectPurchase: boolean;
                StartDate: Date;
                Cost: Record<string, number>;
                Rewards: {
                    ItemTypeID: string;
                    ItemID: string;
                    Quantity: number;
                }[];
            }[];
        }, {
            Offers: {
                OfferID: string;
                IsDirectPurchase: boolean;
                StartDate: string;
                Cost: Record<string, number>;
                Rewards: {
                    ItemTypeID: string;
                    ItemID: string;
                    Quantity: number;
                }[];
            }[];
        }>;
    };
}, "type" | "name" | "url"> & {
    "~type": {
        readonly name: "Prices";
        readonly description: "Get the current store prices for all items";
        readonly type: "pd";
        readonly url: "store/v1/offers/";
        readonly responses: {
            readonly "200": z.ZodObject<{
                Offers: z.ZodArray<z.ZodObject<{
                    OfferID: z.ZodString;
                    IsDirectPurchase: z.ZodBoolean;
                    StartDate: z.ZodEffects<z.ZodString, Date, string>;
                    Cost: z.ZodRecord<z.ZodString, z.ZodNumber>;
                    Rewards: z.ZodArray<z.ZodObject<{
                        ItemTypeID: z.ZodString;
                        ItemID: z.ZodString;
                        Quantity: z.ZodNumber;
                    }, "strip", z.ZodTypeAny, {
                        ItemTypeID: string;
                        ItemID: string;
                        Quantity: number;
                    }, {
                        ItemTypeID: string;
                        ItemID: string;
                        Quantity: number;
                    }>, "many">;
                }, "strip", z.ZodTypeAny, {
                    OfferID: string;
                    IsDirectPurchase: boolean;
                    StartDate: Date;
                    Cost: Record<string, number>;
                    Rewards: {
                        ItemTypeID: string;
                        ItemID: string;
                        Quantity: number;
                    }[];
                }, {
                    OfferID: string;
                    IsDirectPurchase: boolean;
                    StartDate: string;
                    Cost: Record<string, number>;
                    Rewards: {
                        ItemTypeID: string;
                        ItemID: string;
                        Quantity: number;
                    }[];
                }>, "many">;
            }, "strip", z.ZodTypeAny, {
                Offers: {
                    OfferID: string;
                    IsDirectPurchase: boolean;
                    StartDate: Date;
                    Cost: Record<string, number>;
                    Rewards: {
                        ItemTypeID: string;
                        ItemID: string;
                        Quantity: number;
                    }[];
                }[];
            }, {
                Offers: {
                    OfferID: string;
                    IsDirectPurchase: boolean;
                    StartDate: string;
                    Cost: Record<string, number>;
                    Rewards: {
                        ItemTypeID: string;
                        ItemID: string;
                        Quantity: number;
                    }[];
                }[];
            }>;
        };
    };
};

type Params$y = ResolveParams<(typeof _default$y)["~type"]["url"]>;
type Body$y = z.infer<ResolveValue<(typeof _default$y)["~type"], "body">>;
type Data$y = ResolveData<Params$y, Body$y>;
type Response$y = z.infer<ResolveValue<(typeof _default$y)["~type"], "responses">["200"]>;
interface PricesRequestConfig extends ValorantAxiosRequestConfig<Data$y> {
}
declare class PricesEndpoint {
    /**
     * Get the current store prices for all items
     *
     * @EndpointType pd
     */
    getPrices<T = Response$y>(this: RemoteApiClient, config?: PricesRequestConfig): Promise<AxiosResponse<T>>;
}

declare const storefrontResponseSchema: z.ZodObject<{
    FeaturedBundle: z.ZodObject<{
        Bundle: z.ZodObject<{
            ID: z.ZodString;
            DataAssetID: z.ZodString;
            CurrencyID: z.ZodString;
            Items: z.ZodArray<z.ZodObject<{
                Item: z.ZodObject<{
                    ItemTypeID: z.ZodString;
                    ItemID: z.ZodString;
                    Amount: z.ZodNumber;
                }, "strip", z.ZodTypeAny, {
                    ItemTypeID: string;
                    ItemID: string;
                    Amount: number;
                }, {
                    ItemTypeID: string;
                    ItemID: string;
                    Amount: number;
                }>;
                BasePrice: z.ZodNumber;
                CurrencyID: z.ZodString;
                DiscountPercent: z.ZodNumber;
                DiscountedPrice: z.ZodNumber;
                IsPromoItem: z.ZodBoolean;
            }, "strip", z.ZodTypeAny, {
                Item: {
                    ItemTypeID: string;
                    ItemID: string;
                    Amount: number;
                };
                CurrencyID: string;
                BasePrice: number;
                DiscountPercent: number;
                DiscountedPrice: number;
                IsPromoItem: boolean;
            }, {
                Item: {
                    ItemTypeID: string;
                    ItemID: string;
                    Amount: number;
                };
                CurrencyID: string;
                BasePrice: number;
                DiscountPercent: number;
                DiscountedPrice: number;
                IsPromoItem: boolean;
            }>, "many">;
            ItemOffers: z.ZodNullable<z.ZodArray<z.ZodObject<{
                BundleItemOfferID: z.ZodString;
                Offer: z.ZodObject<{
                    OfferID: z.ZodString;
                    IsDirectPurchase: z.ZodBoolean;
                    StartDate: z.ZodEffects<z.ZodString, Date, string>;
                    Cost: z.ZodRecord<z.ZodString, z.ZodNumber>;
                    Rewards: z.ZodArray<z.ZodObject<{
                        ItemTypeID: z.ZodString;
                        ItemID: z.ZodString;
                        Quantity: z.ZodNumber;
                    }, "strip", z.ZodTypeAny, {
                        ItemTypeID: string;
                        ItemID: string;
                        Quantity: number;
                    }, {
                        ItemTypeID: string;
                        ItemID: string;
                        Quantity: number;
                    }>, "many">;
                }, "strip", z.ZodTypeAny, {
                    OfferID: string;
                    IsDirectPurchase: boolean;
                    StartDate: Date;
                    Cost: Record<string, number>;
                    Rewards: {
                        ItemTypeID: string;
                        ItemID: string;
                        Quantity: number;
                    }[];
                }, {
                    OfferID: string;
                    IsDirectPurchase: boolean;
                    StartDate: string;
                    Cost: Record<string, number>;
                    Rewards: {
                        ItemTypeID: string;
                        ItemID: string;
                        Quantity: number;
                    }[];
                }>;
                DiscountPercent: z.ZodNumber;
                DiscountedCost: z.ZodRecord<z.ZodString, z.ZodNumber>;
            }, "strip", z.ZodTypeAny, {
                DiscountPercent: number;
                BundleItemOfferID: string;
                Offer: {
                    OfferID: string;
                    IsDirectPurchase: boolean;
                    StartDate: Date;
                    Cost: Record<string, number>;
                    Rewards: {
                        ItemTypeID: string;
                        ItemID: string;
                        Quantity: number;
                    }[];
                };
                DiscountedCost: Record<string, number>;
            }, {
                DiscountPercent: number;
                BundleItemOfferID: string;
                Offer: {
                    OfferID: string;
                    IsDirectPurchase: boolean;
                    StartDate: string;
                    Cost: Record<string, number>;
                    Rewards: {
                        ItemTypeID: string;
                        ItemID: string;
                        Quantity: number;
                    }[];
                };
                DiscountedCost: Record<string, number>;
            }>, "many">>;
            TotalBaseCost: z.ZodNullable<z.ZodRecord<z.ZodString, z.ZodNumber>>;
            TotalDiscountedCost: z.ZodNullable<z.ZodRecord<z.ZodString, z.ZodNumber>>;
            TotalDiscountPercent: z.ZodNumber;
            DurationRemainingInSeconds: z.ZodNumber;
            WholesaleOnly: z.ZodBoolean;
        }, "strip", z.ZodTypeAny, {
            Items: {
                Item: {
                    ItemTypeID: string;
                    ItemID: string;
                    Amount: number;
                };
                CurrencyID: string;
                BasePrice: number;
                DiscountPercent: number;
                DiscountedPrice: number;
                IsPromoItem: boolean;
            }[];
            ID: string;
            CurrencyID: string;
            DataAssetID: string;
            ItemOffers: {
                DiscountPercent: number;
                BundleItemOfferID: string;
                Offer: {
                    OfferID: string;
                    IsDirectPurchase: boolean;
                    StartDate: Date;
                    Cost: Record<string, number>;
                    Rewards: {
                        ItemTypeID: string;
                        ItemID: string;
                        Quantity: number;
                    }[];
                };
                DiscountedCost: Record<string, number>;
            }[] | null;
            TotalBaseCost: Record<string, number> | null;
            TotalDiscountedCost: Record<string, number> | null;
            TotalDiscountPercent: number;
            DurationRemainingInSeconds: number;
            WholesaleOnly: boolean;
        }, {
            Items: {
                Item: {
                    ItemTypeID: string;
                    ItemID: string;
                    Amount: number;
                };
                CurrencyID: string;
                BasePrice: number;
                DiscountPercent: number;
                DiscountedPrice: number;
                IsPromoItem: boolean;
            }[];
            ID: string;
            CurrencyID: string;
            DataAssetID: string;
            ItemOffers: {
                DiscountPercent: number;
                BundleItemOfferID: string;
                Offer: {
                    OfferID: string;
                    IsDirectPurchase: boolean;
                    StartDate: string;
                    Cost: Record<string, number>;
                    Rewards: {
                        ItemTypeID: string;
                        ItemID: string;
                        Quantity: number;
                    }[];
                };
                DiscountedCost: Record<string, number>;
            }[] | null;
            TotalBaseCost: Record<string, number> | null;
            TotalDiscountedCost: Record<string, number> | null;
            TotalDiscountPercent: number;
            DurationRemainingInSeconds: number;
            WholesaleOnly: boolean;
        }>;
        Bundles: z.ZodArray<z.ZodObject<{
            ID: z.ZodString;
            DataAssetID: z.ZodString;
            CurrencyID: z.ZodString;
            Items: z.ZodArray<z.ZodObject<{
                Item: z.ZodObject<{
                    ItemTypeID: z.ZodString;
                    ItemID: z.ZodString;
                    Amount: z.ZodNumber;
                }, "strip", z.ZodTypeAny, {
                    ItemTypeID: string;
                    ItemID: string;
                    Amount: number;
                }, {
                    ItemTypeID: string;
                    ItemID: string;
                    Amount: number;
                }>;
                BasePrice: z.ZodNumber;
                CurrencyID: z.ZodString;
                DiscountPercent: z.ZodNumber;
                DiscountedPrice: z.ZodNumber;
                IsPromoItem: z.ZodBoolean;
            }, "strip", z.ZodTypeAny, {
                Item: {
                    ItemTypeID: string;
                    ItemID: string;
                    Amount: number;
                };
                CurrencyID: string;
                BasePrice: number;
                DiscountPercent: number;
                DiscountedPrice: number;
                IsPromoItem: boolean;
            }, {
                Item: {
                    ItemTypeID: string;
                    ItemID: string;
                    Amount: number;
                };
                CurrencyID: string;
                BasePrice: number;
                DiscountPercent: number;
                DiscountedPrice: number;
                IsPromoItem: boolean;
            }>, "many">;
            ItemOffers: z.ZodNullable<z.ZodArray<z.ZodObject<{
                BundleItemOfferID: z.ZodString;
                Offer: z.ZodObject<{
                    OfferID: z.ZodString;
                    IsDirectPurchase: z.ZodBoolean;
                    StartDate: z.ZodEffects<z.ZodString, Date, string>;
                    Cost: z.ZodRecord<z.ZodString, z.ZodNumber>;
                    Rewards: z.ZodArray<z.ZodObject<{
                        ItemTypeID: z.ZodString;
                        ItemID: z.ZodString;
                        Quantity: z.ZodNumber;
                    }, "strip", z.ZodTypeAny, {
                        ItemTypeID: string;
                        ItemID: string;
                        Quantity: number;
                    }, {
                        ItemTypeID: string;
                        ItemID: string;
                        Quantity: number;
                    }>, "many">;
                }, "strip", z.ZodTypeAny, {
                    OfferID: string;
                    IsDirectPurchase: boolean;
                    StartDate: Date;
                    Cost: Record<string, number>;
                    Rewards: {
                        ItemTypeID: string;
                        ItemID: string;
                        Quantity: number;
                    }[];
                }, {
                    OfferID: string;
                    IsDirectPurchase: boolean;
                    StartDate: string;
                    Cost: Record<string, number>;
                    Rewards: {
                        ItemTypeID: string;
                        ItemID: string;
                        Quantity: number;
                    }[];
                }>;
                DiscountPercent: z.ZodNumber;
                DiscountedCost: z.ZodRecord<z.ZodString, z.ZodNumber>;
            }, "strip", z.ZodTypeAny, {
                DiscountPercent: number;
                BundleItemOfferID: string;
                Offer: {
                    OfferID: string;
                    IsDirectPurchase: boolean;
                    StartDate: Date;
                    Cost: Record<string, number>;
                    Rewards: {
                        ItemTypeID: string;
                        ItemID: string;
                        Quantity: number;
                    }[];
                };
                DiscountedCost: Record<string, number>;
            }, {
                DiscountPercent: number;
                BundleItemOfferID: string;
                Offer: {
                    OfferID: string;
                    IsDirectPurchase: boolean;
                    StartDate: string;
                    Cost: Record<string, number>;
                    Rewards: {
                        ItemTypeID: string;
                        ItemID: string;
                        Quantity: number;
                    }[];
                };
                DiscountedCost: Record<string, number>;
            }>, "many">>;
            TotalBaseCost: z.ZodNullable<z.ZodRecord<z.ZodString, z.ZodNumber>>;
            TotalDiscountedCost: z.ZodNullable<z.ZodRecord<z.ZodString, z.ZodNumber>>;
            TotalDiscountPercent: z.ZodNumber;
            DurationRemainingInSeconds: z.ZodNumber;
            WholesaleOnly: z.ZodBoolean;
        }, "strip", z.ZodTypeAny, {
            Items: {
                Item: {
                    ItemTypeID: string;
                    ItemID: string;
                    Amount: number;
                };
                CurrencyID: string;
                BasePrice: number;
                DiscountPercent: number;
                DiscountedPrice: number;
                IsPromoItem: boolean;
            }[];
            ID: string;
            CurrencyID: string;
            DataAssetID: string;
            ItemOffers: {
                DiscountPercent: number;
                BundleItemOfferID: string;
                Offer: {
                    OfferID: string;
                    IsDirectPurchase: boolean;
                    StartDate: Date;
                    Cost: Record<string, number>;
                    Rewards: {
                        ItemTypeID: string;
                        ItemID: string;
                        Quantity: number;
                    }[];
                };
                DiscountedCost: Record<string, number>;
            }[] | null;
            TotalBaseCost: Record<string, number> | null;
            TotalDiscountedCost: Record<string, number> | null;
            TotalDiscountPercent: number;
            DurationRemainingInSeconds: number;
            WholesaleOnly: boolean;
        }, {
            Items: {
                Item: {
                    ItemTypeID: string;
                    ItemID: string;
                    Amount: number;
                };
                CurrencyID: string;
                BasePrice: number;
                DiscountPercent: number;
                DiscountedPrice: number;
                IsPromoItem: boolean;
            }[];
            ID: string;
            CurrencyID: string;
            DataAssetID: string;
            ItemOffers: {
                DiscountPercent: number;
                BundleItemOfferID: string;
                Offer: {
                    OfferID: string;
                    IsDirectPurchase: boolean;
                    StartDate: string;
                    Cost: Record<string, number>;
                    Rewards: {
                        ItemTypeID: string;
                        ItemID: string;
                        Quantity: number;
                    }[];
                };
                DiscountedCost: Record<string, number>;
            }[] | null;
            TotalBaseCost: Record<string, number> | null;
            TotalDiscountedCost: Record<string, number> | null;
            TotalDiscountPercent: number;
            DurationRemainingInSeconds: number;
            WholesaleOnly: boolean;
        }>, "many">;
        BundleRemainingDurationInSeconds: z.ZodNumber;
    }, "strip", z.ZodTypeAny, {
        Bundle: {
            Items: {
                Item: {
                    ItemTypeID: string;
                    ItemID: string;
                    Amount: number;
                };
                CurrencyID: string;
                BasePrice: number;
                DiscountPercent: number;
                DiscountedPrice: number;
                IsPromoItem: boolean;
            }[];
            ID: string;
            CurrencyID: string;
            DataAssetID: string;
            ItemOffers: {
                DiscountPercent: number;
                BundleItemOfferID: string;
                Offer: {
                    OfferID: string;
                    IsDirectPurchase: boolean;
                    StartDate: Date;
                    Cost: Record<string, number>;
                    Rewards: {
                        ItemTypeID: string;
                        ItemID: string;
                        Quantity: number;
                    }[];
                };
                DiscountedCost: Record<string, number>;
            }[] | null;
            TotalBaseCost: Record<string, number> | null;
            TotalDiscountedCost: Record<string, number> | null;
            TotalDiscountPercent: number;
            DurationRemainingInSeconds: number;
            WholesaleOnly: boolean;
        };
        Bundles: {
            Items: {
                Item: {
                    ItemTypeID: string;
                    ItemID: string;
                    Amount: number;
                };
                CurrencyID: string;
                BasePrice: number;
                DiscountPercent: number;
                DiscountedPrice: number;
                IsPromoItem: boolean;
            }[];
            ID: string;
            CurrencyID: string;
            DataAssetID: string;
            ItemOffers: {
                DiscountPercent: number;
                BundleItemOfferID: string;
                Offer: {
                    OfferID: string;
                    IsDirectPurchase: boolean;
                    StartDate: Date;
                    Cost: Record<string, number>;
                    Rewards: {
                        ItemTypeID: string;
                        ItemID: string;
                        Quantity: number;
                    }[];
                };
                DiscountedCost: Record<string, number>;
            }[] | null;
            TotalBaseCost: Record<string, number> | null;
            TotalDiscountedCost: Record<string, number> | null;
            TotalDiscountPercent: number;
            DurationRemainingInSeconds: number;
            WholesaleOnly: boolean;
        }[];
        BundleRemainingDurationInSeconds: number;
    }, {
        Bundle: {
            Items: {
                Item: {
                    ItemTypeID: string;
                    ItemID: string;
                    Amount: number;
                };
                CurrencyID: string;
                BasePrice: number;
                DiscountPercent: number;
                DiscountedPrice: number;
                IsPromoItem: boolean;
            }[];
            ID: string;
            CurrencyID: string;
            DataAssetID: string;
            ItemOffers: {
                DiscountPercent: number;
                BundleItemOfferID: string;
                Offer: {
                    OfferID: string;
                    IsDirectPurchase: boolean;
                    StartDate: string;
                    Cost: Record<string, number>;
                    Rewards: {
                        ItemTypeID: string;
                        ItemID: string;
                        Quantity: number;
                    }[];
                };
                DiscountedCost: Record<string, number>;
            }[] | null;
            TotalBaseCost: Record<string, number> | null;
            TotalDiscountedCost: Record<string, number> | null;
            TotalDiscountPercent: number;
            DurationRemainingInSeconds: number;
            WholesaleOnly: boolean;
        };
        Bundles: {
            Items: {
                Item: {
                    ItemTypeID: string;
                    ItemID: string;
                    Amount: number;
                };
                CurrencyID: string;
                BasePrice: number;
                DiscountPercent: number;
                DiscountedPrice: number;
                IsPromoItem: boolean;
            }[];
            ID: string;
            CurrencyID: string;
            DataAssetID: string;
            ItemOffers: {
                DiscountPercent: number;
                BundleItemOfferID: string;
                Offer: {
                    OfferID: string;
                    IsDirectPurchase: boolean;
                    StartDate: string;
                    Cost: Record<string, number>;
                    Rewards: {
                        ItemTypeID: string;
                        ItemID: string;
                        Quantity: number;
                    }[];
                };
                DiscountedCost: Record<string, number>;
            }[] | null;
            TotalBaseCost: Record<string, number> | null;
            TotalDiscountedCost: Record<string, number> | null;
            TotalDiscountPercent: number;
            DurationRemainingInSeconds: number;
            WholesaleOnly: boolean;
        }[];
        BundleRemainingDurationInSeconds: number;
    }>;
    SkinsPanelLayout: z.ZodObject<{
        SingleItemOffers: z.ZodArray<z.ZodString, "many">;
        SingleItemStoreOffers: z.ZodArray<z.ZodObject<{
            OfferID: z.ZodString;
            IsDirectPurchase: z.ZodBoolean;
            StartDate: z.ZodEffects<z.ZodString, Date, string>;
            Cost: z.ZodRecord<z.ZodString, z.ZodNumber>;
            Rewards: z.ZodArray<z.ZodObject<{
                ItemTypeID: z.ZodString;
                ItemID: z.ZodString;
                Quantity: z.ZodNumber;
            }, "strip", z.ZodTypeAny, {
                ItemTypeID: string;
                ItemID: string;
                Quantity: number;
            }, {
                ItemTypeID: string;
                ItemID: string;
                Quantity: number;
            }>, "many">;
        }, "strip", z.ZodTypeAny, {
            OfferID: string;
            IsDirectPurchase: boolean;
            StartDate: Date;
            Cost: Record<string, number>;
            Rewards: {
                ItemTypeID: string;
                ItemID: string;
                Quantity: number;
            }[];
        }, {
            OfferID: string;
            IsDirectPurchase: boolean;
            StartDate: string;
            Cost: Record<string, number>;
            Rewards: {
                ItemTypeID: string;
                ItemID: string;
                Quantity: number;
            }[];
        }>, "many">;
        SingleItemOffersRemainingDurationInSeconds: z.ZodNumber;
    }, "strip", z.ZodTypeAny, {
        SingleItemOffers: string[];
        SingleItemStoreOffers: {
            OfferID: string;
            IsDirectPurchase: boolean;
            StartDate: Date;
            Cost: Record<string, number>;
            Rewards: {
                ItemTypeID: string;
                ItemID: string;
                Quantity: number;
            }[];
        }[];
        SingleItemOffersRemainingDurationInSeconds: number;
    }, {
        SingleItemOffers: string[];
        SingleItemStoreOffers: {
            OfferID: string;
            IsDirectPurchase: boolean;
            StartDate: string;
            Cost: Record<string, number>;
            Rewards: {
                ItemTypeID: string;
                ItemID: string;
                Quantity: number;
            }[];
        }[];
        SingleItemOffersRemainingDurationInSeconds: number;
    }>;
    UpgradeCurrencyStore: z.ZodObject<{
        UpgradeCurrencyOffers: z.ZodArray<z.ZodObject<{
            OfferID: z.ZodString;
            StorefrontItemID: z.ZodString;
            Offer: z.ZodObject<{
                OfferID: z.ZodString;
                IsDirectPurchase: z.ZodBoolean;
                StartDate: z.ZodEffects<z.ZodString, Date, string>;
                Cost: z.ZodRecord<z.ZodString, z.ZodNumber>;
                Rewards: z.ZodArray<z.ZodObject<{
                    ItemTypeID: z.ZodString;
                    ItemID: z.ZodString;
                    Quantity: z.ZodNumber;
                }, "strip", z.ZodTypeAny, {
                    ItemTypeID: string;
                    ItemID: string;
                    Quantity: number;
                }, {
                    ItemTypeID: string;
                    ItemID: string;
                    Quantity: number;
                }>, "many">;
            }, "strip", z.ZodTypeAny, {
                OfferID: string;
                IsDirectPurchase: boolean;
                StartDate: Date;
                Cost: Record<string, number>;
                Rewards: {
                    ItemTypeID: string;
                    ItemID: string;
                    Quantity: number;
                }[];
            }, {
                OfferID: string;
                IsDirectPurchase: boolean;
                StartDate: string;
                Cost: Record<string, number>;
                Rewards: {
                    ItemTypeID: string;
                    ItemID: string;
                    Quantity: number;
                }[];
            }>;
            DiscountedPercent: z.ZodNumber;
        }, "strip", z.ZodTypeAny, {
            OfferID: string;
            Offer: {
                OfferID: string;
                IsDirectPurchase: boolean;
                StartDate: Date;
                Cost: Record<string, number>;
                Rewards: {
                    ItemTypeID: string;
                    ItemID: string;
                    Quantity: number;
                }[];
            };
            StorefrontItemID: string;
            DiscountedPercent: number;
        }, {
            OfferID: string;
            Offer: {
                OfferID: string;
                IsDirectPurchase: boolean;
                StartDate: string;
                Cost: Record<string, number>;
                Rewards: {
                    ItemTypeID: string;
                    ItemID: string;
                    Quantity: number;
                }[];
            };
            StorefrontItemID: string;
            DiscountedPercent: number;
        }>, "many">;
    }, "strip", z.ZodTypeAny, {
        UpgradeCurrencyOffers: {
            OfferID: string;
            Offer: {
                OfferID: string;
                IsDirectPurchase: boolean;
                StartDate: Date;
                Cost: Record<string, number>;
                Rewards: {
                    ItemTypeID: string;
                    ItemID: string;
                    Quantity: number;
                }[];
            };
            StorefrontItemID: string;
            DiscountedPercent: number;
        }[];
    }, {
        UpgradeCurrencyOffers: {
            OfferID: string;
            Offer: {
                OfferID: string;
                IsDirectPurchase: boolean;
                StartDate: string;
                Cost: Record<string, number>;
                Rewards: {
                    ItemTypeID: string;
                    ItemID: string;
                    Quantity: number;
                }[];
            };
            StorefrontItemID: string;
            DiscountedPercent: number;
        }[];
    }>;
    AccessoryStore: z.ZodObject<{
        AccessoryStoreOffers: z.ZodArray<z.ZodObject<{
            Offer: z.ZodObject<{
                OfferID: z.ZodString;
                IsDirectPurchase: z.ZodBoolean;
                StartDate: z.ZodEffects<z.ZodString, Date, string>;
                Cost: z.ZodRecord<z.ZodString, z.ZodNumber>;
                Rewards: z.ZodArray<z.ZodObject<{
                    ItemTypeID: z.ZodString;
                    ItemID: z.ZodString;
                    Quantity: z.ZodNumber;
                }, "strip", z.ZodTypeAny, {
                    ItemTypeID: string;
                    ItemID: string;
                    Quantity: number;
                }, {
                    ItemTypeID: string;
                    ItemID: string;
                    Quantity: number;
                }>, "many">;
            }, "strip", z.ZodTypeAny, {
                OfferID: string;
                IsDirectPurchase: boolean;
                StartDate: Date;
                Cost: Record<string, number>;
                Rewards: {
                    ItemTypeID: string;
                    ItemID: string;
                    Quantity: number;
                }[];
            }, {
                OfferID: string;
                IsDirectPurchase: boolean;
                StartDate: string;
                Cost: Record<string, number>;
                Rewards: {
                    ItemTypeID: string;
                    ItemID: string;
                    Quantity: number;
                }[];
            }>;
            ContractID: z.ZodString;
        }, "strip", z.ZodTypeAny, {
            Offer: {
                OfferID: string;
                IsDirectPurchase: boolean;
                StartDate: Date;
                Cost: Record<string, number>;
                Rewards: {
                    ItemTypeID: string;
                    ItemID: string;
                    Quantity: number;
                }[];
            };
            ContractID: string;
        }, {
            Offer: {
                OfferID: string;
                IsDirectPurchase: boolean;
                StartDate: string;
                Cost: Record<string, number>;
                Rewards: {
                    ItemTypeID: string;
                    ItemID: string;
                    Quantity: number;
                }[];
            };
            ContractID: string;
        }>, "many">;
        AccessoryStoreRemainingDurationInSeconds: z.ZodNumber;
        StorefrontID: z.ZodString;
    }, "strip", z.ZodTypeAny, {
        AccessoryStoreOffers: {
            Offer: {
                OfferID: string;
                IsDirectPurchase: boolean;
                StartDate: Date;
                Cost: Record<string, number>;
                Rewards: {
                    ItemTypeID: string;
                    ItemID: string;
                    Quantity: number;
                }[];
            };
            ContractID: string;
        }[];
        AccessoryStoreRemainingDurationInSeconds: number;
        StorefrontID: string;
    }, {
        AccessoryStoreOffers: {
            Offer: {
                OfferID: string;
                IsDirectPurchase: boolean;
                StartDate: string;
                Cost: Record<string, number>;
                Rewards: {
                    ItemTypeID: string;
                    ItemID: string;
                    Quantity: number;
                }[];
            };
            ContractID: string;
        }[];
        AccessoryStoreRemainingDurationInSeconds: number;
        StorefrontID: string;
    }>;
    BonusStore: z.ZodOptional<z.ZodObject<{
        BonusStoreOffers: z.ZodArray<z.ZodObject<{
            BonusOfferID: z.ZodString;
            Offer: z.ZodObject<{
                OfferID: z.ZodString;
                IsDirectPurchase: z.ZodBoolean;
                StartDate: z.ZodEffects<z.ZodString, Date, string>;
                Cost: z.ZodRecord<z.ZodString, z.ZodNumber>;
                Rewards: z.ZodArray<z.ZodObject<{
                    ItemTypeID: z.ZodString;
                    ItemID: z.ZodString;
                    Quantity: z.ZodNumber;
                }, "strip", z.ZodTypeAny, {
                    ItemTypeID: string;
                    ItemID: string;
                    Quantity: number;
                }, {
                    ItemTypeID: string;
                    ItemID: string;
                    Quantity: number;
                }>, "many">;
            }, "strip", z.ZodTypeAny, {
                OfferID: string;
                IsDirectPurchase: boolean;
                StartDate: Date;
                Cost: Record<string, number>;
                Rewards: {
                    ItemTypeID: string;
                    ItemID: string;
                    Quantity: number;
                }[];
            }, {
                OfferID: string;
                IsDirectPurchase: boolean;
                StartDate: string;
                Cost: Record<string, number>;
                Rewards: {
                    ItemTypeID: string;
                    ItemID: string;
                    Quantity: number;
                }[];
            }>;
            DiscountPercent: z.ZodNumber;
            DiscountCosts: z.ZodRecord<z.ZodString, z.ZodNumber>;
            IsSeen: z.ZodBoolean;
        }, "strip", z.ZodTypeAny, {
            DiscountPercent: number;
            Offer: {
                OfferID: string;
                IsDirectPurchase: boolean;
                StartDate: Date;
                Cost: Record<string, number>;
                Rewards: {
                    ItemTypeID: string;
                    ItemID: string;
                    Quantity: number;
                }[];
            };
            BonusOfferID: string;
            DiscountCosts: Record<string, number>;
            IsSeen: boolean;
        }, {
            DiscountPercent: number;
            Offer: {
                OfferID: string;
                IsDirectPurchase: boolean;
                StartDate: string;
                Cost: Record<string, number>;
                Rewards: {
                    ItemTypeID: string;
                    ItemID: string;
                    Quantity: number;
                }[];
            };
            BonusOfferID: string;
            DiscountCosts: Record<string, number>;
            IsSeen: boolean;
        }>, "many">;
        BonusStoreRemainingDurationInSeconds: z.ZodNumber;
    }, "strip", z.ZodTypeAny, {
        BonusStoreOffers: {
            DiscountPercent: number;
            Offer: {
                OfferID: string;
                IsDirectPurchase: boolean;
                StartDate: Date;
                Cost: Record<string, number>;
                Rewards: {
                    ItemTypeID: string;
                    ItemID: string;
                    Quantity: number;
                }[];
            };
            BonusOfferID: string;
            DiscountCosts: Record<string, number>;
            IsSeen: boolean;
        }[];
        BonusStoreRemainingDurationInSeconds: number;
    }, {
        BonusStoreOffers: {
            DiscountPercent: number;
            Offer: {
                OfferID: string;
                IsDirectPurchase: boolean;
                StartDate: string;
                Cost: Record<string, number>;
                Rewards: {
                    ItemTypeID: string;
                    ItemID: string;
                    Quantity: number;
                }[];
            };
            BonusOfferID: string;
            DiscountCosts: Record<string, number>;
            IsSeen: boolean;
        }[];
        BonusStoreRemainingDurationInSeconds: number;
    }>>;
}, "strip", z.ZodTypeAny, {
    FeaturedBundle: {
        Bundle: {
            Items: {
                Item: {
                    ItemTypeID: string;
                    ItemID: string;
                    Amount: number;
                };
                CurrencyID: string;
                BasePrice: number;
                DiscountPercent: number;
                DiscountedPrice: number;
                IsPromoItem: boolean;
            }[];
            ID: string;
            CurrencyID: string;
            DataAssetID: string;
            ItemOffers: {
                DiscountPercent: number;
                BundleItemOfferID: string;
                Offer: {
                    OfferID: string;
                    IsDirectPurchase: boolean;
                    StartDate: Date;
                    Cost: Record<string, number>;
                    Rewards: {
                        ItemTypeID: string;
                        ItemID: string;
                        Quantity: number;
                    }[];
                };
                DiscountedCost: Record<string, number>;
            }[] | null;
            TotalBaseCost: Record<string, number> | null;
            TotalDiscountedCost: Record<string, number> | null;
            TotalDiscountPercent: number;
            DurationRemainingInSeconds: number;
            WholesaleOnly: boolean;
        };
        Bundles: {
            Items: {
                Item: {
                    ItemTypeID: string;
                    ItemID: string;
                    Amount: number;
                };
                CurrencyID: string;
                BasePrice: number;
                DiscountPercent: number;
                DiscountedPrice: number;
                IsPromoItem: boolean;
            }[];
            ID: string;
            CurrencyID: string;
            DataAssetID: string;
            ItemOffers: {
                DiscountPercent: number;
                BundleItemOfferID: string;
                Offer: {
                    OfferID: string;
                    IsDirectPurchase: boolean;
                    StartDate: Date;
                    Cost: Record<string, number>;
                    Rewards: {
                        ItemTypeID: string;
                        ItemID: string;
                        Quantity: number;
                    }[];
                };
                DiscountedCost: Record<string, number>;
            }[] | null;
            TotalBaseCost: Record<string, number> | null;
            TotalDiscountedCost: Record<string, number> | null;
            TotalDiscountPercent: number;
            DurationRemainingInSeconds: number;
            WholesaleOnly: boolean;
        }[];
        BundleRemainingDurationInSeconds: number;
    };
    SkinsPanelLayout: {
        SingleItemOffers: string[];
        SingleItemStoreOffers: {
            OfferID: string;
            IsDirectPurchase: boolean;
            StartDate: Date;
            Cost: Record<string, number>;
            Rewards: {
                ItemTypeID: string;
                ItemID: string;
                Quantity: number;
            }[];
        }[];
        SingleItemOffersRemainingDurationInSeconds: number;
    };
    UpgradeCurrencyStore: {
        UpgradeCurrencyOffers: {
            OfferID: string;
            Offer: {
                OfferID: string;
                IsDirectPurchase: boolean;
                StartDate: Date;
                Cost: Record<string, number>;
                Rewards: {
                    ItemTypeID: string;
                    ItemID: string;
                    Quantity: number;
                }[];
            };
            StorefrontItemID: string;
            DiscountedPercent: number;
        }[];
    };
    AccessoryStore: {
        AccessoryStoreOffers: {
            Offer: {
                OfferID: string;
                IsDirectPurchase: boolean;
                StartDate: Date;
                Cost: Record<string, number>;
                Rewards: {
                    ItemTypeID: string;
                    ItemID: string;
                    Quantity: number;
                }[];
            };
            ContractID: string;
        }[];
        AccessoryStoreRemainingDurationInSeconds: number;
        StorefrontID: string;
    };
    BonusStore?: {
        BonusStoreOffers: {
            DiscountPercent: number;
            Offer: {
                OfferID: string;
                IsDirectPurchase: boolean;
                StartDate: Date;
                Cost: Record<string, number>;
                Rewards: {
                    ItemTypeID: string;
                    ItemID: string;
                    Quantity: number;
                }[];
            };
            BonusOfferID: string;
            DiscountCosts: Record<string, number>;
            IsSeen: boolean;
        }[];
        BonusStoreRemainingDurationInSeconds: number;
    } | undefined;
}, {
    FeaturedBundle: {
        Bundle: {
            Items: {
                Item: {
                    ItemTypeID: string;
                    ItemID: string;
                    Amount: number;
                };
                CurrencyID: string;
                BasePrice: number;
                DiscountPercent: number;
                DiscountedPrice: number;
                IsPromoItem: boolean;
            }[];
            ID: string;
            CurrencyID: string;
            DataAssetID: string;
            ItemOffers: {
                DiscountPercent: number;
                BundleItemOfferID: string;
                Offer: {
                    OfferID: string;
                    IsDirectPurchase: boolean;
                    StartDate: string;
                    Cost: Record<string, number>;
                    Rewards: {
                        ItemTypeID: string;
                        ItemID: string;
                        Quantity: number;
                    }[];
                };
                DiscountedCost: Record<string, number>;
            }[] | null;
            TotalBaseCost: Record<string, number> | null;
            TotalDiscountedCost: Record<string, number> | null;
            TotalDiscountPercent: number;
            DurationRemainingInSeconds: number;
            WholesaleOnly: boolean;
        };
        Bundles: {
            Items: {
                Item: {
                    ItemTypeID: string;
                    ItemID: string;
                    Amount: number;
                };
                CurrencyID: string;
                BasePrice: number;
                DiscountPercent: number;
                DiscountedPrice: number;
                IsPromoItem: boolean;
            }[];
            ID: string;
            CurrencyID: string;
            DataAssetID: string;
            ItemOffers: {
                DiscountPercent: number;
                BundleItemOfferID: string;
                Offer: {
                    OfferID: string;
                    IsDirectPurchase: boolean;
                    StartDate: string;
                    Cost: Record<string, number>;
                    Rewards: {
                        ItemTypeID: string;
                        ItemID: string;
                        Quantity: number;
                    }[];
                };
                DiscountedCost: Record<string, number>;
            }[] | null;
            TotalBaseCost: Record<string, number> | null;
            TotalDiscountedCost: Record<string, number> | null;
            TotalDiscountPercent: number;
            DurationRemainingInSeconds: number;
            WholesaleOnly: boolean;
        }[];
        BundleRemainingDurationInSeconds: number;
    };
    SkinsPanelLayout: {
        SingleItemOffers: string[];
        SingleItemStoreOffers: {
            OfferID: string;
            IsDirectPurchase: boolean;
            StartDate: string;
            Cost: Record<string, number>;
            Rewards: {
                ItemTypeID: string;
                ItemID: string;
                Quantity: number;
            }[];
        }[];
        SingleItemOffersRemainingDurationInSeconds: number;
    };
    UpgradeCurrencyStore: {
        UpgradeCurrencyOffers: {
            OfferID: string;
            Offer: {
                OfferID: string;
                IsDirectPurchase: boolean;
                StartDate: string;
                Cost: Record<string, number>;
                Rewards: {
                    ItemTypeID: string;
                    ItemID: string;
                    Quantity: number;
                }[];
            };
            StorefrontItemID: string;
            DiscountedPercent: number;
        }[];
    };
    AccessoryStore: {
        AccessoryStoreOffers: {
            Offer: {
                OfferID: string;
                IsDirectPurchase: boolean;
                StartDate: string;
                Cost: Record<string, number>;
                Rewards: {
                    ItemTypeID: string;
                    ItemID: string;
                    Quantity: number;
                }[];
            };
            ContractID: string;
        }[];
        AccessoryStoreRemainingDurationInSeconds: number;
        StorefrontID: string;
    };
    BonusStore?: {
        BonusStoreOffers: {
            DiscountPercent: number;
            Offer: {
                OfferID: string;
                IsDirectPurchase: boolean;
                StartDate: string;
                Cost: Record<string, number>;
                Rewards: {
                    ItemTypeID: string;
                    ItemID: string;
                    Quantity: number;
                }[];
            };
            BonusOfferID: string;
            DiscountCosts: Record<string, number>;
            IsSeen: boolean;
        }[];
        BonusStoreRemainingDurationInSeconds: number;
    } | undefined;
}>;
declare const _default$x: Omit<{
    requirements: string[];
    type: "auth" | "local" | "pd" | "glz" | "shared";
    name: string;
    method: "PUT" | "GET" | "DELETE" | "POST";
    url: string;
    description?: string | undefined;
    headers?: Record<string, string> | undefined;
    body?: z.ZodType<any, z.ZodTypeDef, any> | undefined;
    query?: z.ZodType<any, z.ZodTypeDef, any> | undefined;
    responses?: Record<string, z.ZodType<any, z.ZodTypeDef, any>> | undefined;
}, "type" | "name" | "url"> & Pick<{
    readonly name: "Storefront";
    readonly description: "Get the currently available items in the store";
    readonly type: "pd";
    readonly url: "store/v2/storefront/:puuid";
    readonly responses: {
        readonly "200": z.ZodObject<{
            FeaturedBundle: z.ZodObject<{
                Bundle: z.ZodObject<{
                    ID: z.ZodString;
                    DataAssetID: z.ZodString;
                    CurrencyID: z.ZodString;
                    Items: z.ZodArray<z.ZodObject<{
                        Item: z.ZodObject<{
                            ItemTypeID: z.ZodString;
                            ItemID: z.ZodString;
                            Amount: z.ZodNumber;
                        }, "strip", z.ZodTypeAny, {
                            ItemTypeID: string;
                            ItemID: string;
                            Amount: number;
                        }, {
                            ItemTypeID: string;
                            ItemID: string;
                            Amount: number;
                        }>;
                        BasePrice: z.ZodNumber;
                        CurrencyID: z.ZodString;
                        DiscountPercent: z.ZodNumber;
                        DiscountedPrice: z.ZodNumber;
                        IsPromoItem: z.ZodBoolean;
                    }, "strip", z.ZodTypeAny, {
                        Item: {
                            ItemTypeID: string;
                            ItemID: string;
                            Amount: number;
                        };
                        CurrencyID: string;
                        BasePrice: number;
                        DiscountPercent: number;
                        DiscountedPrice: number;
                        IsPromoItem: boolean;
                    }, {
                        Item: {
                            ItemTypeID: string;
                            ItemID: string;
                            Amount: number;
                        };
                        CurrencyID: string;
                        BasePrice: number;
                        DiscountPercent: number;
                        DiscountedPrice: number;
                        IsPromoItem: boolean;
                    }>, "many">;
                    ItemOffers: z.ZodNullable<z.ZodArray<z.ZodObject<{
                        BundleItemOfferID: z.ZodString;
                        Offer: z.ZodObject<{
                            OfferID: z.ZodString;
                            IsDirectPurchase: z.ZodBoolean;
                            StartDate: z.ZodEffects<z.ZodString, Date, string>;
                            Cost: z.ZodRecord<z.ZodString, z.ZodNumber>;
                            Rewards: z.ZodArray<z.ZodObject<{
                                ItemTypeID: z.ZodString;
                                ItemID: z.ZodString;
                                Quantity: z.ZodNumber;
                            }, "strip", z.ZodTypeAny, {
                                ItemTypeID: string;
                                ItemID: string;
                                Quantity: number;
                            }, {
                                ItemTypeID: string;
                                ItemID: string;
                                Quantity: number;
                            }>, "many">;
                        }, "strip", z.ZodTypeAny, {
                            OfferID: string;
                            IsDirectPurchase: boolean;
                            StartDate: Date;
                            Cost: Record<string, number>;
                            Rewards: {
                                ItemTypeID: string;
                                ItemID: string;
                                Quantity: number;
                            }[];
                        }, {
                            OfferID: string;
                            IsDirectPurchase: boolean;
                            StartDate: string;
                            Cost: Record<string, number>;
                            Rewards: {
                                ItemTypeID: string;
                                ItemID: string;
                                Quantity: number;
                            }[];
                        }>;
                        DiscountPercent: z.ZodNumber;
                        DiscountedCost: z.ZodRecord<z.ZodString, z.ZodNumber>;
                    }, "strip", z.ZodTypeAny, {
                        DiscountPercent: number;
                        BundleItemOfferID: string;
                        Offer: {
                            OfferID: string;
                            IsDirectPurchase: boolean;
                            StartDate: Date;
                            Cost: Record<string, number>;
                            Rewards: {
                                ItemTypeID: string;
                                ItemID: string;
                                Quantity: number;
                            }[];
                        };
                        DiscountedCost: Record<string, number>;
                    }, {
                        DiscountPercent: number;
                        BundleItemOfferID: string;
                        Offer: {
                            OfferID: string;
                            IsDirectPurchase: boolean;
                            StartDate: string;
                            Cost: Record<string, number>;
                            Rewards: {
                                ItemTypeID: string;
                                ItemID: string;
                                Quantity: number;
                            }[];
                        };
                        DiscountedCost: Record<string, number>;
                    }>, "many">>;
                    TotalBaseCost: z.ZodNullable<z.ZodRecord<z.ZodString, z.ZodNumber>>;
                    TotalDiscountedCost: z.ZodNullable<z.ZodRecord<z.ZodString, z.ZodNumber>>;
                    TotalDiscountPercent: z.ZodNumber;
                    DurationRemainingInSeconds: z.ZodNumber;
                    WholesaleOnly: z.ZodBoolean;
                }, "strip", z.ZodTypeAny, {
                    Items: {
                        Item: {
                            ItemTypeID: string;
                            ItemID: string;
                            Amount: number;
                        };
                        CurrencyID: string;
                        BasePrice: number;
                        DiscountPercent: number;
                        DiscountedPrice: number;
                        IsPromoItem: boolean;
                    }[];
                    ID: string;
                    CurrencyID: string;
                    DataAssetID: string;
                    ItemOffers: {
                        DiscountPercent: number;
                        BundleItemOfferID: string;
                        Offer: {
                            OfferID: string;
                            IsDirectPurchase: boolean;
                            StartDate: Date;
                            Cost: Record<string, number>;
                            Rewards: {
                                ItemTypeID: string;
                                ItemID: string;
                                Quantity: number;
                            }[];
                        };
                        DiscountedCost: Record<string, number>;
                    }[] | null;
                    TotalBaseCost: Record<string, number> | null;
                    TotalDiscountedCost: Record<string, number> | null;
                    TotalDiscountPercent: number;
                    DurationRemainingInSeconds: number;
                    WholesaleOnly: boolean;
                }, {
                    Items: {
                        Item: {
                            ItemTypeID: string;
                            ItemID: string;
                            Amount: number;
                        };
                        CurrencyID: string;
                        BasePrice: number;
                        DiscountPercent: number;
                        DiscountedPrice: number;
                        IsPromoItem: boolean;
                    }[];
                    ID: string;
                    CurrencyID: string;
                    DataAssetID: string;
                    ItemOffers: {
                        DiscountPercent: number;
                        BundleItemOfferID: string;
                        Offer: {
                            OfferID: string;
                            IsDirectPurchase: boolean;
                            StartDate: string;
                            Cost: Record<string, number>;
                            Rewards: {
                                ItemTypeID: string;
                                ItemID: string;
                                Quantity: number;
                            }[];
                        };
                        DiscountedCost: Record<string, number>;
                    }[] | null;
                    TotalBaseCost: Record<string, number> | null;
                    TotalDiscountedCost: Record<string, number> | null;
                    TotalDiscountPercent: number;
                    DurationRemainingInSeconds: number;
                    WholesaleOnly: boolean;
                }>;
                Bundles: z.ZodArray<z.ZodObject<{
                    ID: z.ZodString;
                    DataAssetID: z.ZodString;
                    CurrencyID: z.ZodString;
                    Items: z.ZodArray<z.ZodObject<{
                        Item: z.ZodObject<{
                            ItemTypeID: z.ZodString;
                            ItemID: z.ZodString;
                            Amount: z.ZodNumber;
                        }, "strip", z.ZodTypeAny, {
                            ItemTypeID: string;
                            ItemID: string;
                            Amount: number;
                        }, {
                            ItemTypeID: string;
                            ItemID: string;
                            Amount: number;
                        }>;
                        BasePrice: z.ZodNumber;
                        CurrencyID: z.ZodString;
                        DiscountPercent: z.ZodNumber;
                        DiscountedPrice: z.ZodNumber;
                        IsPromoItem: z.ZodBoolean;
                    }, "strip", z.ZodTypeAny, {
                        Item: {
                            ItemTypeID: string;
                            ItemID: string;
                            Amount: number;
                        };
                        CurrencyID: string;
                        BasePrice: number;
                        DiscountPercent: number;
                        DiscountedPrice: number;
                        IsPromoItem: boolean;
                    }, {
                        Item: {
                            ItemTypeID: string;
                            ItemID: string;
                            Amount: number;
                        };
                        CurrencyID: string;
                        BasePrice: number;
                        DiscountPercent: number;
                        DiscountedPrice: number;
                        IsPromoItem: boolean;
                    }>, "many">;
                    ItemOffers: z.ZodNullable<z.ZodArray<z.ZodObject<{
                        BundleItemOfferID: z.ZodString;
                        Offer: z.ZodObject<{
                            OfferID: z.ZodString;
                            IsDirectPurchase: z.ZodBoolean;
                            StartDate: z.ZodEffects<z.ZodString, Date, string>;
                            Cost: z.ZodRecord<z.ZodString, z.ZodNumber>;
                            Rewards: z.ZodArray<z.ZodObject<{
                                ItemTypeID: z.ZodString;
                                ItemID: z.ZodString;
                                Quantity: z.ZodNumber;
                            }, "strip", z.ZodTypeAny, {
                                ItemTypeID: string;
                                ItemID: string;
                                Quantity: number;
                            }, {
                                ItemTypeID: string;
                                ItemID: string;
                                Quantity: number;
                            }>, "many">;
                        }, "strip", z.ZodTypeAny, {
                            OfferID: string;
                            IsDirectPurchase: boolean;
                            StartDate: Date;
                            Cost: Record<string, number>;
                            Rewards: {
                                ItemTypeID: string;
                                ItemID: string;
                                Quantity: number;
                            }[];
                        }, {
                            OfferID: string;
                            IsDirectPurchase: boolean;
                            StartDate: string;
                            Cost: Record<string, number>;
                            Rewards: {
                                ItemTypeID: string;
                                ItemID: string;
                                Quantity: number;
                            }[];
                        }>;
                        DiscountPercent: z.ZodNumber;
                        DiscountedCost: z.ZodRecord<z.ZodString, z.ZodNumber>;
                    }, "strip", z.ZodTypeAny, {
                        DiscountPercent: number;
                        BundleItemOfferID: string;
                        Offer: {
                            OfferID: string;
                            IsDirectPurchase: boolean;
                            StartDate: Date;
                            Cost: Record<string, number>;
                            Rewards: {
                                ItemTypeID: string;
                                ItemID: string;
                                Quantity: number;
                            }[];
                        };
                        DiscountedCost: Record<string, number>;
                    }, {
                        DiscountPercent: number;
                        BundleItemOfferID: string;
                        Offer: {
                            OfferID: string;
                            IsDirectPurchase: boolean;
                            StartDate: string;
                            Cost: Record<string, number>;
                            Rewards: {
                                ItemTypeID: string;
                                ItemID: string;
                                Quantity: number;
                            }[];
                        };
                        DiscountedCost: Record<string, number>;
                    }>, "many">>;
                    TotalBaseCost: z.ZodNullable<z.ZodRecord<z.ZodString, z.ZodNumber>>;
                    TotalDiscountedCost: z.ZodNullable<z.ZodRecord<z.ZodString, z.ZodNumber>>;
                    TotalDiscountPercent: z.ZodNumber;
                    DurationRemainingInSeconds: z.ZodNumber;
                    WholesaleOnly: z.ZodBoolean;
                }, "strip", z.ZodTypeAny, {
                    Items: {
                        Item: {
                            ItemTypeID: string;
                            ItemID: string;
                            Amount: number;
                        };
                        CurrencyID: string;
                        BasePrice: number;
                        DiscountPercent: number;
                        DiscountedPrice: number;
                        IsPromoItem: boolean;
                    }[];
                    ID: string;
                    CurrencyID: string;
                    DataAssetID: string;
                    ItemOffers: {
                        DiscountPercent: number;
                        BundleItemOfferID: string;
                        Offer: {
                            OfferID: string;
                            IsDirectPurchase: boolean;
                            StartDate: Date;
                            Cost: Record<string, number>;
                            Rewards: {
                                ItemTypeID: string;
                                ItemID: string;
                                Quantity: number;
                            }[];
                        };
                        DiscountedCost: Record<string, number>;
                    }[] | null;
                    TotalBaseCost: Record<string, number> | null;
                    TotalDiscountedCost: Record<string, number> | null;
                    TotalDiscountPercent: number;
                    DurationRemainingInSeconds: number;
                    WholesaleOnly: boolean;
                }, {
                    Items: {
                        Item: {
                            ItemTypeID: string;
                            ItemID: string;
                            Amount: number;
                        };
                        CurrencyID: string;
                        BasePrice: number;
                        DiscountPercent: number;
                        DiscountedPrice: number;
                        IsPromoItem: boolean;
                    }[];
                    ID: string;
                    CurrencyID: string;
                    DataAssetID: string;
                    ItemOffers: {
                        DiscountPercent: number;
                        BundleItemOfferID: string;
                        Offer: {
                            OfferID: string;
                            IsDirectPurchase: boolean;
                            StartDate: string;
                            Cost: Record<string, number>;
                            Rewards: {
                                ItemTypeID: string;
                                ItemID: string;
                                Quantity: number;
                            }[];
                        };
                        DiscountedCost: Record<string, number>;
                    }[] | null;
                    TotalBaseCost: Record<string, number> | null;
                    TotalDiscountedCost: Record<string, number> | null;
                    TotalDiscountPercent: number;
                    DurationRemainingInSeconds: number;
                    WholesaleOnly: boolean;
                }>, "many">;
                BundleRemainingDurationInSeconds: z.ZodNumber;
            }, "strip", z.ZodTypeAny, {
                Bundle: {
                    Items: {
                        Item: {
                            ItemTypeID: string;
                            ItemID: string;
                            Amount: number;
                        };
                        CurrencyID: string;
                        BasePrice: number;
                        DiscountPercent: number;
                        DiscountedPrice: number;
                        IsPromoItem: boolean;
                    }[];
                    ID: string;
                    CurrencyID: string;
                    DataAssetID: string;
                    ItemOffers: {
                        DiscountPercent: number;
                        BundleItemOfferID: string;
                        Offer: {
                            OfferID: string;
                            IsDirectPurchase: boolean;
                            StartDate: Date;
                            Cost: Record<string, number>;
                            Rewards: {
                                ItemTypeID: string;
                                ItemID: string;
                                Quantity: number;
                            }[];
                        };
                        DiscountedCost: Record<string, number>;
                    }[] | null;
                    TotalBaseCost: Record<string, number> | null;
                    TotalDiscountedCost: Record<string, number> | null;
                    TotalDiscountPercent: number;
                    DurationRemainingInSeconds: number;
                    WholesaleOnly: boolean;
                };
                Bundles: {
                    Items: {
                        Item: {
                            ItemTypeID: string;
                            ItemID: string;
                            Amount: number;
                        };
                        CurrencyID: string;
                        BasePrice: number;
                        DiscountPercent: number;
                        DiscountedPrice: number;
                        IsPromoItem: boolean;
                    }[];
                    ID: string;
                    CurrencyID: string;
                    DataAssetID: string;
                    ItemOffers: {
                        DiscountPercent: number;
                        BundleItemOfferID: string;
                        Offer: {
                            OfferID: string;
                            IsDirectPurchase: boolean;
                            StartDate: Date;
                            Cost: Record<string, number>;
                            Rewards: {
                                ItemTypeID: string;
                                ItemID: string;
                                Quantity: number;
                            }[];
                        };
                        DiscountedCost: Record<string, number>;
                    }[] | null;
                    TotalBaseCost: Record<string, number> | null;
                    TotalDiscountedCost: Record<string, number> | null;
                    TotalDiscountPercent: number;
                    DurationRemainingInSeconds: number;
                    WholesaleOnly: boolean;
                }[];
                BundleRemainingDurationInSeconds: number;
            }, {
                Bundle: {
                    Items: {
                        Item: {
                            ItemTypeID: string;
                            ItemID: string;
                            Amount: number;
                        };
                        CurrencyID: string;
                        BasePrice: number;
                        DiscountPercent: number;
                        DiscountedPrice: number;
                        IsPromoItem: boolean;
                    }[];
                    ID: string;
                    CurrencyID: string;
                    DataAssetID: string;
                    ItemOffers: {
                        DiscountPercent: number;
                        BundleItemOfferID: string;
                        Offer: {
                            OfferID: string;
                            IsDirectPurchase: boolean;
                            StartDate: string;
                            Cost: Record<string, number>;
                            Rewards: {
                                ItemTypeID: string;
                                ItemID: string;
                                Quantity: number;
                            }[];
                        };
                        DiscountedCost: Record<string, number>;
                    }[] | null;
                    TotalBaseCost: Record<string, number> | null;
                    TotalDiscountedCost: Record<string, number> | null;
                    TotalDiscountPercent: number;
                    DurationRemainingInSeconds: number;
                    WholesaleOnly: boolean;
                };
                Bundles: {
                    Items: {
                        Item: {
                            ItemTypeID: string;
                            ItemID: string;
                            Amount: number;
                        };
                        CurrencyID: string;
                        BasePrice: number;
                        DiscountPercent: number;
                        DiscountedPrice: number;
                        IsPromoItem: boolean;
                    }[];
                    ID: string;
                    CurrencyID: string;
                    DataAssetID: string;
                    ItemOffers: {
                        DiscountPercent: number;
                        BundleItemOfferID: string;
                        Offer: {
                            OfferID: string;
                            IsDirectPurchase: boolean;
                            StartDate: string;
                            Cost: Record<string, number>;
                            Rewards: {
                                ItemTypeID: string;
                                ItemID: string;
                                Quantity: number;
                            }[];
                        };
                        DiscountedCost: Record<string, number>;
                    }[] | null;
                    TotalBaseCost: Record<string, number> | null;
                    TotalDiscountedCost: Record<string, number> | null;
                    TotalDiscountPercent: number;
                    DurationRemainingInSeconds: number;
                    WholesaleOnly: boolean;
                }[];
                BundleRemainingDurationInSeconds: number;
            }>;
            SkinsPanelLayout: z.ZodObject<{
                SingleItemOffers: z.ZodArray<z.ZodString, "many">;
                SingleItemStoreOffers: z.ZodArray<z.ZodObject<{
                    OfferID: z.ZodString;
                    IsDirectPurchase: z.ZodBoolean;
                    StartDate: z.ZodEffects<z.ZodString, Date, string>;
                    Cost: z.ZodRecord<z.ZodString, z.ZodNumber>;
                    Rewards: z.ZodArray<z.ZodObject<{
                        ItemTypeID: z.ZodString;
                        ItemID: z.ZodString;
                        Quantity: z.ZodNumber;
                    }, "strip", z.ZodTypeAny, {
                        ItemTypeID: string;
                        ItemID: string;
                        Quantity: number;
                    }, {
                        ItemTypeID: string;
                        ItemID: string;
                        Quantity: number;
                    }>, "many">;
                }, "strip", z.ZodTypeAny, {
                    OfferID: string;
                    IsDirectPurchase: boolean;
                    StartDate: Date;
                    Cost: Record<string, number>;
                    Rewards: {
                        ItemTypeID: string;
                        ItemID: string;
                        Quantity: number;
                    }[];
                }, {
                    OfferID: string;
                    IsDirectPurchase: boolean;
                    StartDate: string;
                    Cost: Record<string, number>;
                    Rewards: {
                        ItemTypeID: string;
                        ItemID: string;
                        Quantity: number;
                    }[];
                }>, "many">;
                SingleItemOffersRemainingDurationInSeconds: z.ZodNumber;
            }, "strip", z.ZodTypeAny, {
                SingleItemOffers: string[];
                SingleItemStoreOffers: {
                    OfferID: string;
                    IsDirectPurchase: boolean;
                    StartDate: Date;
                    Cost: Record<string, number>;
                    Rewards: {
                        ItemTypeID: string;
                        ItemID: string;
                        Quantity: number;
                    }[];
                }[];
                SingleItemOffersRemainingDurationInSeconds: number;
            }, {
                SingleItemOffers: string[];
                SingleItemStoreOffers: {
                    OfferID: string;
                    IsDirectPurchase: boolean;
                    StartDate: string;
                    Cost: Record<string, number>;
                    Rewards: {
                        ItemTypeID: string;
                        ItemID: string;
                        Quantity: number;
                    }[];
                }[];
                SingleItemOffersRemainingDurationInSeconds: number;
            }>;
            UpgradeCurrencyStore: z.ZodObject<{
                UpgradeCurrencyOffers: z.ZodArray<z.ZodObject<{
                    OfferID: z.ZodString;
                    StorefrontItemID: z.ZodString;
                    Offer: z.ZodObject<{
                        OfferID: z.ZodString;
                        IsDirectPurchase: z.ZodBoolean;
                        StartDate: z.ZodEffects<z.ZodString, Date, string>;
                        Cost: z.ZodRecord<z.ZodString, z.ZodNumber>;
                        Rewards: z.ZodArray<z.ZodObject<{
                            ItemTypeID: z.ZodString;
                            ItemID: z.ZodString;
                            Quantity: z.ZodNumber;
                        }, "strip", z.ZodTypeAny, {
                            ItemTypeID: string;
                            ItemID: string;
                            Quantity: number;
                        }, {
                            ItemTypeID: string;
                            ItemID: string;
                            Quantity: number;
                        }>, "many">;
                    }, "strip", z.ZodTypeAny, {
                        OfferID: string;
                        IsDirectPurchase: boolean;
                        StartDate: Date;
                        Cost: Record<string, number>;
                        Rewards: {
                            ItemTypeID: string;
                            ItemID: string;
                            Quantity: number;
                        }[];
                    }, {
                        OfferID: string;
                        IsDirectPurchase: boolean;
                        StartDate: string;
                        Cost: Record<string, number>;
                        Rewards: {
                            ItemTypeID: string;
                            ItemID: string;
                            Quantity: number;
                        }[];
                    }>;
                    DiscountedPercent: z.ZodNumber;
                }, "strip", z.ZodTypeAny, {
                    OfferID: string;
                    Offer: {
                        OfferID: string;
                        IsDirectPurchase: boolean;
                        StartDate: Date;
                        Cost: Record<string, number>;
                        Rewards: {
                            ItemTypeID: string;
                            ItemID: string;
                            Quantity: number;
                        }[];
                    };
                    StorefrontItemID: string;
                    DiscountedPercent: number;
                }, {
                    OfferID: string;
                    Offer: {
                        OfferID: string;
                        IsDirectPurchase: boolean;
                        StartDate: string;
                        Cost: Record<string, number>;
                        Rewards: {
                            ItemTypeID: string;
                            ItemID: string;
                            Quantity: number;
                        }[];
                    };
                    StorefrontItemID: string;
                    DiscountedPercent: number;
                }>, "many">;
            }, "strip", z.ZodTypeAny, {
                UpgradeCurrencyOffers: {
                    OfferID: string;
                    Offer: {
                        OfferID: string;
                        IsDirectPurchase: boolean;
                        StartDate: Date;
                        Cost: Record<string, number>;
                        Rewards: {
                            ItemTypeID: string;
                            ItemID: string;
                            Quantity: number;
                        }[];
                    };
                    StorefrontItemID: string;
                    DiscountedPercent: number;
                }[];
            }, {
                UpgradeCurrencyOffers: {
                    OfferID: string;
                    Offer: {
                        OfferID: string;
                        IsDirectPurchase: boolean;
                        StartDate: string;
                        Cost: Record<string, number>;
                        Rewards: {
                            ItemTypeID: string;
                            ItemID: string;
                            Quantity: number;
                        }[];
                    };
                    StorefrontItemID: string;
                    DiscountedPercent: number;
                }[];
            }>;
            AccessoryStore: z.ZodObject<{
                AccessoryStoreOffers: z.ZodArray<z.ZodObject<{
                    Offer: z.ZodObject<{
                        OfferID: z.ZodString;
                        IsDirectPurchase: z.ZodBoolean;
                        StartDate: z.ZodEffects<z.ZodString, Date, string>;
                        Cost: z.ZodRecord<z.ZodString, z.ZodNumber>;
                        Rewards: z.ZodArray<z.ZodObject<{
                            ItemTypeID: z.ZodString;
                            ItemID: z.ZodString;
                            Quantity: z.ZodNumber;
                        }, "strip", z.ZodTypeAny, {
                            ItemTypeID: string;
                            ItemID: string;
                            Quantity: number;
                        }, {
                            ItemTypeID: string;
                            ItemID: string;
                            Quantity: number;
                        }>, "many">;
                    }, "strip", z.ZodTypeAny, {
                        OfferID: string;
                        IsDirectPurchase: boolean;
                        StartDate: Date;
                        Cost: Record<string, number>;
                        Rewards: {
                            ItemTypeID: string;
                            ItemID: string;
                            Quantity: number;
                        }[];
                    }, {
                        OfferID: string;
                        IsDirectPurchase: boolean;
                        StartDate: string;
                        Cost: Record<string, number>;
                        Rewards: {
                            ItemTypeID: string;
                            ItemID: string;
                            Quantity: number;
                        }[];
                    }>;
                    ContractID: z.ZodString;
                }, "strip", z.ZodTypeAny, {
                    Offer: {
                        OfferID: string;
                        IsDirectPurchase: boolean;
                        StartDate: Date;
                        Cost: Record<string, number>;
                        Rewards: {
                            ItemTypeID: string;
                            ItemID: string;
                            Quantity: number;
                        }[];
                    };
                    ContractID: string;
                }, {
                    Offer: {
                        OfferID: string;
                        IsDirectPurchase: boolean;
                        StartDate: string;
                        Cost: Record<string, number>;
                        Rewards: {
                            ItemTypeID: string;
                            ItemID: string;
                            Quantity: number;
                        }[];
                    };
                    ContractID: string;
                }>, "many">;
                AccessoryStoreRemainingDurationInSeconds: z.ZodNumber;
                StorefrontID: z.ZodString;
            }, "strip", z.ZodTypeAny, {
                AccessoryStoreOffers: {
                    Offer: {
                        OfferID: string;
                        IsDirectPurchase: boolean;
                        StartDate: Date;
                        Cost: Record<string, number>;
                        Rewards: {
                            ItemTypeID: string;
                            ItemID: string;
                            Quantity: number;
                        }[];
                    };
                    ContractID: string;
                }[];
                AccessoryStoreRemainingDurationInSeconds: number;
                StorefrontID: string;
            }, {
                AccessoryStoreOffers: {
                    Offer: {
                        OfferID: string;
                        IsDirectPurchase: boolean;
                        StartDate: string;
                        Cost: Record<string, number>;
                        Rewards: {
                            ItemTypeID: string;
                            ItemID: string;
                            Quantity: number;
                        }[];
                    };
                    ContractID: string;
                }[];
                AccessoryStoreRemainingDurationInSeconds: number;
                StorefrontID: string;
            }>;
            BonusStore: z.ZodOptional<z.ZodObject<{
                BonusStoreOffers: z.ZodArray<z.ZodObject<{
                    BonusOfferID: z.ZodString;
                    Offer: z.ZodObject<{
                        OfferID: z.ZodString;
                        IsDirectPurchase: z.ZodBoolean;
                        StartDate: z.ZodEffects<z.ZodString, Date, string>;
                        Cost: z.ZodRecord<z.ZodString, z.ZodNumber>;
                        Rewards: z.ZodArray<z.ZodObject<{
                            ItemTypeID: z.ZodString;
                            ItemID: z.ZodString;
                            Quantity: z.ZodNumber;
                        }, "strip", z.ZodTypeAny, {
                            ItemTypeID: string;
                            ItemID: string;
                            Quantity: number;
                        }, {
                            ItemTypeID: string;
                            ItemID: string;
                            Quantity: number;
                        }>, "many">;
                    }, "strip", z.ZodTypeAny, {
                        OfferID: string;
                        IsDirectPurchase: boolean;
                        StartDate: Date;
                        Cost: Record<string, number>;
                        Rewards: {
                            ItemTypeID: string;
                            ItemID: string;
                            Quantity: number;
                        }[];
                    }, {
                        OfferID: string;
                        IsDirectPurchase: boolean;
                        StartDate: string;
                        Cost: Record<string, number>;
                        Rewards: {
                            ItemTypeID: string;
                            ItemID: string;
                            Quantity: number;
                        }[];
                    }>;
                    DiscountPercent: z.ZodNumber;
                    DiscountCosts: z.ZodRecord<z.ZodString, z.ZodNumber>;
                    IsSeen: z.ZodBoolean;
                }, "strip", z.ZodTypeAny, {
                    DiscountPercent: number;
                    Offer: {
                        OfferID: string;
                        IsDirectPurchase: boolean;
                        StartDate: Date;
                        Cost: Record<string, number>;
                        Rewards: {
                            ItemTypeID: string;
                            ItemID: string;
                            Quantity: number;
                        }[];
                    };
                    BonusOfferID: string;
                    DiscountCosts: Record<string, number>;
                    IsSeen: boolean;
                }, {
                    DiscountPercent: number;
                    Offer: {
                        OfferID: string;
                        IsDirectPurchase: boolean;
                        StartDate: string;
                        Cost: Record<string, number>;
                        Rewards: {
                            ItemTypeID: string;
                            ItemID: string;
                            Quantity: number;
                        }[];
                    };
                    BonusOfferID: string;
                    DiscountCosts: Record<string, number>;
                    IsSeen: boolean;
                }>, "many">;
                BonusStoreRemainingDurationInSeconds: z.ZodNumber;
            }, "strip", z.ZodTypeAny, {
                BonusStoreOffers: {
                    DiscountPercent: number;
                    Offer: {
                        OfferID: string;
                        IsDirectPurchase: boolean;
                        StartDate: Date;
                        Cost: Record<string, number>;
                        Rewards: {
                            ItemTypeID: string;
                            ItemID: string;
                            Quantity: number;
                        }[];
                    };
                    BonusOfferID: string;
                    DiscountCosts: Record<string, number>;
                    IsSeen: boolean;
                }[];
                BonusStoreRemainingDurationInSeconds: number;
            }, {
                BonusStoreOffers: {
                    DiscountPercent: number;
                    Offer: {
                        OfferID: string;
                        IsDirectPurchase: boolean;
                        StartDate: string;
                        Cost: Record<string, number>;
                        Rewards: {
                            ItemTypeID: string;
                            ItemID: string;
                            Quantity: number;
                        }[];
                    };
                    BonusOfferID: string;
                    DiscountCosts: Record<string, number>;
                    IsSeen: boolean;
                }[];
                BonusStoreRemainingDurationInSeconds: number;
            }>>;
        }, "strip", z.ZodTypeAny, {
            FeaturedBundle: {
                Bundle: {
                    Items: {
                        Item: {
                            ItemTypeID: string;
                            ItemID: string;
                            Amount: number;
                        };
                        CurrencyID: string;
                        BasePrice: number;
                        DiscountPercent: number;
                        DiscountedPrice: number;
                        IsPromoItem: boolean;
                    }[];
                    ID: string;
                    CurrencyID: string;
                    DataAssetID: string;
                    ItemOffers: {
                        DiscountPercent: number;
                        BundleItemOfferID: string;
                        Offer: {
                            OfferID: string;
                            IsDirectPurchase: boolean;
                            StartDate: Date;
                            Cost: Record<string, number>;
                            Rewards: {
                                ItemTypeID: string;
                                ItemID: string;
                                Quantity: number;
                            }[];
                        };
                        DiscountedCost: Record<string, number>;
                    }[] | null;
                    TotalBaseCost: Record<string, number> | null;
                    TotalDiscountedCost: Record<string, number> | null;
                    TotalDiscountPercent: number;
                    DurationRemainingInSeconds: number;
                    WholesaleOnly: boolean;
                };
                Bundles: {
                    Items: {
                        Item: {
                            ItemTypeID: string;
                            ItemID: string;
                            Amount: number;
                        };
                        CurrencyID: string;
                        BasePrice: number;
                        DiscountPercent: number;
                        DiscountedPrice: number;
                        IsPromoItem: boolean;
                    }[];
                    ID: string;
                    CurrencyID: string;
                    DataAssetID: string;
                    ItemOffers: {
                        DiscountPercent: number;
                        BundleItemOfferID: string;
                        Offer: {
                            OfferID: string;
                            IsDirectPurchase: boolean;
                            StartDate: Date;
                            Cost: Record<string, number>;
                            Rewards: {
                                ItemTypeID: string;
                                ItemID: string;
                                Quantity: number;
                            }[];
                        };
                        DiscountedCost: Record<string, number>;
                    }[] | null;
                    TotalBaseCost: Record<string, number> | null;
                    TotalDiscountedCost: Record<string, number> | null;
                    TotalDiscountPercent: number;
                    DurationRemainingInSeconds: number;
                    WholesaleOnly: boolean;
                }[];
                BundleRemainingDurationInSeconds: number;
            };
            SkinsPanelLayout: {
                SingleItemOffers: string[];
                SingleItemStoreOffers: {
                    OfferID: string;
                    IsDirectPurchase: boolean;
                    StartDate: Date;
                    Cost: Record<string, number>;
                    Rewards: {
                        ItemTypeID: string;
                        ItemID: string;
                        Quantity: number;
                    }[];
                }[];
                SingleItemOffersRemainingDurationInSeconds: number;
            };
            UpgradeCurrencyStore: {
                UpgradeCurrencyOffers: {
                    OfferID: string;
                    Offer: {
                        OfferID: string;
                        IsDirectPurchase: boolean;
                        StartDate: Date;
                        Cost: Record<string, number>;
                        Rewards: {
                            ItemTypeID: string;
                            ItemID: string;
                            Quantity: number;
                        }[];
                    };
                    StorefrontItemID: string;
                    DiscountedPercent: number;
                }[];
            };
            AccessoryStore: {
                AccessoryStoreOffers: {
                    Offer: {
                        OfferID: string;
                        IsDirectPurchase: boolean;
                        StartDate: Date;
                        Cost: Record<string, number>;
                        Rewards: {
                            ItemTypeID: string;
                            ItemID: string;
                            Quantity: number;
                        }[];
                    };
                    ContractID: string;
                }[];
                AccessoryStoreRemainingDurationInSeconds: number;
                StorefrontID: string;
            };
            BonusStore?: {
                BonusStoreOffers: {
                    DiscountPercent: number;
                    Offer: {
                        OfferID: string;
                        IsDirectPurchase: boolean;
                        StartDate: Date;
                        Cost: Record<string, number>;
                        Rewards: {
                            ItemTypeID: string;
                            ItemID: string;
                            Quantity: number;
                        }[];
                    };
                    BonusOfferID: string;
                    DiscountCosts: Record<string, number>;
                    IsSeen: boolean;
                }[];
                BonusStoreRemainingDurationInSeconds: number;
            } | undefined;
        }, {
            FeaturedBundle: {
                Bundle: {
                    Items: {
                        Item: {
                            ItemTypeID: string;
                            ItemID: string;
                            Amount: number;
                        };
                        CurrencyID: string;
                        BasePrice: number;
                        DiscountPercent: number;
                        DiscountedPrice: number;
                        IsPromoItem: boolean;
                    }[];
                    ID: string;
                    CurrencyID: string;
                    DataAssetID: string;
                    ItemOffers: {
                        DiscountPercent: number;
                        BundleItemOfferID: string;
                        Offer: {
                            OfferID: string;
                            IsDirectPurchase: boolean;
                            StartDate: string;
                            Cost: Record<string, number>;
                            Rewards: {
                                ItemTypeID: string;
                                ItemID: string;
                                Quantity: number;
                            }[];
                        };
                        DiscountedCost: Record<string, number>;
                    }[] | null;
                    TotalBaseCost: Record<string, number> | null;
                    TotalDiscountedCost: Record<string, number> | null;
                    TotalDiscountPercent: number;
                    DurationRemainingInSeconds: number;
                    WholesaleOnly: boolean;
                };
                Bundles: {
                    Items: {
                        Item: {
                            ItemTypeID: string;
                            ItemID: string;
                            Amount: number;
                        };
                        CurrencyID: string;
                        BasePrice: number;
                        DiscountPercent: number;
                        DiscountedPrice: number;
                        IsPromoItem: boolean;
                    }[];
                    ID: string;
                    CurrencyID: string;
                    DataAssetID: string;
                    ItemOffers: {
                        DiscountPercent: number;
                        BundleItemOfferID: string;
                        Offer: {
                            OfferID: string;
                            IsDirectPurchase: boolean;
                            StartDate: string;
                            Cost: Record<string, number>;
                            Rewards: {
                                ItemTypeID: string;
                                ItemID: string;
                                Quantity: number;
                            }[];
                        };
                        DiscountedCost: Record<string, number>;
                    }[] | null;
                    TotalBaseCost: Record<string, number> | null;
                    TotalDiscountedCost: Record<string, number> | null;
                    TotalDiscountPercent: number;
                    DurationRemainingInSeconds: number;
                    WholesaleOnly: boolean;
                }[];
                BundleRemainingDurationInSeconds: number;
            };
            SkinsPanelLayout: {
                SingleItemOffers: string[];
                SingleItemStoreOffers: {
                    OfferID: string;
                    IsDirectPurchase: boolean;
                    StartDate: string;
                    Cost: Record<string, number>;
                    Rewards: {
                        ItemTypeID: string;
                        ItemID: string;
                        Quantity: number;
                    }[];
                }[];
                SingleItemOffersRemainingDurationInSeconds: number;
            };
            UpgradeCurrencyStore: {
                UpgradeCurrencyOffers: {
                    OfferID: string;
                    Offer: {
                        OfferID: string;
                        IsDirectPurchase: boolean;
                        StartDate: string;
                        Cost: Record<string, number>;
                        Rewards: {
                            ItemTypeID: string;
                            ItemID: string;
                            Quantity: number;
                        }[];
                    };
                    StorefrontItemID: string;
                    DiscountedPercent: number;
                }[];
            };
            AccessoryStore: {
                AccessoryStoreOffers: {
                    Offer: {
                        OfferID: string;
                        IsDirectPurchase: boolean;
                        StartDate: string;
                        Cost: Record<string, number>;
                        Rewards: {
                            ItemTypeID: string;
                            ItemID: string;
                            Quantity: number;
                        }[];
                    };
                    ContractID: string;
                }[];
                AccessoryStoreRemainingDurationInSeconds: number;
                StorefrontID: string;
            };
            BonusStore?: {
                BonusStoreOffers: {
                    DiscountPercent: number;
                    Offer: {
                        OfferID: string;
                        IsDirectPurchase: boolean;
                        StartDate: string;
                        Cost: Record<string, number>;
                        Rewards: {
                            ItemTypeID: string;
                            ItemID: string;
                            Quantity: number;
                        }[];
                    };
                    BonusOfferID: string;
                    DiscountCosts: Record<string, number>;
                    IsSeen: boolean;
                }[];
                BonusStoreRemainingDurationInSeconds: number;
            } | undefined;
        }>;
    };
}, "type" | "name" | "url"> & {
    "~type": {
        readonly name: "Storefront";
        readonly description: "Get the currently available items in the store";
        readonly type: "pd";
        readonly url: "store/v2/storefront/:puuid";
        readonly responses: {
            readonly "200": z.ZodObject<{
                FeaturedBundle: z.ZodObject<{
                    Bundle: z.ZodObject<{
                        ID: z.ZodString;
                        DataAssetID: z.ZodString;
                        CurrencyID: z.ZodString;
                        Items: z.ZodArray<z.ZodObject<{
                            Item: z.ZodObject<{
                                ItemTypeID: z.ZodString;
                                ItemID: z.ZodString;
                                Amount: z.ZodNumber;
                            }, "strip", z.ZodTypeAny, {
                                ItemTypeID: string;
                                ItemID: string;
                                Amount: number;
                            }, {
                                ItemTypeID: string;
                                ItemID: string;
                                Amount: number;
                            }>;
                            BasePrice: z.ZodNumber;
                            CurrencyID: z.ZodString;
                            DiscountPercent: z.ZodNumber;
                            DiscountedPrice: z.ZodNumber;
                            IsPromoItem: z.ZodBoolean;
                        }, "strip", z.ZodTypeAny, {
                            Item: {
                                ItemTypeID: string;
                                ItemID: string;
                                Amount: number;
                            };
                            CurrencyID: string;
                            BasePrice: number;
                            DiscountPercent: number;
                            DiscountedPrice: number;
                            IsPromoItem: boolean;
                        }, {
                            Item: {
                                ItemTypeID: string;
                                ItemID: string;
                                Amount: number;
                            };
                            CurrencyID: string;
                            BasePrice: number;
                            DiscountPercent: number;
                            DiscountedPrice: number;
                            IsPromoItem: boolean;
                        }>, "many">;
                        ItemOffers: z.ZodNullable<z.ZodArray<z.ZodObject<{
                            BundleItemOfferID: z.ZodString;
                            Offer: z.ZodObject<{
                                OfferID: z.ZodString;
                                IsDirectPurchase: z.ZodBoolean;
                                StartDate: z.ZodEffects<z.ZodString, Date, string>;
                                Cost: z.ZodRecord<z.ZodString, z.ZodNumber>;
                                Rewards: z.ZodArray<z.ZodObject<{
                                    ItemTypeID: z.ZodString;
                                    ItemID: z.ZodString;
                                    Quantity: z.ZodNumber;
                                }, "strip", z.ZodTypeAny, {
                                    ItemTypeID: string;
                                    ItemID: string;
                                    Quantity: number;
                                }, {
                                    ItemTypeID: string;
                                    ItemID: string;
                                    Quantity: number;
                                }>, "many">;
                            }, "strip", z.ZodTypeAny, {
                                OfferID: string;
                                IsDirectPurchase: boolean;
                                StartDate: Date;
                                Cost: Record<string, number>;
                                Rewards: {
                                    ItemTypeID: string;
                                    ItemID: string;
                                    Quantity: number;
                                }[];
                            }, {
                                OfferID: string;
                                IsDirectPurchase: boolean;
                                StartDate: string;
                                Cost: Record<string, number>;
                                Rewards: {
                                    ItemTypeID: string;
                                    ItemID: string;
                                    Quantity: number;
                                }[];
                            }>;
                            DiscountPercent: z.ZodNumber;
                            DiscountedCost: z.ZodRecord<z.ZodString, z.ZodNumber>;
                        }, "strip", z.ZodTypeAny, {
                            DiscountPercent: number;
                            BundleItemOfferID: string;
                            Offer: {
                                OfferID: string;
                                IsDirectPurchase: boolean;
                                StartDate: Date;
                                Cost: Record<string, number>;
                                Rewards: {
                                    ItemTypeID: string;
                                    ItemID: string;
                                    Quantity: number;
                                }[];
                            };
                            DiscountedCost: Record<string, number>;
                        }, {
                            DiscountPercent: number;
                            BundleItemOfferID: string;
                            Offer: {
                                OfferID: string;
                                IsDirectPurchase: boolean;
                                StartDate: string;
                                Cost: Record<string, number>;
                                Rewards: {
                                    ItemTypeID: string;
                                    ItemID: string;
                                    Quantity: number;
                                }[];
                            };
                            DiscountedCost: Record<string, number>;
                        }>, "many">>;
                        TotalBaseCost: z.ZodNullable<z.ZodRecord<z.ZodString, z.ZodNumber>>;
                        TotalDiscountedCost: z.ZodNullable<z.ZodRecord<z.ZodString, z.ZodNumber>>;
                        TotalDiscountPercent: z.ZodNumber;
                        DurationRemainingInSeconds: z.ZodNumber;
                        WholesaleOnly: z.ZodBoolean;
                    }, "strip", z.ZodTypeAny, {
                        Items: {
                            Item: {
                                ItemTypeID: string;
                                ItemID: string;
                                Amount: number;
                            };
                            CurrencyID: string;
                            BasePrice: number;
                            DiscountPercent: number;
                            DiscountedPrice: number;
                            IsPromoItem: boolean;
                        }[];
                        ID: string;
                        CurrencyID: string;
                        DataAssetID: string;
                        ItemOffers: {
                            DiscountPercent: number;
                            BundleItemOfferID: string;
                            Offer: {
                                OfferID: string;
                                IsDirectPurchase: boolean;
                                StartDate: Date;
                                Cost: Record<string, number>;
                                Rewards: {
                                    ItemTypeID: string;
                                    ItemID: string;
                                    Quantity: number;
                                }[];
                            };
                            DiscountedCost: Record<string, number>;
                        }[] | null;
                        TotalBaseCost: Record<string, number> | null;
                        TotalDiscountedCost: Record<string, number> | null;
                        TotalDiscountPercent: number;
                        DurationRemainingInSeconds: number;
                        WholesaleOnly: boolean;
                    }, {
                        Items: {
                            Item: {
                                ItemTypeID: string;
                                ItemID: string;
                                Amount: number;
                            };
                            CurrencyID: string;
                            BasePrice: number;
                            DiscountPercent: number;
                            DiscountedPrice: number;
                            IsPromoItem: boolean;
                        }[];
                        ID: string;
                        CurrencyID: string;
                        DataAssetID: string;
                        ItemOffers: {
                            DiscountPercent: number;
                            BundleItemOfferID: string;
                            Offer: {
                                OfferID: string;
                                IsDirectPurchase: boolean;
                                StartDate: string;
                                Cost: Record<string, number>;
                                Rewards: {
                                    ItemTypeID: string;
                                    ItemID: string;
                                    Quantity: number;
                                }[];
                            };
                            DiscountedCost: Record<string, number>;
                        }[] | null;
                        TotalBaseCost: Record<string, number> | null;
                        TotalDiscountedCost: Record<string, number> | null;
                        TotalDiscountPercent: number;
                        DurationRemainingInSeconds: number;
                        WholesaleOnly: boolean;
                    }>;
                    Bundles: z.ZodArray<z.ZodObject<{
                        ID: z.ZodString;
                        DataAssetID: z.ZodString;
                        CurrencyID: z.ZodString;
                        Items: z.ZodArray<z.ZodObject<{
                            Item: z.ZodObject<{
                                ItemTypeID: z.ZodString;
                                ItemID: z.ZodString;
                                Amount: z.ZodNumber;
                            }, "strip", z.ZodTypeAny, {
                                ItemTypeID: string;
                                ItemID: string;
                                Amount: number;
                            }, {
                                ItemTypeID: string;
                                ItemID: string;
                                Amount: number;
                            }>;
                            BasePrice: z.ZodNumber;
                            CurrencyID: z.ZodString;
                            DiscountPercent: z.ZodNumber;
                            DiscountedPrice: z.ZodNumber;
                            IsPromoItem: z.ZodBoolean;
                        }, "strip", z.ZodTypeAny, {
                            Item: {
                                ItemTypeID: string;
                                ItemID: string;
                                Amount: number;
                            };
                            CurrencyID: string;
                            BasePrice: number;
                            DiscountPercent: number;
                            DiscountedPrice: number;
                            IsPromoItem: boolean;
                        }, {
                            Item: {
                                ItemTypeID: string;
                                ItemID: string;
                                Amount: number;
                            };
                            CurrencyID: string;
                            BasePrice: number;
                            DiscountPercent: number;
                            DiscountedPrice: number;
                            IsPromoItem: boolean;
                        }>, "many">;
                        ItemOffers: z.ZodNullable<z.ZodArray<z.ZodObject<{
                            BundleItemOfferID: z.ZodString;
                            Offer: z.ZodObject<{
                                OfferID: z.ZodString;
                                IsDirectPurchase: z.ZodBoolean;
                                StartDate: z.ZodEffects<z.ZodString, Date, string>;
                                Cost: z.ZodRecord<z.ZodString, z.ZodNumber>;
                                Rewards: z.ZodArray<z.ZodObject<{
                                    ItemTypeID: z.ZodString;
                                    ItemID: z.ZodString;
                                    Quantity: z.ZodNumber;
                                }, "strip", z.ZodTypeAny, {
                                    ItemTypeID: string;
                                    ItemID: string;
                                    Quantity: number;
                                }, {
                                    ItemTypeID: string;
                                    ItemID: string;
                                    Quantity: number;
                                }>, "many">;
                            }, "strip", z.ZodTypeAny, {
                                OfferID: string;
                                IsDirectPurchase: boolean;
                                StartDate: Date;
                                Cost: Record<string, number>;
                                Rewards: {
                                    ItemTypeID: string;
                                    ItemID: string;
                                    Quantity: number;
                                }[];
                            }, {
                                OfferID: string;
                                IsDirectPurchase: boolean;
                                StartDate: string;
                                Cost: Record<string, number>;
                                Rewards: {
                                    ItemTypeID: string;
                                    ItemID: string;
                                    Quantity: number;
                                }[];
                            }>;
                            DiscountPercent: z.ZodNumber;
                            DiscountedCost: z.ZodRecord<z.ZodString, z.ZodNumber>;
                        }, "strip", z.ZodTypeAny, {
                            DiscountPercent: number;
                            BundleItemOfferID: string;
                            Offer: {
                                OfferID: string;
                                IsDirectPurchase: boolean;
                                StartDate: Date;
                                Cost: Record<string, number>;
                                Rewards: {
                                    ItemTypeID: string;
                                    ItemID: string;
                                    Quantity: number;
                                }[];
                            };
                            DiscountedCost: Record<string, number>;
                        }, {
                            DiscountPercent: number;
                            BundleItemOfferID: string;
                            Offer: {
                                OfferID: string;
                                IsDirectPurchase: boolean;
                                StartDate: string;
                                Cost: Record<string, number>;
                                Rewards: {
                                    ItemTypeID: string;
                                    ItemID: string;
                                    Quantity: number;
                                }[];
                            };
                            DiscountedCost: Record<string, number>;
                        }>, "many">>;
                        TotalBaseCost: z.ZodNullable<z.ZodRecord<z.ZodString, z.ZodNumber>>;
                        TotalDiscountedCost: z.ZodNullable<z.ZodRecord<z.ZodString, z.ZodNumber>>;
                        TotalDiscountPercent: z.ZodNumber;
                        DurationRemainingInSeconds: z.ZodNumber;
                        WholesaleOnly: z.ZodBoolean;
                    }, "strip", z.ZodTypeAny, {
                        Items: {
                            Item: {
                                ItemTypeID: string;
                                ItemID: string;
                                Amount: number;
                            };
                            CurrencyID: string;
                            BasePrice: number;
                            DiscountPercent: number;
                            DiscountedPrice: number;
                            IsPromoItem: boolean;
                        }[];
                        ID: string;
                        CurrencyID: string;
                        DataAssetID: string;
                        ItemOffers: {
                            DiscountPercent: number;
                            BundleItemOfferID: string;
                            Offer: {
                                OfferID: string;
                                IsDirectPurchase: boolean;
                                StartDate: Date;
                                Cost: Record<string, number>;
                                Rewards: {
                                    ItemTypeID: string;
                                    ItemID: string;
                                    Quantity: number;
                                }[];
                            };
                            DiscountedCost: Record<string, number>;
                        }[] | null;
                        TotalBaseCost: Record<string, number> | null;
                        TotalDiscountedCost: Record<string, number> | null;
                        TotalDiscountPercent: number;
                        DurationRemainingInSeconds: number;
                        WholesaleOnly: boolean;
                    }, {
                        Items: {
                            Item: {
                                ItemTypeID: string;
                                ItemID: string;
                                Amount: number;
                            };
                            CurrencyID: string;
                            BasePrice: number;
                            DiscountPercent: number;
                            DiscountedPrice: number;
                            IsPromoItem: boolean;
                        }[];
                        ID: string;
                        CurrencyID: string;
                        DataAssetID: string;
                        ItemOffers: {
                            DiscountPercent: number;
                            BundleItemOfferID: string;
                            Offer: {
                                OfferID: string;
                                IsDirectPurchase: boolean;
                                StartDate: string;
                                Cost: Record<string, number>;
                                Rewards: {
                                    ItemTypeID: string;
                                    ItemID: string;
                                    Quantity: number;
                                }[];
                            };
                            DiscountedCost: Record<string, number>;
                        }[] | null;
                        TotalBaseCost: Record<string, number> | null;
                        TotalDiscountedCost: Record<string, number> | null;
                        TotalDiscountPercent: number;
                        DurationRemainingInSeconds: number;
                        WholesaleOnly: boolean;
                    }>, "many">;
                    BundleRemainingDurationInSeconds: z.ZodNumber;
                }, "strip", z.ZodTypeAny, {
                    Bundle: {
                        Items: {
                            Item: {
                                ItemTypeID: string;
                                ItemID: string;
                                Amount: number;
                            };
                            CurrencyID: string;
                            BasePrice: number;
                            DiscountPercent: number;
                            DiscountedPrice: number;
                            IsPromoItem: boolean;
                        }[];
                        ID: string;
                        CurrencyID: string;
                        DataAssetID: string;
                        ItemOffers: {
                            DiscountPercent: number;
                            BundleItemOfferID: string;
                            Offer: {
                                OfferID: string;
                                IsDirectPurchase: boolean;
                                StartDate: Date;
                                Cost: Record<string, number>;
                                Rewards: {
                                    ItemTypeID: string;
                                    ItemID: string;
                                    Quantity: number;
                                }[];
                            };
                            DiscountedCost: Record<string, number>;
                        }[] | null;
                        TotalBaseCost: Record<string, number> | null;
                        TotalDiscountedCost: Record<string, number> | null;
                        TotalDiscountPercent: number;
                        DurationRemainingInSeconds: number;
                        WholesaleOnly: boolean;
                    };
                    Bundles: {
                        Items: {
                            Item: {
                                ItemTypeID: string;
                                ItemID: string;
                                Amount: number;
                            };
                            CurrencyID: string;
                            BasePrice: number;
                            DiscountPercent: number;
                            DiscountedPrice: number;
                            IsPromoItem: boolean;
                        }[];
                        ID: string;
                        CurrencyID: string;
                        DataAssetID: string;
                        ItemOffers: {
                            DiscountPercent: number;
                            BundleItemOfferID: string;
                            Offer: {
                                OfferID: string;
                                IsDirectPurchase: boolean;
                                StartDate: Date;
                                Cost: Record<string, number>;
                                Rewards: {
                                    ItemTypeID: string;
                                    ItemID: string;
                                    Quantity: number;
                                }[];
                            };
                            DiscountedCost: Record<string, number>;
                        }[] | null;
                        TotalBaseCost: Record<string, number> | null;
                        TotalDiscountedCost: Record<string, number> | null;
                        TotalDiscountPercent: number;
                        DurationRemainingInSeconds: number;
                        WholesaleOnly: boolean;
                    }[];
                    BundleRemainingDurationInSeconds: number;
                }, {
                    Bundle: {
                        Items: {
                            Item: {
                                ItemTypeID: string;
                                ItemID: string;
                                Amount: number;
                            };
                            CurrencyID: string;
                            BasePrice: number;
                            DiscountPercent: number;
                            DiscountedPrice: number;
                            IsPromoItem: boolean;
                        }[];
                        ID: string;
                        CurrencyID: string;
                        DataAssetID: string;
                        ItemOffers: {
                            DiscountPercent: number;
                            BundleItemOfferID: string;
                            Offer: {
                                OfferID: string;
                                IsDirectPurchase: boolean;
                                StartDate: string;
                                Cost: Record<string, number>;
                                Rewards: {
                                    ItemTypeID: string;
                                    ItemID: string;
                                    Quantity: number;
                                }[];
                            };
                            DiscountedCost: Record<string, number>;
                        }[] | null;
                        TotalBaseCost: Record<string, number> | null;
                        TotalDiscountedCost: Record<string, number> | null;
                        TotalDiscountPercent: number;
                        DurationRemainingInSeconds: number;
                        WholesaleOnly: boolean;
                    };
                    Bundles: {
                        Items: {
                            Item: {
                                ItemTypeID: string;
                                ItemID: string;
                                Amount: number;
                            };
                            CurrencyID: string;
                            BasePrice: number;
                            DiscountPercent: number;
                            DiscountedPrice: number;
                            IsPromoItem: boolean;
                        }[];
                        ID: string;
                        CurrencyID: string;
                        DataAssetID: string;
                        ItemOffers: {
                            DiscountPercent: number;
                            BundleItemOfferID: string;
                            Offer: {
                                OfferID: string;
                                IsDirectPurchase: boolean;
                                StartDate: string;
                                Cost: Record<string, number>;
                                Rewards: {
                                    ItemTypeID: string;
                                    ItemID: string;
                                    Quantity: number;
                                }[];
                            };
                            DiscountedCost: Record<string, number>;
                        }[] | null;
                        TotalBaseCost: Record<string, number> | null;
                        TotalDiscountedCost: Record<string, number> | null;
                        TotalDiscountPercent: number;
                        DurationRemainingInSeconds: number;
                        WholesaleOnly: boolean;
                    }[];
                    BundleRemainingDurationInSeconds: number;
                }>;
                SkinsPanelLayout: z.ZodObject<{
                    SingleItemOffers: z.ZodArray<z.ZodString, "many">;
                    SingleItemStoreOffers: z.ZodArray<z.ZodObject<{
                        OfferID: z.ZodString;
                        IsDirectPurchase: z.ZodBoolean;
                        StartDate: z.ZodEffects<z.ZodString, Date, string>;
                        Cost: z.ZodRecord<z.ZodString, z.ZodNumber>;
                        Rewards: z.ZodArray<z.ZodObject<{
                            ItemTypeID: z.ZodString;
                            ItemID: z.ZodString;
                            Quantity: z.ZodNumber;
                        }, "strip", z.ZodTypeAny, {
                            ItemTypeID: string;
                            ItemID: string;
                            Quantity: number;
                        }, {
                            ItemTypeID: string;
                            ItemID: string;
                            Quantity: number;
                        }>, "many">;
                    }, "strip", z.ZodTypeAny, {
                        OfferID: string;
                        IsDirectPurchase: boolean;
                        StartDate: Date;
                        Cost: Record<string, number>;
                        Rewards: {
                            ItemTypeID: string;
                            ItemID: string;
                            Quantity: number;
                        }[];
                    }, {
                        OfferID: string;
                        IsDirectPurchase: boolean;
                        StartDate: string;
                        Cost: Record<string, number>;
                        Rewards: {
                            ItemTypeID: string;
                            ItemID: string;
                            Quantity: number;
                        }[];
                    }>, "many">;
                    SingleItemOffersRemainingDurationInSeconds: z.ZodNumber;
                }, "strip", z.ZodTypeAny, {
                    SingleItemOffers: string[];
                    SingleItemStoreOffers: {
                        OfferID: string;
                        IsDirectPurchase: boolean;
                        StartDate: Date;
                        Cost: Record<string, number>;
                        Rewards: {
                            ItemTypeID: string;
                            ItemID: string;
                            Quantity: number;
                        }[];
                    }[];
                    SingleItemOffersRemainingDurationInSeconds: number;
                }, {
                    SingleItemOffers: string[];
                    SingleItemStoreOffers: {
                        OfferID: string;
                        IsDirectPurchase: boolean;
                        StartDate: string;
                        Cost: Record<string, number>;
                        Rewards: {
                            ItemTypeID: string;
                            ItemID: string;
                            Quantity: number;
                        }[];
                    }[];
                    SingleItemOffersRemainingDurationInSeconds: number;
                }>;
                UpgradeCurrencyStore: z.ZodObject<{
                    UpgradeCurrencyOffers: z.ZodArray<z.ZodObject<{
                        OfferID: z.ZodString;
                        StorefrontItemID: z.ZodString;
                        Offer: z.ZodObject<{
                            OfferID: z.ZodString;
                            IsDirectPurchase: z.ZodBoolean;
                            StartDate: z.ZodEffects<z.ZodString, Date, string>;
                            Cost: z.ZodRecord<z.ZodString, z.ZodNumber>;
                            Rewards: z.ZodArray<z.ZodObject<{
                                ItemTypeID: z.ZodString;
                                ItemID: z.ZodString;
                                Quantity: z.ZodNumber;
                            }, "strip", z.ZodTypeAny, {
                                ItemTypeID: string;
                                ItemID: string;
                                Quantity: number;
                            }, {
                                ItemTypeID: string;
                                ItemID: string;
                                Quantity: number;
                            }>, "many">;
                        }, "strip", z.ZodTypeAny, {
                            OfferID: string;
                            IsDirectPurchase: boolean;
                            StartDate: Date;
                            Cost: Record<string, number>;
                            Rewards: {
                                ItemTypeID: string;
                                ItemID: string;
                                Quantity: number;
                            }[];
                        }, {
                            OfferID: string;
                            IsDirectPurchase: boolean;
                            StartDate: string;
                            Cost: Record<string, number>;
                            Rewards: {
                                ItemTypeID: string;
                                ItemID: string;
                                Quantity: number;
                            }[];
                        }>;
                        DiscountedPercent: z.ZodNumber;
                    }, "strip", z.ZodTypeAny, {
                        OfferID: string;
                        Offer: {
                            OfferID: string;
                            IsDirectPurchase: boolean;
                            StartDate: Date;
                            Cost: Record<string, number>;
                            Rewards: {
                                ItemTypeID: string;
                                ItemID: string;
                                Quantity: number;
                            }[];
                        };
                        StorefrontItemID: string;
                        DiscountedPercent: number;
                    }, {
                        OfferID: string;
                        Offer: {
                            OfferID: string;
                            IsDirectPurchase: boolean;
                            StartDate: string;
                            Cost: Record<string, number>;
                            Rewards: {
                                ItemTypeID: string;
                                ItemID: string;
                                Quantity: number;
                            }[];
                        };
                        StorefrontItemID: string;
                        DiscountedPercent: number;
                    }>, "many">;
                }, "strip", z.ZodTypeAny, {
                    UpgradeCurrencyOffers: {
                        OfferID: string;
                        Offer: {
                            OfferID: string;
                            IsDirectPurchase: boolean;
                            StartDate: Date;
                            Cost: Record<string, number>;
                            Rewards: {
                                ItemTypeID: string;
                                ItemID: string;
                                Quantity: number;
                            }[];
                        };
                        StorefrontItemID: string;
                        DiscountedPercent: number;
                    }[];
                }, {
                    UpgradeCurrencyOffers: {
                        OfferID: string;
                        Offer: {
                            OfferID: string;
                            IsDirectPurchase: boolean;
                            StartDate: string;
                            Cost: Record<string, number>;
                            Rewards: {
                                ItemTypeID: string;
                                ItemID: string;
                                Quantity: number;
                            }[];
                        };
                        StorefrontItemID: string;
                        DiscountedPercent: number;
                    }[];
                }>;
                AccessoryStore: z.ZodObject<{
                    AccessoryStoreOffers: z.ZodArray<z.ZodObject<{
                        Offer: z.ZodObject<{
                            OfferID: z.ZodString;
                            IsDirectPurchase: z.ZodBoolean;
                            StartDate: z.ZodEffects<z.ZodString, Date, string>;
                            Cost: z.ZodRecord<z.ZodString, z.ZodNumber>;
                            Rewards: z.ZodArray<z.ZodObject<{
                                ItemTypeID: z.ZodString;
                                ItemID: z.ZodString;
                                Quantity: z.ZodNumber;
                            }, "strip", z.ZodTypeAny, {
                                ItemTypeID: string;
                                ItemID: string;
                                Quantity: number;
                            }, {
                                ItemTypeID: string;
                                ItemID: string;
                                Quantity: number;
                            }>, "many">;
                        }, "strip", z.ZodTypeAny, {
                            OfferID: string;
                            IsDirectPurchase: boolean;
                            StartDate: Date;
                            Cost: Record<string, number>;
                            Rewards: {
                                ItemTypeID: string;
                                ItemID: string;
                                Quantity: number;
                            }[];
                        }, {
                            OfferID: string;
                            IsDirectPurchase: boolean;
                            StartDate: string;
                            Cost: Record<string, number>;
                            Rewards: {
                                ItemTypeID: string;
                                ItemID: string;
                                Quantity: number;
                            }[];
                        }>;
                        ContractID: z.ZodString;
                    }, "strip", z.ZodTypeAny, {
                        Offer: {
                            OfferID: string;
                            IsDirectPurchase: boolean;
                            StartDate: Date;
                            Cost: Record<string, number>;
                            Rewards: {
                                ItemTypeID: string;
                                ItemID: string;
                                Quantity: number;
                            }[];
                        };
                        ContractID: string;
                    }, {
                        Offer: {
                            OfferID: string;
                            IsDirectPurchase: boolean;
                            StartDate: string;
                            Cost: Record<string, number>;
                            Rewards: {
                                ItemTypeID: string;
                                ItemID: string;
                                Quantity: number;
                            }[];
                        };
                        ContractID: string;
                    }>, "many">;
                    AccessoryStoreRemainingDurationInSeconds: z.ZodNumber;
                    StorefrontID: z.ZodString;
                }, "strip", z.ZodTypeAny, {
                    AccessoryStoreOffers: {
                        Offer: {
                            OfferID: string;
                            IsDirectPurchase: boolean;
                            StartDate: Date;
                            Cost: Record<string, number>;
                            Rewards: {
                                ItemTypeID: string;
                                ItemID: string;
                                Quantity: number;
                            }[];
                        };
                        ContractID: string;
                    }[];
                    AccessoryStoreRemainingDurationInSeconds: number;
                    StorefrontID: string;
                }, {
                    AccessoryStoreOffers: {
                        Offer: {
                            OfferID: string;
                            IsDirectPurchase: boolean;
                            StartDate: string;
                            Cost: Record<string, number>;
                            Rewards: {
                                ItemTypeID: string;
                                ItemID: string;
                                Quantity: number;
                            }[];
                        };
                        ContractID: string;
                    }[];
                    AccessoryStoreRemainingDurationInSeconds: number;
                    StorefrontID: string;
                }>;
                BonusStore: z.ZodOptional<z.ZodObject<{
                    BonusStoreOffers: z.ZodArray<z.ZodObject<{
                        BonusOfferID: z.ZodString;
                        Offer: z.ZodObject<{
                            OfferID: z.ZodString;
                            IsDirectPurchase: z.ZodBoolean;
                            StartDate: z.ZodEffects<z.ZodString, Date, string>;
                            Cost: z.ZodRecord<z.ZodString, z.ZodNumber>;
                            Rewards: z.ZodArray<z.ZodObject<{
                                ItemTypeID: z.ZodString;
                                ItemID: z.ZodString;
                                Quantity: z.ZodNumber;
                            }, "strip", z.ZodTypeAny, {
                                ItemTypeID: string;
                                ItemID: string;
                                Quantity: number;
                            }, {
                                ItemTypeID: string;
                                ItemID: string;
                                Quantity: number;
                            }>, "many">;
                        }, "strip", z.ZodTypeAny, {
                            OfferID: string;
                            IsDirectPurchase: boolean;
                            StartDate: Date;
                            Cost: Record<string, number>;
                            Rewards: {
                                ItemTypeID: string;
                                ItemID: string;
                                Quantity: number;
                            }[];
                        }, {
                            OfferID: string;
                            IsDirectPurchase: boolean;
                            StartDate: string;
                            Cost: Record<string, number>;
                            Rewards: {
                                ItemTypeID: string;
                                ItemID: string;
                                Quantity: number;
                            }[];
                        }>;
                        DiscountPercent: z.ZodNumber;
                        DiscountCosts: z.ZodRecord<z.ZodString, z.ZodNumber>;
                        IsSeen: z.ZodBoolean;
                    }, "strip", z.ZodTypeAny, {
                        DiscountPercent: number;
                        Offer: {
                            OfferID: string;
                            IsDirectPurchase: boolean;
                            StartDate: Date;
                            Cost: Record<string, number>;
                            Rewards: {
                                ItemTypeID: string;
                                ItemID: string;
                                Quantity: number;
                            }[];
                        };
                        BonusOfferID: string;
                        DiscountCosts: Record<string, number>;
                        IsSeen: boolean;
                    }, {
                        DiscountPercent: number;
                        Offer: {
                            OfferID: string;
                            IsDirectPurchase: boolean;
                            StartDate: string;
                            Cost: Record<string, number>;
                            Rewards: {
                                ItemTypeID: string;
                                ItemID: string;
                                Quantity: number;
                            }[];
                        };
                        BonusOfferID: string;
                        DiscountCosts: Record<string, number>;
                        IsSeen: boolean;
                    }>, "many">;
                    BonusStoreRemainingDurationInSeconds: z.ZodNumber;
                }, "strip", z.ZodTypeAny, {
                    BonusStoreOffers: {
                        DiscountPercent: number;
                        Offer: {
                            OfferID: string;
                            IsDirectPurchase: boolean;
                            StartDate: Date;
                            Cost: Record<string, number>;
                            Rewards: {
                                ItemTypeID: string;
                                ItemID: string;
                                Quantity: number;
                            }[];
                        };
                        BonusOfferID: string;
                        DiscountCosts: Record<string, number>;
                        IsSeen: boolean;
                    }[];
                    BonusStoreRemainingDurationInSeconds: number;
                }, {
                    BonusStoreOffers: {
                        DiscountPercent: number;
                        Offer: {
                            OfferID: string;
                            IsDirectPurchase: boolean;
                            StartDate: string;
                            Cost: Record<string, number>;
                            Rewards: {
                                ItemTypeID: string;
                                ItemID: string;
                                Quantity: number;
                            }[];
                        };
                        BonusOfferID: string;
                        DiscountCosts: Record<string, number>;
                        IsSeen: boolean;
                    }[];
                    BonusStoreRemainingDurationInSeconds: number;
                }>>;
            }, "strip", z.ZodTypeAny, {
                FeaturedBundle: {
                    Bundle: {
                        Items: {
                            Item: {
                                ItemTypeID: string;
                                ItemID: string;
                                Amount: number;
                            };
                            CurrencyID: string;
                            BasePrice: number;
                            DiscountPercent: number;
                            DiscountedPrice: number;
                            IsPromoItem: boolean;
                        }[];
                        ID: string;
                        CurrencyID: string;
                        DataAssetID: string;
                        ItemOffers: {
                            DiscountPercent: number;
                            BundleItemOfferID: string;
                            Offer: {
                                OfferID: string;
                                IsDirectPurchase: boolean;
                                StartDate: Date;
                                Cost: Record<string, number>;
                                Rewards: {
                                    ItemTypeID: string;
                                    ItemID: string;
                                    Quantity: number;
                                }[];
                            };
                            DiscountedCost: Record<string, number>;
                        }[] | null;
                        TotalBaseCost: Record<string, number> | null;
                        TotalDiscountedCost: Record<string, number> | null;
                        TotalDiscountPercent: number;
                        DurationRemainingInSeconds: number;
                        WholesaleOnly: boolean;
                    };
                    Bundles: {
                        Items: {
                            Item: {
                                ItemTypeID: string;
                                ItemID: string;
                                Amount: number;
                            };
                            CurrencyID: string;
                            BasePrice: number;
                            DiscountPercent: number;
                            DiscountedPrice: number;
                            IsPromoItem: boolean;
                        }[];
                        ID: string;
                        CurrencyID: string;
                        DataAssetID: string;
                        ItemOffers: {
                            DiscountPercent: number;
                            BundleItemOfferID: string;
                            Offer: {
                                OfferID: string;
                                IsDirectPurchase: boolean;
                                StartDate: Date;
                                Cost: Record<string, number>;
                                Rewards: {
                                    ItemTypeID: string;
                                    ItemID: string;
                                    Quantity: number;
                                }[];
                            };
                            DiscountedCost: Record<string, number>;
                        }[] | null;
                        TotalBaseCost: Record<string, number> | null;
                        TotalDiscountedCost: Record<string, number> | null;
                        TotalDiscountPercent: number;
                        DurationRemainingInSeconds: number;
                        WholesaleOnly: boolean;
                    }[];
                    BundleRemainingDurationInSeconds: number;
                };
                SkinsPanelLayout: {
                    SingleItemOffers: string[];
                    SingleItemStoreOffers: {
                        OfferID: string;
                        IsDirectPurchase: boolean;
                        StartDate: Date;
                        Cost: Record<string, number>;
                        Rewards: {
                            ItemTypeID: string;
                            ItemID: string;
                            Quantity: number;
                        }[];
                    }[];
                    SingleItemOffersRemainingDurationInSeconds: number;
                };
                UpgradeCurrencyStore: {
                    UpgradeCurrencyOffers: {
                        OfferID: string;
                        Offer: {
                            OfferID: string;
                            IsDirectPurchase: boolean;
                            StartDate: Date;
                            Cost: Record<string, number>;
                            Rewards: {
                                ItemTypeID: string;
                                ItemID: string;
                                Quantity: number;
                            }[];
                        };
                        StorefrontItemID: string;
                        DiscountedPercent: number;
                    }[];
                };
                AccessoryStore: {
                    AccessoryStoreOffers: {
                        Offer: {
                            OfferID: string;
                            IsDirectPurchase: boolean;
                            StartDate: Date;
                            Cost: Record<string, number>;
                            Rewards: {
                                ItemTypeID: string;
                                ItemID: string;
                                Quantity: number;
                            }[];
                        };
                        ContractID: string;
                    }[];
                    AccessoryStoreRemainingDurationInSeconds: number;
                    StorefrontID: string;
                };
                BonusStore?: {
                    BonusStoreOffers: {
                        DiscountPercent: number;
                        Offer: {
                            OfferID: string;
                            IsDirectPurchase: boolean;
                            StartDate: Date;
                            Cost: Record<string, number>;
                            Rewards: {
                                ItemTypeID: string;
                                ItemID: string;
                                Quantity: number;
                            }[];
                        };
                        BonusOfferID: string;
                        DiscountCosts: Record<string, number>;
                        IsSeen: boolean;
                    }[];
                    BonusStoreRemainingDurationInSeconds: number;
                } | undefined;
            }, {
                FeaturedBundle: {
                    Bundle: {
                        Items: {
                            Item: {
                                ItemTypeID: string;
                                ItemID: string;
                                Amount: number;
                            };
                            CurrencyID: string;
                            BasePrice: number;
                            DiscountPercent: number;
                            DiscountedPrice: number;
                            IsPromoItem: boolean;
                        }[];
                        ID: string;
                        CurrencyID: string;
                        DataAssetID: string;
                        ItemOffers: {
                            DiscountPercent: number;
                            BundleItemOfferID: string;
                            Offer: {
                                OfferID: string;
                                IsDirectPurchase: boolean;
                                StartDate: string;
                                Cost: Record<string, number>;
                                Rewards: {
                                    ItemTypeID: string;
                                    ItemID: string;
                                    Quantity: number;
                                }[];
                            };
                            DiscountedCost: Record<string, number>;
                        }[] | null;
                        TotalBaseCost: Record<string, number> | null;
                        TotalDiscountedCost: Record<string, number> | null;
                        TotalDiscountPercent: number;
                        DurationRemainingInSeconds: number;
                        WholesaleOnly: boolean;
                    };
                    Bundles: {
                        Items: {
                            Item: {
                                ItemTypeID: string;
                                ItemID: string;
                                Amount: number;
                            };
                            CurrencyID: string;
                            BasePrice: number;
                            DiscountPercent: number;
                            DiscountedPrice: number;
                            IsPromoItem: boolean;
                        }[];
                        ID: string;
                        CurrencyID: string;
                        DataAssetID: string;
                        ItemOffers: {
                            DiscountPercent: number;
                            BundleItemOfferID: string;
                            Offer: {
                                OfferID: string;
                                IsDirectPurchase: boolean;
                                StartDate: string;
                                Cost: Record<string, number>;
                                Rewards: {
                                    ItemTypeID: string;
                                    ItemID: string;
                                    Quantity: number;
                                }[];
                            };
                            DiscountedCost: Record<string, number>;
                        }[] | null;
                        TotalBaseCost: Record<string, number> | null;
                        TotalDiscountedCost: Record<string, number> | null;
                        TotalDiscountPercent: number;
                        DurationRemainingInSeconds: number;
                        WholesaleOnly: boolean;
                    }[];
                    BundleRemainingDurationInSeconds: number;
                };
                SkinsPanelLayout: {
                    SingleItemOffers: string[];
                    SingleItemStoreOffers: {
                        OfferID: string;
                        IsDirectPurchase: boolean;
                        StartDate: string;
                        Cost: Record<string, number>;
                        Rewards: {
                            ItemTypeID: string;
                            ItemID: string;
                            Quantity: number;
                        }[];
                    }[];
                    SingleItemOffersRemainingDurationInSeconds: number;
                };
                UpgradeCurrencyStore: {
                    UpgradeCurrencyOffers: {
                        OfferID: string;
                        Offer: {
                            OfferID: string;
                            IsDirectPurchase: boolean;
                            StartDate: string;
                            Cost: Record<string, number>;
                            Rewards: {
                                ItemTypeID: string;
                                ItemID: string;
                                Quantity: number;
                            }[];
                        };
                        StorefrontItemID: string;
                        DiscountedPercent: number;
                    }[];
                };
                AccessoryStore: {
                    AccessoryStoreOffers: {
                        Offer: {
                            OfferID: string;
                            IsDirectPurchase: boolean;
                            StartDate: string;
                            Cost: Record<string, number>;
                            Rewards: {
                                ItemTypeID: string;
                                ItemID: string;
                                Quantity: number;
                            }[];
                        };
                        ContractID: string;
                    }[];
                    AccessoryStoreRemainingDurationInSeconds: number;
                    StorefrontID: string;
                };
                BonusStore?: {
                    BonusStoreOffers: {
                        DiscountPercent: number;
                        Offer: {
                            OfferID: string;
                            IsDirectPurchase: boolean;
                            StartDate: string;
                            Cost: Record<string, number>;
                            Rewards: {
                                ItemTypeID: string;
                                ItemID: string;
                                Quantity: number;
                            }[];
                        };
                        BonusOfferID: string;
                        DiscountCosts: Record<string, number>;
                        IsSeen: boolean;
                    }[];
                    BonusStoreRemainingDurationInSeconds: number;
                } | undefined;
            }>;
        };
    };
};

type Params$x = ResolveParams<(typeof _default$x)["~type"]["url"]>;
type Body$x = z.infer<ResolveValue<(typeof _default$x)["~type"], "body">>;
type Data$x = ResolveData<Params$x, Body$x>;
type Response$x = z.infer<ResolveValue<(typeof _default$x)["~type"], "responses">["200"]>;
interface StorefrontRequestConfig extends ValorantAxiosRequestConfig<Data$x> {
}
declare class StorefrontEndpoint {
    /**
     * Get the currently available items in the store
     *
     * @EndpointType pd
     */
    getStorefront<T = Response$x>(this: RemoteApiClient, config?: StorefrontRequestConfig): Promise<AxiosResponse<T>>;
}

declare const walletResponseSchema: z.ZodObject<{
    Balances: z.ZodRecord<z.ZodString, z.ZodNumber>;
}, "strip", z.ZodTypeAny, {
    Balances: Record<string, number>;
}, {
    Balances: Record<string, number>;
}>;
declare const _default$w: Omit<{
    requirements: string[];
    type: "auth" | "local" | "pd" | "glz" | "shared";
    name: string;
    method: "PUT" | "GET" | "DELETE" | "POST";
    url: string;
    description?: string | undefined;
    headers?: Record<string, string> | undefined;
    body?: z.ZodType<any, z.ZodTypeDef, any> | undefined;
    query?: z.ZodType<any, z.ZodTypeDef, any> | undefined;
    responses?: Record<string, z.ZodType<any, z.ZodTypeDef, any>> | undefined;
}, "type" | "name" | "url"> & Pick<{
    readonly name: "Wallet";
    readonly description: "Get the current wallet balance for the user";
    readonly type: "pd";
    readonly url: "store/v1/wallet/:puuid";
    readonly responses: {
        readonly "200": z.ZodObject<{
            Balances: z.ZodRecord<z.ZodString, z.ZodNumber>;
        }, "strip", z.ZodTypeAny, {
            Balances: Record<string, number>;
        }, {
            Balances: Record<string, number>;
        }>;
    };
}, "type" | "name" | "url"> & {
    "~type": {
        readonly name: "Wallet";
        readonly description: "Get the current wallet balance for the user";
        readonly type: "pd";
        readonly url: "store/v1/wallet/:puuid";
        readonly responses: {
            readonly "200": z.ZodObject<{
                Balances: z.ZodRecord<z.ZodString, z.ZodNumber>;
            }, "strip", z.ZodTypeAny, {
                Balances: Record<string, number>;
            }, {
                Balances: Record<string, number>;
            }>;
        };
    };
};

type Params$w = ResolveParams<(typeof _default$w)["~type"]["url"]>;
type Body$w = z.infer<ResolveValue<(typeof _default$w)["~type"], "body">>;
type Data$w = ResolveData<Params$w, Body$w>;
type Response$w = z.infer<ResolveValue<(typeof _default$w)["~type"], "responses">["200"]>;
interface WalletRequestConfig extends ValorantAxiosRequestConfig<Data$w> {
}
declare class WalletEndpoint {
    /**
     * Get the current wallet balance for the user
     *
     * @EndpointType pd
     */
    getWallet<T = Response$w>(this: RemoteApiClient, config?: WalletRequestConfig): Promise<AxiosResponse<T>>;
}

declare const _default$v: Omit<{
    requirements: string[];
    type: "auth" | "local" | "pd" | "glz" | "shared";
    name: string;
    method: "PUT" | "GET" | "DELETE" | "POST";
    url: string;
    description?: string | undefined;
    headers?: Record<string, string> | undefined;
    body?: z.ZodType<any, z.ZodTypeDef, any> | undefined;
    query?: z.ZodType<any, z.ZodTypeDef, any> | undefined;
    responses?: Record<string, z.ZodType<any, z.ZodTypeDef, any>> | undefined;
}, "type" | "name" | "url"> & Pick<{
    readonly name: "Change Queue";
    readonly description: "Change the queue for the party";
    readonly type: "glz";
    readonly method: "POST";
    readonly url: "parties/v1/parties/:partyId/queue";
    readonly body: z.ZodObject<{
        queueId: z.ZodString;
    }, "strip", z.ZodTypeAny, {
        queueId: string;
    }, {
        queueId: string;
    }>;
    readonly responses: {
        readonly "200": z.ZodObject<{
            ID: z.ZodString;
            MUCName: z.ZodString;
            VoiceRoomID: z.ZodString;
            Version: z.ZodNumber;
            ClientVersion: z.ZodString;
            Members: z.ZodArray<z.ZodObject<{
                Subject: z.ZodString;
                CompetitiveTier: z.ZodNumber;
                PlayerIdentity: z.ZodObject<{
                    Subject: z.ZodString;
                    PlayerCardID: z.ZodString;
                    PlayerTitleID: z.ZodString;
                    AccountLevel: z.ZodNumber;
                    PreferredLevelBorderID: z.ZodUnion<[z.ZodString, z.ZodLiteral<"">]>;
                    Incognito: z.ZodBoolean;
                    HideAccountLevel: z.ZodBoolean;
                }, "strip", z.ZodTypeAny, {
                    Subject: string;
                    PlayerCardID: string;
                    PlayerTitleID: string;
                    AccountLevel: number;
                    PreferredLevelBorderID: string;
                    Incognito: boolean;
                    HideAccountLevel: boolean;
                }, {
                    Subject: string;
                    PlayerCardID: string;
                    PlayerTitleID: string;
                    AccountLevel: number;
                    PreferredLevelBorderID: string;
                    Incognito: boolean;
                    HideAccountLevel: boolean;
                }>;
                SeasonalBadgeInfo: z.ZodNull;
                IsOwner: z.ZodOptional<z.ZodBoolean>;
                QueueEligibleRemainingAccountLevels: z.ZodNumber;
                Pings: z.ZodArray<z.ZodObject<{
                    Ping: z.ZodNumber;
                    GamePodID: z.ZodString;
                }, "strip", z.ZodTypeAny, {
                    GamePodID: string;
                    Ping: number;
                }, {
                    GamePodID: string;
                    Ping: number;
                }>, "many">;
                IsReady: z.ZodBoolean;
                IsModerator: z.ZodBoolean;
                UseBroadcastHUD: z.ZodBoolean;
                PlatformType: z.ZodLiteral<"PC">;
            }, "strip", z.ZodTypeAny, {
                Subject: string;
                PlayerIdentity: {
                    Subject: string;
                    PlayerCardID: string;
                    PlayerTitleID: string;
                    AccountLevel: number;
                    PreferredLevelBorderID: string;
                    Incognito: boolean;
                    HideAccountLevel: boolean;
                };
                SeasonalBadgeInfo: null;
                CompetitiveTier: number;
                QueueEligibleRemainingAccountLevels: number;
                Pings: {
                    GamePodID: string;
                    Ping: number;
                }[];
                IsReady: boolean;
                IsModerator: boolean;
                UseBroadcastHUD: boolean;
                PlatformType: "PC";
                IsOwner?: boolean | undefined;
            }, {
                Subject: string;
                PlayerIdentity: {
                    Subject: string;
                    PlayerCardID: string;
                    PlayerTitleID: string;
                    AccountLevel: number;
                    PreferredLevelBorderID: string;
                    Incognito: boolean;
                    HideAccountLevel: boolean;
                };
                SeasonalBadgeInfo: null;
                CompetitiveTier: number;
                QueueEligibleRemainingAccountLevels: number;
                Pings: {
                    GamePodID: string;
                    Ping: number;
                }[];
                IsReady: boolean;
                IsModerator: boolean;
                UseBroadcastHUD: boolean;
                PlatformType: "PC";
                IsOwner?: boolean | undefined;
            }>, "many">;
            State: z.ZodString;
            PreviousState: z.ZodString;
            StateTransitionReason: z.ZodString;
            Accessibility: z.ZodUnion<[z.ZodLiteral<"OPEN">, z.ZodLiteral<"CLOSED">]>;
            CustomGameData: z.ZodObject<{
                Settings: z.ZodObject<{
                    Map: z.ZodString;
                    Mode: z.ZodString;
                    UseBots: z.ZodBoolean;
                    GamePod: z.ZodString;
                    GameRules: z.ZodNullable<z.ZodObject<{
                        AllowGameModifiers: z.ZodOptional<z.ZodEffects<z.ZodString, boolean, string>>;
                        IsOvertimeWinByTwo: z.ZodOptional<z.ZodEffects<z.ZodString, boolean, string>>;
                        PlayOutAllRounds: z.ZodOptional<z.ZodEffects<z.ZodString, boolean, string>>;
                        SkipMatchHistory: z.ZodOptional<z.ZodEffects<z.ZodString, boolean, string>>;
                        TournamentMode: z.ZodOptional<z.ZodEffects<z.ZodString, boolean, string>>;
                    }, "strip", z.ZodTypeAny, {
                        AllowGameModifiers?: boolean | undefined;
                        IsOvertimeWinByTwo?: boolean | undefined;
                        PlayOutAllRounds?: boolean | undefined;
                        SkipMatchHistory?: boolean | undefined;
                        TournamentMode?: boolean | undefined;
                    }, {
                        AllowGameModifiers?: string | undefined;
                        IsOvertimeWinByTwo?: string | undefined;
                        PlayOutAllRounds?: string | undefined;
                        SkipMatchHistory?: string | undefined;
                        TournamentMode?: string | undefined;
                    }>>;
                }, "strip", z.ZodTypeAny, {
                    Mode: string;
                    GameRules: {
                        AllowGameModifiers?: boolean | undefined;
                        IsOvertimeWinByTwo?: boolean | undefined;
                        PlayOutAllRounds?: boolean | undefined;
                        SkipMatchHistory?: boolean | undefined;
                        TournamentMode?: boolean | undefined;
                    } | null;
                    Map: string;
                    UseBots: boolean;
                    GamePod: string;
                }, {
                    Mode: string;
                    GameRules: {
                        AllowGameModifiers?: string | undefined;
                        IsOvertimeWinByTwo?: string | undefined;
                        PlayOutAllRounds?: string | undefined;
                        SkipMatchHistory?: string | undefined;
                        TournamentMode?: string | undefined;
                    } | null;
                    Map: string;
                    UseBots: boolean;
                    GamePod: string;
                }>;
                Membership: z.ZodObject<{
                    teamOne: z.ZodNullable<z.ZodArray<z.ZodObject<{
                        Subject: z.ZodString;
                    }, "strip", z.ZodTypeAny, {
                        Subject: string;
                    }, {
                        Subject: string;
                    }>, "many">>;
                    teamTwo: z.ZodNullable<z.ZodArray<z.ZodObject<{
                        Subject: z.ZodString;
                    }, "strip", z.ZodTypeAny, {
                        Subject: string;
                    }, {
                        Subject: string;
                    }>, "many">>;
                    teamSpectate: z.ZodNullable<z.ZodArray<z.ZodObject<{
                        Subject: z.ZodString;
                    }, "strip", z.ZodTypeAny, {
                        Subject: string;
                    }, {
                        Subject: string;
                    }>, "many">>;
                    teamOneCoaches: z.ZodNullable<z.ZodArray<z.ZodObject<{
                        Subject: z.ZodString;
                    }, "strip", z.ZodTypeAny, {
                        Subject: string;
                    }, {
                        Subject: string;
                    }>, "many">>;
                    teamTwoCoaches: z.ZodNullable<z.ZodArray<z.ZodObject<{
                        Subject: z.ZodString;
                    }, "strip", z.ZodTypeAny, {
                        Subject: string;
                    }, {
                        Subject: string;
                    }>, "many">>;
                }, "strip", z.ZodTypeAny, {
                    teamOne: {
                        Subject: string;
                    }[] | null;
                    teamTwo: {
                        Subject: string;
                    }[] | null;
                    teamSpectate: {
                        Subject: string;
                    }[] | null;
                    teamOneCoaches: {
                        Subject: string;
                    }[] | null;
                    teamTwoCoaches: {
                        Subject: string;
                    }[] | null;
                }, {
                    teamOne: {
                        Subject: string;
                    }[] | null;
                    teamTwo: {
                        Subject: string;
                    }[] | null;
                    teamSpectate: {
                        Subject: string;
                    }[] | null;
                    teamOneCoaches: {
                        Subject: string;
                    }[] | null;
                    teamTwoCoaches: {
                        Subject: string;
                    }[] | null;
                }>;
                MaxPartySize: z.ZodNumber;
                AutobalanceEnabled: z.ZodBoolean;
                AutobalanceMinPlayers: z.ZodNumber;
                HasRecoveryData: z.ZodBoolean;
            }, "strip", z.ZodTypeAny, {
                MaxPartySize: number;
                Settings: {
                    Mode: string;
                    GameRules: {
                        AllowGameModifiers?: boolean | undefined;
                        IsOvertimeWinByTwo?: boolean | undefined;
                        PlayOutAllRounds?: boolean | undefined;
                        SkipMatchHistory?: boolean | undefined;
                        TournamentMode?: boolean | undefined;
                    } | null;
                    Map: string;
                    UseBots: boolean;
                    GamePod: string;
                };
                Membership: {
                    teamOne: {
                        Subject: string;
                    }[] | null;
                    teamTwo: {
                        Subject: string;
                    }[] | null;
                    teamSpectate: {
                        Subject: string;
                    }[] | null;
                    teamOneCoaches: {
                        Subject: string;
                    }[] | null;
                    teamTwoCoaches: {
                        Subject: string;
                    }[] | null;
                };
                AutobalanceEnabled: boolean;
                AutobalanceMinPlayers: number;
                HasRecoveryData: boolean;
            }, {
                MaxPartySize: number;
                Settings: {
                    Mode: string;
                    GameRules: {
                        AllowGameModifiers?: string | undefined;
                        IsOvertimeWinByTwo?: string | undefined;
                        PlayOutAllRounds?: string | undefined;
                        SkipMatchHistory?: string | undefined;
                        TournamentMode?: string | undefined;
                    } | null;
                    Map: string;
                    UseBots: boolean;
                    GamePod: string;
                };
                Membership: {
                    teamOne: {
                        Subject: string;
                    }[] | null;
                    teamTwo: {
                        Subject: string;
                    }[] | null;
                    teamSpectate: {
                        Subject: string;
                    }[] | null;
                    teamOneCoaches: {
                        Subject: string;
                    }[] | null;
                    teamTwoCoaches: {
                        Subject: string;
                    }[] | null;
                };
                AutobalanceEnabled: boolean;
                AutobalanceMinPlayers: number;
                HasRecoveryData: boolean;
            }>;
            MatchmakingData: z.ZodObject<{
                QueueID: z.ZodString;
                PreferredGamePods: z.ZodArray<z.ZodString, "many">;
                SkillDisparityRRPenalty: z.ZodNumber;
            }, "strip", z.ZodTypeAny, {
                QueueID: string;
                PreferredGamePods: string[];
                SkillDisparityRRPenalty: number;
            }, {
                QueueID: string;
                PreferredGamePods: string[];
                SkillDisparityRRPenalty: number;
            }>;
            Invites: z.ZodNull;
            Requests: z.ZodArray<z.ZodUnknown, "many">;
            QueueEntryTime: z.ZodEffects<z.ZodString, Date, string>;
            ErrorNotification: z.ZodObject<{
                ErrorType: z.ZodString;
                ErroredPlayers: z.ZodNullable<z.ZodArray<z.ZodObject<{
                    Subject: z.ZodString;
                }, "strip", z.ZodTypeAny, {
                    Subject: string;
                }, {
                    Subject: string;
                }>, "many">>;
            }, "strip", z.ZodTypeAny, {
                ErrorType: string;
                ErroredPlayers: {
                    Subject: string;
                }[] | null;
            }, {
                ErrorType: string;
                ErroredPlayers: {
                    Subject: string;
                }[] | null;
            }>;
            RestrictedSeconds: z.ZodNumber;
            EligibleQueues: z.ZodArray<z.ZodString, "many">;
            QueueIneligibilities: z.ZodArray<z.ZodString, "many">;
            CheatData: z.ZodObject<{
                GamePodOverride: z.ZodString;
                ForcePostGameProcessing: z.ZodBoolean;
            }, "strip", z.ZodTypeAny, {
                GamePodOverride: string;
                ForcePostGameProcessing: boolean;
            }, {
                GamePodOverride: string;
                ForcePostGameProcessing: boolean;
            }>;
            XPBonuses: z.ZodArray<z.ZodUnknown, "many">;
            InviteCode: z.ZodString;
        }, "strip", z.ZodTypeAny, {
            ID: string;
            Version: number;
            Invites: null;
            Requests: unknown[];
            State: string;
            MatchmakingData: {
                QueueID: string;
                PreferredGamePods: string[];
                SkillDisparityRRPenalty: number;
            };
            MUCName: string;
            VoiceRoomID: string;
            ClientVersion: string;
            Members: {
                Subject: string;
                PlayerIdentity: {
                    Subject: string;
                    PlayerCardID: string;
                    PlayerTitleID: string;
                    AccountLevel: number;
                    PreferredLevelBorderID: string;
                    Incognito: boolean;
                    HideAccountLevel: boolean;
                };
                SeasonalBadgeInfo: null;
                CompetitiveTier: number;
                QueueEligibleRemainingAccountLevels: number;
                Pings: {
                    GamePodID: string;
                    Ping: number;
                }[];
                IsReady: boolean;
                IsModerator: boolean;
                UseBroadcastHUD: boolean;
                PlatformType: "PC";
                IsOwner?: boolean | undefined;
            }[];
            PreviousState: string;
            StateTransitionReason: string;
            Accessibility: "OPEN" | "CLOSED";
            CustomGameData: {
                MaxPartySize: number;
                Settings: {
                    Mode: string;
                    GameRules: {
                        AllowGameModifiers?: boolean | undefined;
                        IsOvertimeWinByTwo?: boolean | undefined;
                        PlayOutAllRounds?: boolean | undefined;
                        SkipMatchHistory?: boolean | undefined;
                        TournamentMode?: boolean | undefined;
                    } | null;
                    Map: string;
                    UseBots: boolean;
                    GamePod: string;
                };
                Membership: {
                    teamOne: {
                        Subject: string;
                    }[] | null;
                    teamTwo: {
                        Subject: string;
                    }[] | null;
                    teamSpectate: {
                        Subject: string;
                    }[] | null;
                    teamOneCoaches: {
                        Subject: string;
                    }[] | null;
                    teamTwoCoaches: {
                        Subject: string;
                    }[] | null;
                };
                AutobalanceEnabled: boolean;
                AutobalanceMinPlayers: number;
                HasRecoveryData: boolean;
            };
            QueueEntryTime: Date;
            ErrorNotification: {
                ErrorType: string;
                ErroredPlayers: {
                    Subject: string;
                }[] | null;
            };
            RestrictedSeconds: number;
            EligibleQueues: string[];
            QueueIneligibilities: string[];
            CheatData: {
                GamePodOverride: string;
                ForcePostGameProcessing: boolean;
            };
            XPBonuses: unknown[];
            InviteCode: string;
        }, {
            ID: string;
            Version: number;
            Invites: null;
            Requests: unknown[];
            State: string;
            MatchmakingData: {
                QueueID: string;
                PreferredGamePods: string[];
                SkillDisparityRRPenalty: number;
            };
            MUCName: string;
            VoiceRoomID: string;
            ClientVersion: string;
            Members: {
                Subject: string;
                PlayerIdentity: {
                    Subject: string;
                    PlayerCardID: string;
                    PlayerTitleID: string;
                    AccountLevel: number;
                    PreferredLevelBorderID: string;
                    Incognito: boolean;
                    HideAccountLevel: boolean;
                };
                SeasonalBadgeInfo: null;
                CompetitiveTier: number;
                QueueEligibleRemainingAccountLevels: number;
                Pings: {
                    GamePodID: string;
                    Ping: number;
                }[];
                IsReady: boolean;
                IsModerator: boolean;
                UseBroadcastHUD: boolean;
                PlatformType: "PC";
                IsOwner?: boolean | undefined;
            }[];
            PreviousState: string;
            StateTransitionReason: string;
            Accessibility: "OPEN" | "CLOSED";
            CustomGameData: {
                MaxPartySize: number;
                Settings: {
                    Mode: string;
                    GameRules: {
                        AllowGameModifiers?: string | undefined;
                        IsOvertimeWinByTwo?: string | undefined;
                        PlayOutAllRounds?: string | undefined;
                        SkipMatchHistory?: string | undefined;
                        TournamentMode?: string | undefined;
                    } | null;
                    Map: string;
                    UseBots: boolean;
                    GamePod: string;
                };
                Membership: {
                    teamOne: {
                        Subject: string;
                    }[] | null;
                    teamTwo: {
                        Subject: string;
                    }[] | null;
                    teamSpectate: {
                        Subject: string;
                    }[] | null;
                    teamOneCoaches: {
                        Subject: string;
                    }[] | null;
                    teamTwoCoaches: {
                        Subject: string;
                    }[] | null;
                };
                AutobalanceEnabled: boolean;
                AutobalanceMinPlayers: number;
                HasRecoveryData: boolean;
            };
            QueueEntryTime: string;
            ErrorNotification: {
                ErrorType: string;
                ErroredPlayers: {
                    Subject: string;
                }[] | null;
            };
            RestrictedSeconds: number;
            EligibleQueues: string[];
            QueueIneligibilities: string[];
            CheatData: {
                GamePodOverride: string;
                ForcePostGameProcessing: boolean;
            };
            XPBonuses: unknown[];
            InviteCode: string;
        }>;
    };
}, "type" | "name" | "url"> & {
    "~type": {
        readonly name: "Change Queue";
        readonly description: "Change the queue for the party";
        readonly type: "glz";
        readonly method: "POST";
        readonly url: "parties/v1/parties/:partyId/queue";
        readonly body: z.ZodObject<{
            queueId: z.ZodString;
        }, "strip", z.ZodTypeAny, {
            queueId: string;
        }, {
            queueId: string;
        }>;
        readonly responses: {
            readonly "200": z.ZodObject<{
                ID: z.ZodString;
                MUCName: z.ZodString;
                VoiceRoomID: z.ZodString;
                Version: z.ZodNumber;
                ClientVersion: z.ZodString;
                Members: z.ZodArray<z.ZodObject<{
                    Subject: z.ZodString;
                    CompetitiveTier: z.ZodNumber;
                    PlayerIdentity: z.ZodObject<{
                        Subject: z.ZodString;
                        PlayerCardID: z.ZodString;
                        PlayerTitleID: z.ZodString;
                        AccountLevel: z.ZodNumber;
                        PreferredLevelBorderID: z.ZodUnion<[z.ZodString, z.ZodLiteral<"">]>;
                        Incognito: z.ZodBoolean;
                        HideAccountLevel: z.ZodBoolean;
                    }, "strip", z.ZodTypeAny, {
                        Subject: string;
                        PlayerCardID: string;
                        PlayerTitleID: string;
                        AccountLevel: number;
                        PreferredLevelBorderID: string;
                        Incognito: boolean;
                        HideAccountLevel: boolean;
                    }, {
                        Subject: string;
                        PlayerCardID: string;
                        PlayerTitleID: string;
                        AccountLevel: number;
                        PreferredLevelBorderID: string;
                        Incognito: boolean;
                        HideAccountLevel: boolean;
                    }>;
                    SeasonalBadgeInfo: z.ZodNull;
                    IsOwner: z.ZodOptional<z.ZodBoolean>;
                    QueueEligibleRemainingAccountLevels: z.ZodNumber;
                    Pings: z.ZodArray<z.ZodObject<{
                        Ping: z.ZodNumber;
                        GamePodID: z.ZodString;
                    }, "strip", z.ZodTypeAny, {
                        GamePodID: string;
                        Ping: number;
                    }, {
                        GamePodID: string;
                        Ping: number;
                    }>, "many">;
                    IsReady: z.ZodBoolean;
                    IsModerator: z.ZodBoolean;
                    UseBroadcastHUD: z.ZodBoolean;
                    PlatformType: z.ZodLiteral<"PC">;
                }, "strip", z.ZodTypeAny, {
                    Subject: string;
                    PlayerIdentity: {
                        Subject: string;
                        PlayerCardID: string;
                        PlayerTitleID: string;
                        AccountLevel: number;
                        PreferredLevelBorderID: string;
                        Incognito: boolean;
                        HideAccountLevel: boolean;
                    };
                    SeasonalBadgeInfo: null;
                    CompetitiveTier: number;
                    QueueEligibleRemainingAccountLevels: number;
                    Pings: {
                        GamePodID: string;
                        Ping: number;
                    }[];
                    IsReady: boolean;
                    IsModerator: boolean;
                    UseBroadcastHUD: boolean;
                    PlatformType: "PC";
                    IsOwner?: boolean | undefined;
                }, {
                    Subject: string;
                    PlayerIdentity: {
                        Subject: string;
                        PlayerCardID: string;
                        PlayerTitleID: string;
                        AccountLevel: number;
                        PreferredLevelBorderID: string;
                        Incognito: boolean;
                        HideAccountLevel: boolean;
                    };
                    SeasonalBadgeInfo: null;
                    CompetitiveTier: number;
                    QueueEligibleRemainingAccountLevels: number;
                    Pings: {
                        GamePodID: string;
                        Ping: number;
                    }[];
                    IsReady: boolean;
                    IsModerator: boolean;
                    UseBroadcastHUD: boolean;
                    PlatformType: "PC";
                    IsOwner?: boolean | undefined;
                }>, "many">;
                State: z.ZodString;
                PreviousState: z.ZodString;
                StateTransitionReason: z.ZodString;
                Accessibility: z.ZodUnion<[z.ZodLiteral<"OPEN">, z.ZodLiteral<"CLOSED">]>;
                CustomGameData: z.ZodObject<{
                    Settings: z.ZodObject<{
                        Map: z.ZodString;
                        Mode: z.ZodString;
                        UseBots: z.ZodBoolean;
                        GamePod: z.ZodString;
                        GameRules: z.ZodNullable<z.ZodObject<{
                            AllowGameModifiers: z.ZodOptional<z.ZodEffects<z.ZodString, boolean, string>>;
                            IsOvertimeWinByTwo: z.ZodOptional<z.ZodEffects<z.ZodString, boolean, string>>;
                            PlayOutAllRounds: z.ZodOptional<z.ZodEffects<z.ZodString, boolean, string>>;
                            SkipMatchHistory: z.ZodOptional<z.ZodEffects<z.ZodString, boolean, string>>;
                            TournamentMode: z.ZodOptional<z.ZodEffects<z.ZodString, boolean, string>>;
                        }, "strip", z.ZodTypeAny, {
                            AllowGameModifiers?: boolean | undefined;
                            IsOvertimeWinByTwo?: boolean | undefined;
                            PlayOutAllRounds?: boolean | undefined;
                            SkipMatchHistory?: boolean | undefined;
                            TournamentMode?: boolean | undefined;
                        }, {
                            AllowGameModifiers?: string | undefined;
                            IsOvertimeWinByTwo?: string | undefined;
                            PlayOutAllRounds?: string | undefined;
                            SkipMatchHistory?: string | undefined;
                            TournamentMode?: string | undefined;
                        }>>;
                    }, "strip", z.ZodTypeAny, {
                        Mode: string;
                        GameRules: {
                            AllowGameModifiers?: boolean | undefined;
                            IsOvertimeWinByTwo?: boolean | undefined;
                            PlayOutAllRounds?: boolean | undefined;
                            SkipMatchHistory?: boolean | undefined;
                            TournamentMode?: boolean | undefined;
                        } | null;
                        Map: string;
                        UseBots: boolean;
                        GamePod: string;
                    }, {
                        Mode: string;
                        GameRules: {
                            AllowGameModifiers?: string | undefined;
                            IsOvertimeWinByTwo?: string | undefined;
                            PlayOutAllRounds?: string | undefined;
                            SkipMatchHistory?: string | undefined;
                            TournamentMode?: string | undefined;
                        } | null;
                        Map: string;
                        UseBots: boolean;
                        GamePod: string;
                    }>;
                    Membership: z.ZodObject<{
                        teamOne: z.ZodNullable<z.ZodArray<z.ZodObject<{
                            Subject: z.ZodString;
                        }, "strip", z.ZodTypeAny, {
                            Subject: string;
                        }, {
                            Subject: string;
                        }>, "many">>;
                        teamTwo: z.ZodNullable<z.ZodArray<z.ZodObject<{
                            Subject: z.ZodString;
                        }, "strip", z.ZodTypeAny, {
                            Subject: string;
                        }, {
                            Subject: string;
                        }>, "many">>;
                        teamSpectate: z.ZodNullable<z.ZodArray<z.ZodObject<{
                            Subject: z.ZodString;
                        }, "strip", z.ZodTypeAny, {
                            Subject: string;
                        }, {
                            Subject: string;
                        }>, "many">>;
                        teamOneCoaches: z.ZodNullable<z.ZodArray<z.ZodObject<{
                            Subject: z.ZodString;
                        }, "strip", z.ZodTypeAny, {
                            Subject: string;
                        }, {
                            Subject: string;
                        }>, "many">>;
                        teamTwoCoaches: z.ZodNullable<z.ZodArray<z.ZodObject<{
                            Subject: z.ZodString;
                        }, "strip", z.ZodTypeAny, {
                            Subject: string;
                        }, {
                            Subject: string;
                        }>, "many">>;
                    }, "strip", z.ZodTypeAny, {
                        teamOne: {
                            Subject: string;
                        }[] | null;
                        teamTwo: {
                            Subject: string;
                        }[] | null;
                        teamSpectate: {
                            Subject: string;
                        }[] | null;
                        teamOneCoaches: {
                            Subject: string;
                        }[] | null;
                        teamTwoCoaches: {
                            Subject: string;
                        }[] | null;
                    }, {
                        teamOne: {
                            Subject: string;
                        }[] | null;
                        teamTwo: {
                            Subject: string;
                        }[] | null;
                        teamSpectate: {
                            Subject: string;
                        }[] | null;
                        teamOneCoaches: {
                            Subject: string;
                        }[] | null;
                        teamTwoCoaches: {
                            Subject: string;
                        }[] | null;
                    }>;
                    MaxPartySize: z.ZodNumber;
                    AutobalanceEnabled: z.ZodBoolean;
                    AutobalanceMinPlayers: z.ZodNumber;
                    HasRecoveryData: z.ZodBoolean;
                }, "strip", z.ZodTypeAny, {
                    MaxPartySize: number;
                    Settings: {
                        Mode: string;
                        GameRules: {
                            AllowGameModifiers?: boolean | undefined;
                            IsOvertimeWinByTwo?: boolean | undefined;
                            PlayOutAllRounds?: boolean | undefined;
                            SkipMatchHistory?: boolean | undefined;
                            TournamentMode?: boolean | undefined;
                        } | null;
                        Map: string;
                        UseBots: boolean;
                        GamePod: string;
                    };
                    Membership: {
                        teamOne: {
                            Subject: string;
                        }[] | null;
                        teamTwo: {
                            Subject: string;
                        }[] | null;
                        teamSpectate: {
                            Subject: string;
                        }[] | null;
                        teamOneCoaches: {
                            Subject: string;
                        }[] | null;
                        teamTwoCoaches: {
                            Subject: string;
                        }[] | null;
                    };
                    AutobalanceEnabled: boolean;
                    AutobalanceMinPlayers: number;
                    HasRecoveryData: boolean;
                }, {
                    MaxPartySize: number;
                    Settings: {
                        Mode: string;
                        GameRules: {
                            AllowGameModifiers?: string | undefined;
                            IsOvertimeWinByTwo?: string | undefined;
                            PlayOutAllRounds?: string | undefined;
                            SkipMatchHistory?: string | undefined;
                            TournamentMode?: string | undefined;
                        } | null;
                        Map: string;
                        UseBots: boolean;
                        GamePod: string;
                    };
                    Membership: {
                        teamOne: {
                            Subject: string;
                        }[] | null;
                        teamTwo: {
                            Subject: string;
                        }[] | null;
                        teamSpectate: {
                            Subject: string;
                        }[] | null;
                        teamOneCoaches: {
                            Subject: string;
                        }[] | null;
                        teamTwoCoaches: {
                            Subject: string;
                        }[] | null;
                    };
                    AutobalanceEnabled: boolean;
                    AutobalanceMinPlayers: number;
                    HasRecoveryData: boolean;
                }>;
                MatchmakingData: z.ZodObject<{
                    QueueID: z.ZodString;
                    PreferredGamePods: z.ZodArray<z.ZodString, "many">;
                    SkillDisparityRRPenalty: z.ZodNumber;
                }, "strip", z.ZodTypeAny, {
                    QueueID: string;
                    PreferredGamePods: string[];
                    SkillDisparityRRPenalty: number;
                }, {
                    QueueID: string;
                    PreferredGamePods: string[];
                    SkillDisparityRRPenalty: number;
                }>;
                Invites: z.ZodNull;
                Requests: z.ZodArray<z.ZodUnknown, "many">;
                QueueEntryTime: z.ZodEffects<z.ZodString, Date, string>;
                ErrorNotification: z.ZodObject<{
                    ErrorType: z.ZodString;
                    ErroredPlayers: z.ZodNullable<z.ZodArray<z.ZodObject<{
                        Subject: z.ZodString;
                    }, "strip", z.ZodTypeAny, {
                        Subject: string;
                    }, {
                        Subject: string;
                    }>, "many">>;
                }, "strip", z.ZodTypeAny, {
                    ErrorType: string;
                    ErroredPlayers: {
                        Subject: string;
                    }[] | null;
                }, {
                    ErrorType: string;
                    ErroredPlayers: {
                        Subject: string;
                    }[] | null;
                }>;
                RestrictedSeconds: z.ZodNumber;
                EligibleQueues: z.ZodArray<z.ZodString, "many">;
                QueueIneligibilities: z.ZodArray<z.ZodString, "many">;
                CheatData: z.ZodObject<{
                    GamePodOverride: z.ZodString;
                    ForcePostGameProcessing: z.ZodBoolean;
                }, "strip", z.ZodTypeAny, {
                    GamePodOverride: string;
                    ForcePostGameProcessing: boolean;
                }, {
                    GamePodOverride: string;
                    ForcePostGameProcessing: boolean;
                }>;
                XPBonuses: z.ZodArray<z.ZodUnknown, "many">;
                InviteCode: z.ZodString;
            }, "strip", z.ZodTypeAny, {
                ID: string;
                Version: number;
                Invites: null;
                Requests: unknown[];
                State: string;
                MatchmakingData: {
                    QueueID: string;
                    PreferredGamePods: string[];
                    SkillDisparityRRPenalty: number;
                };
                MUCName: string;
                VoiceRoomID: string;
                ClientVersion: string;
                Members: {
                    Subject: string;
                    PlayerIdentity: {
                        Subject: string;
                        PlayerCardID: string;
                        PlayerTitleID: string;
                        AccountLevel: number;
                        PreferredLevelBorderID: string;
                        Incognito: boolean;
                        HideAccountLevel: boolean;
                    };
                    SeasonalBadgeInfo: null;
                    CompetitiveTier: number;
                    QueueEligibleRemainingAccountLevels: number;
                    Pings: {
                        GamePodID: string;
                        Ping: number;
                    }[];
                    IsReady: boolean;
                    IsModerator: boolean;
                    UseBroadcastHUD: boolean;
                    PlatformType: "PC";
                    IsOwner?: boolean | undefined;
                }[];
                PreviousState: string;
                StateTransitionReason: string;
                Accessibility: "OPEN" | "CLOSED";
                CustomGameData: {
                    MaxPartySize: number;
                    Settings: {
                        Mode: string;
                        GameRules: {
                            AllowGameModifiers?: boolean | undefined;
                            IsOvertimeWinByTwo?: boolean | undefined;
                            PlayOutAllRounds?: boolean | undefined;
                            SkipMatchHistory?: boolean | undefined;
                            TournamentMode?: boolean | undefined;
                        } | null;
                        Map: string;
                        UseBots: boolean;
                        GamePod: string;
                    };
                    Membership: {
                        teamOne: {
                            Subject: string;
                        }[] | null;
                        teamTwo: {
                            Subject: string;
                        }[] | null;
                        teamSpectate: {
                            Subject: string;
                        }[] | null;
                        teamOneCoaches: {
                            Subject: string;
                        }[] | null;
                        teamTwoCoaches: {
                            Subject: string;
                        }[] | null;
                    };
                    AutobalanceEnabled: boolean;
                    AutobalanceMinPlayers: number;
                    HasRecoveryData: boolean;
                };
                QueueEntryTime: Date;
                ErrorNotification: {
                    ErrorType: string;
                    ErroredPlayers: {
                        Subject: string;
                    }[] | null;
                };
                RestrictedSeconds: number;
                EligibleQueues: string[];
                QueueIneligibilities: string[];
                CheatData: {
                    GamePodOverride: string;
                    ForcePostGameProcessing: boolean;
                };
                XPBonuses: unknown[];
                InviteCode: string;
            }, {
                ID: string;
                Version: number;
                Invites: null;
                Requests: unknown[];
                State: string;
                MatchmakingData: {
                    QueueID: string;
                    PreferredGamePods: string[];
                    SkillDisparityRRPenalty: number;
                };
                MUCName: string;
                VoiceRoomID: string;
                ClientVersion: string;
                Members: {
                    Subject: string;
                    PlayerIdentity: {
                        Subject: string;
                        PlayerCardID: string;
                        PlayerTitleID: string;
                        AccountLevel: number;
                        PreferredLevelBorderID: string;
                        Incognito: boolean;
                        HideAccountLevel: boolean;
                    };
                    SeasonalBadgeInfo: null;
                    CompetitiveTier: number;
                    QueueEligibleRemainingAccountLevels: number;
                    Pings: {
                        GamePodID: string;
                        Ping: number;
                    }[];
                    IsReady: boolean;
                    IsModerator: boolean;
                    UseBroadcastHUD: boolean;
                    PlatformType: "PC";
                    IsOwner?: boolean | undefined;
                }[];
                PreviousState: string;
                StateTransitionReason: string;
                Accessibility: "OPEN" | "CLOSED";
                CustomGameData: {
                    MaxPartySize: number;
                    Settings: {
                        Mode: string;
                        GameRules: {
                            AllowGameModifiers?: string | undefined;
                            IsOvertimeWinByTwo?: string | undefined;
                            PlayOutAllRounds?: string | undefined;
                            SkipMatchHistory?: string | undefined;
                            TournamentMode?: string | undefined;
                        } | null;
                        Map: string;
                        UseBots: boolean;
                        GamePod: string;
                    };
                    Membership: {
                        teamOne: {
                            Subject: string;
                        }[] | null;
                        teamTwo: {
                            Subject: string;
                        }[] | null;
                        teamSpectate: {
                            Subject: string;
                        }[] | null;
                        teamOneCoaches: {
                            Subject: string;
                        }[] | null;
                        teamTwoCoaches: {
                            Subject: string;
                        }[] | null;
                    };
                    AutobalanceEnabled: boolean;
                    AutobalanceMinPlayers: number;
                    HasRecoveryData: boolean;
                };
                QueueEntryTime: string;
                ErrorNotification: {
                    ErrorType: string;
                    ErroredPlayers: {
                        Subject: string;
                    }[] | null;
                };
                RestrictedSeconds: number;
                EligibleQueues: string[];
                QueueIneligibilities: string[];
                CheatData: {
                    GamePodOverride: string;
                    ForcePostGameProcessing: boolean;
                };
                XPBonuses: unknown[];
                InviteCode: string;
            }>;
        };
    };
};

type Params$v = ResolveParams<(typeof _default$v)["~type"]["url"]>;
type Body$v = z.infer<ResolveValue<(typeof _default$v)["~type"], "body">>;
type Data$v = ResolveData<Params$v, Body$v>;
type Response$v = z.infer<ResolveValue<(typeof _default$v)["~type"], "responses">["200"]>;
interface ChangeQueueRequestConfig extends ValorantAxiosRequestConfig<Data$v> {
}
declare class ChangeQueueEndpoint {
    /**
     * Change the queue for the party
     *
     * @EndpointType glz
     */
    postChangeQueue<T = Response$v>(this: RemoteApiClient, config: ChangeQueueRequestConfig): Promise<AxiosResponse<T>>;
}

declare const CurrentGameLoadoutsResponseSchema: z.ZodObject<{
    Loadouts: z.ZodArray<z.ZodObject<{
        CharacterID: z.ZodString;
        Loadout: z.ZodObject<{
            Subject: z.ZodString;
            Sprays: z.ZodObject<{
                SpraySelections: z.ZodArray<z.ZodObject<{
                    SocketID: z.ZodString;
                    SprayID: z.ZodString;
                    LevelID: z.ZodString;
                }, "strip", z.ZodTypeAny, {
                    SocketID: string;
                    SprayID: string;
                    LevelID: string;
                }, {
                    SocketID: string;
                    SprayID: string;
                    LevelID: string;
                }>, "many">;
            }, "strip", z.ZodTypeAny, {
                SpraySelections: {
                    SocketID: string;
                    SprayID: string;
                    LevelID: string;
                }[];
            }, {
                SpraySelections: {
                    SocketID: string;
                    SprayID: string;
                    LevelID: string;
                }[];
            }>;
            Expressions: z.ZodObject<{
                AESSelections: z.ZodArray<z.ZodObject<{
                    SocketID: z.ZodString;
                    AssetID: z.ZodString;
                    TypeID: z.ZodString;
                }, "strip", z.ZodTypeAny, {
                    SocketID: string;
                    AssetID: string;
                    TypeID: string;
                }, {
                    SocketID: string;
                    AssetID: string;
                    TypeID: string;
                }>, "many">;
            }, "strip", z.ZodTypeAny, {
                AESSelections: {
                    SocketID: string;
                    AssetID: string;
                    TypeID: string;
                }[];
            }, {
                AESSelections: {
                    SocketID: string;
                    AssetID: string;
                    TypeID: string;
                }[];
            }>;
            Items: z.ZodRecord<z.ZodString, z.ZodObject<{
                ID: z.ZodString;
                TypeID: z.ZodString;
                Sockets: z.ZodRecord<z.ZodString, z.ZodObject<{
                    ID: z.ZodString;
                    Item: z.ZodObject<{
                        ID: z.ZodString;
                        TypeID: z.ZodString;
                    }, "strip", z.ZodTypeAny, {
                        TypeID: string;
                        ID: string;
                    }, {
                        TypeID: string;
                        ID: string;
                    }>;
                }, "strip", z.ZodTypeAny, {
                    ID: string;
                    Item: {
                        TypeID: string;
                        ID: string;
                    };
                }, {
                    ID: string;
                    Item: {
                        TypeID: string;
                        ID: string;
                    };
                }>>;
            }, "strip", z.ZodTypeAny, {
                TypeID: string;
                ID: string;
                Sockets: Record<string, {
                    ID: string;
                    Item: {
                        TypeID: string;
                        ID: string;
                    };
                }>;
            }, {
                TypeID: string;
                ID: string;
                Sockets: Record<string, {
                    ID: string;
                    Item: {
                        TypeID: string;
                        ID: string;
                    };
                }>;
            }>>;
        }, "strip", z.ZodTypeAny, {
            Subject: string;
            Sprays: {
                SpraySelections: {
                    SocketID: string;
                    SprayID: string;
                    LevelID: string;
                }[];
            };
            Expressions: {
                AESSelections: {
                    SocketID: string;
                    AssetID: string;
                    TypeID: string;
                }[];
            };
            Items: Record<string, {
                TypeID: string;
                ID: string;
                Sockets: Record<string, {
                    ID: string;
                    Item: {
                        TypeID: string;
                        ID: string;
                    };
                }>;
            }>;
        }, {
            Subject: string;
            Sprays: {
                SpraySelections: {
                    SocketID: string;
                    SprayID: string;
                    LevelID: string;
                }[];
            };
            Expressions: {
                AESSelections: {
                    SocketID: string;
                    AssetID: string;
                    TypeID: string;
                }[];
            };
            Items: Record<string, {
                TypeID: string;
                ID: string;
                Sockets: Record<string, {
                    ID: string;
                    Item: {
                        TypeID: string;
                        ID: string;
                    };
                }>;
            }>;
        }>;
    }, "strip", z.ZodTypeAny, {
        CharacterID: string;
        Loadout: {
            Subject: string;
            Sprays: {
                SpraySelections: {
                    SocketID: string;
                    SprayID: string;
                    LevelID: string;
                }[];
            };
            Expressions: {
                AESSelections: {
                    SocketID: string;
                    AssetID: string;
                    TypeID: string;
                }[];
            };
            Items: Record<string, {
                TypeID: string;
                ID: string;
                Sockets: Record<string, {
                    ID: string;
                    Item: {
                        TypeID: string;
                        ID: string;
                    };
                }>;
            }>;
        };
    }, {
        CharacterID: string;
        Loadout: {
            Subject: string;
            Sprays: {
                SpraySelections: {
                    SocketID: string;
                    SprayID: string;
                    LevelID: string;
                }[];
            };
            Expressions: {
                AESSelections: {
                    SocketID: string;
                    AssetID: string;
                    TypeID: string;
                }[];
            };
            Items: Record<string, {
                TypeID: string;
                ID: string;
                Sockets: Record<string, {
                    ID: string;
                    Item: {
                        TypeID: string;
                        ID: string;
                    };
                }>;
            }>;
        };
    }>, "many">;
}, "strip", z.ZodTypeAny, {
    Loadouts: {
        CharacterID: string;
        Loadout: {
            Subject: string;
            Sprays: {
                SpraySelections: {
                    SocketID: string;
                    SprayID: string;
                    LevelID: string;
                }[];
            };
            Expressions: {
                AESSelections: {
                    SocketID: string;
                    AssetID: string;
                    TypeID: string;
                }[];
            };
            Items: Record<string, {
                TypeID: string;
                ID: string;
                Sockets: Record<string, {
                    ID: string;
                    Item: {
                        TypeID: string;
                        ID: string;
                    };
                }>;
            }>;
        };
    }[];
}, {
    Loadouts: {
        CharacterID: string;
        Loadout: {
            Subject: string;
            Sprays: {
                SpraySelections: {
                    SocketID: string;
                    SprayID: string;
                    LevelID: string;
                }[];
            };
            Expressions: {
                AESSelections: {
                    SocketID: string;
                    AssetID: string;
                    TypeID: string;
                }[];
            };
            Items: Record<string, {
                TypeID: string;
                ID: string;
                Sockets: Record<string, {
                    ID: string;
                    Item: {
                        TypeID: string;
                        ID: string;
                    };
                }>;
            }>;
        };
    }[];
}>;
declare const _default$u: Omit<{
    requirements: string[];
    type: "auth" | "local" | "pd" | "glz" | "shared";
    name: string;
    method: "PUT" | "GET" | "DELETE" | "POST";
    url: string;
    description?: string | undefined;
    headers?: Record<string, string> | undefined;
    body?: z.ZodType<any, z.ZodTypeDef, any> | undefined;
    query?: z.ZodType<any, z.ZodTypeDef, any> | undefined;
    responses?: Record<string, z.ZodType<any, z.ZodTypeDef, any>> | undefined;
}, "type" | "name" | "url"> & Pick<{
    readonly name: "Current Game Loadouts";
    readonly description: "Get the current game loadout info for all players in the match";
    readonly type: "glz";
    readonly url: "core-game/v1/matches/:currentGameMatchId/loadouts";
    readonly responses: {
        readonly "200": z.ZodObject<{
            Loadouts: z.ZodArray<z.ZodObject<{
                CharacterID: z.ZodString;
                Loadout: z.ZodObject<{
                    Subject: z.ZodString;
                    Sprays: z.ZodObject<{
                        SpraySelections: z.ZodArray<z.ZodObject<{
                            SocketID: z.ZodString;
                            SprayID: z.ZodString;
                            LevelID: z.ZodString;
                        }, "strip", z.ZodTypeAny, {
                            SocketID: string;
                            SprayID: string;
                            LevelID: string;
                        }, {
                            SocketID: string;
                            SprayID: string;
                            LevelID: string;
                        }>, "many">;
                    }, "strip", z.ZodTypeAny, {
                        SpraySelections: {
                            SocketID: string;
                            SprayID: string;
                            LevelID: string;
                        }[];
                    }, {
                        SpraySelections: {
                            SocketID: string;
                            SprayID: string;
                            LevelID: string;
                        }[];
                    }>;
                    Expressions: z.ZodObject<{
                        AESSelections: z.ZodArray<z.ZodObject<{
                            SocketID: z.ZodString;
                            AssetID: z.ZodString;
                            TypeID: z.ZodString;
                        }, "strip", z.ZodTypeAny, {
                            SocketID: string;
                            AssetID: string;
                            TypeID: string;
                        }, {
                            SocketID: string;
                            AssetID: string;
                            TypeID: string;
                        }>, "many">;
                    }, "strip", z.ZodTypeAny, {
                        AESSelections: {
                            SocketID: string;
                            AssetID: string;
                            TypeID: string;
                        }[];
                    }, {
                        AESSelections: {
                            SocketID: string;
                            AssetID: string;
                            TypeID: string;
                        }[];
                    }>;
                    Items: z.ZodRecord<z.ZodString, z.ZodObject<{
                        ID: z.ZodString;
                        TypeID: z.ZodString;
                        Sockets: z.ZodRecord<z.ZodString, z.ZodObject<{
                            ID: z.ZodString;
                            Item: z.ZodObject<{
                                ID: z.ZodString;
                                TypeID: z.ZodString;
                            }, "strip", z.ZodTypeAny, {
                                TypeID: string;
                                ID: string;
                            }, {
                                TypeID: string;
                                ID: string;
                            }>;
                        }, "strip", z.ZodTypeAny, {
                            ID: string;
                            Item: {
                                TypeID: string;
                                ID: string;
                            };
                        }, {
                            ID: string;
                            Item: {
                                TypeID: string;
                                ID: string;
                            };
                        }>>;
                    }, "strip", z.ZodTypeAny, {
                        TypeID: string;
                        ID: string;
                        Sockets: Record<string, {
                            ID: string;
                            Item: {
                                TypeID: string;
                                ID: string;
                            };
                        }>;
                    }, {
                        TypeID: string;
                        ID: string;
                        Sockets: Record<string, {
                            ID: string;
                            Item: {
                                TypeID: string;
                                ID: string;
                            };
                        }>;
                    }>>;
                }, "strip", z.ZodTypeAny, {
                    Subject: string;
                    Sprays: {
                        SpraySelections: {
                            SocketID: string;
                            SprayID: string;
                            LevelID: string;
                        }[];
                    };
                    Expressions: {
                        AESSelections: {
                            SocketID: string;
                            AssetID: string;
                            TypeID: string;
                        }[];
                    };
                    Items: Record<string, {
                        TypeID: string;
                        ID: string;
                        Sockets: Record<string, {
                            ID: string;
                            Item: {
                                TypeID: string;
                                ID: string;
                            };
                        }>;
                    }>;
                }, {
                    Subject: string;
                    Sprays: {
                        SpraySelections: {
                            SocketID: string;
                            SprayID: string;
                            LevelID: string;
                        }[];
                    };
                    Expressions: {
                        AESSelections: {
                            SocketID: string;
                            AssetID: string;
                            TypeID: string;
                        }[];
                    };
                    Items: Record<string, {
                        TypeID: string;
                        ID: string;
                        Sockets: Record<string, {
                            ID: string;
                            Item: {
                                TypeID: string;
                                ID: string;
                            };
                        }>;
                    }>;
                }>;
            }, "strip", z.ZodTypeAny, {
                CharacterID: string;
                Loadout: {
                    Subject: string;
                    Sprays: {
                        SpraySelections: {
                            SocketID: string;
                            SprayID: string;
                            LevelID: string;
                        }[];
                    };
                    Expressions: {
                        AESSelections: {
                            SocketID: string;
                            AssetID: string;
                            TypeID: string;
                        }[];
                    };
                    Items: Record<string, {
                        TypeID: string;
                        ID: string;
                        Sockets: Record<string, {
                            ID: string;
                            Item: {
                                TypeID: string;
                                ID: string;
                            };
                        }>;
                    }>;
                };
            }, {
                CharacterID: string;
                Loadout: {
                    Subject: string;
                    Sprays: {
                        SpraySelections: {
                            SocketID: string;
                            SprayID: string;
                            LevelID: string;
                        }[];
                    };
                    Expressions: {
                        AESSelections: {
                            SocketID: string;
                            AssetID: string;
                            TypeID: string;
                        }[];
                    };
                    Items: Record<string, {
                        TypeID: string;
                        ID: string;
                        Sockets: Record<string, {
                            ID: string;
                            Item: {
                                TypeID: string;
                                ID: string;
                            };
                        }>;
                    }>;
                };
            }>, "many">;
        }, "strip", z.ZodTypeAny, {
            Loadouts: {
                CharacterID: string;
                Loadout: {
                    Subject: string;
                    Sprays: {
                        SpraySelections: {
                            SocketID: string;
                            SprayID: string;
                            LevelID: string;
                        }[];
                    };
                    Expressions: {
                        AESSelections: {
                            SocketID: string;
                            AssetID: string;
                            TypeID: string;
                        }[];
                    };
                    Items: Record<string, {
                        TypeID: string;
                        ID: string;
                        Sockets: Record<string, {
                            ID: string;
                            Item: {
                                TypeID: string;
                                ID: string;
                            };
                        }>;
                    }>;
                };
            }[];
        }, {
            Loadouts: {
                CharacterID: string;
                Loadout: {
                    Subject: string;
                    Sprays: {
                        SpraySelections: {
                            SocketID: string;
                            SprayID: string;
                            LevelID: string;
                        }[];
                    };
                    Expressions: {
                        AESSelections: {
                            SocketID: string;
                            AssetID: string;
                            TypeID: string;
                        }[];
                    };
                    Items: Record<string, {
                        TypeID: string;
                        ID: string;
                        Sockets: Record<string, {
                            ID: string;
                            Item: {
                                TypeID: string;
                                ID: string;
                            };
                        }>;
                    }>;
                };
            }[];
        }>;
    };
}, "type" | "name" | "url"> & {
    "~type": {
        readonly name: "Current Game Loadouts";
        readonly description: "Get the current game loadout info for all players in the match";
        readonly type: "glz";
        readonly url: "core-game/v1/matches/:currentGameMatchId/loadouts";
        readonly responses: {
            readonly "200": z.ZodObject<{
                Loadouts: z.ZodArray<z.ZodObject<{
                    CharacterID: z.ZodString;
                    Loadout: z.ZodObject<{
                        Subject: z.ZodString;
                        Sprays: z.ZodObject<{
                            SpraySelections: z.ZodArray<z.ZodObject<{
                                SocketID: z.ZodString;
                                SprayID: z.ZodString;
                                LevelID: z.ZodString;
                            }, "strip", z.ZodTypeAny, {
                                SocketID: string;
                                SprayID: string;
                                LevelID: string;
                            }, {
                                SocketID: string;
                                SprayID: string;
                                LevelID: string;
                            }>, "many">;
                        }, "strip", z.ZodTypeAny, {
                            SpraySelections: {
                                SocketID: string;
                                SprayID: string;
                                LevelID: string;
                            }[];
                        }, {
                            SpraySelections: {
                                SocketID: string;
                                SprayID: string;
                                LevelID: string;
                            }[];
                        }>;
                        Expressions: z.ZodObject<{
                            AESSelections: z.ZodArray<z.ZodObject<{
                                SocketID: z.ZodString;
                                AssetID: z.ZodString;
                                TypeID: z.ZodString;
                            }, "strip", z.ZodTypeAny, {
                                SocketID: string;
                                AssetID: string;
                                TypeID: string;
                            }, {
                                SocketID: string;
                                AssetID: string;
                                TypeID: string;
                            }>, "many">;
                        }, "strip", z.ZodTypeAny, {
                            AESSelections: {
                                SocketID: string;
                                AssetID: string;
                                TypeID: string;
                            }[];
                        }, {
                            AESSelections: {
                                SocketID: string;
                                AssetID: string;
                                TypeID: string;
                            }[];
                        }>;
                        Items: z.ZodRecord<z.ZodString, z.ZodObject<{
                            ID: z.ZodString;
                            TypeID: z.ZodString;
                            Sockets: z.ZodRecord<z.ZodString, z.ZodObject<{
                                ID: z.ZodString;
                                Item: z.ZodObject<{
                                    ID: z.ZodString;
                                    TypeID: z.ZodString;
                                }, "strip", z.ZodTypeAny, {
                                    TypeID: string;
                                    ID: string;
                                }, {
                                    TypeID: string;
                                    ID: string;
                                }>;
                            }, "strip", z.ZodTypeAny, {
                                ID: string;
                                Item: {
                                    TypeID: string;
                                    ID: string;
                                };
                            }, {
                                ID: string;
                                Item: {
                                    TypeID: string;
                                    ID: string;
                                };
                            }>>;
                        }, "strip", z.ZodTypeAny, {
                            TypeID: string;
                            ID: string;
                            Sockets: Record<string, {
                                ID: string;
                                Item: {
                                    TypeID: string;
                                    ID: string;
                                };
                            }>;
                        }, {
                            TypeID: string;
                            ID: string;
                            Sockets: Record<string, {
                                ID: string;
                                Item: {
                                    TypeID: string;
                                    ID: string;
                                };
                            }>;
                        }>>;
                    }, "strip", z.ZodTypeAny, {
                        Subject: string;
                        Sprays: {
                            SpraySelections: {
                                SocketID: string;
                                SprayID: string;
                                LevelID: string;
                            }[];
                        };
                        Expressions: {
                            AESSelections: {
                                SocketID: string;
                                AssetID: string;
                                TypeID: string;
                            }[];
                        };
                        Items: Record<string, {
                            TypeID: string;
                            ID: string;
                            Sockets: Record<string, {
                                ID: string;
                                Item: {
                                    TypeID: string;
                                    ID: string;
                                };
                            }>;
                        }>;
                    }, {
                        Subject: string;
                        Sprays: {
                            SpraySelections: {
                                SocketID: string;
                                SprayID: string;
                                LevelID: string;
                            }[];
                        };
                        Expressions: {
                            AESSelections: {
                                SocketID: string;
                                AssetID: string;
                                TypeID: string;
                            }[];
                        };
                        Items: Record<string, {
                            TypeID: string;
                            ID: string;
                            Sockets: Record<string, {
                                ID: string;
                                Item: {
                                    TypeID: string;
                                    ID: string;
                                };
                            }>;
                        }>;
                    }>;
                }, "strip", z.ZodTypeAny, {
                    CharacterID: string;
                    Loadout: {
                        Subject: string;
                        Sprays: {
                            SpraySelections: {
                                SocketID: string;
                                SprayID: string;
                                LevelID: string;
                            }[];
                        };
                        Expressions: {
                            AESSelections: {
                                SocketID: string;
                                AssetID: string;
                                TypeID: string;
                            }[];
                        };
                        Items: Record<string, {
                            TypeID: string;
                            ID: string;
                            Sockets: Record<string, {
                                ID: string;
                                Item: {
                                    TypeID: string;
                                    ID: string;
                                };
                            }>;
                        }>;
                    };
                }, {
                    CharacterID: string;
                    Loadout: {
                        Subject: string;
                        Sprays: {
                            SpraySelections: {
                                SocketID: string;
                                SprayID: string;
                                LevelID: string;
                            }[];
                        };
                        Expressions: {
                            AESSelections: {
                                SocketID: string;
                                AssetID: string;
                                TypeID: string;
                            }[];
                        };
                        Items: Record<string, {
                            TypeID: string;
                            ID: string;
                            Sockets: Record<string, {
                                ID: string;
                                Item: {
                                    TypeID: string;
                                    ID: string;
                                };
                            }>;
                        }>;
                    };
                }>, "many">;
            }, "strip", z.ZodTypeAny, {
                Loadouts: {
                    CharacterID: string;
                    Loadout: {
                        Subject: string;
                        Sprays: {
                            SpraySelections: {
                                SocketID: string;
                                SprayID: string;
                                LevelID: string;
                            }[];
                        };
                        Expressions: {
                            AESSelections: {
                                SocketID: string;
                                AssetID: string;
                                TypeID: string;
                            }[];
                        };
                        Items: Record<string, {
                            TypeID: string;
                            ID: string;
                            Sockets: Record<string, {
                                ID: string;
                                Item: {
                                    TypeID: string;
                                    ID: string;
                                };
                            }>;
                        }>;
                    };
                }[];
            }, {
                Loadouts: {
                    CharacterID: string;
                    Loadout: {
                        Subject: string;
                        Sprays: {
                            SpraySelections: {
                                SocketID: string;
                                SprayID: string;
                                LevelID: string;
                            }[];
                        };
                        Expressions: {
                            AESSelections: {
                                SocketID: string;
                                AssetID: string;
                                TypeID: string;
                            }[];
                        };
                        Items: Record<string, {
                            TypeID: string;
                            ID: string;
                            Sockets: Record<string, {
                                ID: string;
                                Item: {
                                    TypeID: string;
                                    ID: string;
                                };
                            }>;
                        }>;
                    };
                }[];
            }>;
        };
    };
};

type Params$u = ResolveParams<(typeof _default$u)["~type"]["url"]>;
type Body$u = z.infer<ResolveValue<(typeof _default$u)["~type"], "body">>;
type Data$u = ResolveData<Params$u, Body$u>;
type Response$u = z.infer<ResolveValue<(typeof _default$u)["~type"], "responses">["200"]>;
interface CurrentGameLoadoutsRequestConfig extends ValorantAxiosRequestConfig<Data$u> {
}
declare class CurrentGameLoadoutsEndpoint {
    /**
     * Get the current game loadout info for all players in the match
     *
     * @EndpointType glz
     */
    getCurrentGameLoadouts<T = Response$u>(this: RemoteApiClient, config: CurrentGameLoadoutsRequestConfig): Promise<AxiosResponse<T>>;
}

declare const CurrentGameMatchResponseSchema: z.ZodObject<{
    MatchID: z.ZodString;
    Version: z.ZodNumber;
    State: z.ZodEnum<["IN_PROGRESS"]>;
    MapID: z.ZodString;
    ModeID: z.ZodString;
    ProvisioningFlow: z.ZodEnum<["Matchmaking", "CustomGame"]>;
    GamePodID: z.ZodString;
    AllMUCName: z.ZodString;
    TeamMUCName: z.ZodString;
    TeamVoiceID: z.ZodString;
    TeamMatchToken: z.ZodString;
    IsReconnectable: z.ZodBoolean;
    ConnectionDetails: z.ZodObject<{
        GameServerHosts: z.ZodArray<z.ZodString, "many">;
        GameServerHost: z.ZodString;
        GameServerPort: z.ZodNumber;
        GameServerObfuscatedIP: z.ZodNumber;
        GameClientHash: z.ZodNumber;
        PlayerKey: z.ZodString;
    }, "strip", z.ZodTypeAny, {
        GameServerHosts: string[];
        GameServerHost: string;
        GameServerPort: number;
        GameServerObfuscatedIP: number;
        GameClientHash: number;
        PlayerKey: string;
    }, {
        GameServerHosts: string[];
        GameServerHost: string;
        GameServerPort: number;
        GameServerObfuscatedIP: number;
        GameClientHash: number;
        PlayerKey: string;
    }>;
    PostGameDetails: z.ZodNull;
    Players: z.ZodArray<z.ZodObject<{
        Subject: z.ZodString;
        TeamID: z.ZodUnion<[z.ZodEnum<["Blue", "Red"]>, z.ZodString]>;
        CharacterID: z.ZodString;
        PlayerIdentity: z.ZodObject<{
            Subject: z.ZodString;
            PlayerCardID: z.ZodString;
            PlayerTitleID: z.ZodString;
            AccountLevel: z.ZodNumber;
            PreferredLevelBorderID: z.ZodUnion<[z.ZodString, z.ZodLiteral<"">]>;
            Incognito: z.ZodBoolean;
            HideAccountLevel: z.ZodBoolean;
        }, "strip", z.ZodTypeAny, {
            Subject: string;
            PlayerCardID: string;
            PlayerTitleID: string;
            AccountLevel: number;
            PreferredLevelBorderID: string;
            Incognito: boolean;
            HideAccountLevel: boolean;
        }, {
            Subject: string;
            PlayerCardID: string;
            PlayerTitleID: string;
            AccountLevel: number;
            PreferredLevelBorderID: string;
            Incognito: boolean;
            HideAccountLevel: boolean;
        }>;
        SeasonalBadgeInfo: z.ZodObject<{
            SeasonID: z.ZodUnion<[z.ZodString, z.ZodLiteral<"">]>;
            NumberOfWins: z.ZodNumber;
            WinsByTier: z.ZodNull;
            Rank: z.ZodNumber;
            LeaderboardRank: z.ZodNumber;
        }, "strip", z.ZodTypeAny, {
            SeasonID: string;
            NumberOfWins: number;
            WinsByTier: null;
            Rank: number;
            LeaderboardRank: number;
        }, {
            SeasonID: string;
            NumberOfWins: number;
            WinsByTier: null;
            Rank: number;
            LeaderboardRank: number;
        }>;
        IsCoach: z.ZodBoolean;
        IsAssociated: z.ZodBoolean;
    }, "strip", z.ZodTypeAny, {
        CharacterID: string;
        Subject: string;
        TeamID: string;
        PlayerIdentity: {
            Subject: string;
            PlayerCardID: string;
            PlayerTitleID: string;
            AccountLevel: number;
            PreferredLevelBorderID: string;
            Incognito: boolean;
            HideAccountLevel: boolean;
        };
        SeasonalBadgeInfo: {
            SeasonID: string;
            NumberOfWins: number;
            WinsByTier: null;
            Rank: number;
            LeaderboardRank: number;
        };
        IsCoach: boolean;
        IsAssociated: boolean;
    }, {
        CharacterID: string;
        Subject: string;
        TeamID: string;
        PlayerIdentity: {
            Subject: string;
            PlayerCardID: string;
            PlayerTitleID: string;
            AccountLevel: number;
            PreferredLevelBorderID: string;
            Incognito: boolean;
            HideAccountLevel: boolean;
        };
        SeasonalBadgeInfo: {
            SeasonID: string;
            NumberOfWins: number;
            WinsByTier: null;
            Rank: number;
            LeaderboardRank: number;
        };
        IsCoach: boolean;
        IsAssociated: boolean;
    }>, "many">;
    MatchmakingData: z.ZodNull;
}, "strip", z.ZodTypeAny, {
    Version: number;
    MatchID: string;
    State: "IN_PROGRESS";
    MapID: string;
    ModeID: string;
    ProvisioningFlow: "Matchmaking" | "CustomGame";
    GamePodID: string;
    AllMUCName: string;
    TeamMUCName: string;
    TeamVoiceID: string;
    TeamMatchToken: string;
    IsReconnectable: boolean;
    ConnectionDetails: {
        GameServerHosts: string[];
        GameServerHost: string;
        GameServerPort: number;
        GameServerObfuscatedIP: number;
        GameClientHash: number;
        PlayerKey: string;
    };
    PostGameDetails: null;
    Players: {
        CharacterID: string;
        Subject: string;
        TeamID: string;
        PlayerIdentity: {
            Subject: string;
            PlayerCardID: string;
            PlayerTitleID: string;
            AccountLevel: number;
            PreferredLevelBorderID: string;
            Incognito: boolean;
            HideAccountLevel: boolean;
        };
        SeasonalBadgeInfo: {
            SeasonID: string;
            NumberOfWins: number;
            WinsByTier: null;
            Rank: number;
            LeaderboardRank: number;
        };
        IsCoach: boolean;
        IsAssociated: boolean;
    }[];
    MatchmakingData: null;
}, {
    Version: number;
    MatchID: string;
    State: "IN_PROGRESS";
    MapID: string;
    ModeID: string;
    ProvisioningFlow: "Matchmaking" | "CustomGame";
    GamePodID: string;
    AllMUCName: string;
    TeamMUCName: string;
    TeamVoiceID: string;
    TeamMatchToken: string;
    IsReconnectable: boolean;
    ConnectionDetails: {
        GameServerHosts: string[];
        GameServerHost: string;
        GameServerPort: number;
        GameServerObfuscatedIP: number;
        GameClientHash: number;
        PlayerKey: string;
    };
    PostGameDetails: null;
    Players: {
        CharacterID: string;
        Subject: string;
        TeamID: string;
        PlayerIdentity: {
            Subject: string;
            PlayerCardID: string;
            PlayerTitleID: string;
            AccountLevel: number;
            PreferredLevelBorderID: string;
            Incognito: boolean;
            HideAccountLevel: boolean;
        };
        SeasonalBadgeInfo: {
            SeasonID: string;
            NumberOfWins: number;
            WinsByTier: null;
            Rank: number;
            LeaderboardRank: number;
        };
        IsCoach: boolean;
        IsAssociated: boolean;
    }[];
    MatchmakingData: null;
}>;
declare const _default$t: Omit<{
    requirements: string[];
    type: "auth" | "local" | "pd" | "glz" | "shared";
    name: string;
    method: "PUT" | "GET" | "DELETE" | "POST";
    url: string;
    description?: string | undefined;
    headers?: Record<string, string> | undefined;
    body?: z.ZodType<any, z.ZodTypeDef, any> | undefined;
    query?: z.ZodType<any, z.ZodTypeDef, any> | undefined;
    responses?: Record<string, z.ZodType<any, z.ZodTypeDef, any>> | undefined;
}, "type" | "name" | "url"> & Pick<{
    readonly name: "Current Game Match";
    readonly description: "Get the current game match info";
    readonly type: "glz";
    readonly url: "core-game/v1/matches/:currentGameMatchId";
    readonly responses: {
        readonly "200": z.ZodObject<{
            MatchID: z.ZodString;
            Version: z.ZodNumber;
            State: z.ZodEnum<["IN_PROGRESS"]>;
            MapID: z.ZodString;
            ModeID: z.ZodString;
            ProvisioningFlow: z.ZodEnum<["Matchmaking", "CustomGame"]>;
            GamePodID: z.ZodString;
            AllMUCName: z.ZodString;
            TeamMUCName: z.ZodString;
            TeamVoiceID: z.ZodString;
            TeamMatchToken: z.ZodString;
            IsReconnectable: z.ZodBoolean;
            ConnectionDetails: z.ZodObject<{
                GameServerHosts: z.ZodArray<z.ZodString, "many">;
                GameServerHost: z.ZodString;
                GameServerPort: z.ZodNumber;
                GameServerObfuscatedIP: z.ZodNumber;
                GameClientHash: z.ZodNumber;
                PlayerKey: z.ZodString;
            }, "strip", z.ZodTypeAny, {
                GameServerHosts: string[];
                GameServerHost: string;
                GameServerPort: number;
                GameServerObfuscatedIP: number;
                GameClientHash: number;
                PlayerKey: string;
            }, {
                GameServerHosts: string[];
                GameServerHost: string;
                GameServerPort: number;
                GameServerObfuscatedIP: number;
                GameClientHash: number;
                PlayerKey: string;
            }>;
            PostGameDetails: z.ZodNull;
            Players: z.ZodArray<z.ZodObject<{
                Subject: z.ZodString;
                TeamID: z.ZodUnion<[z.ZodEnum<["Blue", "Red"]>, z.ZodString]>;
                CharacterID: z.ZodString;
                PlayerIdentity: z.ZodObject<{
                    Subject: z.ZodString;
                    PlayerCardID: z.ZodString;
                    PlayerTitleID: z.ZodString;
                    AccountLevel: z.ZodNumber;
                    PreferredLevelBorderID: z.ZodUnion<[z.ZodString, z.ZodLiteral<"">]>;
                    Incognito: z.ZodBoolean;
                    HideAccountLevel: z.ZodBoolean;
                }, "strip", z.ZodTypeAny, {
                    Subject: string;
                    PlayerCardID: string;
                    PlayerTitleID: string;
                    AccountLevel: number;
                    PreferredLevelBorderID: string;
                    Incognito: boolean;
                    HideAccountLevel: boolean;
                }, {
                    Subject: string;
                    PlayerCardID: string;
                    PlayerTitleID: string;
                    AccountLevel: number;
                    PreferredLevelBorderID: string;
                    Incognito: boolean;
                    HideAccountLevel: boolean;
                }>;
                SeasonalBadgeInfo: z.ZodObject<{
                    SeasonID: z.ZodUnion<[z.ZodString, z.ZodLiteral<"">]>;
                    NumberOfWins: z.ZodNumber;
                    WinsByTier: z.ZodNull;
                    Rank: z.ZodNumber;
                    LeaderboardRank: z.ZodNumber;
                }, "strip", z.ZodTypeAny, {
                    SeasonID: string;
                    NumberOfWins: number;
                    WinsByTier: null;
                    Rank: number;
                    LeaderboardRank: number;
                }, {
                    SeasonID: string;
                    NumberOfWins: number;
                    WinsByTier: null;
                    Rank: number;
                    LeaderboardRank: number;
                }>;
                IsCoach: z.ZodBoolean;
                IsAssociated: z.ZodBoolean;
            }, "strip", z.ZodTypeAny, {
                CharacterID: string;
                Subject: string;
                TeamID: string;
                PlayerIdentity: {
                    Subject: string;
                    PlayerCardID: string;
                    PlayerTitleID: string;
                    AccountLevel: number;
                    PreferredLevelBorderID: string;
                    Incognito: boolean;
                    HideAccountLevel: boolean;
                };
                SeasonalBadgeInfo: {
                    SeasonID: string;
                    NumberOfWins: number;
                    WinsByTier: null;
                    Rank: number;
                    LeaderboardRank: number;
                };
                IsCoach: boolean;
                IsAssociated: boolean;
            }, {
                CharacterID: string;
                Subject: string;
                TeamID: string;
                PlayerIdentity: {
                    Subject: string;
                    PlayerCardID: string;
                    PlayerTitleID: string;
                    AccountLevel: number;
                    PreferredLevelBorderID: string;
                    Incognito: boolean;
                    HideAccountLevel: boolean;
                };
                SeasonalBadgeInfo: {
                    SeasonID: string;
                    NumberOfWins: number;
                    WinsByTier: null;
                    Rank: number;
                    LeaderboardRank: number;
                };
                IsCoach: boolean;
                IsAssociated: boolean;
            }>, "many">;
            MatchmakingData: z.ZodNull;
        }, "strip", z.ZodTypeAny, {
            Version: number;
            MatchID: string;
            State: "IN_PROGRESS";
            MapID: string;
            ModeID: string;
            ProvisioningFlow: "Matchmaking" | "CustomGame";
            GamePodID: string;
            AllMUCName: string;
            TeamMUCName: string;
            TeamVoiceID: string;
            TeamMatchToken: string;
            IsReconnectable: boolean;
            ConnectionDetails: {
                GameServerHosts: string[];
                GameServerHost: string;
                GameServerPort: number;
                GameServerObfuscatedIP: number;
                GameClientHash: number;
                PlayerKey: string;
            };
            PostGameDetails: null;
            Players: {
                CharacterID: string;
                Subject: string;
                TeamID: string;
                PlayerIdentity: {
                    Subject: string;
                    PlayerCardID: string;
                    PlayerTitleID: string;
                    AccountLevel: number;
                    PreferredLevelBorderID: string;
                    Incognito: boolean;
                    HideAccountLevel: boolean;
                };
                SeasonalBadgeInfo: {
                    SeasonID: string;
                    NumberOfWins: number;
                    WinsByTier: null;
                    Rank: number;
                    LeaderboardRank: number;
                };
                IsCoach: boolean;
                IsAssociated: boolean;
            }[];
            MatchmakingData: null;
        }, {
            Version: number;
            MatchID: string;
            State: "IN_PROGRESS";
            MapID: string;
            ModeID: string;
            ProvisioningFlow: "Matchmaking" | "CustomGame";
            GamePodID: string;
            AllMUCName: string;
            TeamMUCName: string;
            TeamVoiceID: string;
            TeamMatchToken: string;
            IsReconnectable: boolean;
            ConnectionDetails: {
                GameServerHosts: string[];
                GameServerHost: string;
                GameServerPort: number;
                GameServerObfuscatedIP: number;
                GameClientHash: number;
                PlayerKey: string;
            };
            PostGameDetails: null;
            Players: {
                CharacterID: string;
                Subject: string;
                TeamID: string;
                PlayerIdentity: {
                    Subject: string;
                    PlayerCardID: string;
                    PlayerTitleID: string;
                    AccountLevel: number;
                    PreferredLevelBorderID: string;
                    Incognito: boolean;
                    HideAccountLevel: boolean;
                };
                SeasonalBadgeInfo: {
                    SeasonID: string;
                    NumberOfWins: number;
                    WinsByTier: null;
                    Rank: number;
                    LeaderboardRank: number;
                };
                IsCoach: boolean;
                IsAssociated: boolean;
            }[];
            MatchmakingData: null;
        }>;
    };
}, "type" | "name" | "url"> & {
    "~type": {
        readonly name: "Current Game Match";
        readonly description: "Get the current game match info";
        readonly type: "glz";
        readonly url: "core-game/v1/matches/:currentGameMatchId";
        readonly responses: {
            readonly "200": z.ZodObject<{
                MatchID: z.ZodString;
                Version: z.ZodNumber;
                State: z.ZodEnum<["IN_PROGRESS"]>;
                MapID: z.ZodString;
                ModeID: z.ZodString;
                ProvisioningFlow: z.ZodEnum<["Matchmaking", "CustomGame"]>;
                GamePodID: z.ZodString;
                AllMUCName: z.ZodString;
                TeamMUCName: z.ZodString;
                TeamVoiceID: z.ZodString;
                TeamMatchToken: z.ZodString;
                IsReconnectable: z.ZodBoolean;
                ConnectionDetails: z.ZodObject<{
                    GameServerHosts: z.ZodArray<z.ZodString, "many">;
                    GameServerHost: z.ZodString;
                    GameServerPort: z.ZodNumber;
                    GameServerObfuscatedIP: z.ZodNumber;
                    GameClientHash: z.ZodNumber;
                    PlayerKey: z.ZodString;
                }, "strip", z.ZodTypeAny, {
                    GameServerHosts: string[];
                    GameServerHost: string;
                    GameServerPort: number;
                    GameServerObfuscatedIP: number;
                    GameClientHash: number;
                    PlayerKey: string;
                }, {
                    GameServerHosts: string[];
                    GameServerHost: string;
                    GameServerPort: number;
                    GameServerObfuscatedIP: number;
                    GameClientHash: number;
                    PlayerKey: string;
                }>;
                PostGameDetails: z.ZodNull;
                Players: z.ZodArray<z.ZodObject<{
                    Subject: z.ZodString;
                    TeamID: z.ZodUnion<[z.ZodEnum<["Blue", "Red"]>, z.ZodString]>;
                    CharacterID: z.ZodString;
                    PlayerIdentity: z.ZodObject<{
                        Subject: z.ZodString;
                        PlayerCardID: z.ZodString;
                        PlayerTitleID: z.ZodString;
                        AccountLevel: z.ZodNumber;
                        PreferredLevelBorderID: z.ZodUnion<[z.ZodString, z.ZodLiteral<"">]>;
                        Incognito: z.ZodBoolean;
                        HideAccountLevel: z.ZodBoolean;
                    }, "strip", z.ZodTypeAny, {
                        Subject: string;
                        PlayerCardID: string;
                        PlayerTitleID: string;
                        AccountLevel: number;
                        PreferredLevelBorderID: string;
                        Incognito: boolean;
                        HideAccountLevel: boolean;
                    }, {
                        Subject: string;
                        PlayerCardID: string;
                        PlayerTitleID: string;
                        AccountLevel: number;
                        PreferredLevelBorderID: string;
                        Incognito: boolean;
                        HideAccountLevel: boolean;
                    }>;
                    SeasonalBadgeInfo: z.ZodObject<{
                        SeasonID: z.ZodUnion<[z.ZodString, z.ZodLiteral<"">]>;
                        NumberOfWins: z.ZodNumber;
                        WinsByTier: z.ZodNull;
                        Rank: z.ZodNumber;
                        LeaderboardRank: z.ZodNumber;
                    }, "strip", z.ZodTypeAny, {
                        SeasonID: string;
                        NumberOfWins: number;
                        WinsByTier: null;
                        Rank: number;
                        LeaderboardRank: number;
                    }, {
                        SeasonID: string;
                        NumberOfWins: number;
                        WinsByTier: null;
                        Rank: number;
                        LeaderboardRank: number;
                    }>;
                    IsCoach: z.ZodBoolean;
                    IsAssociated: z.ZodBoolean;
                }, "strip", z.ZodTypeAny, {
                    CharacterID: string;
                    Subject: string;
                    TeamID: string;
                    PlayerIdentity: {
                        Subject: string;
                        PlayerCardID: string;
                        PlayerTitleID: string;
                        AccountLevel: number;
                        PreferredLevelBorderID: string;
                        Incognito: boolean;
                        HideAccountLevel: boolean;
                    };
                    SeasonalBadgeInfo: {
                        SeasonID: string;
                        NumberOfWins: number;
                        WinsByTier: null;
                        Rank: number;
                        LeaderboardRank: number;
                    };
                    IsCoach: boolean;
                    IsAssociated: boolean;
                }, {
                    CharacterID: string;
                    Subject: string;
                    TeamID: string;
                    PlayerIdentity: {
                        Subject: string;
                        PlayerCardID: string;
                        PlayerTitleID: string;
                        AccountLevel: number;
                        PreferredLevelBorderID: string;
                        Incognito: boolean;
                        HideAccountLevel: boolean;
                    };
                    SeasonalBadgeInfo: {
                        SeasonID: string;
                        NumberOfWins: number;
                        WinsByTier: null;
                        Rank: number;
                        LeaderboardRank: number;
                    };
                    IsCoach: boolean;
                    IsAssociated: boolean;
                }>, "many">;
                MatchmakingData: z.ZodNull;
            }, "strip", z.ZodTypeAny, {
                Version: number;
                MatchID: string;
                State: "IN_PROGRESS";
                MapID: string;
                ModeID: string;
                ProvisioningFlow: "Matchmaking" | "CustomGame";
                GamePodID: string;
                AllMUCName: string;
                TeamMUCName: string;
                TeamVoiceID: string;
                TeamMatchToken: string;
                IsReconnectable: boolean;
                ConnectionDetails: {
                    GameServerHosts: string[];
                    GameServerHost: string;
                    GameServerPort: number;
                    GameServerObfuscatedIP: number;
                    GameClientHash: number;
                    PlayerKey: string;
                };
                PostGameDetails: null;
                Players: {
                    CharacterID: string;
                    Subject: string;
                    TeamID: string;
                    PlayerIdentity: {
                        Subject: string;
                        PlayerCardID: string;
                        PlayerTitleID: string;
                        AccountLevel: number;
                        PreferredLevelBorderID: string;
                        Incognito: boolean;
                        HideAccountLevel: boolean;
                    };
                    SeasonalBadgeInfo: {
                        SeasonID: string;
                        NumberOfWins: number;
                        WinsByTier: null;
                        Rank: number;
                        LeaderboardRank: number;
                    };
                    IsCoach: boolean;
                    IsAssociated: boolean;
                }[];
                MatchmakingData: null;
            }, {
                Version: number;
                MatchID: string;
                State: "IN_PROGRESS";
                MapID: string;
                ModeID: string;
                ProvisioningFlow: "Matchmaking" | "CustomGame";
                GamePodID: string;
                AllMUCName: string;
                TeamMUCName: string;
                TeamVoiceID: string;
                TeamMatchToken: string;
                IsReconnectable: boolean;
                ConnectionDetails: {
                    GameServerHosts: string[];
                    GameServerHost: string;
                    GameServerPort: number;
                    GameServerObfuscatedIP: number;
                    GameClientHash: number;
                    PlayerKey: string;
                };
                PostGameDetails: null;
                Players: {
                    CharacterID: string;
                    Subject: string;
                    TeamID: string;
                    PlayerIdentity: {
                        Subject: string;
                        PlayerCardID: string;
                        PlayerTitleID: string;
                        AccountLevel: number;
                        PreferredLevelBorderID: string;
                        Incognito: boolean;
                        HideAccountLevel: boolean;
                    };
                    SeasonalBadgeInfo: {
                        SeasonID: string;
                        NumberOfWins: number;
                        WinsByTier: null;
                        Rank: number;
                        LeaderboardRank: number;
                    };
                    IsCoach: boolean;
                    IsAssociated: boolean;
                }[];
                MatchmakingData: null;
            }>;
        };
    };
};

type Params$t = ResolveParams<(typeof _default$t)["~type"]["url"]>;
type Body$t = z.infer<ResolveValue<(typeof _default$t)["~type"], "body">>;
type Data$t = ResolveData<Params$t, Body$t>;
type Response$t = z.infer<ResolveValue<(typeof _default$t)["~type"], "responses">["200"]>;
interface CurrentGameMatchRequestConfig extends ValorantAxiosRequestConfig<Data$t> {
}
declare class CurrentGameMatchEndpoint {
    /**
     * Get the current game match info
     *
     * @EndpointType glz
     */
    getCurrentGameMatch<T = Response$t>(this: RemoteApiClient, config: CurrentGameMatchRequestConfig): Promise<AxiosResponse<T>>;
}

declare const CurrentGamePlayerResponseSchema: z.ZodObject<{
    Subject: z.ZodString;
    MatchID: z.ZodString;
    Version: z.ZodNumber;
}, "strip", z.ZodTypeAny, {
    Subject: string;
    Version: number;
    MatchID: string;
}, {
    Subject: string;
    Version: number;
    MatchID: string;
}>;
declare const _default$s: Omit<{
    requirements: string[];
    type: "auth" | "local" | "pd" | "glz" | "shared";
    name: string;
    method: "PUT" | "GET" | "DELETE" | "POST";
    url: string;
    description?: string | undefined;
    headers?: Record<string, string> | undefined;
    body?: z.ZodType<any, z.ZodTypeDef, any> | undefined;
    query?: z.ZodType<any, z.ZodTypeDef, any> | undefined;
    responses?: Record<string, z.ZodType<any, z.ZodTypeDef, any>> | undefined;
}, "type" | "name" | "url"> & Pick<{
    readonly name: "Current Game Player";
    readonly description: "Get the current game match ID for the provided player";
    readonly type: "glz";
    readonly url: "core-game/v1/players/:puuid";
    readonly responses: {
        readonly "200": z.ZodObject<{
            Subject: z.ZodString;
            MatchID: z.ZodString;
            Version: z.ZodNumber;
        }, "strip", z.ZodTypeAny, {
            Subject: string;
            Version: number;
            MatchID: string;
        }, {
            Subject: string;
            Version: number;
            MatchID: string;
        }>;
    };
}, "type" | "name" | "url"> & {
    "~type": {
        readonly name: "Current Game Player";
        readonly description: "Get the current game match ID for the provided player";
        readonly type: "glz";
        readonly url: "core-game/v1/players/:puuid";
        readonly responses: {
            readonly "200": z.ZodObject<{
                Subject: z.ZodString;
                MatchID: z.ZodString;
                Version: z.ZodNumber;
            }, "strip", z.ZodTypeAny, {
                Subject: string;
                Version: number;
                MatchID: string;
            }, {
                Subject: string;
                Version: number;
                MatchID: string;
            }>;
        };
    };
};

type Params$s = ResolveParams<(typeof _default$s)["~type"]["url"]>;
type Body$s = z.infer<ResolveValue<(typeof _default$s)["~type"], "body">>;
type Data$s = ResolveData<Params$s, Body$s>;
type Response$s = z.infer<ResolveValue<(typeof _default$s)["~type"], "responses">["200"]>;
interface CurrentGamePlayerRequestConfig extends ValorantAxiosRequestConfig<Data$s> {
}
declare class CurrentGamePlayerEndpoint {
    /**
     * Get the current game match ID for the provided player
     *
     * @EndpointType glz
     */
    getCurrentGamePlayer<T = Response$s>(this: RemoteApiClient, config?: CurrentGamePlayerRequestConfig): Promise<AxiosResponse<T>>;
}

declare const _default$r: Omit<{
    requirements: string[];
    type: "auth" | "local" | "pd" | "glz" | "shared";
    name: string;
    method: "PUT" | "GET" | "DELETE" | "POST";
    url: string;
    description?: string | undefined;
    headers?: Record<string, string> | undefined;
    body?: z.ZodType<any, z.ZodTypeDef, any> | undefined;
    query?: z.ZodType<any, z.ZodTypeDef, any> | undefined;
    responses?: Record<string, z.ZodType<any, z.ZodTypeDef, any>> | undefined;
}, "type" | "name" | "url"> & Pick<{
    readonly name: "Current Game Quit";
    readonly description: "Quits the current game";
    readonly type: "glz";
    readonly method: "POST";
    readonly url: "core-game/v1/players/:puuid/disassociate/:currentGameMatchId";
    readonly responses: {
        readonly "204": z.ZodUndefined;
    };
}, "type" | "name" | "url"> & {
    "~type": {
        readonly name: "Current Game Quit";
        readonly description: "Quits the current game";
        readonly type: "glz";
        readonly method: "POST";
        readonly url: "core-game/v1/players/:puuid/disassociate/:currentGameMatchId";
        readonly responses: {
            readonly "204": z.ZodUndefined;
        };
    };
};

type Params$r = ResolveParams<(typeof _default$r)["~type"]["url"]>;
type Body$r = z.infer<ResolveValue<(typeof _default$r)["~type"], "body">>;
type Data$r = ResolveData<Params$r, Body$r>;
type Response$r = z.infer<ResolveValue<(typeof _default$r)["~type"], "responses">["204"]>;
interface CurrentGameQuitRequestConfig extends ValorantAxiosRequestConfig<Data$r> {
}
declare class CurrentGameQuitEndpoint {
    /**
     * Quits the current game
     *
     * @EndpointType glz
     */
    postCurrentGameQuit<T = Response$r>(this: RemoteApiClient, config: CurrentGameQuitRequestConfig): Promise<AxiosResponse<T>>;
}

declare const CustomGameConfigResponseSchema: z.ZodObject<{
    Enabled: z.ZodBoolean;
    EnabledMaps: z.ZodArray<z.ZodString, "many">;
    EnabledModes: z.ZodArray<z.ZodString, "many">;
    Queues: z.ZodArray<z.ZodObject<{
        QueueID: z.ZodString;
        Enabled: z.ZodBoolean;
        TeamSize: z.ZodNumber;
        NumTeams: z.ZodNumber;
        MaxPartySize: z.ZodNumber;
        MinPartySize: z.ZodNumber;
        InvalidPartySizes: z.ZodArray<z.ZodNumber, "many">;
        MaxPartySizeHighSkill: z.ZodNumber;
        HighSkillTier: z.ZodNumber;
        MaxSkillTier: z.ZodNumber;
        AllowFullPartyBypassSkillRestrictions: z.ZodBoolean;
        Mode: z.ZodString;
        IsRanked: z.ZodBoolean;
        IsTournament: z.ZodBoolean;
        RequireRoster: z.ZodBoolean;
        Priority: z.ZodNumber;
        PartyMaxCompetitiveTierRange: z.ZodNumber;
        PartyMaxCompetitiveTierRangePlacementBuffer: z.ZodNumber;
        FullPartyMaxCompetitiveTierRange: z.ZodNumber;
        PartySkillDisparityCompetitiveTiersCeilings: z.ZodRecord<z.ZodString, z.ZodNumber>;
        UseAccountLevelRequirement: z.ZodBoolean;
        MinimumAccountLevelRequired: z.ZodNumber;
        GameRules: z.ZodRecord<z.ZodString, z.ZodEffects<z.ZodString, boolean, string>>;
        SupportedPlatformTypes: z.ZodArray<z.ZodLiteral<"PC">, "many">;
        DisabledContent: z.ZodArray<z.ZodUnknown, "many">;
        queueFieldA: z.ZodArray<z.ZodUnknown, "many">;
        NextScheduleChangeSeconds: z.ZodNumber;
        TimeUntilNextScheduleChangeSeconds: z.ZodNumber;
        MapWeights: z.ZodEffects<z.ZodArray<z.ZodString, "many">, string[][], string[]>;
    }, "strip", z.ZodTypeAny, {
        Enabled: boolean;
        QueueID: string;
        TeamSize: number;
        NumTeams: number;
        MaxPartySize: number;
        MinPartySize: number;
        InvalidPartySizes: number[];
        MaxPartySizeHighSkill: number;
        HighSkillTier: number;
        MaxSkillTier: number;
        AllowFullPartyBypassSkillRestrictions: boolean;
        Mode: string;
        IsRanked: boolean;
        IsTournament: boolean;
        RequireRoster: boolean;
        Priority: number;
        PartyMaxCompetitiveTierRange: number;
        PartyMaxCompetitiveTierRangePlacementBuffer: number;
        FullPartyMaxCompetitiveTierRange: number;
        PartySkillDisparityCompetitiveTiersCeilings: Record<string, number>;
        UseAccountLevelRequirement: boolean;
        MinimumAccountLevelRequired: number;
        GameRules: Record<string, boolean>;
        SupportedPlatformTypes: "PC"[];
        DisabledContent: unknown[];
        queueFieldA: unknown[];
        NextScheduleChangeSeconds: number;
        TimeUntilNextScheduleChangeSeconds: number;
        MapWeights: string[][];
    }, {
        Enabled: boolean;
        QueueID: string;
        TeamSize: number;
        NumTeams: number;
        MaxPartySize: number;
        MinPartySize: number;
        InvalidPartySizes: number[];
        MaxPartySizeHighSkill: number;
        HighSkillTier: number;
        MaxSkillTier: number;
        AllowFullPartyBypassSkillRestrictions: boolean;
        Mode: string;
        IsRanked: boolean;
        IsTournament: boolean;
        RequireRoster: boolean;
        Priority: number;
        PartyMaxCompetitiveTierRange: number;
        PartyMaxCompetitiveTierRangePlacementBuffer: number;
        FullPartyMaxCompetitiveTierRange: number;
        PartySkillDisparityCompetitiveTiersCeilings: Record<string, number>;
        UseAccountLevelRequirement: boolean;
        MinimumAccountLevelRequired: number;
        GameRules: Record<string, string>;
        SupportedPlatformTypes: "PC"[];
        DisabledContent: unknown[];
        queueFieldA: unknown[];
        NextScheduleChangeSeconds: number;
        TimeUntilNextScheduleChangeSeconds: number;
        MapWeights: string[];
    }>, "many">;
    GamePodPingServiceInfo: z.ZodRecord<z.ZodString, z.ZodObject<{
        SecurityHash: z.ZodNumber;
        ObfuscatedIP: z.ZodNumber;
        PingProxyAddress: z.ZodString;
        PingProxyAddresses: z.ZodArray<z.ZodString, "many">;
    }, "strip", z.ZodTypeAny, {
        SecurityHash: number;
        ObfuscatedIP: number;
        PingProxyAddress: string;
        PingProxyAddresses: string[];
    }, {
        SecurityHash: number;
        ObfuscatedIP: number;
        PingProxyAddress: string;
        PingProxyAddresses: string[];
    }>>;
}, "strip", z.ZodTypeAny, {
    Enabled: boolean;
    EnabledMaps: string[];
    EnabledModes: string[];
    Queues: {
        Enabled: boolean;
        QueueID: string;
        TeamSize: number;
        NumTeams: number;
        MaxPartySize: number;
        MinPartySize: number;
        InvalidPartySizes: number[];
        MaxPartySizeHighSkill: number;
        HighSkillTier: number;
        MaxSkillTier: number;
        AllowFullPartyBypassSkillRestrictions: boolean;
        Mode: string;
        IsRanked: boolean;
        IsTournament: boolean;
        RequireRoster: boolean;
        Priority: number;
        PartyMaxCompetitiveTierRange: number;
        PartyMaxCompetitiveTierRangePlacementBuffer: number;
        FullPartyMaxCompetitiveTierRange: number;
        PartySkillDisparityCompetitiveTiersCeilings: Record<string, number>;
        UseAccountLevelRequirement: boolean;
        MinimumAccountLevelRequired: number;
        GameRules: Record<string, boolean>;
        SupportedPlatformTypes: "PC"[];
        DisabledContent: unknown[];
        queueFieldA: unknown[];
        NextScheduleChangeSeconds: number;
        TimeUntilNextScheduleChangeSeconds: number;
        MapWeights: string[][];
    }[];
    GamePodPingServiceInfo: Record<string, {
        SecurityHash: number;
        ObfuscatedIP: number;
        PingProxyAddress: string;
        PingProxyAddresses: string[];
    }>;
}, {
    Enabled: boolean;
    EnabledMaps: string[];
    EnabledModes: string[];
    Queues: {
        Enabled: boolean;
        QueueID: string;
        TeamSize: number;
        NumTeams: number;
        MaxPartySize: number;
        MinPartySize: number;
        InvalidPartySizes: number[];
        MaxPartySizeHighSkill: number;
        HighSkillTier: number;
        MaxSkillTier: number;
        AllowFullPartyBypassSkillRestrictions: boolean;
        Mode: string;
        IsRanked: boolean;
        IsTournament: boolean;
        RequireRoster: boolean;
        Priority: number;
        PartyMaxCompetitiveTierRange: number;
        PartyMaxCompetitiveTierRangePlacementBuffer: number;
        FullPartyMaxCompetitiveTierRange: number;
        PartySkillDisparityCompetitiveTiersCeilings: Record<string, number>;
        UseAccountLevelRequirement: boolean;
        MinimumAccountLevelRequired: number;
        GameRules: Record<string, string>;
        SupportedPlatformTypes: "PC"[];
        DisabledContent: unknown[];
        queueFieldA: unknown[];
        NextScheduleChangeSeconds: number;
        TimeUntilNextScheduleChangeSeconds: number;
        MapWeights: string[];
    }[];
    GamePodPingServiceInfo: Record<string, {
        SecurityHash: number;
        ObfuscatedIP: number;
        PingProxyAddress: string;
        PingProxyAddresses: string[];
    }>;
}>;
declare const _default$q: Omit<{
    requirements: string[];
    type: "auth" | "local" | "pd" | "glz" | "shared";
    name: string;
    method: "PUT" | "GET" | "DELETE" | "POST";
    url: string;
    description?: string | undefined;
    headers?: Record<string, string> | undefined;
    body?: z.ZodType<any, z.ZodTypeDef, any> | undefined;
    query?: z.ZodType<any, z.ZodTypeDef, any> | undefined;
    responses?: Record<string, z.ZodType<any, z.ZodTypeDef, any>> | undefined;
}, "type" | "name" | "url"> & Pick<{
    readonly name: "Custom Game Configs";
    readonly description: "Get information about the available gamemodes, maps, queues, and gamepods";
    readonly type: "glz";
    readonly url: "parties/v1/parties/customgameconfigs";
    readonly responses: {
        readonly "200": z.ZodObject<{
            Enabled: z.ZodBoolean;
            EnabledMaps: z.ZodArray<z.ZodString, "many">;
            EnabledModes: z.ZodArray<z.ZodString, "many">;
            Queues: z.ZodArray<z.ZodObject<{
                QueueID: z.ZodString;
                Enabled: z.ZodBoolean;
                TeamSize: z.ZodNumber;
                NumTeams: z.ZodNumber;
                MaxPartySize: z.ZodNumber;
                MinPartySize: z.ZodNumber;
                InvalidPartySizes: z.ZodArray<z.ZodNumber, "many">;
                MaxPartySizeHighSkill: z.ZodNumber;
                HighSkillTier: z.ZodNumber;
                MaxSkillTier: z.ZodNumber;
                AllowFullPartyBypassSkillRestrictions: z.ZodBoolean;
                Mode: z.ZodString;
                IsRanked: z.ZodBoolean;
                IsTournament: z.ZodBoolean;
                RequireRoster: z.ZodBoolean;
                Priority: z.ZodNumber;
                PartyMaxCompetitiveTierRange: z.ZodNumber;
                PartyMaxCompetitiveTierRangePlacementBuffer: z.ZodNumber;
                FullPartyMaxCompetitiveTierRange: z.ZodNumber;
                PartySkillDisparityCompetitiveTiersCeilings: z.ZodRecord<z.ZodString, z.ZodNumber>;
                UseAccountLevelRequirement: z.ZodBoolean;
                MinimumAccountLevelRequired: z.ZodNumber;
                GameRules: z.ZodRecord<z.ZodString, z.ZodEffects<z.ZodString, boolean, string>>;
                SupportedPlatformTypes: z.ZodArray<z.ZodLiteral<"PC">, "many">;
                DisabledContent: z.ZodArray<z.ZodUnknown, "many">;
                queueFieldA: z.ZodArray<z.ZodUnknown, "many">;
                NextScheduleChangeSeconds: z.ZodNumber;
                TimeUntilNextScheduleChangeSeconds: z.ZodNumber;
                MapWeights: z.ZodEffects<z.ZodArray<z.ZodString, "many">, string[][], string[]>;
            }, "strip", z.ZodTypeAny, {
                Enabled: boolean;
                QueueID: string;
                TeamSize: number;
                NumTeams: number;
                MaxPartySize: number;
                MinPartySize: number;
                InvalidPartySizes: number[];
                MaxPartySizeHighSkill: number;
                HighSkillTier: number;
                MaxSkillTier: number;
                AllowFullPartyBypassSkillRestrictions: boolean;
                Mode: string;
                IsRanked: boolean;
                IsTournament: boolean;
                RequireRoster: boolean;
                Priority: number;
                PartyMaxCompetitiveTierRange: number;
                PartyMaxCompetitiveTierRangePlacementBuffer: number;
                FullPartyMaxCompetitiveTierRange: number;
                PartySkillDisparityCompetitiveTiersCeilings: Record<string, number>;
                UseAccountLevelRequirement: boolean;
                MinimumAccountLevelRequired: number;
                GameRules: Record<string, boolean>;
                SupportedPlatformTypes: "PC"[];
                DisabledContent: unknown[];
                queueFieldA: unknown[];
                NextScheduleChangeSeconds: number;
                TimeUntilNextScheduleChangeSeconds: number;
                MapWeights: string[][];
            }, {
                Enabled: boolean;
                QueueID: string;
                TeamSize: number;
                NumTeams: number;
                MaxPartySize: number;
                MinPartySize: number;
                InvalidPartySizes: number[];
                MaxPartySizeHighSkill: number;
                HighSkillTier: number;
                MaxSkillTier: number;
                AllowFullPartyBypassSkillRestrictions: boolean;
                Mode: string;
                IsRanked: boolean;
                IsTournament: boolean;
                RequireRoster: boolean;
                Priority: number;
                PartyMaxCompetitiveTierRange: number;
                PartyMaxCompetitiveTierRangePlacementBuffer: number;
                FullPartyMaxCompetitiveTierRange: number;
                PartySkillDisparityCompetitiveTiersCeilings: Record<string, number>;
                UseAccountLevelRequirement: boolean;
                MinimumAccountLevelRequired: number;
                GameRules: Record<string, string>;
                SupportedPlatformTypes: "PC"[];
                DisabledContent: unknown[];
                queueFieldA: unknown[];
                NextScheduleChangeSeconds: number;
                TimeUntilNextScheduleChangeSeconds: number;
                MapWeights: string[];
            }>, "many">;
            GamePodPingServiceInfo: z.ZodRecord<z.ZodString, z.ZodObject<{
                SecurityHash: z.ZodNumber;
                ObfuscatedIP: z.ZodNumber;
                PingProxyAddress: z.ZodString;
                PingProxyAddresses: z.ZodArray<z.ZodString, "many">;
            }, "strip", z.ZodTypeAny, {
                SecurityHash: number;
                ObfuscatedIP: number;
                PingProxyAddress: string;
                PingProxyAddresses: string[];
            }, {
                SecurityHash: number;
                ObfuscatedIP: number;
                PingProxyAddress: string;
                PingProxyAddresses: string[];
            }>>;
        }, "strip", z.ZodTypeAny, {
            Enabled: boolean;
            EnabledMaps: string[];
            EnabledModes: string[];
            Queues: {
                Enabled: boolean;
                QueueID: string;
                TeamSize: number;
                NumTeams: number;
                MaxPartySize: number;
                MinPartySize: number;
                InvalidPartySizes: number[];
                MaxPartySizeHighSkill: number;
                HighSkillTier: number;
                MaxSkillTier: number;
                AllowFullPartyBypassSkillRestrictions: boolean;
                Mode: string;
                IsRanked: boolean;
                IsTournament: boolean;
                RequireRoster: boolean;
                Priority: number;
                PartyMaxCompetitiveTierRange: number;
                PartyMaxCompetitiveTierRangePlacementBuffer: number;
                FullPartyMaxCompetitiveTierRange: number;
                PartySkillDisparityCompetitiveTiersCeilings: Record<string, number>;
                UseAccountLevelRequirement: boolean;
                MinimumAccountLevelRequired: number;
                GameRules: Record<string, boolean>;
                SupportedPlatformTypes: "PC"[];
                DisabledContent: unknown[];
                queueFieldA: unknown[];
                NextScheduleChangeSeconds: number;
                TimeUntilNextScheduleChangeSeconds: number;
                MapWeights: string[][];
            }[];
            GamePodPingServiceInfo: Record<string, {
                SecurityHash: number;
                ObfuscatedIP: number;
                PingProxyAddress: string;
                PingProxyAddresses: string[];
            }>;
        }, {
            Enabled: boolean;
            EnabledMaps: string[];
            EnabledModes: string[];
            Queues: {
                Enabled: boolean;
                QueueID: string;
                TeamSize: number;
                NumTeams: number;
                MaxPartySize: number;
                MinPartySize: number;
                InvalidPartySizes: number[];
                MaxPartySizeHighSkill: number;
                HighSkillTier: number;
                MaxSkillTier: number;
                AllowFullPartyBypassSkillRestrictions: boolean;
                Mode: string;
                IsRanked: boolean;
                IsTournament: boolean;
                RequireRoster: boolean;
                Priority: number;
                PartyMaxCompetitiveTierRange: number;
                PartyMaxCompetitiveTierRangePlacementBuffer: number;
                FullPartyMaxCompetitiveTierRange: number;
                PartySkillDisparityCompetitiveTiersCeilings: Record<string, number>;
                UseAccountLevelRequirement: boolean;
                MinimumAccountLevelRequired: number;
                GameRules: Record<string, string>;
                SupportedPlatformTypes: "PC"[];
                DisabledContent: unknown[];
                queueFieldA: unknown[];
                NextScheduleChangeSeconds: number;
                TimeUntilNextScheduleChangeSeconds: number;
                MapWeights: string[];
            }[];
            GamePodPingServiceInfo: Record<string, {
                SecurityHash: number;
                ObfuscatedIP: number;
                PingProxyAddress: string;
                PingProxyAddresses: string[];
            }>;
        }>;
    };
}, "type" | "name" | "url"> & {
    "~type": {
        readonly name: "Custom Game Configs";
        readonly description: "Get information about the available gamemodes, maps, queues, and gamepods";
        readonly type: "glz";
        readonly url: "parties/v1/parties/customgameconfigs";
        readonly responses: {
            readonly "200": z.ZodObject<{
                Enabled: z.ZodBoolean;
                EnabledMaps: z.ZodArray<z.ZodString, "many">;
                EnabledModes: z.ZodArray<z.ZodString, "many">;
                Queues: z.ZodArray<z.ZodObject<{
                    QueueID: z.ZodString;
                    Enabled: z.ZodBoolean;
                    TeamSize: z.ZodNumber;
                    NumTeams: z.ZodNumber;
                    MaxPartySize: z.ZodNumber;
                    MinPartySize: z.ZodNumber;
                    InvalidPartySizes: z.ZodArray<z.ZodNumber, "many">;
                    MaxPartySizeHighSkill: z.ZodNumber;
                    HighSkillTier: z.ZodNumber;
                    MaxSkillTier: z.ZodNumber;
                    AllowFullPartyBypassSkillRestrictions: z.ZodBoolean;
                    Mode: z.ZodString;
                    IsRanked: z.ZodBoolean;
                    IsTournament: z.ZodBoolean;
                    RequireRoster: z.ZodBoolean;
                    Priority: z.ZodNumber;
                    PartyMaxCompetitiveTierRange: z.ZodNumber;
                    PartyMaxCompetitiveTierRangePlacementBuffer: z.ZodNumber;
                    FullPartyMaxCompetitiveTierRange: z.ZodNumber;
                    PartySkillDisparityCompetitiveTiersCeilings: z.ZodRecord<z.ZodString, z.ZodNumber>;
                    UseAccountLevelRequirement: z.ZodBoolean;
                    MinimumAccountLevelRequired: z.ZodNumber;
                    GameRules: z.ZodRecord<z.ZodString, z.ZodEffects<z.ZodString, boolean, string>>;
                    SupportedPlatformTypes: z.ZodArray<z.ZodLiteral<"PC">, "many">;
                    DisabledContent: z.ZodArray<z.ZodUnknown, "many">;
                    queueFieldA: z.ZodArray<z.ZodUnknown, "many">;
                    NextScheduleChangeSeconds: z.ZodNumber;
                    TimeUntilNextScheduleChangeSeconds: z.ZodNumber;
                    MapWeights: z.ZodEffects<z.ZodArray<z.ZodString, "many">, string[][], string[]>;
                }, "strip", z.ZodTypeAny, {
                    Enabled: boolean;
                    QueueID: string;
                    TeamSize: number;
                    NumTeams: number;
                    MaxPartySize: number;
                    MinPartySize: number;
                    InvalidPartySizes: number[];
                    MaxPartySizeHighSkill: number;
                    HighSkillTier: number;
                    MaxSkillTier: number;
                    AllowFullPartyBypassSkillRestrictions: boolean;
                    Mode: string;
                    IsRanked: boolean;
                    IsTournament: boolean;
                    RequireRoster: boolean;
                    Priority: number;
                    PartyMaxCompetitiveTierRange: number;
                    PartyMaxCompetitiveTierRangePlacementBuffer: number;
                    FullPartyMaxCompetitiveTierRange: number;
                    PartySkillDisparityCompetitiveTiersCeilings: Record<string, number>;
                    UseAccountLevelRequirement: boolean;
                    MinimumAccountLevelRequired: number;
                    GameRules: Record<string, boolean>;
                    SupportedPlatformTypes: "PC"[];
                    DisabledContent: unknown[];
                    queueFieldA: unknown[];
                    NextScheduleChangeSeconds: number;
                    TimeUntilNextScheduleChangeSeconds: number;
                    MapWeights: string[][];
                }, {
                    Enabled: boolean;
                    QueueID: string;
                    TeamSize: number;
                    NumTeams: number;
                    MaxPartySize: number;
                    MinPartySize: number;
                    InvalidPartySizes: number[];
                    MaxPartySizeHighSkill: number;
                    HighSkillTier: number;
                    MaxSkillTier: number;
                    AllowFullPartyBypassSkillRestrictions: boolean;
                    Mode: string;
                    IsRanked: boolean;
                    IsTournament: boolean;
                    RequireRoster: boolean;
                    Priority: number;
                    PartyMaxCompetitiveTierRange: number;
                    PartyMaxCompetitiveTierRangePlacementBuffer: number;
                    FullPartyMaxCompetitiveTierRange: number;
                    PartySkillDisparityCompetitiveTiersCeilings: Record<string, number>;
                    UseAccountLevelRequirement: boolean;
                    MinimumAccountLevelRequired: number;
                    GameRules: Record<string, string>;
                    SupportedPlatformTypes: "PC"[];
                    DisabledContent: unknown[];
                    queueFieldA: unknown[];
                    NextScheduleChangeSeconds: number;
                    TimeUntilNextScheduleChangeSeconds: number;
                    MapWeights: string[];
                }>, "many">;
                GamePodPingServiceInfo: z.ZodRecord<z.ZodString, z.ZodObject<{
                    SecurityHash: z.ZodNumber;
                    ObfuscatedIP: z.ZodNumber;
                    PingProxyAddress: z.ZodString;
                    PingProxyAddresses: z.ZodArray<z.ZodString, "many">;
                }, "strip", z.ZodTypeAny, {
                    SecurityHash: number;
                    ObfuscatedIP: number;
                    PingProxyAddress: string;
                    PingProxyAddresses: string[];
                }, {
                    SecurityHash: number;
                    ObfuscatedIP: number;
                    PingProxyAddress: string;
                    PingProxyAddresses: string[];
                }>>;
            }, "strip", z.ZodTypeAny, {
                Enabled: boolean;
                EnabledMaps: string[];
                EnabledModes: string[];
                Queues: {
                    Enabled: boolean;
                    QueueID: string;
                    TeamSize: number;
                    NumTeams: number;
                    MaxPartySize: number;
                    MinPartySize: number;
                    InvalidPartySizes: number[];
                    MaxPartySizeHighSkill: number;
                    HighSkillTier: number;
                    MaxSkillTier: number;
                    AllowFullPartyBypassSkillRestrictions: boolean;
                    Mode: string;
                    IsRanked: boolean;
                    IsTournament: boolean;
                    RequireRoster: boolean;
                    Priority: number;
                    PartyMaxCompetitiveTierRange: number;
                    PartyMaxCompetitiveTierRangePlacementBuffer: number;
                    FullPartyMaxCompetitiveTierRange: number;
                    PartySkillDisparityCompetitiveTiersCeilings: Record<string, number>;
                    UseAccountLevelRequirement: boolean;
                    MinimumAccountLevelRequired: number;
                    GameRules: Record<string, boolean>;
                    SupportedPlatformTypes: "PC"[];
                    DisabledContent: unknown[];
                    queueFieldA: unknown[];
                    NextScheduleChangeSeconds: number;
                    TimeUntilNextScheduleChangeSeconds: number;
                    MapWeights: string[][];
                }[];
                GamePodPingServiceInfo: Record<string, {
                    SecurityHash: number;
                    ObfuscatedIP: number;
                    PingProxyAddress: string;
                    PingProxyAddresses: string[];
                }>;
            }, {
                Enabled: boolean;
                EnabledMaps: string[];
                EnabledModes: string[];
                Queues: {
                    Enabled: boolean;
                    QueueID: string;
                    TeamSize: number;
                    NumTeams: number;
                    MaxPartySize: number;
                    MinPartySize: number;
                    InvalidPartySizes: number[];
                    MaxPartySizeHighSkill: number;
                    HighSkillTier: number;
                    MaxSkillTier: number;
                    AllowFullPartyBypassSkillRestrictions: boolean;
                    Mode: string;
                    IsRanked: boolean;
                    IsTournament: boolean;
                    RequireRoster: boolean;
                    Priority: number;
                    PartyMaxCompetitiveTierRange: number;
                    PartyMaxCompetitiveTierRangePlacementBuffer: number;
                    FullPartyMaxCompetitiveTierRange: number;
                    PartySkillDisparityCompetitiveTiersCeilings: Record<string, number>;
                    UseAccountLevelRequirement: boolean;
                    MinimumAccountLevelRequired: number;
                    GameRules: Record<string, string>;
                    SupportedPlatformTypes: "PC"[];
                    DisabledContent: unknown[];
                    queueFieldA: unknown[];
                    NextScheduleChangeSeconds: number;
                    TimeUntilNextScheduleChangeSeconds: number;
                    MapWeights: string[];
                }[];
                GamePodPingServiceInfo: Record<string, {
                    SecurityHash: number;
                    ObfuscatedIP: number;
                    PingProxyAddress: string;
                    PingProxyAddresses: string[];
                }>;
            }>;
        };
    };
};

type Params$q = ResolveParams<(typeof _default$q)["~type"]["url"]>;
type Body$q = z.infer<ResolveValue<(typeof _default$q)["~type"], "body">>;
type Data$q = ResolveData<Params$q, Body$q>;
type Response$q = z.infer<ResolveValue<(typeof _default$q)["~type"], "responses">["200"]>;
interface CustomGameConfigsRequestConfig extends ValorantAxiosRequestConfig<Data$q> {
}
declare class CustomGameConfigsEndpoint {
    /**
     * Get information about the available gamemodes, maps, queues, and gamepods
     *
     * @EndpointType glz
     */
    getCustomGameConfigs<T = Response$q>(this: RemoteApiClient, config?: CustomGameConfigsRequestConfig): Promise<AxiosResponse<T>>;
}

declare const _default$p: Omit<{
    requirements: string[];
    type: "auth" | "local" | "pd" | "glz" | "shared";
    name: string;
    method: "PUT" | "GET" | "DELETE" | "POST";
    url: string;
    description?: string | undefined;
    headers?: Record<string, string> | undefined;
    body?: zod.ZodType<any, zod.ZodTypeDef, any> | undefined;
    query?: zod.ZodType<any, zod.ZodTypeDef, any> | undefined;
    responses?: Record<string, zod.ZodType<any, zod.ZodTypeDef, any>> | undefined;
}, "type" | "name" | "url"> & Pick<{
    readonly name: "Enter Matchmaking Queue";
    readonly description: "Enter the matchmaking queue for the party";
    readonly type: "glz";
    readonly method: "POST";
    readonly url: "parties/v1/parties/:partyId/matchmaking/join";
    readonly responses: {
        readonly "200": zod.ZodObject<{
            ID: zod.ZodString;
            MUCName: zod.ZodString;
            VoiceRoomID: zod.ZodString;
            Version: zod.ZodNumber;
            ClientVersion: zod.ZodString;
            Members: zod.ZodArray<zod.ZodObject<{
                Subject: zod.ZodString;
                CompetitiveTier: zod.ZodNumber;
                PlayerIdentity: zod.ZodObject<{
                    Subject: zod.ZodString;
                    PlayerCardID: zod.ZodString;
                    PlayerTitleID: zod.ZodString;
                    AccountLevel: zod.ZodNumber;
                    PreferredLevelBorderID: zod.ZodUnion<[zod.ZodString, zod.ZodLiteral<"">]>;
                    Incognito: zod.ZodBoolean;
                    HideAccountLevel: zod.ZodBoolean;
                }, "strip", zod.ZodTypeAny, {
                    Subject: string;
                    PlayerCardID: string;
                    PlayerTitleID: string;
                    AccountLevel: number;
                    PreferredLevelBorderID: string;
                    Incognito: boolean;
                    HideAccountLevel: boolean;
                }, {
                    Subject: string;
                    PlayerCardID: string;
                    PlayerTitleID: string;
                    AccountLevel: number;
                    PreferredLevelBorderID: string;
                    Incognito: boolean;
                    HideAccountLevel: boolean;
                }>;
                SeasonalBadgeInfo: zod.ZodNull;
                IsOwner: zod.ZodOptional<zod.ZodBoolean>;
                QueueEligibleRemainingAccountLevels: zod.ZodNumber;
                Pings: zod.ZodArray<zod.ZodObject<{
                    Ping: zod.ZodNumber;
                    GamePodID: zod.ZodString;
                }, "strip", zod.ZodTypeAny, {
                    GamePodID: string;
                    Ping: number;
                }, {
                    GamePodID: string;
                    Ping: number;
                }>, "many">;
                IsReady: zod.ZodBoolean;
                IsModerator: zod.ZodBoolean;
                UseBroadcastHUD: zod.ZodBoolean;
                PlatformType: zod.ZodLiteral<"PC">;
            }, "strip", zod.ZodTypeAny, {
                Subject: string;
                PlayerIdentity: {
                    Subject: string;
                    PlayerCardID: string;
                    PlayerTitleID: string;
                    AccountLevel: number;
                    PreferredLevelBorderID: string;
                    Incognito: boolean;
                    HideAccountLevel: boolean;
                };
                SeasonalBadgeInfo: null;
                CompetitiveTier: number;
                QueueEligibleRemainingAccountLevels: number;
                Pings: {
                    GamePodID: string;
                    Ping: number;
                }[];
                IsReady: boolean;
                IsModerator: boolean;
                UseBroadcastHUD: boolean;
                PlatformType: "PC";
                IsOwner?: boolean | undefined;
            }, {
                Subject: string;
                PlayerIdentity: {
                    Subject: string;
                    PlayerCardID: string;
                    PlayerTitleID: string;
                    AccountLevel: number;
                    PreferredLevelBorderID: string;
                    Incognito: boolean;
                    HideAccountLevel: boolean;
                };
                SeasonalBadgeInfo: null;
                CompetitiveTier: number;
                QueueEligibleRemainingAccountLevels: number;
                Pings: {
                    GamePodID: string;
                    Ping: number;
                }[];
                IsReady: boolean;
                IsModerator: boolean;
                UseBroadcastHUD: boolean;
                PlatformType: "PC";
                IsOwner?: boolean | undefined;
            }>, "many">;
            State: zod.ZodString;
            PreviousState: zod.ZodString;
            StateTransitionReason: zod.ZodString;
            Accessibility: zod.ZodUnion<[zod.ZodLiteral<"OPEN">, zod.ZodLiteral<"CLOSED">]>;
            CustomGameData: zod.ZodObject<{
                Settings: zod.ZodObject<{
                    Map: zod.ZodString;
                    Mode: zod.ZodString;
                    UseBots: zod.ZodBoolean;
                    GamePod: zod.ZodString;
                    GameRules: zod.ZodNullable<zod.ZodObject<{
                        AllowGameModifiers: zod.ZodOptional<zod.ZodEffects<zod.ZodString, boolean, string>>;
                        IsOvertimeWinByTwo: zod.ZodOptional<zod.ZodEffects<zod.ZodString, boolean, string>>;
                        PlayOutAllRounds: zod.ZodOptional<zod.ZodEffects<zod.ZodString, boolean, string>>;
                        SkipMatchHistory: zod.ZodOptional<zod.ZodEffects<zod.ZodString, boolean, string>>;
                        TournamentMode: zod.ZodOptional<zod.ZodEffects<zod.ZodString, boolean, string>>;
                    }, "strip", zod.ZodTypeAny, {
                        AllowGameModifiers?: boolean | undefined;
                        IsOvertimeWinByTwo?: boolean | undefined;
                        PlayOutAllRounds?: boolean | undefined;
                        SkipMatchHistory?: boolean | undefined;
                        TournamentMode?: boolean | undefined;
                    }, {
                        AllowGameModifiers?: string | undefined;
                        IsOvertimeWinByTwo?: string | undefined;
                        PlayOutAllRounds?: string | undefined;
                        SkipMatchHistory?: string | undefined;
                        TournamentMode?: string | undefined;
                    }>>;
                }, "strip", zod.ZodTypeAny, {
                    Mode: string;
                    GameRules: {
                        AllowGameModifiers?: boolean | undefined;
                        IsOvertimeWinByTwo?: boolean | undefined;
                        PlayOutAllRounds?: boolean | undefined;
                        SkipMatchHistory?: boolean | undefined;
                        TournamentMode?: boolean | undefined;
                    } | null;
                    Map: string;
                    UseBots: boolean;
                    GamePod: string;
                }, {
                    Mode: string;
                    GameRules: {
                        AllowGameModifiers?: string | undefined;
                        IsOvertimeWinByTwo?: string | undefined;
                        PlayOutAllRounds?: string | undefined;
                        SkipMatchHistory?: string | undefined;
                        TournamentMode?: string | undefined;
                    } | null;
                    Map: string;
                    UseBots: boolean;
                    GamePod: string;
                }>;
                Membership: zod.ZodObject<{
                    teamOne: zod.ZodNullable<zod.ZodArray<zod.ZodObject<{
                        Subject: zod.ZodString;
                    }, "strip", zod.ZodTypeAny, {
                        Subject: string;
                    }, {
                        Subject: string;
                    }>, "many">>;
                    teamTwo: zod.ZodNullable<zod.ZodArray<zod.ZodObject<{
                        Subject: zod.ZodString;
                    }, "strip", zod.ZodTypeAny, {
                        Subject: string;
                    }, {
                        Subject: string;
                    }>, "many">>;
                    teamSpectate: zod.ZodNullable<zod.ZodArray<zod.ZodObject<{
                        Subject: zod.ZodString;
                    }, "strip", zod.ZodTypeAny, {
                        Subject: string;
                    }, {
                        Subject: string;
                    }>, "many">>;
                    teamOneCoaches: zod.ZodNullable<zod.ZodArray<zod.ZodObject<{
                        Subject: zod.ZodString;
                    }, "strip", zod.ZodTypeAny, {
                        Subject: string;
                    }, {
                        Subject: string;
                    }>, "many">>;
                    teamTwoCoaches: zod.ZodNullable<zod.ZodArray<zod.ZodObject<{
                        Subject: zod.ZodString;
                    }, "strip", zod.ZodTypeAny, {
                        Subject: string;
                    }, {
                        Subject: string;
                    }>, "many">>;
                }, "strip", zod.ZodTypeAny, {
                    teamOne: {
                        Subject: string;
                    }[] | null;
                    teamTwo: {
                        Subject: string;
                    }[] | null;
                    teamSpectate: {
                        Subject: string;
                    }[] | null;
                    teamOneCoaches: {
                        Subject: string;
                    }[] | null;
                    teamTwoCoaches: {
                        Subject: string;
                    }[] | null;
                }, {
                    teamOne: {
                        Subject: string;
                    }[] | null;
                    teamTwo: {
                        Subject: string;
                    }[] | null;
                    teamSpectate: {
                        Subject: string;
                    }[] | null;
                    teamOneCoaches: {
                        Subject: string;
                    }[] | null;
                    teamTwoCoaches: {
                        Subject: string;
                    }[] | null;
                }>;
                MaxPartySize: zod.ZodNumber;
                AutobalanceEnabled: zod.ZodBoolean;
                AutobalanceMinPlayers: zod.ZodNumber;
                HasRecoveryData: zod.ZodBoolean;
            }, "strip", zod.ZodTypeAny, {
                MaxPartySize: number;
                Settings: {
                    Mode: string;
                    GameRules: {
                        AllowGameModifiers?: boolean | undefined;
                        IsOvertimeWinByTwo?: boolean | undefined;
                        PlayOutAllRounds?: boolean | undefined;
                        SkipMatchHistory?: boolean | undefined;
                        TournamentMode?: boolean | undefined;
                    } | null;
                    Map: string;
                    UseBots: boolean;
                    GamePod: string;
                };
                Membership: {
                    teamOne: {
                        Subject: string;
                    }[] | null;
                    teamTwo: {
                        Subject: string;
                    }[] | null;
                    teamSpectate: {
                        Subject: string;
                    }[] | null;
                    teamOneCoaches: {
                        Subject: string;
                    }[] | null;
                    teamTwoCoaches: {
                        Subject: string;
                    }[] | null;
                };
                AutobalanceEnabled: boolean;
                AutobalanceMinPlayers: number;
                HasRecoveryData: boolean;
            }, {
                MaxPartySize: number;
                Settings: {
                    Mode: string;
                    GameRules: {
                        AllowGameModifiers?: string | undefined;
                        IsOvertimeWinByTwo?: string | undefined;
                        PlayOutAllRounds?: string | undefined;
                        SkipMatchHistory?: string | undefined;
                        TournamentMode?: string | undefined;
                    } | null;
                    Map: string;
                    UseBots: boolean;
                    GamePod: string;
                };
                Membership: {
                    teamOne: {
                        Subject: string;
                    }[] | null;
                    teamTwo: {
                        Subject: string;
                    }[] | null;
                    teamSpectate: {
                        Subject: string;
                    }[] | null;
                    teamOneCoaches: {
                        Subject: string;
                    }[] | null;
                    teamTwoCoaches: {
                        Subject: string;
                    }[] | null;
                };
                AutobalanceEnabled: boolean;
                AutobalanceMinPlayers: number;
                HasRecoveryData: boolean;
            }>;
            MatchmakingData: zod.ZodObject<{
                QueueID: zod.ZodString;
                PreferredGamePods: zod.ZodArray<zod.ZodString, "many">;
                SkillDisparityRRPenalty: zod.ZodNumber;
            }, "strip", zod.ZodTypeAny, {
                QueueID: string;
                PreferredGamePods: string[];
                SkillDisparityRRPenalty: number;
            }, {
                QueueID: string;
                PreferredGamePods: string[];
                SkillDisparityRRPenalty: number;
            }>;
            Invites: zod.ZodNull;
            Requests: zod.ZodArray<zod.ZodUnknown, "many">;
            QueueEntryTime: zod.ZodEffects<zod.ZodString, Date, string>;
            ErrorNotification: zod.ZodObject<{
                ErrorType: zod.ZodString;
                ErroredPlayers: zod.ZodNullable<zod.ZodArray<zod.ZodObject<{
                    Subject: zod.ZodString;
                }, "strip", zod.ZodTypeAny, {
                    Subject: string;
                }, {
                    Subject: string;
                }>, "many">>;
            }, "strip", zod.ZodTypeAny, {
                ErrorType: string;
                ErroredPlayers: {
                    Subject: string;
                }[] | null;
            }, {
                ErrorType: string;
                ErroredPlayers: {
                    Subject: string;
                }[] | null;
            }>;
            RestrictedSeconds: zod.ZodNumber;
            EligibleQueues: zod.ZodArray<zod.ZodString, "many">;
            QueueIneligibilities: zod.ZodArray<zod.ZodString, "many">;
            CheatData: zod.ZodObject<{
                GamePodOverride: zod.ZodString;
                ForcePostGameProcessing: zod.ZodBoolean;
            }, "strip", zod.ZodTypeAny, {
                GamePodOverride: string;
                ForcePostGameProcessing: boolean;
            }, {
                GamePodOverride: string;
                ForcePostGameProcessing: boolean;
            }>;
            XPBonuses: zod.ZodArray<zod.ZodUnknown, "many">;
            InviteCode: zod.ZodString;
        }, "strip", zod.ZodTypeAny, {
            ID: string;
            Version: number;
            Invites: null;
            Requests: unknown[];
            State: string;
            MatchmakingData: {
                QueueID: string;
                PreferredGamePods: string[];
                SkillDisparityRRPenalty: number;
            };
            MUCName: string;
            VoiceRoomID: string;
            ClientVersion: string;
            Members: {
                Subject: string;
                PlayerIdentity: {
                    Subject: string;
                    PlayerCardID: string;
                    PlayerTitleID: string;
                    AccountLevel: number;
                    PreferredLevelBorderID: string;
                    Incognito: boolean;
                    HideAccountLevel: boolean;
                };
                SeasonalBadgeInfo: null;
                CompetitiveTier: number;
                QueueEligibleRemainingAccountLevels: number;
                Pings: {
                    GamePodID: string;
                    Ping: number;
                }[];
                IsReady: boolean;
                IsModerator: boolean;
                UseBroadcastHUD: boolean;
                PlatformType: "PC";
                IsOwner?: boolean | undefined;
            }[];
            PreviousState: string;
            StateTransitionReason: string;
            Accessibility: "OPEN" | "CLOSED";
            CustomGameData: {
                MaxPartySize: number;
                Settings: {
                    Mode: string;
                    GameRules: {
                        AllowGameModifiers?: boolean | undefined;
                        IsOvertimeWinByTwo?: boolean | undefined;
                        PlayOutAllRounds?: boolean | undefined;
                        SkipMatchHistory?: boolean | undefined;
                        TournamentMode?: boolean | undefined;
                    } | null;
                    Map: string;
                    UseBots: boolean;
                    GamePod: string;
                };
                Membership: {
                    teamOne: {
                        Subject: string;
                    }[] | null;
                    teamTwo: {
                        Subject: string;
                    }[] | null;
                    teamSpectate: {
                        Subject: string;
                    }[] | null;
                    teamOneCoaches: {
                        Subject: string;
                    }[] | null;
                    teamTwoCoaches: {
                        Subject: string;
                    }[] | null;
                };
                AutobalanceEnabled: boolean;
                AutobalanceMinPlayers: number;
                HasRecoveryData: boolean;
            };
            QueueEntryTime: Date;
            ErrorNotification: {
                ErrorType: string;
                ErroredPlayers: {
                    Subject: string;
                }[] | null;
            };
            RestrictedSeconds: number;
            EligibleQueues: string[];
            QueueIneligibilities: string[];
            CheatData: {
                GamePodOverride: string;
                ForcePostGameProcessing: boolean;
            };
            XPBonuses: unknown[];
            InviteCode: string;
        }, {
            ID: string;
            Version: number;
            Invites: null;
            Requests: unknown[];
            State: string;
            MatchmakingData: {
                QueueID: string;
                PreferredGamePods: string[];
                SkillDisparityRRPenalty: number;
            };
            MUCName: string;
            VoiceRoomID: string;
            ClientVersion: string;
            Members: {
                Subject: string;
                PlayerIdentity: {
                    Subject: string;
                    PlayerCardID: string;
                    PlayerTitleID: string;
                    AccountLevel: number;
                    PreferredLevelBorderID: string;
                    Incognito: boolean;
                    HideAccountLevel: boolean;
                };
                SeasonalBadgeInfo: null;
                CompetitiveTier: number;
                QueueEligibleRemainingAccountLevels: number;
                Pings: {
                    GamePodID: string;
                    Ping: number;
                }[];
                IsReady: boolean;
                IsModerator: boolean;
                UseBroadcastHUD: boolean;
                PlatformType: "PC";
                IsOwner?: boolean | undefined;
            }[];
            PreviousState: string;
            StateTransitionReason: string;
            Accessibility: "OPEN" | "CLOSED";
            CustomGameData: {
                MaxPartySize: number;
                Settings: {
                    Mode: string;
                    GameRules: {
                        AllowGameModifiers?: string | undefined;
                        IsOvertimeWinByTwo?: string | undefined;
                        PlayOutAllRounds?: string | undefined;
                        SkipMatchHistory?: string | undefined;
                        TournamentMode?: string | undefined;
                    } | null;
                    Map: string;
                    UseBots: boolean;
                    GamePod: string;
                };
                Membership: {
                    teamOne: {
                        Subject: string;
                    }[] | null;
                    teamTwo: {
                        Subject: string;
                    }[] | null;
                    teamSpectate: {
                        Subject: string;
                    }[] | null;
                    teamOneCoaches: {
                        Subject: string;
                    }[] | null;
                    teamTwoCoaches: {
                        Subject: string;
                    }[] | null;
                };
                AutobalanceEnabled: boolean;
                AutobalanceMinPlayers: number;
                HasRecoveryData: boolean;
            };
            QueueEntryTime: string;
            ErrorNotification: {
                ErrorType: string;
                ErroredPlayers: {
                    Subject: string;
                }[] | null;
            };
            RestrictedSeconds: number;
            EligibleQueues: string[];
            QueueIneligibilities: string[];
            CheatData: {
                GamePodOverride: string;
                ForcePostGameProcessing: boolean;
            };
            XPBonuses: unknown[];
            InviteCode: string;
        }>;
    };
}, "type" | "name" | "url"> & {
    "~type": {
        readonly name: "Enter Matchmaking Queue";
        readonly description: "Enter the matchmaking queue for the party";
        readonly type: "glz";
        readonly method: "POST";
        readonly url: "parties/v1/parties/:partyId/matchmaking/join";
        readonly responses: {
            readonly "200": zod.ZodObject<{
                ID: zod.ZodString;
                MUCName: zod.ZodString;
                VoiceRoomID: zod.ZodString;
                Version: zod.ZodNumber;
                ClientVersion: zod.ZodString;
                Members: zod.ZodArray<zod.ZodObject<{
                    Subject: zod.ZodString;
                    CompetitiveTier: zod.ZodNumber;
                    PlayerIdentity: zod.ZodObject<{
                        Subject: zod.ZodString;
                        PlayerCardID: zod.ZodString;
                        PlayerTitleID: zod.ZodString;
                        AccountLevel: zod.ZodNumber;
                        PreferredLevelBorderID: zod.ZodUnion<[zod.ZodString, zod.ZodLiteral<"">]>;
                        Incognito: zod.ZodBoolean;
                        HideAccountLevel: zod.ZodBoolean;
                    }, "strip", zod.ZodTypeAny, {
                        Subject: string;
                        PlayerCardID: string;
                        PlayerTitleID: string;
                        AccountLevel: number;
                        PreferredLevelBorderID: string;
                        Incognito: boolean;
                        HideAccountLevel: boolean;
                    }, {
                        Subject: string;
                        PlayerCardID: string;
                        PlayerTitleID: string;
                        AccountLevel: number;
                        PreferredLevelBorderID: string;
                        Incognito: boolean;
                        HideAccountLevel: boolean;
                    }>;
                    SeasonalBadgeInfo: zod.ZodNull;
                    IsOwner: zod.ZodOptional<zod.ZodBoolean>;
                    QueueEligibleRemainingAccountLevels: zod.ZodNumber;
                    Pings: zod.ZodArray<zod.ZodObject<{
                        Ping: zod.ZodNumber;
                        GamePodID: zod.ZodString;
                    }, "strip", zod.ZodTypeAny, {
                        GamePodID: string;
                        Ping: number;
                    }, {
                        GamePodID: string;
                        Ping: number;
                    }>, "many">;
                    IsReady: zod.ZodBoolean;
                    IsModerator: zod.ZodBoolean;
                    UseBroadcastHUD: zod.ZodBoolean;
                    PlatformType: zod.ZodLiteral<"PC">;
                }, "strip", zod.ZodTypeAny, {
                    Subject: string;
                    PlayerIdentity: {
                        Subject: string;
                        PlayerCardID: string;
                        PlayerTitleID: string;
                        AccountLevel: number;
                        PreferredLevelBorderID: string;
                        Incognito: boolean;
                        HideAccountLevel: boolean;
                    };
                    SeasonalBadgeInfo: null;
                    CompetitiveTier: number;
                    QueueEligibleRemainingAccountLevels: number;
                    Pings: {
                        GamePodID: string;
                        Ping: number;
                    }[];
                    IsReady: boolean;
                    IsModerator: boolean;
                    UseBroadcastHUD: boolean;
                    PlatformType: "PC";
                    IsOwner?: boolean | undefined;
                }, {
                    Subject: string;
                    PlayerIdentity: {
                        Subject: string;
                        PlayerCardID: string;
                        PlayerTitleID: string;
                        AccountLevel: number;
                        PreferredLevelBorderID: string;
                        Incognito: boolean;
                        HideAccountLevel: boolean;
                    };
                    SeasonalBadgeInfo: null;
                    CompetitiveTier: number;
                    QueueEligibleRemainingAccountLevels: number;
                    Pings: {
                        GamePodID: string;
                        Ping: number;
                    }[];
                    IsReady: boolean;
                    IsModerator: boolean;
                    UseBroadcastHUD: boolean;
                    PlatformType: "PC";
                    IsOwner?: boolean | undefined;
                }>, "many">;
                State: zod.ZodString;
                PreviousState: zod.ZodString;
                StateTransitionReason: zod.ZodString;
                Accessibility: zod.ZodUnion<[zod.ZodLiteral<"OPEN">, zod.ZodLiteral<"CLOSED">]>;
                CustomGameData: zod.ZodObject<{
                    Settings: zod.ZodObject<{
                        Map: zod.ZodString;
                        Mode: zod.ZodString;
                        UseBots: zod.ZodBoolean;
                        GamePod: zod.ZodString;
                        GameRules: zod.ZodNullable<zod.ZodObject<{
                            AllowGameModifiers: zod.ZodOptional<zod.ZodEffects<zod.ZodString, boolean, string>>;
                            IsOvertimeWinByTwo: zod.ZodOptional<zod.ZodEffects<zod.ZodString, boolean, string>>;
                            PlayOutAllRounds: zod.ZodOptional<zod.ZodEffects<zod.ZodString, boolean, string>>;
                            SkipMatchHistory: zod.ZodOptional<zod.ZodEffects<zod.ZodString, boolean, string>>;
                            TournamentMode: zod.ZodOptional<zod.ZodEffects<zod.ZodString, boolean, string>>;
                        }, "strip", zod.ZodTypeAny, {
                            AllowGameModifiers?: boolean | undefined;
                            IsOvertimeWinByTwo?: boolean | undefined;
                            PlayOutAllRounds?: boolean | undefined;
                            SkipMatchHistory?: boolean | undefined;
                            TournamentMode?: boolean | undefined;
                        }, {
                            AllowGameModifiers?: string | undefined;
                            IsOvertimeWinByTwo?: string | undefined;
                            PlayOutAllRounds?: string | undefined;
                            SkipMatchHistory?: string | undefined;
                            TournamentMode?: string | undefined;
                        }>>;
                    }, "strip", zod.ZodTypeAny, {
                        Mode: string;
                        GameRules: {
                            AllowGameModifiers?: boolean | undefined;
                            IsOvertimeWinByTwo?: boolean | undefined;
                            PlayOutAllRounds?: boolean | undefined;
                            SkipMatchHistory?: boolean | undefined;
                            TournamentMode?: boolean | undefined;
                        } | null;
                        Map: string;
                        UseBots: boolean;
                        GamePod: string;
                    }, {
                        Mode: string;
                        GameRules: {
                            AllowGameModifiers?: string | undefined;
                            IsOvertimeWinByTwo?: string | undefined;
                            PlayOutAllRounds?: string | undefined;
                            SkipMatchHistory?: string | undefined;
                            TournamentMode?: string | undefined;
                        } | null;
                        Map: string;
                        UseBots: boolean;
                        GamePod: string;
                    }>;
                    Membership: zod.ZodObject<{
                        teamOne: zod.ZodNullable<zod.ZodArray<zod.ZodObject<{
                            Subject: zod.ZodString;
                        }, "strip", zod.ZodTypeAny, {
                            Subject: string;
                        }, {
                            Subject: string;
                        }>, "many">>;
                        teamTwo: zod.ZodNullable<zod.ZodArray<zod.ZodObject<{
                            Subject: zod.ZodString;
                        }, "strip", zod.ZodTypeAny, {
                            Subject: string;
                        }, {
                            Subject: string;
                        }>, "many">>;
                        teamSpectate: zod.ZodNullable<zod.ZodArray<zod.ZodObject<{
                            Subject: zod.ZodString;
                        }, "strip", zod.ZodTypeAny, {
                            Subject: string;
                        }, {
                            Subject: string;
                        }>, "many">>;
                        teamOneCoaches: zod.ZodNullable<zod.ZodArray<zod.ZodObject<{
                            Subject: zod.ZodString;
                        }, "strip", zod.ZodTypeAny, {
                            Subject: string;
                        }, {
                            Subject: string;
                        }>, "many">>;
                        teamTwoCoaches: zod.ZodNullable<zod.ZodArray<zod.ZodObject<{
                            Subject: zod.ZodString;
                        }, "strip", zod.ZodTypeAny, {
                            Subject: string;
                        }, {
                            Subject: string;
                        }>, "many">>;
                    }, "strip", zod.ZodTypeAny, {
                        teamOne: {
                            Subject: string;
                        }[] | null;
                        teamTwo: {
                            Subject: string;
                        }[] | null;
                        teamSpectate: {
                            Subject: string;
                        }[] | null;
                        teamOneCoaches: {
                            Subject: string;
                        }[] | null;
                        teamTwoCoaches: {
                            Subject: string;
                        }[] | null;
                    }, {
                        teamOne: {
                            Subject: string;
                        }[] | null;
                        teamTwo: {
                            Subject: string;
                        }[] | null;
                        teamSpectate: {
                            Subject: string;
                        }[] | null;
                        teamOneCoaches: {
                            Subject: string;
                        }[] | null;
                        teamTwoCoaches: {
                            Subject: string;
                        }[] | null;
                    }>;
                    MaxPartySize: zod.ZodNumber;
                    AutobalanceEnabled: zod.ZodBoolean;
                    AutobalanceMinPlayers: zod.ZodNumber;
                    HasRecoveryData: zod.ZodBoolean;
                }, "strip", zod.ZodTypeAny, {
                    MaxPartySize: number;
                    Settings: {
                        Mode: string;
                        GameRules: {
                            AllowGameModifiers?: boolean | undefined;
                            IsOvertimeWinByTwo?: boolean | undefined;
                            PlayOutAllRounds?: boolean | undefined;
                            SkipMatchHistory?: boolean | undefined;
                            TournamentMode?: boolean | undefined;
                        } | null;
                        Map: string;
                        UseBots: boolean;
                        GamePod: string;
                    };
                    Membership: {
                        teamOne: {
                            Subject: string;
                        }[] | null;
                        teamTwo: {
                            Subject: string;
                        }[] | null;
                        teamSpectate: {
                            Subject: string;
                        }[] | null;
                        teamOneCoaches: {
                            Subject: string;
                        }[] | null;
                        teamTwoCoaches: {
                            Subject: string;
                        }[] | null;
                    };
                    AutobalanceEnabled: boolean;
                    AutobalanceMinPlayers: number;
                    HasRecoveryData: boolean;
                }, {
                    MaxPartySize: number;
                    Settings: {
                        Mode: string;
                        GameRules: {
                            AllowGameModifiers?: string | undefined;
                            IsOvertimeWinByTwo?: string | undefined;
                            PlayOutAllRounds?: string | undefined;
                            SkipMatchHistory?: string | undefined;
                            TournamentMode?: string | undefined;
                        } | null;
                        Map: string;
                        UseBots: boolean;
                        GamePod: string;
                    };
                    Membership: {
                        teamOne: {
                            Subject: string;
                        }[] | null;
                        teamTwo: {
                            Subject: string;
                        }[] | null;
                        teamSpectate: {
                            Subject: string;
                        }[] | null;
                        teamOneCoaches: {
                            Subject: string;
                        }[] | null;
                        teamTwoCoaches: {
                            Subject: string;
                        }[] | null;
                    };
                    AutobalanceEnabled: boolean;
                    AutobalanceMinPlayers: number;
                    HasRecoveryData: boolean;
                }>;
                MatchmakingData: zod.ZodObject<{
                    QueueID: zod.ZodString;
                    PreferredGamePods: zod.ZodArray<zod.ZodString, "many">;
                    SkillDisparityRRPenalty: zod.ZodNumber;
                }, "strip", zod.ZodTypeAny, {
                    QueueID: string;
                    PreferredGamePods: string[];
                    SkillDisparityRRPenalty: number;
                }, {
                    QueueID: string;
                    PreferredGamePods: string[];
                    SkillDisparityRRPenalty: number;
                }>;
                Invites: zod.ZodNull;
                Requests: zod.ZodArray<zod.ZodUnknown, "many">;
                QueueEntryTime: zod.ZodEffects<zod.ZodString, Date, string>;
                ErrorNotification: zod.ZodObject<{
                    ErrorType: zod.ZodString;
                    ErroredPlayers: zod.ZodNullable<zod.ZodArray<zod.ZodObject<{
                        Subject: zod.ZodString;
                    }, "strip", zod.ZodTypeAny, {
                        Subject: string;
                    }, {
                        Subject: string;
                    }>, "many">>;
                }, "strip", zod.ZodTypeAny, {
                    ErrorType: string;
                    ErroredPlayers: {
                        Subject: string;
                    }[] | null;
                }, {
                    ErrorType: string;
                    ErroredPlayers: {
                        Subject: string;
                    }[] | null;
                }>;
                RestrictedSeconds: zod.ZodNumber;
                EligibleQueues: zod.ZodArray<zod.ZodString, "many">;
                QueueIneligibilities: zod.ZodArray<zod.ZodString, "many">;
                CheatData: zod.ZodObject<{
                    GamePodOverride: zod.ZodString;
                    ForcePostGameProcessing: zod.ZodBoolean;
                }, "strip", zod.ZodTypeAny, {
                    GamePodOverride: string;
                    ForcePostGameProcessing: boolean;
                }, {
                    GamePodOverride: string;
                    ForcePostGameProcessing: boolean;
                }>;
                XPBonuses: zod.ZodArray<zod.ZodUnknown, "many">;
                InviteCode: zod.ZodString;
            }, "strip", zod.ZodTypeAny, {
                ID: string;
                Version: number;
                Invites: null;
                Requests: unknown[];
                State: string;
                MatchmakingData: {
                    QueueID: string;
                    PreferredGamePods: string[];
                    SkillDisparityRRPenalty: number;
                };
                MUCName: string;
                VoiceRoomID: string;
                ClientVersion: string;
                Members: {
                    Subject: string;
                    PlayerIdentity: {
                        Subject: string;
                        PlayerCardID: string;
                        PlayerTitleID: string;
                        AccountLevel: number;
                        PreferredLevelBorderID: string;
                        Incognito: boolean;
                        HideAccountLevel: boolean;
                    };
                    SeasonalBadgeInfo: null;
                    CompetitiveTier: number;
                    QueueEligibleRemainingAccountLevels: number;
                    Pings: {
                        GamePodID: string;
                        Ping: number;
                    }[];
                    IsReady: boolean;
                    IsModerator: boolean;
                    UseBroadcastHUD: boolean;
                    PlatformType: "PC";
                    IsOwner?: boolean | undefined;
                }[];
                PreviousState: string;
                StateTransitionReason: string;
                Accessibility: "OPEN" | "CLOSED";
                CustomGameData: {
                    MaxPartySize: number;
                    Settings: {
                        Mode: string;
                        GameRules: {
                            AllowGameModifiers?: boolean | undefined;
                            IsOvertimeWinByTwo?: boolean | undefined;
                            PlayOutAllRounds?: boolean | undefined;
                            SkipMatchHistory?: boolean | undefined;
                            TournamentMode?: boolean | undefined;
                        } | null;
                        Map: string;
                        UseBots: boolean;
                        GamePod: string;
                    };
                    Membership: {
                        teamOne: {
                            Subject: string;
                        }[] | null;
                        teamTwo: {
                            Subject: string;
                        }[] | null;
                        teamSpectate: {
                            Subject: string;
                        }[] | null;
                        teamOneCoaches: {
                            Subject: string;
                        }[] | null;
                        teamTwoCoaches: {
                            Subject: string;
                        }[] | null;
                    };
                    AutobalanceEnabled: boolean;
                    AutobalanceMinPlayers: number;
                    HasRecoveryData: boolean;
                };
                QueueEntryTime: Date;
                ErrorNotification: {
                    ErrorType: string;
                    ErroredPlayers: {
                        Subject: string;
                    }[] | null;
                };
                RestrictedSeconds: number;
                EligibleQueues: string[];
                QueueIneligibilities: string[];
                CheatData: {
                    GamePodOverride: string;
                    ForcePostGameProcessing: boolean;
                };
                XPBonuses: unknown[];
                InviteCode: string;
            }, {
                ID: string;
                Version: number;
                Invites: null;
                Requests: unknown[];
                State: string;
                MatchmakingData: {
                    QueueID: string;
                    PreferredGamePods: string[];
                    SkillDisparityRRPenalty: number;
                };
                MUCName: string;
                VoiceRoomID: string;
                ClientVersion: string;
                Members: {
                    Subject: string;
                    PlayerIdentity: {
                        Subject: string;
                        PlayerCardID: string;
                        PlayerTitleID: string;
                        AccountLevel: number;
                        PreferredLevelBorderID: string;
                        Incognito: boolean;
                        HideAccountLevel: boolean;
                    };
                    SeasonalBadgeInfo: null;
                    CompetitiveTier: number;
                    QueueEligibleRemainingAccountLevels: number;
                    Pings: {
                        GamePodID: string;
                        Ping: number;
                    }[];
                    IsReady: boolean;
                    IsModerator: boolean;
                    UseBroadcastHUD: boolean;
                    PlatformType: "PC";
                    IsOwner?: boolean | undefined;
                }[];
                PreviousState: string;
                StateTransitionReason: string;
                Accessibility: "OPEN" | "CLOSED";
                CustomGameData: {
                    MaxPartySize: number;
                    Settings: {
                        Mode: string;
                        GameRules: {
                            AllowGameModifiers?: string | undefined;
                            IsOvertimeWinByTwo?: string | undefined;
                            PlayOutAllRounds?: string | undefined;
                            SkipMatchHistory?: string | undefined;
                            TournamentMode?: string | undefined;
                        } | null;
                        Map: string;
                        UseBots: boolean;
                        GamePod: string;
                    };
                    Membership: {
                        teamOne: {
                            Subject: string;
                        }[] | null;
                        teamTwo: {
                            Subject: string;
                        }[] | null;
                        teamSpectate: {
                            Subject: string;
                        }[] | null;
                        teamOneCoaches: {
                            Subject: string;
                        }[] | null;
                        teamTwoCoaches: {
                            Subject: string;
                        }[] | null;
                    };
                    AutobalanceEnabled: boolean;
                    AutobalanceMinPlayers: number;
                    HasRecoveryData: boolean;
                };
                QueueEntryTime: string;
                ErrorNotification: {
                    ErrorType: string;
                    ErroredPlayers: {
                        Subject: string;
                    }[] | null;
                };
                RestrictedSeconds: number;
                EligibleQueues: string[];
                QueueIneligibilities: string[];
                CheatData: {
                    GamePodOverride: string;
                    ForcePostGameProcessing: boolean;
                };
                XPBonuses: unknown[];
                InviteCode: string;
            }>;
        };
    };
};

type Params$p = ResolveParams<(typeof _default$p)["~type"]["url"]>;
type Body$p = z.infer<ResolveValue<(typeof _default$p)["~type"], "body">>;
type Data$p = ResolveData<Params$p, Body$p>;
type Response$p = z.infer<ResolveValue<(typeof _default$p)["~type"], "responses">["200"]>;
interface EnterMatchmakingQueueRequestConfig extends ValorantAxiosRequestConfig<Data$p> {
}
declare class EnterMatchmakingQueueEndpoint {
    /**
     * Enter the matchmaking queue for the party
     *
     * @EndpointType glz
     */
    postEnterMatchmakingQueue<T = Response$p>(this: RemoteApiClient, config: EnterMatchmakingQueueRequestConfig): Promise<AxiosResponse<T>>;
}

declare const _default$o: Omit<{
    requirements: string[];
    type: "auth" | "local" | "pd" | "glz" | "shared";
    name: string;
    method: "PUT" | "GET" | "DELETE" | "POST";
    url: string;
    description?: string | undefined;
    headers?: Record<string, string> | undefined;
    body?: zod.ZodType<any, zod.ZodTypeDef, any> | undefined;
    query?: zod.ZodType<any, zod.ZodTypeDef, any> | undefined;
    responses?: Record<string, zod.ZodType<any, zod.ZodTypeDef, any>> | undefined;
}, "type" | "name" | "url"> & Pick<{
    readonly name: "Leave Matchmaking Queue";
    readonly description: "Leave the matchmaking queue for the party";
    readonly type: "glz";
    readonly method: "POST";
    readonly url: "parties/v1/parties/:partyId/matchmaking/leave";
    readonly responses: {
        readonly "200": zod.ZodObject<{
            ID: zod.ZodString;
            MUCName: zod.ZodString;
            VoiceRoomID: zod.ZodString;
            Version: zod.ZodNumber;
            ClientVersion: zod.ZodString;
            Members: zod.ZodArray<zod.ZodObject<{
                Subject: zod.ZodString;
                CompetitiveTier: zod.ZodNumber;
                PlayerIdentity: zod.ZodObject<{
                    Subject: zod.ZodString;
                    PlayerCardID: zod.ZodString;
                    PlayerTitleID: zod.ZodString;
                    AccountLevel: zod.ZodNumber;
                    PreferredLevelBorderID: zod.ZodUnion<[zod.ZodString, zod.ZodLiteral<"">]>;
                    Incognito: zod.ZodBoolean;
                    HideAccountLevel: zod.ZodBoolean;
                }, "strip", zod.ZodTypeAny, {
                    Subject: string;
                    PlayerCardID: string;
                    PlayerTitleID: string;
                    AccountLevel: number;
                    PreferredLevelBorderID: string;
                    Incognito: boolean;
                    HideAccountLevel: boolean;
                }, {
                    Subject: string;
                    PlayerCardID: string;
                    PlayerTitleID: string;
                    AccountLevel: number;
                    PreferredLevelBorderID: string;
                    Incognito: boolean;
                    HideAccountLevel: boolean;
                }>;
                SeasonalBadgeInfo: zod.ZodNull;
                IsOwner: zod.ZodOptional<zod.ZodBoolean>;
                QueueEligibleRemainingAccountLevels: zod.ZodNumber;
                Pings: zod.ZodArray<zod.ZodObject<{
                    Ping: zod.ZodNumber;
                    GamePodID: zod.ZodString;
                }, "strip", zod.ZodTypeAny, {
                    GamePodID: string;
                    Ping: number;
                }, {
                    GamePodID: string;
                    Ping: number;
                }>, "many">;
                IsReady: zod.ZodBoolean;
                IsModerator: zod.ZodBoolean;
                UseBroadcastHUD: zod.ZodBoolean;
                PlatformType: zod.ZodLiteral<"PC">;
            }, "strip", zod.ZodTypeAny, {
                Subject: string;
                PlayerIdentity: {
                    Subject: string;
                    PlayerCardID: string;
                    PlayerTitleID: string;
                    AccountLevel: number;
                    PreferredLevelBorderID: string;
                    Incognito: boolean;
                    HideAccountLevel: boolean;
                };
                SeasonalBadgeInfo: null;
                CompetitiveTier: number;
                QueueEligibleRemainingAccountLevels: number;
                Pings: {
                    GamePodID: string;
                    Ping: number;
                }[];
                IsReady: boolean;
                IsModerator: boolean;
                UseBroadcastHUD: boolean;
                PlatformType: "PC";
                IsOwner?: boolean | undefined;
            }, {
                Subject: string;
                PlayerIdentity: {
                    Subject: string;
                    PlayerCardID: string;
                    PlayerTitleID: string;
                    AccountLevel: number;
                    PreferredLevelBorderID: string;
                    Incognito: boolean;
                    HideAccountLevel: boolean;
                };
                SeasonalBadgeInfo: null;
                CompetitiveTier: number;
                QueueEligibleRemainingAccountLevels: number;
                Pings: {
                    GamePodID: string;
                    Ping: number;
                }[];
                IsReady: boolean;
                IsModerator: boolean;
                UseBroadcastHUD: boolean;
                PlatformType: "PC";
                IsOwner?: boolean | undefined;
            }>, "many">;
            State: zod.ZodString;
            PreviousState: zod.ZodString;
            StateTransitionReason: zod.ZodString;
            Accessibility: zod.ZodUnion<[zod.ZodLiteral<"OPEN">, zod.ZodLiteral<"CLOSED">]>;
            CustomGameData: zod.ZodObject<{
                Settings: zod.ZodObject<{
                    Map: zod.ZodString;
                    Mode: zod.ZodString;
                    UseBots: zod.ZodBoolean;
                    GamePod: zod.ZodString;
                    GameRules: zod.ZodNullable<zod.ZodObject<{
                        AllowGameModifiers: zod.ZodOptional<zod.ZodEffects<zod.ZodString, boolean, string>>;
                        IsOvertimeWinByTwo: zod.ZodOptional<zod.ZodEffects<zod.ZodString, boolean, string>>;
                        PlayOutAllRounds: zod.ZodOptional<zod.ZodEffects<zod.ZodString, boolean, string>>;
                        SkipMatchHistory: zod.ZodOptional<zod.ZodEffects<zod.ZodString, boolean, string>>;
                        TournamentMode: zod.ZodOptional<zod.ZodEffects<zod.ZodString, boolean, string>>;
                    }, "strip", zod.ZodTypeAny, {
                        AllowGameModifiers?: boolean | undefined;
                        IsOvertimeWinByTwo?: boolean | undefined;
                        PlayOutAllRounds?: boolean | undefined;
                        SkipMatchHistory?: boolean | undefined;
                        TournamentMode?: boolean | undefined;
                    }, {
                        AllowGameModifiers?: string | undefined;
                        IsOvertimeWinByTwo?: string | undefined;
                        PlayOutAllRounds?: string | undefined;
                        SkipMatchHistory?: string | undefined;
                        TournamentMode?: string | undefined;
                    }>>;
                }, "strip", zod.ZodTypeAny, {
                    Mode: string;
                    GameRules: {
                        AllowGameModifiers?: boolean | undefined;
                        IsOvertimeWinByTwo?: boolean | undefined;
                        PlayOutAllRounds?: boolean | undefined;
                        SkipMatchHistory?: boolean | undefined;
                        TournamentMode?: boolean | undefined;
                    } | null;
                    Map: string;
                    UseBots: boolean;
                    GamePod: string;
                }, {
                    Mode: string;
                    GameRules: {
                        AllowGameModifiers?: string | undefined;
                        IsOvertimeWinByTwo?: string | undefined;
                        PlayOutAllRounds?: string | undefined;
                        SkipMatchHistory?: string | undefined;
                        TournamentMode?: string | undefined;
                    } | null;
                    Map: string;
                    UseBots: boolean;
                    GamePod: string;
                }>;
                Membership: zod.ZodObject<{
                    teamOne: zod.ZodNullable<zod.ZodArray<zod.ZodObject<{
                        Subject: zod.ZodString;
                    }, "strip", zod.ZodTypeAny, {
                        Subject: string;
                    }, {
                        Subject: string;
                    }>, "many">>;
                    teamTwo: zod.ZodNullable<zod.ZodArray<zod.ZodObject<{
                        Subject: zod.ZodString;
                    }, "strip", zod.ZodTypeAny, {
                        Subject: string;
                    }, {
                        Subject: string;
                    }>, "many">>;
                    teamSpectate: zod.ZodNullable<zod.ZodArray<zod.ZodObject<{
                        Subject: zod.ZodString;
                    }, "strip", zod.ZodTypeAny, {
                        Subject: string;
                    }, {
                        Subject: string;
                    }>, "many">>;
                    teamOneCoaches: zod.ZodNullable<zod.ZodArray<zod.ZodObject<{
                        Subject: zod.ZodString;
                    }, "strip", zod.ZodTypeAny, {
                        Subject: string;
                    }, {
                        Subject: string;
                    }>, "many">>;
                    teamTwoCoaches: zod.ZodNullable<zod.ZodArray<zod.ZodObject<{
                        Subject: zod.ZodString;
                    }, "strip", zod.ZodTypeAny, {
                        Subject: string;
                    }, {
                        Subject: string;
                    }>, "many">>;
                }, "strip", zod.ZodTypeAny, {
                    teamOne: {
                        Subject: string;
                    }[] | null;
                    teamTwo: {
                        Subject: string;
                    }[] | null;
                    teamSpectate: {
                        Subject: string;
                    }[] | null;
                    teamOneCoaches: {
                        Subject: string;
                    }[] | null;
                    teamTwoCoaches: {
                        Subject: string;
                    }[] | null;
                }, {
                    teamOne: {
                        Subject: string;
                    }[] | null;
                    teamTwo: {
                        Subject: string;
                    }[] | null;
                    teamSpectate: {
                        Subject: string;
                    }[] | null;
                    teamOneCoaches: {
                        Subject: string;
                    }[] | null;
                    teamTwoCoaches: {
                        Subject: string;
                    }[] | null;
                }>;
                MaxPartySize: zod.ZodNumber;
                AutobalanceEnabled: zod.ZodBoolean;
                AutobalanceMinPlayers: zod.ZodNumber;
                HasRecoveryData: zod.ZodBoolean;
            }, "strip", zod.ZodTypeAny, {
                MaxPartySize: number;
                Settings: {
                    Mode: string;
                    GameRules: {
                        AllowGameModifiers?: boolean | undefined;
                        IsOvertimeWinByTwo?: boolean | undefined;
                        PlayOutAllRounds?: boolean | undefined;
                        SkipMatchHistory?: boolean | undefined;
                        TournamentMode?: boolean | undefined;
                    } | null;
                    Map: string;
                    UseBots: boolean;
                    GamePod: string;
                };
                Membership: {
                    teamOne: {
                        Subject: string;
                    }[] | null;
                    teamTwo: {
                        Subject: string;
                    }[] | null;
                    teamSpectate: {
                        Subject: string;
                    }[] | null;
                    teamOneCoaches: {
                        Subject: string;
                    }[] | null;
                    teamTwoCoaches: {
                        Subject: string;
                    }[] | null;
                };
                AutobalanceEnabled: boolean;
                AutobalanceMinPlayers: number;
                HasRecoveryData: boolean;
            }, {
                MaxPartySize: number;
                Settings: {
                    Mode: string;
                    GameRules: {
                        AllowGameModifiers?: string | undefined;
                        IsOvertimeWinByTwo?: string | undefined;
                        PlayOutAllRounds?: string | undefined;
                        SkipMatchHistory?: string | undefined;
                        TournamentMode?: string | undefined;
                    } | null;
                    Map: string;
                    UseBots: boolean;
                    GamePod: string;
                };
                Membership: {
                    teamOne: {
                        Subject: string;
                    }[] | null;
                    teamTwo: {
                        Subject: string;
                    }[] | null;
                    teamSpectate: {
                        Subject: string;
                    }[] | null;
                    teamOneCoaches: {
                        Subject: string;
                    }[] | null;
                    teamTwoCoaches: {
                        Subject: string;
                    }[] | null;
                };
                AutobalanceEnabled: boolean;
                AutobalanceMinPlayers: number;
                HasRecoveryData: boolean;
            }>;
            MatchmakingData: zod.ZodObject<{
                QueueID: zod.ZodString;
                PreferredGamePods: zod.ZodArray<zod.ZodString, "many">;
                SkillDisparityRRPenalty: zod.ZodNumber;
            }, "strip", zod.ZodTypeAny, {
                QueueID: string;
                PreferredGamePods: string[];
                SkillDisparityRRPenalty: number;
            }, {
                QueueID: string;
                PreferredGamePods: string[];
                SkillDisparityRRPenalty: number;
            }>;
            Invites: zod.ZodNull;
            Requests: zod.ZodArray<zod.ZodUnknown, "many">;
            QueueEntryTime: zod.ZodEffects<zod.ZodString, Date, string>;
            ErrorNotification: zod.ZodObject<{
                ErrorType: zod.ZodString;
                ErroredPlayers: zod.ZodNullable<zod.ZodArray<zod.ZodObject<{
                    Subject: zod.ZodString;
                }, "strip", zod.ZodTypeAny, {
                    Subject: string;
                }, {
                    Subject: string;
                }>, "many">>;
            }, "strip", zod.ZodTypeAny, {
                ErrorType: string;
                ErroredPlayers: {
                    Subject: string;
                }[] | null;
            }, {
                ErrorType: string;
                ErroredPlayers: {
                    Subject: string;
                }[] | null;
            }>;
            RestrictedSeconds: zod.ZodNumber;
            EligibleQueues: zod.ZodArray<zod.ZodString, "many">;
            QueueIneligibilities: zod.ZodArray<zod.ZodString, "many">;
            CheatData: zod.ZodObject<{
                GamePodOverride: zod.ZodString;
                ForcePostGameProcessing: zod.ZodBoolean;
            }, "strip", zod.ZodTypeAny, {
                GamePodOverride: string;
                ForcePostGameProcessing: boolean;
            }, {
                GamePodOverride: string;
                ForcePostGameProcessing: boolean;
            }>;
            XPBonuses: zod.ZodArray<zod.ZodUnknown, "many">;
            InviteCode: zod.ZodString;
        }, "strip", zod.ZodTypeAny, {
            ID: string;
            Version: number;
            Invites: null;
            Requests: unknown[];
            State: string;
            MatchmakingData: {
                QueueID: string;
                PreferredGamePods: string[];
                SkillDisparityRRPenalty: number;
            };
            MUCName: string;
            VoiceRoomID: string;
            ClientVersion: string;
            Members: {
                Subject: string;
                PlayerIdentity: {
                    Subject: string;
                    PlayerCardID: string;
                    PlayerTitleID: string;
                    AccountLevel: number;
                    PreferredLevelBorderID: string;
                    Incognito: boolean;
                    HideAccountLevel: boolean;
                };
                SeasonalBadgeInfo: null;
                CompetitiveTier: number;
                QueueEligibleRemainingAccountLevels: number;
                Pings: {
                    GamePodID: string;
                    Ping: number;
                }[];
                IsReady: boolean;
                IsModerator: boolean;
                UseBroadcastHUD: boolean;
                PlatformType: "PC";
                IsOwner?: boolean | undefined;
            }[];
            PreviousState: string;
            StateTransitionReason: string;
            Accessibility: "OPEN" | "CLOSED";
            CustomGameData: {
                MaxPartySize: number;
                Settings: {
                    Mode: string;
                    GameRules: {
                        AllowGameModifiers?: boolean | undefined;
                        IsOvertimeWinByTwo?: boolean | undefined;
                        PlayOutAllRounds?: boolean | undefined;
                        SkipMatchHistory?: boolean | undefined;
                        TournamentMode?: boolean | undefined;
                    } | null;
                    Map: string;
                    UseBots: boolean;
                    GamePod: string;
                };
                Membership: {
                    teamOne: {
                        Subject: string;
                    }[] | null;
                    teamTwo: {
                        Subject: string;
                    }[] | null;
                    teamSpectate: {
                        Subject: string;
                    }[] | null;
                    teamOneCoaches: {
                        Subject: string;
                    }[] | null;
                    teamTwoCoaches: {
                        Subject: string;
                    }[] | null;
                };
                AutobalanceEnabled: boolean;
                AutobalanceMinPlayers: number;
                HasRecoveryData: boolean;
            };
            QueueEntryTime: Date;
            ErrorNotification: {
                ErrorType: string;
                ErroredPlayers: {
                    Subject: string;
                }[] | null;
            };
            RestrictedSeconds: number;
            EligibleQueues: string[];
            QueueIneligibilities: string[];
            CheatData: {
                GamePodOverride: string;
                ForcePostGameProcessing: boolean;
            };
            XPBonuses: unknown[];
            InviteCode: string;
        }, {
            ID: string;
            Version: number;
            Invites: null;
            Requests: unknown[];
            State: string;
            MatchmakingData: {
                QueueID: string;
                PreferredGamePods: string[];
                SkillDisparityRRPenalty: number;
            };
            MUCName: string;
            VoiceRoomID: string;
            ClientVersion: string;
            Members: {
                Subject: string;
                PlayerIdentity: {
                    Subject: string;
                    PlayerCardID: string;
                    PlayerTitleID: string;
                    AccountLevel: number;
                    PreferredLevelBorderID: string;
                    Incognito: boolean;
                    HideAccountLevel: boolean;
                };
                SeasonalBadgeInfo: null;
                CompetitiveTier: number;
                QueueEligibleRemainingAccountLevels: number;
                Pings: {
                    GamePodID: string;
                    Ping: number;
                }[];
                IsReady: boolean;
                IsModerator: boolean;
                UseBroadcastHUD: boolean;
                PlatformType: "PC";
                IsOwner?: boolean | undefined;
            }[];
            PreviousState: string;
            StateTransitionReason: string;
            Accessibility: "OPEN" | "CLOSED";
            CustomGameData: {
                MaxPartySize: number;
                Settings: {
                    Mode: string;
                    GameRules: {
                        AllowGameModifiers?: string | undefined;
                        IsOvertimeWinByTwo?: string | undefined;
                        PlayOutAllRounds?: string | undefined;
                        SkipMatchHistory?: string | undefined;
                        TournamentMode?: string | undefined;
                    } | null;
                    Map: string;
                    UseBots: boolean;
                    GamePod: string;
                };
                Membership: {
                    teamOne: {
                        Subject: string;
                    }[] | null;
                    teamTwo: {
                        Subject: string;
                    }[] | null;
                    teamSpectate: {
                        Subject: string;
                    }[] | null;
                    teamOneCoaches: {
                        Subject: string;
                    }[] | null;
                    teamTwoCoaches: {
                        Subject: string;
                    }[] | null;
                };
                AutobalanceEnabled: boolean;
                AutobalanceMinPlayers: number;
                HasRecoveryData: boolean;
            };
            QueueEntryTime: string;
            ErrorNotification: {
                ErrorType: string;
                ErroredPlayers: {
                    Subject: string;
                }[] | null;
            };
            RestrictedSeconds: number;
            EligibleQueues: string[];
            QueueIneligibilities: string[];
            CheatData: {
                GamePodOverride: string;
                ForcePostGameProcessing: boolean;
            };
            XPBonuses: unknown[];
            InviteCode: string;
        }>;
    };
}, "type" | "name" | "url"> & {
    "~type": {
        readonly name: "Leave Matchmaking Queue";
        readonly description: "Leave the matchmaking queue for the party";
        readonly type: "glz";
        readonly method: "POST";
        readonly url: "parties/v1/parties/:partyId/matchmaking/leave";
        readonly responses: {
            readonly "200": zod.ZodObject<{
                ID: zod.ZodString;
                MUCName: zod.ZodString;
                VoiceRoomID: zod.ZodString;
                Version: zod.ZodNumber;
                ClientVersion: zod.ZodString;
                Members: zod.ZodArray<zod.ZodObject<{
                    Subject: zod.ZodString;
                    CompetitiveTier: zod.ZodNumber;
                    PlayerIdentity: zod.ZodObject<{
                        Subject: zod.ZodString;
                        PlayerCardID: zod.ZodString;
                        PlayerTitleID: zod.ZodString;
                        AccountLevel: zod.ZodNumber;
                        PreferredLevelBorderID: zod.ZodUnion<[zod.ZodString, zod.ZodLiteral<"">]>;
                        Incognito: zod.ZodBoolean;
                        HideAccountLevel: zod.ZodBoolean;
                    }, "strip", zod.ZodTypeAny, {
                        Subject: string;
                        PlayerCardID: string;
                        PlayerTitleID: string;
                        AccountLevel: number;
                        PreferredLevelBorderID: string;
                        Incognito: boolean;
                        HideAccountLevel: boolean;
                    }, {
                        Subject: string;
                        PlayerCardID: string;
                        PlayerTitleID: string;
                        AccountLevel: number;
                        PreferredLevelBorderID: string;
                        Incognito: boolean;
                        HideAccountLevel: boolean;
                    }>;
                    SeasonalBadgeInfo: zod.ZodNull;
                    IsOwner: zod.ZodOptional<zod.ZodBoolean>;
                    QueueEligibleRemainingAccountLevels: zod.ZodNumber;
                    Pings: zod.ZodArray<zod.ZodObject<{
                        Ping: zod.ZodNumber;
                        GamePodID: zod.ZodString;
                    }, "strip", zod.ZodTypeAny, {
                        GamePodID: string;
                        Ping: number;
                    }, {
                        GamePodID: string;
                        Ping: number;
                    }>, "many">;
                    IsReady: zod.ZodBoolean;
                    IsModerator: zod.ZodBoolean;
                    UseBroadcastHUD: zod.ZodBoolean;
                    PlatformType: zod.ZodLiteral<"PC">;
                }, "strip", zod.ZodTypeAny, {
                    Subject: string;
                    PlayerIdentity: {
                        Subject: string;
                        PlayerCardID: string;
                        PlayerTitleID: string;
                        AccountLevel: number;
                        PreferredLevelBorderID: string;
                        Incognito: boolean;
                        HideAccountLevel: boolean;
                    };
                    SeasonalBadgeInfo: null;
                    CompetitiveTier: number;
                    QueueEligibleRemainingAccountLevels: number;
                    Pings: {
                        GamePodID: string;
                        Ping: number;
                    }[];
                    IsReady: boolean;
                    IsModerator: boolean;
                    UseBroadcastHUD: boolean;
                    PlatformType: "PC";
                    IsOwner?: boolean | undefined;
                }, {
                    Subject: string;
                    PlayerIdentity: {
                        Subject: string;
                        PlayerCardID: string;
                        PlayerTitleID: string;
                        AccountLevel: number;
                        PreferredLevelBorderID: string;
                        Incognito: boolean;
                        HideAccountLevel: boolean;
                    };
                    SeasonalBadgeInfo: null;
                    CompetitiveTier: number;
                    QueueEligibleRemainingAccountLevels: number;
                    Pings: {
                        GamePodID: string;
                        Ping: number;
                    }[];
                    IsReady: boolean;
                    IsModerator: boolean;
                    UseBroadcastHUD: boolean;
                    PlatformType: "PC";
                    IsOwner?: boolean | undefined;
                }>, "many">;
                State: zod.ZodString;
                PreviousState: zod.ZodString;
                StateTransitionReason: zod.ZodString;
                Accessibility: zod.ZodUnion<[zod.ZodLiteral<"OPEN">, zod.ZodLiteral<"CLOSED">]>;
                CustomGameData: zod.ZodObject<{
                    Settings: zod.ZodObject<{
                        Map: zod.ZodString;
                        Mode: zod.ZodString;
                        UseBots: zod.ZodBoolean;
                        GamePod: zod.ZodString;
                        GameRules: zod.ZodNullable<zod.ZodObject<{
                            AllowGameModifiers: zod.ZodOptional<zod.ZodEffects<zod.ZodString, boolean, string>>;
                            IsOvertimeWinByTwo: zod.ZodOptional<zod.ZodEffects<zod.ZodString, boolean, string>>;
                            PlayOutAllRounds: zod.ZodOptional<zod.ZodEffects<zod.ZodString, boolean, string>>;
                            SkipMatchHistory: zod.ZodOptional<zod.ZodEffects<zod.ZodString, boolean, string>>;
                            TournamentMode: zod.ZodOptional<zod.ZodEffects<zod.ZodString, boolean, string>>;
                        }, "strip", zod.ZodTypeAny, {
                            AllowGameModifiers?: boolean | undefined;
                            IsOvertimeWinByTwo?: boolean | undefined;
                            PlayOutAllRounds?: boolean | undefined;
                            SkipMatchHistory?: boolean | undefined;
                            TournamentMode?: boolean | undefined;
                        }, {
                            AllowGameModifiers?: string | undefined;
                            IsOvertimeWinByTwo?: string | undefined;
                            PlayOutAllRounds?: string | undefined;
                            SkipMatchHistory?: string | undefined;
                            TournamentMode?: string | undefined;
                        }>>;
                    }, "strip", zod.ZodTypeAny, {
                        Mode: string;
                        GameRules: {
                            AllowGameModifiers?: boolean | undefined;
                            IsOvertimeWinByTwo?: boolean | undefined;
                            PlayOutAllRounds?: boolean | undefined;
                            SkipMatchHistory?: boolean | undefined;
                            TournamentMode?: boolean | undefined;
                        } | null;
                        Map: string;
                        UseBots: boolean;
                        GamePod: string;
                    }, {
                        Mode: string;
                        GameRules: {
                            AllowGameModifiers?: string | undefined;
                            IsOvertimeWinByTwo?: string | undefined;
                            PlayOutAllRounds?: string | undefined;
                            SkipMatchHistory?: string | undefined;
                            TournamentMode?: string | undefined;
                        } | null;
                        Map: string;
                        UseBots: boolean;
                        GamePod: string;
                    }>;
                    Membership: zod.ZodObject<{
                        teamOne: zod.ZodNullable<zod.ZodArray<zod.ZodObject<{
                            Subject: zod.ZodString;
                        }, "strip", zod.ZodTypeAny, {
                            Subject: string;
                        }, {
                            Subject: string;
                        }>, "many">>;
                        teamTwo: zod.ZodNullable<zod.ZodArray<zod.ZodObject<{
                            Subject: zod.ZodString;
                        }, "strip", zod.ZodTypeAny, {
                            Subject: string;
                        }, {
                            Subject: string;
                        }>, "many">>;
                        teamSpectate: zod.ZodNullable<zod.ZodArray<zod.ZodObject<{
                            Subject: zod.ZodString;
                        }, "strip", zod.ZodTypeAny, {
                            Subject: string;
                        }, {
                            Subject: string;
                        }>, "many">>;
                        teamOneCoaches: zod.ZodNullable<zod.ZodArray<zod.ZodObject<{
                            Subject: zod.ZodString;
                        }, "strip", zod.ZodTypeAny, {
                            Subject: string;
                        }, {
                            Subject: string;
                        }>, "many">>;
                        teamTwoCoaches: zod.ZodNullable<zod.ZodArray<zod.ZodObject<{
                            Subject: zod.ZodString;
                        }, "strip", zod.ZodTypeAny, {
                            Subject: string;
                        }, {
                            Subject: string;
                        }>, "many">>;
                    }, "strip", zod.ZodTypeAny, {
                        teamOne: {
                            Subject: string;
                        }[] | null;
                        teamTwo: {
                            Subject: string;
                        }[] | null;
                        teamSpectate: {
                            Subject: string;
                        }[] | null;
                        teamOneCoaches: {
                            Subject: string;
                        }[] | null;
                        teamTwoCoaches: {
                            Subject: string;
                        }[] | null;
                    }, {
                        teamOne: {
                            Subject: string;
                        }[] | null;
                        teamTwo: {
                            Subject: string;
                        }[] | null;
                        teamSpectate: {
                            Subject: string;
                        }[] | null;
                        teamOneCoaches: {
                            Subject: string;
                        }[] | null;
                        teamTwoCoaches: {
                            Subject: string;
                        }[] | null;
                    }>;
                    MaxPartySize: zod.ZodNumber;
                    AutobalanceEnabled: zod.ZodBoolean;
                    AutobalanceMinPlayers: zod.ZodNumber;
                    HasRecoveryData: zod.ZodBoolean;
                }, "strip", zod.ZodTypeAny, {
                    MaxPartySize: number;
                    Settings: {
                        Mode: string;
                        GameRules: {
                            AllowGameModifiers?: boolean | undefined;
                            IsOvertimeWinByTwo?: boolean | undefined;
                            PlayOutAllRounds?: boolean | undefined;
                            SkipMatchHistory?: boolean | undefined;
                            TournamentMode?: boolean | undefined;
                        } | null;
                        Map: string;
                        UseBots: boolean;
                        GamePod: string;
                    };
                    Membership: {
                        teamOne: {
                            Subject: string;
                        }[] | null;
                        teamTwo: {
                            Subject: string;
                        }[] | null;
                        teamSpectate: {
                            Subject: string;
                        }[] | null;
                        teamOneCoaches: {
                            Subject: string;
                        }[] | null;
                        teamTwoCoaches: {
                            Subject: string;
                        }[] | null;
                    };
                    AutobalanceEnabled: boolean;
                    AutobalanceMinPlayers: number;
                    HasRecoveryData: boolean;
                }, {
                    MaxPartySize: number;
                    Settings: {
                        Mode: string;
                        GameRules: {
                            AllowGameModifiers?: string | undefined;
                            IsOvertimeWinByTwo?: string | undefined;
                            PlayOutAllRounds?: string | undefined;
                            SkipMatchHistory?: string | undefined;
                            TournamentMode?: string | undefined;
                        } | null;
                        Map: string;
                        UseBots: boolean;
                        GamePod: string;
                    };
                    Membership: {
                        teamOne: {
                            Subject: string;
                        }[] | null;
                        teamTwo: {
                            Subject: string;
                        }[] | null;
                        teamSpectate: {
                            Subject: string;
                        }[] | null;
                        teamOneCoaches: {
                            Subject: string;
                        }[] | null;
                        teamTwoCoaches: {
                            Subject: string;
                        }[] | null;
                    };
                    AutobalanceEnabled: boolean;
                    AutobalanceMinPlayers: number;
                    HasRecoveryData: boolean;
                }>;
                MatchmakingData: zod.ZodObject<{
                    QueueID: zod.ZodString;
                    PreferredGamePods: zod.ZodArray<zod.ZodString, "many">;
                    SkillDisparityRRPenalty: zod.ZodNumber;
                }, "strip", zod.ZodTypeAny, {
                    QueueID: string;
                    PreferredGamePods: string[];
                    SkillDisparityRRPenalty: number;
                }, {
                    QueueID: string;
                    PreferredGamePods: string[];
                    SkillDisparityRRPenalty: number;
                }>;
                Invites: zod.ZodNull;
                Requests: zod.ZodArray<zod.ZodUnknown, "many">;
                QueueEntryTime: zod.ZodEffects<zod.ZodString, Date, string>;
                ErrorNotification: zod.ZodObject<{
                    ErrorType: zod.ZodString;
                    ErroredPlayers: zod.ZodNullable<zod.ZodArray<zod.ZodObject<{
                        Subject: zod.ZodString;
                    }, "strip", zod.ZodTypeAny, {
                        Subject: string;
                    }, {
                        Subject: string;
                    }>, "many">>;
                }, "strip", zod.ZodTypeAny, {
                    ErrorType: string;
                    ErroredPlayers: {
                        Subject: string;
                    }[] | null;
                }, {
                    ErrorType: string;
                    ErroredPlayers: {
                        Subject: string;
                    }[] | null;
                }>;
                RestrictedSeconds: zod.ZodNumber;
                EligibleQueues: zod.ZodArray<zod.ZodString, "many">;
                QueueIneligibilities: zod.ZodArray<zod.ZodString, "many">;
                CheatData: zod.ZodObject<{
                    GamePodOverride: zod.ZodString;
                    ForcePostGameProcessing: zod.ZodBoolean;
                }, "strip", zod.ZodTypeAny, {
                    GamePodOverride: string;
                    ForcePostGameProcessing: boolean;
                }, {
                    GamePodOverride: string;
                    ForcePostGameProcessing: boolean;
                }>;
                XPBonuses: zod.ZodArray<zod.ZodUnknown, "many">;
                InviteCode: zod.ZodString;
            }, "strip", zod.ZodTypeAny, {
                ID: string;
                Version: number;
                Invites: null;
                Requests: unknown[];
                State: string;
                MatchmakingData: {
                    QueueID: string;
                    PreferredGamePods: string[];
                    SkillDisparityRRPenalty: number;
                };
                MUCName: string;
                VoiceRoomID: string;
                ClientVersion: string;
                Members: {
                    Subject: string;
                    PlayerIdentity: {
                        Subject: string;
                        PlayerCardID: string;
                        PlayerTitleID: string;
                        AccountLevel: number;
                        PreferredLevelBorderID: string;
                        Incognito: boolean;
                        HideAccountLevel: boolean;
                    };
                    SeasonalBadgeInfo: null;
                    CompetitiveTier: number;
                    QueueEligibleRemainingAccountLevels: number;
                    Pings: {
                        GamePodID: string;
                        Ping: number;
                    }[];
                    IsReady: boolean;
                    IsModerator: boolean;
                    UseBroadcastHUD: boolean;
                    PlatformType: "PC";
                    IsOwner?: boolean | undefined;
                }[];
                PreviousState: string;
                StateTransitionReason: string;
                Accessibility: "OPEN" | "CLOSED";
                CustomGameData: {
                    MaxPartySize: number;
                    Settings: {
                        Mode: string;
                        GameRules: {
                            AllowGameModifiers?: boolean | undefined;
                            IsOvertimeWinByTwo?: boolean | undefined;
                            PlayOutAllRounds?: boolean | undefined;
                            SkipMatchHistory?: boolean | undefined;
                            TournamentMode?: boolean | undefined;
                        } | null;
                        Map: string;
                        UseBots: boolean;
                        GamePod: string;
                    };
                    Membership: {
                        teamOne: {
                            Subject: string;
                        }[] | null;
                        teamTwo: {
                            Subject: string;
                        }[] | null;
                        teamSpectate: {
                            Subject: string;
                        }[] | null;
                        teamOneCoaches: {
                            Subject: string;
                        }[] | null;
                        teamTwoCoaches: {
                            Subject: string;
                        }[] | null;
                    };
                    AutobalanceEnabled: boolean;
                    AutobalanceMinPlayers: number;
                    HasRecoveryData: boolean;
                };
                QueueEntryTime: Date;
                ErrorNotification: {
                    ErrorType: string;
                    ErroredPlayers: {
                        Subject: string;
                    }[] | null;
                };
                RestrictedSeconds: number;
                EligibleQueues: string[];
                QueueIneligibilities: string[];
                CheatData: {
                    GamePodOverride: string;
                    ForcePostGameProcessing: boolean;
                };
                XPBonuses: unknown[];
                InviteCode: string;
            }, {
                ID: string;
                Version: number;
                Invites: null;
                Requests: unknown[];
                State: string;
                MatchmakingData: {
                    QueueID: string;
                    PreferredGamePods: string[];
                    SkillDisparityRRPenalty: number;
                };
                MUCName: string;
                VoiceRoomID: string;
                ClientVersion: string;
                Members: {
                    Subject: string;
                    PlayerIdentity: {
                        Subject: string;
                        PlayerCardID: string;
                        PlayerTitleID: string;
                        AccountLevel: number;
                        PreferredLevelBorderID: string;
                        Incognito: boolean;
                        HideAccountLevel: boolean;
                    };
                    SeasonalBadgeInfo: null;
                    CompetitiveTier: number;
                    QueueEligibleRemainingAccountLevels: number;
                    Pings: {
                        GamePodID: string;
                        Ping: number;
                    }[];
                    IsReady: boolean;
                    IsModerator: boolean;
                    UseBroadcastHUD: boolean;
                    PlatformType: "PC";
                    IsOwner?: boolean | undefined;
                }[];
                PreviousState: string;
                StateTransitionReason: string;
                Accessibility: "OPEN" | "CLOSED";
                CustomGameData: {
                    MaxPartySize: number;
                    Settings: {
                        Mode: string;
                        GameRules: {
                            AllowGameModifiers?: string | undefined;
                            IsOvertimeWinByTwo?: string | undefined;
                            PlayOutAllRounds?: string | undefined;
                            SkipMatchHistory?: string | undefined;
                            TournamentMode?: string | undefined;
                        } | null;
                        Map: string;
                        UseBots: boolean;
                        GamePod: string;
                    };
                    Membership: {
                        teamOne: {
                            Subject: string;
                        }[] | null;
                        teamTwo: {
                            Subject: string;
                        }[] | null;
                        teamSpectate: {
                            Subject: string;
                        }[] | null;
                        teamOneCoaches: {
                            Subject: string;
                        }[] | null;
                        teamTwoCoaches: {
                            Subject: string;
                        }[] | null;
                    };
                    AutobalanceEnabled: boolean;
                    AutobalanceMinPlayers: number;
                    HasRecoveryData: boolean;
                };
                QueueEntryTime: string;
                ErrorNotification: {
                    ErrorType: string;
                    ErroredPlayers: {
                        Subject: string;
                    }[] | null;
                };
                RestrictedSeconds: number;
                EligibleQueues: string[];
                QueueIneligibilities: string[];
                CheatData: {
                    GamePodOverride: string;
                    ForcePostGameProcessing: boolean;
                };
                XPBonuses: unknown[];
                InviteCode: string;
            }>;
        };
    };
};

type Params$o = ResolveParams<(typeof _default$o)["~type"]["url"]>;
type Body$o = z.infer<ResolveValue<(typeof _default$o)["~type"], "body">>;
type Data$o = ResolveData<Params$o, Body$o>;
type Response$o = z.infer<ResolveValue<(typeof _default$o)["~type"], "responses">["200"]>;
interface LeaveMatchmakingQueueRequestConfig extends ValorantAxiosRequestConfig<Data$o> {
}
declare class LeaveMatchmakingQueueEndpoint {
    /**
     * Leave the matchmaking queue for the party
     *
     * @EndpointType glz
     */
    postLeaveMatchmakingQueue<T = Response$o>(this: RemoteApiClient, config: LeaveMatchmakingQueueRequestConfig): Promise<AxiosResponse<T>>;
}

declare const _default$n: Omit<{
    requirements: string[];
    type: "auth" | "local" | "pd" | "glz" | "shared";
    name: string;
    method: "PUT" | "GET" | "DELETE" | "POST";
    url: string;
    description?: string | undefined;
    headers?: Record<string, string> | undefined;
    body?: zod.ZodType<any, zod.ZodTypeDef, any> | undefined;
    query?: zod.ZodType<any, zod.ZodTypeDef, any> | undefined;
    responses?: Record<string, zod.ZodType<any, zod.ZodTypeDef, any>> | undefined;
}, "type" | "name" | "url"> & Pick<{
    readonly name: "Lock Character";
    readonly description: string;
    readonly type: "glz";
    readonly method: "POST";
    readonly url: "pregame/v1/matches/:pregameMatchId/lock/:agentId";
    readonly responses: {
        readonly "200": zod.ZodObject<{
            ID: zod.ZodString;
            Version: zod.ZodNumber;
            Teams: zod.ZodArray<zod.ZodObject<{
                TeamID: zod.ZodUnion<[zod.ZodEnum<["Blue", "Red"]>, zod.ZodString]>;
                Players: zod.ZodArray<zod.ZodObject<{
                    Subject: zod.ZodString;
                    CharacterID: zod.ZodString;
                    CharacterSelectionState: zod.ZodEnum<["", "selected", "locked"]>;
                    PregamePlayerState: zod.ZodEnum<["joined"]>;
                    CompetitiveTier: zod.ZodNumber;
                    PlayerIdentity: zod.ZodObject<{
                        Subject: zod.ZodString;
                        PlayerCardID: zod.ZodString;
                        PlayerTitleID: zod.ZodString;
                        AccountLevel: zod.ZodNumber;
                        PreferredLevelBorderID: zod.ZodUnion<[zod.ZodString, zod.ZodLiteral<"">]>;
                        Incognito: zod.ZodBoolean;
                        HideAccountLevel: zod.ZodBoolean;
                    }, "strip", zod.ZodTypeAny, {
                        Subject: string;
                        PlayerCardID: string;
                        PlayerTitleID: string;
                        AccountLevel: number;
                        PreferredLevelBorderID: string;
                        Incognito: boolean;
                        HideAccountLevel: boolean;
                    }, {
                        Subject: string;
                        PlayerCardID: string;
                        PlayerTitleID: string;
                        AccountLevel: number;
                        PreferredLevelBorderID: string;
                        Incognito: boolean;
                        HideAccountLevel: boolean;
                    }>;
                    SeasonalBadgeInfo: zod.ZodObject<{
                        SeasonID: zod.ZodUnion<[zod.ZodString, zod.ZodLiteral<"">]>;
                        NumberOfWins: zod.ZodNumber;
                        WinsByTier: zod.ZodNull;
                        Rank: zod.ZodNumber;
                        LeaderboardRank: zod.ZodNumber;
                    }, "strip", zod.ZodTypeAny, {
                        SeasonID: string;
                        NumberOfWins: number;
                        WinsByTier: null;
                        Rank: number;
                        LeaderboardRank: number;
                    }, {
                        SeasonID: string;
                        NumberOfWins: number;
                        WinsByTier: null;
                        Rank: number;
                        LeaderboardRank: number;
                    }>;
                    IsCaptain: zod.ZodBoolean;
                }, "strip", zod.ZodTypeAny, {
                    CharacterID: string;
                    Subject: string;
                    PlayerIdentity: {
                        Subject: string;
                        PlayerCardID: string;
                        PlayerTitleID: string;
                        AccountLevel: number;
                        PreferredLevelBorderID: string;
                        Incognito: boolean;
                        HideAccountLevel: boolean;
                    };
                    SeasonalBadgeInfo: {
                        SeasonID: string;
                        NumberOfWins: number;
                        WinsByTier: null;
                        Rank: number;
                        LeaderboardRank: number;
                    };
                    CompetitiveTier: number;
                    CharacterSelectionState: "" | "selected" | "locked";
                    PregamePlayerState: "joined";
                    IsCaptain: boolean;
                }, {
                    CharacterID: string;
                    Subject: string;
                    PlayerIdentity: {
                        Subject: string;
                        PlayerCardID: string;
                        PlayerTitleID: string;
                        AccountLevel: number;
                        PreferredLevelBorderID: string;
                        Incognito: boolean;
                        HideAccountLevel: boolean;
                    };
                    SeasonalBadgeInfo: {
                        SeasonID: string;
                        NumberOfWins: number;
                        WinsByTier: null;
                        Rank: number;
                        LeaderboardRank: number;
                    };
                    CompetitiveTier: number;
                    CharacterSelectionState: "" | "selected" | "locked";
                    PregamePlayerState: "joined";
                    IsCaptain: boolean;
                }>, "many">;
            }, "strip", zod.ZodTypeAny, {
                Players: {
                    CharacterID: string;
                    Subject: string;
                    PlayerIdentity: {
                        Subject: string;
                        PlayerCardID: string;
                        PlayerTitleID: string;
                        AccountLevel: number;
                        PreferredLevelBorderID: string;
                        Incognito: boolean;
                        HideAccountLevel: boolean;
                    };
                    SeasonalBadgeInfo: {
                        SeasonID: string;
                        NumberOfWins: number;
                        WinsByTier: null;
                        Rank: number;
                        LeaderboardRank: number;
                    };
                    CompetitiveTier: number;
                    CharacterSelectionState: "" | "selected" | "locked";
                    PregamePlayerState: "joined";
                    IsCaptain: boolean;
                }[];
                TeamID: string;
            }, {
                Players: {
                    CharacterID: string;
                    Subject: string;
                    PlayerIdentity: {
                        Subject: string;
                        PlayerCardID: string;
                        PlayerTitleID: string;
                        AccountLevel: number;
                        PreferredLevelBorderID: string;
                        Incognito: boolean;
                        HideAccountLevel: boolean;
                    };
                    SeasonalBadgeInfo: {
                        SeasonID: string;
                        NumberOfWins: number;
                        WinsByTier: null;
                        Rank: number;
                        LeaderboardRank: number;
                    };
                    CompetitiveTier: number;
                    CharacterSelectionState: "" | "selected" | "locked";
                    PregamePlayerState: "joined";
                    IsCaptain: boolean;
                }[];
                TeamID: string;
            }>, "many">;
            AllyTeam: zod.ZodNullable<zod.ZodObject<{
                TeamID: zod.ZodUnion<[zod.ZodEnum<["Blue", "Red"]>, zod.ZodString]>;
                Players: zod.ZodArray<zod.ZodObject<{
                    Subject: zod.ZodString;
                    CharacterID: zod.ZodString;
                    CharacterSelectionState: zod.ZodEnum<["", "selected", "locked"]>;
                    PregamePlayerState: zod.ZodEnum<["joined"]>;
                    CompetitiveTier: zod.ZodNumber;
                    PlayerIdentity: zod.ZodObject<{
                        Subject: zod.ZodString;
                        PlayerCardID: zod.ZodString;
                        PlayerTitleID: zod.ZodString;
                        AccountLevel: zod.ZodNumber;
                        PreferredLevelBorderID: zod.ZodUnion<[zod.ZodString, zod.ZodLiteral<"">]>;
                        Incognito: zod.ZodBoolean;
                        HideAccountLevel: zod.ZodBoolean;
                    }, "strip", zod.ZodTypeAny, {
                        Subject: string;
                        PlayerCardID: string;
                        PlayerTitleID: string;
                        AccountLevel: number;
                        PreferredLevelBorderID: string;
                        Incognito: boolean;
                        HideAccountLevel: boolean;
                    }, {
                        Subject: string;
                        PlayerCardID: string;
                        PlayerTitleID: string;
                        AccountLevel: number;
                        PreferredLevelBorderID: string;
                        Incognito: boolean;
                        HideAccountLevel: boolean;
                    }>;
                    SeasonalBadgeInfo: zod.ZodObject<{
                        SeasonID: zod.ZodUnion<[zod.ZodString, zod.ZodLiteral<"">]>;
                        NumberOfWins: zod.ZodNumber;
                        WinsByTier: zod.ZodNull;
                        Rank: zod.ZodNumber;
                        LeaderboardRank: zod.ZodNumber;
                    }, "strip", zod.ZodTypeAny, {
                        SeasonID: string;
                        NumberOfWins: number;
                        WinsByTier: null;
                        Rank: number;
                        LeaderboardRank: number;
                    }, {
                        SeasonID: string;
                        NumberOfWins: number;
                        WinsByTier: null;
                        Rank: number;
                        LeaderboardRank: number;
                    }>;
                    IsCaptain: zod.ZodBoolean;
                }, "strip", zod.ZodTypeAny, {
                    CharacterID: string;
                    Subject: string;
                    PlayerIdentity: {
                        Subject: string;
                        PlayerCardID: string;
                        PlayerTitleID: string;
                        AccountLevel: number;
                        PreferredLevelBorderID: string;
                        Incognito: boolean;
                        HideAccountLevel: boolean;
                    };
                    SeasonalBadgeInfo: {
                        SeasonID: string;
                        NumberOfWins: number;
                        WinsByTier: null;
                        Rank: number;
                        LeaderboardRank: number;
                    };
                    CompetitiveTier: number;
                    CharacterSelectionState: "" | "selected" | "locked";
                    PregamePlayerState: "joined";
                    IsCaptain: boolean;
                }, {
                    CharacterID: string;
                    Subject: string;
                    PlayerIdentity: {
                        Subject: string;
                        PlayerCardID: string;
                        PlayerTitleID: string;
                        AccountLevel: number;
                        PreferredLevelBorderID: string;
                        Incognito: boolean;
                        HideAccountLevel: boolean;
                    };
                    SeasonalBadgeInfo: {
                        SeasonID: string;
                        NumberOfWins: number;
                        WinsByTier: null;
                        Rank: number;
                        LeaderboardRank: number;
                    };
                    CompetitiveTier: number;
                    CharacterSelectionState: "" | "selected" | "locked";
                    PregamePlayerState: "joined";
                    IsCaptain: boolean;
                }>, "many">;
            }, "strip", zod.ZodTypeAny, {
                Players: {
                    CharacterID: string;
                    Subject: string;
                    PlayerIdentity: {
                        Subject: string;
                        PlayerCardID: string;
                        PlayerTitleID: string;
                        AccountLevel: number;
                        PreferredLevelBorderID: string;
                        Incognito: boolean;
                        HideAccountLevel: boolean;
                    };
                    SeasonalBadgeInfo: {
                        SeasonID: string;
                        NumberOfWins: number;
                        WinsByTier: null;
                        Rank: number;
                        LeaderboardRank: number;
                    };
                    CompetitiveTier: number;
                    CharacterSelectionState: "" | "selected" | "locked";
                    PregamePlayerState: "joined";
                    IsCaptain: boolean;
                }[];
                TeamID: string;
            }, {
                Players: {
                    CharacterID: string;
                    Subject: string;
                    PlayerIdentity: {
                        Subject: string;
                        PlayerCardID: string;
                        PlayerTitleID: string;
                        AccountLevel: number;
                        PreferredLevelBorderID: string;
                        Incognito: boolean;
                        HideAccountLevel: boolean;
                    };
                    SeasonalBadgeInfo: {
                        SeasonID: string;
                        NumberOfWins: number;
                        WinsByTier: null;
                        Rank: number;
                        LeaderboardRank: number;
                    };
                    CompetitiveTier: number;
                    CharacterSelectionState: "" | "selected" | "locked";
                    PregamePlayerState: "joined";
                    IsCaptain: boolean;
                }[];
                TeamID: string;
            }>>;
            EnemyTeam: zod.ZodNullable<zod.ZodObject<{
                TeamID: zod.ZodUnion<[zod.ZodEnum<["Blue", "Red"]>, zod.ZodString]>;
                Players: zod.ZodArray<zod.ZodObject<{
                    Subject: zod.ZodString;
                    CharacterID: zod.ZodString;
                    CharacterSelectionState: zod.ZodEnum<["", "selected", "locked"]>;
                    PregamePlayerState: zod.ZodEnum<["joined"]>;
                    CompetitiveTier: zod.ZodNumber;
                    PlayerIdentity: zod.ZodObject<{
                        Subject: zod.ZodString;
                        PlayerCardID: zod.ZodString;
                        PlayerTitleID: zod.ZodString;
                        AccountLevel: zod.ZodNumber;
                        PreferredLevelBorderID: zod.ZodUnion<[zod.ZodString, zod.ZodLiteral<"">]>;
                        Incognito: zod.ZodBoolean;
                        HideAccountLevel: zod.ZodBoolean;
                    }, "strip", zod.ZodTypeAny, {
                        Subject: string;
                        PlayerCardID: string;
                        PlayerTitleID: string;
                        AccountLevel: number;
                        PreferredLevelBorderID: string;
                        Incognito: boolean;
                        HideAccountLevel: boolean;
                    }, {
                        Subject: string;
                        PlayerCardID: string;
                        PlayerTitleID: string;
                        AccountLevel: number;
                        PreferredLevelBorderID: string;
                        Incognito: boolean;
                        HideAccountLevel: boolean;
                    }>;
                    SeasonalBadgeInfo: zod.ZodObject<{
                        SeasonID: zod.ZodUnion<[zod.ZodString, zod.ZodLiteral<"">]>;
                        NumberOfWins: zod.ZodNumber;
                        WinsByTier: zod.ZodNull;
                        Rank: zod.ZodNumber;
                        LeaderboardRank: zod.ZodNumber;
                    }, "strip", zod.ZodTypeAny, {
                        SeasonID: string;
                        NumberOfWins: number;
                        WinsByTier: null;
                        Rank: number;
                        LeaderboardRank: number;
                    }, {
                        SeasonID: string;
                        NumberOfWins: number;
                        WinsByTier: null;
                        Rank: number;
                        LeaderboardRank: number;
                    }>;
                    IsCaptain: zod.ZodBoolean;
                }, "strip", zod.ZodTypeAny, {
                    CharacterID: string;
                    Subject: string;
                    PlayerIdentity: {
                        Subject: string;
                        PlayerCardID: string;
                        PlayerTitleID: string;
                        AccountLevel: number;
                        PreferredLevelBorderID: string;
                        Incognito: boolean;
                        HideAccountLevel: boolean;
                    };
                    SeasonalBadgeInfo: {
                        SeasonID: string;
                        NumberOfWins: number;
                        WinsByTier: null;
                        Rank: number;
                        LeaderboardRank: number;
                    };
                    CompetitiveTier: number;
                    CharacterSelectionState: "" | "selected" | "locked";
                    PregamePlayerState: "joined";
                    IsCaptain: boolean;
                }, {
                    CharacterID: string;
                    Subject: string;
                    PlayerIdentity: {
                        Subject: string;
                        PlayerCardID: string;
                        PlayerTitleID: string;
                        AccountLevel: number;
                        PreferredLevelBorderID: string;
                        Incognito: boolean;
                        HideAccountLevel: boolean;
                    };
                    SeasonalBadgeInfo: {
                        SeasonID: string;
                        NumberOfWins: number;
                        WinsByTier: null;
                        Rank: number;
                        LeaderboardRank: number;
                    };
                    CompetitiveTier: number;
                    CharacterSelectionState: "" | "selected" | "locked";
                    PregamePlayerState: "joined";
                    IsCaptain: boolean;
                }>, "many">;
            }, "strip", zod.ZodTypeAny, {
                Players: {
                    CharacterID: string;
                    Subject: string;
                    PlayerIdentity: {
                        Subject: string;
                        PlayerCardID: string;
                        PlayerTitleID: string;
                        AccountLevel: number;
                        PreferredLevelBorderID: string;
                        Incognito: boolean;
                        HideAccountLevel: boolean;
                    };
                    SeasonalBadgeInfo: {
                        SeasonID: string;
                        NumberOfWins: number;
                        WinsByTier: null;
                        Rank: number;
                        LeaderboardRank: number;
                    };
                    CompetitiveTier: number;
                    CharacterSelectionState: "" | "selected" | "locked";
                    PregamePlayerState: "joined";
                    IsCaptain: boolean;
                }[];
                TeamID: string;
            }, {
                Players: {
                    CharacterID: string;
                    Subject: string;
                    PlayerIdentity: {
                        Subject: string;
                        PlayerCardID: string;
                        PlayerTitleID: string;
                        AccountLevel: number;
                        PreferredLevelBorderID: string;
                        Incognito: boolean;
                        HideAccountLevel: boolean;
                    };
                    SeasonalBadgeInfo: {
                        SeasonID: string;
                        NumberOfWins: number;
                        WinsByTier: null;
                        Rank: number;
                        LeaderboardRank: number;
                    };
                    CompetitiveTier: number;
                    CharacterSelectionState: "" | "selected" | "locked";
                    PregamePlayerState: "joined";
                    IsCaptain: boolean;
                }[];
                TeamID: string;
            }>>;
            ObserverSubjects: zod.ZodArray<zod.ZodUnknown, "many">;
            MatchCoaches: zod.ZodArray<zod.ZodUnknown, "many">;
            EnemyTeamSize: zod.ZodNumber;
            EnemyTeamLockCount: zod.ZodNumber;
            PregameState: zod.ZodEnum<["character_select_active", "provisioned"]>;
            LastUpdated: zod.ZodEffects<zod.ZodString, Date, string>;
            MapID: zod.ZodString;
            MapSelectPool: zod.ZodArray<zod.ZodUnknown, "many">;
            BannedMapIDs: zod.ZodArray<zod.ZodUnknown, "many">;
            CastedVotes: zod.ZodUnknown;
            MapSelectSteps: zod.ZodArray<zod.ZodUnknown, "many">;
            MapSelectStep: zod.ZodNumber;
            Team1: zod.ZodUnion<[zod.ZodEnum<["Blue", "Red"]>, zod.ZodString]>;
            GamePodID: zod.ZodString;
            Mode: zod.ZodString;
            VoiceSessionID: zod.ZodString;
            MUCName: zod.ZodString;
            TeamMatchToken: zod.ZodString;
            QueueID: zod.ZodUnion<[zod.ZodString, zod.ZodLiteral<"">]>;
            ProvisioningFlowID: zod.ZodEnum<["Matchmaking", "CustomGame"]>;
            IsRanked: zod.ZodBoolean;
            PhaseTimeRemainingNS: zod.ZodNumber;
            StepTimeRemainingNS: zod.ZodNumber;
            altModesFlagADA: zod.ZodBoolean;
            TournamentMetadata: zod.ZodNull;
            RosterMetadata: zod.ZodNull;
        }, "strip", zod.ZodTypeAny, {
            ID: string;
            Version: number;
            QueueID: string;
            Mode: string;
            IsRanked: boolean;
            MapID: string;
            GamePodID: string;
            TeamMatchToken: string;
            MUCName: string;
            Teams: {
                Players: {
                    CharacterID: string;
                    Subject: string;
                    PlayerIdentity: {
                        Subject: string;
                        PlayerCardID: string;
                        PlayerTitleID: string;
                        AccountLevel: number;
                        PreferredLevelBorderID: string;
                        Incognito: boolean;
                        HideAccountLevel: boolean;
                    };
                    SeasonalBadgeInfo: {
                        SeasonID: string;
                        NumberOfWins: number;
                        WinsByTier: null;
                        Rank: number;
                        LeaderboardRank: number;
                    };
                    CompetitiveTier: number;
                    CharacterSelectionState: "" | "selected" | "locked";
                    PregamePlayerState: "joined";
                    IsCaptain: boolean;
                }[];
                TeamID: string;
            }[];
            AllyTeam: {
                Players: {
                    CharacterID: string;
                    Subject: string;
                    PlayerIdentity: {
                        Subject: string;
                        PlayerCardID: string;
                        PlayerTitleID: string;
                        AccountLevel: number;
                        PreferredLevelBorderID: string;
                        Incognito: boolean;
                        HideAccountLevel: boolean;
                    };
                    SeasonalBadgeInfo: {
                        SeasonID: string;
                        NumberOfWins: number;
                        WinsByTier: null;
                        Rank: number;
                        LeaderboardRank: number;
                    };
                    CompetitiveTier: number;
                    CharacterSelectionState: "" | "selected" | "locked";
                    PregamePlayerState: "joined";
                    IsCaptain: boolean;
                }[];
                TeamID: string;
            } | null;
            EnemyTeam: {
                Players: {
                    CharacterID: string;
                    Subject: string;
                    PlayerIdentity: {
                        Subject: string;
                        PlayerCardID: string;
                        PlayerTitleID: string;
                        AccountLevel: number;
                        PreferredLevelBorderID: string;
                        Incognito: boolean;
                        HideAccountLevel: boolean;
                    };
                    SeasonalBadgeInfo: {
                        SeasonID: string;
                        NumberOfWins: number;
                        WinsByTier: null;
                        Rank: number;
                        LeaderboardRank: number;
                    };
                    CompetitiveTier: number;
                    CharacterSelectionState: "" | "selected" | "locked";
                    PregamePlayerState: "joined";
                    IsCaptain: boolean;
                }[];
                TeamID: string;
            } | null;
            ObserverSubjects: unknown[];
            MatchCoaches: unknown[];
            EnemyTeamSize: number;
            EnemyTeamLockCount: number;
            PregameState: "character_select_active" | "provisioned";
            LastUpdated: Date;
            MapSelectPool: unknown[];
            BannedMapIDs: unknown[];
            MapSelectSteps: unknown[];
            MapSelectStep: number;
            Team1: string;
            VoiceSessionID: string;
            ProvisioningFlowID: "Matchmaking" | "CustomGame";
            PhaseTimeRemainingNS: number;
            StepTimeRemainingNS: number;
            altModesFlagADA: boolean;
            TournamentMetadata: null;
            RosterMetadata: null;
            CastedVotes?: unknown;
        }, {
            ID: string;
            Version: number;
            QueueID: string;
            Mode: string;
            IsRanked: boolean;
            MapID: string;
            GamePodID: string;
            TeamMatchToken: string;
            MUCName: string;
            Teams: {
                Players: {
                    CharacterID: string;
                    Subject: string;
                    PlayerIdentity: {
                        Subject: string;
                        PlayerCardID: string;
                        PlayerTitleID: string;
                        AccountLevel: number;
                        PreferredLevelBorderID: string;
                        Incognito: boolean;
                        HideAccountLevel: boolean;
                    };
                    SeasonalBadgeInfo: {
                        SeasonID: string;
                        NumberOfWins: number;
                        WinsByTier: null;
                        Rank: number;
                        LeaderboardRank: number;
                    };
                    CompetitiveTier: number;
                    CharacterSelectionState: "" | "selected" | "locked";
                    PregamePlayerState: "joined";
                    IsCaptain: boolean;
                }[];
                TeamID: string;
            }[];
            AllyTeam: {
                Players: {
                    CharacterID: string;
                    Subject: string;
                    PlayerIdentity: {
                        Subject: string;
                        PlayerCardID: string;
                        PlayerTitleID: string;
                        AccountLevel: number;
                        PreferredLevelBorderID: string;
                        Incognito: boolean;
                        HideAccountLevel: boolean;
                    };
                    SeasonalBadgeInfo: {
                        SeasonID: string;
                        NumberOfWins: number;
                        WinsByTier: null;
                        Rank: number;
                        LeaderboardRank: number;
                    };
                    CompetitiveTier: number;
                    CharacterSelectionState: "" | "selected" | "locked";
                    PregamePlayerState: "joined";
                    IsCaptain: boolean;
                }[];
                TeamID: string;
            } | null;
            EnemyTeam: {
                Players: {
                    CharacterID: string;
                    Subject: string;
                    PlayerIdentity: {
                        Subject: string;
                        PlayerCardID: string;
                        PlayerTitleID: string;
                        AccountLevel: number;
                        PreferredLevelBorderID: string;
                        Incognito: boolean;
                        HideAccountLevel: boolean;
                    };
                    SeasonalBadgeInfo: {
                        SeasonID: string;
                        NumberOfWins: number;
                        WinsByTier: null;
                        Rank: number;
                        LeaderboardRank: number;
                    };
                    CompetitiveTier: number;
                    CharacterSelectionState: "" | "selected" | "locked";
                    PregamePlayerState: "joined";
                    IsCaptain: boolean;
                }[];
                TeamID: string;
            } | null;
            ObserverSubjects: unknown[];
            MatchCoaches: unknown[];
            EnemyTeamSize: number;
            EnemyTeamLockCount: number;
            PregameState: "character_select_active" | "provisioned";
            LastUpdated: string;
            MapSelectPool: unknown[];
            BannedMapIDs: unknown[];
            MapSelectSteps: unknown[];
            MapSelectStep: number;
            Team1: string;
            VoiceSessionID: string;
            ProvisioningFlowID: "Matchmaking" | "CustomGame";
            PhaseTimeRemainingNS: number;
            StepTimeRemainingNS: number;
            altModesFlagADA: boolean;
            TournamentMetadata: null;
            RosterMetadata: null;
            CastedVotes?: unknown;
        }>;
    };
}, "type" | "name" | "url"> & {
    "~type": {
        readonly name: "Lock Character";
        readonly description: string;
        readonly type: "glz";
        readonly method: "POST";
        readonly url: "pregame/v1/matches/:pregameMatchId/lock/:agentId";
        readonly responses: {
            readonly "200": zod.ZodObject<{
                ID: zod.ZodString;
                Version: zod.ZodNumber;
                Teams: zod.ZodArray<zod.ZodObject<{
                    TeamID: zod.ZodUnion<[zod.ZodEnum<["Blue", "Red"]>, zod.ZodString]>;
                    Players: zod.ZodArray<zod.ZodObject<{
                        Subject: zod.ZodString;
                        CharacterID: zod.ZodString;
                        CharacterSelectionState: zod.ZodEnum<["", "selected", "locked"]>;
                        PregamePlayerState: zod.ZodEnum<["joined"]>;
                        CompetitiveTier: zod.ZodNumber;
                        PlayerIdentity: zod.ZodObject<{
                            Subject: zod.ZodString;
                            PlayerCardID: zod.ZodString;
                            PlayerTitleID: zod.ZodString;
                            AccountLevel: zod.ZodNumber;
                            PreferredLevelBorderID: zod.ZodUnion<[zod.ZodString, zod.ZodLiteral<"">]>;
                            Incognito: zod.ZodBoolean;
                            HideAccountLevel: zod.ZodBoolean;
                        }, "strip", zod.ZodTypeAny, {
                            Subject: string;
                            PlayerCardID: string;
                            PlayerTitleID: string;
                            AccountLevel: number;
                            PreferredLevelBorderID: string;
                            Incognito: boolean;
                            HideAccountLevel: boolean;
                        }, {
                            Subject: string;
                            PlayerCardID: string;
                            PlayerTitleID: string;
                            AccountLevel: number;
                            PreferredLevelBorderID: string;
                            Incognito: boolean;
                            HideAccountLevel: boolean;
                        }>;
                        SeasonalBadgeInfo: zod.ZodObject<{
                            SeasonID: zod.ZodUnion<[zod.ZodString, zod.ZodLiteral<"">]>;
                            NumberOfWins: zod.ZodNumber;
                            WinsByTier: zod.ZodNull;
                            Rank: zod.ZodNumber;
                            LeaderboardRank: zod.ZodNumber;
                        }, "strip", zod.ZodTypeAny, {
                            SeasonID: string;
                            NumberOfWins: number;
                            WinsByTier: null;
                            Rank: number;
                            LeaderboardRank: number;
                        }, {
                            SeasonID: string;
                            NumberOfWins: number;
                            WinsByTier: null;
                            Rank: number;
                            LeaderboardRank: number;
                        }>;
                        IsCaptain: zod.ZodBoolean;
                    }, "strip", zod.ZodTypeAny, {
                        CharacterID: string;
                        Subject: string;
                        PlayerIdentity: {
                            Subject: string;
                            PlayerCardID: string;
                            PlayerTitleID: string;
                            AccountLevel: number;
                            PreferredLevelBorderID: string;
                            Incognito: boolean;
                            HideAccountLevel: boolean;
                        };
                        SeasonalBadgeInfo: {
                            SeasonID: string;
                            NumberOfWins: number;
                            WinsByTier: null;
                            Rank: number;
                            LeaderboardRank: number;
                        };
                        CompetitiveTier: number;
                        CharacterSelectionState: "" | "selected" | "locked";
                        PregamePlayerState: "joined";
                        IsCaptain: boolean;
                    }, {
                        CharacterID: string;
                        Subject: string;
                        PlayerIdentity: {
                            Subject: string;
                            PlayerCardID: string;
                            PlayerTitleID: string;
                            AccountLevel: number;
                            PreferredLevelBorderID: string;
                            Incognito: boolean;
                            HideAccountLevel: boolean;
                        };
                        SeasonalBadgeInfo: {
                            SeasonID: string;
                            NumberOfWins: number;
                            WinsByTier: null;
                            Rank: number;
                            LeaderboardRank: number;
                        };
                        CompetitiveTier: number;
                        CharacterSelectionState: "" | "selected" | "locked";
                        PregamePlayerState: "joined";
                        IsCaptain: boolean;
                    }>, "many">;
                }, "strip", zod.ZodTypeAny, {
                    Players: {
                        CharacterID: string;
                        Subject: string;
                        PlayerIdentity: {
                            Subject: string;
                            PlayerCardID: string;
                            PlayerTitleID: string;
                            AccountLevel: number;
                            PreferredLevelBorderID: string;
                            Incognito: boolean;
                            HideAccountLevel: boolean;
                        };
                        SeasonalBadgeInfo: {
                            SeasonID: string;
                            NumberOfWins: number;
                            WinsByTier: null;
                            Rank: number;
                            LeaderboardRank: number;
                        };
                        CompetitiveTier: number;
                        CharacterSelectionState: "" | "selected" | "locked";
                        PregamePlayerState: "joined";
                        IsCaptain: boolean;
                    }[];
                    TeamID: string;
                }, {
                    Players: {
                        CharacterID: string;
                        Subject: string;
                        PlayerIdentity: {
                            Subject: string;
                            PlayerCardID: string;
                            PlayerTitleID: string;
                            AccountLevel: number;
                            PreferredLevelBorderID: string;
                            Incognito: boolean;
                            HideAccountLevel: boolean;
                        };
                        SeasonalBadgeInfo: {
                            SeasonID: string;
                            NumberOfWins: number;
                            WinsByTier: null;
                            Rank: number;
                            LeaderboardRank: number;
                        };
                        CompetitiveTier: number;
                        CharacterSelectionState: "" | "selected" | "locked";
                        PregamePlayerState: "joined";
                        IsCaptain: boolean;
                    }[];
                    TeamID: string;
                }>, "many">;
                AllyTeam: zod.ZodNullable<zod.ZodObject<{
                    TeamID: zod.ZodUnion<[zod.ZodEnum<["Blue", "Red"]>, zod.ZodString]>;
                    Players: zod.ZodArray<zod.ZodObject<{
                        Subject: zod.ZodString;
                        CharacterID: zod.ZodString;
                        CharacterSelectionState: zod.ZodEnum<["", "selected", "locked"]>;
                        PregamePlayerState: zod.ZodEnum<["joined"]>;
                        CompetitiveTier: zod.ZodNumber;
                        PlayerIdentity: zod.ZodObject<{
                            Subject: zod.ZodString;
                            PlayerCardID: zod.ZodString;
                            PlayerTitleID: zod.ZodString;
                            AccountLevel: zod.ZodNumber;
                            PreferredLevelBorderID: zod.ZodUnion<[zod.ZodString, zod.ZodLiteral<"">]>;
                            Incognito: zod.ZodBoolean;
                            HideAccountLevel: zod.ZodBoolean;
                        }, "strip", zod.ZodTypeAny, {
                            Subject: string;
                            PlayerCardID: string;
                            PlayerTitleID: string;
                            AccountLevel: number;
                            PreferredLevelBorderID: string;
                            Incognito: boolean;
                            HideAccountLevel: boolean;
                        }, {
                            Subject: string;
                            PlayerCardID: string;
                            PlayerTitleID: string;
                            AccountLevel: number;
                            PreferredLevelBorderID: string;
                            Incognito: boolean;
                            HideAccountLevel: boolean;
                        }>;
                        SeasonalBadgeInfo: zod.ZodObject<{
                            SeasonID: zod.ZodUnion<[zod.ZodString, zod.ZodLiteral<"">]>;
                            NumberOfWins: zod.ZodNumber;
                            WinsByTier: zod.ZodNull;
                            Rank: zod.ZodNumber;
                            LeaderboardRank: zod.ZodNumber;
                        }, "strip", zod.ZodTypeAny, {
                            SeasonID: string;
                            NumberOfWins: number;
                            WinsByTier: null;
                            Rank: number;
                            LeaderboardRank: number;
                        }, {
                            SeasonID: string;
                            NumberOfWins: number;
                            WinsByTier: null;
                            Rank: number;
                            LeaderboardRank: number;
                        }>;
                        IsCaptain: zod.ZodBoolean;
                    }, "strip", zod.ZodTypeAny, {
                        CharacterID: string;
                        Subject: string;
                        PlayerIdentity: {
                            Subject: string;
                            PlayerCardID: string;
                            PlayerTitleID: string;
                            AccountLevel: number;
                            PreferredLevelBorderID: string;
                            Incognito: boolean;
                            HideAccountLevel: boolean;
                        };
                        SeasonalBadgeInfo: {
                            SeasonID: string;
                            NumberOfWins: number;
                            WinsByTier: null;
                            Rank: number;
                            LeaderboardRank: number;
                        };
                        CompetitiveTier: number;
                        CharacterSelectionState: "" | "selected" | "locked";
                        PregamePlayerState: "joined";
                        IsCaptain: boolean;
                    }, {
                        CharacterID: string;
                        Subject: string;
                        PlayerIdentity: {
                            Subject: string;
                            PlayerCardID: string;
                            PlayerTitleID: string;
                            AccountLevel: number;
                            PreferredLevelBorderID: string;
                            Incognito: boolean;
                            HideAccountLevel: boolean;
                        };
                        SeasonalBadgeInfo: {
                            SeasonID: string;
                            NumberOfWins: number;
                            WinsByTier: null;
                            Rank: number;
                            LeaderboardRank: number;
                        };
                        CompetitiveTier: number;
                        CharacterSelectionState: "" | "selected" | "locked";
                        PregamePlayerState: "joined";
                        IsCaptain: boolean;
                    }>, "many">;
                }, "strip", zod.ZodTypeAny, {
                    Players: {
                        CharacterID: string;
                        Subject: string;
                        PlayerIdentity: {
                            Subject: string;
                            PlayerCardID: string;
                            PlayerTitleID: string;
                            AccountLevel: number;
                            PreferredLevelBorderID: string;
                            Incognito: boolean;
                            HideAccountLevel: boolean;
                        };
                        SeasonalBadgeInfo: {
                            SeasonID: string;
                            NumberOfWins: number;
                            WinsByTier: null;
                            Rank: number;
                            LeaderboardRank: number;
                        };
                        CompetitiveTier: number;
                        CharacterSelectionState: "" | "selected" | "locked";
                        PregamePlayerState: "joined";
                        IsCaptain: boolean;
                    }[];
                    TeamID: string;
                }, {
                    Players: {
                        CharacterID: string;
                        Subject: string;
                        PlayerIdentity: {
                            Subject: string;
                            PlayerCardID: string;
                            PlayerTitleID: string;
                            AccountLevel: number;
                            PreferredLevelBorderID: string;
                            Incognito: boolean;
                            HideAccountLevel: boolean;
                        };
                        SeasonalBadgeInfo: {
                            SeasonID: string;
                            NumberOfWins: number;
                            WinsByTier: null;
                            Rank: number;
                            LeaderboardRank: number;
                        };
                        CompetitiveTier: number;
                        CharacterSelectionState: "" | "selected" | "locked";
                        PregamePlayerState: "joined";
                        IsCaptain: boolean;
                    }[];
                    TeamID: string;
                }>>;
                EnemyTeam: zod.ZodNullable<zod.ZodObject<{
                    TeamID: zod.ZodUnion<[zod.ZodEnum<["Blue", "Red"]>, zod.ZodString]>;
                    Players: zod.ZodArray<zod.ZodObject<{
                        Subject: zod.ZodString;
                        CharacterID: zod.ZodString;
                        CharacterSelectionState: zod.ZodEnum<["", "selected", "locked"]>;
                        PregamePlayerState: zod.ZodEnum<["joined"]>;
                        CompetitiveTier: zod.ZodNumber;
                        PlayerIdentity: zod.ZodObject<{
                            Subject: zod.ZodString;
                            PlayerCardID: zod.ZodString;
                            PlayerTitleID: zod.ZodString;
                            AccountLevel: zod.ZodNumber;
                            PreferredLevelBorderID: zod.ZodUnion<[zod.ZodString, zod.ZodLiteral<"">]>;
                            Incognito: zod.ZodBoolean;
                            HideAccountLevel: zod.ZodBoolean;
                        }, "strip", zod.ZodTypeAny, {
                            Subject: string;
                            PlayerCardID: string;
                            PlayerTitleID: string;
                            AccountLevel: number;
                            PreferredLevelBorderID: string;
                            Incognito: boolean;
                            HideAccountLevel: boolean;
                        }, {
                            Subject: string;
                            PlayerCardID: string;
                            PlayerTitleID: string;
                            AccountLevel: number;
                            PreferredLevelBorderID: string;
                            Incognito: boolean;
                            HideAccountLevel: boolean;
                        }>;
                        SeasonalBadgeInfo: zod.ZodObject<{
                            SeasonID: zod.ZodUnion<[zod.ZodString, zod.ZodLiteral<"">]>;
                            NumberOfWins: zod.ZodNumber;
                            WinsByTier: zod.ZodNull;
                            Rank: zod.ZodNumber;
                            LeaderboardRank: zod.ZodNumber;
                        }, "strip", zod.ZodTypeAny, {
                            SeasonID: string;
                            NumberOfWins: number;
                            WinsByTier: null;
                            Rank: number;
                            LeaderboardRank: number;
                        }, {
                            SeasonID: string;
                            NumberOfWins: number;
                            WinsByTier: null;
                            Rank: number;
                            LeaderboardRank: number;
                        }>;
                        IsCaptain: zod.ZodBoolean;
                    }, "strip", zod.ZodTypeAny, {
                        CharacterID: string;
                        Subject: string;
                        PlayerIdentity: {
                            Subject: string;
                            PlayerCardID: string;
                            PlayerTitleID: string;
                            AccountLevel: number;
                            PreferredLevelBorderID: string;
                            Incognito: boolean;
                            HideAccountLevel: boolean;
                        };
                        SeasonalBadgeInfo: {
                            SeasonID: string;
                            NumberOfWins: number;
                            WinsByTier: null;
                            Rank: number;
                            LeaderboardRank: number;
                        };
                        CompetitiveTier: number;
                        CharacterSelectionState: "" | "selected" | "locked";
                        PregamePlayerState: "joined";
                        IsCaptain: boolean;
                    }, {
                        CharacterID: string;
                        Subject: string;
                        PlayerIdentity: {
                            Subject: string;
                            PlayerCardID: string;
                            PlayerTitleID: string;
                            AccountLevel: number;
                            PreferredLevelBorderID: string;
                            Incognito: boolean;
                            HideAccountLevel: boolean;
                        };
                        SeasonalBadgeInfo: {
                            SeasonID: string;
                            NumberOfWins: number;
                            WinsByTier: null;
                            Rank: number;
                            LeaderboardRank: number;
                        };
                        CompetitiveTier: number;
                        CharacterSelectionState: "" | "selected" | "locked";
                        PregamePlayerState: "joined";
                        IsCaptain: boolean;
                    }>, "many">;
                }, "strip", zod.ZodTypeAny, {
                    Players: {
                        CharacterID: string;
                        Subject: string;
                        PlayerIdentity: {
                            Subject: string;
                            PlayerCardID: string;
                            PlayerTitleID: string;
                            AccountLevel: number;
                            PreferredLevelBorderID: string;
                            Incognito: boolean;
                            HideAccountLevel: boolean;
                        };
                        SeasonalBadgeInfo: {
                            SeasonID: string;
                            NumberOfWins: number;
                            WinsByTier: null;
                            Rank: number;
                            LeaderboardRank: number;
                        };
                        CompetitiveTier: number;
                        CharacterSelectionState: "" | "selected" | "locked";
                        PregamePlayerState: "joined";
                        IsCaptain: boolean;
                    }[];
                    TeamID: string;
                }, {
                    Players: {
                        CharacterID: string;
                        Subject: string;
                        PlayerIdentity: {
                            Subject: string;
                            PlayerCardID: string;
                            PlayerTitleID: string;
                            AccountLevel: number;
                            PreferredLevelBorderID: string;
                            Incognito: boolean;
                            HideAccountLevel: boolean;
                        };
                        SeasonalBadgeInfo: {
                            SeasonID: string;
                            NumberOfWins: number;
                            WinsByTier: null;
                            Rank: number;
                            LeaderboardRank: number;
                        };
                        CompetitiveTier: number;
                        CharacterSelectionState: "" | "selected" | "locked";
                        PregamePlayerState: "joined";
                        IsCaptain: boolean;
                    }[];
                    TeamID: string;
                }>>;
                ObserverSubjects: zod.ZodArray<zod.ZodUnknown, "many">;
                MatchCoaches: zod.ZodArray<zod.ZodUnknown, "many">;
                EnemyTeamSize: zod.ZodNumber;
                EnemyTeamLockCount: zod.ZodNumber;
                PregameState: zod.ZodEnum<["character_select_active", "provisioned"]>;
                LastUpdated: zod.ZodEffects<zod.ZodString, Date, string>;
                MapID: zod.ZodString;
                MapSelectPool: zod.ZodArray<zod.ZodUnknown, "many">;
                BannedMapIDs: zod.ZodArray<zod.ZodUnknown, "many">;
                CastedVotes: zod.ZodUnknown;
                MapSelectSteps: zod.ZodArray<zod.ZodUnknown, "many">;
                MapSelectStep: zod.ZodNumber;
                Team1: zod.ZodUnion<[zod.ZodEnum<["Blue", "Red"]>, zod.ZodString]>;
                GamePodID: zod.ZodString;
                Mode: zod.ZodString;
                VoiceSessionID: zod.ZodString;
                MUCName: zod.ZodString;
                TeamMatchToken: zod.ZodString;
                QueueID: zod.ZodUnion<[zod.ZodString, zod.ZodLiteral<"">]>;
                ProvisioningFlowID: zod.ZodEnum<["Matchmaking", "CustomGame"]>;
                IsRanked: zod.ZodBoolean;
                PhaseTimeRemainingNS: zod.ZodNumber;
                StepTimeRemainingNS: zod.ZodNumber;
                altModesFlagADA: zod.ZodBoolean;
                TournamentMetadata: zod.ZodNull;
                RosterMetadata: zod.ZodNull;
            }, "strip", zod.ZodTypeAny, {
                ID: string;
                Version: number;
                QueueID: string;
                Mode: string;
                IsRanked: boolean;
                MapID: string;
                GamePodID: string;
                TeamMatchToken: string;
                MUCName: string;
                Teams: {
                    Players: {
                        CharacterID: string;
                        Subject: string;
                        PlayerIdentity: {
                            Subject: string;
                            PlayerCardID: string;
                            PlayerTitleID: string;
                            AccountLevel: number;
                            PreferredLevelBorderID: string;
                            Incognito: boolean;
                            HideAccountLevel: boolean;
                        };
                        SeasonalBadgeInfo: {
                            SeasonID: string;
                            NumberOfWins: number;
                            WinsByTier: null;
                            Rank: number;
                            LeaderboardRank: number;
                        };
                        CompetitiveTier: number;
                        CharacterSelectionState: "" | "selected" | "locked";
                        PregamePlayerState: "joined";
                        IsCaptain: boolean;
                    }[];
                    TeamID: string;
                }[];
                AllyTeam: {
                    Players: {
                        CharacterID: string;
                        Subject: string;
                        PlayerIdentity: {
                            Subject: string;
                            PlayerCardID: string;
                            PlayerTitleID: string;
                            AccountLevel: number;
                            PreferredLevelBorderID: string;
                            Incognito: boolean;
                            HideAccountLevel: boolean;
                        };
                        SeasonalBadgeInfo: {
                            SeasonID: string;
                            NumberOfWins: number;
                            WinsByTier: null;
                            Rank: number;
                            LeaderboardRank: number;
                        };
                        CompetitiveTier: number;
                        CharacterSelectionState: "" | "selected" | "locked";
                        PregamePlayerState: "joined";
                        IsCaptain: boolean;
                    }[];
                    TeamID: string;
                } | null;
                EnemyTeam: {
                    Players: {
                        CharacterID: string;
                        Subject: string;
                        PlayerIdentity: {
                            Subject: string;
                            PlayerCardID: string;
                            PlayerTitleID: string;
                            AccountLevel: number;
                            PreferredLevelBorderID: string;
                            Incognito: boolean;
                            HideAccountLevel: boolean;
                        };
                        SeasonalBadgeInfo: {
                            SeasonID: string;
                            NumberOfWins: number;
                            WinsByTier: null;
                            Rank: number;
                            LeaderboardRank: number;
                        };
                        CompetitiveTier: number;
                        CharacterSelectionState: "" | "selected" | "locked";
                        PregamePlayerState: "joined";
                        IsCaptain: boolean;
                    }[];
                    TeamID: string;
                } | null;
                ObserverSubjects: unknown[];
                MatchCoaches: unknown[];
                EnemyTeamSize: number;
                EnemyTeamLockCount: number;
                PregameState: "character_select_active" | "provisioned";
                LastUpdated: Date;
                MapSelectPool: unknown[];
                BannedMapIDs: unknown[];
                MapSelectSteps: unknown[];
                MapSelectStep: number;
                Team1: string;
                VoiceSessionID: string;
                ProvisioningFlowID: "Matchmaking" | "CustomGame";
                PhaseTimeRemainingNS: number;
                StepTimeRemainingNS: number;
                altModesFlagADA: boolean;
                TournamentMetadata: null;
                RosterMetadata: null;
                CastedVotes?: unknown;
            }, {
                ID: string;
                Version: number;
                QueueID: string;
                Mode: string;
                IsRanked: boolean;
                MapID: string;
                GamePodID: string;
                TeamMatchToken: string;
                MUCName: string;
                Teams: {
                    Players: {
                        CharacterID: string;
                        Subject: string;
                        PlayerIdentity: {
                            Subject: string;
                            PlayerCardID: string;
                            PlayerTitleID: string;
                            AccountLevel: number;
                            PreferredLevelBorderID: string;
                            Incognito: boolean;
                            HideAccountLevel: boolean;
                        };
                        SeasonalBadgeInfo: {
                            SeasonID: string;
                            NumberOfWins: number;
                            WinsByTier: null;
                            Rank: number;
                            LeaderboardRank: number;
                        };
                        CompetitiveTier: number;
                        CharacterSelectionState: "" | "selected" | "locked";
                        PregamePlayerState: "joined";
                        IsCaptain: boolean;
                    }[];
                    TeamID: string;
                }[];
                AllyTeam: {
                    Players: {
                        CharacterID: string;
                        Subject: string;
                        PlayerIdentity: {
                            Subject: string;
                            PlayerCardID: string;
                            PlayerTitleID: string;
                            AccountLevel: number;
                            PreferredLevelBorderID: string;
                            Incognito: boolean;
                            HideAccountLevel: boolean;
                        };
                        SeasonalBadgeInfo: {
                            SeasonID: string;
                            NumberOfWins: number;
                            WinsByTier: null;
                            Rank: number;
                            LeaderboardRank: number;
                        };
                        CompetitiveTier: number;
                        CharacterSelectionState: "" | "selected" | "locked";
                        PregamePlayerState: "joined";
                        IsCaptain: boolean;
                    }[];
                    TeamID: string;
                } | null;
                EnemyTeam: {
                    Players: {
                        CharacterID: string;
                        Subject: string;
                        PlayerIdentity: {
                            Subject: string;
                            PlayerCardID: string;
                            PlayerTitleID: string;
                            AccountLevel: number;
                            PreferredLevelBorderID: string;
                            Incognito: boolean;
                            HideAccountLevel: boolean;
                        };
                        SeasonalBadgeInfo: {
                            SeasonID: string;
                            NumberOfWins: number;
                            WinsByTier: null;
                            Rank: number;
                            LeaderboardRank: number;
                        };
                        CompetitiveTier: number;
                        CharacterSelectionState: "" | "selected" | "locked";
                        PregamePlayerState: "joined";
                        IsCaptain: boolean;
                    }[];
                    TeamID: string;
                } | null;
                ObserverSubjects: unknown[];
                MatchCoaches: unknown[];
                EnemyTeamSize: number;
                EnemyTeamLockCount: number;
                PregameState: "character_select_active" | "provisioned";
                LastUpdated: string;
                MapSelectPool: unknown[];
                BannedMapIDs: unknown[];
                MapSelectSteps: unknown[];
                MapSelectStep: number;
                Team1: string;
                VoiceSessionID: string;
                ProvisioningFlowID: "Matchmaking" | "CustomGame";
                PhaseTimeRemainingNS: number;
                StepTimeRemainingNS: number;
                altModesFlagADA: boolean;
                TournamentMetadata: null;
                RosterMetadata: null;
                CastedVotes?: unknown;
            }>;
        };
    };
};

type Params$n = ResolveParams<(typeof _default$n)["~type"]["url"]>;
type Body$n = z.infer<ResolveValue<(typeof _default$n)["~type"], "body">>;
type Data$n = ResolveData<Params$n, Body$n>;
type Response$n = z.infer<ResolveValue<(typeof _default$n)["~type"], "responses">["200"]>;
interface LockCharacterRequestConfig extends ValorantAxiosRequestConfig<Data$n> {
}
declare class LockCharacterEndpoint {
    /**
     * Lock in an agent
     * DO NOT USE THIS FOR INSTALOCKING
     * Riot doesn't like this. You may get banned or get the API restricted for the rest of us
     *
     * @EndpointType glz
     */
    postLockCharacter<T = Response$n>(this: RemoteApiClient, config: LockCharacterRequestConfig): Promise<AxiosResponse<T>>;
}

declare const PartyChatTokenResponseSchema: z.ZodObject<{
    Token: z.ZodString;
    Room: z.ZodString;
}, "strip", z.ZodTypeAny, {
    Token: string;
    Room: string;
}, {
    Token: string;
    Room: string;
}>;
declare const _default$m: Omit<{
    requirements: string[];
    type: "auth" | "local" | "pd" | "glz" | "shared";
    name: string;
    method: "PUT" | "GET" | "DELETE" | "POST";
    url: string;
    description?: string | undefined;
    headers?: Record<string, string> | undefined;
    body?: z.ZodType<any, z.ZodTypeDef, any> | undefined;
    query?: z.ZodType<any, z.ZodTypeDef, any> | undefined;
    responses?: Record<string, z.ZodType<any, z.ZodTypeDef, any>> | undefined;
}, "type" | "name" | "url"> & Pick<{
    readonly name: "Party Chat Token";
    readonly description: "Get the party chat token";
    readonly type: "glz";
    readonly url: "parties/v1/parties/:partyId/muctoken";
    readonly responses: {
        readonly "200": z.ZodObject<{
            Token: z.ZodString;
            Room: z.ZodString;
        }, "strip", z.ZodTypeAny, {
            Token: string;
            Room: string;
        }, {
            Token: string;
            Room: string;
        }>;
    };
}, "type" | "name" | "url"> & {
    "~type": {
        readonly name: "Party Chat Token";
        readonly description: "Get the party chat token";
        readonly type: "glz";
        readonly url: "parties/v1/parties/:partyId/muctoken";
        readonly responses: {
            readonly "200": z.ZodObject<{
                Token: z.ZodString;
                Room: z.ZodString;
            }, "strip", z.ZodTypeAny, {
                Token: string;
                Room: string;
            }, {
                Token: string;
                Room: string;
            }>;
        };
    };
};

type Params$m = ResolveParams<(typeof _default$m)["~type"]["url"]>;
type Body$m = z.infer<ResolveValue<(typeof _default$m)["~type"], "body">>;
type Data$m = ResolveData<Params$m, Body$m>;
type Response$m = z.infer<ResolveValue<(typeof _default$m)["~type"], "responses">["200"]>;
interface PartyChatTokenRequestConfig extends ValorantAxiosRequestConfig<Data$m> {
}
declare class PartyChatTokenEndpoint {
    /**
     * Get the party chat token
     *
     * @EndpointType glz
     */
    getPartyChatToken<T = Response$m>(this: RemoteApiClient, config: PartyChatTokenRequestConfig): Promise<AxiosResponse<T>>;
}

declare const _default$l: Omit<{
    requirements: string[];
    type: "auth" | "local" | "pd" | "glz" | "shared";
    name: string;
    method: "PUT" | "GET" | "DELETE" | "POST";
    url: string;
    description?: string | undefined;
    headers?: Record<string, string> | undefined;
    body?: zod.ZodType<any, zod.ZodTypeDef, any> | undefined;
    query?: zod.ZodType<any, zod.ZodTypeDef, any> | undefined;
    responses?: Record<string, zod.ZodType<any, zod.ZodTypeDef, any>> | undefined;
}, "type" | "name" | "url"> & Pick<{
    readonly name: "Party Decline";
    readonly description: "Decline a party invite request";
    readonly type: "glz";
    readonly method: "POST";
    readonly url: "parties/v1/parties/:partyId/request/:requestId/decline";
    readonly responses: {
        readonly "200": zod.ZodObject<{
            ID: zod.ZodString;
            MUCName: zod.ZodString;
            VoiceRoomID: zod.ZodString;
            Version: zod.ZodNumber;
            ClientVersion: zod.ZodString;
            Members: zod.ZodArray<zod.ZodObject<{
                Subject: zod.ZodString;
                CompetitiveTier: zod.ZodNumber;
                PlayerIdentity: zod.ZodObject<{
                    Subject: zod.ZodString;
                    PlayerCardID: zod.ZodString;
                    PlayerTitleID: zod.ZodString;
                    AccountLevel: zod.ZodNumber;
                    PreferredLevelBorderID: zod.ZodUnion<[zod.ZodString, zod.ZodLiteral<"">]>;
                    Incognito: zod.ZodBoolean;
                    HideAccountLevel: zod.ZodBoolean;
                }, "strip", zod.ZodTypeAny, {
                    Subject: string;
                    PlayerCardID: string;
                    PlayerTitleID: string;
                    AccountLevel: number;
                    PreferredLevelBorderID: string;
                    Incognito: boolean;
                    HideAccountLevel: boolean;
                }, {
                    Subject: string;
                    PlayerCardID: string;
                    PlayerTitleID: string;
                    AccountLevel: number;
                    PreferredLevelBorderID: string;
                    Incognito: boolean;
                    HideAccountLevel: boolean;
                }>;
                SeasonalBadgeInfo: zod.ZodNull;
                IsOwner: zod.ZodOptional<zod.ZodBoolean>;
                QueueEligibleRemainingAccountLevels: zod.ZodNumber;
                Pings: zod.ZodArray<zod.ZodObject<{
                    Ping: zod.ZodNumber;
                    GamePodID: zod.ZodString;
                }, "strip", zod.ZodTypeAny, {
                    GamePodID: string;
                    Ping: number;
                }, {
                    GamePodID: string;
                    Ping: number;
                }>, "many">;
                IsReady: zod.ZodBoolean;
                IsModerator: zod.ZodBoolean;
                UseBroadcastHUD: zod.ZodBoolean;
                PlatformType: zod.ZodLiteral<"PC">;
            }, "strip", zod.ZodTypeAny, {
                Subject: string;
                PlayerIdentity: {
                    Subject: string;
                    PlayerCardID: string;
                    PlayerTitleID: string;
                    AccountLevel: number;
                    PreferredLevelBorderID: string;
                    Incognito: boolean;
                    HideAccountLevel: boolean;
                };
                SeasonalBadgeInfo: null;
                CompetitiveTier: number;
                QueueEligibleRemainingAccountLevels: number;
                Pings: {
                    GamePodID: string;
                    Ping: number;
                }[];
                IsReady: boolean;
                IsModerator: boolean;
                UseBroadcastHUD: boolean;
                PlatformType: "PC";
                IsOwner?: boolean | undefined;
            }, {
                Subject: string;
                PlayerIdentity: {
                    Subject: string;
                    PlayerCardID: string;
                    PlayerTitleID: string;
                    AccountLevel: number;
                    PreferredLevelBorderID: string;
                    Incognito: boolean;
                    HideAccountLevel: boolean;
                };
                SeasonalBadgeInfo: null;
                CompetitiveTier: number;
                QueueEligibleRemainingAccountLevels: number;
                Pings: {
                    GamePodID: string;
                    Ping: number;
                }[];
                IsReady: boolean;
                IsModerator: boolean;
                UseBroadcastHUD: boolean;
                PlatformType: "PC";
                IsOwner?: boolean | undefined;
            }>, "many">;
            State: zod.ZodString;
            PreviousState: zod.ZodString;
            StateTransitionReason: zod.ZodString;
            Accessibility: zod.ZodUnion<[zod.ZodLiteral<"OPEN">, zod.ZodLiteral<"CLOSED">]>;
            CustomGameData: zod.ZodObject<{
                Settings: zod.ZodObject<{
                    Map: zod.ZodString;
                    Mode: zod.ZodString;
                    UseBots: zod.ZodBoolean;
                    GamePod: zod.ZodString;
                    GameRules: zod.ZodNullable<zod.ZodObject<{
                        AllowGameModifiers: zod.ZodOptional<zod.ZodEffects<zod.ZodString, boolean, string>>;
                        IsOvertimeWinByTwo: zod.ZodOptional<zod.ZodEffects<zod.ZodString, boolean, string>>;
                        PlayOutAllRounds: zod.ZodOptional<zod.ZodEffects<zod.ZodString, boolean, string>>;
                        SkipMatchHistory: zod.ZodOptional<zod.ZodEffects<zod.ZodString, boolean, string>>;
                        TournamentMode: zod.ZodOptional<zod.ZodEffects<zod.ZodString, boolean, string>>;
                    }, "strip", zod.ZodTypeAny, {
                        AllowGameModifiers?: boolean | undefined;
                        IsOvertimeWinByTwo?: boolean | undefined;
                        PlayOutAllRounds?: boolean | undefined;
                        SkipMatchHistory?: boolean | undefined;
                        TournamentMode?: boolean | undefined;
                    }, {
                        AllowGameModifiers?: string | undefined;
                        IsOvertimeWinByTwo?: string | undefined;
                        PlayOutAllRounds?: string | undefined;
                        SkipMatchHistory?: string | undefined;
                        TournamentMode?: string | undefined;
                    }>>;
                }, "strip", zod.ZodTypeAny, {
                    Mode: string;
                    GameRules: {
                        AllowGameModifiers?: boolean | undefined;
                        IsOvertimeWinByTwo?: boolean | undefined;
                        PlayOutAllRounds?: boolean | undefined;
                        SkipMatchHistory?: boolean | undefined;
                        TournamentMode?: boolean | undefined;
                    } | null;
                    Map: string;
                    UseBots: boolean;
                    GamePod: string;
                }, {
                    Mode: string;
                    GameRules: {
                        AllowGameModifiers?: string | undefined;
                        IsOvertimeWinByTwo?: string | undefined;
                        PlayOutAllRounds?: string | undefined;
                        SkipMatchHistory?: string | undefined;
                        TournamentMode?: string | undefined;
                    } | null;
                    Map: string;
                    UseBots: boolean;
                    GamePod: string;
                }>;
                Membership: zod.ZodObject<{
                    teamOne: zod.ZodNullable<zod.ZodArray<zod.ZodObject<{
                        Subject: zod.ZodString;
                    }, "strip", zod.ZodTypeAny, {
                        Subject: string;
                    }, {
                        Subject: string;
                    }>, "many">>;
                    teamTwo: zod.ZodNullable<zod.ZodArray<zod.ZodObject<{
                        Subject: zod.ZodString;
                    }, "strip", zod.ZodTypeAny, {
                        Subject: string;
                    }, {
                        Subject: string;
                    }>, "many">>;
                    teamSpectate: zod.ZodNullable<zod.ZodArray<zod.ZodObject<{
                        Subject: zod.ZodString;
                    }, "strip", zod.ZodTypeAny, {
                        Subject: string;
                    }, {
                        Subject: string;
                    }>, "many">>;
                    teamOneCoaches: zod.ZodNullable<zod.ZodArray<zod.ZodObject<{
                        Subject: zod.ZodString;
                    }, "strip", zod.ZodTypeAny, {
                        Subject: string;
                    }, {
                        Subject: string;
                    }>, "many">>;
                    teamTwoCoaches: zod.ZodNullable<zod.ZodArray<zod.ZodObject<{
                        Subject: zod.ZodString;
                    }, "strip", zod.ZodTypeAny, {
                        Subject: string;
                    }, {
                        Subject: string;
                    }>, "many">>;
                }, "strip", zod.ZodTypeAny, {
                    teamOne: {
                        Subject: string;
                    }[] | null;
                    teamTwo: {
                        Subject: string;
                    }[] | null;
                    teamSpectate: {
                        Subject: string;
                    }[] | null;
                    teamOneCoaches: {
                        Subject: string;
                    }[] | null;
                    teamTwoCoaches: {
                        Subject: string;
                    }[] | null;
                }, {
                    teamOne: {
                        Subject: string;
                    }[] | null;
                    teamTwo: {
                        Subject: string;
                    }[] | null;
                    teamSpectate: {
                        Subject: string;
                    }[] | null;
                    teamOneCoaches: {
                        Subject: string;
                    }[] | null;
                    teamTwoCoaches: {
                        Subject: string;
                    }[] | null;
                }>;
                MaxPartySize: zod.ZodNumber;
                AutobalanceEnabled: zod.ZodBoolean;
                AutobalanceMinPlayers: zod.ZodNumber;
                HasRecoveryData: zod.ZodBoolean;
            }, "strip", zod.ZodTypeAny, {
                MaxPartySize: number;
                Settings: {
                    Mode: string;
                    GameRules: {
                        AllowGameModifiers?: boolean | undefined;
                        IsOvertimeWinByTwo?: boolean | undefined;
                        PlayOutAllRounds?: boolean | undefined;
                        SkipMatchHistory?: boolean | undefined;
                        TournamentMode?: boolean | undefined;
                    } | null;
                    Map: string;
                    UseBots: boolean;
                    GamePod: string;
                };
                Membership: {
                    teamOne: {
                        Subject: string;
                    }[] | null;
                    teamTwo: {
                        Subject: string;
                    }[] | null;
                    teamSpectate: {
                        Subject: string;
                    }[] | null;
                    teamOneCoaches: {
                        Subject: string;
                    }[] | null;
                    teamTwoCoaches: {
                        Subject: string;
                    }[] | null;
                };
                AutobalanceEnabled: boolean;
                AutobalanceMinPlayers: number;
                HasRecoveryData: boolean;
            }, {
                MaxPartySize: number;
                Settings: {
                    Mode: string;
                    GameRules: {
                        AllowGameModifiers?: string | undefined;
                        IsOvertimeWinByTwo?: string | undefined;
                        PlayOutAllRounds?: string | undefined;
                        SkipMatchHistory?: string | undefined;
                        TournamentMode?: string | undefined;
                    } | null;
                    Map: string;
                    UseBots: boolean;
                    GamePod: string;
                };
                Membership: {
                    teamOne: {
                        Subject: string;
                    }[] | null;
                    teamTwo: {
                        Subject: string;
                    }[] | null;
                    teamSpectate: {
                        Subject: string;
                    }[] | null;
                    teamOneCoaches: {
                        Subject: string;
                    }[] | null;
                    teamTwoCoaches: {
                        Subject: string;
                    }[] | null;
                };
                AutobalanceEnabled: boolean;
                AutobalanceMinPlayers: number;
                HasRecoveryData: boolean;
            }>;
            MatchmakingData: zod.ZodObject<{
                QueueID: zod.ZodString;
                PreferredGamePods: zod.ZodArray<zod.ZodString, "many">;
                SkillDisparityRRPenalty: zod.ZodNumber;
            }, "strip", zod.ZodTypeAny, {
                QueueID: string;
                PreferredGamePods: string[];
                SkillDisparityRRPenalty: number;
            }, {
                QueueID: string;
                PreferredGamePods: string[];
                SkillDisparityRRPenalty: number;
            }>;
            Invites: zod.ZodNull;
            Requests: zod.ZodArray<zod.ZodUnknown, "many">;
            QueueEntryTime: zod.ZodEffects<zod.ZodString, Date, string>;
            ErrorNotification: zod.ZodObject<{
                ErrorType: zod.ZodString;
                ErroredPlayers: zod.ZodNullable<zod.ZodArray<zod.ZodObject<{
                    Subject: zod.ZodString;
                }, "strip", zod.ZodTypeAny, {
                    Subject: string;
                }, {
                    Subject: string;
                }>, "many">>;
            }, "strip", zod.ZodTypeAny, {
                ErrorType: string;
                ErroredPlayers: {
                    Subject: string;
                }[] | null;
            }, {
                ErrorType: string;
                ErroredPlayers: {
                    Subject: string;
                }[] | null;
            }>;
            RestrictedSeconds: zod.ZodNumber;
            EligibleQueues: zod.ZodArray<zod.ZodString, "many">;
            QueueIneligibilities: zod.ZodArray<zod.ZodString, "many">;
            CheatData: zod.ZodObject<{
                GamePodOverride: zod.ZodString;
                ForcePostGameProcessing: zod.ZodBoolean;
            }, "strip", zod.ZodTypeAny, {
                GamePodOverride: string;
                ForcePostGameProcessing: boolean;
            }, {
                GamePodOverride: string;
                ForcePostGameProcessing: boolean;
            }>;
            XPBonuses: zod.ZodArray<zod.ZodUnknown, "many">;
            InviteCode: zod.ZodString;
        }, "strip", zod.ZodTypeAny, {
            ID: string;
            Version: number;
            Invites: null;
            Requests: unknown[];
            State: string;
            MatchmakingData: {
                QueueID: string;
                PreferredGamePods: string[];
                SkillDisparityRRPenalty: number;
            };
            MUCName: string;
            VoiceRoomID: string;
            ClientVersion: string;
            Members: {
                Subject: string;
                PlayerIdentity: {
                    Subject: string;
                    PlayerCardID: string;
                    PlayerTitleID: string;
                    AccountLevel: number;
                    PreferredLevelBorderID: string;
                    Incognito: boolean;
                    HideAccountLevel: boolean;
                };
                SeasonalBadgeInfo: null;
                CompetitiveTier: number;
                QueueEligibleRemainingAccountLevels: number;
                Pings: {
                    GamePodID: string;
                    Ping: number;
                }[];
                IsReady: boolean;
                IsModerator: boolean;
                UseBroadcastHUD: boolean;
                PlatformType: "PC";
                IsOwner?: boolean | undefined;
            }[];
            PreviousState: string;
            StateTransitionReason: string;
            Accessibility: "OPEN" | "CLOSED";
            CustomGameData: {
                MaxPartySize: number;
                Settings: {
                    Mode: string;
                    GameRules: {
                        AllowGameModifiers?: boolean | undefined;
                        IsOvertimeWinByTwo?: boolean | undefined;
                        PlayOutAllRounds?: boolean | undefined;
                        SkipMatchHistory?: boolean | undefined;
                        TournamentMode?: boolean | undefined;
                    } | null;
                    Map: string;
                    UseBots: boolean;
                    GamePod: string;
                };
                Membership: {
                    teamOne: {
                        Subject: string;
                    }[] | null;
                    teamTwo: {
                        Subject: string;
                    }[] | null;
                    teamSpectate: {
                        Subject: string;
                    }[] | null;
                    teamOneCoaches: {
                        Subject: string;
                    }[] | null;
                    teamTwoCoaches: {
                        Subject: string;
                    }[] | null;
                };
                AutobalanceEnabled: boolean;
                AutobalanceMinPlayers: number;
                HasRecoveryData: boolean;
            };
            QueueEntryTime: Date;
            ErrorNotification: {
                ErrorType: string;
                ErroredPlayers: {
                    Subject: string;
                }[] | null;
            };
            RestrictedSeconds: number;
            EligibleQueues: string[];
            QueueIneligibilities: string[];
            CheatData: {
                GamePodOverride: string;
                ForcePostGameProcessing: boolean;
            };
            XPBonuses: unknown[];
            InviteCode: string;
        }, {
            ID: string;
            Version: number;
            Invites: null;
            Requests: unknown[];
            State: string;
            MatchmakingData: {
                QueueID: string;
                PreferredGamePods: string[];
                SkillDisparityRRPenalty: number;
            };
            MUCName: string;
            VoiceRoomID: string;
            ClientVersion: string;
            Members: {
                Subject: string;
                PlayerIdentity: {
                    Subject: string;
                    PlayerCardID: string;
                    PlayerTitleID: string;
                    AccountLevel: number;
                    PreferredLevelBorderID: string;
                    Incognito: boolean;
                    HideAccountLevel: boolean;
                };
                SeasonalBadgeInfo: null;
                CompetitiveTier: number;
                QueueEligibleRemainingAccountLevels: number;
                Pings: {
                    GamePodID: string;
                    Ping: number;
                }[];
                IsReady: boolean;
                IsModerator: boolean;
                UseBroadcastHUD: boolean;
                PlatformType: "PC";
                IsOwner?: boolean | undefined;
            }[];
            PreviousState: string;
            StateTransitionReason: string;
            Accessibility: "OPEN" | "CLOSED";
            CustomGameData: {
                MaxPartySize: number;
                Settings: {
                    Mode: string;
                    GameRules: {
                        AllowGameModifiers?: string | undefined;
                        IsOvertimeWinByTwo?: string | undefined;
                        PlayOutAllRounds?: string | undefined;
                        SkipMatchHistory?: string | undefined;
                        TournamentMode?: string | undefined;
                    } | null;
                    Map: string;
                    UseBots: boolean;
                    GamePod: string;
                };
                Membership: {
                    teamOne: {
                        Subject: string;
                    }[] | null;
                    teamTwo: {
                        Subject: string;
                    }[] | null;
                    teamSpectate: {
                        Subject: string;
                    }[] | null;
                    teamOneCoaches: {
                        Subject: string;
                    }[] | null;
                    teamTwoCoaches: {
                        Subject: string;
                    }[] | null;
                };
                AutobalanceEnabled: boolean;
                AutobalanceMinPlayers: number;
                HasRecoveryData: boolean;
            };
            QueueEntryTime: string;
            ErrorNotification: {
                ErrorType: string;
                ErroredPlayers: {
                    Subject: string;
                }[] | null;
            };
            RestrictedSeconds: number;
            EligibleQueues: string[];
            QueueIneligibilities: string[];
            CheatData: {
                GamePodOverride: string;
                ForcePostGameProcessing: boolean;
            };
            XPBonuses: unknown[];
            InviteCode: string;
        }>;
    };
}, "type" | "name" | "url"> & {
    "~type": {
        readonly name: "Party Decline";
        readonly description: "Decline a party invite request";
        readonly type: "glz";
        readonly method: "POST";
        readonly url: "parties/v1/parties/:partyId/request/:requestId/decline";
        readonly responses: {
            readonly "200": zod.ZodObject<{
                ID: zod.ZodString;
                MUCName: zod.ZodString;
                VoiceRoomID: zod.ZodString;
                Version: zod.ZodNumber;
                ClientVersion: zod.ZodString;
                Members: zod.ZodArray<zod.ZodObject<{
                    Subject: zod.ZodString;
                    CompetitiveTier: zod.ZodNumber;
                    PlayerIdentity: zod.ZodObject<{
                        Subject: zod.ZodString;
                        PlayerCardID: zod.ZodString;
                        PlayerTitleID: zod.ZodString;
                        AccountLevel: zod.ZodNumber;
                        PreferredLevelBorderID: zod.ZodUnion<[zod.ZodString, zod.ZodLiteral<"">]>;
                        Incognito: zod.ZodBoolean;
                        HideAccountLevel: zod.ZodBoolean;
                    }, "strip", zod.ZodTypeAny, {
                        Subject: string;
                        PlayerCardID: string;
                        PlayerTitleID: string;
                        AccountLevel: number;
                        PreferredLevelBorderID: string;
                        Incognito: boolean;
                        HideAccountLevel: boolean;
                    }, {
                        Subject: string;
                        PlayerCardID: string;
                        PlayerTitleID: string;
                        AccountLevel: number;
                        PreferredLevelBorderID: string;
                        Incognito: boolean;
                        HideAccountLevel: boolean;
                    }>;
                    SeasonalBadgeInfo: zod.ZodNull;
                    IsOwner: zod.ZodOptional<zod.ZodBoolean>;
                    QueueEligibleRemainingAccountLevels: zod.ZodNumber;
                    Pings: zod.ZodArray<zod.ZodObject<{
                        Ping: zod.ZodNumber;
                        GamePodID: zod.ZodString;
                    }, "strip", zod.ZodTypeAny, {
                        GamePodID: string;
                        Ping: number;
                    }, {
                        GamePodID: string;
                        Ping: number;
                    }>, "many">;
                    IsReady: zod.ZodBoolean;
                    IsModerator: zod.ZodBoolean;
                    UseBroadcastHUD: zod.ZodBoolean;
                    PlatformType: zod.ZodLiteral<"PC">;
                }, "strip", zod.ZodTypeAny, {
                    Subject: string;
                    PlayerIdentity: {
                        Subject: string;
                        PlayerCardID: string;
                        PlayerTitleID: string;
                        AccountLevel: number;
                        PreferredLevelBorderID: string;
                        Incognito: boolean;
                        HideAccountLevel: boolean;
                    };
                    SeasonalBadgeInfo: null;
                    CompetitiveTier: number;
                    QueueEligibleRemainingAccountLevels: number;
                    Pings: {
                        GamePodID: string;
                        Ping: number;
                    }[];
                    IsReady: boolean;
                    IsModerator: boolean;
                    UseBroadcastHUD: boolean;
                    PlatformType: "PC";
                    IsOwner?: boolean | undefined;
                }, {
                    Subject: string;
                    PlayerIdentity: {
                        Subject: string;
                        PlayerCardID: string;
                        PlayerTitleID: string;
                        AccountLevel: number;
                        PreferredLevelBorderID: string;
                        Incognito: boolean;
                        HideAccountLevel: boolean;
                    };
                    SeasonalBadgeInfo: null;
                    CompetitiveTier: number;
                    QueueEligibleRemainingAccountLevels: number;
                    Pings: {
                        GamePodID: string;
                        Ping: number;
                    }[];
                    IsReady: boolean;
                    IsModerator: boolean;
                    UseBroadcastHUD: boolean;
                    PlatformType: "PC";
                    IsOwner?: boolean | undefined;
                }>, "many">;
                State: zod.ZodString;
                PreviousState: zod.ZodString;
                StateTransitionReason: zod.ZodString;
                Accessibility: zod.ZodUnion<[zod.ZodLiteral<"OPEN">, zod.ZodLiteral<"CLOSED">]>;
                CustomGameData: zod.ZodObject<{
                    Settings: zod.ZodObject<{
                        Map: zod.ZodString;
                        Mode: zod.ZodString;
                        UseBots: zod.ZodBoolean;
                        GamePod: zod.ZodString;
                        GameRules: zod.ZodNullable<zod.ZodObject<{
                            AllowGameModifiers: zod.ZodOptional<zod.ZodEffects<zod.ZodString, boolean, string>>;
                            IsOvertimeWinByTwo: zod.ZodOptional<zod.ZodEffects<zod.ZodString, boolean, string>>;
                            PlayOutAllRounds: zod.ZodOptional<zod.ZodEffects<zod.ZodString, boolean, string>>;
                            SkipMatchHistory: zod.ZodOptional<zod.ZodEffects<zod.ZodString, boolean, string>>;
                            TournamentMode: zod.ZodOptional<zod.ZodEffects<zod.ZodString, boolean, string>>;
                        }, "strip", zod.ZodTypeAny, {
                            AllowGameModifiers?: boolean | undefined;
                            IsOvertimeWinByTwo?: boolean | undefined;
                            PlayOutAllRounds?: boolean | undefined;
                            SkipMatchHistory?: boolean | undefined;
                            TournamentMode?: boolean | undefined;
                        }, {
                            AllowGameModifiers?: string | undefined;
                            IsOvertimeWinByTwo?: string | undefined;
                            PlayOutAllRounds?: string | undefined;
                            SkipMatchHistory?: string | undefined;
                            TournamentMode?: string | undefined;
                        }>>;
                    }, "strip", zod.ZodTypeAny, {
                        Mode: string;
                        GameRules: {
                            AllowGameModifiers?: boolean | undefined;
                            IsOvertimeWinByTwo?: boolean | undefined;
                            PlayOutAllRounds?: boolean | undefined;
                            SkipMatchHistory?: boolean | undefined;
                            TournamentMode?: boolean | undefined;
                        } | null;
                        Map: string;
                        UseBots: boolean;
                        GamePod: string;
                    }, {
                        Mode: string;
                        GameRules: {
                            AllowGameModifiers?: string | undefined;
                            IsOvertimeWinByTwo?: string | undefined;
                            PlayOutAllRounds?: string | undefined;
                            SkipMatchHistory?: string | undefined;
                            TournamentMode?: string | undefined;
                        } | null;
                        Map: string;
                        UseBots: boolean;
                        GamePod: string;
                    }>;
                    Membership: zod.ZodObject<{
                        teamOne: zod.ZodNullable<zod.ZodArray<zod.ZodObject<{
                            Subject: zod.ZodString;
                        }, "strip", zod.ZodTypeAny, {
                            Subject: string;
                        }, {
                            Subject: string;
                        }>, "many">>;
                        teamTwo: zod.ZodNullable<zod.ZodArray<zod.ZodObject<{
                            Subject: zod.ZodString;
                        }, "strip", zod.ZodTypeAny, {
                            Subject: string;
                        }, {
                            Subject: string;
                        }>, "many">>;
                        teamSpectate: zod.ZodNullable<zod.ZodArray<zod.ZodObject<{
                            Subject: zod.ZodString;
                        }, "strip", zod.ZodTypeAny, {
                            Subject: string;
                        }, {
                            Subject: string;
                        }>, "many">>;
                        teamOneCoaches: zod.ZodNullable<zod.ZodArray<zod.ZodObject<{
                            Subject: zod.ZodString;
                        }, "strip", zod.ZodTypeAny, {
                            Subject: string;
                        }, {
                            Subject: string;
                        }>, "many">>;
                        teamTwoCoaches: zod.ZodNullable<zod.ZodArray<zod.ZodObject<{
                            Subject: zod.ZodString;
                        }, "strip", zod.ZodTypeAny, {
                            Subject: string;
                        }, {
                            Subject: string;
                        }>, "many">>;
                    }, "strip", zod.ZodTypeAny, {
                        teamOne: {
                            Subject: string;
                        }[] | null;
                        teamTwo: {
                            Subject: string;
                        }[] | null;
                        teamSpectate: {
                            Subject: string;
                        }[] | null;
                        teamOneCoaches: {
                            Subject: string;
                        }[] | null;
                        teamTwoCoaches: {
                            Subject: string;
                        }[] | null;
                    }, {
                        teamOne: {
                            Subject: string;
                        }[] | null;
                        teamTwo: {
                            Subject: string;
                        }[] | null;
                        teamSpectate: {
                            Subject: string;
                        }[] | null;
                        teamOneCoaches: {
                            Subject: string;
                        }[] | null;
                        teamTwoCoaches: {
                            Subject: string;
                        }[] | null;
                    }>;
                    MaxPartySize: zod.ZodNumber;
                    AutobalanceEnabled: zod.ZodBoolean;
                    AutobalanceMinPlayers: zod.ZodNumber;
                    HasRecoveryData: zod.ZodBoolean;
                }, "strip", zod.ZodTypeAny, {
                    MaxPartySize: number;
                    Settings: {
                        Mode: string;
                        GameRules: {
                            AllowGameModifiers?: boolean | undefined;
                            IsOvertimeWinByTwo?: boolean | undefined;
                            PlayOutAllRounds?: boolean | undefined;
                            SkipMatchHistory?: boolean | undefined;
                            TournamentMode?: boolean | undefined;
                        } | null;
                        Map: string;
                        UseBots: boolean;
                        GamePod: string;
                    };
                    Membership: {
                        teamOne: {
                            Subject: string;
                        }[] | null;
                        teamTwo: {
                            Subject: string;
                        }[] | null;
                        teamSpectate: {
                            Subject: string;
                        }[] | null;
                        teamOneCoaches: {
                            Subject: string;
                        }[] | null;
                        teamTwoCoaches: {
                            Subject: string;
                        }[] | null;
                    };
                    AutobalanceEnabled: boolean;
                    AutobalanceMinPlayers: number;
                    HasRecoveryData: boolean;
                }, {
                    MaxPartySize: number;
                    Settings: {
                        Mode: string;
                        GameRules: {
                            AllowGameModifiers?: string | undefined;
                            IsOvertimeWinByTwo?: string | undefined;
                            PlayOutAllRounds?: string | undefined;
                            SkipMatchHistory?: string | undefined;
                            TournamentMode?: string | undefined;
                        } | null;
                        Map: string;
                        UseBots: boolean;
                        GamePod: string;
                    };
                    Membership: {
                        teamOne: {
                            Subject: string;
                        }[] | null;
                        teamTwo: {
                            Subject: string;
                        }[] | null;
                        teamSpectate: {
                            Subject: string;
                        }[] | null;
                        teamOneCoaches: {
                            Subject: string;
                        }[] | null;
                        teamTwoCoaches: {
                            Subject: string;
                        }[] | null;
                    };
                    AutobalanceEnabled: boolean;
                    AutobalanceMinPlayers: number;
                    HasRecoveryData: boolean;
                }>;
                MatchmakingData: zod.ZodObject<{
                    QueueID: zod.ZodString;
                    PreferredGamePods: zod.ZodArray<zod.ZodString, "many">;
                    SkillDisparityRRPenalty: zod.ZodNumber;
                }, "strip", zod.ZodTypeAny, {
                    QueueID: string;
                    PreferredGamePods: string[];
                    SkillDisparityRRPenalty: number;
                }, {
                    QueueID: string;
                    PreferredGamePods: string[];
                    SkillDisparityRRPenalty: number;
                }>;
                Invites: zod.ZodNull;
                Requests: zod.ZodArray<zod.ZodUnknown, "many">;
                QueueEntryTime: zod.ZodEffects<zod.ZodString, Date, string>;
                ErrorNotification: zod.ZodObject<{
                    ErrorType: zod.ZodString;
                    ErroredPlayers: zod.ZodNullable<zod.ZodArray<zod.ZodObject<{
                        Subject: zod.ZodString;
                    }, "strip", zod.ZodTypeAny, {
                        Subject: string;
                    }, {
                        Subject: string;
                    }>, "many">>;
                }, "strip", zod.ZodTypeAny, {
                    ErrorType: string;
                    ErroredPlayers: {
                        Subject: string;
                    }[] | null;
                }, {
                    ErrorType: string;
                    ErroredPlayers: {
                        Subject: string;
                    }[] | null;
                }>;
                RestrictedSeconds: zod.ZodNumber;
                EligibleQueues: zod.ZodArray<zod.ZodString, "many">;
                QueueIneligibilities: zod.ZodArray<zod.ZodString, "many">;
                CheatData: zod.ZodObject<{
                    GamePodOverride: zod.ZodString;
                    ForcePostGameProcessing: zod.ZodBoolean;
                }, "strip", zod.ZodTypeAny, {
                    GamePodOverride: string;
                    ForcePostGameProcessing: boolean;
                }, {
                    GamePodOverride: string;
                    ForcePostGameProcessing: boolean;
                }>;
                XPBonuses: zod.ZodArray<zod.ZodUnknown, "many">;
                InviteCode: zod.ZodString;
            }, "strip", zod.ZodTypeAny, {
                ID: string;
                Version: number;
                Invites: null;
                Requests: unknown[];
                State: string;
                MatchmakingData: {
                    QueueID: string;
                    PreferredGamePods: string[];
                    SkillDisparityRRPenalty: number;
                };
                MUCName: string;
                VoiceRoomID: string;
                ClientVersion: string;
                Members: {
                    Subject: string;
                    PlayerIdentity: {
                        Subject: string;
                        PlayerCardID: string;
                        PlayerTitleID: string;
                        AccountLevel: number;
                        PreferredLevelBorderID: string;
                        Incognito: boolean;
                        HideAccountLevel: boolean;
                    };
                    SeasonalBadgeInfo: null;
                    CompetitiveTier: number;
                    QueueEligibleRemainingAccountLevels: number;
                    Pings: {
                        GamePodID: string;
                        Ping: number;
                    }[];
                    IsReady: boolean;
                    IsModerator: boolean;
                    UseBroadcastHUD: boolean;
                    PlatformType: "PC";
                    IsOwner?: boolean | undefined;
                }[];
                PreviousState: string;
                StateTransitionReason: string;
                Accessibility: "OPEN" | "CLOSED";
                CustomGameData: {
                    MaxPartySize: number;
                    Settings: {
                        Mode: string;
                        GameRules: {
                            AllowGameModifiers?: boolean | undefined;
                            IsOvertimeWinByTwo?: boolean | undefined;
                            PlayOutAllRounds?: boolean | undefined;
                            SkipMatchHistory?: boolean | undefined;
                            TournamentMode?: boolean | undefined;
                        } | null;
                        Map: string;
                        UseBots: boolean;
                        GamePod: string;
                    };
                    Membership: {
                        teamOne: {
                            Subject: string;
                        }[] | null;
                        teamTwo: {
                            Subject: string;
                        }[] | null;
                        teamSpectate: {
                            Subject: string;
                        }[] | null;
                        teamOneCoaches: {
                            Subject: string;
                        }[] | null;
                        teamTwoCoaches: {
                            Subject: string;
                        }[] | null;
                    };
                    AutobalanceEnabled: boolean;
                    AutobalanceMinPlayers: number;
                    HasRecoveryData: boolean;
                };
                QueueEntryTime: Date;
                ErrorNotification: {
                    ErrorType: string;
                    ErroredPlayers: {
                        Subject: string;
                    }[] | null;
                };
                RestrictedSeconds: number;
                EligibleQueues: string[];
                QueueIneligibilities: string[];
                CheatData: {
                    GamePodOverride: string;
                    ForcePostGameProcessing: boolean;
                };
                XPBonuses: unknown[];
                InviteCode: string;
            }, {
                ID: string;
                Version: number;
                Invites: null;
                Requests: unknown[];
                State: string;
                MatchmakingData: {
                    QueueID: string;
                    PreferredGamePods: string[];
                    SkillDisparityRRPenalty: number;
                };
                MUCName: string;
                VoiceRoomID: string;
                ClientVersion: string;
                Members: {
                    Subject: string;
                    PlayerIdentity: {
                        Subject: string;
                        PlayerCardID: string;
                        PlayerTitleID: string;
                        AccountLevel: number;
                        PreferredLevelBorderID: string;
                        Incognito: boolean;
                        HideAccountLevel: boolean;
                    };
                    SeasonalBadgeInfo: null;
                    CompetitiveTier: number;
                    QueueEligibleRemainingAccountLevels: number;
                    Pings: {
                        GamePodID: string;
                        Ping: number;
                    }[];
                    IsReady: boolean;
                    IsModerator: boolean;
                    UseBroadcastHUD: boolean;
                    PlatformType: "PC";
                    IsOwner?: boolean | undefined;
                }[];
                PreviousState: string;
                StateTransitionReason: string;
                Accessibility: "OPEN" | "CLOSED";
                CustomGameData: {
                    MaxPartySize: number;
                    Settings: {
                        Mode: string;
                        GameRules: {
                            AllowGameModifiers?: string | undefined;
                            IsOvertimeWinByTwo?: string | undefined;
                            PlayOutAllRounds?: string | undefined;
                            SkipMatchHistory?: string | undefined;
                            TournamentMode?: string | undefined;
                        } | null;
                        Map: string;
                        UseBots: boolean;
                        GamePod: string;
                    };
                    Membership: {
                        teamOne: {
                            Subject: string;
                        }[] | null;
                        teamTwo: {
                            Subject: string;
                        }[] | null;
                        teamSpectate: {
                            Subject: string;
                        }[] | null;
                        teamOneCoaches: {
                            Subject: string;
                        }[] | null;
                        teamTwoCoaches: {
                            Subject: string;
                        }[] | null;
                    };
                    AutobalanceEnabled: boolean;
                    AutobalanceMinPlayers: number;
                    HasRecoveryData: boolean;
                };
                QueueEntryTime: string;
                ErrorNotification: {
                    ErrorType: string;
                    ErroredPlayers: {
                        Subject: string;
                    }[] | null;
                };
                RestrictedSeconds: number;
                EligibleQueues: string[];
                QueueIneligibilities: string[];
                CheatData: {
                    GamePodOverride: string;
                    ForcePostGameProcessing: boolean;
                };
                XPBonuses: unknown[];
                InviteCode: string;
            }>;
        };
    };
};

type Params$l = ResolveParams<(typeof _default$l)["~type"]["url"]>;
type Body$l = z.infer<ResolveValue<(typeof _default$l)["~type"], "body">>;
type Data$l = ResolveData<Params$l, Body$l>;
type Response$l = z.infer<ResolveValue<(typeof _default$l)["~type"], "responses">["200"]>;
interface PartyDeclineRequestConfig extends ValorantAxiosRequestConfig<Data$l> {
}
declare class PartyDeclineEndpoint {
    /**
     * Decline a party invite request
     *
     * @EndpointType glz
     */
    postPartyDecline<T = Response$l>(this: RemoteApiClient, config: PartyDeclineRequestConfig): Promise<AxiosResponse<T>>;
}

declare const _default$k: Omit<{
    requirements: string[];
    type: "auth" | "local" | "pd" | "glz" | "shared";
    name: string;
    method: "PUT" | "GET" | "DELETE" | "POST";
    url: string;
    description?: string | undefined;
    headers?: Record<string, string> | undefined;
    body?: zod.ZodType<any, zod.ZodTypeDef, any> | undefined;
    query?: zod.ZodType<any, zod.ZodTypeDef, any> | undefined;
    responses?: Record<string, zod.ZodType<any, zod.ZodTypeDef, any>> | undefined;
}, "type" | "name" | "url"> & Pick<{
    readonly name: "Party Disable Code";
    readonly description: "Disable the party invite code";
    readonly type: "glz";
    readonly method: "DELETE";
    readonly url: "parties/v1/parties/:partyId/invitecode";
    readonly responses: {
        readonly "200": zod.ZodObject<{
            ID: zod.ZodString;
            MUCName: zod.ZodString;
            VoiceRoomID: zod.ZodString;
            Version: zod.ZodNumber;
            ClientVersion: zod.ZodString;
            Members: zod.ZodArray<zod.ZodObject<{
                Subject: zod.ZodString;
                CompetitiveTier: zod.ZodNumber;
                PlayerIdentity: zod.ZodObject<{
                    Subject: zod.ZodString;
                    PlayerCardID: zod.ZodString;
                    PlayerTitleID: zod.ZodString;
                    AccountLevel: zod.ZodNumber;
                    PreferredLevelBorderID: zod.ZodUnion<[zod.ZodString, zod.ZodLiteral<"">]>;
                    Incognito: zod.ZodBoolean;
                    HideAccountLevel: zod.ZodBoolean;
                }, "strip", zod.ZodTypeAny, {
                    Subject: string;
                    PlayerCardID: string;
                    PlayerTitleID: string;
                    AccountLevel: number;
                    PreferredLevelBorderID: string;
                    Incognito: boolean;
                    HideAccountLevel: boolean;
                }, {
                    Subject: string;
                    PlayerCardID: string;
                    PlayerTitleID: string;
                    AccountLevel: number;
                    PreferredLevelBorderID: string;
                    Incognito: boolean;
                    HideAccountLevel: boolean;
                }>;
                SeasonalBadgeInfo: zod.ZodNull;
                IsOwner: zod.ZodOptional<zod.ZodBoolean>;
                QueueEligibleRemainingAccountLevels: zod.ZodNumber;
                Pings: zod.ZodArray<zod.ZodObject<{
                    Ping: zod.ZodNumber;
                    GamePodID: zod.ZodString;
                }, "strip", zod.ZodTypeAny, {
                    GamePodID: string;
                    Ping: number;
                }, {
                    GamePodID: string;
                    Ping: number;
                }>, "many">;
                IsReady: zod.ZodBoolean;
                IsModerator: zod.ZodBoolean;
                UseBroadcastHUD: zod.ZodBoolean;
                PlatformType: zod.ZodLiteral<"PC">;
            }, "strip", zod.ZodTypeAny, {
                Subject: string;
                PlayerIdentity: {
                    Subject: string;
                    PlayerCardID: string;
                    PlayerTitleID: string;
                    AccountLevel: number;
                    PreferredLevelBorderID: string;
                    Incognito: boolean;
                    HideAccountLevel: boolean;
                };
                SeasonalBadgeInfo: null;
                CompetitiveTier: number;
                QueueEligibleRemainingAccountLevels: number;
                Pings: {
                    GamePodID: string;
                    Ping: number;
                }[];
                IsReady: boolean;
                IsModerator: boolean;
                UseBroadcastHUD: boolean;
                PlatformType: "PC";
                IsOwner?: boolean | undefined;
            }, {
                Subject: string;
                PlayerIdentity: {
                    Subject: string;
                    PlayerCardID: string;
                    PlayerTitleID: string;
                    AccountLevel: number;
                    PreferredLevelBorderID: string;
                    Incognito: boolean;
                    HideAccountLevel: boolean;
                };
                SeasonalBadgeInfo: null;
                CompetitiveTier: number;
                QueueEligibleRemainingAccountLevels: number;
                Pings: {
                    GamePodID: string;
                    Ping: number;
                }[];
                IsReady: boolean;
                IsModerator: boolean;
                UseBroadcastHUD: boolean;
                PlatformType: "PC";
                IsOwner?: boolean | undefined;
            }>, "many">;
            State: zod.ZodString;
            PreviousState: zod.ZodString;
            StateTransitionReason: zod.ZodString;
            Accessibility: zod.ZodUnion<[zod.ZodLiteral<"OPEN">, zod.ZodLiteral<"CLOSED">]>;
            CustomGameData: zod.ZodObject<{
                Settings: zod.ZodObject<{
                    Map: zod.ZodString;
                    Mode: zod.ZodString;
                    UseBots: zod.ZodBoolean;
                    GamePod: zod.ZodString;
                    GameRules: zod.ZodNullable<zod.ZodObject<{
                        AllowGameModifiers: zod.ZodOptional<zod.ZodEffects<zod.ZodString, boolean, string>>;
                        IsOvertimeWinByTwo: zod.ZodOptional<zod.ZodEffects<zod.ZodString, boolean, string>>;
                        PlayOutAllRounds: zod.ZodOptional<zod.ZodEffects<zod.ZodString, boolean, string>>;
                        SkipMatchHistory: zod.ZodOptional<zod.ZodEffects<zod.ZodString, boolean, string>>;
                        TournamentMode: zod.ZodOptional<zod.ZodEffects<zod.ZodString, boolean, string>>;
                    }, "strip", zod.ZodTypeAny, {
                        AllowGameModifiers?: boolean | undefined;
                        IsOvertimeWinByTwo?: boolean | undefined;
                        PlayOutAllRounds?: boolean | undefined;
                        SkipMatchHistory?: boolean | undefined;
                        TournamentMode?: boolean | undefined;
                    }, {
                        AllowGameModifiers?: string | undefined;
                        IsOvertimeWinByTwo?: string | undefined;
                        PlayOutAllRounds?: string | undefined;
                        SkipMatchHistory?: string | undefined;
                        TournamentMode?: string | undefined;
                    }>>;
                }, "strip", zod.ZodTypeAny, {
                    Mode: string;
                    GameRules: {
                        AllowGameModifiers?: boolean | undefined;
                        IsOvertimeWinByTwo?: boolean | undefined;
                        PlayOutAllRounds?: boolean | undefined;
                        SkipMatchHistory?: boolean | undefined;
                        TournamentMode?: boolean | undefined;
                    } | null;
                    Map: string;
                    UseBots: boolean;
                    GamePod: string;
                }, {
                    Mode: string;
                    GameRules: {
                        AllowGameModifiers?: string | undefined;
                        IsOvertimeWinByTwo?: string | undefined;
                        PlayOutAllRounds?: string | undefined;
                        SkipMatchHistory?: string | undefined;
                        TournamentMode?: string | undefined;
                    } | null;
                    Map: string;
                    UseBots: boolean;
                    GamePod: string;
                }>;
                Membership: zod.ZodObject<{
                    teamOne: zod.ZodNullable<zod.ZodArray<zod.ZodObject<{
                        Subject: zod.ZodString;
                    }, "strip", zod.ZodTypeAny, {
                        Subject: string;
                    }, {
                        Subject: string;
                    }>, "many">>;
                    teamTwo: zod.ZodNullable<zod.ZodArray<zod.ZodObject<{
                        Subject: zod.ZodString;
                    }, "strip", zod.ZodTypeAny, {
                        Subject: string;
                    }, {
                        Subject: string;
                    }>, "many">>;
                    teamSpectate: zod.ZodNullable<zod.ZodArray<zod.ZodObject<{
                        Subject: zod.ZodString;
                    }, "strip", zod.ZodTypeAny, {
                        Subject: string;
                    }, {
                        Subject: string;
                    }>, "many">>;
                    teamOneCoaches: zod.ZodNullable<zod.ZodArray<zod.ZodObject<{
                        Subject: zod.ZodString;
                    }, "strip", zod.ZodTypeAny, {
                        Subject: string;
                    }, {
                        Subject: string;
                    }>, "many">>;
                    teamTwoCoaches: zod.ZodNullable<zod.ZodArray<zod.ZodObject<{
                        Subject: zod.ZodString;
                    }, "strip", zod.ZodTypeAny, {
                        Subject: string;
                    }, {
                        Subject: string;
                    }>, "many">>;
                }, "strip", zod.ZodTypeAny, {
                    teamOne: {
                        Subject: string;
                    }[] | null;
                    teamTwo: {
                        Subject: string;
                    }[] | null;
                    teamSpectate: {
                        Subject: string;
                    }[] | null;
                    teamOneCoaches: {
                        Subject: string;
                    }[] | null;
                    teamTwoCoaches: {
                        Subject: string;
                    }[] | null;
                }, {
                    teamOne: {
                        Subject: string;
                    }[] | null;
                    teamTwo: {
                        Subject: string;
                    }[] | null;
                    teamSpectate: {
                        Subject: string;
                    }[] | null;
                    teamOneCoaches: {
                        Subject: string;
                    }[] | null;
                    teamTwoCoaches: {
                        Subject: string;
                    }[] | null;
                }>;
                MaxPartySize: zod.ZodNumber;
                AutobalanceEnabled: zod.ZodBoolean;
                AutobalanceMinPlayers: zod.ZodNumber;
                HasRecoveryData: zod.ZodBoolean;
            }, "strip", zod.ZodTypeAny, {
                MaxPartySize: number;
                Settings: {
                    Mode: string;
                    GameRules: {
                        AllowGameModifiers?: boolean | undefined;
                        IsOvertimeWinByTwo?: boolean | undefined;
                        PlayOutAllRounds?: boolean | undefined;
                        SkipMatchHistory?: boolean | undefined;
                        TournamentMode?: boolean | undefined;
                    } | null;
                    Map: string;
                    UseBots: boolean;
                    GamePod: string;
                };
                Membership: {
                    teamOne: {
                        Subject: string;
                    }[] | null;
                    teamTwo: {
                        Subject: string;
                    }[] | null;
                    teamSpectate: {
                        Subject: string;
                    }[] | null;
                    teamOneCoaches: {
                        Subject: string;
                    }[] | null;
                    teamTwoCoaches: {
                        Subject: string;
                    }[] | null;
                };
                AutobalanceEnabled: boolean;
                AutobalanceMinPlayers: number;
                HasRecoveryData: boolean;
            }, {
                MaxPartySize: number;
                Settings: {
                    Mode: string;
                    GameRules: {
                        AllowGameModifiers?: string | undefined;
                        IsOvertimeWinByTwo?: string | undefined;
                        PlayOutAllRounds?: string | undefined;
                        SkipMatchHistory?: string | undefined;
                        TournamentMode?: string | undefined;
                    } | null;
                    Map: string;
                    UseBots: boolean;
                    GamePod: string;
                };
                Membership: {
                    teamOne: {
                        Subject: string;
                    }[] | null;
                    teamTwo: {
                        Subject: string;
                    }[] | null;
                    teamSpectate: {
                        Subject: string;
                    }[] | null;
                    teamOneCoaches: {
                        Subject: string;
                    }[] | null;
                    teamTwoCoaches: {
                        Subject: string;
                    }[] | null;
                };
                AutobalanceEnabled: boolean;
                AutobalanceMinPlayers: number;
                HasRecoveryData: boolean;
            }>;
            MatchmakingData: zod.ZodObject<{
                QueueID: zod.ZodString;
                PreferredGamePods: zod.ZodArray<zod.ZodString, "many">;
                SkillDisparityRRPenalty: zod.ZodNumber;
            }, "strip", zod.ZodTypeAny, {
                QueueID: string;
                PreferredGamePods: string[];
                SkillDisparityRRPenalty: number;
            }, {
                QueueID: string;
                PreferredGamePods: string[];
                SkillDisparityRRPenalty: number;
            }>;
            Invites: zod.ZodNull;
            Requests: zod.ZodArray<zod.ZodUnknown, "many">;
            QueueEntryTime: zod.ZodEffects<zod.ZodString, Date, string>;
            ErrorNotification: zod.ZodObject<{
                ErrorType: zod.ZodString;
                ErroredPlayers: zod.ZodNullable<zod.ZodArray<zod.ZodObject<{
                    Subject: zod.ZodString;
                }, "strip", zod.ZodTypeAny, {
                    Subject: string;
                }, {
                    Subject: string;
                }>, "many">>;
            }, "strip", zod.ZodTypeAny, {
                ErrorType: string;
                ErroredPlayers: {
                    Subject: string;
                }[] | null;
            }, {
                ErrorType: string;
                ErroredPlayers: {
                    Subject: string;
                }[] | null;
            }>;
            RestrictedSeconds: zod.ZodNumber;
            EligibleQueues: zod.ZodArray<zod.ZodString, "many">;
            QueueIneligibilities: zod.ZodArray<zod.ZodString, "many">;
            CheatData: zod.ZodObject<{
                GamePodOverride: zod.ZodString;
                ForcePostGameProcessing: zod.ZodBoolean;
            }, "strip", zod.ZodTypeAny, {
                GamePodOverride: string;
                ForcePostGameProcessing: boolean;
            }, {
                GamePodOverride: string;
                ForcePostGameProcessing: boolean;
            }>;
            XPBonuses: zod.ZodArray<zod.ZodUnknown, "many">;
            InviteCode: zod.ZodString;
        }, "strip", zod.ZodTypeAny, {
            ID: string;
            Version: number;
            Invites: null;
            Requests: unknown[];
            State: string;
            MatchmakingData: {
                QueueID: string;
                PreferredGamePods: string[];
                SkillDisparityRRPenalty: number;
            };
            MUCName: string;
            VoiceRoomID: string;
            ClientVersion: string;
            Members: {
                Subject: string;
                PlayerIdentity: {
                    Subject: string;
                    PlayerCardID: string;
                    PlayerTitleID: string;
                    AccountLevel: number;
                    PreferredLevelBorderID: string;
                    Incognito: boolean;
                    HideAccountLevel: boolean;
                };
                SeasonalBadgeInfo: null;
                CompetitiveTier: number;
                QueueEligibleRemainingAccountLevels: number;
                Pings: {
                    GamePodID: string;
                    Ping: number;
                }[];
                IsReady: boolean;
                IsModerator: boolean;
                UseBroadcastHUD: boolean;
                PlatformType: "PC";
                IsOwner?: boolean | undefined;
            }[];
            PreviousState: string;
            StateTransitionReason: string;
            Accessibility: "OPEN" | "CLOSED";
            CustomGameData: {
                MaxPartySize: number;
                Settings: {
                    Mode: string;
                    GameRules: {
                        AllowGameModifiers?: boolean | undefined;
                        IsOvertimeWinByTwo?: boolean | undefined;
                        PlayOutAllRounds?: boolean | undefined;
                        SkipMatchHistory?: boolean | undefined;
                        TournamentMode?: boolean | undefined;
                    } | null;
                    Map: string;
                    UseBots: boolean;
                    GamePod: string;
                };
                Membership: {
                    teamOne: {
                        Subject: string;
                    }[] | null;
                    teamTwo: {
                        Subject: string;
                    }[] | null;
                    teamSpectate: {
                        Subject: string;
                    }[] | null;
                    teamOneCoaches: {
                        Subject: string;
                    }[] | null;
                    teamTwoCoaches: {
                        Subject: string;
                    }[] | null;
                };
                AutobalanceEnabled: boolean;
                AutobalanceMinPlayers: number;
                HasRecoveryData: boolean;
            };
            QueueEntryTime: Date;
            ErrorNotification: {
                ErrorType: string;
                ErroredPlayers: {
                    Subject: string;
                }[] | null;
            };
            RestrictedSeconds: number;
            EligibleQueues: string[];
            QueueIneligibilities: string[];
            CheatData: {
                GamePodOverride: string;
                ForcePostGameProcessing: boolean;
            };
            XPBonuses: unknown[];
            InviteCode: string;
        }, {
            ID: string;
            Version: number;
            Invites: null;
            Requests: unknown[];
            State: string;
            MatchmakingData: {
                QueueID: string;
                PreferredGamePods: string[];
                SkillDisparityRRPenalty: number;
            };
            MUCName: string;
            VoiceRoomID: string;
            ClientVersion: string;
            Members: {
                Subject: string;
                PlayerIdentity: {
                    Subject: string;
                    PlayerCardID: string;
                    PlayerTitleID: string;
                    AccountLevel: number;
                    PreferredLevelBorderID: string;
                    Incognito: boolean;
                    HideAccountLevel: boolean;
                };
                SeasonalBadgeInfo: null;
                CompetitiveTier: number;
                QueueEligibleRemainingAccountLevels: number;
                Pings: {
                    GamePodID: string;
                    Ping: number;
                }[];
                IsReady: boolean;
                IsModerator: boolean;
                UseBroadcastHUD: boolean;
                PlatformType: "PC";
                IsOwner?: boolean | undefined;
            }[];
            PreviousState: string;
            StateTransitionReason: string;
            Accessibility: "OPEN" | "CLOSED";
            CustomGameData: {
                MaxPartySize: number;
                Settings: {
                    Mode: string;
                    GameRules: {
                        AllowGameModifiers?: string | undefined;
                        IsOvertimeWinByTwo?: string | undefined;
                        PlayOutAllRounds?: string | undefined;
                        SkipMatchHistory?: string | undefined;
                        TournamentMode?: string | undefined;
                    } | null;
                    Map: string;
                    UseBots: boolean;
                    GamePod: string;
                };
                Membership: {
                    teamOne: {
                        Subject: string;
                    }[] | null;
                    teamTwo: {
                        Subject: string;
                    }[] | null;
                    teamSpectate: {
                        Subject: string;
                    }[] | null;
                    teamOneCoaches: {
                        Subject: string;
                    }[] | null;
                    teamTwoCoaches: {
                        Subject: string;
                    }[] | null;
                };
                AutobalanceEnabled: boolean;
                AutobalanceMinPlayers: number;
                HasRecoveryData: boolean;
            };
            QueueEntryTime: string;
            ErrorNotification: {
                ErrorType: string;
                ErroredPlayers: {
                    Subject: string;
                }[] | null;
            };
            RestrictedSeconds: number;
            EligibleQueues: string[];
            QueueIneligibilities: string[];
            CheatData: {
                GamePodOverride: string;
                ForcePostGameProcessing: boolean;
            };
            XPBonuses: unknown[];
            InviteCode: string;
        }>;
    };
}, "type" | "name" | "url"> & {
    "~type": {
        readonly name: "Party Disable Code";
        readonly description: "Disable the party invite code";
        readonly type: "glz";
        readonly method: "DELETE";
        readonly url: "parties/v1/parties/:partyId/invitecode";
        readonly responses: {
            readonly "200": zod.ZodObject<{
                ID: zod.ZodString;
                MUCName: zod.ZodString;
                VoiceRoomID: zod.ZodString;
                Version: zod.ZodNumber;
                ClientVersion: zod.ZodString;
                Members: zod.ZodArray<zod.ZodObject<{
                    Subject: zod.ZodString;
                    CompetitiveTier: zod.ZodNumber;
                    PlayerIdentity: zod.ZodObject<{
                        Subject: zod.ZodString;
                        PlayerCardID: zod.ZodString;
                        PlayerTitleID: zod.ZodString;
                        AccountLevel: zod.ZodNumber;
                        PreferredLevelBorderID: zod.ZodUnion<[zod.ZodString, zod.ZodLiteral<"">]>;
                        Incognito: zod.ZodBoolean;
                        HideAccountLevel: zod.ZodBoolean;
                    }, "strip", zod.ZodTypeAny, {
                        Subject: string;
                        PlayerCardID: string;
                        PlayerTitleID: string;
                        AccountLevel: number;
                        PreferredLevelBorderID: string;
                        Incognito: boolean;
                        HideAccountLevel: boolean;
                    }, {
                        Subject: string;
                        PlayerCardID: string;
                        PlayerTitleID: string;
                        AccountLevel: number;
                        PreferredLevelBorderID: string;
                        Incognito: boolean;
                        HideAccountLevel: boolean;
                    }>;
                    SeasonalBadgeInfo: zod.ZodNull;
                    IsOwner: zod.ZodOptional<zod.ZodBoolean>;
                    QueueEligibleRemainingAccountLevels: zod.ZodNumber;
                    Pings: zod.ZodArray<zod.ZodObject<{
                        Ping: zod.ZodNumber;
                        GamePodID: zod.ZodString;
                    }, "strip", zod.ZodTypeAny, {
                        GamePodID: string;
                        Ping: number;
                    }, {
                        GamePodID: string;
                        Ping: number;
                    }>, "many">;
                    IsReady: zod.ZodBoolean;
                    IsModerator: zod.ZodBoolean;
                    UseBroadcastHUD: zod.ZodBoolean;
                    PlatformType: zod.ZodLiteral<"PC">;
                }, "strip", zod.ZodTypeAny, {
                    Subject: string;
                    PlayerIdentity: {
                        Subject: string;
                        PlayerCardID: string;
                        PlayerTitleID: string;
                        AccountLevel: number;
                        PreferredLevelBorderID: string;
                        Incognito: boolean;
                        HideAccountLevel: boolean;
                    };
                    SeasonalBadgeInfo: null;
                    CompetitiveTier: number;
                    QueueEligibleRemainingAccountLevels: number;
                    Pings: {
                        GamePodID: string;
                        Ping: number;
                    }[];
                    IsReady: boolean;
                    IsModerator: boolean;
                    UseBroadcastHUD: boolean;
                    PlatformType: "PC";
                    IsOwner?: boolean | undefined;
                }, {
                    Subject: string;
                    PlayerIdentity: {
                        Subject: string;
                        PlayerCardID: string;
                        PlayerTitleID: string;
                        AccountLevel: number;
                        PreferredLevelBorderID: string;
                        Incognito: boolean;
                        HideAccountLevel: boolean;
                    };
                    SeasonalBadgeInfo: null;
                    CompetitiveTier: number;
                    QueueEligibleRemainingAccountLevels: number;
                    Pings: {
                        GamePodID: string;
                        Ping: number;
                    }[];
                    IsReady: boolean;
                    IsModerator: boolean;
                    UseBroadcastHUD: boolean;
                    PlatformType: "PC";
                    IsOwner?: boolean | undefined;
                }>, "many">;
                State: zod.ZodString;
                PreviousState: zod.ZodString;
                StateTransitionReason: zod.ZodString;
                Accessibility: zod.ZodUnion<[zod.ZodLiteral<"OPEN">, zod.ZodLiteral<"CLOSED">]>;
                CustomGameData: zod.ZodObject<{
                    Settings: zod.ZodObject<{
                        Map: zod.ZodString;
                        Mode: zod.ZodString;
                        UseBots: zod.ZodBoolean;
                        GamePod: zod.ZodString;
                        GameRules: zod.ZodNullable<zod.ZodObject<{
                            AllowGameModifiers: zod.ZodOptional<zod.ZodEffects<zod.ZodString, boolean, string>>;
                            IsOvertimeWinByTwo: zod.ZodOptional<zod.ZodEffects<zod.ZodString, boolean, string>>;
                            PlayOutAllRounds: zod.ZodOptional<zod.ZodEffects<zod.ZodString, boolean, string>>;
                            SkipMatchHistory: zod.ZodOptional<zod.ZodEffects<zod.ZodString, boolean, string>>;
                            TournamentMode: zod.ZodOptional<zod.ZodEffects<zod.ZodString, boolean, string>>;
                        }, "strip", zod.ZodTypeAny, {
                            AllowGameModifiers?: boolean | undefined;
                            IsOvertimeWinByTwo?: boolean | undefined;
                            PlayOutAllRounds?: boolean | undefined;
                            SkipMatchHistory?: boolean | undefined;
                            TournamentMode?: boolean | undefined;
                        }, {
                            AllowGameModifiers?: string | undefined;
                            IsOvertimeWinByTwo?: string | undefined;
                            PlayOutAllRounds?: string | undefined;
                            SkipMatchHistory?: string | undefined;
                            TournamentMode?: string | undefined;
                        }>>;
                    }, "strip", zod.ZodTypeAny, {
                        Mode: string;
                        GameRules: {
                            AllowGameModifiers?: boolean | undefined;
                            IsOvertimeWinByTwo?: boolean | undefined;
                            PlayOutAllRounds?: boolean | undefined;
                            SkipMatchHistory?: boolean | undefined;
                            TournamentMode?: boolean | undefined;
                        } | null;
                        Map: string;
                        UseBots: boolean;
                        GamePod: string;
                    }, {
                        Mode: string;
                        GameRules: {
                            AllowGameModifiers?: string | undefined;
                            IsOvertimeWinByTwo?: string | undefined;
                            PlayOutAllRounds?: string | undefined;
                            SkipMatchHistory?: string | undefined;
                            TournamentMode?: string | undefined;
                        } | null;
                        Map: string;
                        UseBots: boolean;
                        GamePod: string;
                    }>;
                    Membership: zod.ZodObject<{
                        teamOne: zod.ZodNullable<zod.ZodArray<zod.ZodObject<{
                            Subject: zod.ZodString;
                        }, "strip", zod.ZodTypeAny, {
                            Subject: string;
                        }, {
                            Subject: string;
                        }>, "many">>;
                        teamTwo: zod.ZodNullable<zod.ZodArray<zod.ZodObject<{
                            Subject: zod.ZodString;
                        }, "strip", zod.ZodTypeAny, {
                            Subject: string;
                        }, {
                            Subject: string;
                        }>, "many">>;
                        teamSpectate: zod.ZodNullable<zod.ZodArray<zod.ZodObject<{
                            Subject: zod.ZodString;
                        }, "strip", zod.ZodTypeAny, {
                            Subject: string;
                        }, {
                            Subject: string;
                        }>, "many">>;
                        teamOneCoaches: zod.ZodNullable<zod.ZodArray<zod.ZodObject<{
                            Subject: zod.ZodString;
                        }, "strip", zod.ZodTypeAny, {
                            Subject: string;
                        }, {
                            Subject: string;
                        }>, "many">>;
                        teamTwoCoaches: zod.ZodNullable<zod.ZodArray<zod.ZodObject<{
                            Subject: zod.ZodString;
                        }, "strip", zod.ZodTypeAny, {
                            Subject: string;
                        }, {
                            Subject: string;
                        }>, "many">>;
                    }, "strip", zod.ZodTypeAny, {
                        teamOne: {
                            Subject: string;
                        }[] | null;
                        teamTwo: {
                            Subject: string;
                        }[] | null;
                        teamSpectate: {
                            Subject: string;
                        }[] | null;
                        teamOneCoaches: {
                            Subject: string;
                        }[] | null;
                        teamTwoCoaches: {
                            Subject: string;
                        }[] | null;
                    }, {
                        teamOne: {
                            Subject: string;
                        }[] | null;
                        teamTwo: {
                            Subject: string;
                        }[] | null;
                        teamSpectate: {
                            Subject: string;
                        }[] | null;
                        teamOneCoaches: {
                            Subject: string;
                        }[] | null;
                        teamTwoCoaches: {
                            Subject: string;
                        }[] | null;
                    }>;
                    MaxPartySize: zod.ZodNumber;
                    AutobalanceEnabled: zod.ZodBoolean;
                    AutobalanceMinPlayers: zod.ZodNumber;
                    HasRecoveryData: zod.ZodBoolean;
                }, "strip", zod.ZodTypeAny, {
                    MaxPartySize: number;
                    Settings: {
                        Mode: string;
                        GameRules: {
                            AllowGameModifiers?: boolean | undefined;
                            IsOvertimeWinByTwo?: boolean | undefined;
                            PlayOutAllRounds?: boolean | undefined;
                            SkipMatchHistory?: boolean | undefined;
                            TournamentMode?: boolean | undefined;
                        } | null;
                        Map: string;
                        UseBots: boolean;
                        GamePod: string;
                    };
                    Membership: {
                        teamOne: {
                            Subject: string;
                        }[] | null;
                        teamTwo: {
                            Subject: string;
                        }[] | null;
                        teamSpectate: {
                            Subject: string;
                        }[] | null;
                        teamOneCoaches: {
                            Subject: string;
                        }[] | null;
                        teamTwoCoaches: {
                            Subject: string;
                        }[] | null;
                    };
                    AutobalanceEnabled: boolean;
                    AutobalanceMinPlayers: number;
                    HasRecoveryData: boolean;
                }, {
                    MaxPartySize: number;
                    Settings: {
                        Mode: string;
                        GameRules: {
                            AllowGameModifiers?: string | undefined;
                            IsOvertimeWinByTwo?: string | undefined;
                            PlayOutAllRounds?: string | undefined;
                            SkipMatchHistory?: string | undefined;
                            TournamentMode?: string | undefined;
                        } | null;
                        Map: string;
                        UseBots: boolean;
                        GamePod: string;
                    };
                    Membership: {
                        teamOne: {
                            Subject: string;
                        }[] | null;
                        teamTwo: {
                            Subject: string;
                        }[] | null;
                        teamSpectate: {
                            Subject: string;
                        }[] | null;
                        teamOneCoaches: {
                            Subject: string;
                        }[] | null;
                        teamTwoCoaches: {
                            Subject: string;
                        }[] | null;
                    };
                    AutobalanceEnabled: boolean;
                    AutobalanceMinPlayers: number;
                    HasRecoveryData: boolean;
                }>;
                MatchmakingData: zod.ZodObject<{
                    QueueID: zod.ZodString;
                    PreferredGamePods: zod.ZodArray<zod.ZodString, "many">;
                    SkillDisparityRRPenalty: zod.ZodNumber;
                }, "strip", zod.ZodTypeAny, {
                    QueueID: string;
                    PreferredGamePods: string[];
                    SkillDisparityRRPenalty: number;
                }, {
                    QueueID: string;
                    PreferredGamePods: string[];
                    SkillDisparityRRPenalty: number;
                }>;
                Invites: zod.ZodNull;
                Requests: zod.ZodArray<zod.ZodUnknown, "many">;
                QueueEntryTime: zod.ZodEffects<zod.ZodString, Date, string>;
                ErrorNotification: zod.ZodObject<{
                    ErrorType: zod.ZodString;
                    ErroredPlayers: zod.ZodNullable<zod.ZodArray<zod.ZodObject<{
                        Subject: zod.ZodString;
                    }, "strip", zod.ZodTypeAny, {
                        Subject: string;
                    }, {
                        Subject: string;
                    }>, "many">>;
                }, "strip", zod.ZodTypeAny, {
                    ErrorType: string;
                    ErroredPlayers: {
                        Subject: string;
                    }[] | null;
                }, {
                    ErrorType: string;
                    ErroredPlayers: {
                        Subject: string;
                    }[] | null;
                }>;
                RestrictedSeconds: zod.ZodNumber;
                EligibleQueues: zod.ZodArray<zod.ZodString, "many">;
                QueueIneligibilities: zod.ZodArray<zod.ZodString, "many">;
                CheatData: zod.ZodObject<{
                    GamePodOverride: zod.ZodString;
                    ForcePostGameProcessing: zod.ZodBoolean;
                }, "strip", zod.ZodTypeAny, {
                    GamePodOverride: string;
                    ForcePostGameProcessing: boolean;
                }, {
                    GamePodOverride: string;
                    ForcePostGameProcessing: boolean;
                }>;
                XPBonuses: zod.ZodArray<zod.ZodUnknown, "many">;
                InviteCode: zod.ZodString;
            }, "strip", zod.ZodTypeAny, {
                ID: string;
                Version: number;
                Invites: null;
                Requests: unknown[];
                State: string;
                MatchmakingData: {
                    QueueID: string;
                    PreferredGamePods: string[];
                    SkillDisparityRRPenalty: number;
                };
                MUCName: string;
                VoiceRoomID: string;
                ClientVersion: string;
                Members: {
                    Subject: string;
                    PlayerIdentity: {
                        Subject: string;
                        PlayerCardID: string;
                        PlayerTitleID: string;
                        AccountLevel: number;
                        PreferredLevelBorderID: string;
                        Incognito: boolean;
                        HideAccountLevel: boolean;
                    };
                    SeasonalBadgeInfo: null;
                    CompetitiveTier: number;
                    QueueEligibleRemainingAccountLevels: number;
                    Pings: {
                        GamePodID: string;
                        Ping: number;
                    }[];
                    IsReady: boolean;
                    IsModerator: boolean;
                    UseBroadcastHUD: boolean;
                    PlatformType: "PC";
                    IsOwner?: boolean | undefined;
                }[];
                PreviousState: string;
                StateTransitionReason: string;
                Accessibility: "OPEN" | "CLOSED";
                CustomGameData: {
                    MaxPartySize: number;
                    Settings: {
                        Mode: string;
                        GameRules: {
                            AllowGameModifiers?: boolean | undefined;
                            IsOvertimeWinByTwo?: boolean | undefined;
                            PlayOutAllRounds?: boolean | undefined;
                            SkipMatchHistory?: boolean | undefined;
                            TournamentMode?: boolean | undefined;
                        } | null;
                        Map: string;
                        UseBots: boolean;
                        GamePod: string;
                    };
                    Membership: {
                        teamOne: {
                            Subject: string;
                        }[] | null;
                        teamTwo: {
                            Subject: string;
                        }[] | null;
                        teamSpectate: {
                            Subject: string;
                        }[] | null;
                        teamOneCoaches: {
                            Subject: string;
                        }[] | null;
                        teamTwoCoaches: {
                            Subject: string;
                        }[] | null;
                    };
                    AutobalanceEnabled: boolean;
                    AutobalanceMinPlayers: number;
                    HasRecoveryData: boolean;
                };
                QueueEntryTime: Date;
                ErrorNotification: {
                    ErrorType: string;
                    ErroredPlayers: {
                        Subject: string;
                    }[] | null;
                };
                RestrictedSeconds: number;
                EligibleQueues: string[];
                QueueIneligibilities: string[];
                CheatData: {
                    GamePodOverride: string;
                    ForcePostGameProcessing: boolean;
                };
                XPBonuses: unknown[];
                InviteCode: string;
            }, {
                ID: string;
                Version: number;
                Invites: null;
                Requests: unknown[];
                State: string;
                MatchmakingData: {
                    QueueID: string;
                    PreferredGamePods: string[];
                    SkillDisparityRRPenalty: number;
                };
                MUCName: string;
                VoiceRoomID: string;
                ClientVersion: string;
                Members: {
                    Subject: string;
                    PlayerIdentity: {
                        Subject: string;
                        PlayerCardID: string;
                        PlayerTitleID: string;
                        AccountLevel: number;
                        PreferredLevelBorderID: string;
                        Incognito: boolean;
                        HideAccountLevel: boolean;
                    };
                    SeasonalBadgeInfo: null;
                    CompetitiveTier: number;
                    QueueEligibleRemainingAccountLevels: number;
                    Pings: {
                        GamePodID: string;
                        Ping: number;
                    }[];
                    IsReady: boolean;
                    IsModerator: boolean;
                    UseBroadcastHUD: boolean;
                    PlatformType: "PC";
                    IsOwner?: boolean | undefined;
                }[];
                PreviousState: string;
                StateTransitionReason: string;
                Accessibility: "OPEN" | "CLOSED";
                CustomGameData: {
                    MaxPartySize: number;
                    Settings: {
                        Mode: string;
                        GameRules: {
                            AllowGameModifiers?: string | undefined;
                            IsOvertimeWinByTwo?: string | undefined;
                            PlayOutAllRounds?: string | undefined;
                            SkipMatchHistory?: string | undefined;
                            TournamentMode?: string | undefined;
                        } | null;
                        Map: string;
                        UseBots: boolean;
                        GamePod: string;
                    };
                    Membership: {
                        teamOne: {
                            Subject: string;
                        }[] | null;
                        teamTwo: {
                            Subject: string;
                        }[] | null;
                        teamSpectate: {
                            Subject: string;
                        }[] | null;
                        teamOneCoaches: {
                            Subject: string;
                        }[] | null;
                        teamTwoCoaches: {
                            Subject: string;
                        }[] | null;
                    };
                    AutobalanceEnabled: boolean;
                    AutobalanceMinPlayers: number;
                    HasRecoveryData: boolean;
                };
                QueueEntryTime: string;
                ErrorNotification: {
                    ErrorType: string;
                    ErroredPlayers: {
                        Subject: string;
                    }[] | null;
                };
                RestrictedSeconds: number;
                EligibleQueues: string[];
                QueueIneligibilities: string[];
                CheatData: {
                    GamePodOverride: string;
                    ForcePostGameProcessing: boolean;
                };
                XPBonuses: unknown[];
                InviteCode: string;
            }>;
        };
    };
};

type Params$k = ResolveParams<(typeof _default$k)["~type"]["url"]>;
type Body$k = z.infer<ResolveValue<(typeof _default$k)["~type"], "body">>;
type Data$k = ResolveData<Params$k, Body$k>;
type Response$k = z.infer<ResolveValue<(typeof _default$k)["~type"], "responses">["200"]>;
interface PartyDisableCodeRequestConfig extends ValorantAxiosRequestConfig<Data$k> {
}
declare class PartyDisableCodeEndpoint {
    /**
     * Disable the party invite code
     *
     * @EndpointType glz
     */
    deletePartyDisableCode<T = Response$k>(this: RemoteApiClient, config: PartyDisableCodeRequestConfig): Promise<AxiosResponse<T>>;
}

declare const _default$j: Omit<{
    requirements: string[];
    type: "auth" | "local" | "pd" | "glz" | "shared";
    name: string;
    method: "PUT" | "GET" | "DELETE" | "POST";
    url: string;
    description?: string | undefined;
    headers?: Record<string, string> | undefined;
    body?: zod.ZodType<any, zod.ZodTypeDef, any> | undefined;
    query?: zod.ZodType<any, zod.ZodTypeDef, any> | undefined;
    responses?: Record<string, zod.ZodType<any, zod.ZodTypeDef, any>> | undefined;
}, "type" | "name" | "url"> & Pick<{
    readonly name: "Party Generate Code";
    readonly description: "Generate a party invite code";
    readonly type: "glz";
    readonly method: "POST";
    readonly url: "parties/v1/parties/:partyId/invitecode";
    readonly responses: {
        readonly "200": zod.ZodObject<{
            ID: zod.ZodString;
            MUCName: zod.ZodString;
            VoiceRoomID: zod.ZodString;
            Version: zod.ZodNumber;
            ClientVersion: zod.ZodString;
            Members: zod.ZodArray<zod.ZodObject<{
                Subject: zod.ZodString;
                CompetitiveTier: zod.ZodNumber;
                PlayerIdentity: zod.ZodObject<{
                    Subject: zod.ZodString;
                    PlayerCardID: zod.ZodString;
                    PlayerTitleID: zod.ZodString;
                    AccountLevel: zod.ZodNumber;
                    PreferredLevelBorderID: zod.ZodUnion<[zod.ZodString, zod.ZodLiteral<"">]>;
                    Incognito: zod.ZodBoolean;
                    HideAccountLevel: zod.ZodBoolean;
                }, "strip", zod.ZodTypeAny, {
                    Subject: string;
                    PlayerCardID: string;
                    PlayerTitleID: string;
                    AccountLevel: number;
                    PreferredLevelBorderID: string;
                    Incognito: boolean;
                    HideAccountLevel: boolean;
                }, {
                    Subject: string;
                    PlayerCardID: string;
                    PlayerTitleID: string;
                    AccountLevel: number;
                    PreferredLevelBorderID: string;
                    Incognito: boolean;
                    HideAccountLevel: boolean;
                }>;
                SeasonalBadgeInfo: zod.ZodNull;
                IsOwner: zod.ZodOptional<zod.ZodBoolean>;
                QueueEligibleRemainingAccountLevels: zod.ZodNumber;
                Pings: zod.ZodArray<zod.ZodObject<{
                    Ping: zod.ZodNumber;
                    GamePodID: zod.ZodString;
                }, "strip", zod.ZodTypeAny, {
                    GamePodID: string;
                    Ping: number;
                }, {
                    GamePodID: string;
                    Ping: number;
                }>, "many">;
                IsReady: zod.ZodBoolean;
                IsModerator: zod.ZodBoolean;
                UseBroadcastHUD: zod.ZodBoolean;
                PlatformType: zod.ZodLiteral<"PC">;
            }, "strip", zod.ZodTypeAny, {
                Subject: string;
                PlayerIdentity: {
                    Subject: string;
                    PlayerCardID: string;
                    PlayerTitleID: string;
                    AccountLevel: number;
                    PreferredLevelBorderID: string;
                    Incognito: boolean;
                    HideAccountLevel: boolean;
                };
                SeasonalBadgeInfo: null;
                CompetitiveTier: number;
                QueueEligibleRemainingAccountLevels: number;
                Pings: {
                    GamePodID: string;
                    Ping: number;
                }[];
                IsReady: boolean;
                IsModerator: boolean;
                UseBroadcastHUD: boolean;
                PlatformType: "PC";
                IsOwner?: boolean | undefined;
            }, {
                Subject: string;
                PlayerIdentity: {
                    Subject: string;
                    PlayerCardID: string;
                    PlayerTitleID: string;
                    AccountLevel: number;
                    PreferredLevelBorderID: string;
                    Incognito: boolean;
                    HideAccountLevel: boolean;
                };
                SeasonalBadgeInfo: null;
                CompetitiveTier: number;
                QueueEligibleRemainingAccountLevels: number;
                Pings: {
                    GamePodID: string;
                    Ping: number;
                }[];
                IsReady: boolean;
                IsModerator: boolean;
                UseBroadcastHUD: boolean;
                PlatformType: "PC";
                IsOwner?: boolean | undefined;
            }>, "many">;
            State: zod.ZodString;
            PreviousState: zod.ZodString;
            StateTransitionReason: zod.ZodString;
            Accessibility: zod.ZodUnion<[zod.ZodLiteral<"OPEN">, zod.ZodLiteral<"CLOSED">]>;
            CustomGameData: zod.ZodObject<{
                Settings: zod.ZodObject<{
                    Map: zod.ZodString;
                    Mode: zod.ZodString;
                    UseBots: zod.ZodBoolean;
                    GamePod: zod.ZodString;
                    GameRules: zod.ZodNullable<zod.ZodObject<{
                        AllowGameModifiers: zod.ZodOptional<zod.ZodEffects<zod.ZodString, boolean, string>>;
                        IsOvertimeWinByTwo: zod.ZodOptional<zod.ZodEffects<zod.ZodString, boolean, string>>;
                        PlayOutAllRounds: zod.ZodOptional<zod.ZodEffects<zod.ZodString, boolean, string>>;
                        SkipMatchHistory: zod.ZodOptional<zod.ZodEffects<zod.ZodString, boolean, string>>;
                        TournamentMode: zod.ZodOptional<zod.ZodEffects<zod.ZodString, boolean, string>>;
                    }, "strip", zod.ZodTypeAny, {
                        AllowGameModifiers?: boolean | undefined;
                        IsOvertimeWinByTwo?: boolean | undefined;
                        PlayOutAllRounds?: boolean | undefined;
                        SkipMatchHistory?: boolean | undefined;
                        TournamentMode?: boolean | undefined;
                    }, {
                        AllowGameModifiers?: string | undefined;
                        IsOvertimeWinByTwo?: string | undefined;
                        PlayOutAllRounds?: string | undefined;
                        SkipMatchHistory?: string | undefined;
                        TournamentMode?: string | undefined;
                    }>>;
                }, "strip", zod.ZodTypeAny, {
                    Mode: string;
                    GameRules: {
                        AllowGameModifiers?: boolean | undefined;
                        IsOvertimeWinByTwo?: boolean | undefined;
                        PlayOutAllRounds?: boolean | undefined;
                        SkipMatchHistory?: boolean | undefined;
                        TournamentMode?: boolean | undefined;
                    } | null;
                    Map: string;
                    UseBots: boolean;
                    GamePod: string;
                }, {
                    Mode: string;
                    GameRules: {
                        AllowGameModifiers?: string | undefined;
                        IsOvertimeWinByTwo?: string | undefined;
                        PlayOutAllRounds?: string | undefined;
                        SkipMatchHistory?: string | undefined;
                        TournamentMode?: string | undefined;
                    } | null;
                    Map: string;
                    UseBots: boolean;
                    GamePod: string;
                }>;
                Membership: zod.ZodObject<{
                    teamOne: zod.ZodNullable<zod.ZodArray<zod.ZodObject<{
                        Subject: zod.ZodString;
                    }, "strip", zod.ZodTypeAny, {
                        Subject: string;
                    }, {
                        Subject: string;
                    }>, "many">>;
                    teamTwo: zod.ZodNullable<zod.ZodArray<zod.ZodObject<{
                        Subject: zod.ZodString;
                    }, "strip", zod.ZodTypeAny, {
                        Subject: string;
                    }, {
                        Subject: string;
                    }>, "many">>;
                    teamSpectate: zod.ZodNullable<zod.ZodArray<zod.ZodObject<{
                        Subject: zod.ZodString;
                    }, "strip", zod.ZodTypeAny, {
                        Subject: string;
                    }, {
                        Subject: string;
                    }>, "many">>;
                    teamOneCoaches: zod.ZodNullable<zod.ZodArray<zod.ZodObject<{
                        Subject: zod.ZodString;
                    }, "strip", zod.ZodTypeAny, {
                        Subject: string;
                    }, {
                        Subject: string;
                    }>, "many">>;
                    teamTwoCoaches: zod.ZodNullable<zod.ZodArray<zod.ZodObject<{
                        Subject: zod.ZodString;
                    }, "strip", zod.ZodTypeAny, {
                        Subject: string;
                    }, {
                        Subject: string;
                    }>, "many">>;
                }, "strip", zod.ZodTypeAny, {
                    teamOne: {
                        Subject: string;
                    }[] | null;
                    teamTwo: {
                        Subject: string;
                    }[] | null;
                    teamSpectate: {
                        Subject: string;
                    }[] | null;
                    teamOneCoaches: {
                        Subject: string;
                    }[] | null;
                    teamTwoCoaches: {
                        Subject: string;
                    }[] | null;
                }, {
                    teamOne: {
                        Subject: string;
                    }[] | null;
                    teamTwo: {
                        Subject: string;
                    }[] | null;
                    teamSpectate: {
                        Subject: string;
                    }[] | null;
                    teamOneCoaches: {
                        Subject: string;
                    }[] | null;
                    teamTwoCoaches: {
                        Subject: string;
                    }[] | null;
                }>;
                MaxPartySize: zod.ZodNumber;
                AutobalanceEnabled: zod.ZodBoolean;
                AutobalanceMinPlayers: zod.ZodNumber;
                HasRecoveryData: zod.ZodBoolean;
            }, "strip", zod.ZodTypeAny, {
                MaxPartySize: number;
                Settings: {
                    Mode: string;
                    GameRules: {
                        AllowGameModifiers?: boolean | undefined;
                        IsOvertimeWinByTwo?: boolean | undefined;
                        PlayOutAllRounds?: boolean | undefined;
                        SkipMatchHistory?: boolean | undefined;
                        TournamentMode?: boolean | undefined;
                    } | null;
                    Map: string;
                    UseBots: boolean;
                    GamePod: string;
                };
                Membership: {
                    teamOne: {
                        Subject: string;
                    }[] | null;
                    teamTwo: {
                        Subject: string;
                    }[] | null;
                    teamSpectate: {
                        Subject: string;
                    }[] | null;
                    teamOneCoaches: {
                        Subject: string;
                    }[] | null;
                    teamTwoCoaches: {
                        Subject: string;
                    }[] | null;
                };
                AutobalanceEnabled: boolean;
                AutobalanceMinPlayers: number;
                HasRecoveryData: boolean;
            }, {
                MaxPartySize: number;
                Settings: {
                    Mode: string;
                    GameRules: {
                        AllowGameModifiers?: string | undefined;
                        IsOvertimeWinByTwo?: string | undefined;
                        PlayOutAllRounds?: string | undefined;
                        SkipMatchHistory?: string | undefined;
                        TournamentMode?: string | undefined;
                    } | null;
                    Map: string;
                    UseBots: boolean;
                    GamePod: string;
                };
                Membership: {
                    teamOne: {
                        Subject: string;
                    }[] | null;
                    teamTwo: {
                        Subject: string;
                    }[] | null;
                    teamSpectate: {
                        Subject: string;
                    }[] | null;
                    teamOneCoaches: {
                        Subject: string;
                    }[] | null;
                    teamTwoCoaches: {
                        Subject: string;
                    }[] | null;
                };
                AutobalanceEnabled: boolean;
                AutobalanceMinPlayers: number;
                HasRecoveryData: boolean;
            }>;
            MatchmakingData: zod.ZodObject<{
                QueueID: zod.ZodString;
                PreferredGamePods: zod.ZodArray<zod.ZodString, "many">;
                SkillDisparityRRPenalty: zod.ZodNumber;
            }, "strip", zod.ZodTypeAny, {
                QueueID: string;
                PreferredGamePods: string[];
                SkillDisparityRRPenalty: number;
            }, {
                QueueID: string;
                PreferredGamePods: string[];
                SkillDisparityRRPenalty: number;
            }>;
            Invites: zod.ZodNull;
            Requests: zod.ZodArray<zod.ZodUnknown, "many">;
            QueueEntryTime: zod.ZodEffects<zod.ZodString, Date, string>;
            ErrorNotification: zod.ZodObject<{
                ErrorType: zod.ZodString;
                ErroredPlayers: zod.ZodNullable<zod.ZodArray<zod.ZodObject<{
                    Subject: zod.ZodString;
                }, "strip", zod.ZodTypeAny, {
                    Subject: string;
                }, {
                    Subject: string;
                }>, "many">>;
            }, "strip", zod.ZodTypeAny, {
                ErrorType: string;
                ErroredPlayers: {
                    Subject: string;
                }[] | null;
            }, {
                ErrorType: string;
                ErroredPlayers: {
                    Subject: string;
                }[] | null;
            }>;
            RestrictedSeconds: zod.ZodNumber;
            EligibleQueues: zod.ZodArray<zod.ZodString, "many">;
            QueueIneligibilities: zod.ZodArray<zod.ZodString, "many">;
            CheatData: zod.ZodObject<{
                GamePodOverride: zod.ZodString;
                ForcePostGameProcessing: zod.ZodBoolean;
            }, "strip", zod.ZodTypeAny, {
                GamePodOverride: string;
                ForcePostGameProcessing: boolean;
            }, {
                GamePodOverride: string;
                ForcePostGameProcessing: boolean;
            }>;
            XPBonuses: zod.ZodArray<zod.ZodUnknown, "many">;
            InviteCode: zod.ZodString;
        }, "strip", zod.ZodTypeAny, {
            ID: string;
            Version: number;
            Invites: null;
            Requests: unknown[];
            State: string;
            MatchmakingData: {
                QueueID: string;
                PreferredGamePods: string[];
                SkillDisparityRRPenalty: number;
            };
            MUCName: string;
            VoiceRoomID: string;
            ClientVersion: string;
            Members: {
                Subject: string;
                PlayerIdentity: {
                    Subject: string;
                    PlayerCardID: string;
                    PlayerTitleID: string;
                    AccountLevel: number;
                    PreferredLevelBorderID: string;
                    Incognito: boolean;
                    HideAccountLevel: boolean;
                };
                SeasonalBadgeInfo: null;
                CompetitiveTier: number;
                QueueEligibleRemainingAccountLevels: number;
                Pings: {
                    GamePodID: string;
                    Ping: number;
                }[];
                IsReady: boolean;
                IsModerator: boolean;
                UseBroadcastHUD: boolean;
                PlatformType: "PC";
                IsOwner?: boolean | undefined;
            }[];
            PreviousState: string;
            StateTransitionReason: string;
            Accessibility: "OPEN" | "CLOSED";
            CustomGameData: {
                MaxPartySize: number;
                Settings: {
                    Mode: string;
                    GameRules: {
                        AllowGameModifiers?: boolean | undefined;
                        IsOvertimeWinByTwo?: boolean | undefined;
                        PlayOutAllRounds?: boolean | undefined;
                        SkipMatchHistory?: boolean | undefined;
                        TournamentMode?: boolean | undefined;
                    } | null;
                    Map: string;
                    UseBots: boolean;
                    GamePod: string;
                };
                Membership: {
                    teamOne: {
                        Subject: string;
                    }[] | null;
                    teamTwo: {
                        Subject: string;
                    }[] | null;
                    teamSpectate: {
                        Subject: string;
                    }[] | null;
                    teamOneCoaches: {
                        Subject: string;
                    }[] | null;
                    teamTwoCoaches: {
                        Subject: string;
                    }[] | null;
                };
                AutobalanceEnabled: boolean;
                AutobalanceMinPlayers: number;
                HasRecoveryData: boolean;
            };
            QueueEntryTime: Date;
            ErrorNotification: {
                ErrorType: string;
                ErroredPlayers: {
                    Subject: string;
                }[] | null;
            };
            RestrictedSeconds: number;
            EligibleQueues: string[];
            QueueIneligibilities: string[];
            CheatData: {
                GamePodOverride: string;
                ForcePostGameProcessing: boolean;
            };
            XPBonuses: unknown[];
            InviteCode: string;
        }, {
            ID: string;
            Version: number;
            Invites: null;
            Requests: unknown[];
            State: string;
            MatchmakingData: {
                QueueID: string;
                PreferredGamePods: string[];
                SkillDisparityRRPenalty: number;
            };
            MUCName: string;
            VoiceRoomID: string;
            ClientVersion: string;
            Members: {
                Subject: string;
                PlayerIdentity: {
                    Subject: string;
                    PlayerCardID: string;
                    PlayerTitleID: string;
                    AccountLevel: number;
                    PreferredLevelBorderID: string;
                    Incognito: boolean;
                    HideAccountLevel: boolean;
                };
                SeasonalBadgeInfo: null;
                CompetitiveTier: number;
                QueueEligibleRemainingAccountLevels: number;
                Pings: {
                    GamePodID: string;
                    Ping: number;
                }[];
                IsReady: boolean;
                IsModerator: boolean;
                UseBroadcastHUD: boolean;
                PlatformType: "PC";
                IsOwner?: boolean | undefined;
            }[];
            PreviousState: string;
            StateTransitionReason: string;
            Accessibility: "OPEN" | "CLOSED";
            CustomGameData: {
                MaxPartySize: number;
                Settings: {
                    Mode: string;
                    GameRules: {
                        AllowGameModifiers?: string | undefined;
                        IsOvertimeWinByTwo?: string | undefined;
                        PlayOutAllRounds?: string | undefined;
                        SkipMatchHistory?: string | undefined;
                        TournamentMode?: string | undefined;
                    } | null;
                    Map: string;
                    UseBots: boolean;
                    GamePod: string;
                };
                Membership: {
                    teamOne: {
                        Subject: string;
                    }[] | null;
                    teamTwo: {
                        Subject: string;
                    }[] | null;
                    teamSpectate: {
                        Subject: string;
                    }[] | null;
                    teamOneCoaches: {
                        Subject: string;
                    }[] | null;
                    teamTwoCoaches: {
                        Subject: string;
                    }[] | null;
                };
                AutobalanceEnabled: boolean;
                AutobalanceMinPlayers: number;
                HasRecoveryData: boolean;
            };
            QueueEntryTime: string;
            ErrorNotification: {
                ErrorType: string;
                ErroredPlayers: {
                    Subject: string;
                }[] | null;
            };
            RestrictedSeconds: number;
            EligibleQueues: string[];
            QueueIneligibilities: string[];
            CheatData: {
                GamePodOverride: string;
                ForcePostGameProcessing: boolean;
            };
            XPBonuses: unknown[];
            InviteCode: string;
        }>;
    };
}, "type" | "name" | "url"> & {
    "~type": {
        readonly name: "Party Generate Code";
        readonly description: "Generate a party invite code";
        readonly type: "glz";
        readonly method: "POST";
        readonly url: "parties/v1/parties/:partyId/invitecode";
        readonly responses: {
            readonly "200": zod.ZodObject<{
                ID: zod.ZodString;
                MUCName: zod.ZodString;
                VoiceRoomID: zod.ZodString;
                Version: zod.ZodNumber;
                ClientVersion: zod.ZodString;
                Members: zod.ZodArray<zod.ZodObject<{
                    Subject: zod.ZodString;
                    CompetitiveTier: zod.ZodNumber;
                    PlayerIdentity: zod.ZodObject<{
                        Subject: zod.ZodString;
                        PlayerCardID: zod.ZodString;
                        PlayerTitleID: zod.ZodString;
                        AccountLevel: zod.ZodNumber;
                        PreferredLevelBorderID: zod.ZodUnion<[zod.ZodString, zod.ZodLiteral<"">]>;
                        Incognito: zod.ZodBoolean;
                        HideAccountLevel: zod.ZodBoolean;
                    }, "strip", zod.ZodTypeAny, {
                        Subject: string;
                        PlayerCardID: string;
                        PlayerTitleID: string;
                        AccountLevel: number;
                        PreferredLevelBorderID: string;
                        Incognito: boolean;
                        HideAccountLevel: boolean;
                    }, {
                        Subject: string;
                        PlayerCardID: string;
                        PlayerTitleID: string;
                        AccountLevel: number;
                        PreferredLevelBorderID: string;
                        Incognito: boolean;
                        HideAccountLevel: boolean;
                    }>;
                    SeasonalBadgeInfo: zod.ZodNull;
                    IsOwner: zod.ZodOptional<zod.ZodBoolean>;
                    QueueEligibleRemainingAccountLevels: zod.ZodNumber;
                    Pings: zod.ZodArray<zod.ZodObject<{
                        Ping: zod.ZodNumber;
                        GamePodID: zod.ZodString;
                    }, "strip", zod.ZodTypeAny, {
                        GamePodID: string;
                        Ping: number;
                    }, {
                        GamePodID: string;
                        Ping: number;
                    }>, "many">;
                    IsReady: zod.ZodBoolean;
                    IsModerator: zod.ZodBoolean;
                    UseBroadcastHUD: zod.ZodBoolean;
                    PlatformType: zod.ZodLiteral<"PC">;
                }, "strip", zod.ZodTypeAny, {
                    Subject: string;
                    PlayerIdentity: {
                        Subject: string;
                        PlayerCardID: string;
                        PlayerTitleID: string;
                        AccountLevel: number;
                        PreferredLevelBorderID: string;
                        Incognito: boolean;
                        HideAccountLevel: boolean;
                    };
                    SeasonalBadgeInfo: null;
                    CompetitiveTier: number;
                    QueueEligibleRemainingAccountLevels: number;
                    Pings: {
                        GamePodID: string;
                        Ping: number;
                    }[];
                    IsReady: boolean;
                    IsModerator: boolean;
                    UseBroadcastHUD: boolean;
                    PlatformType: "PC";
                    IsOwner?: boolean | undefined;
                }, {
                    Subject: string;
                    PlayerIdentity: {
                        Subject: string;
                        PlayerCardID: string;
                        PlayerTitleID: string;
                        AccountLevel: number;
                        PreferredLevelBorderID: string;
                        Incognito: boolean;
                        HideAccountLevel: boolean;
                    };
                    SeasonalBadgeInfo: null;
                    CompetitiveTier: number;
                    QueueEligibleRemainingAccountLevels: number;
                    Pings: {
                        GamePodID: string;
                        Ping: number;
                    }[];
                    IsReady: boolean;
                    IsModerator: boolean;
                    UseBroadcastHUD: boolean;
                    PlatformType: "PC";
                    IsOwner?: boolean | undefined;
                }>, "many">;
                State: zod.ZodString;
                PreviousState: zod.ZodString;
                StateTransitionReason: zod.ZodString;
                Accessibility: zod.ZodUnion<[zod.ZodLiteral<"OPEN">, zod.ZodLiteral<"CLOSED">]>;
                CustomGameData: zod.ZodObject<{
                    Settings: zod.ZodObject<{
                        Map: zod.ZodString;
                        Mode: zod.ZodString;
                        UseBots: zod.ZodBoolean;
                        GamePod: zod.ZodString;
                        GameRules: zod.ZodNullable<zod.ZodObject<{
                            AllowGameModifiers: zod.ZodOptional<zod.ZodEffects<zod.ZodString, boolean, string>>;
                            IsOvertimeWinByTwo: zod.ZodOptional<zod.ZodEffects<zod.ZodString, boolean, string>>;
                            PlayOutAllRounds: zod.ZodOptional<zod.ZodEffects<zod.ZodString, boolean, string>>;
                            SkipMatchHistory: zod.ZodOptional<zod.ZodEffects<zod.ZodString, boolean, string>>;
                            TournamentMode: zod.ZodOptional<zod.ZodEffects<zod.ZodString, boolean, string>>;
                        }, "strip", zod.ZodTypeAny, {
                            AllowGameModifiers?: boolean | undefined;
                            IsOvertimeWinByTwo?: boolean | undefined;
                            PlayOutAllRounds?: boolean | undefined;
                            SkipMatchHistory?: boolean | undefined;
                            TournamentMode?: boolean | undefined;
                        }, {
                            AllowGameModifiers?: string | undefined;
                            IsOvertimeWinByTwo?: string | undefined;
                            PlayOutAllRounds?: string | undefined;
                            SkipMatchHistory?: string | undefined;
                            TournamentMode?: string | undefined;
                        }>>;
                    }, "strip", zod.ZodTypeAny, {
                        Mode: string;
                        GameRules: {
                            AllowGameModifiers?: boolean | undefined;
                            IsOvertimeWinByTwo?: boolean | undefined;
                            PlayOutAllRounds?: boolean | undefined;
                            SkipMatchHistory?: boolean | undefined;
                            TournamentMode?: boolean | undefined;
                        } | null;
                        Map: string;
                        UseBots: boolean;
                        GamePod: string;
                    }, {
                        Mode: string;
                        GameRules: {
                            AllowGameModifiers?: string | undefined;
                            IsOvertimeWinByTwo?: string | undefined;
                            PlayOutAllRounds?: string | undefined;
                            SkipMatchHistory?: string | undefined;
                            TournamentMode?: string | undefined;
                        } | null;
                        Map: string;
                        UseBots: boolean;
                        GamePod: string;
                    }>;
                    Membership: zod.ZodObject<{
                        teamOne: zod.ZodNullable<zod.ZodArray<zod.ZodObject<{
                            Subject: zod.ZodString;
                        }, "strip", zod.ZodTypeAny, {
                            Subject: string;
                        }, {
                            Subject: string;
                        }>, "many">>;
                        teamTwo: zod.ZodNullable<zod.ZodArray<zod.ZodObject<{
                            Subject: zod.ZodString;
                        }, "strip", zod.ZodTypeAny, {
                            Subject: string;
                        }, {
                            Subject: string;
                        }>, "many">>;
                        teamSpectate: zod.ZodNullable<zod.ZodArray<zod.ZodObject<{
                            Subject: zod.ZodString;
                        }, "strip", zod.ZodTypeAny, {
                            Subject: string;
                        }, {
                            Subject: string;
                        }>, "many">>;
                        teamOneCoaches: zod.ZodNullable<zod.ZodArray<zod.ZodObject<{
                            Subject: zod.ZodString;
                        }, "strip", zod.ZodTypeAny, {
                            Subject: string;
                        }, {
                            Subject: string;
                        }>, "many">>;
                        teamTwoCoaches: zod.ZodNullable<zod.ZodArray<zod.ZodObject<{
                            Subject: zod.ZodString;
                        }, "strip", zod.ZodTypeAny, {
                            Subject: string;
                        }, {
                            Subject: string;
                        }>, "many">>;
                    }, "strip", zod.ZodTypeAny, {
                        teamOne: {
                            Subject: string;
                        }[] | null;
                        teamTwo: {
                            Subject: string;
                        }[] | null;
                        teamSpectate: {
                            Subject: string;
                        }[] | null;
                        teamOneCoaches: {
                            Subject: string;
                        }[] | null;
                        teamTwoCoaches: {
                            Subject: string;
                        }[] | null;
                    }, {
                        teamOne: {
                            Subject: string;
                        }[] | null;
                        teamTwo: {
                            Subject: string;
                        }[] | null;
                        teamSpectate: {
                            Subject: string;
                        }[] | null;
                        teamOneCoaches: {
                            Subject: string;
                        }[] | null;
                        teamTwoCoaches: {
                            Subject: string;
                        }[] | null;
                    }>;
                    MaxPartySize: zod.ZodNumber;
                    AutobalanceEnabled: zod.ZodBoolean;
                    AutobalanceMinPlayers: zod.ZodNumber;
                    HasRecoveryData: zod.ZodBoolean;
                }, "strip", zod.ZodTypeAny, {
                    MaxPartySize: number;
                    Settings: {
                        Mode: string;
                        GameRules: {
                            AllowGameModifiers?: boolean | undefined;
                            IsOvertimeWinByTwo?: boolean | undefined;
                            PlayOutAllRounds?: boolean | undefined;
                            SkipMatchHistory?: boolean | undefined;
                            TournamentMode?: boolean | undefined;
                        } | null;
                        Map: string;
                        UseBots: boolean;
                        GamePod: string;
                    };
                    Membership: {
                        teamOne: {
                            Subject: string;
                        }[] | null;
                        teamTwo: {
                            Subject: string;
                        }[] | null;
                        teamSpectate: {
                            Subject: string;
                        }[] | null;
                        teamOneCoaches: {
                            Subject: string;
                        }[] | null;
                        teamTwoCoaches: {
                            Subject: string;
                        }[] | null;
                    };
                    AutobalanceEnabled: boolean;
                    AutobalanceMinPlayers: number;
                    HasRecoveryData: boolean;
                }, {
                    MaxPartySize: number;
                    Settings: {
                        Mode: string;
                        GameRules: {
                            AllowGameModifiers?: string | undefined;
                            IsOvertimeWinByTwo?: string | undefined;
                            PlayOutAllRounds?: string | undefined;
                            SkipMatchHistory?: string | undefined;
                            TournamentMode?: string | undefined;
                        } | null;
                        Map: string;
                        UseBots: boolean;
                        GamePod: string;
                    };
                    Membership: {
                        teamOne: {
                            Subject: string;
                        }[] | null;
                        teamTwo: {
                            Subject: string;
                        }[] | null;
                        teamSpectate: {
                            Subject: string;
                        }[] | null;
                        teamOneCoaches: {
                            Subject: string;
                        }[] | null;
                        teamTwoCoaches: {
                            Subject: string;
                        }[] | null;
                    };
                    AutobalanceEnabled: boolean;
                    AutobalanceMinPlayers: number;
                    HasRecoveryData: boolean;
                }>;
                MatchmakingData: zod.ZodObject<{
                    QueueID: zod.ZodString;
                    PreferredGamePods: zod.ZodArray<zod.ZodString, "many">;
                    SkillDisparityRRPenalty: zod.ZodNumber;
                }, "strip", zod.ZodTypeAny, {
                    QueueID: string;
                    PreferredGamePods: string[];
                    SkillDisparityRRPenalty: number;
                }, {
                    QueueID: string;
                    PreferredGamePods: string[];
                    SkillDisparityRRPenalty: number;
                }>;
                Invites: zod.ZodNull;
                Requests: zod.ZodArray<zod.ZodUnknown, "many">;
                QueueEntryTime: zod.ZodEffects<zod.ZodString, Date, string>;
                ErrorNotification: zod.ZodObject<{
                    ErrorType: zod.ZodString;
                    ErroredPlayers: zod.ZodNullable<zod.ZodArray<zod.ZodObject<{
                        Subject: zod.ZodString;
                    }, "strip", zod.ZodTypeAny, {
                        Subject: string;
                    }, {
                        Subject: string;
                    }>, "many">>;
                }, "strip", zod.ZodTypeAny, {
                    ErrorType: string;
                    ErroredPlayers: {
                        Subject: string;
                    }[] | null;
                }, {
                    ErrorType: string;
                    ErroredPlayers: {
                        Subject: string;
                    }[] | null;
                }>;
                RestrictedSeconds: zod.ZodNumber;
                EligibleQueues: zod.ZodArray<zod.ZodString, "many">;
                QueueIneligibilities: zod.ZodArray<zod.ZodString, "many">;
                CheatData: zod.ZodObject<{
                    GamePodOverride: zod.ZodString;
                    ForcePostGameProcessing: zod.ZodBoolean;
                }, "strip", zod.ZodTypeAny, {
                    GamePodOverride: string;
                    ForcePostGameProcessing: boolean;
                }, {
                    GamePodOverride: string;
                    ForcePostGameProcessing: boolean;
                }>;
                XPBonuses: zod.ZodArray<zod.ZodUnknown, "many">;
                InviteCode: zod.ZodString;
            }, "strip", zod.ZodTypeAny, {
                ID: string;
                Version: number;
                Invites: null;
                Requests: unknown[];
                State: string;
                MatchmakingData: {
                    QueueID: string;
                    PreferredGamePods: string[];
                    SkillDisparityRRPenalty: number;
                };
                MUCName: string;
                VoiceRoomID: string;
                ClientVersion: string;
                Members: {
                    Subject: string;
                    PlayerIdentity: {
                        Subject: string;
                        PlayerCardID: string;
                        PlayerTitleID: string;
                        AccountLevel: number;
                        PreferredLevelBorderID: string;
                        Incognito: boolean;
                        HideAccountLevel: boolean;
                    };
                    SeasonalBadgeInfo: null;
                    CompetitiveTier: number;
                    QueueEligibleRemainingAccountLevels: number;
                    Pings: {
                        GamePodID: string;
                        Ping: number;
                    }[];
                    IsReady: boolean;
                    IsModerator: boolean;
                    UseBroadcastHUD: boolean;
                    PlatformType: "PC";
                    IsOwner?: boolean | undefined;
                }[];
                PreviousState: string;
                StateTransitionReason: string;
                Accessibility: "OPEN" | "CLOSED";
                CustomGameData: {
                    MaxPartySize: number;
                    Settings: {
                        Mode: string;
                        GameRules: {
                            AllowGameModifiers?: boolean | undefined;
                            IsOvertimeWinByTwo?: boolean | undefined;
                            PlayOutAllRounds?: boolean | undefined;
                            SkipMatchHistory?: boolean | undefined;
                            TournamentMode?: boolean | undefined;
                        } | null;
                        Map: string;
                        UseBots: boolean;
                        GamePod: string;
                    };
                    Membership: {
                        teamOne: {
                            Subject: string;
                        }[] | null;
                        teamTwo: {
                            Subject: string;
                        }[] | null;
                        teamSpectate: {
                            Subject: string;
                        }[] | null;
                        teamOneCoaches: {
                            Subject: string;
                        }[] | null;
                        teamTwoCoaches: {
                            Subject: string;
                        }[] | null;
                    };
                    AutobalanceEnabled: boolean;
                    AutobalanceMinPlayers: number;
                    HasRecoveryData: boolean;
                };
                QueueEntryTime: Date;
                ErrorNotification: {
                    ErrorType: string;
                    ErroredPlayers: {
                        Subject: string;
                    }[] | null;
                };
                RestrictedSeconds: number;
                EligibleQueues: string[];
                QueueIneligibilities: string[];
                CheatData: {
                    GamePodOverride: string;
                    ForcePostGameProcessing: boolean;
                };
                XPBonuses: unknown[];
                InviteCode: string;
            }, {
                ID: string;
                Version: number;
                Invites: null;
                Requests: unknown[];
                State: string;
                MatchmakingData: {
                    QueueID: string;
                    PreferredGamePods: string[];
                    SkillDisparityRRPenalty: number;
                };
                MUCName: string;
                VoiceRoomID: string;
                ClientVersion: string;
                Members: {
                    Subject: string;
                    PlayerIdentity: {
                        Subject: string;
                        PlayerCardID: string;
                        PlayerTitleID: string;
                        AccountLevel: number;
                        PreferredLevelBorderID: string;
                        Incognito: boolean;
                        HideAccountLevel: boolean;
                    };
                    SeasonalBadgeInfo: null;
                    CompetitiveTier: number;
                    QueueEligibleRemainingAccountLevels: number;
                    Pings: {
                        GamePodID: string;
                        Ping: number;
                    }[];
                    IsReady: boolean;
                    IsModerator: boolean;
                    UseBroadcastHUD: boolean;
                    PlatformType: "PC";
                    IsOwner?: boolean | undefined;
                }[];
                PreviousState: string;
                StateTransitionReason: string;
                Accessibility: "OPEN" | "CLOSED";
                CustomGameData: {
                    MaxPartySize: number;
                    Settings: {
                        Mode: string;
                        GameRules: {
                            AllowGameModifiers?: string | undefined;
                            IsOvertimeWinByTwo?: string | undefined;
                            PlayOutAllRounds?: string | undefined;
                            SkipMatchHistory?: string | undefined;
                            TournamentMode?: string | undefined;
                        } | null;
                        Map: string;
                        UseBots: boolean;
                        GamePod: string;
                    };
                    Membership: {
                        teamOne: {
                            Subject: string;
                        }[] | null;
                        teamTwo: {
                            Subject: string;
                        }[] | null;
                        teamSpectate: {
                            Subject: string;
                        }[] | null;
                        teamOneCoaches: {
                            Subject: string;
                        }[] | null;
                        teamTwoCoaches: {
                            Subject: string;
                        }[] | null;
                    };
                    AutobalanceEnabled: boolean;
                    AutobalanceMinPlayers: number;
                    HasRecoveryData: boolean;
                };
                QueueEntryTime: string;
                ErrorNotification: {
                    ErrorType: string;
                    ErroredPlayers: {
                        Subject: string;
                    }[] | null;
                };
                RestrictedSeconds: number;
                EligibleQueues: string[];
                QueueIneligibilities: string[];
                CheatData: {
                    GamePodOverride: string;
                    ForcePostGameProcessing: boolean;
                };
                XPBonuses: unknown[];
                InviteCode: string;
            }>;
        };
    };
};

type Params$j = ResolveParams<(typeof _default$j)["~type"]["url"]>;
type Body$j = z.infer<ResolveValue<(typeof _default$j)["~type"], "body">>;
type Data$j = ResolveData<Params$j, Body$j>;
type Response$j = z.infer<ResolveValue<(typeof _default$j)["~type"], "responses">["200"]>;
interface PartyGenerateCodeRequestConfig extends ValorantAxiosRequestConfig<Data$j> {
}
declare class PartyGenerateCodeEndpoint {
    /**
     * Generate a party invite code
     *
     * @EndpointType glz
     */
    postPartyGenerateCode<T = Response$j>(this: RemoteApiClient, config: PartyGenerateCodeRequestConfig): Promise<AxiosResponse<T>>;
}

declare const _default$i: Omit<{
    requirements: string[];
    type: "auth" | "local" | "pd" | "glz" | "shared";
    name: string;
    method: "PUT" | "GET" | "DELETE" | "POST";
    url: string;
    description?: string | undefined;
    headers?: Record<string, string> | undefined;
    body?: zod.ZodType<any, zod.ZodTypeDef, any> | undefined;
    query?: zod.ZodType<any, zod.ZodTypeDef, any> | undefined;
    responses?: Record<string, zod.ZodType<any, zod.ZodTypeDef, any>> | undefined;
}, "type" | "name" | "url"> & Pick<{
    readonly name: "Party Invite";
    readonly description: "Invite a player to the party by name and tagline";
    readonly type: "glz";
    readonly method: "POST";
    readonly url: "parties/v1/parties/:partyId/invites/name/:name/tag/:tagline";
    readonly responses: {
        readonly "200": zod.ZodObject<{
            ID: zod.ZodString;
            MUCName: zod.ZodString;
            VoiceRoomID: zod.ZodString;
            Version: zod.ZodNumber;
            ClientVersion: zod.ZodString;
            Members: zod.ZodArray<zod.ZodObject<{
                Subject: zod.ZodString;
                CompetitiveTier: zod.ZodNumber;
                PlayerIdentity: zod.ZodObject<{
                    Subject: zod.ZodString;
                    PlayerCardID: zod.ZodString;
                    PlayerTitleID: zod.ZodString;
                    AccountLevel: zod.ZodNumber;
                    PreferredLevelBorderID: zod.ZodUnion<[zod.ZodString, zod.ZodLiteral<"">]>;
                    Incognito: zod.ZodBoolean;
                    HideAccountLevel: zod.ZodBoolean;
                }, "strip", zod.ZodTypeAny, {
                    Subject: string;
                    PlayerCardID: string;
                    PlayerTitleID: string;
                    AccountLevel: number;
                    PreferredLevelBorderID: string;
                    Incognito: boolean;
                    HideAccountLevel: boolean;
                }, {
                    Subject: string;
                    PlayerCardID: string;
                    PlayerTitleID: string;
                    AccountLevel: number;
                    PreferredLevelBorderID: string;
                    Incognito: boolean;
                    HideAccountLevel: boolean;
                }>;
                SeasonalBadgeInfo: zod.ZodNull;
                IsOwner: zod.ZodOptional<zod.ZodBoolean>;
                QueueEligibleRemainingAccountLevels: zod.ZodNumber;
                Pings: zod.ZodArray<zod.ZodObject<{
                    Ping: zod.ZodNumber;
                    GamePodID: zod.ZodString;
                }, "strip", zod.ZodTypeAny, {
                    GamePodID: string;
                    Ping: number;
                }, {
                    GamePodID: string;
                    Ping: number;
                }>, "many">;
                IsReady: zod.ZodBoolean;
                IsModerator: zod.ZodBoolean;
                UseBroadcastHUD: zod.ZodBoolean;
                PlatformType: zod.ZodLiteral<"PC">;
            }, "strip", zod.ZodTypeAny, {
                Subject: string;
                PlayerIdentity: {
                    Subject: string;
                    PlayerCardID: string;
                    PlayerTitleID: string;
                    AccountLevel: number;
                    PreferredLevelBorderID: string;
                    Incognito: boolean;
                    HideAccountLevel: boolean;
                };
                SeasonalBadgeInfo: null;
                CompetitiveTier: number;
                QueueEligibleRemainingAccountLevels: number;
                Pings: {
                    GamePodID: string;
                    Ping: number;
                }[];
                IsReady: boolean;
                IsModerator: boolean;
                UseBroadcastHUD: boolean;
                PlatformType: "PC";
                IsOwner?: boolean | undefined;
            }, {
                Subject: string;
                PlayerIdentity: {
                    Subject: string;
                    PlayerCardID: string;
                    PlayerTitleID: string;
                    AccountLevel: number;
                    PreferredLevelBorderID: string;
                    Incognito: boolean;
                    HideAccountLevel: boolean;
                };
                SeasonalBadgeInfo: null;
                CompetitiveTier: number;
                QueueEligibleRemainingAccountLevels: number;
                Pings: {
                    GamePodID: string;
                    Ping: number;
                }[];
                IsReady: boolean;
                IsModerator: boolean;
                UseBroadcastHUD: boolean;
                PlatformType: "PC";
                IsOwner?: boolean | undefined;
            }>, "many">;
            State: zod.ZodString;
            PreviousState: zod.ZodString;
            StateTransitionReason: zod.ZodString;
            Accessibility: zod.ZodUnion<[zod.ZodLiteral<"OPEN">, zod.ZodLiteral<"CLOSED">]>;
            CustomGameData: zod.ZodObject<{
                Settings: zod.ZodObject<{
                    Map: zod.ZodString;
                    Mode: zod.ZodString;
                    UseBots: zod.ZodBoolean;
                    GamePod: zod.ZodString;
                    GameRules: zod.ZodNullable<zod.ZodObject<{
                        AllowGameModifiers: zod.ZodOptional<zod.ZodEffects<zod.ZodString, boolean, string>>;
                        IsOvertimeWinByTwo: zod.ZodOptional<zod.ZodEffects<zod.ZodString, boolean, string>>;
                        PlayOutAllRounds: zod.ZodOptional<zod.ZodEffects<zod.ZodString, boolean, string>>;
                        SkipMatchHistory: zod.ZodOptional<zod.ZodEffects<zod.ZodString, boolean, string>>;
                        TournamentMode: zod.ZodOptional<zod.ZodEffects<zod.ZodString, boolean, string>>;
                    }, "strip", zod.ZodTypeAny, {
                        AllowGameModifiers?: boolean | undefined;
                        IsOvertimeWinByTwo?: boolean | undefined;
                        PlayOutAllRounds?: boolean | undefined;
                        SkipMatchHistory?: boolean | undefined;
                        TournamentMode?: boolean | undefined;
                    }, {
                        AllowGameModifiers?: string | undefined;
                        IsOvertimeWinByTwo?: string | undefined;
                        PlayOutAllRounds?: string | undefined;
                        SkipMatchHistory?: string | undefined;
                        TournamentMode?: string | undefined;
                    }>>;
                }, "strip", zod.ZodTypeAny, {
                    Mode: string;
                    GameRules: {
                        AllowGameModifiers?: boolean | undefined;
                        IsOvertimeWinByTwo?: boolean | undefined;
                        PlayOutAllRounds?: boolean | undefined;
                        SkipMatchHistory?: boolean | undefined;
                        TournamentMode?: boolean | undefined;
                    } | null;
                    Map: string;
                    UseBots: boolean;
                    GamePod: string;
                }, {
                    Mode: string;
                    GameRules: {
                        AllowGameModifiers?: string | undefined;
                        IsOvertimeWinByTwo?: string | undefined;
                        PlayOutAllRounds?: string | undefined;
                        SkipMatchHistory?: string | undefined;
                        TournamentMode?: string | undefined;
                    } | null;
                    Map: string;
                    UseBots: boolean;
                    GamePod: string;
                }>;
                Membership: zod.ZodObject<{
                    teamOne: zod.ZodNullable<zod.ZodArray<zod.ZodObject<{
                        Subject: zod.ZodString;
                    }, "strip", zod.ZodTypeAny, {
                        Subject: string;
                    }, {
                        Subject: string;
                    }>, "many">>;
                    teamTwo: zod.ZodNullable<zod.ZodArray<zod.ZodObject<{
                        Subject: zod.ZodString;
                    }, "strip", zod.ZodTypeAny, {
                        Subject: string;
                    }, {
                        Subject: string;
                    }>, "many">>;
                    teamSpectate: zod.ZodNullable<zod.ZodArray<zod.ZodObject<{
                        Subject: zod.ZodString;
                    }, "strip", zod.ZodTypeAny, {
                        Subject: string;
                    }, {
                        Subject: string;
                    }>, "many">>;
                    teamOneCoaches: zod.ZodNullable<zod.ZodArray<zod.ZodObject<{
                        Subject: zod.ZodString;
                    }, "strip", zod.ZodTypeAny, {
                        Subject: string;
                    }, {
                        Subject: string;
                    }>, "many">>;
                    teamTwoCoaches: zod.ZodNullable<zod.ZodArray<zod.ZodObject<{
                        Subject: zod.ZodString;
                    }, "strip", zod.ZodTypeAny, {
                        Subject: string;
                    }, {
                        Subject: string;
                    }>, "many">>;
                }, "strip", zod.ZodTypeAny, {
                    teamOne: {
                        Subject: string;
                    }[] | null;
                    teamTwo: {
                        Subject: string;
                    }[] | null;
                    teamSpectate: {
                        Subject: string;
                    }[] | null;
                    teamOneCoaches: {
                        Subject: string;
                    }[] | null;
                    teamTwoCoaches: {
                        Subject: string;
                    }[] | null;
                }, {
                    teamOne: {
                        Subject: string;
                    }[] | null;
                    teamTwo: {
                        Subject: string;
                    }[] | null;
                    teamSpectate: {
                        Subject: string;
                    }[] | null;
                    teamOneCoaches: {
                        Subject: string;
                    }[] | null;
                    teamTwoCoaches: {
                        Subject: string;
                    }[] | null;
                }>;
                MaxPartySize: zod.ZodNumber;
                AutobalanceEnabled: zod.ZodBoolean;
                AutobalanceMinPlayers: zod.ZodNumber;
                HasRecoveryData: zod.ZodBoolean;
            }, "strip", zod.ZodTypeAny, {
                MaxPartySize: number;
                Settings: {
                    Mode: string;
                    GameRules: {
                        AllowGameModifiers?: boolean | undefined;
                        IsOvertimeWinByTwo?: boolean | undefined;
                        PlayOutAllRounds?: boolean | undefined;
                        SkipMatchHistory?: boolean | undefined;
                        TournamentMode?: boolean | undefined;
                    } | null;
                    Map: string;
                    UseBots: boolean;
                    GamePod: string;
                };
                Membership: {
                    teamOne: {
                        Subject: string;
                    }[] | null;
                    teamTwo: {
                        Subject: string;
                    }[] | null;
                    teamSpectate: {
                        Subject: string;
                    }[] | null;
                    teamOneCoaches: {
                        Subject: string;
                    }[] | null;
                    teamTwoCoaches: {
                        Subject: string;
                    }[] | null;
                };
                AutobalanceEnabled: boolean;
                AutobalanceMinPlayers: number;
                HasRecoveryData: boolean;
            }, {
                MaxPartySize: number;
                Settings: {
                    Mode: string;
                    GameRules: {
                        AllowGameModifiers?: string | undefined;
                        IsOvertimeWinByTwo?: string | undefined;
                        PlayOutAllRounds?: string | undefined;
                        SkipMatchHistory?: string | undefined;
                        TournamentMode?: string | undefined;
                    } | null;
                    Map: string;
                    UseBots: boolean;
                    GamePod: string;
                };
                Membership: {
                    teamOne: {
                        Subject: string;
                    }[] | null;
                    teamTwo: {
                        Subject: string;
                    }[] | null;
                    teamSpectate: {
                        Subject: string;
                    }[] | null;
                    teamOneCoaches: {
                        Subject: string;
                    }[] | null;
                    teamTwoCoaches: {
                        Subject: string;
                    }[] | null;
                };
                AutobalanceEnabled: boolean;
                AutobalanceMinPlayers: number;
                HasRecoveryData: boolean;
            }>;
            MatchmakingData: zod.ZodObject<{
                QueueID: zod.ZodString;
                PreferredGamePods: zod.ZodArray<zod.ZodString, "many">;
                SkillDisparityRRPenalty: zod.ZodNumber;
            }, "strip", zod.ZodTypeAny, {
                QueueID: string;
                PreferredGamePods: string[];
                SkillDisparityRRPenalty: number;
            }, {
                QueueID: string;
                PreferredGamePods: string[];
                SkillDisparityRRPenalty: number;
            }>;
            Invites: zod.ZodNull;
            Requests: zod.ZodArray<zod.ZodUnknown, "many">;
            QueueEntryTime: zod.ZodEffects<zod.ZodString, Date, string>;
            ErrorNotification: zod.ZodObject<{
                ErrorType: zod.ZodString;
                ErroredPlayers: zod.ZodNullable<zod.ZodArray<zod.ZodObject<{
                    Subject: zod.ZodString;
                }, "strip", zod.ZodTypeAny, {
                    Subject: string;
                }, {
                    Subject: string;
                }>, "many">>;
            }, "strip", zod.ZodTypeAny, {
                ErrorType: string;
                ErroredPlayers: {
                    Subject: string;
                }[] | null;
            }, {
                ErrorType: string;
                ErroredPlayers: {
                    Subject: string;
                }[] | null;
            }>;
            RestrictedSeconds: zod.ZodNumber;
            EligibleQueues: zod.ZodArray<zod.ZodString, "many">;
            QueueIneligibilities: zod.ZodArray<zod.ZodString, "many">;
            CheatData: zod.ZodObject<{
                GamePodOverride: zod.ZodString;
                ForcePostGameProcessing: zod.ZodBoolean;
            }, "strip", zod.ZodTypeAny, {
                GamePodOverride: string;
                ForcePostGameProcessing: boolean;
            }, {
                GamePodOverride: string;
                ForcePostGameProcessing: boolean;
            }>;
            XPBonuses: zod.ZodArray<zod.ZodUnknown, "many">;
            InviteCode: zod.ZodString;
        }, "strip", zod.ZodTypeAny, {
            ID: string;
            Version: number;
            Invites: null;
            Requests: unknown[];
            State: string;
            MatchmakingData: {
                QueueID: string;
                PreferredGamePods: string[];
                SkillDisparityRRPenalty: number;
            };
            MUCName: string;
            VoiceRoomID: string;
            ClientVersion: string;
            Members: {
                Subject: string;
                PlayerIdentity: {
                    Subject: string;
                    PlayerCardID: string;
                    PlayerTitleID: string;
                    AccountLevel: number;
                    PreferredLevelBorderID: string;
                    Incognito: boolean;
                    HideAccountLevel: boolean;
                };
                SeasonalBadgeInfo: null;
                CompetitiveTier: number;
                QueueEligibleRemainingAccountLevels: number;
                Pings: {
                    GamePodID: string;
                    Ping: number;
                }[];
                IsReady: boolean;
                IsModerator: boolean;
                UseBroadcastHUD: boolean;
                PlatformType: "PC";
                IsOwner?: boolean | undefined;
            }[];
            PreviousState: string;
            StateTransitionReason: string;
            Accessibility: "OPEN" | "CLOSED";
            CustomGameData: {
                MaxPartySize: number;
                Settings: {
                    Mode: string;
                    GameRules: {
                        AllowGameModifiers?: boolean | undefined;
                        IsOvertimeWinByTwo?: boolean | undefined;
                        PlayOutAllRounds?: boolean | undefined;
                        SkipMatchHistory?: boolean | undefined;
                        TournamentMode?: boolean | undefined;
                    } | null;
                    Map: string;
                    UseBots: boolean;
                    GamePod: string;
                };
                Membership: {
                    teamOne: {
                        Subject: string;
                    }[] | null;
                    teamTwo: {
                        Subject: string;
                    }[] | null;
                    teamSpectate: {
                        Subject: string;
                    }[] | null;
                    teamOneCoaches: {
                        Subject: string;
                    }[] | null;
                    teamTwoCoaches: {
                        Subject: string;
                    }[] | null;
                };
                AutobalanceEnabled: boolean;
                AutobalanceMinPlayers: number;
                HasRecoveryData: boolean;
            };
            QueueEntryTime: Date;
            ErrorNotification: {
                ErrorType: string;
                ErroredPlayers: {
                    Subject: string;
                }[] | null;
            };
            RestrictedSeconds: number;
            EligibleQueues: string[];
            QueueIneligibilities: string[];
            CheatData: {
                GamePodOverride: string;
                ForcePostGameProcessing: boolean;
            };
            XPBonuses: unknown[];
            InviteCode: string;
        }, {
            ID: string;
            Version: number;
            Invites: null;
            Requests: unknown[];
            State: string;
            MatchmakingData: {
                QueueID: string;
                PreferredGamePods: string[];
                SkillDisparityRRPenalty: number;
            };
            MUCName: string;
            VoiceRoomID: string;
            ClientVersion: string;
            Members: {
                Subject: string;
                PlayerIdentity: {
                    Subject: string;
                    PlayerCardID: string;
                    PlayerTitleID: string;
                    AccountLevel: number;
                    PreferredLevelBorderID: string;
                    Incognito: boolean;
                    HideAccountLevel: boolean;
                };
                SeasonalBadgeInfo: null;
                CompetitiveTier: number;
                QueueEligibleRemainingAccountLevels: number;
                Pings: {
                    GamePodID: string;
                    Ping: number;
                }[];
                IsReady: boolean;
                IsModerator: boolean;
                UseBroadcastHUD: boolean;
                PlatformType: "PC";
                IsOwner?: boolean | undefined;
            }[];
            PreviousState: string;
            StateTransitionReason: string;
            Accessibility: "OPEN" | "CLOSED";
            CustomGameData: {
                MaxPartySize: number;
                Settings: {
                    Mode: string;
                    GameRules: {
                        AllowGameModifiers?: string | undefined;
                        IsOvertimeWinByTwo?: string | undefined;
                        PlayOutAllRounds?: string | undefined;
                        SkipMatchHistory?: string | undefined;
                        TournamentMode?: string | undefined;
                    } | null;
                    Map: string;
                    UseBots: boolean;
                    GamePod: string;
                };
                Membership: {
                    teamOne: {
                        Subject: string;
                    }[] | null;
                    teamTwo: {
                        Subject: string;
                    }[] | null;
                    teamSpectate: {
                        Subject: string;
                    }[] | null;
                    teamOneCoaches: {
                        Subject: string;
                    }[] | null;
                    teamTwoCoaches: {
                        Subject: string;
                    }[] | null;
                };
                AutobalanceEnabled: boolean;
                AutobalanceMinPlayers: number;
                HasRecoveryData: boolean;
            };
            QueueEntryTime: string;
            ErrorNotification: {
                ErrorType: string;
                ErroredPlayers: {
                    Subject: string;
                }[] | null;
            };
            RestrictedSeconds: number;
            EligibleQueues: string[];
            QueueIneligibilities: string[];
            CheatData: {
                GamePodOverride: string;
                ForcePostGameProcessing: boolean;
            };
            XPBonuses: unknown[];
            InviteCode: string;
        }>;
    };
}, "type" | "name" | "url"> & {
    "~type": {
        readonly name: "Party Invite";
        readonly description: "Invite a player to the party by name and tagline";
        readonly type: "glz";
        readonly method: "POST";
        readonly url: "parties/v1/parties/:partyId/invites/name/:name/tag/:tagline";
        readonly responses: {
            readonly "200": zod.ZodObject<{
                ID: zod.ZodString;
                MUCName: zod.ZodString;
                VoiceRoomID: zod.ZodString;
                Version: zod.ZodNumber;
                ClientVersion: zod.ZodString;
                Members: zod.ZodArray<zod.ZodObject<{
                    Subject: zod.ZodString;
                    CompetitiveTier: zod.ZodNumber;
                    PlayerIdentity: zod.ZodObject<{
                        Subject: zod.ZodString;
                        PlayerCardID: zod.ZodString;
                        PlayerTitleID: zod.ZodString;
                        AccountLevel: zod.ZodNumber;
                        PreferredLevelBorderID: zod.ZodUnion<[zod.ZodString, zod.ZodLiteral<"">]>;
                        Incognito: zod.ZodBoolean;
                        HideAccountLevel: zod.ZodBoolean;
                    }, "strip", zod.ZodTypeAny, {
                        Subject: string;
                        PlayerCardID: string;
                        PlayerTitleID: string;
                        AccountLevel: number;
                        PreferredLevelBorderID: string;
                        Incognito: boolean;
                        HideAccountLevel: boolean;
                    }, {
                        Subject: string;
                        PlayerCardID: string;
                        PlayerTitleID: string;
                        AccountLevel: number;
                        PreferredLevelBorderID: string;
                        Incognito: boolean;
                        HideAccountLevel: boolean;
                    }>;
                    SeasonalBadgeInfo: zod.ZodNull;
                    IsOwner: zod.ZodOptional<zod.ZodBoolean>;
                    QueueEligibleRemainingAccountLevels: zod.ZodNumber;
                    Pings: zod.ZodArray<zod.ZodObject<{
                        Ping: zod.ZodNumber;
                        GamePodID: zod.ZodString;
                    }, "strip", zod.ZodTypeAny, {
                        GamePodID: string;
                        Ping: number;
                    }, {
                        GamePodID: string;
                        Ping: number;
                    }>, "many">;
                    IsReady: zod.ZodBoolean;
                    IsModerator: zod.ZodBoolean;
                    UseBroadcastHUD: zod.ZodBoolean;
                    PlatformType: zod.ZodLiteral<"PC">;
                }, "strip", zod.ZodTypeAny, {
                    Subject: string;
                    PlayerIdentity: {
                        Subject: string;
                        PlayerCardID: string;
                        PlayerTitleID: string;
                        AccountLevel: number;
                        PreferredLevelBorderID: string;
                        Incognito: boolean;
                        HideAccountLevel: boolean;
                    };
                    SeasonalBadgeInfo: null;
                    CompetitiveTier: number;
                    QueueEligibleRemainingAccountLevels: number;
                    Pings: {
                        GamePodID: string;
                        Ping: number;
                    }[];
                    IsReady: boolean;
                    IsModerator: boolean;
                    UseBroadcastHUD: boolean;
                    PlatformType: "PC";
                    IsOwner?: boolean | undefined;
                }, {
                    Subject: string;
                    PlayerIdentity: {
                        Subject: string;
                        PlayerCardID: string;
                        PlayerTitleID: string;
                        AccountLevel: number;
                        PreferredLevelBorderID: string;
                        Incognito: boolean;
                        HideAccountLevel: boolean;
                    };
                    SeasonalBadgeInfo: null;
                    CompetitiveTier: number;
                    QueueEligibleRemainingAccountLevels: number;
                    Pings: {
                        GamePodID: string;
                        Ping: number;
                    }[];
                    IsReady: boolean;
                    IsModerator: boolean;
                    UseBroadcastHUD: boolean;
                    PlatformType: "PC";
                    IsOwner?: boolean | undefined;
                }>, "many">;
                State: zod.ZodString;
                PreviousState: zod.ZodString;
                StateTransitionReason: zod.ZodString;
                Accessibility: zod.ZodUnion<[zod.ZodLiteral<"OPEN">, zod.ZodLiteral<"CLOSED">]>;
                CustomGameData: zod.ZodObject<{
                    Settings: zod.ZodObject<{
                        Map: zod.ZodString;
                        Mode: zod.ZodString;
                        UseBots: zod.ZodBoolean;
                        GamePod: zod.ZodString;
                        GameRules: zod.ZodNullable<zod.ZodObject<{
                            AllowGameModifiers: zod.ZodOptional<zod.ZodEffects<zod.ZodString, boolean, string>>;
                            IsOvertimeWinByTwo: zod.ZodOptional<zod.ZodEffects<zod.ZodString, boolean, string>>;
                            PlayOutAllRounds: zod.ZodOptional<zod.ZodEffects<zod.ZodString, boolean, string>>;
                            SkipMatchHistory: zod.ZodOptional<zod.ZodEffects<zod.ZodString, boolean, string>>;
                            TournamentMode: zod.ZodOptional<zod.ZodEffects<zod.ZodString, boolean, string>>;
                        }, "strip", zod.ZodTypeAny, {
                            AllowGameModifiers?: boolean | undefined;
                            IsOvertimeWinByTwo?: boolean | undefined;
                            PlayOutAllRounds?: boolean | undefined;
                            SkipMatchHistory?: boolean | undefined;
                            TournamentMode?: boolean | undefined;
                        }, {
                            AllowGameModifiers?: string | undefined;
                            IsOvertimeWinByTwo?: string | undefined;
                            PlayOutAllRounds?: string | undefined;
                            SkipMatchHistory?: string | undefined;
                            TournamentMode?: string | undefined;
                        }>>;
                    }, "strip", zod.ZodTypeAny, {
                        Mode: string;
                        GameRules: {
                            AllowGameModifiers?: boolean | undefined;
                            IsOvertimeWinByTwo?: boolean | undefined;
                            PlayOutAllRounds?: boolean | undefined;
                            SkipMatchHistory?: boolean | undefined;
                            TournamentMode?: boolean | undefined;
                        } | null;
                        Map: string;
                        UseBots: boolean;
                        GamePod: string;
                    }, {
                        Mode: string;
                        GameRules: {
                            AllowGameModifiers?: string | undefined;
                            IsOvertimeWinByTwo?: string | undefined;
                            PlayOutAllRounds?: string | undefined;
                            SkipMatchHistory?: string | undefined;
                            TournamentMode?: string | undefined;
                        } | null;
                        Map: string;
                        UseBots: boolean;
                        GamePod: string;
                    }>;
                    Membership: zod.ZodObject<{
                        teamOne: zod.ZodNullable<zod.ZodArray<zod.ZodObject<{
                            Subject: zod.ZodString;
                        }, "strip", zod.ZodTypeAny, {
                            Subject: string;
                        }, {
                            Subject: string;
                        }>, "many">>;
                        teamTwo: zod.ZodNullable<zod.ZodArray<zod.ZodObject<{
                            Subject: zod.ZodString;
                        }, "strip", zod.ZodTypeAny, {
                            Subject: string;
                        }, {
                            Subject: string;
                        }>, "many">>;
                        teamSpectate: zod.ZodNullable<zod.ZodArray<zod.ZodObject<{
                            Subject: zod.ZodString;
                        }, "strip", zod.ZodTypeAny, {
                            Subject: string;
                        }, {
                            Subject: string;
                        }>, "many">>;
                        teamOneCoaches: zod.ZodNullable<zod.ZodArray<zod.ZodObject<{
                            Subject: zod.ZodString;
                        }, "strip", zod.ZodTypeAny, {
                            Subject: string;
                        }, {
                            Subject: string;
                        }>, "many">>;
                        teamTwoCoaches: zod.ZodNullable<zod.ZodArray<zod.ZodObject<{
                            Subject: zod.ZodString;
                        }, "strip", zod.ZodTypeAny, {
                            Subject: string;
                        }, {
                            Subject: string;
                        }>, "many">>;
                    }, "strip", zod.ZodTypeAny, {
                        teamOne: {
                            Subject: string;
                        }[] | null;
                        teamTwo: {
                            Subject: string;
                        }[] | null;
                        teamSpectate: {
                            Subject: string;
                        }[] | null;
                        teamOneCoaches: {
                            Subject: string;
                        }[] | null;
                        teamTwoCoaches: {
                            Subject: string;
                        }[] | null;
                    }, {
                        teamOne: {
                            Subject: string;
                        }[] | null;
                        teamTwo: {
                            Subject: string;
                        }[] | null;
                        teamSpectate: {
                            Subject: string;
                        }[] | null;
                        teamOneCoaches: {
                            Subject: string;
                        }[] | null;
                        teamTwoCoaches: {
                            Subject: string;
                        }[] | null;
                    }>;
                    MaxPartySize: zod.ZodNumber;
                    AutobalanceEnabled: zod.ZodBoolean;
                    AutobalanceMinPlayers: zod.ZodNumber;
                    HasRecoveryData: zod.ZodBoolean;
                }, "strip", zod.ZodTypeAny, {
                    MaxPartySize: number;
                    Settings: {
                        Mode: string;
                        GameRules: {
                            AllowGameModifiers?: boolean | undefined;
                            IsOvertimeWinByTwo?: boolean | undefined;
                            PlayOutAllRounds?: boolean | undefined;
                            SkipMatchHistory?: boolean | undefined;
                            TournamentMode?: boolean | undefined;
                        } | null;
                        Map: string;
                        UseBots: boolean;
                        GamePod: string;
                    };
                    Membership: {
                        teamOne: {
                            Subject: string;
                        }[] | null;
                        teamTwo: {
                            Subject: string;
                        }[] | null;
                        teamSpectate: {
                            Subject: string;
                        }[] | null;
                        teamOneCoaches: {
                            Subject: string;
                        }[] | null;
                        teamTwoCoaches: {
                            Subject: string;
                        }[] | null;
                    };
                    AutobalanceEnabled: boolean;
                    AutobalanceMinPlayers: number;
                    HasRecoveryData: boolean;
                }, {
                    MaxPartySize: number;
                    Settings: {
                        Mode: string;
                        GameRules: {
                            AllowGameModifiers?: string | undefined;
                            IsOvertimeWinByTwo?: string | undefined;
                            PlayOutAllRounds?: string | undefined;
                            SkipMatchHistory?: string | undefined;
                            TournamentMode?: string | undefined;
                        } | null;
                        Map: string;
                        UseBots: boolean;
                        GamePod: string;
                    };
                    Membership: {
                        teamOne: {
                            Subject: string;
                        }[] | null;
                        teamTwo: {
                            Subject: string;
                        }[] | null;
                        teamSpectate: {
                            Subject: string;
                        }[] | null;
                        teamOneCoaches: {
                            Subject: string;
                        }[] | null;
                        teamTwoCoaches: {
                            Subject: string;
                        }[] | null;
                    };
                    AutobalanceEnabled: boolean;
                    AutobalanceMinPlayers: number;
                    HasRecoveryData: boolean;
                }>;
                MatchmakingData: zod.ZodObject<{
                    QueueID: zod.ZodString;
                    PreferredGamePods: zod.ZodArray<zod.ZodString, "many">;
                    SkillDisparityRRPenalty: zod.ZodNumber;
                }, "strip", zod.ZodTypeAny, {
                    QueueID: string;
                    PreferredGamePods: string[];
                    SkillDisparityRRPenalty: number;
                }, {
                    QueueID: string;
                    PreferredGamePods: string[];
                    SkillDisparityRRPenalty: number;
                }>;
                Invites: zod.ZodNull;
                Requests: zod.ZodArray<zod.ZodUnknown, "many">;
                QueueEntryTime: zod.ZodEffects<zod.ZodString, Date, string>;
                ErrorNotification: zod.ZodObject<{
                    ErrorType: zod.ZodString;
                    ErroredPlayers: zod.ZodNullable<zod.ZodArray<zod.ZodObject<{
                        Subject: zod.ZodString;
                    }, "strip", zod.ZodTypeAny, {
                        Subject: string;
                    }, {
                        Subject: string;
                    }>, "many">>;
                }, "strip", zod.ZodTypeAny, {
                    ErrorType: string;
                    ErroredPlayers: {
                        Subject: string;
                    }[] | null;
                }, {
                    ErrorType: string;
                    ErroredPlayers: {
                        Subject: string;
                    }[] | null;
                }>;
                RestrictedSeconds: zod.ZodNumber;
                EligibleQueues: zod.ZodArray<zod.ZodString, "many">;
                QueueIneligibilities: zod.ZodArray<zod.ZodString, "many">;
                CheatData: zod.ZodObject<{
                    GamePodOverride: zod.ZodString;
                    ForcePostGameProcessing: zod.ZodBoolean;
                }, "strip", zod.ZodTypeAny, {
                    GamePodOverride: string;
                    ForcePostGameProcessing: boolean;
                }, {
                    GamePodOverride: string;
                    ForcePostGameProcessing: boolean;
                }>;
                XPBonuses: zod.ZodArray<zod.ZodUnknown, "many">;
                InviteCode: zod.ZodString;
            }, "strip", zod.ZodTypeAny, {
                ID: string;
                Version: number;
                Invites: null;
                Requests: unknown[];
                State: string;
                MatchmakingData: {
                    QueueID: string;
                    PreferredGamePods: string[];
                    SkillDisparityRRPenalty: number;
                };
                MUCName: string;
                VoiceRoomID: string;
                ClientVersion: string;
                Members: {
                    Subject: string;
                    PlayerIdentity: {
                        Subject: string;
                        PlayerCardID: string;
                        PlayerTitleID: string;
                        AccountLevel: number;
                        PreferredLevelBorderID: string;
                        Incognito: boolean;
                        HideAccountLevel: boolean;
                    };
                    SeasonalBadgeInfo: null;
                    CompetitiveTier: number;
                    QueueEligibleRemainingAccountLevels: number;
                    Pings: {
                        GamePodID: string;
                        Ping: number;
                    }[];
                    IsReady: boolean;
                    IsModerator: boolean;
                    UseBroadcastHUD: boolean;
                    PlatformType: "PC";
                    IsOwner?: boolean | undefined;
                }[];
                PreviousState: string;
                StateTransitionReason: string;
                Accessibility: "OPEN" | "CLOSED";
                CustomGameData: {
                    MaxPartySize: number;
                    Settings: {
                        Mode: string;
                        GameRules: {
                            AllowGameModifiers?: boolean | undefined;
                            IsOvertimeWinByTwo?: boolean | undefined;
                            PlayOutAllRounds?: boolean | undefined;
                            SkipMatchHistory?: boolean | undefined;
                            TournamentMode?: boolean | undefined;
                        } | null;
                        Map: string;
                        UseBots: boolean;
                        GamePod: string;
                    };
                    Membership: {
                        teamOne: {
                            Subject: string;
                        }[] | null;
                        teamTwo: {
                            Subject: string;
                        }[] | null;
                        teamSpectate: {
                            Subject: string;
                        }[] | null;
                        teamOneCoaches: {
                            Subject: string;
                        }[] | null;
                        teamTwoCoaches: {
                            Subject: string;
                        }[] | null;
                    };
                    AutobalanceEnabled: boolean;
                    AutobalanceMinPlayers: number;
                    HasRecoveryData: boolean;
                };
                QueueEntryTime: Date;
                ErrorNotification: {
                    ErrorType: string;
                    ErroredPlayers: {
                        Subject: string;
                    }[] | null;
                };
                RestrictedSeconds: number;
                EligibleQueues: string[];
                QueueIneligibilities: string[];
                CheatData: {
                    GamePodOverride: string;
                    ForcePostGameProcessing: boolean;
                };
                XPBonuses: unknown[];
                InviteCode: string;
            }, {
                ID: string;
                Version: number;
                Invites: null;
                Requests: unknown[];
                State: string;
                MatchmakingData: {
                    QueueID: string;
                    PreferredGamePods: string[];
                    SkillDisparityRRPenalty: number;
                };
                MUCName: string;
                VoiceRoomID: string;
                ClientVersion: string;
                Members: {
                    Subject: string;
                    PlayerIdentity: {
                        Subject: string;
                        PlayerCardID: string;
                        PlayerTitleID: string;
                        AccountLevel: number;
                        PreferredLevelBorderID: string;
                        Incognito: boolean;
                        HideAccountLevel: boolean;
                    };
                    SeasonalBadgeInfo: null;
                    CompetitiveTier: number;
                    QueueEligibleRemainingAccountLevels: number;
                    Pings: {
                        GamePodID: string;
                        Ping: number;
                    }[];
                    IsReady: boolean;
                    IsModerator: boolean;
                    UseBroadcastHUD: boolean;
                    PlatformType: "PC";
                    IsOwner?: boolean | undefined;
                }[];
                PreviousState: string;
                StateTransitionReason: string;
                Accessibility: "OPEN" | "CLOSED";
                CustomGameData: {
                    MaxPartySize: number;
                    Settings: {
                        Mode: string;
                        GameRules: {
                            AllowGameModifiers?: string | undefined;
                            IsOvertimeWinByTwo?: string | undefined;
                            PlayOutAllRounds?: string | undefined;
                            SkipMatchHistory?: string | undefined;
                            TournamentMode?: string | undefined;
                        } | null;
                        Map: string;
                        UseBots: boolean;
                        GamePod: string;
                    };
                    Membership: {
                        teamOne: {
                            Subject: string;
                        }[] | null;
                        teamTwo: {
                            Subject: string;
                        }[] | null;
                        teamSpectate: {
                            Subject: string;
                        }[] | null;
                        teamOneCoaches: {
                            Subject: string;
                        }[] | null;
                        teamTwoCoaches: {
                            Subject: string;
                        }[] | null;
                    };
                    AutobalanceEnabled: boolean;
                    AutobalanceMinPlayers: number;
                    HasRecoveryData: boolean;
                };
                QueueEntryTime: string;
                ErrorNotification: {
                    ErrorType: string;
                    ErroredPlayers: {
                        Subject: string;
                    }[] | null;
                };
                RestrictedSeconds: number;
                EligibleQueues: string[];
                QueueIneligibilities: string[];
                CheatData: {
                    GamePodOverride: string;
                    ForcePostGameProcessing: boolean;
                };
                XPBonuses: unknown[];
                InviteCode: string;
            }>;
        };
    };
};

type Params$i = ResolveParams<(typeof _default$i)["~type"]["url"]>;
type Body$i = z.infer<ResolveValue<(typeof _default$i)["~type"], "body">>;
type Data$i = ResolveData<Params$i, Body$i>;
type Response$i = z.infer<ResolveValue<(typeof _default$i)["~type"], "responses">["200"]>;
interface PartyInviteRequestConfig extends ValorantAxiosRequestConfig<Data$i> {
}
declare class PartyInviteEndpoint {
    /**
     * Invite a player to the party by name and tagline
     *
     * @EndpointType glz
     */
    postPartyInvite<T = Response$i>(this: RemoteApiClient, config: PartyInviteRequestConfig): Promise<AxiosResponse<T>>;
}

declare const PartyJoinByCodeResponseSchema: z.ZodObject<{
    Subject: z.ZodString;
    Version: z.ZodNumber;
    CurrentPartyID: z.ZodString;
    Invites: z.ZodNull;
    Requests: z.ZodArray<z.ZodObject<{
        ID: z.ZodString;
        PartyID: z.ZodString;
        RequestedBySubject: z.ZodString;
        Subjects: z.ZodArray<z.ZodString, "many">;
        CreatedAt: z.ZodEffects<z.ZodString, Date, string>;
        RefreshedAt: z.ZodEffects<z.ZodString, Date, string>;
        ExpiresIn: z.ZodNumber;
    }, "strip", z.ZodTypeAny, {
        ID: string;
        PartyID: string;
        RequestedBySubject: string;
        Subjects: string[];
        CreatedAt: Date;
        RefreshedAt: Date;
        ExpiresIn: number;
    }, {
        ID: string;
        PartyID: string;
        RequestedBySubject: string;
        Subjects: string[];
        CreatedAt: string;
        RefreshedAt: string;
        ExpiresIn: number;
    }>, "many">;
    PlatformInfo: z.ZodObject<{
        platformType: z.ZodLiteral<"PC">;
        platformOS: z.ZodLiteral<"Windows">;
        platformOSVersion: z.ZodString;
        platformChipset: z.ZodLiteral<"Unknown">;
    }, "strip", z.ZodTypeAny, {
        platformType: "PC";
        platformOS: "Windows";
        platformOSVersion: string;
        platformChipset: "Unknown";
    }, {
        platformType: "PC";
        platformOS: "Windows";
        platformOSVersion: string;
        platformChipset: "Unknown";
    }>;
}, "strip", z.ZodTypeAny, {
    Subject: string;
    Version: number;
    CurrentPartyID: string;
    Invites: null;
    Requests: {
        ID: string;
        PartyID: string;
        RequestedBySubject: string;
        Subjects: string[];
        CreatedAt: Date;
        RefreshedAt: Date;
        ExpiresIn: number;
    }[];
    PlatformInfo: {
        platformType: "PC";
        platformOS: "Windows";
        platformOSVersion: string;
        platformChipset: "Unknown";
    };
}, {
    Subject: string;
    Version: number;
    CurrentPartyID: string;
    Invites: null;
    Requests: {
        ID: string;
        PartyID: string;
        RequestedBySubject: string;
        Subjects: string[];
        CreatedAt: string;
        RefreshedAt: string;
        ExpiresIn: number;
    }[];
    PlatformInfo: {
        platformType: "PC";
        platformOS: "Windows";
        platformOSVersion: string;
        platformChipset: "Unknown";
    };
}>;
declare const _default$h: Omit<{
    requirements: string[];
    type: "auth" | "local" | "pd" | "glz" | "shared";
    name: string;
    method: "PUT" | "GET" | "DELETE" | "POST";
    url: string;
    description?: string | undefined;
    headers?: Record<string, string> | undefined;
    body?: z.ZodType<any, z.ZodTypeDef, any> | undefined;
    query?: z.ZodType<any, z.ZodTypeDef, any> | undefined;
    responses?: Record<string, z.ZodType<any, z.ZodTypeDef, any>> | undefined;
}, "type" | "name" | "url"> & Pick<{
    readonly name: "Party Join By Code";
    readonly description: "Join a party using an invite code";
    readonly type: "glz";
    readonly method: "POST";
    readonly url: "parties/v1/players/joinbycode/:code";
    readonly responses: {
        readonly "200": z.ZodObject<{
            Subject: z.ZodString;
            Version: z.ZodNumber;
            CurrentPartyID: z.ZodString;
            Invites: z.ZodNull;
            Requests: z.ZodArray<z.ZodObject<{
                ID: z.ZodString;
                PartyID: z.ZodString;
                RequestedBySubject: z.ZodString;
                Subjects: z.ZodArray<z.ZodString, "many">;
                CreatedAt: z.ZodEffects<z.ZodString, Date, string>;
                RefreshedAt: z.ZodEffects<z.ZodString, Date, string>;
                ExpiresIn: z.ZodNumber;
            }, "strip", z.ZodTypeAny, {
                ID: string;
                PartyID: string;
                RequestedBySubject: string;
                Subjects: string[];
                CreatedAt: Date;
                RefreshedAt: Date;
                ExpiresIn: number;
            }, {
                ID: string;
                PartyID: string;
                RequestedBySubject: string;
                Subjects: string[];
                CreatedAt: string;
                RefreshedAt: string;
                ExpiresIn: number;
            }>, "many">;
            PlatformInfo: z.ZodObject<{
                platformType: z.ZodLiteral<"PC">;
                platformOS: z.ZodLiteral<"Windows">;
                platformOSVersion: z.ZodString;
                platformChipset: z.ZodLiteral<"Unknown">;
            }, "strip", z.ZodTypeAny, {
                platformType: "PC";
                platformOS: "Windows";
                platformOSVersion: string;
                platformChipset: "Unknown";
            }, {
                platformType: "PC";
                platformOS: "Windows";
                platformOSVersion: string;
                platformChipset: "Unknown";
            }>;
        }, "strip", z.ZodTypeAny, {
            Subject: string;
            Version: number;
            CurrentPartyID: string;
            Invites: null;
            Requests: {
                ID: string;
                PartyID: string;
                RequestedBySubject: string;
                Subjects: string[];
                CreatedAt: Date;
                RefreshedAt: Date;
                ExpiresIn: number;
            }[];
            PlatformInfo: {
                platformType: "PC";
                platformOS: "Windows";
                platformOSVersion: string;
                platformChipset: "Unknown";
            };
        }, {
            Subject: string;
            Version: number;
            CurrentPartyID: string;
            Invites: null;
            Requests: {
                ID: string;
                PartyID: string;
                RequestedBySubject: string;
                Subjects: string[];
                CreatedAt: string;
                RefreshedAt: string;
                ExpiresIn: number;
            }[];
            PlatformInfo: {
                platformType: "PC";
                platformOS: "Windows";
                platformOSVersion: string;
                platformChipset: "Unknown";
            };
        }>;
        readonly "404": z.ZodObject<{
            httpStatus: z.ZodLiteral<404>;
            errorCode: z.ZodLiteral<"ERR_MISSING_INVITE_CODE_MAPPING">;
            message: z.ZodLiteral<"No PartyID <--> InviteCode mapping found">;
        }, "strip", z.ZodTypeAny, {
            message: "No PartyID <--> InviteCode mapping found";
            httpStatus: 404;
            errorCode: "ERR_MISSING_INVITE_CODE_MAPPING";
        }, {
            message: "No PartyID <--> InviteCode mapping found";
            httpStatus: 404;
            errorCode: "ERR_MISSING_INVITE_CODE_MAPPING";
        }>;
    };
}, "type" | "name" | "url"> & {
    "~type": {
        readonly name: "Party Join By Code";
        readonly description: "Join a party using an invite code";
        readonly type: "glz";
        readonly method: "POST";
        readonly url: "parties/v1/players/joinbycode/:code";
        readonly responses: {
            readonly "200": z.ZodObject<{
                Subject: z.ZodString;
                Version: z.ZodNumber;
                CurrentPartyID: z.ZodString;
                Invites: z.ZodNull;
                Requests: z.ZodArray<z.ZodObject<{
                    ID: z.ZodString;
                    PartyID: z.ZodString;
                    RequestedBySubject: z.ZodString;
                    Subjects: z.ZodArray<z.ZodString, "many">;
                    CreatedAt: z.ZodEffects<z.ZodString, Date, string>;
                    RefreshedAt: z.ZodEffects<z.ZodString, Date, string>;
                    ExpiresIn: z.ZodNumber;
                }, "strip", z.ZodTypeAny, {
                    ID: string;
                    PartyID: string;
                    RequestedBySubject: string;
                    Subjects: string[];
                    CreatedAt: Date;
                    RefreshedAt: Date;
                    ExpiresIn: number;
                }, {
                    ID: string;
                    PartyID: string;
                    RequestedBySubject: string;
                    Subjects: string[];
                    CreatedAt: string;
                    RefreshedAt: string;
                    ExpiresIn: number;
                }>, "many">;
                PlatformInfo: z.ZodObject<{
                    platformType: z.ZodLiteral<"PC">;
                    platformOS: z.ZodLiteral<"Windows">;
                    platformOSVersion: z.ZodString;
                    platformChipset: z.ZodLiteral<"Unknown">;
                }, "strip", z.ZodTypeAny, {
                    platformType: "PC";
                    platformOS: "Windows";
                    platformOSVersion: string;
                    platformChipset: "Unknown";
                }, {
                    platformType: "PC";
                    platformOS: "Windows";
                    platformOSVersion: string;
                    platformChipset: "Unknown";
                }>;
            }, "strip", z.ZodTypeAny, {
                Subject: string;
                Version: number;
                CurrentPartyID: string;
                Invites: null;
                Requests: {
                    ID: string;
                    PartyID: string;
                    RequestedBySubject: string;
                    Subjects: string[];
                    CreatedAt: Date;
                    RefreshedAt: Date;
                    ExpiresIn: number;
                }[];
                PlatformInfo: {
                    platformType: "PC";
                    platformOS: "Windows";
                    platformOSVersion: string;
                    platformChipset: "Unknown";
                };
            }, {
                Subject: string;
                Version: number;
                CurrentPartyID: string;
                Invites: null;
                Requests: {
                    ID: string;
                    PartyID: string;
                    RequestedBySubject: string;
                    Subjects: string[];
                    CreatedAt: string;
                    RefreshedAt: string;
                    ExpiresIn: number;
                }[];
                PlatformInfo: {
                    platformType: "PC";
                    platformOS: "Windows";
                    platformOSVersion: string;
                    platformChipset: "Unknown";
                };
            }>;
            readonly "404": z.ZodObject<{
                httpStatus: z.ZodLiteral<404>;
                errorCode: z.ZodLiteral<"ERR_MISSING_INVITE_CODE_MAPPING">;
                message: z.ZodLiteral<"No PartyID <--> InviteCode mapping found">;
            }, "strip", z.ZodTypeAny, {
                message: "No PartyID <--> InviteCode mapping found";
                httpStatus: 404;
                errorCode: "ERR_MISSING_INVITE_CODE_MAPPING";
            }, {
                message: "No PartyID <--> InviteCode mapping found";
                httpStatus: 404;
                errorCode: "ERR_MISSING_INVITE_CODE_MAPPING";
            }>;
        };
    };
};

type Params$h = ResolveParams<(typeof _default$h)["~type"]["url"]>;
type Body$h = z.infer<ResolveValue<(typeof _default$h)["~type"], "body">>;
type Data$h = ResolveData<Params$h, Body$h>;
type Response$h = z.infer<ResolveValue<(typeof _default$h)["~type"], "responses">["200"]>;
interface PartyJoinByCodeRequestConfig extends ValorantAxiosRequestConfig<Data$h> {
}
declare class PartyJoinByCodeEndpoint {
    /**
     * Join a party using an invite code
     *
     * @EndpointType glz
     */
    postPartyJoinByCode<T = Response$h>(this: RemoteApiClient, config: PartyJoinByCodeRequestConfig): Promise<AxiosResponse<T>>;
}

declare const _default$g: Omit<{
    requirements: string[];
    type: "auth" | "local" | "pd" | "glz" | "shared";
    name: string;
    method: "PUT" | "GET" | "DELETE" | "POST";
    url: string;
    description?: string | undefined;
    headers?: Record<string, string> | undefined;
    body?: zod.ZodType<any, zod.ZodTypeDef, any> | undefined;
    query?: zod.ZodType<any, zod.ZodTypeDef, any> | undefined;
    responses?: Record<string, zod.ZodType<any, zod.ZodTypeDef, any>> | undefined;
}, "type" | "name" | "url"> & Pick<{
    readonly name: "Party Player";
    readonly description: "Get the party information for the given player";
    readonly type: "glz";
    readonly url: "parties/v1/players/:puuid";
    readonly responses: {
        readonly "200": zod.ZodObject<{
            Subject: zod.ZodString;
            Version: zod.ZodNumber;
            CurrentPartyID: zod.ZodString;
            Invites: zod.ZodNull;
            Requests: zod.ZodArray<zod.ZodObject<{
                ID: zod.ZodString;
                PartyID: zod.ZodString;
                RequestedBySubject: zod.ZodString;
                Subjects: zod.ZodArray<zod.ZodString, "many">;
                CreatedAt: zod.ZodEffects<zod.ZodString, Date, string>;
                RefreshedAt: zod.ZodEffects<zod.ZodString, Date, string>;
                ExpiresIn: zod.ZodNumber;
            }, "strip", zod.ZodTypeAny, {
                ID: string;
                PartyID: string;
                RequestedBySubject: string;
                Subjects: string[];
                CreatedAt: Date;
                RefreshedAt: Date;
                ExpiresIn: number;
            }, {
                ID: string;
                PartyID: string;
                RequestedBySubject: string;
                Subjects: string[];
                CreatedAt: string;
                RefreshedAt: string;
                ExpiresIn: number;
            }>, "many">;
            PlatformInfo: zod.ZodObject<{
                platformType: zod.ZodLiteral<"PC">;
                platformOS: zod.ZodLiteral<"Windows">;
                platformOSVersion: zod.ZodString;
                platformChipset: zod.ZodLiteral<"Unknown">;
            }, "strip", zod.ZodTypeAny, {
                platformType: "PC";
                platformOS: "Windows";
                platformOSVersion: string;
                platformChipset: "Unknown";
            }, {
                platformType: "PC";
                platformOS: "Windows";
                platformOSVersion: string;
                platformChipset: "Unknown";
            }>;
        }, "strip", zod.ZodTypeAny, {
            Subject: string;
            Version: number;
            CurrentPartyID: string;
            Invites: null;
            Requests: {
                ID: string;
                PartyID: string;
                RequestedBySubject: string;
                Subjects: string[];
                CreatedAt: Date;
                RefreshedAt: Date;
                ExpiresIn: number;
            }[];
            PlatformInfo: {
                platformType: "PC";
                platformOS: "Windows";
                platformOSVersion: string;
                platformChipset: "Unknown";
            };
        }, {
            Subject: string;
            Version: number;
            CurrentPartyID: string;
            Invites: null;
            Requests: {
                ID: string;
                PartyID: string;
                RequestedBySubject: string;
                Subjects: string[];
                CreatedAt: string;
                RefreshedAt: string;
                ExpiresIn: number;
            }[];
            PlatformInfo: {
                platformType: "PC";
                platformOS: "Windows";
                platformOSVersion: string;
                platformChipset: "Unknown";
            };
        }>;
    };
}, "type" | "name" | "url"> & {
    "~type": {
        readonly name: "Party Player";
        readonly description: "Get the party information for the given player";
        readonly type: "glz";
        readonly url: "parties/v1/players/:puuid";
        readonly responses: {
            readonly "200": zod.ZodObject<{
                Subject: zod.ZodString;
                Version: zod.ZodNumber;
                CurrentPartyID: zod.ZodString;
                Invites: zod.ZodNull;
                Requests: zod.ZodArray<zod.ZodObject<{
                    ID: zod.ZodString;
                    PartyID: zod.ZodString;
                    RequestedBySubject: zod.ZodString;
                    Subjects: zod.ZodArray<zod.ZodString, "many">;
                    CreatedAt: zod.ZodEffects<zod.ZodString, Date, string>;
                    RefreshedAt: zod.ZodEffects<zod.ZodString, Date, string>;
                    ExpiresIn: zod.ZodNumber;
                }, "strip", zod.ZodTypeAny, {
                    ID: string;
                    PartyID: string;
                    RequestedBySubject: string;
                    Subjects: string[];
                    CreatedAt: Date;
                    RefreshedAt: Date;
                    ExpiresIn: number;
                }, {
                    ID: string;
                    PartyID: string;
                    RequestedBySubject: string;
                    Subjects: string[];
                    CreatedAt: string;
                    RefreshedAt: string;
                    ExpiresIn: number;
                }>, "many">;
                PlatformInfo: zod.ZodObject<{
                    platformType: zod.ZodLiteral<"PC">;
                    platformOS: zod.ZodLiteral<"Windows">;
                    platformOSVersion: zod.ZodString;
                    platformChipset: zod.ZodLiteral<"Unknown">;
                }, "strip", zod.ZodTypeAny, {
                    platformType: "PC";
                    platformOS: "Windows";
                    platformOSVersion: string;
                    platformChipset: "Unknown";
                }, {
                    platformType: "PC";
                    platformOS: "Windows";
                    platformOSVersion: string;
                    platformChipset: "Unknown";
                }>;
            }, "strip", zod.ZodTypeAny, {
                Subject: string;
                Version: number;
                CurrentPartyID: string;
                Invites: null;
                Requests: {
                    ID: string;
                    PartyID: string;
                    RequestedBySubject: string;
                    Subjects: string[];
                    CreatedAt: Date;
                    RefreshedAt: Date;
                    ExpiresIn: number;
                }[];
                PlatformInfo: {
                    platformType: "PC";
                    platformOS: "Windows";
                    platformOSVersion: string;
                    platformChipset: "Unknown";
                };
            }, {
                Subject: string;
                Version: number;
                CurrentPartyID: string;
                Invites: null;
                Requests: {
                    ID: string;
                    PartyID: string;
                    RequestedBySubject: string;
                    Subjects: string[];
                    CreatedAt: string;
                    RefreshedAt: string;
                    ExpiresIn: number;
                }[];
                PlatformInfo: {
                    platformType: "PC";
                    platformOS: "Windows";
                    platformOSVersion: string;
                    platformChipset: "Unknown";
                };
            }>;
        };
    };
};

type Params$g = ResolveParams<(typeof _default$g)["~type"]["url"]>;
type Body$g = z.infer<ResolveValue<(typeof _default$g)["~type"], "body">>;
type Data$g = ResolveData<Params$g, Body$g>;
type Response$g = z.infer<ResolveValue<(typeof _default$g)["~type"], "responses">["200"]>;
interface PartyPlayerRequestConfig extends ValorantAxiosRequestConfig<Data$g> {
}
declare class PartyPlayerEndpoint {
    /**
     * Get the party information for the given player
     *
     * @EndpointType glz
     */
    getPartyPlayer<T = Response$g>(this: RemoteApiClient, config?: PartyPlayerRequestConfig): Promise<AxiosResponse<T>>;
}

declare const _default$f: Omit<{
    requirements: string[];
    type: "auth" | "local" | "pd" | "glz" | "shared";
    name: string;
    method: "PUT" | "GET" | "DELETE" | "POST";
    url: string;
    description?: string | undefined;
    headers?: Record<string, string> | undefined;
    body?: z.ZodType<any, z.ZodTypeDef, any> | undefined;
    query?: z.ZodType<any, z.ZodTypeDef, any> | undefined;
    responses?: Record<string, z.ZodType<any, z.ZodTypeDef, any>> | undefined;
}, "type" | "name" | "url"> & Pick<{
    readonly name: "Party Remove Player";
    readonly description: "Remove a player from the current party";
    readonly type: "glz";
    readonly url: "parties/v1/players/:puuid";
    readonly method: "DELETE";
    readonly responses: {
        readonly "204": z.ZodUndefined;
    };
}, "type" | "name" | "url"> & {
    "~type": {
        readonly name: "Party Remove Player";
        readonly description: "Remove a player from the current party";
        readonly type: "glz";
        readonly url: "parties/v1/players/:puuid";
        readonly method: "DELETE";
        readonly responses: {
            readonly "204": z.ZodUndefined;
        };
    };
};

type Params$f = ResolveParams<(typeof _default$f)["~type"]["url"]>;
type Body$f = z.infer<ResolveValue<(typeof _default$f)["~type"], "body">>;
type Data$f = ResolveData<Params$f, Body$f>;
type Response$f = z.infer<ResolveValue<(typeof _default$f)["~type"], "responses">["204"]>;
interface PartyRemovePlayerRequestConfig extends ValorantAxiosRequestConfig<Data$f> {
}
declare class PartyRemovePlayerEndpoint {
    /**
     * Remove a player from the current party
     *
     * @EndpointType glz
     */
    deletePartyRemovePlayer<T = Response$f>(this: RemoteApiClient, config?: PartyRemovePlayerRequestConfig): Promise<AxiosResponse<T>>;
}

declare const _default$e: Omit<{
    requirements: string[];
    type: "auth" | "local" | "pd" | "glz" | "shared";
    name: string;
    method: "PUT" | "GET" | "DELETE" | "POST";
    url: string;
    description?: string | undefined;
    headers?: Record<string, string> | undefined;
    body?: z.ZodType<any, z.ZodTypeDef, any> | undefined;
    query?: z.ZodType<any, z.ZodTypeDef, any> | undefined;
    responses?: Record<string, z.ZodType<any, z.ZodTypeDef, any>> | undefined;
}, "type" | "name" | "url"> & Pick<{
    readonly name: "Party Request";
    readonly description: "Requests to join the specified party ID";
    readonly type: "glz";
    readonly method: "POST";
    readonly url: "parties/v1/parties/:partyId/request";
    readonly responses: {
        readonly "200": z.ZodUnknown;
    };
}, "type" | "name" | "url"> & {
    "~type": {
        readonly name: "Party Request";
        readonly description: "Requests to join the specified party ID";
        readonly type: "glz";
        readonly method: "POST";
        readonly url: "parties/v1/parties/:partyId/request";
        readonly responses: {
            readonly "200": z.ZodUnknown;
        };
    };
};

type Params$e = ResolveParams<(typeof _default$e)["~type"]["url"]>;
type Body$e = z.infer<ResolveValue<(typeof _default$e)["~type"], "body">>;
type Data$e = ResolveData<Params$e, Body$e>;
type Response$e = z.infer<ResolveValue<(typeof _default$e)["~type"], "responses">["200"]>;
interface PartyRequestRequestConfig extends ValorantAxiosRequestConfig<Data$e> {
}
declare class PartyRequestEndpoint {
    /**
     * Requests to join the specified party ID
     *
     * @EndpointType glz
     */
    postPartyRequest<T = Response$e>(this: RemoteApiClient, config: PartyRequestRequestConfig): Promise<AxiosResponse<T>>;
}

declare const _default$d: Omit<{
    requirements: string[];
    type: "auth" | "local" | "pd" | "glz" | "shared";
    name: string;
    method: "PUT" | "GET" | "DELETE" | "POST";
    url: string;
    description?: string | undefined;
    headers?: Record<string, string> | undefined;
    body?: z.ZodType<any, z.ZodTypeDef, any> | undefined;
    query?: z.ZodType<any, z.ZodTypeDef, any> | undefined;
    responses?: Record<string, z.ZodType<any, z.ZodTypeDef, any>> | undefined;
}, "type" | "name" | "url"> & Pick<{
    readonly name: "Party Set Member Ready";
    readonly description: "Set the ready status of a player in the current party";
    readonly type: "glz";
    readonly url: "parties/v1/parties/:partyId/members/:puuid/setReady";
    readonly method: "POST";
    readonly body: z.ZodObject<{
        ready: z.ZodBoolean;
    }, "strip", z.ZodTypeAny, {
        ready: boolean;
    }, {
        ready: boolean;
    }>;
    readonly responses: {
        readonly "200": z.ZodObject<{
            ID: z.ZodString;
            MUCName: z.ZodString;
            VoiceRoomID: z.ZodString;
            Version: z.ZodNumber;
            ClientVersion: z.ZodString;
            Members: z.ZodArray<z.ZodObject<{
                Subject: z.ZodString;
                CompetitiveTier: z.ZodNumber;
                PlayerIdentity: z.ZodObject<{
                    Subject: z.ZodString;
                    PlayerCardID: z.ZodString;
                    PlayerTitleID: z.ZodString;
                    AccountLevel: z.ZodNumber;
                    PreferredLevelBorderID: z.ZodUnion<[z.ZodString, z.ZodLiteral<"">]>;
                    Incognito: z.ZodBoolean;
                    HideAccountLevel: z.ZodBoolean;
                }, "strip", z.ZodTypeAny, {
                    Subject: string;
                    PlayerCardID: string;
                    PlayerTitleID: string;
                    AccountLevel: number;
                    PreferredLevelBorderID: string;
                    Incognito: boolean;
                    HideAccountLevel: boolean;
                }, {
                    Subject: string;
                    PlayerCardID: string;
                    PlayerTitleID: string;
                    AccountLevel: number;
                    PreferredLevelBorderID: string;
                    Incognito: boolean;
                    HideAccountLevel: boolean;
                }>;
                SeasonalBadgeInfo: z.ZodNull;
                IsOwner: z.ZodOptional<z.ZodBoolean>;
                QueueEligibleRemainingAccountLevels: z.ZodNumber;
                Pings: z.ZodArray<z.ZodObject<{
                    Ping: z.ZodNumber;
                    GamePodID: z.ZodString;
                }, "strip", z.ZodTypeAny, {
                    GamePodID: string;
                    Ping: number;
                }, {
                    GamePodID: string;
                    Ping: number;
                }>, "many">;
                IsReady: z.ZodBoolean;
                IsModerator: z.ZodBoolean;
                UseBroadcastHUD: z.ZodBoolean;
                PlatformType: z.ZodLiteral<"PC">;
            }, "strip", z.ZodTypeAny, {
                Subject: string;
                PlayerIdentity: {
                    Subject: string;
                    PlayerCardID: string;
                    PlayerTitleID: string;
                    AccountLevel: number;
                    PreferredLevelBorderID: string;
                    Incognito: boolean;
                    HideAccountLevel: boolean;
                };
                SeasonalBadgeInfo: null;
                CompetitiveTier: number;
                QueueEligibleRemainingAccountLevels: number;
                Pings: {
                    GamePodID: string;
                    Ping: number;
                }[];
                IsReady: boolean;
                IsModerator: boolean;
                UseBroadcastHUD: boolean;
                PlatformType: "PC";
                IsOwner?: boolean | undefined;
            }, {
                Subject: string;
                PlayerIdentity: {
                    Subject: string;
                    PlayerCardID: string;
                    PlayerTitleID: string;
                    AccountLevel: number;
                    PreferredLevelBorderID: string;
                    Incognito: boolean;
                    HideAccountLevel: boolean;
                };
                SeasonalBadgeInfo: null;
                CompetitiveTier: number;
                QueueEligibleRemainingAccountLevels: number;
                Pings: {
                    GamePodID: string;
                    Ping: number;
                }[];
                IsReady: boolean;
                IsModerator: boolean;
                UseBroadcastHUD: boolean;
                PlatformType: "PC";
                IsOwner?: boolean | undefined;
            }>, "many">;
            State: z.ZodString;
            PreviousState: z.ZodString;
            StateTransitionReason: z.ZodString;
            Accessibility: z.ZodUnion<[z.ZodLiteral<"OPEN">, z.ZodLiteral<"CLOSED">]>;
            CustomGameData: z.ZodObject<{
                Settings: z.ZodObject<{
                    Map: z.ZodString;
                    Mode: z.ZodString;
                    UseBots: z.ZodBoolean;
                    GamePod: z.ZodString;
                    GameRules: z.ZodNullable<z.ZodObject<{
                        AllowGameModifiers: z.ZodOptional<z.ZodEffects<z.ZodString, boolean, string>>;
                        IsOvertimeWinByTwo: z.ZodOptional<z.ZodEffects<z.ZodString, boolean, string>>;
                        PlayOutAllRounds: z.ZodOptional<z.ZodEffects<z.ZodString, boolean, string>>;
                        SkipMatchHistory: z.ZodOptional<z.ZodEffects<z.ZodString, boolean, string>>;
                        TournamentMode: z.ZodOptional<z.ZodEffects<z.ZodString, boolean, string>>;
                    }, "strip", z.ZodTypeAny, {
                        AllowGameModifiers?: boolean | undefined;
                        IsOvertimeWinByTwo?: boolean | undefined;
                        PlayOutAllRounds?: boolean | undefined;
                        SkipMatchHistory?: boolean | undefined;
                        TournamentMode?: boolean | undefined;
                    }, {
                        AllowGameModifiers?: string | undefined;
                        IsOvertimeWinByTwo?: string | undefined;
                        PlayOutAllRounds?: string | undefined;
                        SkipMatchHistory?: string | undefined;
                        TournamentMode?: string | undefined;
                    }>>;
                }, "strip", z.ZodTypeAny, {
                    Mode: string;
                    GameRules: {
                        AllowGameModifiers?: boolean | undefined;
                        IsOvertimeWinByTwo?: boolean | undefined;
                        PlayOutAllRounds?: boolean | undefined;
                        SkipMatchHistory?: boolean | undefined;
                        TournamentMode?: boolean | undefined;
                    } | null;
                    Map: string;
                    UseBots: boolean;
                    GamePod: string;
                }, {
                    Mode: string;
                    GameRules: {
                        AllowGameModifiers?: string | undefined;
                        IsOvertimeWinByTwo?: string | undefined;
                        PlayOutAllRounds?: string | undefined;
                        SkipMatchHistory?: string | undefined;
                        TournamentMode?: string | undefined;
                    } | null;
                    Map: string;
                    UseBots: boolean;
                    GamePod: string;
                }>;
                Membership: z.ZodObject<{
                    teamOne: z.ZodNullable<z.ZodArray<z.ZodObject<{
                        Subject: z.ZodString;
                    }, "strip", z.ZodTypeAny, {
                        Subject: string;
                    }, {
                        Subject: string;
                    }>, "many">>;
                    teamTwo: z.ZodNullable<z.ZodArray<z.ZodObject<{
                        Subject: z.ZodString;
                    }, "strip", z.ZodTypeAny, {
                        Subject: string;
                    }, {
                        Subject: string;
                    }>, "many">>;
                    teamSpectate: z.ZodNullable<z.ZodArray<z.ZodObject<{
                        Subject: z.ZodString;
                    }, "strip", z.ZodTypeAny, {
                        Subject: string;
                    }, {
                        Subject: string;
                    }>, "many">>;
                    teamOneCoaches: z.ZodNullable<z.ZodArray<z.ZodObject<{
                        Subject: z.ZodString;
                    }, "strip", z.ZodTypeAny, {
                        Subject: string;
                    }, {
                        Subject: string;
                    }>, "many">>;
                    teamTwoCoaches: z.ZodNullable<z.ZodArray<z.ZodObject<{
                        Subject: z.ZodString;
                    }, "strip", z.ZodTypeAny, {
                        Subject: string;
                    }, {
                        Subject: string;
                    }>, "many">>;
                }, "strip", z.ZodTypeAny, {
                    teamOne: {
                        Subject: string;
                    }[] | null;
                    teamTwo: {
                        Subject: string;
                    }[] | null;
                    teamSpectate: {
                        Subject: string;
                    }[] | null;
                    teamOneCoaches: {
                        Subject: string;
                    }[] | null;
                    teamTwoCoaches: {
                        Subject: string;
                    }[] | null;
                }, {
                    teamOne: {
                        Subject: string;
                    }[] | null;
                    teamTwo: {
                        Subject: string;
                    }[] | null;
                    teamSpectate: {
                        Subject: string;
                    }[] | null;
                    teamOneCoaches: {
                        Subject: string;
                    }[] | null;
                    teamTwoCoaches: {
                        Subject: string;
                    }[] | null;
                }>;
                MaxPartySize: z.ZodNumber;
                AutobalanceEnabled: z.ZodBoolean;
                AutobalanceMinPlayers: z.ZodNumber;
                HasRecoveryData: z.ZodBoolean;
            }, "strip", z.ZodTypeAny, {
                MaxPartySize: number;
                Settings: {
                    Mode: string;
                    GameRules: {
                        AllowGameModifiers?: boolean | undefined;
                        IsOvertimeWinByTwo?: boolean | undefined;
                        PlayOutAllRounds?: boolean | undefined;
                        SkipMatchHistory?: boolean | undefined;
                        TournamentMode?: boolean | undefined;
                    } | null;
                    Map: string;
                    UseBots: boolean;
                    GamePod: string;
                };
                Membership: {
                    teamOne: {
                        Subject: string;
                    }[] | null;
                    teamTwo: {
                        Subject: string;
                    }[] | null;
                    teamSpectate: {
                        Subject: string;
                    }[] | null;
                    teamOneCoaches: {
                        Subject: string;
                    }[] | null;
                    teamTwoCoaches: {
                        Subject: string;
                    }[] | null;
                };
                AutobalanceEnabled: boolean;
                AutobalanceMinPlayers: number;
                HasRecoveryData: boolean;
            }, {
                MaxPartySize: number;
                Settings: {
                    Mode: string;
                    GameRules: {
                        AllowGameModifiers?: string | undefined;
                        IsOvertimeWinByTwo?: string | undefined;
                        PlayOutAllRounds?: string | undefined;
                        SkipMatchHistory?: string | undefined;
                        TournamentMode?: string | undefined;
                    } | null;
                    Map: string;
                    UseBots: boolean;
                    GamePod: string;
                };
                Membership: {
                    teamOne: {
                        Subject: string;
                    }[] | null;
                    teamTwo: {
                        Subject: string;
                    }[] | null;
                    teamSpectate: {
                        Subject: string;
                    }[] | null;
                    teamOneCoaches: {
                        Subject: string;
                    }[] | null;
                    teamTwoCoaches: {
                        Subject: string;
                    }[] | null;
                };
                AutobalanceEnabled: boolean;
                AutobalanceMinPlayers: number;
                HasRecoveryData: boolean;
            }>;
            MatchmakingData: z.ZodObject<{
                QueueID: z.ZodString;
                PreferredGamePods: z.ZodArray<z.ZodString, "many">;
                SkillDisparityRRPenalty: z.ZodNumber;
            }, "strip", z.ZodTypeAny, {
                QueueID: string;
                PreferredGamePods: string[];
                SkillDisparityRRPenalty: number;
            }, {
                QueueID: string;
                PreferredGamePods: string[];
                SkillDisparityRRPenalty: number;
            }>;
            Invites: z.ZodNull;
            Requests: z.ZodArray<z.ZodUnknown, "many">;
            QueueEntryTime: z.ZodEffects<z.ZodString, Date, string>;
            ErrorNotification: z.ZodObject<{
                ErrorType: z.ZodString;
                ErroredPlayers: z.ZodNullable<z.ZodArray<z.ZodObject<{
                    Subject: z.ZodString;
                }, "strip", z.ZodTypeAny, {
                    Subject: string;
                }, {
                    Subject: string;
                }>, "many">>;
            }, "strip", z.ZodTypeAny, {
                ErrorType: string;
                ErroredPlayers: {
                    Subject: string;
                }[] | null;
            }, {
                ErrorType: string;
                ErroredPlayers: {
                    Subject: string;
                }[] | null;
            }>;
            RestrictedSeconds: z.ZodNumber;
            EligibleQueues: z.ZodArray<z.ZodString, "many">;
            QueueIneligibilities: z.ZodArray<z.ZodString, "many">;
            CheatData: z.ZodObject<{
                GamePodOverride: z.ZodString;
                ForcePostGameProcessing: z.ZodBoolean;
            }, "strip", z.ZodTypeAny, {
                GamePodOverride: string;
                ForcePostGameProcessing: boolean;
            }, {
                GamePodOverride: string;
                ForcePostGameProcessing: boolean;
            }>;
            XPBonuses: z.ZodArray<z.ZodUnknown, "many">;
            InviteCode: z.ZodString;
        }, "strip", z.ZodTypeAny, {
            ID: string;
            Version: number;
            Invites: null;
            Requests: unknown[];
            State: string;
            MatchmakingData: {
                QueueID: string;
                PreferredGamePods: string[];
                SkillDisparityRRPenalty: number;
            };
            MUCName: string;
            VoiceRoomID: string;
            ClientVersion: string;
            Members: {
                Subject: string;
                PlayerIdentity: {
                    Subject: string;
                    PlayerCardID: string;
                    PlayerTitleID: string;
                    AccountLevel: number;
                    PreferredLevelBorderID: string;
                    Incognito: boolean;
                    HideAccountLevel: boolean;
                };
                SeasonalBadgeInfo: null;
                CompetitiveTier: number;
                QueueEligibleRemainingAccountLevels: number;
                Pings: {
                    GamePodID: string;
                    Ping: number;
                }[];
                IsReady: boolean;
                IsModerator: boolean;
                UseBroadcastHUD: boolean;
                PlatformType: "PC";
                IsOwner?: boolean | undefined;
            }[];
            PreviousState: string;
            StateTransitionReason: string;
            Accessibility: "OPEN" | "CLOSED";
            CustomGameData: {
                MaxPartySize: number;
                Settings: {
                    Mode: string;
                    GameRules: {
                        AllowGameModifiers?: boolean | undefined;
                        IsOvertimeWinByTwo?: boolean | undefined;
                        PlayOutAllRounds?: boolean | undefined;
                        SkipMatchHistory?: boolean | undefined;
                        TournamentMode?: boolean | undefined;
                    } | null;
                    Map: string;
                    UseBots: boolean;
                    GamePod: string;
                };
                Membership: {
                    teamOne: {
                        Subject: string;
                    }[] | null;
                    teamTwo: {
                        Subject: string;
                    }[] | null;
                    teamSpectate: {
                        Subject: string;
                    }[] | null;
                    teamOneCoaches: {
                        Subject: string;
                    }[] | null;
                    teamTwoCoaches: {
                        Subject: string;
                    }[] | null;
                };
                AutobalanceEnabled: boolean;
                AutobalanceMinPlayers: number;
                HasRecoveryData: boolean;
            };
            QueueEntryTime: Date;
            ErrorNotification: {
                ErrorType: string;
                ErroredPlayers: {
                    Subject: string;
                }[] | null;
            };
            RestrictedSeconds: number;
            EligibleQueues: string[];
            QueueIneligibilities: string[];
            CheatData: {
                GamePodOverride: string;
                ForcePostGameProcessing: boolean;
            };
            XPBonuses: unknown[];
            InviteCode: string;
        }, {
            ID: string;
            Version: number;
            Invites: null;
            Requests: unknown[];
            State: string;
            MatchmakingData: {
                QueueID: string;
                PreferredGamePods: string[];
                SkillDisparityRRPenalty: number;
            };
            MUCName: string;
            VoiceRoomID: string;
            ClientVersion: string;
            Members: {
                Subject: string;
                PlayerIdentity: {
                    Subject: string;
                    PlayerCardID: string;
                    PlayerTitleID: string;
                    AccountLevel: number;
                    PreferredLevelBorderID: string;
                    Incognito: boolean;
                    HideAccountLevel: boolean;
                };
                SeasonalBadgeInfo: null;
                CompetitiveTier: number;
                QueueEligibleRemainingAccountLevels: number;
                Pings: {
                    GamePodID: string;
                    Ping: number;
                }[];
                IsReady: boolean;
                IsModerator: boolean;
                UseBroadcastHUD: boolean;
                PlatformType: "PC";
                IsOwner?: boolean | undefined;
            }[];
            PreviousState: string;
            StateTransitionReason: string;
            Accessibility: "OPEN" | "CLOSED";
            CustomGameData: {
                MaxPartySize: number;
                Settings: {
                    Mode: string;
                    GameRules: {
                        AllowGameModifiers?: string | undefined;
                        IsOvertimeWinByTwo?: string | undefined;
                        PlayOutAllRounds?: string | undefined;
                        SkipMatchHistory?: string | undefined;
                        TournamentMode?: string | undefined;
                    } | null;
                    Map: string;
                    UseBots: boolean;
                    GamePod: string;
                };
                Membership: {
                    teamOne: {
                        Subject: string;
                    }[] | null;
                    teamTwo: {
                        Subject: string;
                    }[] | null;
                    teamSpectate: {
                        Subject: string;
                    }[] | null;
                    teamOneCoaches: {
                        Subject: string;
                    }[] | null;
                    teamTwoCoaches: {
                        Subject: string;
                    }[] | null;
                };
                AutobalanceEnabled: boolean;
                AutobalanceMinPlayers: number;
                HasRecoveryData: boolean;
            };
            QueueEntryTime: string;
            ErrorNotification: {
                ErrorType: string;
                ErroredPlayers: {
                    Subject: string;
                }[] | null;
            };
            RestrictedSeconds: number;
            EligibleQueues: string[];
            QueueIneligibilities: string[];
            CheatData: {
                GamePodOverride: string;
                ForcePostGameProcessing: boolean;
            };
            XPBonuses: unknown[];
            InviteCode: string;
        }>;
    };
}, "type" | "name" | "url"> & {
    "~type": {
        readonly name: "Party Set Member Ready";
        readonly description: "Set the ready status of a player in the current party";
        readonly type: "glz";
        readonly url: "parties/v1/parties/:partyId/members/:puuid/setReady";
        readonly method: "POST";
        readonly body: z.ZodObject<{
            ready: z.ZodBoolean;
        }, "strip", z.ZodTypeAny, {
            ready: boolean;
        }, {
            ready: boolean;
        }>;
        readonly responses: {
            readonly "200": z.ZodObject<{
                ID: z.ZodString;
                MUCName: z.ZodString;
                VoiceRoomID: z.ZodString;
                Version: z.ZodNumber;
                ClientVersion: z.ZodString;
                Members: z.ZodArray<z.ZodObject<{
                    Subject: z.ZodString;
                    CompetitiveTier: z.ZodNumber;
                    PlayerIdentity: z.ZodObject<{
                        Subject: z.ZodString;
                        PlayerCardID: z.ZodString;
                        PlayerTitleID: z.ZodString;
                        AccountLevel: z.ZodNumber;
                        PreferredLevelBorderID: z.ZodUnion<[z.ZodString, z.ZodLiteral<"">]>;
                        Incognito: z.ZodBoolean;
                        HideAccountLevel: z.ZodBoolean;
                    }, "strip", z.ZodTypeAny, {
                        Subject: string;
                        PlayerCardID: string;
                        PlayerTitleID: string;
                        AccountLevel: number;
                        PreferredLevelBorderID: string;
                        Incognito: boolean;
                        HideAccountLevel: boolean;
                    }, {
                        Subject: string;
                        PlayerCardID: string;
                        PlayerTitleID: string;
                        AccountLevel: number;
                        PreferredLevelBorderID: string;
                        Incognito: boolean;
                        HideAccountLevel: boolean;
                    }>;
                    SeasonalBadgeInfo: z.ZodNull;
                    IsOwner: z.ZodOptional<z.ZodBoolean>;
                    QueueEligibleRemainingAccountLevels: z.ZodNumber;
                    Pings: z.ZodArray<z.ZodObject<{
                        Ping: z.ZodNumber;
                        GamePodID: z.ZodString;
                    }, "strip", z.ZodTypeAny, {
                        GamePodID: string;
                        Ping: number;
                    }, {
                        GamePodID: string;
                        Ping: number;
                    }>, "many">;
                    IsReady: z.ZodBoolean;
                    IsModerator: z.ZodBoolean;
                    UseBroadcastHUD: z.ZodBoolean;
                    PlatformType: z.ZodLiteral<"PC">;
                }, "strip", z.ZodTypeAny, {
                    Subject: string;
                    PlayerIdentity: {
                        Subject: string;
                        PlayerCardID: string;
                        PlayerTitleID: string;
                        AccountLevel: number;
                        PreferredLevelBorderID: string;
                        Incognito: boolean;
                        HideAccountLevel: boolean;
                    };
                    SeasonalBadgeInfo: null;
                    CompetitiveTier: number;
                    QueueEligibleRemainingAccountLevels: number;
                    Pings: {
                        GamePodID: string;
                        Ping: number;
                    }[];
                    IsReady: boolean;
                    IsModerator: boolean;
                    UseBroadcastHUD: boolean;
                    PlatformType: "PC";
                    IsOwner?: boolean | undefined;
                }, {
                    Subject: string;
                    PlayerIdentity: {
                        Subject: string;
                        PlayerCardID: string;
                        PlayerTitleID: string;
                        AccountLevel: number;
                        PreferredLevelBorderID: string;
                        Incognito: boolean;
                        HideAccountLevel: boolean;
                    };
                    SeasonalBadgeInfo: null;
                    CompetitiveTier: number;
                    QueueEligibleRemainingAccountLevels: number;
                    Pings: {
                        GamePodID: string;
                        Ping: number;
                    }[];
                    IsReady: boolean;
                    IsModerator: boolean;
                    UseBroadcastHUD: boolean;
                    PlatformType: "PC";
                    IsOwner?: boolean | undefined;
                }>, "many">;
                State: z.ZodString;
                PreviousState: z.ZodString;
                StateTransitionReason: z.ZodString;
                Accessibility: z.ZodUnion<[z.ZodLiteral<"OPEN">, z.ZodLiteral<"CLOSED">]>;
                CustomGameData: z.ZodObject<{
                    Settings: z.ZodObject<{
                        Map: z.ZodString;
                        Mode: z.ZodString;
                        UseBots: z.ZodBoolean;
                        GamePod: z.ZodString;
                        GameRules: z.ZodNullable<z.ZodObject<{
                            AllowGameModifiers: z.ZodOptional<z.ZodEffects<z.ZodString, boolean, string>>;
                            IsOvertimeWinByTwo: z.ZodOptional<z.ZodEffects<z.ZodString, boolean, string>>;
                            PlayOutAllRounds: z.ZodOptional<z.ZodEffects<z.ZodString, boolean, string>>;
                            SkipMatchHistory: z.ZodOptional<z.ZodEffects<z.ZodString, boolean, string>>;
                            TournamentMode: z.ZodOptional<z.ZodEffects<z.ZodString, boolean, string>>;
                        }, "strip", z.ZodTypeAny, {
                            AllowGameModifiers?: boolean | undefined;
                            IsOvertimeWinByTwo?: boolean | undefined;
                            PlayOutAllRounds?: boolean | undefined;
                            SkipMatchHistory?: boolean | undefined;
                            TournamentMode?: boolean | undefined;
                        }, {
                            AllowGameModifiers?: string | undefined;
                            IsOvertimeWinByTwo?: string | undefined;
                            PlayOutAllRounds?: string | undefined;
                            SkipMatchHistory?: string | undefined;
                            TournamentMode?: string | undefined;
                        }>>;
                    }, "strip", z.ZodTypeAny, {
                        Mode: string;
                        GameRules: {
                            AllowGameModifiers?: boolean | undefined;
                            IsOvertimeWinByTwo?: boolean | undefined;
                            PlayOutAllRounds?: boolean | undefined;
                            SkipMatchHistory?: boolean | undefined;
                            TournamentMode?: boolean | undefined;
                        } | null;
                        Map: string;
                        UseBots: boolean;
                        GamePod: string;
                    }, {
                        Mode: string;
                        GameRules: {
                            AllowGameModifiers?: string | undefined;
                            IsOvertimeWinByTwo?: string | undefined;
                            PlayOutAllRounds?: string | undefined;
                            SkipMatchHistory?: string | undefined;
                            TournamentMode?: string | undefined;
                        } | null;
                        Map: string;
                        UseBots: boolean;
                        GamePod: string;
                    }>;
                    Membership: z.ZodObject<{
                        teamOne: z.ZodNullable<z.ZodArray<z.ZodObject<{
                            Subject: z.ZodString;
                        }, "strip", z.ZodTypeAny, {
                            Subject: string;
                        }, {
                            Subject: string;
                        }>, "many">>;
                        teamTwo: z.ZodNullable<z.ZodArray<z.ZodObject<{
                            Subject: z.ZodString;
                        }, "strip", z.ZodTypeAny, {
                            Subject: string;
                        }, {
                            Subject: string;
                        }>, "many">>;
                        teamSpectate: z.ZodNullable<z.ZodArray<z.ZodObject<{
                            Subject: z.ZodString;
                        }, "strip", z.ZodTypeAny, {
                            Subject: string;
                        }, {
                            Subject: string;
                        }>, "many">>;
                        teamOneCoaches: z.ZodNullable<z.ZodArray<z.ZodObject<{
                            Subject: z.ZodString;
                        }, "strip", z.ZodTypeAny, {
                            Subject: string;
                        }, {
                            Subject: string;
                        }>, "many">>;
                        teamTwoCoaches: z.ZodNullable<z.ZodArray<z.ZodObject<{
                            Subject: z.ZodString;
                        }, "strip", z.ZodTypeAny, {
                            Subject: string;
                        }, {
                            Subject: string;
                        }>, "many">>;
                    }, "strip", z.ZodTypeAny, {
                        teamOne: {
                            Subject: string;
                        }[] | null;
                        teamTwo: {
                            Subject: string;
                        }[] | null;
                        teamSpectate: {
                            Subject: string;
                        }[] | null;
                        teamOneCoaches: {
                            Subject: string;
                        }[] | null;
                        teamTwoCoaches: {
                            Subject: string;
                        }[] | null;
                    }, {
                        teamOne: {
                            Subject: string;
                        }[] | null;
                        teamTwo: {
                            Subject: string;
                        }[] | null;
                        teamSpectate: {
                            Subject: string;
                        }[] | null;
                        teamOneCoaches: {
                            Subject: string;
                        }[] | null;
                        teamTwoCoaches: {
                            Subject: string;
                        }[] | null;
                    }>;
                    MaxPartySize: z.ZodNumber;
                    AutobalanceEnabled: z.ZodBoolean;
                    AutobalanceMinPlayers: z.ZodNumber;
                    HasRecoveryData: z.ZodBoolean;
                }, "strip", z.ZodTypeAny, {
                    MaxPartySize: number;
                    Settings: {
                        Mode: string;
                        GameRules: {
                            AllowGameModifiers?: boolean | undefined;
                            IsOvertimeWinByTwo?: boolean | undefined;
                            PlayOutAllRounds?: boolean | undefined;
                            SkipMatchHistory?: boolean | undefined;
                            TournamentMode?: boolean | undefined;
                        } | null;
                        Map: string;
                        UseBots: boolean;
                        GamePod: string;
                    };
                    Membership: {
                        teamOne: {
                            Subject: string;
                        }[] | null;
                        teamTwo: {
                            Subject: string;
                        }[] | null;
                        teamSpectate: {
                            Subject: string;
                        }[] | null;
                        teamOneCoaches: {
                            Subject: string;
                        }[] | null;
                        teamTwoCoaches: {
                            Subject: string;
                        }[] | null;
                    };
                    AutobalanceEnabled: boolean;
                    AutobalanceMinPlayers: number;
                    HasRecoveryData: boolean;
                }, {
                    MaxPartySize: number;
                    Settings: {
                        Mode: string;
                        GameRules: {
                            AllowGameModifiers?: string | undefined;
                            IsOvertimeWinByTwo?: string | undefined;
                            PlayOutAllRounds?: string | undefined;
                            SkipMatchHistory?: string | undefined;
                            TournamentMode?: string | undefined;
                        } | null;
                        Map: string;
                        UseBots: boolean;
                        GamePod: string;
                    };
                    Membership: {
                        teamOne: {
                            Subject: string;
                        }[] | null;
                        teamTwo: {
                            Subject: string;
                        }[] | null;
                        teamSpectate: {
                            Subject: string;
                        }[] | null;
                        teamOneCoaches: {
                            Subject: string;
                        }[] | null;
                        teamTwoCoaches: {
                            Subject: string;
                        }[] | null;
                    };
                    AutobalanceEnabled: boolean;
                    AutobalanceMinPlayers: number;
                    HasRecoveryData: boolean;
                }>;
                MatchmakingData: z.ZodObject<{
                    QueueID: z.ZodString;
                    PreferredGamePods: z.ZodArray<z.ZodString, "many">;
                    SkillDisparityRRPenalty: z.ZodNumber;
                }, "strip", z.ZodTypeAny, {
                    QueueID: string;
                    PreferredGamePods: string[];
                    SkillDisparityRRPenalty: number;
                }, {
                    QueueID: string;
                    PreferredGamePods: string[];
                    SkillDisparityRRPenalty: number;
                }>;
                Invites: z.ZodNull;
                Requests: z.ZodArray<z.ZodUnknown, "many">;
                QueueEntryTime: z.ZodEffects<z.ZodString, Date, string>;
                ErrorNotification: z.ZodObject<{
                    ErrorType: z.ZodString;
                    ErroredPlayers: z.ZodNullable<z.ZodArray<z.ZodObject<{
                        Subject: z.ZodString;
                    }, "strip", z.ZodTypeAny, {
                        Subject: string;
                    }, {
                        Subject: string;
                    }>, "many">>;
                }, "strip", z.ZodTypeAny, {
                    ErrorType: string;
                    ErroredPlayers: {
                        Subject: string;
                    }[] | null;
                }, {
                    ErrorType: string;
                    ErroredPlayers: {
                        Subject: string;
                    }[] | null;
                }>;
                RestrictedSeconds: z.ZodNumber;
                EligibleQueues: z.ZodArray<z.ZodString, "many">;
                QueueIneligibilities: z.ZodArray<z.ZodString, "many">;
                CheatData: z.ZodObject<{
                    GamePodOverride: z.ZodString;
                    ForcePostGameProcessing: z.ZodBoolean;
                }, "strip", z.ZodTypeAny, {
                    GamePodOverride: string;
                    ForcePostGameProcessing: boolean;
                }, {
                    GamePodOverride: string;
                    ForcePostGameProcessing: boolean;
                }>;
                XPBonuses: z.ZodArray<z.ZodUnknown, "many">;
                InviteCode: z.ZodString;
            }, "strip", z.ZodTypeAny, {
                ID: string;
                Version: number;
                Invites: null;
                Requests: unknown[];
                State: string;
                MatchmakingData: {
                    QueueID: string;
                    PreferredGamePods: string[];
                    SkillDisparityRRPenalty: number;
                };
                MUCName: string;
                VoiceRoomID: string;
                ClientVersion: string;
                Members: {
                    Subject: string;
                    PlayerIdentity: {
                        Subject: string;
                        PlayerCardID: string;
                        PlayerTitleID: string;
                        AccountLevel: number;
                        PreferredLevelBorderID: string;
                        Incognito: boolean;
                        HideAccountLevel: boolean;
                    };
                    SeasonalBadgeInfo: null;
                    CompetitiveTier: number;
                    QueueEligibleRemainingAccountLevels: number;
                    Pings: {
                        GamePodID: string;
                        Ping: number;
                    }[];
                    IsReady: boolean;
                    IsModerator: boolean;
                    UseBroadcastHUD: boolean;
                    PlatformType: "PC";
                    IsOwner?: boolean | undefined;
                }[];
                PreviousState: string;
                StateTransitionReason: string;
                Accessibility: "OPEN" | "CLOSED";
                CustomGameData: {
                    MaxPartySize: number;
                    Settings: {
                        Mode: string;
                        GameRules: {
                            AllowGameModifiers?: boolean | undefined;
                            IsOvertimeWinByTwo?: boolean | undefined;
                            PlayOutAllRounds?: boolean | undefined;
                            SkipMatchHistory?: boolean | undefined;
                            TournamentMode?: boolean | undefined;
                        } | null;
                        Map: string;
                        UseBots: boolean;
                        GamePod: string;
                    };
                    Membership: {
                        teamOne: {
                            Subject: string;
                        }[] | null;
                        teamTwo: {
                            Subject: string;
                        }[] | null;
                        teamSpectate: {
                            Subject: string;
                        }[] | null;
                        teamOneCoaches: {
                            Subject: string;
                        }[] | null;
                        teamTwoCoaches: {
                            Subject: string;
                        }[] | null;
                    };
                    AutobalanceEnabled: boolean;
                    AutobalanceMinPlayers: number;
                    HasRecoveryData: boolean;
                };
                QueueEntryTime: Date;
                ErrorNotification: {
                    ErrorType: string;
                    ErroredPlayers: {
                        Subject: string;
                    }[] | null;
                };
                RestrictedSeconds: number;
                EligibleQueues: string[];
                QueueIneligibilities: string[];
                CheatData: {
                    GamePodOverride: string;
                    ForcePostGameProcessing: boolean;
                };
                XPBonuses: unknown[];
                InviteCode: string;
            }, {
                ID: string;
                Version: number;
                Invites: null;
                Requests: unknown[];
                State: string;
                MatchmakingData: {
                    QueueID: string;
                    PreferredGamePods: string[];
                    SkillDisparityRRPenalty: number;
                };
                MUCName: string;
                VoiceRoomID: string;
                ClientVersion: string;
                Members: {
                    Subject: string;
                    PlayerIdentity: {
                        Subject: string;
                        PlayerCardID: string;
                        PlayerTitleID: string;
                        AccountLevel: number;
                        PreferredLevelBorderID: string;
                        Incognito: boolean;
                        HideAccountLevel: boolean;
                    };
                    SeasonalBadgeInfo: null;
                    CompetitiveTier: number;
                    QueueEligibleRemainingAccountLevels: number;
                    Pings: {
                        GamePodID: string;
                        Ping: number;
                    }[];
                    IsReady: boolean;
                    IsModerator: boolean;
                    UseBroadcastHUD: boolean;
                    PlatformType: "PC";
                    IsOwner?: boolean | undefined;
                }[];
                PreviousState: string;
                StateTransitionReason: string;
                Accessibility: "OPEN" | "CLOSED";
                CustomGameData: {
                    MaxPartySize: number;
                    Settings: {
                        Mode: string;
                        GameRules: {
                            AllowGameModifiers?: string | undefined;
                            IsOvertimeWinByTwo?: string | undefined;
                            PlayOutAllRounds?: string | undefined;
                            SkipMatchHistory?: string | undefined;
                            TournamentMode?: string | undefined;
                        } | null;
                        Map: string;
                        UseBots: boolean;
                        GamePod: string;
                    };
                    Membership: {
                        teamOne: {
                            Subject: string;
                        }[] | null;
                        teamTwo: {
                            Subject: string;
                        }[] | null;
                        teamSpectate: {
                            Subject: string;
                        }[] | null;
                        teamOneCoaches: {
                            Subject: string;
                        }[] | null;
                        teamTwoCoaches: {
                            Subject: string;
                        }[] | null;
                    };
                    AutobalanceEnabled: boolean;
                    AutobalanceMinPlayers: number;
                    HasRecoveryData: boolean;
                };
                QueueEntryTime: string;
                ErrorNotification: {
                    ErrorType: string;
                    ErroredPlayers: {
                        Subject: string;
                    }[] | null;
                };
                RestrictedSeconds: number;
                EligibleQueues: string[];
                QueueIneligibilities: string[];
                CheatData: {
                    GamePodOverride: string;
                    ForcePostGameProcessing: boolean;
                };
                XPBonuses: unknown[];
                InviteCode: string;
            }>;
        };
    };
};

type Params$d = ResolveParams<(typeof _default$d)["~type"]["url"]>;
type Body$d = z.infer<ResolveValue<(typeof _default$d)["~type"], "body">>;
type Data$d = ResolveData<Params$d, Body$d>;
type Response$d = z.infer<ResolveValue<(typeof _default$d)["~type"], "responses">["200"]>;
interface PartySetMemberReadyRequestConfig extends ValorantAxiosRequestConfig<Data$d> {
}
declare class PartySetMemberReadyEndpoint {
    /**
     * Set the ready status of a player in the current party
     *
     * @EndpointType glz
     */
    postPartySetMemberReady<T = Response$d>(this: RemoteApiClient, config: PartySetMemberReadyRequestConfig): Promise<AxiosResponse<T>>;
}

declare const PartyVoiceTokenResponseSchema: z.ZodObject<{
    Token: z.ZodString;
    Room: z.ZodString;
}, "strip", z.ZodTypeAny, {
    Token: string;
    Room: string;
}, {
    Token: string;
    Room: string;
}>;
declare const _default$c: Omit<{
    requirements: string[];
    type: "auth" | "local" | "pd" | "glz" | "shared";
    name: string;
    method: "PUT" | "GET" | "DELETE" | "POST";
    url: string;
    description?: string | undefined;
    headers?: Record<string, string> | undefined;
    body?: z.ZodType<any, z.ZodTypeDef, any> | undefined;
    query?: z.ZodType<any, z.ZodTypeDef, any> | undefined;
    responses?: Record<string, z.ZodType<any, z.ZodTypeDef, any>> | undefined;
}, "type" | "name" | "url"> & Pick<{
    readonly name: "Party Voice Token";
    readonly description: "Get the party voice token";
    readonly type: "glz";
    readonly url: "parties/v1/parties/:partyId/voicetoken";
    readonly responses: {
        readonly "200": z.ZodObject<{
            Token: z.ZodString;
            Room: z.ZodString;
        }, "strip", z.ZodTypeAny, {
            Token: string;
            Room: string;
        }, {
            Token: string;
            Room: string;
        }>;
    };
}, "type" | "name" | "url"> & {
    "~type": {
        readonly name: "Party Voice Token";
        readonly description: "Get the party voice token";
        readonly type: "glz";
        readonly url: "parties/v1/parties/:partyId/voicetoken";
        readonly responses: {
            readonly "200": z.ZodObject<{
                Token: z.ZodString;
                Room: z.ZodString;
            }, "strip", z.ZodTypeAny, {
                Token: string;
                Room: string;
            }, {
                Token: string;
                Room: string;
            }>;
        };
    };
};

type Params$c = ResolveParams<(typeof _default$c)["~type"]["url"]>;
type Body$c = z.infer<ResolveValue<(typeof _default$c)["~type"], "body">>;
type Data$c = ResolveData<Params$c, Body$c>;
type Response$c = z.infer<ResolveValue<(typeof _default$c)["~type"], "responses">["200"]>;
interface PartyVoiceTokenRequestConfig extends ValorantAxiosRequestConfig<Data$c> {
}
declare class PartyVoiceTokenEndpoint {
    /**
     * Get the party voice token
     *
     * @EndpointType glz
     */
    getPartyVoiceToken<T = Response$c>(this: RemoteApiClient, config: PartyVoiceTokenRequestConfig): Promise<AxiosResponse<T>>;
}

declare const _default$b: Omit<{
    requirements: string[];
    type: "auth" | "local" | "pd" | "glz" | "shared";
    name: string;
    method: "PUT" | "GET" | "DELETE" | "POST";
    url: string;
    description?: string | undefined;
    headers?: Record<string, string> | undefined;
    body?: zod.ZodType<any, zod.ZodTypeDef, any> | undefined;
    query?: zod.ZodType<any, zod.ZodTypeDef, any> | undefined;
    responses?: Record<string, zod.ZodType<any, zod.ZodTypeDef, any>> | undefined;
}, "type" | "name" | "url"> & Pick<{
    readonly name: "Party";
    readonly description: "Get the party information for the given party ID";
    readonly queryName: "Party_FetchParty";
    readonly category: "Party Endpoints";
    readonly type: "glz";
    readonly url: "parties/v1/parties/:partyId";
    readonly responses: {
        readonly "200": zod.ZodObject<{
            ID: zod.ZodString;
            MUCName: zod.ZodString;
            VoiceRoomID: zod.ZodString;
            Version: zod.ZodNumber;
            ClientVersion: zod.ZodString;
            Members: zod.ZodArray<zod.ZodObject<{
                Subject: zod.ZodString;
                CompetitiveTier: zod.ZodNumber;
                PlayerIdentity: zod.ZodObject<{
                    Subject: zod.ZodString;
                    PlayerCardID: zod.ZodString;
                    PlayerTitleID: zod.ZodString;
                    AccountLevel: zod.ZodNumber;
                    PreferredLevelBorderID: zod.ZodUnion<[zod.ZodString, zod.ZodLiteral<"">]>;
                    Incognito: zod.ZodBoolean;
                    HideAccountLevel: zod.ZodBoolean;
                }, "strip", zod.ZodTypeAny, {
                    Subject: string;
                    PlayerCardID: string;
                    PlayerTitleID: string;
                    AccountLevel: number;
                    PreferredLevelBorderID: string;
                    Incognito: boolean;
                    HideAccountLevel: boolean;
                }, {
                    Subject: string;
                    PlayerCardID: string;
                    PlayerTitleID: string;
                    AccountLevel: number;
                    PreferredLevelBorderID: string;
                    Incognito: boolean;
                    HideAccountLevel: boolean;
                }>;
                SeasonalBadgeInfo: zod.ZodNull;
                IsOwner: zod.ZodOptional<zod.ZodBoolean>;
                QueueEligibleRemainingAccountLevels: zod.ZodNumber;
                Pings: zod.ZodArray<zod.ZodObject<{
                    Ping: zod.ZodNumber;
                    GamePodID: zod.ZodString;
                }, "strip", zod.ZodTypeAny, {
                    GamePodID: string;
                    Ping: number;
                }, {
                    GamePodID: string;
                    Ping: number;
                }>, "many">;
                IsReady: zod.ZodBoolean;
                IsModerator: zod.ZodBoolean;
                UseBroadcastHUD: zod.ZodBoolean;
                PlatformType: zod.ZodLiteral<"PC">;
            }, "strip", zod.ZodTypeAny, {
                Subject: string;
                PlayerIdentity: {
                    Subject: string;
                    PlayerCardID: string;
                    PlayerTitleID: string;
                    AccountLevel: number;
                    PreferredLevelBorderID: string;
                    Incognito: boolean;
                    HideAccountLevel: boolean;
                };
                SeasonalBadgeInfo: null;
                CompetitiveTier: number;
                QueueEligibleRemainingAccountLevels: number;
                Pings: {
                    GamePodID: string;
                    Ping: number;
                }[];
                IsReady: boolean;
                IsModerator: boolean;
                UseBroadcastHUD: boolean;
                PlatformType: "PC";
                IsOwner?: boolean | undefined;
            }, {
                Subject: string;
                PlayerIdentity: {
                    Subject: string;
                    PlayerCardID: string;
                    PlayerTitleID: string;
                    AccountLevel: number;
                    PreferredLevelBorderID: string;
                    Incognito: boolean;
                    HideAccountLevel: boolean;
                };
                SeasonalBadgeInfo: null;
                CompetitiveTier: number;
                QueueEligibleRemainingAccountLevels: number;
                Pings: {
                    GamePodID: string;
                    Ping: number;
                }[];
                IsReady: boolean;
                IsModerator: boolean;
                UseBroadcastHUD: boolean;
                PlatformType: "PC";
                IsOwner?: boolean | undefined;
            }>, "many">;
            State: zod.ZodString;
            PreviousState: zod.ZodString;
            StateTransitionReason: zod.ZodString;
            Accessibility: zod.ZodUnion<[zod.ZodLiteral<"OPEN">, zod.ZodLiteral<"CLOSED">]>;
            CustomGameData: zod.ZodObject<{
                Settings: zod.ZodObject<{
                    Map: zod.ZodString;
                    Mode: zod.ZodString;
                    UseBots: zod.ZodBoolean;
                    GamePod: zod.ZodString;
                    GameRules: zod.ZodNullable<zod.ZodObject<{
                        AllowGameModifiers: zod.ZodOptional<zod.ZodEffects<zod.ZodString, boolean, string>>;
                        IsOvertimeWinByTwo: zod.ZodOptional<zod.ZodEffects<zod.ZodString, boolean, string>>;
                        PlayOutAllRounds: zod.ZodOptional<zod.ZodEffects<zod.ZodString, boolean, string>>;
                        SkipMatchHistory: zod.ZodOptional<zod.ZodEffects<zod.ZodString, boolean, string>>;
                        TournamentMode: zod.ZodOptional<zod.ZodEffects<zod.ZodString, boolean, string>>;
                    }, "strip", zod.ZodTypeAny, {
                        AllowGameModifiers?: boolean | undefined;
                        IsOvertimeWinByTwo?: boolean | undefined;
                        PlayOutAllRounds?: boolean | undefined;
                        SkipMatchHistory?: boolean | undefined;
                        TournamentMode?: boolean | undefined;
                    }, {
                        AllowGameModifiers?: string | undefined;
                        IsOvertimeWinByTwo?: string | undefined;
                        PlayOutAllRounds?: string | undefined;
                        SkipMatchHistory?: string | undefined;
                        TournamentMode?: string | undefined;
                    }>>;
                }, "strip", zod.ZodTypeAny, {
                    Mode: string;
                    GameRules: {
                        AllowGameModifiers?: boolean | undefined;
                        IsOvertimeWinByTwo?: boolean | undefined;
                        PlayOutAllRounds?: boolean | undefined;
                        SkipMatchHistory?: boolean | undefined;
                        TournamentMode?: boolean | undefined;
                    } | null;
                    Map: string;
                    UseBots: boolean;
                    GamePod: string;
                }, {
                    Mode: string;
                    GameRules: {
                        AllowGameModifiers?: string | undefined;
                        IsOvertimeWinByTwo?: string | undefined;
                        PlayOutAllRounds?: string | undefined;
                        SkipMatchHistory?: string | undefined;
                        TournamentMode?: string | undefined;
                    } | null;
                    Map: string;
                    UseBots: boolean;
                    GamePod: string;
                }>;
                Membership: zod.ZodObject<{
                    teamOne: zod.ZodNullable<zod.ZodArray<zod.ZodObject<{
                        Subject: zod.ZodString;
                    }, "strip", zod.ZodTypeAny, {
                        Subject: string;
                    }, {
                        Subject: string;
                    }>, "many">>;
                    teamTwo: zod.ZodNullable<zod.ZodArray<zod.ZodObject<{
                        Subject: zod.ZodString;
                    }, "strip", zod.ZodTypeAny, {
                        Subject: string;
                    }, {
                        Subject: string;
                    }>, "many">>;
                    teamSpectate: zod.ZodNullable<zod.ZodArray<zod.ZodObject<{
                        Subject: zod.ZodString;
                    }, "strip", zod.ZodTypeAny, {
                        Subject: string;
                    }, {
                        Subject: string;
                    }>, "many">>;
                    teamOneCoaches: zod.ZodNullable<zod.ZodArray<zod.ZodObject<{
                        Subject: zod.ZodString;
                    }, "strip", zod.ZodTypeAny, {
                        Subject: string;
                    }, {
                        Subject: string;
                    }>, "many">>;
                    teamTwoCoaches: zod.ZodNullable<zod.ZodArray<zod.ZodObject<{
                        Subject: zod.ZodString;
                    }, "strip", zod.ZodTypeAny, {
                        Subject: string;
                    }, {
                        Subject: string;
                    }>, "many">>;
                }, "strip", zod.ZodTypeAny, {
                    teamOne: {
                        Subject: string;
                    }[] | null;
                    teamTwo: {
                        Subject: string;
                    }[] | null;
                    teamSpectate: {
                        Subject: string;
                    }[] | null;
                    teamOneCoaches: {
                        Subject: string;
                    }[] | null;
                    teamTwoCoaches: {
                        Subject: string;
                    }[] | null;
                }, {
                    teamOne: {
                        Subject: string;
                    }[] | null;
                    teamTwo: {
                        Subject: string;
                    }[] | null;
                    teamSpectate: {
                        Subject: string;
                    }[] | null;
                    teamOneCoaches: {
                        Subject: string;
                    }[] | null;
                    teamTwoCoaches: {
                        Subject: string;
                    }[] | null;
                }>;
                MaxPartySize: zod.ZodNumber;
                AutobalanceEnabled: zod.ZodBoolean;
                AutobalanceMinPlayers: zod.ZodNumber;
                HasRecoveryData: zod.ZodBoolean;
            }, "strip", zod.ZodTypeAny, {
                MaxPartySize: number;
                Settings: {
                    Mode: string;
                    GameRules: {
                        AllowGameModifiers?: boolean | undefined;
                        IsOvertimeWinByTwo?: boolean | undefined;
                        PlayOutAllRounds?: boolean | undefined;
                        SkipMatchHistory?: boolean | undefined;
                        TournamentMode?: boolean | undefined;
                    } | null;
                    Map: string;
                    UseBots: boolean;
                    GamePod: string;
                };
                Membership: {
                    teamOne: {
                        Subject: string;
                    }[] | null;
                    teamTwo: {
                        Subject: string;
                    }[] | null;
                    teamSpectate: {
                        Subject: string;
                    }[] | null;
                    teamOneCoaches: {
                        Subject: string;
                    }[] | null;
                    teamTwoCoaches: {
                        Subject: string;
                    }[] | null;
                };
                AutobalanceEnabled: boolean;
                AutobalanceMinPlayers: number;
                HasRecoveryData: boolean;
            }, {
                MaxPartySize: number;
                Settings: {
                    Mode: string;
                    GameRules: {
                        AllowGameModifiers?: string | undefined;
                        IsOvertimeWinByTwo?: string | undefined;
                        PlayOutAllRounds?: string | undefined;
                        SkipMatchHistory?: string | undefined;
                        TournamentMode?: string | undefined;
                    } | null;
                    Map: string;
                    UseBots: boolean;
                    GamePod: string;
                };
                Membership: {
                    teamOne: {
                        Subject: string;
                    }[] | null;
                    teamTwo: {
                        Subject: string;
                    }[] | null;
                    teamSpectate: {
                        Subject: string;
                    }[] | null;
                    teamOneCoaches: {
                        Subject: string;
                    }[] | null;
                    teamTwoCoaches: {
                        Subject: string;
                    }[] | null;
                };
                AutobalanceEnabled: boolean;
                AutobalanceMinPlayers: number;
                HasRecoveryData: boolean;
            }>;
            MatchmakingData: zod.ZodObject<{
                QueueID: zod.ZodString;
                PreferredGamePods: zod.ZodArray<zod.ZodString, "many">;
                SkillDisparityRRPenalty: zod.ZodNumber;
            }, "strip", zod.ZodTypeAny, {
                QueueID: string;
                PreferredGamePods: string[];
                SkillDisparityRRPenalty: number;
            }, {
                QueueID: string;
                PreferredGamePods: string[];
                SkillDisparityRRPenalty: number;
            }>;
            Invites: zod.ZodNull;
            Requests: zod.ZodArray<zod.ZodUnknown, "many">;
            QueueEntryTime: zod.ZodEffects<zod.ZodString, Date, string>;
            ErrorNotification: zod.ZodObject<{
                ErrorType: zod.ZodString;
                ErroredPlayers: zod.ZodNullable<zod.ZodArray<zod.ZodObject<{
                    Subject: zod.ZodString;
                }, "strip", zod.ZodTypeAny, {
                    Subject: string;
                }, {
                    Subject: string;
                }>, "many">>;
            }, "strip", zod.ZodTypeAny, {
                ErrorType: string;
                ErroredPlayers: {
                    Subject: string;
                }[] | null;
            }, {
                ErrorType: string;
                ErroredPlayers: {
                    Subject: string;
                }[] | null;
            }>;
            RestrictedSeconds: zod.ZodNumber;
            EligibleQueues: zod.ZodArray<zod.ZodString, "many">;
            QueueIneligibilities: zod.ZodArray<zod.ZodString, "many">;
            CheatData: zod.ZodObject<{
                GamePodOverride: zod.ZodString;
                ForcePostGameProcessing: zod.ZodBoolean;
            }, "strip", zod.ZodTypeAny, {
                GamePodOverride: string;
                ForcePostGameProcessing: boolean;
            }, {
                GamePodOverride: string;
                ForcePostGameProcessing: boolean;
            }>;
            XPBonuses: zod.ZodArray<zod.ZodUnknown, "many">;
            InviteCode: zod.ZodString;
        }, "strip", zod.ZodTypeAny, {
            ID: string;
            Version: number;
            Invites: null;
            Requests: unknown[];
            State: string;
            MatchmakingData: {
                QueueID: string;
                PreferredGamePods: string[];
                SkillDisparityRRPenalty: number;
            };
            MUCName: string;
            VoiceRoomID: string;
            ClientVersion: string;
            Members: {
                Subject: string;
                PlayerIdentity: {
                    Subject: string;
                    PlayerCardID: string;
                    PlayerTitleID: string;
                    AccountLevel: number;
                    PreferredLevelBorderID: string;
                    Incognito: boolean;
                    HideAccountLevel: boolean;
                };
                SeasonalBadgeInfo: null;
                CompetitiveTier: number;
                QueueEligibleRemainingAccountLevels: number;
                Pings: {
                    GamePodID: string;
                    Ping: number;
                }[];
                IsReady: boolean;
                IsModerator: boolean;
                UseBroadcastHUD: boolean;
                PlatformType: "PC";
                IsOwner?: boolean | undefined;
            }[];
            PreviousState: string;
            StateTransitionReason: string;
            Accessibility: "OPEN" | "CLOSED";
            CustomGameData: {
                MaxPartySize: number;
                Settings: {
                    Mode: string;
                    GameRules: {
                        AllowGameModifiers?: boolean | undefined;
                        IsOvertimeWinByTwo?: boolean | undefined;
                        PlayOutAllRounds?: boolean | undefined;
                        SkipMatchHistory?: boolean | undefined;
                        TournamentMode?: boolean | undefined;
                    } | null;
                    Map: string;
                    UseBots: boolean;
                    GamePod: string;
                };
                Membership: {
                    teamOne: {
                        Subject: string;
                    }[] | null;
                    teamTwo: {
                        Subject: string;
                    }[] | null;
                    teamSpectate: {
                        Subject: string;
                    }[] | null;
                    teamOneCoaches: {
                        Subject: string;
                    }[] | null;
                    teamTwoCoaches: {
                        Subject: string;
                    }[] | null;
                };
                AutobalanceEnabled: boolean;
                AutobalanceMinPlayers: number;
                HasRecoveryData: boolean;
            };
            QueueEntryTime: Date;
            ErrorNotification: {
                ErrorType: string;
                ErroredPlayers: {
                    Subject: string;
                }[] | null;
            };
            RestrictedSeconds: number;
            EligibleQueues: string[];
            QueueIneligibilities: string[];
            CheatData: {
                GamePodOverride: string;
                ForcePostGameProcessing: boolean;
            };
            XPBonuses: unknown[];
            InviteCode: string;
        }, {
            ID: string;
            Version: number;
            Invites: null;
            Requests: unknown[];
            State: string;
            MatchmakingData: {
                QueueID: string;
                PreferredGamePods: string[];
                SkillDisparityRRPenalty: number;
            };
            MUCName: string;
            VoiceRoomID: string;
            ClientVersion: string;
            Members: {
                Subject: string;
                PlayerIdentity: {
                    Subject: string;
                    PlayerCardID: string;
                    PlayerTitleID: string;
                    AccountLevel: number;
                    PreferredLevelBorderID: string;
                    Incognito: boolean;
                    HideAccountLevel: boolean;
                };
                SeasonalBadgeInfo: null;
                CompetitiveTier: number;
                QueueEligibleRemainingAccountLevels: number;
                Pings: {
                    GamePodID: string;
                    Ping: number;
                }[];
                IsReady: boolean;
                IsModerator: boolean;
                UseBroadcastHUD: boolean;
                PlatformType: "PC";
                IsOwner?: boolean | undefined;
            }[];
            PreviousState: string;
            StateTransitionReason: string;
            Accessibility: "OPEN" | "CLOSED";
            CustomGameData: {
                MaxPartySize: number;
                Settings: {
                    Mode: string;
                    GameRules: {
                        AllowGameModifiers?: string | undefined;
                        IsOvertimeWinByTwo?: string | undefined;
                        PlayOutAllRounds?: string | undefined;
                        SkipMatchHistory?: string | undefined;
                        TournamentMode?: string | undefined;
                    } | null;
                    Map: string;
                    UseBots: boolean;
                    GamePod: string;
                };
                Membership: {
                    teamOne: {
                        Subject: string;
                    }[] | null;
                    teamTwo: {
                        Subject: string;
                    }[] | null;
                    teamSpectate: {
                        Subject: string;
                    }[] | null;
                    teamOneCoaches: {
                        Subject: string;
                    }[] | null;
                    teamTwoCoaches: {
                        Subject: string;
                    }[] | null;
                };
                AutobalanceEnabled: boolean;
                AutobalanceMinPlayers: number;
                HasRecoveryData: boolean;
            };
            QueueEntryTime: string;
            ErrorNotification: {
                ErrorType: string;
                ErroredPlayers: {
                    Subject: string;
                }[] | null;
            };
            RestrictedSeconds: number;
            EligibleQueues: string[];
            QueueIneligibilities: string[];
            CheatData: {
                GamePodOverride: string;
                ForcePostGameProcessing: boolean;
            };
            XPBonuses: unknown[];
            InviteCode: string;
        }>;
    };
}, "type" | "name" | "url"> & {
    "~type": {
        readonly name: "Party";
        readonly description: "Get the party information for the given party ID";
        readonly queryName: "Party_FetchParty";
        readonly category: "Party Endpoints";
        readonly type: "glz";
        readonly url: "parties/v1/parties/:partyId";
        readonly responses: {
            readonly "200": zod.ZodObject<{
                ID: zod.ZodString;
                MUCName: zod.ZodString;
                VoiceRoomID: zod.ZodString;
                Version: zod.ZodNumber;
                ClientVersion: zod.ZodString;
                Members: zod.ZodArray<zod.ZodObject<{
                    Subject: zod.ZodString;
                    CompetitiveTier: zod.ZodNumber;
                    PlayerIdentity: zod.ZodObject<{
                        Subject: zod.ZodString;
                        PlayerCardID: zod.ZodString;
                        PlayerTitleID: zod.ZodString;
                        AccountLevel: zod.ZodNumber;
                        PreferredLevelBorderID: zod.ZodUnion<[zod.ZodString, zod.ZodLiteral<"">]>;
                        Incognito: zod.ZodBoolean;
                        HideAccountLevel: zod.ZodBoolean;
                    }, "strip", zod.ZodTypeAny, {
                        Subject: string;
                        PlayerCardID: string;
                        PlayerTitleID: string;
                        AccountLevel: number;
                        PreferredLevelBorderID: string;
                        Incognito: boolean;
                        HideAccountLevel: boolean;
                    }, {
                        Subject: string;
                        PlayerCardID: string;
                        PlayerTitleID: string;
                        AccountLevel: number;
                        PreferredLevelBorderID: string;
                        Incognito: boolean;
                        HideAccountLevel: boolean;
                    }>;
                    SeasonalBadgeInfo: zod.ZodNull;
                    IsOwner: zod.ZodOptional<zod.ZodBoolean>;
                    QueueEligibleRemainingAccountLevels: zod.ZodNumber;
                    Pings: zod.ZodArray<zod.ZodObject<{
                        Ping: zod.ZodNumber;
                        GamePodID: zod.ZodString;
                    }, "strip", zod.ZodTypeAny, {
                        GamePodID: string;
                        Ping: number;
                    }, {
                        GamePodID: string;
                        Ping: number;
                    }>, "many">;
                    IsReady: zod.ZodBoolean;
                    IsModerator: zod.ZodBoolean;
                    UseBroadcastHUD: zod.ZodBoolean;
                    PlatformType: zod.ZodLiteral<"PC">;
                }, "strip", zod.ZodTypeAny, {
                    Subject: string;
                    PlayerIdentity: {
                        Subject: string;
                        PlayerCardID: string;
                        PlayerTitleID: string;
                        AccountLevel: number;
                        PreferredLevelBorderID: string;
                        Incognito: boolean;
                        HideAccountLevel: boolean;
                    };
                    SeasonalBadgeInfo: null;
                    CompetitiveTier: number;
                    QueueEligibleRemainingAccountLevels: number;
                    Pings: {
                        GamePodID: string;
                        Ping: number;
                    }[];
                    IsReady: boolean;
                    IsModerator: boolean;
                    UseBroadcastHUD: boolean;
                    PlatformType: "PC";
                    IsOwner?: boolean | undefined;
                }, {
                    Subject: string;
                    PlayerIdentity: {
                        Subject: string;
                        PlayerCardID: string;
                        PlayerTitleID: string;
                        AccountLevel: number;
                        PreferredLevelBorderID: string;
                        Incognito: boolean;
                        HideAccountLevel: boolean;
                    };
                    SeasonalBadgeInfo: null;
                    CompetitiveTier: number;
                    QueueEligibleRemainingAccountLevels: number;
                    Pings: {
                        GamePodID: string;
                        Ping: number;
                    }[];
                    IsReady: boolean;
                    IsModerator: boolean;
                    UseBroadcastHUD: boolean;
                    PlatformType: "PC";
                    IsOwner?: boolean | undefined;
                }>, "many">;
                State: zod.ZodString;
                PreviousState: zod.ZodString;
                StateTransitionReason: zod.ZodString;
                Accessibility: zod.ZodUnion<[zod.ZodLiteral<"OPEN">, zod.ZodLiteral<"CLOSED">]>;
                CustomGameData: zod.ZodObject<{
                    Settings: zod.ZodObject<{
                        Map: zod.ZodString;
                        Mode: zod.ZodString;
                        UseBots: zod.ZodBoolean;
                        GamePod: zod.ZodString;
                        GameRules: zod.ZodNullable<zod.ZodObject<{
                            AllowGameModifiers: zod.ZodOptional<zod.ZodEffects<zod.ZodString, boolean, string>>;
                            IsOvertimeWinByTwo: zod.ZodOptional<zod.ZodEffects<zod.ZodString, boolean, string>>;
                            PlayOutAllRounds: zod.ZodOptional<zod.ZodEffects<zod.ZodString, boolean, string>>;
                            SkipMatchHistory: zod.ZodOptional<zod.ZodEffects<zod.ZodString, boolean, string>>;
                            TournamentMode: zod.ZodOptional<zod.ZodEffects<zod.ZodString, boolean, string>>;
                        }, "strip", zod.ZodTypeAny, {
                            AllowGameModifiers?: boolean | undefined;
                            IsOvertimeWinByTwo?: boolean | undefined;
                            PlayOutAllRounds?: boolean | undefined;
                            SkipMatchHistory?: boolean | undefined;
                            TournamentMode?: boolean | undefined;
                        }, {
                            AllowGameModifiers?: string | undefined;
                            IsOvertimeWinByTwo?: string | undefined;
                            PlayOutAllRounds?: string | undefined;
                            SkipMatchHistory?: string | undefined;
                            TournamentMode?: string | undefined;
                        }>>;
                    }, "strip", zod.ZodTypeAny, {
                        Mode: string;
                        GameRules: {
                            AllowGameModifiers?: boolean | undefined;
                            IsOvertimeWinByTwo?: boolean | undefined;
                            PlayOutAllRounds?: boolean | undefined;
                            SkipMatchHistory?: boolean | undefined;
                            TournamentMode?: boolean | undefined;
                        } | null;
                        Map: string;
                        UseBots: boolean;
                        GamePod: string;
                    }, {
                        Mode: string;
                        GameRules: {
                            AllowGameModifiers?: string | undefined;
                            IsOvertimeWinByTwo?: string | undefined;
                            PlayOutAllRounds?: string | undefined;
                            SkipMatchHistory?: string | undefined;
                            TournamentMode?: string | undefined;
                        } | null;
                        Map: string;
                        UseBots: boolean;
                        GamePod: string;
                    }>;
                    Membership: zod.ZodObject<{
                        teamOne: zod.ZodNullable<zod.ZodArray<zod.ZodObject<{
                            Subject: zod.ZodString;
                        }, "strip", zod.ZodTypeAny, {
                            Subject: string;
                        }, {
                            Subject: string;
                        }>, "many">>;
                        teamTwo: zod.ZodNullable<zod.ZodArray<zod.ZodObject<{
                            Subject: zod.ZodString;
                        }, "strip", zod.ZodTypeAny, {
                            Subject: string;
                        }, {
                            Subject: string;
                        }>, "many">>;
                        teamSpectate: zod.ZodNullable<zod.ZodArray<zod.ZodObject<{
                            Subject: zod.ZodString;
                        }, "strip", zod.ZodTypeAny, {
                            Subject: string;
                        }, {
                            Subject: string;
                        }>, "many">>;
                        teamOneCoaches: zod.ZodNullable<zod.ZodArray<zod.ZodObject<{
                            Subject: zod.ZodString;
                        }, "strip", zod.ZodTypeAny, {
                            Subject: string;
                        }, {
                            Subject: string;
                        }>, "many">>;
                        teamTwoCoaches: zod.ZodNullable<zod.ZodArray<zod.ZodObject<{
                            Subject: zod.ZodString;
                        }, "strip", zod.ZodTypeAny, {
                            Subject: string;
                        }, {
                            Subject: string;
                        }>, "many">>;
                    }, "strip", zod.ZodTypeAny, {
                        teamOne: {
                            Subject: string;
                        }[] | null;
                        teamTwo: {
                            Subject: string;
                        }[] | null;
                        teamSpectate: {
                            Subject: string;
                        }[] | null;
                        teamOneCoaches: {
                            Subject: string;
                        }[] | null;
                        teamTwoCoaches: {
                            Subject: string;
                        }[] | null;
                    }, {
                        teamOne: {
                            Subject: string;
                        }[] | null;
                        teamTwo: {
                            Subject: string;
                        }[] | null;
                        teamSpectate: {
                            Subject: string;
                        }[] | null;
                        teamOneCoaches: {
                            Subject: string;
                        }[] | null;
                        teamTwoCoaches: {
                            Subject: string;
                        }[] | null;
                    }>;
                    MaxPartySize: zod.ZodNumber;
                    AutobalanceEnabled: zod.ZodBoolean;
                    AutobalanceMinPlayers: zod.ZodNumber;
                    HasRecoveryData: zod.ZodBoolean;
                }, "strip", zod.ZodTypeAny, {
                    MaxPartySize: number;
                    Settings: {
                        Mode: string;
                        GameRules: {
                            AllowGameModifiers?: boolean | undefined;
                            IsOvertimeWinByTwo?: boolean | undefined;
                            PlayOutAllRounds?: boolean | undefined;
                            SkipMatchHistory?: boolean | undefined;
                            TournamentMode?: boolean | undefined;
                        } | null;
                        Map: string;
                        UseBots: boolean;
                        GamePod: string;
                    };
                    Membership: {
                        teamOne: {
                            Subject: string;
                        }[] | null;
                        teamTwo: {
                            Subject: string;
                        }[] | null;
                        teamSpectate: {
                            Subject: string;
                        }[] | null;
                        teamOneCoaches: {
                            Subject: string;
                        }[] | null;
                        teamTwoCoaches: {
                            Subject: string;
                        }[] | null;
                    };
                    AutobalanceEnabled: boolean;
                    AutobalanceMinPlayers: number;
                    HasRecoveryData: boolean;
                }, {
                    MaxPartySize: number;
                    Settings: {
                        Mode: string;
                        GameRules: {
                            AllowGameModifiers?: string | undefined;
                            IsOvertimeWinByTwo?: string | undefined;
                            PlayOutAllRounds?: string | undefined;
                            SkipMatchHistory?: string | undefined;
                            TournamentMode?: string | undefined;
                        } | null;
                        Map: string;
                        UseBots: boolean;
                        GamePod: string;
                    };
                    Membership: {
                        teamOne: {
                            Subject: string;
                        }[] | null;
                        teamTwo: {
                            Subject: string;
                        }[] | null;
                        teamSpectate: {
                            Subject: string;
                        }[] | null;
                        teamOneCoaches: {
                            Subject: string;
                        }[] | null;
                        teamTwoCoaches: {
                            Subject: string;
                        }[] | null;
                    };
                    AutobalanceEnabled: boolean;
                    AutobalanceMinPlayers: number;
                    HasRecoveryData: boolean;
                }>;
                MatchmakingData: zod.ZodObject<{
                    QueueID: zod.ZodString;
                    PreferredGamePods: zod.ZodArray<zod.ZodString, "many">;
                    SkillDisparityRRPenalty: zod.ZodNumber;
                }, "strip", zod.ZodTypeAny, {
                    QueueID: string;
                    PreferredGamePods: string[];
                    SkillDisparityRRPenalty: number;
                }, {
                    QueueID: string;
                    PreferredGamePods: string[];
                    SkillDisparityRRPenalty: number;
                }>;
                Invites: zod.ZodNull;
                Requests: zod.ZodArray<zod.ZodUnknown, "many">;
                QueueEntryTime: zod.ZodEffects<zod.ZodString, Date, string>;
                ErrorNotification: zod.ZodObject<{
                    ErrorType: zod.ZodString;
                    ErroredPlayers: zod.ZodNullable<zod.ZodArray<zod.ZodObject<{
                        Subject: zod.ZodString;
                    }, "strip", zod.ZodTypeAny, {
                        Subject: string;
                    }, {
                        Subject: string;
                    }>, "many">>;
                }, "strip", zod.ZodTypeAny, {
                    ErrorType: string;
                    ErroredPlayers: {
                        Subject: string;
                    }[] | null;
                }, {
                    ErrorType: string;
                    ErroredPlayers: {
                        Subject: string;
                    }[] | null;
                }>;
                RestrictedSeconds: zod.ZodNumber;
                EligibleQueues: zod.ZodArray<zod.ZodString, "many">;
                QueueIneligibilities: zod.ZodArray<zod.ZodString, "many">;
                CheatData: zod.ZodObject<{
                    GamePodOverride: zod.ZodString;
                    ForcePostGameProcessing: zod.ZodBoolean;
                }, "strip", zod.ZodTypeAny, {
                    GamePodOverride: string;
                    ForcePostGameProcessing: boolean;
                }, {
                    GamePodOverride: string;
                    ForcePostGameProcessing: boolean;
                }>;
                XPBonuses: zod.ZodArray<zod.ZodUnknown, "many">;
                InviteCode: zod.ZodString;
            }, "strip", zod.ZodTypeAny, {
                ID: string;
                Version: number;
                Invites: null;
                Requests: unknown[];
                State: string;
                MatchmakingData: {
                    QueueID: string;
                    PreferredGamePods: string[];
                    SkillDisparityRRPenalty: number;
                };
                MUCName: string;
                VoiceRoomID: string;
                ClientVersion: string;
                Members: {
                    Subject: string;
                    PlayerIdentity: {
                        Subject: string;
                        PlayerCardID: string;
                        PlayerTitleID: string;
                        AccountLevel: number;
                        PreferredLevelBorderID: string;
                        Incognito: boolean;
                        HideAccountLevel: boolean;
                    };
                    SeasonalBadgeInfo: null;
                    CompetitiveTier: number;
                    QueueEligibleRemainingAccountLevels: number;
                    Pings: {
                        GamePodID: string;
                        Ping: number;
                    }[];
                    IsReady: boolean;
                    IsModerator: boolean;
                    UseBroadcastHUD: boolean;
                    PlatformType: "PC";
                    IsOwner?: boolean | undefined;
                }[];
                PreviousState: string;
                StateTransitionReason: string;
                Accessibility: "OPEN" | "CLOSED";
                CustomGameData: {
                    MaxPartySize: number;
                    Settings: {
                        Mode: string;
                        GameRules: {
                            AllowGameModifiers?: boolean | undefined;
                            IsOvertimeWinByTwo?: boolean | undefined;
                            PlayOutAllRounds?: boolean | undefined;
                            SkipMatchHistory?: boolean | undefined;
                            TournamentMode?: boolean | undefined;
                        } | null;
                        Map: string;
                        UseBots: boolean;
                        GamePod: string;
                    };
                    Membership: {
                        teamOne: {
                            Subject: string;
                        }[] | null;
                        teamTwo: {
                            Subject: string;
                        }[] | null;
                        teamSpectate: {
                            Subject: string;
                        }[] | null;
                        teamOneCoaches: {
                            Subject: string;
                        }[] | null;
                        teamTwoCoaches: {
                            Subject: string;
                        }[] | null;
                    };
                    AutobalanceEnabled: boolean;
                    AutobalanceMinPlayers: number;
                    HasRecoveryData: boolean;
                };
                QueueEntryTime: Date;
                ErrorNotification: {
                    ErrorType: string;
                    ErroredPlayers: {
                        Subject: string;
                    }[] | null;
                };
                RestrictedSeconds: number;
                EligibleQueues: string[];
                QueueIneligibilities: string[];
                CheatData: {
                    GamePodOverride: string;
                    ForcePostGameProcessing: boolean;
                };
                XPBonuses: unknown[];
                InviteCode: string;
            }, {
                ID: string;
                Version: number;
                Invites: null;
                Requests: unknown[];
                State: string;
                MatchmakingData: {
                    QueueID: string;
                    PreferredGamePods: string[];
                    SkillDisparityRRPenalty: number;
                };
                MUCName: string;
                VoiceRoomID: string;
                ClientVersion: string;
                Members: {
                    Subject: string;
                    PlayerIdentity: {
                        Subject: string;
                        PlayerCardID: string;
                        PlayerTitleID: string;
                        AccountLevel: number;
                        PreferredLevelBorderID: string;
                        Incognito: boolean;
                        HideAccountLevel: boolean;
                    };
                    SeasonalBadgeInfo: null;
                    CompetitiveTier: number;
                    QueueEligibleRemainingAccountLevels: number;
                    Pings: {
                        GamePodID: string;
                        Ping: number;
                    }[];
                    IsReady: boolean;
                    IsModerator: boolean;
                    UseBroadcastHUD: boolean;
                    PlatformType: "PC";
                    IsOwner?: boolean | undefined;
                }[];
                PreviousState: string;
                StateTransitionReason: string;
                Accessibility: "OPEN" | "CLOSED";
                CustomGameData: {
                    MaxPartySize: number;
                    Settings: {
                        Mode: string;
                        GameRules: {
                            AllowGameModifiers?: string | undefined;
                            IsOvertimeWinByTwo?: string | undefined;
                            PlayOutAllRounds?: string | undefined;
                            SkipMatchHistory?: string | undefined;
                            TournamentMode?: string | undefined;
                        } | null;
                        Map: string;
                        UseBots: boolean;
                        GamePod: string;
                    };
                    Membership: {
                        teamOne: {
                            Subject: string;
                        }[] | null;
                        teamTwo: {
                            Subject: string;
                        }[] | null;
                        teamSpectate: {
                            Subject: string;
                        }[] | null;
                        teamOneCoaches: {
                            Subject: string;
                        }[] | null;
                        teamTwoCoaches: {
                            Subject: string;
                        }[] | null;
                    };
                    AutobalanceEnabled: boolean;
                    AutobalanceMinPlayers: number;
                    HasRecoveryData: boolean;
                };
                QueueEntryTime: string;
                ErrorNotification: {
                    ErrorType: string;
                    ErroredPlayers: {
                        Subject: string;
                    }[] | null;
                };
                RestrictedSeconds: number;
                EligibleQueues: string[];
                QueueIneligibilities: string[];
                CheatData: {
                    GamePodOverride: string;
                    ForcePostGameProcessing: boolean;
                };
                XPBonuses: unknown[];
                InviteCode: string;
            }>;
        };
    };
};

type Params$b = ResolveParams<(typeof _default$b)["~type"]["url"]>;
type Body$b = z.infer<ResolveValue<(typeof _default$b)["~type"], "body">>;
type Data$b = ResolveData<Params$b, Body$b>;
type Response$b = z.infer<ResolveValue<(typeof _default$b)["~type"], "responses">["200"]>;
interface PartyRequestConfig extends ValorantAxiosRequestConfig<Data$b> {
}
declare class PartyEndpoint {
    /**
     * Get the party information for the given party ID
     *
     * @EndpointType glz
     */
    getParty<T = Response$b>(this: RemoteApiClient, config: PartyRequestConfig): Promise<AxiosResponse<T>>;
}

declare const PreGameLoadoutsResponseSchema: z.ZodObject<{
    Loadouts: z.ZodArray<z.ZodObject<{
        Subject: z.ZodString;
        Sprays: z.ZodObject<{
            SpraySelections: z.ZodArray<z.ZodObject<{
                SocketID: z.ZodString;
                SprayID: z.ZodString;
                LevelID: z.ZodString;
            }, "strip", z.ZodTypeAny, {
                SocketID: string;
                SprayID: string;
                LevelID: string;
            }, {
                SocketID: string;
                SprayID: string;
                LevelID: string;
            }>, "many">;
        }, "strip", z.ZodTypeAny, {
            SpraySelections: {
                SocketID: string;
                SprayID: string;
                LevelID: string;
            }[];
        }, {
            SpraySelections: {
                SocketID: string;
                SprayID: string;
                LevelID: string;
            }[];
        }>;
        Expressions: z.ZodObject<{
            AESSelections: z.ZodArray<z.ZodObject<{
                SocketID: z.ZodString;
                AssetID: z.ZodString;
                TypeID: z.ZodString;
            }, "strip", z.ZodTypeAny, {
                SocketID: string;
                AssetID: string;
                TypeID: string;
            }, {
                SocketID: string;
                AssetID: string;
                TypeID: string;
            }>, "many">;
        }, "strip", z.ZodTypeAny, {
            AESSelections: {
                SocketID: string;
                AssetID: string;
                TypeID: string;
            }[];
        }, {
            AESSelections: {
                SocketID: string;
                AssetID: string;
                TypeID: string;
            }[];
        }>;
        Items: z.ZodRecord<z.ZodString, z.ZodObject<{
            ID: z.ZodString;
            TypeID: z.ZodString;
            Sockets: z.ZodRecord<z.ZodString, z.ZodObject<{
                ID: z.ZodString;
                Item: z.ZodObject<{
                    ID: z.ZodString;
                    TypeID: z.ZodString;
                }, "strip", z.ZodTypeAny, {
                    TypeID: string;
                    ID: string;
                }, {
                    TypeID: string;
                    ID: string;
                }>;
            }, "strip", z.ZodTypeAny, {
                ID: string;
                Item: {
                    TypeID: string;
                    ID: string;
                };
            }, {
                ID: string;
                Item: {
                    TypeID: string;
                    ID: string;
                };
            }>>;
        }, "strip", z.ZodTypeAny, {
            TypeID: string;
            ID: string;
            Sockets: Record<string, {
                ID: string;
                Item: {
                    TypeID: string;
                    ID: string;
                };
            }>;
        }, {
            TypeID: string;
            ID: string;
            Sockets: Record<string, {
                ID: string;
                Item: {
                    TypeID: string;
                    ID: string;
                };
            }>;
        }>>;
    }, "strip", z.ZodTypeAny, {
        Subject: string;
        Sprays: {
            SpraySelections: {
                SocketID: string;
                SprayID: string;
                LevelID: string;
            }[];
        };
        Expressions: {
            AESSelections: {
                SocketID: string;
                AssetID: string;
                TypeID: string;
            }[];
        };
        Items: Record<string, {
            TypeID: string;
            ID: string;
            Sockets: Record<string, {
                ID: string;
                Item: {
                    TypeID: string;
                    ID: string;
                };
            }>;
        }>;
    }, {
        Subject: string;
        Sprays: {
            SpraySelections: {
                SocketID: string;
                SprayID: string;
                LevelID: string;
            }[];
        };
        Expressions: {
            AESSelections: {
                SocketID: string;
                AssetID: string;
                TypeID: string;
            }[];
        };
        Items: Record<string, {
            TypeID: string;
            ID: string;
            Sockets: Record<string, {
                ID: string;
                Item: {
                    TypeID: string;
                    ID: string;
                };
            }>;
        }>;
    }>, "many">;
    LoadoutsValid: z.ZodBoolean;
}, "strip", z.ZodTypeAny, {
    Loadouts: {
        Subject: string;
        Sprays: {
            SpraySelections: {
                SocketID: string;
                SprayID: string;
                LevelID: string;
            }[];
        };
        Expressions: {
            AESSelections: {
                SocketID: string;
                AssetID: string;
                TypeID: string;
            }[];
        };
        Items: Record<string, {
            TypeID: string;
            ID: string;
            Sockets: Record<string, {
                ID: string;
                Item: {
                    TypeID: string;
                    ID: string;
                };
            }>;
        }>;
    }[];
    LoadoutsValid: boolean;
}, {
    Loadouts: {
        Subject: string;
        Sprays: {
            SpraySelections: {
                SocketID: string;
                SprayID: string;
                LevelID: string;
            }[];
        };
        Expressions: {
            AESSelections: {
                SocketID: string;
                AssetID: string;
                TypeID: string;
            }[];
        };
        Items: Record<string, {
            TypeID: string;
            ID: string;
            Sockets: Record<string, {
                ID: string;
                Item: {
                    TypeID: string;
                    ID: string;
                };
            }>;
        }>;
    }[];
    LoadoutsValid: boolean;
}>;
declare const _default$a: Omit<{
    requirements: string[];
    type: "auth" | "local" | "pd" | "glz" | "shared";
    name: string;
    method: "PUT" | "GET" | "DELETE" | "POST";
    url: string;
    description?: string | undefined;
    headers?: Record<string, string> | undefined;
    body?: z.ZodType<any, z.ZodTypeDef, any> | undefined;
    query?: z.ZodType<any, z.ZodTypeDef, any> | undefined;
    responses?: Record<string, z.ZodType<any, z.ZodTypeDef, any>> | undefined;
}, "type" | "name" | "url"> & Pick<{
    readonly name: "PreGame Loadouts";
    readonly description: "Get Pre-Game loadout data";
    readonly type: "glz";
    readonly url: "pregame/v1/matches/:pregameMatchId/loadouts";
    readonly responses: {
        readonly "200": z.ZodObject<{
            Loadouts: z.ZodArray<z.ZodObject<{
                Subject: z.ZodString;
                Sprays: z.ZodObject<{
                    SpraySelections: z.ZodArray<z.ZodObject<{
                        SocketID: z.ZodString;
                        SprayID: z.ZodString;
                        LevelID: z.ZodString;
                    }, "strip", z.ZodTypeAny, {
                        SocketID: string;
                        SprayID: string;
                        LevelID: string;
                    }, {
                        SocketID: string;
                        SprayID: string;
                        LevelID: string;
                    }>, "many">;
                }, "strip", z.ZodTypeAny, {
                    SpraySelections: {
                        SocketID: string;
                        SprayID: string;
                        LevelID: string;
                    }[];
                }, {
                    SpraySelections: {
                        SocketID: string;
                        SprayID: string;
                        LevelID: string;
                    }[];
                }>;
                Expressions: z.ZodObject<{
                    AESSelections: z.ZodArray<z.ZodObject<{
                        SocketID: z.ZodString;
                        AssetID: z.ZodString;
                        TypeID: z.ZodString;
                    }, "strip", z.ZodTypeAny, {
                        SocketID: string;
                        AssetID: string;
                        TypeID: string;
                    }, {
                        SocketID: string;
                        AssetID: string;
                        TypeID: string;
                    }>, "many">;
                }, "strip", z.ZodTypeAny, {
                    AESSelections: {
                        SocketID: string;
                        AssetID: string;
                        TypeID: string;
                    }[];
                }, {
                    AESSelections: {
                        SocketID: string;
                        AssetID: string;
                        TypeID: string;
                    }[];
                }>;
                Items: z.ZodRecord<z.ZodString, z.ZodObject<{
                    ID: z.ZodString;
                    TypeID: z.ZodString;
                    Sockets: z.ZodRecord<z.ZodString, z.ZodObject<{
                        ID: z.ZodString;
                        Item: z.ZodObject<{
                            ID: z.ZodString;
                            TypeID: z.ZodString;
                        }, "strip", z.ZodTypeAny, {
                            TypeID: string;
                            ID: string;
                        }, {
                            TypeID: string;
                            ID: string;
                        }>;
                    }, "strip", z.ZodTypeAny, {
                        ID: string;
                        Item: {
                            TypeID: string;
                            ID: string;
                        };
                    }, {
                        ID: string;
                        Item: {
                            TypeID: string;
                            ID: string;
                        };
                    }>>;
                }, "strip", z.ZodTypeAny, {
                    TypeID: string;
                    ID: string;
                    Sockets: Record<string, {
                        ID: string;
                        Item: {
                            TypeID: string;
                            ID: string;
                        };
                    }>;
                }, {
                    TypeID: string;
                    ID: string;
                    Sockets: Record<string, {
                        ID: string;
                        Item: {
                            TypeID: string;
                            ID: string;
                        };
                    }>;
                }>>;
            }, "strip", z.ZodTypeAny, {
                Subject: string;
                Sprays: {
                    SpraySelections: {
                        SocketID: string;
                        SprayID: string;
                        LevelID: string;
                    }[];
                };
                Expressions: {
                    AESSelections: {
                        SocketID: string;
                        AssetID: string;
                        TypeID: string;
                    }[];
                };
                Items: Record<string, {
                    TypeID: string;
                    ID: string;
                    Sockets: Record<string, {
                        ID: string;
                        Item: {
                            TypeID: string;
                            ID: string;
                        };
                    }>;
                }>;
            }, {
                Subject: string;
                Sprays: {
                    SpraySelections: {
                        SocketID: string;
                        SprayID: string;
                        LevelID: string;
                    }[];
                };
                Expressions: {
                    AESSelections: {
                        SocketID: string;
                        AssetID: string;
                        TypeID: string;
                    }[];
                };
                Items: Record<string, {
                    TypeID: string;
                    ID: string;
                    Sockets: Record<string, {
                        ID: string;
                        Item: {
                            TypeID: string;
                            ID: string;
                        };
                    }>;
                }>;
            }>, "many">;
            LoadoutsValid: z.ZodBoolean;
        }, "strip", z.ZodTypeAny, {
            Loadouts: {
                Subject: string;
                Sprays: {
                    SpraySelections: {
                        SocketID: string;
                        SprayID: string;
                        LevelID: string;
                    }[];
                };
                Expressions: {
                    AESSelections: {
                        SocketID: string;
                        AssetID: string;
                        TypeID: string;
                    }[];
                };
                Items: Record<string, {
                    TypeID: string;
                    ID: string;
                    Sockets: Record<string, {
                        ID: string;
                        Item: {
                            TypeID: string;
                            ID: string;
                        };
                    }>;
                }>;
            }[];
            LoadoutsValid: boolean;
        }, {
            Loadouts: {
                Subject: string;
                Sprays: {
                    SpraySelections: {
                        SocketID: string;
                        SprayID: string;
                        LevelID: string;
                    }[];
                };
                Expressions: {
                    AESSelections: {
                        SocketID: string;
                        AssetID: string;
                        TypeID: string;
                    }[];
                };
                Items: Record<string, {
                    TypeID: string;
                    ID: string;
                    Sockets: Record<string, {
                        ID: string;
                        Item: {
                            TypeID: string;
                            ID: string;
                        };
                    }>;
                }>;
            }[];
            LoadoutsValid: boolean;
        }>;
    };
}, "type" | "name" | "url"> & {
    "~type": {
        readonly name: "PreGame Loadouts";
        readonly description: "Get Pre-Game loadout data";
        readonly type: "glz";
        readonly url: "pregame/v1/matches/:pregameMatchId/loadouts";
        readonly responses: {
            readonly "200": z.ZodObject<{
                Loadouts: z.ZodArray<z.ZodObject<{
                    Subject: z.ZodString;
                    Sprays: z.ZodObject<{
                        SpraySelections: z.ZodArray<z.ZodObject<{
                            SocketID: z.ZodString;
                            SprayID: z.ZodString;
                            LevelID: z.ZodString;
                        }, "strip", z.ZodTypeAny, {
                            SocketID: string;
                            SprayID: string;
                            LevelID: string;
                        }, {
                            SocketID: string;
                            SprayID: string;
                            LevelID: string;
                        }>, "many">;
                    }, "strip", z.ZodTypeAny, {
                        SpraySelections: {
                            SocketID: string;
                            SprayID: string;
                            LevelID: string;
                        }[];
                    }, {
                        SpraySelections: {
                            SocketID: string;
                            SprayID: string;
                            LevelID: string;
                        }[];
                    }>;
                    Expressions: z.ZodObject<{
                        AESSelections: z.ZodArray<z.ZodObject<{
                            SocketID: z.ZodString;
                            AssetID: z.ZodString;
                            TypeID: z.ZodString;
                        }, "strip", z.ZodTypeAny, {
                            SocketID: string;
                            AssetID: string;
                            TypeID: string;
                        }, {
                            SocketID: string;
                            AssetID: string;
                            TypeID: string;
                        }>, "many">;
                    }, "strip", z.ZodTypeAny, {
                        AESSelections: {
                            SocketID: string;
                            AssetID: string;
                            TypeID: string;
                        }[];
                    }, {
                        AESSelections: {
                            SocketID: string;
                            AssetID: string;
                            TypeID: string;
                        }[];
                    }>;
                    Items: z.ZodRecord<z.ZodString, z.ZodObject<{
                        ID: z.ZodString;
                        TypeID: z.ZodString;
                        Sockets: z.ZodRecord<z.ZodString, z.ZodObject<{
                            ID: z.ZodString;
                            Item: z.ZodObject<{
                                ID: z.ZodString;
                                TypeID: z.ZodString;
                            }, "strip", z.ZodTypeAny, {
                                TypeID: string;
                                ID: string;
                            }, {
                                TypeID: string;
                                ID: string;
                            }>;
                        }, "strip", z.ZodTypeAny, {
                            ID: string;
                            Item: {
                                TypeID: string;
                                ID: string;
                            };
                        }, {
                            ID: string;
                            Item: {
                                TypeID: string;
                                ID: string;
                            };
                        }>>;
                    }, "strip", z.ZodTypeAny, {
                        TypeID: string;
                        ID: string;
                        Sockets: Record<string, {
                            ID: string;
                            Item: {
                                TypeID: string;
                                ID: string;
                            };
                        }>;
                    }, {
                        TypeID: string;
                        ID: string;
                        Sockets: Record<string, {
                            ID: string;
                            Item: {
                                TypeID: string;
                                ID: string;
                            };
                        }>;
                    }>>;
                }, "strip", z.ZodTypeAny, {
                    Subject: string;
                    Sprays: {
                        SpraySelections: {
                            SocketID: string;
                            SprayID: string;
                            LevelID: string;
                        }[];
                    };
                    Expressions: {
                        AESSelections: {
                            SocketID: string;
                            AssetID: string;
                            TypeID: string;
                        }[];
                    };
                    Items: Record<string, {
                        TypeID: string;
                        ID: string;
                        Sockets: Record<string, {
                            ID: string;
                            Item: {
                                TypeID: string;
                                ID: string;
                            };
                        }>;
                    }>;
                }, {
                    Subject: string;
                    Sprays: {
                        SpraySelections: {
                            SocketID: string;
                            SprayID: string;
                            LevelID: string;
                        }[];
                    };
                    Expressions: {
                        AESSelections: {
                            SocketID: string;
                            AssetID: string;
                            TypeID: string;
                        }[];
                    };
                    Items: Record<string, {
                        TypeID: string;
                        ID: string;
                        Sockets: Record<string, {
                            ID: string;
                            Item: {
                                TypeID: string;
                                ID: string;
                            };
                        }>;
                    }>;
                }>, "many">;
                LoadoutsValid: z.ZodBoolean;
            }, "strip", z.ZodTypeAny, {
                Loadouts: {
                    Subject: string;
                    Sprays: {
                        SpraySelections: {
                            SocketID: string;
                            SprayID: string;
                            LevelID: string;
                        }[];
                    };
                    Expressions: {
                        AESSelections: {
                            SocketID: string;
                            AssetID: string;
                            TypeID: string;
                        }[];
                    };
                    Items: Record<string, {
                        TypeID: string;
                        ID: string;
                        Sockets: Record<string, {
                            ID: string;
                            Item: {
                                TypeID: string;
                                ID: string;
                            };
                        }>;
                    }>;
                }[];
                LoadoutsValid: boolean;
            }, {
                Loadouts: {
                    Subject: string;
                    Sprays: {
                        SpraySelections: {
                            SocketID: string;
                            SprayID: string;
                            LevelID: string;
                        }[];
                    };
                    Expressions: {
                        AESSelections: {
                            SocketID: string;
                            AssetID: string;
                            TypeID: string;
                        }[];
                    };
                    Items: Record<string, {
                        TypeID: string;
                        ID: string;
                        Sockets: Record<string, {
                            ID: string;
                            Item: {
                                TypeID: string;
                                ID: string;
                            };
                        }>;
                    }>;
                }[];
                LoadoutsValid: boolean;
            }>;
        };
    };
};

type Params$a = ResolveParams<(typeof _default$a)["~type"]["url"]>;
type Body$a = z.infer<ResolveValue<(typeof _default$a)["~type"], "body">>;
type Data$a = ResolveData<Params$a, Body$a>;
type Response$a = z.infer<ResolveValue<(typeof _default$a)["~type"], "responses">["200"]>;
interface PreGameLoadoutsRequestConfig extends ValorantAxiosRequestConfig<Data$a> {
}
declare class PreGameLoadoutsEndpoint {
    /**
     * Get Pre-Game loadout data
     *
     * @EndpointType glz
     */
    getPreGameLoadouts<T = Response$a>(this: RemoteApiClient, config: PreGameLoadoutsRequestConfig): Promise<AxiosResponse<T>>;
}

declare const _default$9: Omit<{
    requirements: string[];
    type: "auth" | "local" | "pd" | "glz" | "shared";
    name: string;
    method: "PUT" | "GET" | "DELETE" | "POST";
    url: string;
    description?: string | undefined;
    headers?: Record<string, string> | undefined;
    body?: zod.ZodType<any, zod.ZodTypeDef, any> | undefined;
    query?: zod.ZodType<any, zod.ZodTypeDef, any> | undefined;
    responses?: Record<string, zod.ZodType<any, zod.ZodTypeDef, any>> | undefined;
}, "type" | "name" | "url"> & Pick<{
    readonly name: "PreGame Match";
    readonly description: "Get Pre-Game match data";
    readonly type: "glz";
    readonly url: "pregame/v1/matches/:pregameMatchId";
    readonly responses: {
        readonly "200": zod.ZodObject<{
            ID: zod.ZodString;
            Version: zod.ZodNumber;
            Teams: zod.ZodArray<zod.ZodObject<{
                TeamID: zod.ZodUnion<[zod.ZodEnum<["Blue", "Red"]>, zod.ZodString]>;
                Players: zod.ZodArray<zod.ZodObject<{
                    Subject: zod.ZodString;
                    CharacterID: zod.ZodString;
                    CharacterSelectionState: zod.ZodEnum<["", "selected", "locked"]>;
                    PregamePlayerState: zod.ZodEnum<["joined"]>;
                    CompetitiveTier: zod.ZodNumber;
                    PlayerIdentity: zod.ZodObject<{
                        Subject: zod.ZodString;
                        PlayerCardID: zod.ZodString;
                        PlayerTitleID: zod.ZodString;
                        AccountLevel: zod.ZodNumber;
                        PreferredLevelBorderID: zod.ZodUnion<[zod.ZodString, zod.ZodLiteral<"">]>;
                        Incognito: zod.ZodBoolean;
                        HideAccountLevel: zod.ZodBoolean;
                    }, "strip", zod.ZodTypeAny, {
                        Subject: string;
                        PlayerCardID: string;
                        PlayerTitleID: string;
                        AccountLevel: number;
                        PreferredLevelBorderID: string;
                        Incognito: boolean;
                        HideAccountLevel: boolean;
                    }, {
                        Subject: string;
                        PlayerCardID: string;
                        PlayerTitleID: string;
                        AccountLevel: number;
                        PreferredLevelBorderID: string;
                        Incognito: boolean;
                        HideAccountLevel: boolean;
                    }>;
                    SeasonalBadgeInfo: zod.ZodObject<{
                        SeasonID: zod.ZodUnion<[zod.ZodString, zod.ZodLiteral<"">]>;
                        NumberOfWins: zod.ZodNumber;
                        WinsByTier: zod.ZodNull;
                        Rank: zod.ZodNumber;
                        LeaderboardRank: zod.ZodNumber;
                    }, "strip", zod.ZodTypeAny, {
                        SeasonID: string;
                        NumberOfWins: number;
                        WinsByTier: null;
                        Rank: number;
                        LeaderboardRank: number;
                    }, {
                        SeasonID: string;
                        NumberOfWins: number;
                        WinsByTier: null;
                        Rank: number;
                        LeaderboardRank: number;
                    }>;
                    IsCaptain: zod.ZodBoolean;
                }, "strip", zod.ZodTypeAny, {
                    CharacterID: string;
                    Subject: string;
                    PlayerIdentity: {
                        Subject: string;
                        PlayerCardID: string;
                        PlayerTitleID: string;
                        AccountLevel: number;
                        PreferredLevelBorderID: string;
                        Incognito: boolean;
                        HideAccountLevel: boolean;
                    };
                    SeasonalBadgeInfo: {
                        SeasonID: string;
                        NumberOfWins: number;
                        WinsByTier: null;
                        Rank: number;
                        LeaderboardRank: number;
                    };
                    CompetitiveTier: number;
                    CharacterSelectionState: "" | "selected" | "locked";
                    PregamePlayerState: "joined";
                    IsCaptain: boolean;
                }, {
                    CharacterID: string;
                    Subject: string;
                    PlayerIdentity: {
                        Subject: string;
                        PlayerCardID: string;
                        PlayerTitleID: string;
                        AccountLevel: number;
                        PreferredLevelBorderID: string;
                        Incognito: boolean;
                        HideAccountLevel: boolean;
                    };
                    SeasonalBadgeInfo: {
                        SeasonID: string;
                        NumberOfWins: number;
                        WinsByTier: null;
                        Rank: number;
                        LeaderboardRank: number;
                    };
                    CompetitiveTier: number;
                    CharacterSelectionState: "" | "selected" | "locked";
                    PregamePlayerState: "joined";
                    IsCaptain: boolean;
                }>, "many">;
            }, "strip", zod.ZodTypeAny, {
                Players: {
                    CharacterID: string;
                    Subject: string;
                    PlayerIdentity: {
                        Subject: string;
                        PlayerCardID: string;
                        PlayerTitleID: string;
                        AccountLevel: number;
                        PreferredLevelBorderID: string;
                        Incognito: boolean;
                        HideAccountLevel: boolean;
                    };
                    SeasonalBadgeInfo: {
                        SeasonID: string;
                        NumberOfWins: number;
                        WinsByTier: null;
                        Rank: number;
                        LeaderboardRank: number;
                    };
                    CompetitiveTier: number;
                    CharacterSelectionState: "" | "selected" | "locked";
                    PregamePlayerState: "joined";
                    IsCaptain: boolean;
                }[];
                TeamID: string;
            }, {
                Players: {
                    CharacterID: string;
                    Subject: string;
                    PlayerIdentity: {
                        Subject: string;
                        PlayerCardID: string;
                        PlayerTitleID: string;
                        AccountLevel: number;
                        PreferredLevelBorderID: string;
                        Incognito: boolean;
                        HideAccountLevel: boolean;
                    };
                    SeasonalBadgeInfo: {
                        SeasonID: string;
                        NumberOfWins: number;
                        WinsByTier: null;
                        Rank: number;
                        LeaderboardRank: number;
                    };
                    CompetitiveTier: number;
                    CharacterSelectionState: "" | "selected" | "locked";
                    PregamePlayerState: "joined";
                    IsCaptain: boolean;
                }[];
                TeamID: string;
            }>, "many">;
            AllyTeam: zod.ZodNullable<zod.ZodObject<{
                TeamID: zod.ZodUnion<[zod.ZodEnum<["Blue", "Red"]>, zod.ZodString]>;
                Players: zod.ZodArray<zod.ZodObject<{
                    Subject: zod.ZodString;
                    CharacterID: zod.ZodString;
                    CharacterSelectionState: zod.ZodEnum<["", "selected", "locked"]>;
                    PregamePlayerState: zod.ZodEnum<["joined"]>;
                    CompetitiveTier: zod.ZodNumber;
                    PlayerIdentity: zod.ZodObject<{
                        Subject: zod.ZodString;
                        PlayerCardID: zod.ZodString;
                        PlayerTitleID: zod.ZodString;
                        AccountLevel: zod.ZodNumber;
                        PreferredLevelBorderID: zod.ZodUnion<[zod.ZodString, zod.ZodLiteral<"">]>;
                        Incognito: zod.ZodBoolean;
                        HideAccountLevel: zod.ZodBoolean;
                    }, "strip", zod.ZodTypeAny, {
                        Subject: string;
                        PlayerCardID: string;
                        PlayerTitleID: string;
                        AccountLevel: number;
                        PreferredLevelBorderID: string;
                        Incognito: boolean;
                        HideAccountLevel: boolean;
                    }, {
                        Subject: string;
                        PlayerCardID: string;
                        PlayerTitleID: string;
                        AccountLevel: number;
                        PreferredLevelBorderID: string;
                        Incognito: boolean;
                        HideAccountLevel: boolean;
                    }>;
                    SeasonalBadgeInfo: zod.ZodObject<{
                        SeasonID: zod.ZodUnion<[zod.ZodString, zod.ZodLiteral<"">]>;
                        NumberOfWins: zod.ZodNumber;
                        WinsByTier: zod.ZodNull;
                        Rank: zod.ZodNumber;
                        LeaderboardRank: zod.ZodNumber;
                    }, "strip", zod.ZodTypeAny, {
                        SeasonID: string;
                        NumberOfWins: number;
                        WinsByTier: null;
                        Rank: number;
                        LeaderboardRank: number;
                    }, {
                        SeasonID: string;
                        NumberOfWins: number;
                        WinsByTier: null;
                        Rank: number;
                        LeaderboardRank: number;
                    }>;
                    IsCaptain: zod.ZodBoolean;
                }, "strip", zod.ZodTypeAny, {
                    CharacterID: string;
                    Subject: string;
                    PlayerIdentity: {
                        Subject: string;
                        PlayerCardID: string;
                        PlayerTitleID: string;
                        AccountLevel: number;
                        PreferredLevelBorderID: string;
                        Incognito: boolean;
                        HideAccountLevel: boolean;
                    };
                    SeasonalBadgeInfo: {
                        SeasonID: string;
                        NumberOfWins: number;
                        WinsByTier: null;
                        Rank: number;
                        LeaderboardRank: number;
                    };
                    CompetitiveTier: number;
                    CharacterSelectionState: "" | "selected" | "locked";
                    PregamePlayerState: "joined";
                    IsCaptain: boolean;
                }, {
                    CharacterID: string;
                    Subject: string;
                    PlayerIdentity: {
                        Subject: string;
                        PlayerCardID: string;
                        PlayerTitleID: string;
                        AccountLevel: number;
                        PreferredLevelBorderID: string;
                        Incognito: boolean;
                        HideAccountLevel: boolean;
                    };
                    SeasonalBadgeInfo: {
                        SeasonID: string;
                        NumberOfWins: number;
                        WinsByTier: null;
                        Rank: number;
                        LeaderboardRank: number;
                    };
                    CompetitiveTier: number;
                    CharacterSelectionState: "" | "selected" | "locked";
                    PregamePlayerState: "joined";
                    IsCaptain: boolean;
                }>, "many">;
            }, "strip", zod.ZodTypeAny, {
                Players: {
                    CharacterID: string;
                    Subject: string;
                    PlayerIdentity: {
                        Subject: string;
                        PlayerCardID: string;
                        PlayerTitleID: string;
                        AccountLevel: number;
                        PreferredLevelBorderID: string;
                        Incognito: boolean;
                        HideAccountLevel: boolean;
                    };
                    SeasonalBadgeInfo: {
                        SeasonID: string;
                        NumberOfWins: number;
                        WinsByTier: null;
                        Rank: number;
                        LeaderboardRank: number;
                    };
                    CompetitiveTier: number;
                    CharacterSelectionState: "" | "selected" | "locked";
                    PregamePlayerState: "joined";
                    IsCaptain: boolean;
                }[];
                TeamID: string;
            }, {
                Players: {
                    CharacterID: string;
                    Subject: string;
                    PlayerIdentity: {
                        Subject: string;
                        PlayerCardID: string;
                        PlayerTitleID: string;
                        AccountLevel: number;
                        PreferredLevelBorderID: string;
                        Incognito: boolean;
                        HideAccountLevel: boolean;
                    };
                    SeasonalBadgeInfo: {
                        SeasonID: string;
                        NumberOfWins: number;
                        WinsByTier: null;
                        Rank: number;
                        LeaderboardRank: number;
                    };
                    CompetitiveTier: number;
                    CharacterSelectionState: "" | "selected" | "locked";
                    PregamePlayerState: "joined";
                    IsCaptain: boolean;
                }[];
                TeamID: string;
            }>>;
            EnemyTeam: zod.ZodNullable<zod.ZodObject<{
                TeamID: zod.ZodUnion<[zod.ZodEnum<["Blue", "Red"]>, zod.ZodString]>;
                Players: zod.ZodArray<zod.ZodObject<{
                    Subject: zod.ZodString;
                    CharacterID: zod.ZodString;
                    CharacterSelectionState: zod.ZodEnum<["", "selected", "locked"]>;
                    PregamePlayerState: zod.ZodEnum<["joined"]>;
                    CompetitiveTier: zod.ZodNumber;
                    PlayerIdentity: zod.ZodObject<{
                        Subject: zod.ZodString;
                        PlayerCardID: zod.ZodString;
                        PlayerTitleID: zod.ZodString;
                        AccountLevel: zod.ZodNumber;
                        PreferredLevelBorderID: zod.ZodUnion<[zod.ZodString, zod.ZodLiteral<"">]>;
                        Incognito: zod.ZodBoolean;
                        HideAccountLevel: zod.ZodBoolean;
                    }, "strip", zod.ZodTypeAny, {
                        Subject: string;
                        PlayerCardID: string;
                        PlayerTitleID: string;
                        AccountLevel: number;
                        PreferredLevelBorderID: string;
                        Incognito: boolean;
                        HideAccountLevel: boolean;
                    }, {
                        Subject: string;
                        PlayerCardID: string;
                        PlayerTitleID: string;
                        AccountLevel: number;
                        PreferredLevelBorderID: string;
                        Incognito: boolean;
                        HideAccountLevel: boolean;
                    }>;
                    SeasonalBadgeInfo: zod.ZodObject<{
                        SeasonID: zod.ZodUnion<[zod.ZodString, zod.ZodLiteral<"">]>;
                        NumberOfWins: zod.ZodNumber;
                        WinsByTier: zod.ZodNull;
                        Rank: zod.ZodNumber;
                        LeaderboardRank: zod.ZodNumber;
                    }, "strip", zod.ZodTypeAny, {
                        SeasonID: string;
                        NumberOfWins: number;
                        WinsByTier: null;
                        Rank: number;
                        LeaderboardRank: number;
                    }, {
                        SeasonID: string;
                        NumberOfWins: number;
                        WinsByTier: null;
                        Rank: number;
                        LeaderboardRank: number;
                    }>;
                    IsCaptain: zod.ZodBoolean;
                }, "strip", zod.ZodTypeAny, {
                    CharacterID: string;
                    Subject: string;
                    PlayerIdentity: {
                        Subject: string;
                        PlayerCardID: string;
                        PlayerTitleID: string;
                        AccountLevel: number;
                        PreferredLevelBorderID: string;
                        Incognito: boolean;
                        HideAccountLevel: boolean;
                    };
                    SeasonalBadgeInfo: {
                        SeasonID: string;
                        NumberOfWins: number;
                        WinsByTier: null;
                        Rank: number;
                        LeaderboardRank: number;
                    };
                    CompetitiveTier: number;
                    CharacterSelectionState: "" | "selected" | "locked";
                    PregamePlayerState: "joined";
                    IsCaptain: boolean;
                }, {
                    CharacterID: string;
                    Subject: string;
                    PlayerIdentity: {
                        Subject: string;
                        PlayerCardID: string;
                        PlayerTitleID: string;
                        AccountLevel: number;
                        PreferredLevelBorderID: string;
                        Incognito: boolean;
                        HideAccountLevel: boolean;
                    };
                    SeasonalBadgeInfo: {
                        SeasonID: string;
                        NumberOfWins: number;
                        WinsByTier: null;
                        Rank: number;
                        LeaderboardRank: number;
                    };
                    CompetitiveTier: number;
                    CharacterSelectionState: "" | "selected" | "locked";
                    PregamePlayerState: "joined";
                    IsCaptain: boolean;
                }>, "many">;
            }, "strip", zod.ZodTypeAny, {
                Players: {
                    CharacterID: string;
                    Subject: string;
                    PlayerIdentity: {
                        Subject: string;
                        PlayerCardID: string;
                        PlayerTitleID: string;
                        AccountLevel: number;
                        PreferredLevelBorderID: string;
                        Incognito: boolean;
                        HideAccountLevel: boolean;
                    };
                    SeasonalBadgeInfo: {
                        SeasonID: string;
                        NumberOfWins: number;
                        WinsByTier: null;
                        Rank: number;
                        LeaderboardRank: number;
                    };
                    CompetitiveTier: number;
                    CharacterSelectionState: "" | "selected" | "locked";
                    PregamePlayerState: "joined";
                    IsCaptain: boolean;
                }[];
                TeamID: string;
            }, {
                Players: {
                    CharacterID: string;
                    Subject: string;
                    PlayerIdentity: {
                        Subject: string;
                        PlayerCardID: string;
                        PlayerTitleID: string;
                        AccountLevel: number;
                        PreferredLevelBorderID: string;
                        Incognito: boolean;
                        HideAccountLevel: boolean;
                    };
                    SeasonalBadgeInfo: {
                        SeasonID: string;
                        NumberOfWins: number;
                        WinsByTier: null;
                        Rank: number;
                        LeaderboardRank: number;
                    };
                    CompetitiveTier: number;
                    CharacterSelectionState: "" | "selected" | "locked";
                    PregamePlayerState: "joined";
                    IsCaptain: boolean;
                }[];
                TeamID: string;
            }>>;
            ObserverSubjects: zod.ZodArray<zod.ZodUnknown, "many">;
            MatchCoaches: zod.ZodArray<zod.ZodUnknown, "many">;
            EnemyTeamSize: zod.ZodNumber;
            EnemyTeamLockCount: zod.ZodNumber;
            PregameState: zod.ZodEnum<["character_select_active", "provisioned"]>;
            LastUpdated: zod.ZodEffects<zod.ZodString, Date, string>;
            MapID: zod.ZodString;
            MapSelectPool: zod.ZodArray<zod.ZodUnknown, "many">;
            BannedMapIDs: zod.ZodArray<zod.ZodUnknown, "many">;
            CastedVotes: zod.ZodUnknown;
            MapSelectSteps: zod.ZodArray<zod.ZodUnknown, "many">;
            MapSelectStep: zod.ZodNumber;
            Team1: zod.ZodUnion<[zod.ZodEnum<["Blue", "Red"]>, zod.ZodString]>;
            GamePodID: zod.ZodString;
            Mode: zod.ZodString;
            VoiceSessionID: zod.ZodString;
            MUCName: zod.ZodString;
            TeamMatchToken: zod.ZodString;
            QueueID: zod.ZodUnion<[zod.ZodString, zod.ZodLiteral<"">]>;
            ProvisioningFlowID: zod.ZodEnum<["Matchmaking", "CustomGame"]>;
            IsRanked: zod.ZodBoolean;
            PhaseTimeRemainingNS: zod.ZodNumber;
            StepTimeRemainingNS: zod.ZodNumber;
            altModesFlagADA: zod.ZodBoolean;
            TournamentMetadata: zod.ZodNull;
            RosterMetadata: zod.ZodNull;
        }, "strip", zod.ZodTypeAny, {
            ID: string;
            Version: number;
            QueueID: string;
            Mode: string;
            IsRanked: boolean;
            MapID: string;
            GamePodID: string;
            TeamMatchToken: string;
            MUCName: string;
            Teams: {
                Players: {
                    CharacterID: string;
                    Subject: string;
                    PlayerIdentity: {
                        Subject: string;
                        PlayerCardID: string;
                        PlayerTitleID: string;
                        AccountLevel: number;
                        PreferredLevelBorderID: string;
                        Incognito: boolean;
                        HideAccountLevel: boolean;
                    };
                    SeasonalBadgeInfo: {
                        SeasonID: string;
                        NumberOfWins: number;
                        WinsByTier: null;
                        Rank: number;
                        LeaderboardRank: number;
                    };
                    CompetitiveTier: number;
                    CharacterSelectionState: "" | "selected" | "locked";
                    PregamePlayerState: "joined";
                    IsCaptain: boolean;
                }[];
                TeamID: string;
            }[];
            AllyTeam: {
                Players: {
                    CharacterID: string;
                    Subject: string;
                    PlayerIdentity: {
                        Subject: string;
                        PlayerCardID: string;
                        PlayerTitleID: string;
                        AccountLevel: number;
                        PreferredLevelBorderID: string;
                        Incognito: boolean;
                        HideAccountLevel: boolean;
                    };
                    SeasonalBadgeInfo: {
                        SeasonID: string;
                        NumberOfWins: number;
                        WinsByTier: null;
                        Rank: number;
                        LeaderboardRank: number;
                    };
                    CompetitiveTier: number;
                    CharacterSelectionState: "" | "selected" | "locked";
                    PregamePlayerState: "joined";
                    IsCaptain: boolean;
                }[];
                TeamID: string;
            } | null;
            EnemyTeam: {
                Players: {
                    CharacterID: string;
                    Subject: string;
                    PlayerIdentity: {
                        Subject: string;
                        PlayerCardID: string;
                        PlayerTitleID: string;
                        AccountLevel: number;
                        PreferredLevelBorderID: string;
                        Incognito: boolean;
                        HideAccountLevel: boolean;
                    };
                    SeasonalBadgeInfo: {
                        SeasonID: string;
                        NumberOfWins: number;
                        WinsByTier: null;
                        Rank: number;
                        LeaderboardRank: number;
                    };
                    CompetitiveTier: number;
                    CharacterSelectionState: "" | "selected" | "locked";
                    PregamePlayerState: "joined";
                    IsCaptain: boolean;
                }[];
                TeamID: string;
            } | null;
            ObserverSubjects: unknown[];
            MatchCoaches: unknown[];
            EnemyTeamSize: number;
            EnemyTeamLockCount: number;
            PregameState: "character_select_active" | "provisioned";
            LastUpdated: Date;
            MapSelectPool: unknown[];
            BannedMapIDs: unknown[];
            MapSelectSteps: unknown[];
            MapSelectStep: number;
            Team1: string;
            VoiceSessionID: string;
            ProvisioningFlowID: "Matchmaking" | "CustomGame";
            PhaseTimeRemainingNS: number;
            StepTimeRemainingNS: number;
            altModesFlagADA: boolean;
            TournamentMetadata: null;
            RosterMetadata: null;
            CastedVotes?: unknown;
        }, {
            ID: string;
            Version: number;
            QueueID: string;
            Mode: string;
            IsRanked: boolean;
            MapID: string;
            GamePodID: string;
            TeamMatchToken: string;
            MUCName: string;
            Teams: {
                Players: {
                    CharacterID: string;
                    Subject: string;
                    PlayerIdentity: {
                        Subject: string;
                        PlayerCardID: string;
                        PlayerTitleID: string;
                        AccountLevel: number;
                        PreferredLevelBorderID: string;
                        Incognito: boolean;
                        HideAccountLevel: boolean;
                    };
                    SeasonalBadgeInfo: {
                        SeasonID: string;
                        NumberOfWins: number;
                        WinsByTier: null;
                        Rank: number;
                        LeaderboardRank: number;
                    };
                    CompetitiveTier: number;
                    CharacterSelectionState: "" | "selected" | "locked";
                    PregamePlayerState: "joined";
                    IsCaptain: boolean;
                }[];
                TeamID: string;
            }[];
            AllyTeam: {
                Players: {
                    CharacterID: string;
                    Subject: string;
                    PlayerIdentity: {
                        Subject: string;
                        PlayerCardID: string;
                        PlayerTitleID: string;
                        AccountLevel: number;
                        PreferredLevelBorderID: string;
                        Incognito: boolean;
                        HideAccountLevel: boolean;
                    };
                    SeasonalBadgeInfo: {
                        SeasonID: string;
                        NumberOfWins: number;
                        WinsByTier: null;
                        Rank: number;
                        LeaderboardRank: number;
                    };
                    CompetitiveTier: number;
                    CharacterSelectionState: "" | "selected" | "locked";
                    PregamePlayerState: "joined";
                    IsCaptain: boolean;
                }[];
                TeamID: string;
            } | null;
            EnemyTeam: {
                Players: {
                    CharacterID: string;
                    Subject: string;
                    PlayerIdentity: {
                        Subject: string;
                        PlayerCardID: string;
                        PlayerTitleID: string;
                        AccountLevel: number;
                        PreferredLevelBorderID: string;
                        Incognito: boolean;
                        HideAccountLevel: boolean;
                    };
                    SeasonalBadgeInfo: {
                        SeasonID: string;
                        NumberOfWins: number;
                        WinsByTier: null;
                        Rank: number;
                        LeaderboardRank: number;
                    };
                    CompetitiveTier: number;
                    CharacterSelectionState: "" | "selected" | "locked";
                    PregamePlayerState: "joined";
                    IsCaptain: boolean;
                }[];
                TeamID: string;
            } | null;
            ObserverSubjects: unknown[];
            MatchCoaches: unknown[];
            EnemyTeamSize: number;
            EnemyTeamLockCount: number;
            PregameState: "character_select_active" | "provisioned";
            LastUpdated: string;
            MapSelectPool: unknown[];
            BannedMapIDs: unknown[];
            MapSelectSteps: unknown[];
            MapSelectStep: number;
            Team1: string;
            VoiceSessionID: string;
            ProvisioningFlowID: "Matchmaking" | "CustomGame";
            PhaseTimeRemainingNS: number;
            StepTimeRemainingNS: number;
            altModesFlagADA: boolean;
            TournamentMetadata: null;
            RosterMetadata: null;
            CastedVotes?: unknown;
        }>;
    };
}, "type" | "name" | "url"> & {
    "~type": {
        readonly name: "PreGame Match";
        readonly description: "Get Pre-Game match data";
        readonly type: "glz";
        readonly url: "pregame/v1/matches/:pregameMatchId";
        readonly responses: {
            readonly "200": zod.ZodObject<{
                ID: zod.ZodString;
                Version: zod.ZodNumber;
                Teams: zod.ZodArray<zod.ZodObject<{
                    TeamID: zod.ZodUnion<[zod.ZodEnum<["Blue", "Red"]>, zod.ZodString]>;
                    Players: zod.ZodArray<zod.ZodObject<{
                        Subject: zod.ZodString;
                        CharacterID: zod.ZodString;
                        CharacterSelectionState: zod.ZodEnum<["", "selected", "locked"]>;
                        PregamePlayerState: zod.ZodEnum<["joined"]>;
                        CompetitiveTier: zod.ZodNumber;
                        PlayerIdentity: zod.ZodObject<{
                            Subject: zod.ZodString;
                            PlayerCardID: zod.ZodString;
                            PlayerTitleID: zod.ZodString;
                            AccountLevel: zod.ZodNumber;
                            PreferredLevelBorderID: zod.ZodUnion<[zod.ZodString, zod.ZodLiteral<"">]>;
                            Incognito: zod.ZodBoolean;
                            HideAccountLevel: zod.ZodBoolean;
                        }, "strip", zod.ZodTypeAny, {
                            Subject: string;
                            PlayerCardID: string;
                            PlayerTitleID: string;
                            AccountLevel: number;
                            PreferredLevelBorderID: string;
                            Incognito: boolean;
                            HideAccountLevel: boolean;
                        }, {
                            Subject: string;
                            PlayerCardID: string;
                            PlayerTitleID: string;
                            AccountLevel: number;
                            PreferredLevelBorderID: string;
                            Incognito: boolean;
                            HideAccountLevel: boolean;
                        }>;
                        SeasonalBadgeInfo: zod.ZodObject<{
                            SeasonID: zod.ZodUnion<[zod.ZodString, zod.ZodLiteral<"">]>;
                            NumberOfWins: zod.ZodNumber;
                            WinsByTier: zod.ZodNull;
                            Rank: zod.ZodNumber;
                            LeaderboardRank: zod.ZodNumber;
                        }, "strip", zod.ZodTypeAny, {
                            SeasonID: string;
                            NumberOfWins: number;
                            WinsByTier: null;
                            Rank: number;
                            LeaderboardRank: number;
                        }, {
                            SeasonID: string;
                            NumberOfWins: number;
                            WinsByTier: null;
                            Rank: number;
                            LeaderboardRank: number;
                        }>;
                        IsCaptain: zod.ZodBoolean;
                    }, "strip", zod.ZodTypeAny, {
                        CharacterID: string;
                        Subject: string;
                        PlayerIdentity: {
                            Subject: string;
                            PlayerCardID: string;
                            PlayerTitleID: string;
                            AccountLevel: number;
                            PreferredLevelBorderID: string;
                            Incognito: boolean;
                            HideAccountLevel: boolean;
                        };
                        SeasonalBadgeInfo: {
                            SeasonID: string;
                            NumberOfWins: number;
                            WinsByTier: null;
                            Rank: number;
                            LeaderboardRank: number;
                        };
                        CompetitiveTier: number;
                        CharacterSelectionState: "" | "selected" | "locked";
                        PregamePlayerState: "joined";
                        IsCaptain: boolean;
                    }, {
                        CharacterID: string;
                        Subject: string;
                        PlayerIdentity: {
                            Subject: string;
                            PlayerCardID: string;
                            PlayerTitleID: string;
                            AccountLevel: number;
                            PreferredLevelBorderID: string;
                            Incognito: boolean;
                            HideAccountLevel: boolean;
                        };
                        SeasonalBadgeInfo: {
                            SeasonID: string;
                            NumberOfWins: number;
                            WinsByTier: null;
                            Rank: number;
                            LeaderboardRank: number;
                        };
                        CompetitiveTier: number;
                        CharacterSelectionState: "" | "selected" | "locked";
                        PregamePlayerState: "joined";
                        IsCaptain: boolean;
                    }>, "many">;
                }, "strip", zod.ZodTypeAny, {
                    Players: {
                        CharacterID: string;
                        Subject: string;
                        PlayerIdentity: {
                            Subject: string;
                            PlayerCardID: string;
                            PlayerTitleID: string;
                            AccountLevel: number;
                            PreferredLevelBorderID: string;
                            Incognito: boolean;
                            HideAccountLevel: boolean;
                        };
                        SeasonalBadgeInfo: {
                            SeasonID: string;
                            NumberOfWins: number;
                            WinsByTier: null;
                            Rank: number;
                            LeaderboardRank: number;
                        };
                        CompetitiveTier: number;
                        CharacterSelectionState: "" | "selected" | "locked";
                        PregamePlayerState: "joined";
                        IsCaptain: boolean;
                    }[];
                    TeamID: string;
                }, {
                    Players: {
                        CharacterID: string;
                        Subject: string;
                        PlayerIdentity: {
                            Subject: string;
                            PlayerCardID: string;
                            PlayerTitleID: string;
                            AccountLevel: number;
                            PreferredLevelBorderID: string;
                            Incognito: boolean;
                            HideAccountLevel: boolean;
                        };
                        SeasonalBadgeInfo: {
                            SeasonID: string;
                            NumberOfWins: number;
                            WinsByTier: null;
                            Rank: number;
                            LeaderboardRank: number;
                        };
                        CompetitiveTier: number;
                        CharacterSelectionState: "" | "selected" | "locked";
                        PregamePlayerState: "joined";
                        IsCaptain: boolean;
                    }[];
                    TeamID: string;
                }>, "many">;
                AllyTeam: zod.ZodNullable<zod.ZodObject<{
                    TeamID: zod.ZodUnion<[zod.ZodEnum<["Blue", "Red"]>, zod.ZodString]>;
                    Players: zod.ZodArray<zod.ZodObject<{
                        Subject: zod.ZodString;
                        CharacterID: zod.ZodString;
                        CharacterSelectionState: zod.ZodEnum<["", "selected", "locked"]>;
                        PregamePlayerState: zod.ZodEnum<["joined"]>;
                        CompetitiveTier: zod.ZodNumber;
                        PlayerIdentity: zod.ZodObject<{
                            Subject: zod.ZodString;
                            PlayerCardID: zod.ZodString;
                            PlayerTitleID: zod.ZodString;
                            AccountLevel: zod.ZodNumber;
                            PreferredLevelBorderID: zod.ZodUnion<[zod.ZodString, zod.ZodLiteral<"">]>;
                            Incognito: zod.ZodBoolean;
                            HideAccountLevel: zod.ZodBoolean;
                        }, "strip", zod.ZodTypeAny, {
                            Subject: string;
                            PlayerCardID: string;
                            PlayerTitleID: string;
                            AccountLevel: number;
                            PreferredLevelBorderID: string;
                            Incognito: boolean;
                            HideAccountLevel: boolean;
                        }, {
                            Subject: string;
                            PlayerCardID: string;
                            PlayerTitleID: string;
                            AccountLevel: number;
                            PreferredLevelBorderID: string;
                            Incognito: boolean;
                            HideAccountLevel: boolean;
                        }>;
                        SeasonalBadgeInfo: zod.ZodObject<{
                            SeasonID: zod.ZodUnion<[zod.ZodString, zod.ZodLiteral<"">]>;
                            NumberOfWins: zod.ZodNumber;
                            WinsByTier: zod.ZodNull;
                            Rank: zod.ZodNumber;
                            LeaderboardRank: zod.ZodNumber;
                        }, "strip", zod.ZodTypeAny, {
                            SeasonID: string;
                            NumberOfWins: number;
                            WinsByTier: null;
                            Rank: number;
                            LeaderboardRank: number;
                        }, {
                            SeasonID: string;
                            NumberOfWins: number;
                            WinsByTier: null;
                            Rank: number;
                            LeaderboardRank: number;
                        }>;
                        IsCaptain: zod.ZodBoolean;
                    }, "strip", zod.ZodTypeAny, {
                        CharacterID: string;
                        Subject: string;
                        PlayerIdentity: {
                            Subject: string;
                            PlayerCardID: string;
                            PlayerTitleID: string;
                            AccountLevel: number;
                            PreferredLevelBorderID: string;
                            Incognito: boolean;
                            HideAccountLevel: boolean;
                        };
                        SeasonalBadgeInfo: {
                            SeasonID: string;
                            NumberOfWins: number;
                            WinsByTier: null;
                            Rank: number;
                            LeaderboardRank: number;
                        };
                        CompetitiveTier: number;
                        CharacterSelectionState: "" | "selected" | "locked";
                        PregamePlayerState: "joined";
                        IsCaptain: boolean;
                    }, {
                        CharacterID: string;
                        Subject: string;
                        PlayerIdentity: {
                            Subject: string;
                            PlayerCardID: string;
                            PlayerTitleID: string;
                            AccountLevel: number;
                            PreferredLevelBorderID: string;
                            Incognito: boolean;
                            HideAccountLevel: boolean;
                        };
                        SeasonalBadgeInfo: {
                            SeasonID: string;
                            NumberOfWins: number;
                            WinsByTier: null;
                            Rank: number;
                            LeaderboardRank: number;
                        };
                        CompetitiveTier: number;
                        CharacterSelectionState: "" | "selected" | "locked";
                        PregamePlayerState: "joined";
                        IsCaptain: boolean;
                    }>, "many">;
                }, "strip", zod.ZodTypeAny, {
                    Players: {
                        CharacterID: string;
                        Subject: string;
                        PlayerIdentity: {
                            Subject: string;
                            PlayerCardID: string;
                            PlayerTitleID: string;
                            AccountLevel: number;
                            PreferredLevelBorderID: string;
                            Incognito: boolean;
                            HideAccountLevel: boolean;
                        };
                        SeasonalBadgeInfo: {
                            SeasonID: string;
                            NumberOfWins: number;
                            WinsByTier: null;
                            Rank: number;
                            LeaderboardRank: number;
                        };
                        CompetitiveTier: number;
                        CharacterSelectionState: "" | "selected" | "locked";
                        PregamePlayerState: "joined";
                        IsCaptain: boolean;
                    }[];
                    TeamID: string;
                }, {
                    Players: {
                        CharacterID: string;
                        Subject: string;
                        PlayerIdentity: {
                            Subject: string;
                            PlayerCardID: string;
                            PlayerTitleID: string;
                            AccountLevel: number;
                            PreferredLevelBorderID: string;
                            Incognito: boolean;
                            HideAccountLevel: boolean;
                        };
                        SeasonalBadgeInfo: {
                            SeasonID: string;
                            NumberOfWins: number;
                            WinsByTier: null;
                            Rank: number;
                            LeaderboardRank: number;
                        };
                        CompetitiveTier: number;
                        CharacterSelectionState: "" | "selected" | "locked";
                        PregamePlayerState: "joined";
                        IsCaptain: boolean;
                    }[];
                    TeamID: string;
                }>>;
                EnemyTeam: zod.ZodNullable<zod.ZodObject<{
                    TeamID: zod.ZodUnion<[zod.ZodEnum<["Blue", "Red"]>, zod.ZodString]>;
                    Players: zod.ZodArray<zod.ZodObject<{
                        Subject: zod.ZodString;
                        CharacterID: zod.ZodString;
                        CharacterSelectionState: zod.ZodEnum<["", "selected", "locked"]>;
                        PregamePlayerState: zod.ZodEnum<["joined"]>;
                        CompetitiveTier: zod.ZodNumber;
                        PlayerIdentity: zod.ZodObject<{
                            Subject: zod.ZodString;
                            PlayerCardID: zod.ZodString;
                            PlayerTitleID: zod.ZodString;
                            AccountLevel: zod.ZodNumber;
                            PreferredLevelBorderID: zod.ZodUnion<[zod.ZodString, zod.ZodLiteral<"">]>;
                            Incognito: zod.ZodBoolean;
                            HideAccountLevel: zod.ZodBoolean;
                        }, "strip", zod.ZodTypeAny, {
                            Subject: string;
                            PlayerCardID: string;
                            PlayerTitleID: string;
                            AccountLevel: number;
                            PreferredLevelBorderID: string;
                            Incognito: boolean;
                            HideAccountLevel: boolean;
                        }, {
                            Subject: string;
                            PlayerCardID: string;
                            PlayerTitleID: string;
                            AccountLevel: number;
                            PreferredLevelBorderID: string;
                            Incognito: boolean;
                            HideAccountLevel: boolean;
                        }>;
                        SeasonalBadgeInfo: zod.ZodObject<{
                            SeasonID: zod.ZodUnion<[zod.ZodString, zod.ZodLiteral<"">]>;
                            NumberOfWins: zod.ZodNumber;
                            WinsByTier: zod.ZodNull;
                            Rank: zod.ZodNumber;
                            LeaderboardRank: zod.ZodNumber;
                        }, "strip", zod.ZodTypeAny, {
                            SeasonID: string;
                            NumberOfWins: number;
                            WinsByTier: null;
                            Rank: number;
                            LeaderboardRank: number;
                        }, {
                            SeasonID: string;
                            NumberOfWins: number;
                            WinsByTier: null;
                            Rank: number;
                            LeaderboardRank: number;
                        }>;
                        IsCaptain: zod.ZodBoolean;
                    }, "strip", zod.ZodTypeAny, {
                        CharacterID: string;
                        Subject: string;
                        PlayerIdentity: {
                            Subject: string;
                            PlayerCardID: string;
                            PlayerTitleID: string;
                            AccountLevel: number;
                            PreferredLevelBorderID: string;
                            Incognito: boolean;
                            HideAccountLevel: boolean;
                        };
                        SeasonalBadgeInfo: {
                            SeasonID: string;
                            NumberOfWins: number;
                            WinsByTier: null;
                            Rank: number;
                            LeaderboardRank: number;
                        };
                        CompetitiveTier: number;
                        CharacterSelectionState: "" | "selected" | "locked";
                        PregamePlayerState: "joined";
                        IsCaptain: boolean;
                    }, {
                        CharacterID: string;
                        Subject: string;
                        PlayerIdentity: {
                            Subject: string;
                            PlayerCardID: string;
                            PlayerTitleID: string;
                            AccountLevel: number;
                            PreferredLevelBorderID: string;
                            Incognito: boolean;
                            HideAccountLevel: boolean;
                        };
                        SeasonalBadgeInfo: {
                            SeasonID: string;
                            NumberOfWins: number;
                            WinsByTier: null;
                            Rank: number;
                            LeaderboardRank: number;
                        };
                        CompetitiveTier: number;
                        CharacterSelectionState: "" | "selected" | "locked";
                        PregamePlayerState: "joined";
                        IsCaptain: boolean;
                    }>, "many">;
                }, "strip", zod.ZodTypeAny, {
                    Players: {
                        CharacterID: string;
                        Subject: string;
                        PlayerIdentity: {
                            Subject: string;
                            PlayerCardID: string;
                            PlayerTitleID: string;
                            AccountLevel: number;
                            PreferredLevelBorderID: string;
                            Incognito: boolean;
                            HideAccountLevel: boolean;
                        };
                        SeasonalBadgeInfo: {
                            SeasonID: string;
                            NumberOfWins: number;
                            WinsByTier: null;
                            Rank: number;
                            LeaderboardRank: number;
                        };
                        CompetitiveTier: number;
                        CharacterSelectionState: "" | "selected" | "locked";
                        PregamePlayerState: "joined";
                        IsCaptain: boolean;
                    }[];
                    TeamID: string;
                }, {
                    Players: {
                        CharacterID: string;
                        Subject: string;
                        PlayerIdentity: {
                            Subject: string;
                            PlayerCardID: string;
                            PlayerTitleID: string;
                            AccountLevel: number;
                            PreferredLevelBorderID: string;
                            Incognito: boolean;
                            HideAccountLevel: boolean;
                        };
                        SeasonalBadgeInfo: {
                            SeasonID: string;
                            NumberOfWins: number;
                            WinsByTier: null;
                            Rank: number;
                            LeaderboardRank: number;
                        };
                        CompetitiveTier: number;
                        CharacterSelectionState: "" | "selected" | "locked";
                        PregamePlayerState: "joined";
                        IsCaptain: boolean;
                    }[];
                    TeamID: string;
                }>>;
                ObserverSubjects: zod.ZodArray<zod.ZodUnknown, "many">;
                MatchCoaches: zod.ZodArray<zod.ZodUnknown, "many">;
                EnemyTeamSize: zod.ZodNumber;
                EnemyTeamLockCount: zod.ZodNumber;
                PregameState: zod.ZodEnum<["character_select_active", "provisioned"]>;
                LastUpdated: zod.ZodEffects<zod.ZodString, Date, string>;
                MapID: zod.ZodString;
                MapSelectPool: zod.ZodArray<zod.ZodUnknown, "many">;
                BannedMapIDs: zod.ZodArray<zod.ZodUnknown, "many">;
                CastedVotes: zod.ZodUnknown;
                MapSelectSteps: zod.ZodArray<zod.ZodUnknown, "many">;
                MapSelectStep: zod.ZodNumber;
                Team1: zod.ZodUnion<[zod.ZodEnum<["Blue", "Red"]>, zod.ZodString]>;
                GamePodID: zod.ZodString;
                Mode: zod.ZodString;
                VoiceSessionID: zod.ZodString;
                MUCName: zod.ZodString;
                TeamMatchToken: zod.ZodString;
                QueueID: zod.ZodUnion<[zod.ZodString, zod.ZodLiteral<"">]>;
                ProvisioningFlowID: zod.ZodEnum<["Matchmaking", "CustomGame"]>;
                IsRanked: zod.ZodBoolean;
                PhaseTimeRemainingNS: zod.ZodNumber;
                StepTimeRemainingNS: zod.ZodNumber;
                altModesFlagADA: zod.ZodBoolean;
                TournamentMetadata: zod.ZodNull;
                RosterMetadata: zod.ZodNull;
            }, "strip", zod.ZodTypeAny, {
                ID: string;
                Version: number;
                QueueID: string;
                Mode: string;
                IsRanked: boolean;
                MapID: string;
                GamePodID: string;
                TeamMatchToken: string;
                MUCName: string;
                Teams: {
                    Players: {
                        CharacterID: string;
                        Subject: string;
                        PlayerIdentity: {
                            Subject: string;
                            PlayerCardID: string;
                            PlayerTitleID: string;
                            AccountLevel: number;
                            PreferredLevelBorderID: string;
                            Incognito: boolean;
                            HideAccountLevel: boolean;
                        };
                        SeasonalBadgeInfo: {
                            SeasonID: string;
                            NumberOfWins: number;
                            WinsByTier: null;
                            Rank: number;
                            LeaderboardRank: number;
                        };
                        CompetitiveTier: number;
                        CharacterSelectionState: "" | "selected" | "locked";
                        PregamePlayerState: "joined";
                        IsCaptain: boolean;
                    }[];
                    TeamID: string;
                }[];
                AllyTeam: {
                    Players: {
                        CharacterID: string;
                        Subject: string;
                        PlayerIdentity: {
                            Subject: string;
                            PlayerCardID: string;
                            PlayerTitleID: string;
                            AccountLevel: number;
                            PreferredLevelBorderID: string;
                            Incognito: boolean;
                            HideAccountLevel: boolean;
                        };
                        SeasonalBadgeInfo: {
                            SeasonID: string;
                            NumberOfWins: number;
                            WinsByTier: null;
                            Rank: number;
                            LeaderboardRank: number;
                        };
                        CompetitiveTier: number;
                        CharacterSelectionState: "" | "selected" | "locked";
                        PregamePlayerState: "joined";
                        IsCaptain: boolean;
                    }[];
                    TeamID: string;
                } | null;
                EnemyTeam: {
                    Players: {
                        CharacterID: string;
                        Subject: string;
                        PlayerIdentity: {
                            Subject: string;
                            PlayerCardID: string;
                            PlayerTitleID: string;
                            AccountLevel: number;
                            PreferredLevelBorderID: string;
                            Incognito: boolean;
                            HideAccountLevel: boolean;
                        };
                        SeasonalBadgeInfo: {
                            SeasonID: string;
                            NumberOfWins: number;
                            WinsByTier: null;
                            Rank: number;
                            LeaderboardRank: number;
                        };
                        CompetitiveTier: number;
                        CharacterSelectionState: "" | "selected" | "locked";
                        PregamePlayerState: "joined";
                        IsCaptain: boolean;
                    }[];
                    TeamID: string;
                } | null;
                ObserverSubjects: unknown[];
                MatchCoaches: unknown[];
                EnemyTeamSize: number;
                EnemyTeamLockCount: number;
                PregameState: "character_select_active" | "provisioned";
                LastUpdated: Date;
                MapSelectPool: unknown[];
                BannedMapIDs: unknown[];
                MapSelectSteps: unknown[];
                MapSelectStep: number;
                Team1: string;
                VoiceSessionID: string;
                ProvisioningFlowID: "Matchmaking" | "CustomGame";
                PhaseTimeRemainingNS: number;
                StepTimeRemainingNS: number;
                altModesFlagADA: boolean;
                TournamentMetadata: null;
                RosterMetadata: null;
                CastedVotes?: unknown;
            }, {
                ID: string;
                Version: number;
                QueueID: string;
                Mode: string;
                IsRanked: boolean;
                MapID: string;
                GamePodID: string;
                TeamMatchToken: string;
                MUCName: string;
                Teams: {
                    Players: {
                        CharacterID: string;
                        Subject: string;
                        PlayerIdentity: {
                            Subject: string;
                            PlayerCardID: string;
                            PlayerTitleID: string;
                            AccountLevel: number;
                            PreferredLevelBorderID: string;
                            Incognito: boolean;
                            HideAccountLevel: boolean;
                        };
                        SeasonalBadgeInfo: {
                            SeasonID: string;
                            NumberOfWins: number;
                            WinsByTier: null;
                            Rank: number;
                            LeaderboardRank: number;
                        };
                        CompetitiveTier: number;
                        CharacterSelectionState: "" | "selected" | "locked";
                        PregamePlayerState: "joined";
                        IsCaptain: boolean;
                    }[];
                    TeamID: string;
                }[];
                AllyTeam: {
                    Players: {
                        CharacterID: string;
                        Subject: string;
                        PlayerIdentity: {
                            Subject: string;
                            PlayerCardID: string;
                            PlayerTitleID: string;
                            AccountLevel: number;
                            PreferredLevelBorderID: string;
                            Incognito: boolean;
                            HideAccountLevel: boolean;
                        };
                        SeasonalBadgeInfo: {
                            SeasonID: string;
                            NumberOfWins: number;
                            WinsByTier: null;
                            Rank: number;
                            LeaderboardRank: number;
                        };
                        CompetitiveTier: number;
                        CharacterSelectionState: "" | "selected" | "locked";
                        PregamePlayerState: "joined";
                        IsCaptain: boolean;
                    }[];
                    TeamID: string;
                } | null;
                EnemyTeam: {
                    Players: {
                        CharacterID: string;
                        Subject: string;
                        PlayerIdentity: {
                            Subject: string;
                            PlayerCardID: string;
                            PlayerTitleID: string;
                            AccountLevel: number;
                            PreferredLevelBorderID: string;
                            Incognito: boolean;
                            HideAccountLevel: boolean;
                        };
                        SeasonalBadgeInfo: {
                            SeasonID: string;
                            NumberOfWins: number;
                            WinsByTier: null;
                            Rank: number;
                            LeaderboardRank: number;
                        };
                        CompetitiveTier: number;
                        CharacterSelectionState: "" | "selected" | "locked";
                        PregamePlayerState: "joined";
                        IsCaptain: boolean;
                    }[];
                    TeamID: string;
                } | null;
                ObserverSubjects: unknown[];
                MatchCoaches: unknown[];
                EnemyTeamSize: number;
                EnemyTeamLockCount: number;
                PregameState: "character_select_active" | "provisioned";
                LastUpdated: string;
                MapSelectPool: unknown[];
                BannedMapIDs: unknown[];
                MapSelectSteps: unknown[];
                MapSelectStep: number;
                Team1: string;
                VoiceSessionID: string;
                ProvisioningFlowID: "Matchmaking" | "CustomGame";
                PhaseTimeRemainingNS: number;
                StepTimeRemainingNS: number;
                altModesFlagADA: boolean;
                TournamentMetadata: null;
                RosterMetadata: null;
                CastedVotes?: unknown;
            }>;
        };
    };
};

type Params$9 = ResolveParams<(typeof _default$9)["~type"]["url"]>;
type Body$9 = z.infer<ResolveValue<(typeof _default$9)["~type"], "body">>;
type Data$9 = ResolveData<Params$9, Body$9>;
type Response$9 = z.infer<ResolveValue<(typeof _default$9)["~type"], "responses">["200"]>;
interface PreGameMatchRequestConfig extends ValorantAxiosRequestConfig<Data$9> {
}
declare class PreGameMatchEndpoint {
    /**
     * Get Pre-Game match data
     *
     * @EndpointType glz
     */
    getPreGameMatch<T = Response$9>(this: RemoteApiClient, config: PreGameMatchRequestConfig): Promise<AxiosResponse<T>>;
}

declare const PreGamePlayerResponseSchema: z.ZodObject<{
    Subject: z.ZodString;
    MatchID: z.ZodString;
    Version: z.ZodNumber;
}, "strip", z.ZodTypeAny, {
    Subject: string;
    Version: number;
    MatchID: string;
}, {
    Subject: string;
    Version: number;
    MatchID: string;
}>;
declare const _default$8: Omit<{
    requirements: string[];
    type: "auth" | "local" | "pd" | "glz" | "shared";
    name: string;
    method: "PUT" | "GET" | "DELETE" | "POST";
    url: string;
    description?: string | undefined;
    headers?: Record<string, string> | undefined;
    body?: z.ZodType<any, z.ZodTypeDef, any> | undefined;
    query?: z.ZodType<any, z.ZodTypeDef, any> | undefined;
    responses?: Record<string, z.ZodType<any, z.ZodTypeDef, any>> | undefined;
}, "type" | "name" | "url"> & Pick<{
    readonly name: "PreGame Player";
    readonly description: "Get the pre-game match ID for the provided player";
    readonly type: "glz";
    readonly url: "pregame/v1/players/:puuid";
    readonly responses: {
        readonly "200": z.ZodObject<{
            Subject: z.ZodString;
            MatchID: z.ZodString;
            Version: z.ZodNumber;
        }, "strip", z.ZodTypeAny, {
            Subject: string;
            Version: number;
            MatchID: string;
        }, {
            Subject: string;
            Version: number;
            MatchID: string;
        }>;
    };
}, "type" | "name" | "url"> & {
    "~type": {
        readonly name: "PreGame Player";
        readonly description: "Get the pre-game match ID for the provided player";
        readonly type: "glz";
        readonly url: "pregame/v1/players/:puuid";
        readonly responses: {
            readonly "200": z.ZodObject<{
                Subject: z.ZodString;
                MatchID: z.ZodString;
                Version: z.ZodNumber;
            }, "strip", z.ZodTypeAny, {
                Subject: string;
                Version: number;
                MatchID: string;
            }, {
                Subject: string;
                Version: number;
                MatchID: string;
            }>;
        };
    };
};

type Params$8 = ResolveParams<(typeof _default$8)["~type"]["url"]>;
type Body$8 = z.infer<ResolveValue<(typeof _default$8)["~type"], "body">>;
type Data$8 = ResolveData<Params$8, Body$8>;
type Response$8 = z.infer<ResolveValue<(typeof _default$8)["~type"], "responses">["200"]>;
interface PreGamePlayerRequestConfig extends ValorantAxiosRequestConfig<Data$8> {
}
declare class PreGamePlayerEndpoint {
    /**
     * Get the pre-game match ID for the provided player
     *
     * @EndpointType glz
     */
    getPreGamePlayer<T = Response$8>(this: RemoteApiClient, config?: PreGamePlayerRequestConfig): Promise<AxiosResponse<T>>;
}

declare const _default$7: Omit<{
    requirements: string[];
    type: "auth" | "local" | "pd" | "glz" | "shared";
    name: string;
    method: "PUT" | "GET" | "DELETE" | "POST";
    url: string;
    description?: string | undefined;
    headers?: Record<string, string> | undefined;
    body?: z.ZodType<any, z.ZodTypeDef, any> | undefined;
    query?: z.ZodType<any, z.ZodTypeDef, any> | undefined;
    responses?: Record<string, z.ZodType<any, z.ZodTypeDef, any>> | undefined;
}, "type" | "name" | "url"> & Pick<{
    readonly name: "PreGame Quit";
    readonly description: "Quit the pre-game lobby";
    readonly type: "glz";
    readonly method: "POST";
    readonly url: "pregame/v1/matches/:pregameMatchId/quit";
    readonly responses: {
        readonly "204": z.ZodUndefined;
    };
}, "type" | "name" | "url"> & {
    "~type": {
        readonly name: "PreGame Quit";
        readonly description: "Quit the pre-game lobby";
        readonly type: "glz";
        readonly method: "POST";
        readonly url: "pregame/v1/matches/:pregameMatchId/quit";
        readonly responses: {
            readonly "204": z.ZodUndefined;
        };
    };
};

type Params$7 = ResolveParams<(typeof _default$7)["~type"]["url"]>;
type Body$7 = z.infer<ResolveValue<(typeof _default$7)["~type"], "body">>;
type Data$7 = ResolveData<Params$7, Body$7>;
type Response$7 = z.infer<ResolveValue<(typeof _default$7)["~type"], "responses">["204"]>;
interface PreGameQuitRequestConfig extends ValorantAxiosRequestConfig<Data$7> {
}
declare class PreGameQuitEndpoint {
    /**
     * Quit the pre-game lobby
     *
     * @EndpointType glz
     */
    postPreGameQuit<T = Response$7>(this: RemoteApiClient, config: PreGameQuitRequestConfig): Promise<AxiosResponse<T>>;
}

declare const _default$6: Omit<{
    requirements: string[];
    type: "auth" | "local" | "pd" | "glz" | "shared";
    name: string;
    method: "PUT" | "GET" | "DELETE" | "POST";
    url: string;
    description?: string | undefined;
    headers?: Record<string, string> | undefined;
    body?: zod.ZodType<any, zod.ZodTypeDef, any> | undefined;
    query?: zod.ZodType<any, zod.ZodTypeDef, any> | undefined;
    responses?: Record<string, zod.ZodType<any, zod.ZodTypeDef, any>> | undefined;
}, "type" | "name" | "url"> & Pick<{
    readonly name: "Refresh Competitive Tier";
    readonly description: "Refresh the competitive tier of the specified player";
    readonly type: "glz";
    readonly method: "POST";
    readonly url: "parties/v1/parties/:partyId/members/:puuid/refreshCompetitiveTier";
    readonly responses: {
        readonly "200": zod.ZodObject<{
            ID: zod.ZodString;
            MUCName: zod.ZodString;
            VoiceRoomID: zod.ZodString;
            Version: zod.ZodNumber;
            ClientVersion: zod.ZodString;
            Members: zod.ZodArray<zod.ZodObject<{
                Subject: zod.ZodString;
                CompetitiveTier: zod.ZodNumber;
                PlayerIdentity: zod.ZodObject<{
                    Subject: zod.ZodString;
                    PlayerCardID: zod.ZodString;
                    PlayerTitleID: zod.ZodString;
                    AccountLevel: zod.ZodNumber;
                    PreferredLevelBorderID: zod.ZodUnion<[zod.ZodString, zod.ZodLiteral<"">]>;
                    Incognito: zod.ZodBoolean;
                    HideAccountLevel: zod.ZodBoolean;
                }, "strip", zod.ZodTypeAny, {
                    Subject: string;
                    PlayerCardID: string;
                    PlayerTitleID: string;
                    AccountLevel: number;
                    PreferredLevelBorderID: string;
                    Incognito: boolean;
                    HideAccountLevel: boolean;
                }, {
                    Subject: string;
                    PlayerCardID: string;
                    PlayerTitleID: string;
                    AccountLevel: number;
                    PreferredLevelBorderID: string;
                    Incognito: boolean;
                    HideAccountLevel: boolean;
                }>;
                SeasonalBadgeInfo: zod.ZodNull;
                IsOwner: zod.ZodOptional<zod.ZodBoolean>;
                QueueEligibleRemainingAccountLevels: zod.ZodNumber;
                Pings: zod.ZodArray<zod.ZodObject<{
                    Ping: zod.ZodNumber;
                    GamePodID: zod.ZodString;
                }, "strip", zod.ZodTypeAny, {
                    GamePodID: string;
                    Ping: number;
                }, {
                    GamePodID: string;
                    Ping: number;
                }>, "many">;
                IsReady: zod.ZodBoolean;
                IsModerator: zod.ZodBoolean;
                UseBroadcastHUD: zod.ZodBoolean;
                PlatformType: zod.ZodLiteral<"PC">;
            }, "strip", zod.ZodTypeAny, {
                Subject: string;
                PlayerIdentity: {
                    Subject: string;
                    PlayerCardID: string;
                    PlayerTitleID: string;
                    AccountLevel: number;
                    PreferredLevelBorderID: string;
                    Incognito: boolean;
                    HideAccountLevel: boolean;
                };
                SeasonalBadgeInfo: null;
                CompetitiveTier: number;
                QueueEligibleRemainingAccountLevels: number;
                Pings: {
                    GamePodID: string;
                    Ping: number;
                }[];
                IsReady: boolean;
                IsModerator: boolean;
                UseBroadcastHUD: boolean;
                PlatformType: "PC";
                IsOwner?: boolean | undefined;
            }, {
                Subject: string;
                PlayerIdentity: {
                    Subject: string;
                    PlayerCardID: string;
                    PlayerTitleID: string;
                    AccountLevel: number;
                    PreferredLevelBorderID: string;
                    Incognito: boolean;
                    HideAccountLevel: boolean;
                };
                SeasonalBadgeInfo: null;
                CompetitiveTier: number;
                QueueEligibleRemainingAccountLevels: number;
                Pings: {
                    GamePodID: string;
                    Ping: number;
                }[];
                IsReady: boolean;
                IsModerator: boolean;
                UseBroadcastHUD: boolean;
                PlatformType: "PC";
                IsOwner?: boolean | undefined;
            }>, "many">;
            State: zod.ZodString;
            PreviousState: zod.ZodString;
            StateTransitionReason: zod.ZodString;
            Accessibility: zod.ZodUnion<[zod.ZodLiteral<"OPEN">, zod.ZodLiteral<"CLOSED">]>;
            CustomGameData: zod.ZodObject<{
                Settings: zod.ZodObject<{
                    Map: zod.ZodString;
                    Mode: zod.ZodString;
                    UseBots: zod.ZodBoolean;
                    GamePod: zod.ZodString;
                    GameRules: zod.ZodNullable<zod.ZodObject<{
                        AllowGameModifiers: zod.ZodOptional<zod.ZodEffects<zod.ZodString, boolean, string>>;
                        IsOvertimeWinByTwo: zod.ZodOptional<zod.ZodEffects<zod.ZodString, boolean, string>>;
                        PlayOutAllRounds: zod.ZodOptional<zod.ZodEffects<zod.ZodString, boolean, string>>;
                        SkipMatchHistory: zod.ZodOptional<zod.ZodEffects<zod.ZodString, boolean, string>>;
                        TournamentMode: zod.ZodOptional<zod.ZodEffects<zod.ZodString, boolean, string>>;
                    }, "strip", zod.ZodTypeAny, {
                        AllowGameModifiers?: boolean | undefined;
                        IsOvertimeWinByTwo?: boolean | undefined;
                        PlayOutAllRounds?: boolean | undefined;
                        SkipMatchHistory?: boolean | undefined;
                        TournamentMode?: boolean | undefined;
                    }, {
                        AllowGameModifiers?: string | undefined;
                        IsOvertimeWinByTwo?: string | undefined;
                        PlayOutAllRounds?: string | undefined;
                        SkipMatchHistory?: string | undefined;
                        TournamentMode?: string | undefined;
                    }>>;
                }, "strip", zod.ZodTypeAny, {
                    Mode: string;
                    GameRules: {
                        AllowGameModifiers?: boolean | undefined;
                        IsOvertimeWinByTwo?: boolean | undefined;
                        PlayOutAllRounds?: boolean | undefined;
                        SkipMatchHistory?: boolean | undefined;
                        TournamentMode?: boolean | undefined;
                    } | null;
                    Map: string;
                    UseBots: boolean;
                    GamePod: string;
                }, {
                    Mode: string;
                    GameRules: {
                        AllowGameModifiers?: string | undefined;
                        IsOvertimeWinByTwo?: string | undefined;
                        PlayOutAllRounds?: string | undefined;
                        SkipMatchHistory?: string | undefined;
                        TournamentMode?: string | undefined;
                    } | null;
                    Map: string;
                    UseBots: boolean;
                    GamePod: string;
                }>;
                Membership: zod.ZodObject<{
                    teamOne: zod.ZodNullable<zod.ZodArray<zod.ZodObject<{
                        Subject: zod.ZodString;
                    }, "strip", zod.ZodTypeAny, {
                        Subject: string;
                    }, {
                        Subject: string;
                    }>, "many">>;
                    teamTwo: zod.ZodNullable<zod.ZodArray<zod.ZodObject<{
                        Subject: zod.ZodString;
                    }, "strip", zod.ZodTypeAny, {
                        Subject: string;
                    }, {
                        Subject: string;
                    }>, "many">>;
                    teamSpectate: zod.ZodNullable<zod.ZodArray<zod.ZodObject<{
                        Subject: zod.ZodString;
                    }, "strip", zod.ZodTypeAny, {
                        Subject: string;
                    }, {
                        Subject: string;
                    }>, "many">>;
                    teamOneCoaches: zod.ZodNullable<zod.ZodArray<zod.ZodObject<{
                        Subject: zod.ZodString;
                    }, "strip", zod.ZodTypeAny, {
                        Subject: string;
                    }, {
                        Subject: string;
                    }>, "many">>;
                    teamTwoCoaches: zod.ZodNullable<zod.ZodArray<zod.ZodObject<{
                        Subject: zod.ZodString;
                    }, "strip", zod.ZodTypeAny, {
                        Subject: string;
                    }, {
                        Subject: string;
                    }>, "many">>;
                }, "strip", zod.ZodTypeAny, {
                    teamOne: {
                        Subject: string;
                    }[] | null;
                    teamTwo: {
                        Subject: string;
                    }[] | null;
                    teamSpectate: {
                        Subject: string;
                    }[] | null;
                    teamOneCoaches: {
                        Subject: string;
                    }[] | null;
                    teamTwoCoaches: {
                        Subject: string;
                    }[] | null;
                }, {
                    teamOne: {
                        Subject: string;
                    }[] | null;
                    teamTwo: {
                        Subject: string;
                    }[] | null;
                    teamSpectate: {
                        Subject: string;
                    }[] | null;
                    teamOneCoaches: {
                        Subject: string;
                    }[] | null;
                    teamTwoCoaches: {
                        Subject: string;
                    }[] | null;
                }>;
                MaxPartySize: zod.ZodNumber;
                AutobalanceEnabled: zod.ZodBoolean;
                AutobalanceMinPlayers: zod.ZodNumber;
                HasRecoveryData: zod.ZodBoolean;
            }, "strip", zod.ZodTypeAny, {
                MaxPartySize: number;
                Settings: {
                    Mode: string;
                    GameRules: {
                        AllowGameModifiers?: boolean | undefined;
                        IsOvertimeWinByTwo?: boolean | undefined;
                        PlayOutAllRounds?: boolean | undefined;
                        SkipMatchHistory?: boolean | undefined;
                        TournamentMode?: boolean | undefined;
                    } | null;
                    Map: string;
                    UseBots: boolean;
                    GamePod: string;
                };
                Membership: {
                    teamOne: {
                        Subject: string;
                    }[] | null;
                    teamTwo: {
                        Subject: string;
                    }[] | null;
                    teamSpectate: {
                        Subject: string;
                    }[] | null;
                    teamOneCoaches: {
                        Subject: string;
                    }[] | null;
                    teamTwoCoaches: {
                        Subject: string;
                    }[] | null;
                };
                AutobalanceEnabled: boolean;
                AutobalanceMinPlayers: number;
                HasRecoveryData: boolean;
            }, {
                MaxPartySize: number;
                Settings: {
                    Mode: string;
                    GameRules: {
                        AllowGameModifiers?: string | undefined;
                        IsOvertimeWinByTwo?: string | undefined;
                        PlayOutAllRounds?: string | undefined;
                        SkipMatchHistory?: string | undefined;
                        TournamentMode?: string | undefined;
                    } | null;
                    Map: string;
                    UseBots: boolean;
                    GamePod: string;
                };
                Membership: {
                    teamOne: {
                        Subject: string;
                    }[] | null;
                    teamTwo: {
                        Subject: string;
                    }[] | null;
                    teamSpectate: {
                        Subject: string;
                    }[] | null;
                    teamOneCoaches: {
                        Subject: string;
                    }[] | null;
                    teamTwoCoaches: {
                        Subject: string;
                    }[] | null;
                };
                AutobalanceEnabled: boolean;
                AutobalanceMinPlayers: number;
                HasRecoveryData: boolean;
            }>;
            MatchmakingData: zod.ZodObject<{
                QueueID: zod.ZodString;
                PreferredGamePods: zod.ZodArray<zod.ZodString, "many">;
                SkillDisparityRRPenalty: zod.ZodNumber;
            }, "strip", zod.ZodTypeAny, {
                QueueID: string;
                PreferredGamePods: string[];
                SkillDisparityRRPenalty: number;
            }, {
                QueueID: string;
                PreferredGamePods: string[];
                SkillDisparityRRPenalty: number;
            }>;
            Invites: zod.ZodNull;
            Requests: zod.ZodArray<zod.ZodUnknown, "many">;
            QueueEntryTime: zod.ZodEffects<zod.ZodString, Date, string>;
            ErrorNotification: zod.ZodObject<{
                ErrorType: zod.ZodString;
                ErroredPlayers: zod.ZodNullable<zod.ZodArray<zod.ZodObject<{
                    Subject: zod.ZodString;
                }, "strip", zod.ZodTypeAny, {
                    Subject: string;
                }, {
                    Subject: string;
                }>, "many">>;
            }, "strip", zod.ZodTypeAny, {
                ErrorType: string;
                ErroredPlayers: {
                    Subject: string;
                }[] | null;
            }, {
                ErrorType: string;
                ErroredPlayers: {
                    Subject: string;
                }[] | null;
            }>;
            RestrictedSeconds: zod.ZodNumber;
            EligibleQueues: zod.ZodArray<zod.ZodString, "many">;
            QueueIneligibilities: zod.ZodArray<zod.ZodString, "many">;
            CheatData: zod.ZodObject<{
                GamePodOverride: zod.ZodString;
                ForcePostGameProcessing: zod.ZodBoolean;
            }, "strip", zod.ZodTypeAny, {
                GamePodOverride: string;
                ForcePostGameProcessing: boolean;
            }, {
                GamePodOverride: string;
                ForcePostGameProcessing: boolean;
            }>;
            XPBonuses: zod.ZodArray<zod.ZodUnknown, "many">;
            InviteCode: zod.ZodString;
        }, "strip", zod.ZodTypeAny, {
            ID: string;
            Version: number;
            Invites: null;
            Requests: unknown[];
            State: string;
            MatchmakingData: {
                QueueID: string;
                PreferredGamePods: string[];
                SkillDisparityRRPenalty: number;
            };
            MUCName: string;
            VoiceRoomID: string;
            ClientVersion: string;
            Members: {
                Subject: string;
                PlayerIdentity: {
                    Subject: string;
                    PlayerCardID: string;
                    PlayerTitleID: string;
                    AccountLevel: number;
                    PreferredLevelBorderID: string;
                    Incognito: boolean;
                    HideAccountLevel: boolean;
                };
                SeasonalBadgeInfo: null;
                CompetitiveTier: number;
                QueueEligibleRemainingAccountLevels: number;
                Pings: {
                    GamePodID: string;
                    Ping: number;
                }[];
                IsReady: boolean;
                IsModerator: boolean;
                UseBroadcastHUD: boolean;
                PlatformType: "PC";
                IsOwner?: boolean | undefined;
            }[];
            PreviousState: string;
            StateTransitionReason: string;
            Accessibility: "OPEN" | "CLOSED";
            CustomGameData: {
                MaxPartySize: number;
                Settings: {
                    Mode: string;
                    GameRules: {
                        AllowGameModifiers?: boolean | undefined;
                        IsOvertimeWinByTwo?: boolean | undefined;
                        PlayOutAllRounds?: boolean | undefined;
                        SkipMatchHistory?: boolean | undefined;
                        TournamentMode?: boolean | undefined;
                    } | null;
                    Map: string;
                    UseBots: boolean;
                    GamePod: string;
                };
                Membership: {
                    teamOne: {
                        Subject: string;
                    }[] | null;
                    teamTwo: {
                        Subject: string;
                    }[] | null;
                    teamSpectate: {
                        Subject: string;
                    }[] | null;
                    teamOneCoaches: {
                        Subject: string;
                    }[] | null;
                    teamTwoCoaches: {
                        Subject: string;
                    }[] | null;
                };
                AutobalanceEnabled: boolean;
                AutobalanceMinPlayers: number;
                HasRecoveryData: boolean;
            };
            QueueEntryTime: Date;
            ErrorNotification: {
                ErrorType: string;
                ErroredPlayers: {
                    Subject: string;
                }[] | null;
            };
            RestrictedSeconds: number;
            EligibleQueues: string[];
            QueueIneligibilities: string[];
            CheatData: {
                GamePodOverride: string;
                ForcePostGameProcessing: boolean;
            };
            XPBonuses: unknown[];
            InviteCode: string;
        }, {
            ID: string;
            Version: number;
            Invites: null;
            Requests: unknown[];
            State: string;
            MatchmakingData: {
                QueueID: string;
                PreferredGamePods: string[];
                SkillDisparityRRPenalty: number;
            };
            MUCName: string;
            VoiceRoomID: string;
            ClientVersion: string;
            Members: {
                Subject: string;
                PlayerIdentity: {
                    Subject: string;
                    PlayerCardID: string;
                    PlayerTitleID: string;
                    AccountLevel: number;
                    PreferredLevelBorderID: string;
                    Incognito: boolean;
                    HideAccountLevel: boolean;
                };
                SeasonalBadgeInfo: null;
                CompetitiveTier: number;
                QueueEligibleRemainingAccountLevels: number;
                Pings: {
                    GamePodID: string;
                    Ping: number;
                }[];
                IsReady: boolean;
                IsModerator: boolean;
                UseBroadcastHUD: boolean;
                PlatformType: "PC";
                IsOwner?: boolean | undefined;
            }[];
            PreviousState: string;
            StateTransitionReason: string;
            Accessibility: "OPEN" | "CLOSED";
            CustomGameData: {
                MaxPartySize: number;
                Settings: {
                    Mode: string;
                    GameRules: {
                        AllowGameModifiers?: string | undefined;
                        IsOvertimeWinByTwo?: string | undefined;
                        PlayOutAllRounds?: string | undefined;
                        SkipMatchHistory?: string | undefined;
                        TournamentMode?: string | undefined;
                    } | null;
                    Map: string;
                    UseBots: boolean;
                    GamePod: string;
                };
                Membership: {
                    teamOne: {
                        Subject: string;
                    }[] | null;
                    teamTwo: {
                        Subject: string;
                    }[] | null;
                    teamSpectate: {
                        Subject: string;
                    }[] | null;
                    teamOneCoaches: {
                        Subject: string;
                    }[] | null;
                    teamTwoCoaches: {
                        Subject: string;
                    }[] | null;
                };
                AutobalanceEnabled: boolean;
                AutobalanceMinPlayers: number;
                HasRecoveryData: boolean;
            };
            QueueEntryTime: string;
            ErrorNotification: {
                ErrorType: string;
                ErroredPlayers: {
                    Subject: string;
                }[] | null;
            };
            RestrictedSeconds: number;
            EligibleQueues: string[];
            QueueIneligibilities: string[];
            CheatData: {
                GamePodOverride: string;
                ForcePostGameProcessing: boolean;
            };
            XPBonuses: unknown[];
            InviteCode: string;
        }>;
    };
}, "type" | "name" | "url"> & {
    "~type": {
        readonly name: "Refresh Competitive Tier";
        readonly description: "Refresh the competitive tier of the specified player";
        readonly type: "glz";
        readonly method: "POST";
        readonly url: "parties/v1/parties/:partyId/members/:puuid/refreshCompetitiveTier";
        readonly responses: {
            readonly "200": zod.ZodObject<{
                ID: zod.ZodString;
                MUCName: zod.ZodString;
                VoiceRoomID: zod.ZodString;
                Version: zod.ZodNumber;
                ClientVersion: zod.ZodString;
                Members: zod.ZodArray<zod.ZodObject<{
                    Subject: zod.ZodString;
                    CompetitiveTier: zod.ZodNumber;
                    PlayerIdentity: zod.ZodObject<{
                        Subject: zod.ZodString;
                        PlayerCardID: zod.ZodString;
                        PlayerTitleID: zod.ZodString;
                        AccountLevel: zod.ZodNumber;
                        PreferredLevelBorderID: zod.ZodUnion<[zod.ZodString, zod.ZodLiteral<"">]>;
                        Incognito: zod.ZodBoolean;
                        HideAccountLevel: zod.ZodBoolean;
                    }, "strip", zod.ZodTypeAny, {
                        Subject: string;
                        PlayerCardID: string;
                        PlayerTitleID: string;
                        AccountLevel: number;
                        PreferredLevelBorderID: string;
                        Incognito: boolean;
                        HideAccountLevel: boolean;
                    }, {
                        Subject: string;
                        PlayerCardID: string;
                        PlayerTitleID: string;
                        AccountLevel: number;
                        PreferredLevelBorderID: string;
                        Incognito: boolean;
                        HideAccountLevel: boolean;
                    }>;
                    SeasonalBadgeInfo: zod.ZodNull;
                    IsOwner: zod.ZodOptional<zod.ZodBoolean>;
                    QueueEligibleRemainingAccountLevels: zod.ZodNumber;
                    Pings: zod.ZodArray<zod.ZodObject<{
                        Ping: zod.ZodNumber;
                        GamePodID: zod.ZodString;
                    }, "strip", zod.ZodTypeAny, {
                        GamePodID: string;
                        Ping: number;
                    }, {
                        GamePodID: string;
                        Ping: number;
                    }>, "many">;
                    IsReady: zod.ZodBoolean;
                    IsModerator: zod.ZodBoolean;
                    UseBroadcastHUD: zod.ZodBoolean;
                    PlatformType: zod.ZodLiteral<"PC">;
                }, "strip", zod.ZodTypeAny, {
                    Subject: string;
                    PlayerIdentity: {
                        Subject: string;
                        PlayerCardID: string;
                        PlayerTitleID: string;
                        AccountLevel: number;
                        PreferredLevelBorderID: string;
                        Incognito: boolean;
                        HideAccountLevel: boolean;
                    };
                    SeasonalBadgeInfo: null;
                    CompetitiveTier: number;
                    QueueEligibleRemainingAccountLevels: number;
                    Pings: {
                        GamePodID: string;
                        Ping: number;
                    }[];
                    IsReady: boolean;
                    IsModerator: boolean;
                    UseBroadcastHUD: boolean;
                    PlatformType: "PC";
                    IsOwner?: boolean | undefined;
                }, {
                    Subject: string;
                    PlayerIdentity: {
                        Subject: string;
                        PlayerCardID: string;
                        PlayerTitleID: string;
                        AccountLevel: number;
                        PreferredLevelBorderID: string;
                        Incognito: boolean;
                        HideAccountLevel: boolean;
                    };
                    SeasonalBadgeInfo: null;
                    CompetitiveTier: number;
                    QueueEligibleRemainingAccountLevels: number;
                    Pings: {
                        GamePodID: string;
                        Ping: number;
                    }[];
                    IsReady: boolean;
                    IsModerator: boolean;
                    UseBroadcastHUD: boolean;
                    PlatformType: "PC";
                    IsOwner?: boolean | undefined;
                }>, "many">;
                State: zod.ZodString;
                PreviousState: zod.ZodString;
                StateTransitionReason: zod.ZodString;
                Accessibility: zod.ZodUnion<[zod.ZodLiteral<"OPEN">, zod.ZodLiteral<"CLOSED">]>;
                CustomGameData: zod.ZodObject<{
                    Settings: zod.ZodObject<{
                        Map: zod.ZodString;
                        Mode: zod.ZodString;
                        UseBots: zod.ZodBoolean;
                        GamePod: zod.ZodString;
                        GameRules: zod.ZodNullable<zod.ZodObject<{
                            AllowGameModifiers: zod.ZodOptional<zod.ZodEffects<zod.ZodString, boolean, string>>;
                            IsOvertimeWinByTwo: zod.ZodOptional<zod.ZodEffects<zod.ZodString, boolean, string>>;
                            PlayOutAllRounds: zod.ZodOptional<zod.ZodEffects<zod.ZodString, boolean, string>>;
                            SkipMatchHistory: zod.ZodOptional<zod.ZodEffects<zod.ZodString, boolean, string>>;
                            TournamentMode: zod.ZodOptional<zod.ZodEffects<zod.ZodString, boolean, string>>;
                        }, "strip", zod.ZodTypeAny, {
                            AllowGameModifiers?: boolean | undefined;
                            IsOvertimeWinByTwo?: boolean | undefined;
                            PlayOutAllRounds?: boolean | undefined;
                            SkipMatchHistory?: boolean | undefined;
                            TournamentMode?: boolean | undefined;
                        }, {
                            AllowGameModifiers?: string | undefined;
                            IsOvertimeWinByTwo?: string | undefined;
                            PlayOutAllRounds?: string | undefined;
                            SkipMatchHistory?: string | undefined;
                            TournamentMode?: string | undefined;
                        }>>;
                    }, "strip", zod.ZodTypeAny, {
                        Mode: string;
                        GameRules: {
                            AllowGameModifiers?: boolean | undefined;
                            IsOvertimeWinByTwo?: boolean | undefined;
                            PlayOutAllRounds?: boolean | undefined;
                            SkipMatchHistory?: boolean | undefined;
                            TournamentMode?: boolean | undefined;
                        } | null;
                        Map: string;
                        UseBots: boolean;
                        GamePod: string;
                    }, {
                        Mode: string;
                        GameRules: {
                            AllowGameModifiers?: string | undefined;
                            IsOvertimeWinByTwo?: string | undefined;
                            PlayOutAllRounds?: string | undefined;
                            SkipMatchHistory?: string | undefined;
                            TournamentMode?: string | undefined;
                        } | null;
                        Map: string;
                        UseBots: boolean;
                        GamePod: string;
                    }>;
                    Membership: zod.ZodObject<{
                        teamOne: zod.ZodNullable<zod.ZodArray<zod.ZodObject<{
                            Subject: zod.ZodString;
                        }, "strip", zod.ZodTypeAny, {
                            Subject: string;
                        }, {
                            Subject: string;
                        }>, "many">>;
                        teamTwo: zod.ZodNullable<zod.ZodArray<zod.ZodObject<{
                            Subject: zod.ZodString;
                        }, "strip", zod.ZodTypeAny, {
                            Subject: string;
                        }, {
                            Subject: string;
                        }>, "many">>;
                        teamSpectate: zod.ZodNullable<zod.ZodArray<zod.ZodObject<{
                            Subject: zod.ZodString;
                        }, "strip", zod.ZodTypeAny, {
                            Subject: string;
                        }, {
                            Subject: string;
                        }>, "many">>;
                        teamOneCoaches: zod.ZodNullable<zod.ZodArray<zod.ZodObject<{
                            Subject: zod.ZodString;
                        }, "strip", zod.ZodTypeAny, {
                            Subject: string;
                        }, {
                            Subject: string;
                        }>, "many">>;
                        teamTwoCoaches: zod.ZodNullable<zod.ZodArray<zod.ZodObject<{
                            Subject: zod.ZodString;
                        }, "strip", zod.ZodTypeAny, {
                            Subject: string;
                        }, {
                            Subject: string;
                        }>, "many">>;
                    }, "strip", zod.ZodTypeAny, {
                        teamOne: {
                            Subject: string;
                        }[] | null;
                        teamTwo: {
                            Subject: string;
                        }[] | null;
                        teamSpectate: {
                            Subject: string;
                        }[] | null;
                        teamOneCoaches: {
                            Subject: string;
                        }[] | null;
                        teamTwoCoaches: {
                            Subject: string;
                        }[] | null;
                    }, {
                        teamOne: {
                            Subject: string;
                        }[] | null;
                        teamTwo: {
                            Subject: string;
                        }[] | null;
                        teamSpectate: {
                            Subject: string;
                        }[] | null;
                        teamOneCoaches: {
                            Subject: string;
                        }[] | null;
                        teamTwoCoaches: {
                            Subject: string;
                        }[] | null;
                    }>;
                    MaxPartySize: zod.ZodNumber;
                    AutobalanceEnabled: zod.ZodBoolean;
                    AutobalanceMinPlayers: zod.ZodNumber;
                    HasRecoveryData: zod.ZodBoolean;
                }, "strip", zod.ZodTypeAny, {
                    MaxPartySize: number;
                    Settings: {
                        Mode: string;
                        GameRules: {
                            AllowGameModifiers?: boolean | undefined;
                            IsOvertimeWinByTwo?: boolean | undefined;
                            PlayOutAllRounds?: boolean | undefined;
                            SkipMatchHistory?: boolean | undefined;
                            TournamentMode?: boolean | undefined;
                        } | null;
                        Map: string;
                        UseBots: boolean;
                        GamePod: string;
                    };
                    Membership: {
                        teamOne: {
                            Subject: string;
                        }[] | null;
                        teamTwo: {
                            Subject: string;
                        }[] | null;
                        teamSpectate: {
                            Subject: string;
                        }[] | null;
                        teamOneCoaches: {
                            Subject: string;
                        }[] | null;
                        teamTwoCoaches: {
                            Subject: string;
                        }[] | null;
                    };
                    AutobalanceEnabled: boolean;
                    AutobalanceMinPlayers: number;
                    HasRecoveryData: boolean;
                }, {
                    MaxPartySize: number;
                    Settings: {
                        Mode: string;
                        GameRules: {
                            AllowGameModifiers?: string | undefined;
                            IsOvertimeWinByTwo?: string | undefined;
                            PlayOutAllRounds?: string | undefined;
                            SkipMatchHistory?: string | undefined;
                            TournamentMode?: string | undefined;
                        } | null;
                        Map: string;
                        UseBots: boolean;
                        GamePod: string;
                    };
                    Membership: {
                        teamOne: {
                            Subject: string;
                        }[] | null;
                        teamTwo: {
                            Subject: string;
                        }[] | null;
                        teamSpectate: {
                            Subject: string;
                        }[] | null;
                        teamOneCoaches: {
                            Subject: string;
                        }[] | null;
                        teamTwoCoaches: {
                            Subject: string;
                        }[] | null;
                    };
                    AutobalanceEnabled: boolean;
                    AutobalanceMinPlayers: number;
                    HasRecoveryData: boolean;
                }>;
                MatchmakingData: zod.ZodObject<{
                    QueueID: zod.ZodString;
                    PreferredGamePods: zod.ZodArray<zod.ZodString, "many">;
                    SkillDisparityRRPenalty: zod.ZodNumber;
                }, "strip", zod.ZodTypeAny, {
                    QueueID: string;
                    PreferredGamePods: string[];
                    SkillDisparityRRPenalty: number;
                }, {
                    QueueID: string;
                    PreferredGamePods: string[];
                    SkillDisparityRRPenalty: number;
                }>;
                Invites: zod.ZodNull;
                Requests: zod.ZodArray<zod.ZodUnknown, "many">;
                QueueEntryTime: zod.ZodEffects<zod.ZodString, Date, string>;
                ErrorNotification: zod.ZodObject<{
                    ErrorType: zod.ZodString;
                    ErroredPlayers: zod.ZodNullable<zod.ZodArray<zod.ZodObject<{
                        Subject: zod.ZodString;
                    }, "strip", zod.ZodTypeAny, {
                        Subject: string;
                    }, {
                        Subject: string;
                    }>, "many">>;
                }, "strip", zod.ZodTypeAny, {
                    ErrorType: string;
                    ErroredPlayers: {
                        Subject: string;
                    }[] | null;
                }, {
                    ErrorType: string;
                    ErroredPlayers: {
                        Subject: string;
                    }[] | null;
                }>;
                RestrictedSeconds: zod.ZodNumber;
                EligibleQueues: zod.ZodArray<zod.ZodString, "many">;
                QueueIneligibilities: zod.ZodArray<zod.ZodString, "many">;
                CheatData: zod.ZodObject<{
                    GamePodOverride: zod.ZodString;
                    ForcePostGameProcessing: zod.ZodBoolean;
                }, "strip", zod.ZodTypeAny, {
                    GamePodOverride: string;
                    ForcePostGameProcessing: boolean;
                }, {
                    GamePodOverride: string;
                    ForcePostGameProcessing: boolean;
                }>;
                XPBonuses: zod.ZodArray<zod.ZodUnknown, "many">;
                InviteCode: zod.ZodString;
            }, "strip", zod.ZodTypeAny, {
                ID: string;
                Version: number;
                Invites: null;
                Requests: unknown[];
                State: string;
                MatchmakingData: {
                    QueueID: string;
                    PreferredGamePods: string[];
                    SkillDisparityRRPenalty: number;
                };
                MUCName: string;
                VoiceRoomID: string;
                ClientVersion: string;
                Members: {
                    Subject: string;
                    PlayerIdentity: {
                        Subject: string;
                        PlayerCardID: string;
                        PlayerTitleID: string;
                        AccountLevel: number;
                        PreferredLevelBorderID: string;
                        Incognito: boolean;
                        HideAccountLevel: boolean;
                    };
                    SeasonalBadgeInfo: null;
                    CompetitiveTier: number;
                    QueueEligibleRemainingAccountLevels: number;
                    Pings: {
                        GamePodID: string;
                        Ping: number;
                    }[];
                    IsReady: boolean;
                    IsModerator: boolean;
                    UseBroadcastHUD: boolean;
                    PlatformType: "PC";
                    IsOwner?: boolean | undefined;
                }[];
                PreviousState: string;
                StateTransitionReason: string;
                Accessibility: "OPEN" | "CLOSED";
                CustomGameData: {
                    MaxPartySize: number;
                    Settings: {
                        Mode: string;
                        GameRules: {
                            AllowGameModifiers?: boolean | undefined;
                            IsOvertimeWinByTwo?: boolean | undefined;
                            PlayOutAllRounds?: boolean | undefined;
                            SkipMatchHistory?: boolean | undefined;
                            TournamentMode?: boolean | undefined;
                        } | null;
                        Map: string;
                        UseBots: boolean;
                        GamePod: string;
                    };
                    Membership: {
                        teamOne: {
                            Subject: string;
                        }[] | null;
                        teamTwo: {
                            Subject: string;
                        }[] | null;
                        teamSpectate: {
                            Subject: string;
                        }[] | null;
                        teamOneCoaches: {
                            Subject: string;
                        }[] | null;
                        teamTwoCoaches: {
                            Subject: string;
                        }[] | null;
                    };
                    AutobalanceEnabled: boolean;
                    AutobalanceMinPlayers: number;
                    HasRecoveryData: boolean;
                };
                QueueEntryTime: Date;
                ErrorNotification: {
                    ErrorType: string;
                    ErroredPlayers: {
                        Subject: string;
                    }[] | null;
                };
                RestrictedSeconds: number;
                EligibleQueues: string[];
                QueueIneligibilities: string[];
                CheatData: {
                    GamePodOverride: string;
                    ForcePostGameProcessing: boolean;
                };
                XPBonuses: unknown[];
                InviteCode: string;
            }, {
                ID: string;
                Version: number;
                Invites: null;
                Requests: unknown[];
                State: string;
                MatchmakingData: {
                    QueueID: string;
                    PreferredGamePods: string[];
                    SkillDisparityRRPenalty: number;
                };
                MUCName: string;
                VoiceRoomID: string;
                ClientVersion: string;
                Members: {
                    Subject: string;
                    PlayerIdentity: {
                        Subject: string;
                        PlayerCardID: string;
                        PlayerTitleID: string;
                        AccountLevel: number;
                        PreferredLevelBorderID: string;
                        Incognito: boolean;
                        HideAccountLevel: boolean;
                    };
                    SeasonalBadgeInfo: null;
                    CompetitiveTier: number;
                    QueueEligibleRemainingAccountLevels: number;
                    Pings: {
                        GamePodID: string;
                        Ping: number;
                    }[];
                    IsReady: boolean;
                    IsModerator: boolean;
                    UseBroadcastHUD: boolean;
                    PlatformType: "PC";
                    IsOwner?: boolean | undefined;
                }[];
                PreviousState: string;
                StateTransitionReason: string;
                Accessibility: "OPEN" | "CLOSED";
                CustomGameData: {
                    MaxPartySize: number;
                    Settings: {
                        Mode: string;
                        GameRules: {
                            AllowGameModifiers?: string | undefined;
                            IsOvertimeWinByTwo?: string | undefined;
                            PlayOutAllRounds?: string | undefined;
                            SkipMatchHistory?: string | undefined;
                            TournamentMode?: string | undefined;
                        } | null;
                        Map: string;
                        UseBots: boolean;
                        GamePod: string;
                    };
                    Membership: {
                        teamOne: {
                            Subject: string;
                        }[] | null;
                        teamTwo: {
                            Subject: string;
                        }[] | null;
                        teamSpectate: {
                            Subject: string;
                        }[] | null;
                        teamOneCoaches: {
                            Subject: string;
                        }[] | null;
                        teamTwoCoaches: {
                            Subject: string;
                        }[] | null;
                    };
                    AutobalanceEnabled: boolean;
                    AutobalanceMinPlayers: number;
                    HasRecoveryData: boolean;
                };
                QueueEntryTime: string;
                ErrorNotification: {
                    ErrorType: string;
                    ErroredPlayers: {
                        Subject: string;
                    }[] | null;
                };
                RestrictedSeconds: number;
                EligibleQueues: string[];
                QueueIneligibilities: string[];
                CheatData: {
                    GamePodOverride: string;
                    ForcePostGameProcessing: boolean;
                };
                XPBonuses: unknown[];
                InviteCode: string;
            }>;
        };
    };
};

type Params$6 = ResolveParams<(typeof _default$6)["~type"]["url"]>;
type Body$6 = z.infer<ResolveValue<(typeof _default$6)["~type"], "body">>;
type Data$6 = ResolveData<Params$6, Body$6>;
type Response$6 = z.infer<ResolveValue<(typeof _default$6)["~type"], "responses">["200"]>;
interface RefreshCompetitiveTierRequestConfig extends ValorantAxiosRequestConfig<Data$6> {
}
declare class RefreshCompetitiveTierEndpoint {
    /**
     * Refresh the competitive tier of the specified player
     *
     * @EndpointType glz
     */
    postRefreshCompetitiveTier<T = Response$6>(this: RemoteApiClient, config: RefreshCompetitiveTierRequestConfig): Promise<AxiosResponse<T>>;
}

declare const _default$5: Omit<{
    requirements: string[];
    type: "auth" | "local" | "pd" | "glz" | "shared";
    name: string;
    method: "PUT" | "GET" | "DELETE" | "POST";
    url: string;
    description?: string | undefined;
    headers?: Record<string, string> | undefined;
    body?: zod.ZodType<any, zod.ZodTypeDef, any> | undefined;
    query?: zod.ZodType<any, zod.ZodTypeDef, any> | undefined;
    responses?: Record<string, zod.ZodType<any, zod.ZodTypeDef, any>> | undefined;
}, "type" | "name" | "url"> & Pick<{
    readonly name: "Refresh Pings";
    readonly description: "Refresh the pings of the specified player";
    readonly type: "glz";
    readonly method: "POST";
    readonly url: "parties/v1/parties/:partyId/members/:puuid/refreshPings";
    readonly responses: {
        readonly "200": zod.ZodObject<{
            ID: zod.ZodString;
            MUCName: zod.ZodString;
            VoiceRoomID: zod.ZodString;
            Version: zod.ZodNumber;
            ClientVersion: zod.ZodString;
            Members: zod.ZodArray<zod.ZodObject<{
                Subject: zod.ZodString;
                CompetitiveTier: zod.ZodNumber;
                PlayerIdentity: zod.ZodObject<{
                    Subject: zod.ZodString;
                    PlayerCardID: zod.ZodString;
                    PlayerTitleID: zod.ZodString;
                    AccountLevel: zod.ZodNumber;
                    PreferredLevelBorderID: zod.ZodUnion<[zod.ZodString, zod.ZodLiteral<"">]>;
                    Incognito: zod.ZodBoolean;
                    HideAccountLevel: zod.ZodBoolean;
                }, "strip", zod.ZodTypeAny, {
                    Subject: string;
                    PlayerCardID: string;
                    PlayerTitleID: string;
                    AccountLevel: number;
                    PreferredLevelBorderID: string;
                    Incognito: boolean;
                    HideAccountLevel: boolean;
                }, {
                    Subject: string;
                    PlayerCardID: string;
                    PlayerTitleID: string;
                    AccountLevel: number;
                    PreferredLevelBorderID: string;
                    Incognito: boolean;
                    HideAccountLevel: boolean;
                }>;
                SeasonalBadgeInfo: zod.ZodNull;
                IsOwner: zod.ZodOptional<zod.ZodBoolean>;
                QueueEligibleRemainingAccountLevels: zod.ZodNumber;
                Pings: zod.ZodArray<zod.ZodObject<{
                    Ping: zod.ZodNumber;
                    GamePodID: zod.ZodString;
                }, "strip", zod.ZodTypeAny, {
                    GamePodID: string;
                    Ping: number;
                }, {
                    GamePodID: string;
                    Ping: number;
                }>, "many">;
                IsReady: zod.ZodBoolean;
                IsModerator: zod.ZodBoolean;
                UseBroadcastHUD: zod.ZodBoolean;
                PlatformType: zod.ZodLiteral<"PC">;
            }, "strip", zod.ZodTypeAny, {
                Subject: string;
                PlayerIdentity: {
                    Subject: string;
                    PlayerCardID: string;
                    PlayerTitleID: string;
                    AccountLevel: number;
                    PreferredLevelBorderID: string;
                    Incognito: boolean;
                    HideAccountLevel: boolean;
                };
                SeasonalBadgeInfo: null;
                CompetitiveTier: number;
                QueueEligibleRemainingAccountLevels: number;
                Pings: {
                    GamePodID: string;
                    Ping: number;
                }[];
                IsReady: boolean;
                IsModerator: boolean;
                UseBroadcastHUD: boolean;
                PlatformType: "PC";
                IsOwner?: boolean | undefined;
            }, {
                Subject: string;
                PlayerIdentity: {
                    Subject: string;
                    PlayerCardID: string;
                    PlayerTitleID: string;
                    AccountLevel: number;
                    PreferredLevelBorderID: string;
                    Incognito: boolean;
                    HideAccountLevel: boolean;
                };
                SeasonalBadgeInfo: null;
                CompetitiveTier: number;
                QueueEligibleRemainingAccountLevels: number;
                Pings: {
                    GamePodID: string;
                    Ping: number;
                }[];
                IsReady: boolean;
                IsModerator: boolean;
                UseBroadcastHUD: boolean;
                PlatformType: "PC";
                IsOwner?: boolean | undefined;
            }>, "many">;
            State: zod.ZodString;
            PreviousState: zod.ZodString;
            StateTransitionReason: zod.ZodString;
            Accessibility: zod.ZodUnion<[zod.ZodLiteral<"OPEN">, zod.ZodLiteral<"CLOSED">]>;
            CustomGameData: zod.ZodObject<{
                Settings: zod.ZodObject<{
                    Map: zod.ZodString;
                    Mode: zod.ZodString;
                    UseBots: zod.ZodBoolean;
                    GamePod: zod.ZodString;
                    GameRules: zod.ZodNullable<zod.ZodObject<{
                        AllowGameModifiers: zod.ZodOptional<zod.ZodEffects<zod.ZodString, boolean, string>>;
                        IsOvertimeWinByTwo: zod.ZodOptional<zod.ZodEffects<zod.ZodString, boolean, string>>;
                        PlayOutAllRounds: zod.ZodOptional<zod.ZodEffects<zod.ZodString, boolean, string>>;
                        SkipMatchHistory: zod.ZodOptional<zod.ZodEffects<zod.ZodString, boolean, string>>;
                        TournamentMode: zod.ZodOptional<zod.ZodEffects<zod.ZodString, boolean, string>>;
                    }, "strip", zod.ZodTypeAny, {
                        AllowGameModifiers?: boolean | undefined;
                        IsOvertimeWinByTwo?: boolean | undefined;
                        PlayOutAllRounds?: boolean | undefined;
                        SkipMatchHistory?: boolean | undefined;
                        TournamentMode?: boolean | undefined;
                    }, {
                        AllowGameModifiers?: string | undefined;
                        IsOvertimeWinByTwo?: string | undefined;
                        PlayOutAllRounds?: string | undefined;
                        SkipMatchHistory?: string | undefined;
                        TournamentMode?: string | undefined;
                    }>>;
                }, "strip", zod.ZodTypeAny, {
                    Mode: string;
                    GameRules: {
                        AllowGameModifiers?: boolean | undefined;
                        IsOvertimeWinByTwo?: boolean | undefined;
                        PlayOutAllRounds?: boolean | undefined;
                        SkipMatchHistory?: boolean | undefined;
                        TournamentMode?: boolean | undefined;
                    } | null;
                    Map: string;
                    UseBots: boolean;
                    GamePod: string;
                }, {
                    Mode: string;
                    GameRules: {
                        AllowGameModifiers?: string | undefined;
                        IsOvertimeWinByTwo?: string | undefined;
                        PlayOutAllRounds?: string | undefined;
                        SkipMatchHistory?: string | undefined;
                        TournamentMode?: string | undefined;
                    } | null;
                    Map: string;
                    UseBots: boolean;
                    GamePod: string;
                }>;
                Membership: zod.ZodObject<{
                    teamOne: zod.ZodNullable<zod.ZodArray<zod.ZodObject<{
                        Subject: zod.ZodString;
                    }, "strip", zod.ZodTypeAny, {
                        Subject: string;
                    }, {
                        Subject: string;
                    }>, "many">>;
                    teamTwo: zod.ZodNullable<zod.ZodArray<zod.ZodObject<{
                        Subject: zod.ZodString;
                    }, "strip", zod.ZodTypeAny, {
                        Subject: string;
                    }, {
                        Subject: string;
                    }>, "many">>;
                    teamSpectate: zod.ZodNullable<zod.ZodArray<zod.ZodObject<{
                        Subject: zod.ZodString;
                    }, "strip", zod.ZodTypeAny, {
                        Subject: string;
                    }, {
                        Subject: string;
                    }>, "many">>;
                    teamOneCoaches: zod.ZodNullable<zod.ZodArray<zod.ZodObject<{
                        Subject: zod.ZodString;
                    }, "strip", zod.ZodTypeAny, {
                        Subject: string;
                    }, {
                        Subject: string;
                    }>, "many">>;
                    teamTwoCoaches: zod.ZodNullable<zod.ZodArray<zod.ZodObject<{
                        Subject: zod.ZodString;
                    }, "strip", zod.ZodTypeAny, {
                        Subject: string;
                    }, {
                        Subject: string;
                    }>, "many">>;
                }, "strip", zod.ZodTypeAny, {
                    teamOne: {
                        Subject: string;
                    }[] | null;
                    teamTwo: {
                        Subject: string;
                    }[] | null;
                    teamSpectate: {
                        Subject: string;
                    }[] | null;
                    teamOneCoaches: {
                        Subject: string;
                    }[] | null;
                    teamTwoCoaches: {
                        Subject: string;
                    }[] | null;
                }, {
                    teamOne: {
                        Subject: string;
                    }[] | null;
                    teamTwo: {
                        Subject: string;
                    }[] | null;
                    teamSpectate: {
                        Subject: string;
                    }[] | null;
                    teamOneCoaches: {
                        Subject: string;
                    }[] | null;
                    teamTwoCoaches: {
                        Subject: string;
                    }[] | null;
                }>;
                MaxPartySize: zod.ZodNumber;
                AutobalanceEnabled: zod.ZodBoolean;
                AutobalanceMinPlayers: zod.ZodNumber;
                HasRecoveryData: zod.ZodBoolean;
            }, "strip", zod.ZodTypeAny, {
                MaxPartySize: number;
                Settings: {
                    Mode: string;
                    GameRules: {
                        AllowGameModifiers?: boolean | undefined;
                        IsOvertimeWinByTwo?: boolean | undefined;
                        PlayOutAllRounds?: boolean | undefined;
                        SkipMatchHistory?: boolean | undefined;
                        TournamentMode?: boolean | undefined;
                    } | null;
                    Map: string;
                    UseBots: boolean;
                    GamePod: string;
                };
                Membership: {
                    teamOne: {
                        Subject: string;
                    }[] | null;
                    teamTwo: {
                        Subject: string;
                    }[] | null;
                    teamSpectate: {
                        Subject: string;
                    }[] | null;
                    teamOneCoaches: {
                        Subject: string;
                    }[] | null;
                    teamTwoCoaches: {
                        Subject: string;
                    }[] | null;
                };
                AutobalanceEnabled: boolean;
                AutobalanceMinPlayers: number;
                HasRecoveryData: boolean;
            }, {
                MaxPartySize: number;
                Settings: {
                    Mode: string;
                    GameRules: {
                        AllowGameModifiers?: string | undefined;
                        IsOvertimeWinByTwo?: string | undefined;
                        PlayOutAllRounds?: string | undefined;
                        SkipMatchHistory?: string | undefined;
                        TournamentMode?: string | undefined;
                    } | null;
                    Map: string;
                    UseBots: boolean;
                    GamePod: string;
                };
                Membership: {
                    teamOne: {
                        Subject: string;
                    }[] | null;
                    teamTwo: {
                        Subject: string;
                    }[] | null;
                    teamSpectate: {
                        Subject: string;
                    }[] | null;
                    teamOneCoaches: {
                        Subject: string;
                    }[] | null;
                    teamTwoCoaches: {
                        Subject: string;
                    }[] | null;
                };
                AutobalanceEnabled: boolean;
                AutobalanceMinPlayers: number;
                HasRecoveryData: boolean;
            }>;
            MatchmakingData: zod.ZodObject<{
                QueueID: zod.ZodString;
                PreferredGamePods: zod.ZodArray<zod.ZodString, "many">;
                SkillDisparityRRPenalty: zod.ZodNumber;
            }, "strip", zod.ZodTypeAny, {
                QueueID: string;
                PreferredGamePods: string[];
                SkillDisparityRRPenalty: number;
            }, {
                QueueID: string;
                PreferredGamePods: string[];
                SkillDisparityRRPenalty: number;
            }>;
            Invites: zod.ZodNull;
            Requests: zod.ZodArray<zod.ZodUnknown, "many">;
            QueueEntryTime: zod.ZodEffects<zod.ZodString, Date, string>;
            ErrorNotification: zod.ZodObject<{
                ErrorType: zod.ZodString;
                ErroredPlayers: zod.ZodNullable<zod.ZodArray<zod.ZodObject<{
                    Subject: zod.ZodString;
                }, "strip", zod.ZodTypeAny, {
                    Subject: string;
                }, {
                    Subject: string;
                }>, "many">>;
            }, "strip", zod.ZodTypeAny, {
                ErrorType: string;
                ErroredPlayers: {
                    Subject: string;
                }[] | null;
            }, {
                ErrorType: string;
                ErroredPlayers: {
                    Subject: string;
                }[] | null;
            }>;
            RestrictedSeconds: zod.ZodNumber;
            EligibleQueues: zod.ZodArray<zod.ZodString, "many">;
            QueueIneligibilities: zod.ZodArray<zod.ZodString, "many">;
            CheatData: zod.ZodObject<{
                GamePodOverride: zod.ZodString;
                ForcePostGameProcessing: zod.ZodBoolean;
            }, "strip", zod.ZodTypeAny, {
                GamePodOverride: string;
                ForcePostGameProcessing: boolean;
            }, {
                GamePodOverride: string;
                ForcePostGameProcessing: boolean;
            }>;
            XPBonuses: zod.ZodArray<zod.ZodUnknown, "many">;
            InviteCode: zod.ZodString;
        }, "strip", zod.ZodTypeAny, {
            ID: string;
            Version: number;
            Invites: null;
            Requests: unknown[];
            State: string;
            MatchmakingData: {
                QueueID: string;
                PreferredGamePods: string[];
                SkillDisparityRRPenalty: number;
            };
            MUCName: string;
            VoiceRoomID: string;
            ClientVersion: string;
            Members: {
                Subject: string;
                PlayerIdentity: {
                    Subject: string;
                    PlayerCardID: string;
                    PlayerTitleID: string;
                    AccountLevel: number;
                    PreferredLevelBorderID: string;
                    Incognito: boolean;
                    HideAccountLevel: boolean;
                };
                SeasonalBadgeInfo: null;
                CompetitiveTier: number;
                QueueEligibleRemainingAccountLevels: number;
                Pings: {
                    GamePodID: string;
                    Ping: number;
                }[];
                IsReady: boolean;
                IsModerator: boolean;
                UseBroadcastHUD: boolean;
                PlatformType: "PC";
                IsOwner?: boolean | undefined;
            }[];
            PreviousState: string;
            StateTransitionReason: string;
            Accessibility: "OPEN" | "CLOSED";
            CustomGameData: {
                MaxPartySize: number;
                Settings: {
                    Mode: string;
                    GameRules: {
                        AllowGameModifiers?: boolean | undefined;
                        IsOvertimeWinByTwo?: boolean | undefined;
                        PlayOutAllRounds?: boolean | undefined;
                        SkipMatchHistory?: boolean | undefined;
                        TournamentMode?: boolean | undefined;
                    } | null;
                    Map: string;
                    UseBots: boolean;
                    GamePod: string;
                };
                Membership: {
                    teamOne: {
                        Subject: string;
                    }[] | null;
                    teamTwo: {
                        Subject: string;
                    }[] | null;
                    teamSpectate: {
                        Subject: string;
                    }[] | null;
                    teamOneCoaches: {
                        Subject: string;
                    }[] | null;
                    teamTwoCoaches: {
                        Subject: string;
                    }[] | null;
                };
                AutobalanceEnabled: boolean;
                AutobalanceMinPlayers: number;
                HasRecoveryData: boolean;
            };
            QueueEntryTime: Date;
            ErrorNotification: {
                ErrorType: string;
                ErroredPlayers: {
                    Subject: string;
                }[] | null;
            };
            RestrictedSeconds: number;
            EligibleQueues: string[];
            QueueIneligibilities: string[];
            CheatData: {
                GamePodOverride: string;
                ForcePostGameProcessing: boolean;
            };
            XPBonuses: unknown[];
            InviteCode: string;
        }, {
            ID: string;
            Version: number;
            Invites: null;
            Requests: unknown[];
            State: string;
            MatchmakingData: {
                QueueID: string;
                PreferredGamePods: string[];
                SkillDisparityRRPenalty: number;
            };
            MUCName: string;
            VoiceRoomID: string;
            ClientVersion: string;
            Members: {
                Subject: string;
                PlayerIdentity: {
                    Subject: string;
                    PlayerCardID: string;
                    PlayerTitleID: string;
                    AccountLevel: number;
                    PreferredLevelBorderID: string;
                    Incognito: boolean;
                    HideAccountLevel: boolean;
                };
                SeasonalBadgeInfo: null;
                CompetitiveTier: number;
                QueueEligibleRemainingAccountLevels: number;
                Pings: {
                    GamePodID: string;
                    Ping: number;
                }[];
                IsReady: boolean;
                IsModerator: boolean;
                UseBroadcastHUD: boolean;
                PlatformType: "PC";
                IsOwner?: boolean | undefined;
            }[];
            PreviousState: string;
            StateTransitionReason: string;
            Accessibility: "OPEN" | "CLOSED";
            CustomGameData: {
                MaxPartySize: number;
                Settings: {
                    Mode: string;
                    GameRules: {
                        AllowGameModifiers?: string | undefined;
                        IsOvertimeWinByTwo?: string | undefined;
                        PlayOutAllRounds?: string | undefined;
                        SkipMatchHistory?: string | undefined;
                        TournamentMode?: string | undefined;
                    } | null;
                    Map: string;
                    UseBots: boolean;
                    GamePod: string;
                };
                Membership: {
                    teamOne: {
                        Subject: string;
                    }[] | null;
                    teamTwo: {
                        Subject: string;
                    }[] | null;
                    teamSpectate: {
                        Subject: string;
                    }[] | null;
                    teamOneCoaches: {
                        Subject: string;
                    }[] | null;
                    teamTwoCoaches: {
                        Subject: string;
                    }[] | null;
                };
                AutobalanceEnabled: boolean;
                AutobalanceMinPlayers: number;
                HasRecoveryData: boolean;
            };
            QueueEntryTime: string;
            ErrorNotification: {
                ErrorType: string;
                ErroredPlayers: {
                    Subject: string;
                }[] | null;
            };
            RestrictedSeconds: number;
            EligibleQueues: string[];
            QueueIneligibilities: string[];
            CheatData: {
                GamePodOverride: string;
                ForcePostGameProcessing: boolean;
            };
            XPBonuses: unknown[];
            InviteCode: string;
        }>;
    };
}, "type" | "name" | "url"> & {
    "~type": {
        readonly name: "Refresh Pings";
        readonly description: "Refresh the pings of the specified player";
        readonly type: "glz";
        readonly method: "POST";
        readonly url: "parties/v1/parties/:partyId/members/:puuid/refreshPings";
        readonly responses: {
            readonly "200": zod.ZodObject<{
                ID: zod.ZodString;
                MUCName: zod.ZodString;
                VoiceRoomID: zod.ZodString;
                Version: zod.ZodNumber;
                ClientVersion: zod.ZodString;
                Members: zod.ZodArray<zod.ZodObject<{
                    Subject: zod.ZodString;
                    CompetitiveTier: zod.ZodNumber;
                    PlayerIdentity: zod.ZodObject<{
                        Subject: zod.ZodString;
                        PlayerCardID: zod.ZodString;
                        PlayerTitleID: zod.ZodString;
                        AccountLevel: zod.ZodNumber;
                        PreferredLevelBorderID: zod.ZodUnion<[zod.ZodString, zod.ZodLiteral<"">]>;
                        Incognito: zod.ZodBoolean;
                        HideAccountLevel: zod.ZodBoolean;
                    }, "strip", zod.ZodTypeAny, {
                        Subject: string;
                        PlayerCardID: string;
                        PlayerTitleID: string;
                        AccountLevel: number;
                        PreferredLevelBorderID: string;
                        Incognito: boolean;
                        HideAccountLevel: boolean;
                    }, {
                        Subject: string;
                        PlayerCardID: string;
                        PlayerTitleID: string;
                        AccountLevel: number;
                        PreferredLevelBorderID: string;
                        Incognito: boolean;
                        HideAccountLevel: boolean;
                    }>;
                    SeasonalBadgeInfo: zod.ZodNull;
                    IsOwner: zod.ZodOptional<zod.ZodBoolean>;
                    QueueEligibleRemainingAccountLevels: zod.ZodNumber;
                    Pings: zod.ZodArray<zod.ZodObject<{
                        Ping: zod.ZodNumber;
                        GamePodID: zod.ZodString;
                    }, "strip", zod.ZodTypeAny, {
                        GamePodID: string;
                        Ping: number;
                    }, {
                        GamePodID: string;
                        Ping: number;
                    }>, "many">;
                    IsReady: zod.ZodBoolean;
                    IsModerator: zod.ZodBoolean;
                    UseBroadcastHUD: zod.ZodBoolean;
                    PlatformType: zod.ZodLiteral<"PC">;
                }, "strip", zod.ZodTypeAny, {
                    Subject: string;
                    PlayerIdentity: {
                        Subject: string;
                        PlayerCardID: string;
                        PlayerTitleID: string;
                        AccountLevel: number;
                        PreferredLevelBorderID: string;
                        Incognito: boolean;
                        HideAccountLevel: boolean;
                    };
                    SeasonalBadgeInfo: null;
                    CompetitiveTier: number;
                    QueueEligibleRemainingAccountLevels: number;
                    Pings: {
                        GamePodID: string;
                        Ping: number;
                    }[];
                    IsReady: boolean;
                    IsModerator: boolean;
                    UseBroadcastHUD: boolean;
                    PlatformType: "PC";
                    IsOwner?: boolean | undefined;
                }, {
                    Subject: string;
                    PlayerIdentity: {
                        Subject: string;
                        PlayerCardID: string;
                        PlayerTitleID: string;
                        AccountLevel: number;
                        PreferredLevelBorderID: string;
                        Incognito: boolean;
                        HideAccountLevel: boolean;
                    };
                    SeasonalBadgeInfo: null;
                    CompetitiveTier: number;
                    QueueEligibleRemainingAccountLevels: number;
                    Pings: {
                        GamePodID: string;
                        Ping: number;
                    }[];
                    IsReady: boolean;
                    IsModerator: boolean;
                    UseBroadcastHUD: boolean;
                    PlatformType: "PC";
                    IsOwner?: boolean | undefined;
                }>, "many">;
                State: zod.ZodString;
                PreviousState: zod.ZodString;
                StateTransitionReason: zod.ZodString;
                Accessibility: zod.ZodUnion<[zod.ZodLiteral<"OPEN">, zod.ZodLiteral<"CLOSED">]>;
                CustomGameData: zod.ZodObject<{
                    Settings: zod.ZodObject<{
                        Map: zod.ZodString;
                        Mode: zod.ZodString;
                        UseBots: zod.ZodBoolean;
                        GamePod: zod.ZodString;
                        GameRules: zod.ZodNullable<zod.ZodObject<{
                            AllowGameModifiers: zod.ZodOptional<zod.ZodEffects<zod.ZodString, boolean, string>>;
                            IsOvertimeWinByTwo: zod.ZodOptional<zod.ZodEffects<zod.ZodString, boolean, string>>;
                            PlayOutAllRounds: zod.ZodOptional<zod.ZodEffects<zod.ZodString, boolean, string>>;
                            SkipMatchHistory: zod.ZodOptional<zod.ZodEffects<zod.ZodString, boolean, string>>;
                            TournamentMode: zod.ZodOptional<zod.ZodEffects<zod.ZodString, boolean, string>>;
                        }, "strip", zod.ZodTypeAny, {
                            AllowGameModifiers?: boolean | undefined;
                            IsOvertimeWinByTwo?: boolean | undefined;
                            PlayOutAllRounds?: boolean | undefined;
                            SkipMatchHistory?: boolean | undefined;
                            TournamentMode?: boolean | undefined;
                        }, {
                            AllowGameModifiers?: string | undefined;
                            IsOvertimeWinByTwo?: string | undefined;
                            PlayOutAllRounds?: string | undefined;
                            SkipMatchHistory?: string | undefined;
                            TournamentMode?: string | undefined;
                        }>>;
                    }, "strip", zod.ZodTypeAny, {
                        Mode: string;
                        GameRules: {
                            AllowGameModifiers?: boolean | undefined;
                            IsOvertimeWinByTwo?: boolean | undefined;
                            PlayOutAllRounds?: boolean | undefined;
                            SkipMatchHistory?: boolean | undefined;
                            TournamentMode?: boolean | undefined;
                        } | null;
                        Map: string;
                        UseBots: boolean;
                        GamePod: string;
                    }, {
                        Mode: string;
                        GameRules: {
                            AllowGameModifiers?: string | undefined;
                            IsOvertimeWinByTwo?: string | undefined;
                            PlayOutAllRounds?: string | undefined;
                            SkipMatchHistory?: string | undefined;
                            TournamentMode?: string | undefined;
                        } | null;
                        Map: string;
                        UseBots: boolean;
                        GamePod: string;
                    }>;
                    Membership: zod.ZodObject<{
                        teamOne: zod.ZodNullable<zod.ZodArray<zod.ZodObject<{
                            Subject: zod.ZodString;
                        }, "strip", zod.ZodTypeAny, {
                            Subject: string;
                        }, {
                            Subject: string;
                        }>, "many">>;
                        teamTwo: zod.ZodNullable<zod.ZodArray<zod.ZodObject<{
                            Subject: zod.ZodString;
                        }, "strip", zod.ZodTypeAny, {
                            Subject: string;
                        }, {
                            Subject: string;
                        }>, "many">>;
                        teamSpectate: zod.ZodNullable<zod.ZodArray<zod.ZodObject<{
                            Subject: zod.ZodString;
                        }, "strip", zod.ZodTypeAny, {
                            Subject: string;
                        }, {
                            Subject: string;
                        }>, "many">>;
                        teamOneCoaches: zod.ZodNullable<zod.ZodArray<zod.ZodObject<{
                            Subject: zod.ZodString;
                        }, "strip", zod.ZodTypeAny, {
                            Subject: string;
                        }, {
                            Subject: string;
                        }>, "many">>;
                        teamTwoCoaches: zod.ZodNullable<zod.ZodArray<zod.ZodObject<{
                            Subject: zod.ZodString;
                        }, "strip", zod.ZodTypeAny, {
                            Subject: string;
                        }, {
                            Subject: string;
                        }>, "many">>;
                    }, "strip", zod.ZodTypeAny, {
                        teamOne: {
                            Subject: string;
                        }[] | null;
                        teamTwo: {
                            Subject: string;
                        }[] | null;
                        teamSpectate: {
                            Subject: string;
                        }[] | null;
                        teamOneCoaches: {
                            Subject: string;
                        }[] | null;
                        teamTwoCoaches: {
                            Subject: string;
                        }[] | null;
                    }, {
                        teamOne: {
                            Subject: string;
                        }[] | null;
                        teamTwo: {
                            Subject: string;
                        }[] | null;
                        teamSpectate: {
                            Subject: string;
                        }[] | null;
                        teamOneCoaches: {
                            Subject: string;
                        }[] | null;
                        teamTwoCoaches: {
                            Subject: string;
                        }[] | null;
                    }>;
                    MaxPartySize: zod.ZodNumber;
                    AutobalanceEnabled: zod.ZodBoolean;
                    AutobalanceMinPlayers: zod.ZodNumber;
                    HasRecoveryData: zod.ZodBoolean;
                }, "strip", zod.ZodTypeAny, {
                    MaxPartySize: number;
                    Settings: {
                        Mode: string;
                        GameRules: {
                            AllowGameModifiers?: boolean | undefined;
                            IsOvertimeWinByTwo?: boolean | undefined;
                            PlayOutAllRounds?: boolean | undefined;
                            SkipMatchHistory?: boolean | undefined;
                            TournamentMode?: boolean | undefined;
                        } | null;
                        Map: string;
                        UseBots: boolean;
                        GamePod: string;
                    };
                    Membership: {
                        teamOne: {
                            Subject: string;
                        }[] | null;
                        teamTwo: {
                            Subject: string;
                        }[] | null;
                        teamSpectate: {
                            Subject: string;
                        }[] | null;
                        teamOneCoaches: {
                            Subject: string;
                        }[] | null;
                        teamTwoCoaches: {
                            Subject: string;
                        }[] | null;
                    };
                    AutobalanceEnabled: boolean;
                    AutobalanceMinPlayers: number;
                    HasRecoveryData: boolean;
                }, {
                    MaxPartySize: number;
                    Settings: {
                        Mode: string;
                        GameRules: {
                            AllowGameModifiers?: string | undefined;
                            IsOvertimeWinByTwo?: string | undefined;
                            PlayOutAllRounds?: string | undefined;
                            SkipMatchHistory?: string | undefined;
                            TournamentMode?: string | undefined;
                        } | null;
                        Map: string;
                        UseBots: boolean;
                        GamePod: string;
                    };
                    Membership: {
                        teamOne: {
                            Subject: string;
                        }[] | null;
                        teamTwo: {
                            Subject: string;
                        }[] | null;
                        teamSpectate: {
                            Subject: string;
                        }[] | null;
                        teamOneCoaches: {
                            Subject: string;
                        }[] | null;
                        teamTwoCoaches: {
                            Subject: string;
                        }[] | null;
                    };
                    AutobalanceEnabled: boolean;
                    AutobalanceMinPlayers: number;
                    HasRecoveryData: boolean;
                }>;
                MatchmakingData: zod.ZodObject<{
                    QueueID: zod.ZodString;
                    PreferredGamePods: zod.ZodArray<zod.ZodString, "many">;
                    SkillDisparityRRPenalty: zod.ZodNumber;
                }, "strip", zod.ZodTypeAny, {
                    QueueID: string;
                    PreferredGamePods: string[];
                    SkillDisparityRRPenalty: number;
                }, {
                    QueueID: string;
                    PreferredGamePods: string[];
                    SkillDisparityRRPenalty: number;
                }>;
                Invites: zod.ZodNull;
                Requests: zod.ZodArray<zod.ZodUnknown, "many">;
                QueueEntryTime: zod.ZodEffects<zod.ZodString, Date, string>;
                ErrorNotification: zod.ZodObject<{
                    ErrorType: zod.ZodString;
                    ErroredPlayers: zod.ZodNullable<zod.ZodArray<zod.ZodObject<{
                        Subject: zod.ZodString;
                    }, "strip", zod.ZodTypeAny, {
                        Subject: string;
                    }, {
                        Subject: string;
                    }>, "many">>;
                }, "strip", zod.ZodTypeAny, {
                    ErrorType: string;
                    ErroredPlayers: {
                        Subject: string;
                    }[] | null;
                }, {
                    ErrorType: string;
                    ErroredPlayers: {
                        Subject: string;
                    }[] | null;
                }>;
                RestrictedSeconds: zod.ZodNumber;
                EligibleQueues: zod.ZodArray<zod.ZodString, "many">;
                QueueIneligibilities: zod.ZodArray<zod.ZodString, "many">;
                CheatData: zod.ZodObject<{
                    GamePodOverride: zod.ZodString;
                    ForcePostGameProcessing: zod.ZodBoolean;
                }, "strip", zod.ZodTypeAny, {
                    GamePodOverride: string;
                    ForcePostGameProcessing: boolean;
                }, {
                    GamePodOverride: string;
                    ForcePostGameProcessing: boolean;
                }>;
                XPBonuses: zod.ZodArray<zod.ZodUnknown, "many">;
                InviteCode: zod.ZodString;
            }, "strip", zod.ZodTypeAny, {
                ID: string;
                Version: number;
                Invites: null;
                Requests: unknown[];
                State: string;
                MatchmakingData: {
                    QueueID: string;
                    PreferredGamePods: string[];
                    SkillDisparityRRPenalty: number;
                };
                MUCName: string;
                VoiceRoomID: string;
                ClientVersion: string;
                Members: {
                    Subject: string;
                    PlayerIdentity: {
                        Subject: string;
                        PlayerCardID: string;
                        PlayerTitleID: string;
                        AccountLevel: number;
                        PreferredLevelBorderID: string;
                        Incognito: boolean;
                        HideAccountLevel: boolean;
                    };
                    SeasonalBadgeInfo: null;
                    CompetitiveTier: number;
                    QueueEligibleRemainingAccountLevels: number;
                    Pings: {
                        GamePodID: string;
                        Ping: number;
                    }[];
                    IsReady: boolean;
                    IsModerator: boolean;
                    UseBroadcastHUD: boolean;
                    PlatformType: "PC";
                    IsOwner?: boolean | undefined;
                }[];
                PreviousState: string;
                StateTransitionReason: string;
                Accessibility: "OPEN" | "CLOSED";
                CustomGameData: {
                    MaxPartySize: number;
                    Settings: {
                        Mode: string;
                        GameRules: {
                            AllowGameModifiers?: boolean | undefined;
                            IsOvertimeWinByTwo?: boolean | undefined;
                            PlayOutAllRounds?: boolean | undefined;
                            SkipMatchHistory?: boolean | undefined;
                            TournamentMode?: boolean | undefined;
                        } | null;
                        Map: string;
                        UseBots: boolean;
                        GamePod: string;
                    };
                    Membership: {
                        teamOne: {
                            Subject: string;
                        }[] | null;
                        teamTwo: {
                            Subject: string;
                        }[] | null;
                        teamSpectate: {
                            Subject: string;
                        }[] | null;
                        teamOneCoaches: {
                            Subject: string;
                        }[] | null;
                        teamTwoCoaches: {
                            Subject: string;
                        }[] | null;
                    };
                    AutobalanceEnabled: boolean;
                    AutobalanceMinPlayers: number;
                    HasRecoveryData: boolean;
                };
                QueueEntryTime: Date;
                ErrorNotification: {
                    ErrorType: string;
                    ErroredPlayers: {
                        Subject: string;
                    }[] | null;
                };
                RestrictedSeconds: number;
                EligibleQueues: string[];
                QueueIneligibilities: string[];
                CheatData: {
                    GamePodOverride: string;
                    ForcePostGameProcessing: boolean;
                };
                XPBonuses: unknown[];
                InviteCode: string;
            }, {
                ID: string;
                Version: number;
                Invites: null;
                Requests: unknown[];
                State: string;
                MatchmakingData: {
                    QueueID: string;
                    PreferredGamePods: string[];
                    SkillDisparityRRPenalty: number;
                };
                MUCName: string;
                VoiceRoomID: string;
                ClientVersion: string;
                Members: {
                    Subject: string;
                    PlayerIdentity: {
                        Subject: string;
                        PlayerCardID: string;
                        PlayerTitleID: string;
                        AccountLevel: number;
                        PreferredLevelBorderID: string;
                        Incognito: boolean;
                        HideAccountLevel: boolean;
                    };
                    SeasonalBadgeInfo: null;
                    CompetitiveTier: number;
                    QueueEligibleRemainingAccountLevels: number;
                    Pings: {
                        GamePodID: string;
                        Ping: number;
                    }[];
                    IsReady: boolean;
                    IsModerator: boolean;
                    UseBroadcastHUD: boolean;
                    PlatformType: "PC";
                    IsOwner?: boolean | undefined;
                }[];
                PreviousState: string;
                StateTransitionReason: string;
                Accessibility: "OPEN" | "CLOSED";
                CustomGameData: {
                    MaxPartySize: number;
                    Settings: {
                        Mode: string;
                        GameRules: {
                            AllowGameModifiers?: string | undefined;
                            IsOvertimeWinByTwo?: string | undefined;
                            PlayOutAllRounds?: string | undefined;
                            SkipMatchHistory?: string | undefined;
                            TournamentMode?: string | undefined;
                        } | null;
                        Map: string;
                        UseBots: boolean;
                        GamePod: string;
                    };
                    Membership: {
                        teamOne: {
                            Subject: string;
                        }[] | null;
                        teamTwo: {
                            Subject: string;
                        }[] | null;
                        teamSpectate: {
                            Subject: string;
                        }[] | null;
                        teamOneCoaches: {
                            Subject: string;
                        }[] | null;
                        teamTwoCoaches: {
                            Subject: string;
                        }[] | null;
                    };
                    AutobalanceEnabled: boolean;
                    AutobalanceMinPlayers: number;
                    HasRecoveryData: boolean;
                };
                QueueEntryTime: string;
                ErrorNotification: {
                    ErrorType: string;
                    ErroredPlayers: {
                        Subject: string;
                    }[] | null;
                };
                RestrictedSeconds: number;
                EligibleQueues: string[];
                QueueIneligibilities: string[];
                CheatData: {
                    GamePodOverride: string;
                    ForcePostGameProcessing: boolean;
                };
                XPBonuses: unknown[];
                InviteCode: string;
            }>;
        };
    };
};

type Params$5 = ResolveParams<(typeof _default$5)["~type"]["url"]>;
type Body$5 = z.infer<ResolveValue<(typeof _default$5)["~type"], "body">>;
type Data$5 = ResolveData<Params$5, Body$5>;
type Response$5 = z.infer<ResolveValue<(typeof _default$5)["~type"], "responses">["200"]>;
interface RefreshPingsRequestConfig extends ValorantAxiosRequestConfig<Data$5> {
}
declare class RefreshPingsEndpoint {
    /**
     * Refresh the pings of the specified player
     *
     * @EndpointType glz
     */
    postRefreshPings<T = Response$5>(this: RemoteApiClient, config: RefreshPingsRequestConfig): Promise<AxiosResponse<T>>;
}

declare const _default$4: Omit<{
    requirements: string[];
    type: "auth" | "local" | "pd" | "glz" | "shared";
    name: string;
    method: "PUT" | "GET" | "DELETE" | "POST";
    url: string;
    description?: string | undefined;
    headers?: Record<string, string> | undefined;
    body?: zod.ZodType<any, zod.ZodTypeDef, any> | undefined;
    query?: zod.ZodType<any, zod.ZodTypeDef, any> | undefined;
    responses?: Record<string, zod.ZodType<any, zod.ZodTypeDef, any>> | undefined;
}, "type" | "name" | "url"> & Pick<{
    readonly name: "Refresh Player Identity";
    readonly description: "Refresh the identity of the specified player";
    readonly type: "glz";
    readonly method: "POST";
    readonly url: "parties/v1/parties/:partyId/members/:puuid/refreshPlayerIdentity";
    readonly responses: {
        readonly "200": zod.ZodObject<{
            ID: zod.ZodString;
            MUCName: zod.ZodString;
            VoiceRoomID: zod.ZodString;
            Version: zod.ZodNumber;
            ClientVersion: zod.ZodString;
            Members: zod.ZodArray<zod.ZodObject<{
                Subject: zod.ZodString;
                CompetitiveTier: zod.ZodNumber;
                PlayerIdentity: zod.ZodObject<{
                    Subject: zod.ZodString;
                    PlayerCardID: zod.ZodString;
                    PlayerTitleID: zod.ZodString;
                    AccountLevel: zod.ZodNumber;
                    PreferredLevelBorderID: zod.ZodUnion<[zod.ZodString, zod.ZodLiteral<"">]>;
                    Incognito: zod.ZodBoolean;
                    HideAccountLevel: zod.ZodBoolean;
                }, "strip", zod.ZodTypeAny, {
                    Subject: string;
                    PlayerCardID: string;
                    PlayerTitleID: string;
                    AccountLevel: number;
                    PreferredLevelBorderID: string;
                    Incognito: boolean;
                    HideAccountLevel: boolean;
                }, {
                    Subject: string;
                    PlayerCardID: string;
                    PlayerTitleID: string;
                    AccountLevel: number;
                    PreferredLevelBorderID: string;
                    Incognito: boolean;
                    HideAccountLevel: boolean;
                }>;
                SeasonalBadgeInfo: zod.ZodNull;
                IsOwner: zod.ZodOptional<zod.ZodBoolean>;
                QueueEligibleRemainingAccountLevels: zod.ZodNumber;
                Pings: zod.ZodArray<zod.ZodObject<{
                    Ping: zod.ZodNumber;
                    GamePodID: zod.ZodString;
                }, "strip", zod.ZodTypeAny, {
                    GamePodID: string;
                    Ping: number;
                }, {
                    GamePodID: string;
                    Ping: number;
                }>, "many">;
                IsReady: zod.ZodBoolean;
                IsModerator: zod.ZodBoolean;
                UseBroadcastHUD: zod.ZodBoolean;
                PlatformType: zod.ZodLiteral<"PC">;
            }, "strip", zod.ZodTypeAny, {
                Subject: string;
                PlayerIdentity: {
                    Subject: string;
                    PlayerCardID: string;
                    PlayerTitleID: string;
                    AccountLevel: number;
                    PreferredLevelBorderID: string;
                    Incognito: boolean;
                    HideAccountLevel: boolean;
                };
                SeasonalBadgeInfo: null;
                CompetitiveTier: number;
                QueueEligibleRemainingAccountLevels: number;
                Pings: {
                    GamePodID: string;
                    Ping: number;
                }[];
                IsReady: boolean;
                IsModerator: boolean;
                UseBroadcastHUD: boolean;
                PlatformType: "PC";
                IsOwner?: boolean | undefined;
            }, {
                Subject: string;
                PlayerIdentity: {
                    Subject: string;
                    PlayerCardID: string;
                    PlayerTitleID: string;
                    AccountLevel: number;
                    PreferredLevelBorderID: string;
                    Incognito: boolean;
                    HideAccountLevel: boolean;
                };
                SeasonalBadgeInfo: null;
                CompetitiveTier: number;
                QueueEligibleRemainingAccountLevels: number;
                Pings: {
                    GamePodID: string;
                    Ping: number;
                }[];
                IsReady: boolean;
                IsModerator: boolean;
                UseBroadcastHUD: boolean;
                PlatformType: "PC";
                IsOwner?: boolean | undefined;
            }>, "many">;
            State: zod.ZodString;
            PreviousState: zod.ZodString;
            StateTransitionReason: zod.ZodString;
            Accessibility: zod.ZodUnion<[zod.ZodLiteral<"OPEN">, zod.ZodLiteral<"CLOSED">]>;
            CustomGameData: zod.ZodObject<{
                Settings: zod.ZodObject<{
                    Map: zod.ZodString;
                    Mode: zod.ZodString;
                    UseBots: zod.ZodBoolean;
                    GamePod: zod.ZodString;
                    GameRules: zod.ZodNullable<zod.ZodObject<{
                        AllowGameModifiers: zod.ZodOptional<zod.ZodEffects<zod.ZodString, boolean, string>>;
                        IsOvertimeWinByTwo: zod.ZodOptional<zod.ZodEffects<zod.ZodString, boolean, string>>;
                        PlayOutAllRounds: zod.ZodOptional<zod.ZodEffects<zod.ZodString, boolean, string>>;
                        SkipMatchHistory: zod.ZodOptional<zod.ZodEffects<zod.ZodString, boolean, string>>;
                        TournamentMode: zod.ZodOptional<zod.ZodEffects<zod.ZodString, boolean, string>>;
                    }, "strip", zod.ZodTypeAny, {
                        AllowGameModifiers?: boolean | undefined;
                        IsOvertimeWinByTwo?: boolean | undefined;
                        PlayOutAllRounds?: boolean | undefined;
                        SkipMatchHistory?: boolean | undefined;
                        TournamentMode?: boolean | undefined;
                    }, {
                        AllowGameModifiers?: string | undefined;
                        IsOvertimeWinByTwo?: string | undefined;
                        PlayOutAllRounds?: string | undefined;
                        SkipMatchHistory?: string | undefined;
                        TournamentMode?: string | undefined;
                    }>>;
                }, "strip", zod.ZodTypeAny, {
                    Mode: string;
                    GameRules: {
                        AllowGameModifiers?: boolean | undefined;
                        IsOvertimeWinByTwo?: boolean | undefined;
                        PlayOutAllRounds?: boolean | undefined;
                        SkipMatchHistory?: boolean | undefined;
                        TournamentMode?: boolean | undefined;
                    } | null;
                    Map: string;
                    UseBots: boolean;
                    GamePod: string;
                }, {
                    Mode: string;
                    GameRules: {
                        AllowGameModifiers?: string | undefined;
                        IsOvertimeWinByTwo?: string | undefined;
                        PlayOutAllRounds?: string | undefined;
                        SkipMatchHistory?: string | undefined;
                        TournamentMode?: string | undefined;
                    } | null;
                    Map: string;
                    UseBots: boolean;
                    GamePod: string;
                }>;
                Membership: zod.ZodObject<{
                    teamOne: zod.ZodNullable<zod.ZodArray<zod.ZodObject<{
                        Subject: zod.ZodString;
                    }, "strip", zod.ZodTypeAny, {
                        Subject: string;
                    }, {
                        Subject: string;
                    }>, "many">>;
                    teamTwo: zod.ZodNullable<zod.ZodArray<zod.ZodObject<{
                        Subject: zod.ZodString;
                    }, "strip", zod.ZodTypeAny, {
                        Subject: string;
                    }, {
                        Subject: string;
                    }>, "many">>;
                    teamSpectate: zod.ZodNullable<zod.ZodArray<zod.ZodObject<{
                        Subject: zod.ZodString;
                    }, "strip", zod.ZodTypeAny, {
                        Subject: string;
                    }, {
                        Subject: string;
                    }>, "many">>;
                    teamOneCoaches: zod.ZodNullable<zod.ZodArray<zod.ZodObject<{
                        Subject: zod.ZodString;
                    }, "strip", zod.ZodTypeAny, {
                        Subject: string;
                    }, {
                        Subject: string;
                    }>, "many">>;
                    teamTwoCoaches: zod.ZodNullable<zod.ZodArray<zod.ZodObject<{
                        Subject: zod.ZodString;
                    }, "strip", zod.ZodTypeAny, {
                        Subject: string;
                    }, {
                        Subject: string;
                    }>, "many">>;
                }, "strip", zod.ZodTypeAny, {
                    teamOne: {
                        Subject: string;
                    }[] | null;
                    teamTwo: {
                        Subject: string;
                    }[] | null;
                    teamSpectate: {
                        Subject: string;
                    }[] | null;
                    teamOneCoaches: {
                        Subject: string;
                    }[] | null;
                    teamTwoCoaches: {
                        Subject: string;
                    }[] | null;
                }, {
                    teamOne: {
                        Subject: string;
                    }[] | null;
                    teamTwo: {
                        Subject: string;
                    }[] | null;
                    teamSpectate: {
                        Subject: string;
                    }[] | null;
                    teamOneCoaches: {
                        Subject: string;
                    }[] | null;
                    teamTwoCoaches: {
                        Subject: string;
                    }[] | null;
                }>;
                MaxPartySize: zod.ZodNumber;
                AutobalanceEnabled: zod.ZodBoolean;
                AutobalanceMinPlayers: zod.ZodNumber;
                HasRecoveryData: zod.ZodBoolean;
            }, "strip", zod.ZodTypeAny, {
                MaxPartySize: number;
                Settings: {
                    Mode: string;
                    GameRules: {
                        AllowGameModifiers?: boolean | undefined;
                        IsOvertimeWinByTwo?: boolean | undefined;
                        PlayOutAllRounds?: boolean | undefined;
                        SkipMatchHistory?: boolean | undefined;
                        TournamentMode?: boolean | undefined;
                    } | null;
                    Map: string;
                    UseBots: boolean;
                    GamePod: string;
                };
                Membership: {
                    teamOne: {
                        Subject: string;
                    }[] | null;
                    teamTwo: {
                        Subject: string;
                    }[] | null;
                    teamSpectate: {
                        Subject: string;
                    }[] | null;
                    teamOneCoaches: {
                        Subject: string;
                    }[] | null;
                    teamTwoCoaches: {
                        Subject: string;
                    }[] | null;
                };
                AutobalanceEnabled: boolean;
                AutobalanceMinPlayers: number;
                HasRecoveryData: boolean;
            }, {
                MaxPartySize: number;
                Settings: {
                    Mode: string;
                    GameRules: {
                        AllowGameModifiers?: string | undefined;
                        IsOvertimeWinByTwo?: string | undefined;
                        PlayOutAllRounds?: string | undefined;
                        SkipMatchHistory?: string | undefined;
                        TournamentMode?: string | undefined;
                    } | null;
                    Map: string;
                    UseBots: boolean;
                    GamePod: string;
                };
                Membership: {
                    teamOne: {
                        Subject: string;
                    }[] | null;
                    teamTwo: {
                        Subject: string;
                    }[] | null;
                    teamSpectate: {
                        Subject: string;
                    }[] | null;
                    teamOneCoaches: {
                        Subject: string;
                    }[] | null;
                    teamTwoCoaches: {
                        Subject: string;
                    }[] | null;
                };
                AutobalanceEnabled: boolean;
                AutobalanceMinPlayers: number;
                HasRecoveryData: boolean;
            }>;
            MatchmakingData: zod.ZodObject<{
                QueueID: zod.ZodString;
                PreferredGamePods: zod.ZodArray<zod.ZodString, "many">;
                SkillDisparityRRPenalty: zod.ZodNumber;
            }, "strip", zod.ZodTypeAny, {
                QueueID: string;
                PreferredGamePods: string[];
                SkillDisparityRRPenalty: number;
            }, {
                QueueID: string;
                PreferredGamePods: string[];
                SkillDisparityRRPenalty: number;
            }>;
            Invites: zod.ZodNull;
            Requests: zod.ZodArray<zod.ZodUnknown, "many">;
            QueueEntryTime: zod.ZodEffects<zod.ZodString, Date, string>;
            ErrorNotification: zod.ZodObject<{
                ErrorType: zod.ZodString;
                ErroredPlayers: zod.ZodNullable<zod.ZodArray<zod.ZodObject<{
                    Subject: zod.ZodString;
                }, "strip", zod.ZodTypeAny, {
                    Subject: string;
                }, {
                    Subject: string;
                }>, "many">>;
            }, "strip", zod.ZodTypeAny, {
                ErrorType: string;
                ErroredPlayers: {
                    Subject: string;
                }[] | null;
            }, {
                ErrorType: string;
                ErroredPlayers: {
                    Subject: string;
                }[] | null;
            }>;
            RestrictedSeconds: zod.ZodNumber;
            EligibleQueues: zod.ZodArray<zod.ZodString, "many">;
            QueueIneligibilities: zod.ZodArray<zod.ZodString, "many">;
            CheatData: zod.ZodObject<{
                GamePodOverride: zod.ZodString;
                ForcePostGameProcessing: zod.ZodBoolean;
            }, "strip", zod.ZodTypeAny, {
                GamePodOverride: string;
                ForcePostGameProcessing: boolean;
            }, {
                GamePodOverride: string;
                ForcePostGameProcessing: boolean;
            }>;
            XPBonuses: zod.ZodArray<zod.ZodUnknown, "many">;
            InviteCode: zod.ZodString;
        }, "strip", zod.ZodTypeAny, {
            ID: string;
            Version: number;
            Invites: null;
            Requests: unknown[];
            State: string;
            MatchmakingData: {
                QueueID: string;
                PreferredGamePods: string[];
                SkillDisparityRRPenalty: number;
            };
            MUCName: string;
            VoiceRoomID: string;
            ClientVersion: string;
            Members: {
                Subject: string;
                PlayerIdentity: {
                    Subject: string;
                    PlayerCardID: string;
                    PlayerTitleID: string;
                    AccountLevel: number;
                    PreferredLevelBorderID: string;
                    Incognito: boolean;
                    HideAccountLevel: boolean;
                };
                SeasonalBadgeInfo: null;
                CompetitiveTier: number;
                QueueEligibleRemainingAccountLevels: number;
                Pings: {
                    GamePodID: string;
                    Ping: number;
                }[];
                IsReady: boolean;
                IsModerator: boolean;
                UseBroadcastHUD: boolean;
                PlatformType: "PC";
                IsOwner?: boolean | undefined;
            }[];
            PreviousState: string;
            StateTransitionReason: string;
            Accessibility: "OPEN" | "CLOSED";
            CustomGameData: {
                MaxPartySize: number;
                Settings: {
                    Mode: string;
                    GameRules: {
                        AllowGameModifiers?: boolean | undefined;
                        IsOvertimeWinByTwo?: boolean | undefined;
                        PlayOutAllRounds?: boolean | undefined;
                        SkipMatchHistory?: boolean | undefined;
                        TournamentMode?: boolean | undefined;
                    } | null;
                    Map: string;
                    UseBots: boolean;
                    GamePod: string;
                };
                Membership: {
                    teamOne: {
                        Subject: string;
                    }[] | null;
                    teamTwo: {
                        Subject: string;
                    }[] | null;
                    teamSpectate: {
                        Subject: string;
                    }[] | null;
                    teamOneCoaches: {
                        Subject: string;
                    }[] | null;
                    teamTwoCoaches: {
                        Subject: string;
                    }[] | null;
                };
                AutobalanceEnabled: boolean;
                AutobalanceMinPlayers: number;
                HasRecoveryData: boolean;
            };
            QueueEntryTime: Date;
            ErrorNotification: {
                ErrorType: string;
                ErroredPlayers: {
                    Subject: string;
                }[] | null;
            };
            RestrictedSeconds: number;
            EligibleQueues: string[];
            QueueIneligibilities: string[];
            CheatData: {
                GamePodOverride: string;
                ForcePostGameProcessing: boolean;
            };
            XPBonuses: unknown[];
            InviteCode: string;
        }, {
            ID: string;
            Version: number;
            Invites: null;
            Requests: unknown[];
            State: string;
            MatchmakingData: {
                QueueID: string;
                PreferredGamePods: string[];
                SkillDisparityRRPenalty: number;
            };
            MUCName: string;
            VoiceRoomID: string;
            ClientVersion: string;
            Members: {
                Subject: string;
                PlayerIdentity: {
                    Subject: string;
                    PlayerCardID: string;
                    PlayerTitleID: string;
                    AccountLevel: number;
                    PreferredLevelBorderID: string;
                    Incognito: boolean;
                    HideAccountLevel: boolean;
                };
                SeasonalBadgeInfo: null;
                CompetitiveTier: number;
                QueueEligibleRemainingAccountLevels: number;
                Pings: {
                    GamePodID: string;
                    Ping: number;
                }[];
                IsReady: boolean;
                IsModerator: boolean;
                UseBroadcastHUD: boolean;
                PlatformType: "PC";
                IsOwner?: boolean | undefined;
            }[];
            PreviousState: string;
            StateTransitionReason: string;
            Accessibility: "OPEN" | "CLOSED";
            CustomGameData: {
                MaxPartySize: number;
                Settings: {
                    Mode: string;
                    GameRules: {
                        AllowGameModifiers?: string | undefined;
                        IsOvertimeWinByTwo?: string | undefined;
                        PlayOutAllRounds?: string | undefined;
                        SkipMatchHistory?: string | undefined;
                        TournamentMode?: string | undefined;
                    } | null;
                    Map: string;
                    UseBots: boolean;
                    GamePod: string;
                };
                Membership: {
                    teamOne: {
                        Subject: string;
                    }[] | null;
                    teamTwo: {
                        Subject: string;
                    }[] | null;
                    teamSpectate: {
                        Subject: string;
                    }[] | null;
                    teamOneCoaches: {
                        Subject: string;
                    }[] | null;
                    teamTwoCoaches: {
                        Subject: string;
                    }[] | null;
                };
                AutobalanceEnabled: boolean;
                AutobalanceMinPlayers: number;
                HasRecoveryData: boolean;
            };
            QueueEntryTime: string;
            ErrorNotification: {
                ErrorType: string;
                ErroredPlayers: {
                    Subject: string;
                }[] | null;
            };
            RestrictedSeconds: number;
            EligibleQueues: string[];
            QueueIneligibilities: string[];
            CheatData: {
                GamePodOverride: string;
                ForcePostGameProcessing: boolean;
            };
            XPBonuses: unknown[];
            InviteCode: string;
        }>;
    };
}, "type" | "name" | "url"> & {
    "~type": {
        readonly name: "Refresh Player Identity";
        readonly description: "Refresh the identity of the specified player";
        readonly type: "glz";
        readonly method: "POST";
        readonly url: "parties/v1/parties/:partyId/members/:puuid/refreshPlayerIdentity";
        readonly responses: {
            readonly "200": zod.ZodObject<{
                ID: zod.ZodString;
                MUCName: zod.ZodString;
                VoiceRoomID: zod.ZodString;
                Version: zod.ZodNumber;
                ClientVersion: zod.ZodString;
                Members: zod.ZodArray<zod.ZodObject<{
                    Subject: zod.ZodString;
                    CompetitiveTier: zod.ZodNumber;
                    PlayerIdentity: zod.ZodObject<{
                        Subject: zod.ZodString;
                        PlayerCardID: zod.ZodString;
                        PlayerTitleID: zod.ZodString;
                        AccountLevel: zod.ZodNumber;
                        PreferredLevelBorderID: zod.ZodUnion<[zod.ZodString, zod.ZodLiteral<"">]>;
                        Incognito: zod.ZodBoolean;
                        HideAccountLevel: zod.ZodBoolean;
                    }, "strip", zod.ZodTypeAny, {
                        Subject: string;
                        PlayerCardID: string;
                        PlayerTitleID: string;
                        AccountLevel: number;
                        PreferredLevelBorderID: string;
                        Incognito: boolean;
                        HideAccountLevel: boolean;
                    }, {
                        Subject: string;
                        PlayerCardID: string;
                        PlayerTitleID: string;
                        AccountLevel: number;
                        PreferredLevelBorderID: string;
                        Incognito: boolean;
                        HideAccountLevel: boolean;
                    }>;
                    SeasonalBadgeInfo: zod.ZodNull;
                    IsOwner: zod.ZodOptional<zod.ZodBoolean>;
                    QueueEligibleRemainingAccountLevels: zod.ZodNumber;
                    Pings: zod.ZodArray<zod.ZodObject<{
                        Ping: zod.ZodNumber;
                        GamePodID: zod.ZodString;
                    }, "strip", zod.ZodTypeAny, {
                        GamePodID: string;
                        Ping: number;
                    }, {
                        GamePodID: string;
                        Ping: number;
                    }>, "many">;
                    IsReady: zod.ZodBoolean;
                    IsModerator: zod.ZodBoolean;
                    UseBroadcastHUD: zod.ZodBoolean;
                    PlatformType: zod.ZodLiteral<"PC">;
                }, "strip", zod.ZodTypeAny, {
                    Subject: string;
                    PlayerIdentity: {
                        Subject: string;
                        PlayerCardID: string;
                        PlayerTitleID: string;
                        AccountLevel: number;
                        PreferredLevelBorderID: string;
                        Incognito: boolean;
                        HideAccountLevel: boolean;
                    };
                    SeasonalBadgeInfo: null;
                    CompetitiveTier: number;
                    QueueEligibleRemainingAccountLevels: number;
                    Pings: {
                        GamePodID: string;
                        Ping: number;
                    }[];
                    IsReady: boolean;
                    IsModerator: boolean;
                    UseBroadcastHUD: boolean;
                    PlatformType: "PC";
                    IsOwner?: boolean | undefined;
                }, {
                    Subject: string;
                    PlayerIdentity: {
                        Subject: string;
                        PlayerCardID: string;
                        PlayerTitleID: string;
                        AccountLevel: number;
                        PreferredLevelBorderID: string;
                        Incognito: boolean;
                        HideAccountLevel: boolean;
                    };
                    SeasonalBadgeInfo: null;
                    CompetitiveTier: number;
                    QueueEligibleRemainingAccountLevels: number;
                    Pings: {
                        GamePodID: string;
                        Ping: number;
                    }[];
                    IsReady: boolean;
                    IsModerator: boolean;
                    UseBroadcastHUD: boolean;
                    PlatformType: "PC";
                    IsOwner?: boolean | undefined;
                }>, "many">;
                State: zod.ZodString;
                PreviousState: zod.ZodString;
                StateTransitionReason: zod.ZodString;
                Accessibility: zod.ZodUnion<[zod.ZodLiteral<"OPEN">, zod.ZodLiteral<"CLOSED">]>;
                CustomGameData: zod.ZodObject<{
                    Settings: zod.ZodObject<{
                        Map: zod.ZodString;
                        Mode: zod.ZodString;
                        UseBots: zod.ZodBoolean;
                        GamePod: zod.ZodString;
                        GameRules: zod.ZodNullable<zod.ZodObject<{
                            AllowGameModifiers: zod.ZodOptional<zod.ZodEffects<zod.ZodString, boolean, string>>;
                            IsOvertimeWinByTwo: zod.ZodOptional<zod.ZodEffects<zod.ZodString, boolean, string>>;
                            PlayOutAllRounds: zod.ZodOptional<zod.ZodEffects<zod.ZodString, boolean, string>>;
                            SkipMatchHistory: zod.ZodOptional<zod.ZodEffects<zod.ZodString, boolean, string>>;
                            TournamentMode: zod.ZodOptional<zod.ZodEffects<zod.ZodString, boolean, string>>;
                        }, "strip", zod.ZodTypeAny, {
                            AllowGameModifiers?: boolean | undefined;
                            IsOvertimeWinByTwo?: boolean | undefined;
                            PlayOutAllRounds?: boolean | undefined;
                            SkipMatchHistory?: boolean | undefined;
                            TournamentMode?: boolean | undefined;
                        }, {
                            AllowGameModifiers?: string | undefined;
                            IsOvertimeWinByTwo?: string | undefined;
                            PlayOutAllRounds?: string | undefined;
                            SkipMatchHistory?: string | undefined;
                            TournamentMode?: string | undefined;
                        }>>;
                    }, "strip", zod.ZodTypeAny, {
                        Mode: string;
                        GameRules: {
                            AllowGameModifiers?: boolean | undefined;
                            IsOvertimeWinByTwo?: boolean | undefined;
                            PlayOutAllRounds?: boolean | undefined;
                            SkipMatchHistory?: boolean | undefined;
                            TournamentMode?: boolean | undefined;
                        } | null;
                        Map: string;
                        UseBots: boolean;
                        GamePod: string;
                    }, {
                        Mode: string;
                        GameRules: {
                            AllowGameModifiers?: string | undefined;
                            IsOvertimeWinByTwo?: string | undefined;
                            PlayOutAllRounds?: string | undefined;
                            SkipMatchHistory?: string | undefined;
                            TournamentMode?: string | undefined;
                        } | null;
                        Map: string;
                        UseBots: boolean;
                        GamePod: string;
                    }>;
                    Membership: zod.ZodObject<{
                        teamOne: zod.ZodNullable<zod.ZodArray<zod.ZodObject<{
                            Subject: zod.ZodString;
                        }, "strip", zod.ZodTypeAny, {
                            Subject: string;
                        }, {
                            Subject: string;
                        }>, "many">>;
                        teamTwo: zod.ZodNullable<zod.ZodArray<zod.ZodObject<{
                            Subject: zod.ZodString;
                        }, "strip", zod.ZodTypeAny, {
                            Subject: string;
                        }, {
                            Subject: string;
                        }>, "many">>;
                        teamSpectate: zod.ZodNullable<zod.ZodArray<zod.ZodObject<{
                            Subject: zod.ZodString;
                        }, "strip", zod.ZodTypeAny, {
                            Subject: string;
                        }, {
                            Subject: string;
                        }>, "many">>;
                        teamOneCoaches: zod.ZodNullable<zod.ZodArray<zod.ZodObject<{
                            Subject: zod.ZodString;
                        }, "strip", zod.ZodTypeAny, {
                            Subject: string;
                        }, {
                            Subject: string;
                        }>, "many">>;
                        teamTwoCoaches: zod.ZodNullable<zod.ZodArray<zod.ZodObject<{
                            Subject: zod.ZodString;
                        }, "strip", zod.ZodTypeAny, {
                            Subject: string;
                        }, {
                            Subject: string;
                        }>, "many">>;
                    }, "strip", zod.ZodTypeAny, {
                        teamOne: {
                            Subject: string;
                        }[] | null;
                        teamTwo: {
                            Subject: string;
                        }[] | null;
                        teamSpectate: {
                            Subject: string;
                        }[] | null;
                        teamOneCoaches: {
                            Subject: string;
                        }[] | null;
                        teamTwoCoaches: {
                            Subject: string;
                        }[] | null;
                    }, {
                        teamOne: {
                            Subject: string;
                        }[] | null;
                        teamTwo: {
                            Subject: string;
                        }[] | null;
                        teamSpectate: {
                            Subject: string;
                        }[] | null;
                        teamOneCoaches: {
                            Subject: string;
                        }[] | null;
                        teamTwoCoaches: {
                            Subject: string;
                        }[] | null;
                    }>;
                    MaxPartySize: zod.ZodNumber;
                    AutobalanceEnabled: zod.ZodBoolean;
                    AutobalanceMinPlayers: zod.ZodNumber;
                    HasRecoveryData: zod.ZodBoolean;
                }, "strip", zod.ZodTypeAny, {
                    MaxPartySize: number;
                    Settings: {
                        Mode: string;
                        GameRules: {
                            AllowGameModifiers?: boolean | undefined;
                            IsOvertimeWinByTwo?: boolean | undefined;
                            PlayOutAllRounds?: boolean | undefined;
                            SkipMatchHistory?: boolean | undefined;
                            TournamentMode?: boolean | undefined;
                        } | null;
                        Map: string;
                        UseBots: boolean;
                        GamePod: string;
                    };
                    Membership: {
                        teamOne: {
                            Subject: string;
                        }[] | null;
                        teamTwo: {
                            Subject: string;
                        }[] | null;
                        teamSpectate: {
                            Subject: string;
                        }[] | null;
                        teamOneCoaches: {
                            Subject: string;
                        }[] | null;
                        teamTwoCoaches: {
                            Subject: string;
                        }[] | null;
                    };
                    AutobalanceEnabled: boolean;
                    AutobalanceMinPlayers: number;
                    HasRecoveryData: boolean;
                }, {
                    MaxPartySize: number;
                    Settings: {
                        Mode: string;
                        GameRules: {
                            AllowGameModifiers?: string | undefined;
                            IsOvertimeWinByTwo?: string | undefined;
                            PlayOutAllRounds?: string | undefined;
                            SkipMatchHistory?: string | undefined;
                            TournamentMode?: string | undefined;
                        } | null;
                        Map: string;
                        UseBots: boolean;
                        GamePod: string;
                    };
                    Membership: {
                        teamOne: {
                            Subject: string;
                        }[] | null;
                        teamTwo: {
                            Subject: string;
                        }[] | null;
                        teamSpectate: {
                            Subject: string;
                        }[] | null;
                        teamOneCoaches: {
                            Subject: string;
                        }[] | null;
                        teamTwoCoaches: {
                            Subject: string;
                        }[] | null;
                    };
                    AutobalanceEnabled: boolean;
                    AutobalanceMinPlayers: number;
                    HasRecoveryData: boolean;
                }>;
                MatchmakingData: zod.ZodObject<{
                    QueueID: zod.ZodString;
                    PreferredGamePods: zod.ZodArray<zod.ZodString, "many">;
                    SkillDisparityRRPenalty: zod.ZodNumber;
                }, "strip", zod.ZodTypeAny, {
                    QueueID: string;
                    PreferredGamePods: string[];
                    SkillDisparityRRPenalty: number;
                }, {
                    QueueID: string;
                    PreferredGamePods: string[];
                    SkillDisparityRRPenalty: number;
                }>;
                Invites: zod.ZodNull;
                Requests: zod.ZodArray<zod.ZodUnknown, "many">;
                QueueEntryTime: zod.ZodEffects<zod.ZodString, Date, string>;
                ErrorNotification: zod.ZodObject<{
                    ErrorType: zod.ZodString;
                    ErroredPlayers: zod.ZodNullable<zod.ZodArray<zod.ZodObject<{
                        Subject: zod.ZodString;
                    }, "strip", zod.ZodTypeAny, {
                        Subject: string;
                    }, {
                        Subject: string;
                    }>, "many">>;
                }, "strip", zod.ZodTypeAny, {
                    ErrorType: string;
                    ErroredPlayers: {
                        Subject: string;
                    }[] | null;
                }, {
                    ErrorType: string;
                    ErroredPlayers: {
                        Subject: string;
                    }[] | null;
                }>;
                RestrictedSeconds: zod.ZodNumber;
                EligibleQueues: zod.ZodArray<zod.ZodString, "many">;
                QueueIneligibilities: zod.ZodArray<zod.ZodString, "many">;
                CheatData: zod.ZodObject<{
                    GamePodOverride: zod.ZodString;
                    ForcePostGameProcessing: zod.ZodBoolean;
                }, "strip", zod.ZodTypeAny, {
                    GamePodOverride: string;
                    ForcePostGameProcessing: boolean;
                }, {
                    GamePodOverride: string;
                    ForcePostGameProcessing: boolean;
                }>;
                XPBonuses: zod.ZodArray<zod.ZodUnknown, "many">;
                InviteCode: zod.ZodString;
            }, "strip", zod.ZodTypeAny, {
                ID: string;
                Version: number;
                Invites: null;
                Requests: unknown[];
                State: string;
                MatchmakingData: {
                    QueueID: string;
                    PreferredGamePods: string[];
                    SkillDisparityRRPenalty: number;
                };
                MUCName: string;
                VoiceRoomID: string;
                ClientVersion: string;
                Members: {
                    Subject: string;
                    PlayerIdentity: {
                        Subject: string;
                        PlayerCardID: string;
                        PlayerTitleID: string;
                        AccountLevel: number;
                        PreferredLevelBorderID: string;
                        Incognito: boolean;
                        HideAccountLevel: boolean;
                    };
                    SeasonalBadgeInfo: null;
                    CompetitiveTier: number;
                    QueueEligibleRemainingAccountLevels: number;
                    Pings: {
                        GamePodID: string;
                        Ping: number;
                    }[];
                    IsReady: boolean;
                    IsModerator: boolean;
                    UseBroadcastHUD: boolean;
                    PlatformType: "PC";
                    IsOwner?: boolean | undefined;
                }[];
                PreviousState: string;
                StateTransitionReason: string;
                Accessibility: "OPEN" | "CLOSED";
                CustomGameData: {
                    MaxPartySize: number;
                    Settings: {
                        Mode: string;
                        GameRules: {
                            AllowGameModifiers?: boolean | undefined;
                            IsOvertimeWinByTwo?: boolean | undefined;
                            PlayOutAllRounds?: boolean | undefined;
                            SkipMatchHistory?: boolean | undefined;
                            TournamentMode?: boolean | undefined;
                        } | null;
                        Map: string;
                        UseBots: boolean;
                        GamePod: string;
                    };
                    Membership: {
                        teamOne: {
                            Subject: string;
                        }[] | null;
                        teamTwo: {
                            Subject: string;
                        }[] | null;
                        teamSpectate: {
                            Subject: string;
                        }[] | null;
                        teamOneCoaches: {
                            Subject: string;
                        }[] | null;
                        teamTwoCoaches: {
                            Subject: string;
                        }[] | null;
                    };
                    AutobalanceEnabled: boolean;
                    AutobalanceMinPlayers: number;
                    HasRecoveryData: boolean;
                };
                QueueEntryTime: Date;
                ErrorNotification: {
                    ErrorType: string;
                    ErroredPlayers: {
                        Subject: string;
                    }[] | null;
                };
                RestrictedSeconds: number;
                EligibleQueues: string[];
                QueueIneligibilities: string[];
                CheatData: {
                    GamePodOverride: string;
                    ForcePostGameProcessing: boolean;
                };
                XPBonuses: unknown[];
                InviteCode: string;
            }, {
                ID: string;
                Version: number;
                Invites: null;
                Requests: unknown[];
                State: string;
                MatchmakingData: {
                    QueueID: string;
                    PreferredGamePods: string[];
                    SkillDisparityRRPenalty: number;
                };
                MUCName: string;
                VoiceRoomID: string;
                ClientVersion: string;
                Members: {
                    Subject: string;
                    PlayerIdentity: {
                        Subject: string;
                        PlayerCardID: string;
                        PlayerTitleID: string;
                        AccountLevel: number;
                        PreferredLevelBorderID: string;
                        Incognito: boolean;
                        HideAccountLevel: boolean;
                    };
                    SeasonalBadgeInfo: null;
                    CompetitiveTier: number;
                    QueueEligibleRemainingAccountLevels: number;
                    Pings: {
                        GamePodID: string;
                        Ping: number;
                    }[];
                    IsReady: boolean;
                    IsModerator: boolean;
                    UseBroadcastHUD: boolean;
                    PlatformType: "PC";
                    IsOwner?: boolean | undefined;
                }[];
                PreviousState: string;
                StateTransitionReason: string;
                Accessibility: "OPEN" | "CLOSED";
                CustomGameData: {
                    MaxPartySize: number;
                    Settings: {
                        Mode: string;
                        GameRules: {
                            AllowGameModifiers?: string | undefined;
                            IsOvertimeWinByTwo?: string | undefined;
                            PlayOutAllRounds?: string | undefined;
                            SkipMatchHistory?: string | undefined;
                            TournamentMode?: string | undefined;
                        } | null;
                        Map: string;
                        UseBots: boolean;
                        GamePod: string;
                    };
                    Membership: {
                        teamOne: {
                            Subject: string;
                        }[] | null;
                        teamTwo: {
                            Subject: string;
                        }[] | null;
                        teamSpectate: {
                            Subject: string;
                        }[] | null;
                        teamOneCoaches: {
                            Subject: string;
                        }[] | null;
                        teamTwoCoaches: {
                            Subject: string;
                        }[] | null;
                    };
                    AutobalanceEnabled: boolean;
                    AutobalanceMinPlayers: number;
                    HasRecoveryData: boolean;
                };
                QueueEntryTime: string;
                ErrorNotification: {
                    ErrorType: string;
                    ErroredPlayers: {
                        Subject: string;
                    }[] | null;
                };
                RestrictedSeconds: number;
                EligibleQueues: string[];
                QueueIneligibilities: string[];
                CheatData: {
                    GamePodOverride: string;
                    ForcePostGameProcessing: boolean;
                };
                XPBonuses: unknown[];
                InviteCode: string;
            }>;
        };
    };
};

type Params$4 = ResolveParams<(typeof _default$4)["~type"]["url"]>;
type Body$4 = z.infer<ResolveValue<(typeof _default$4)["~type"], "body">>;
type Data$4 = ResolveData<Params$4, Body$4>;
type Response$4 = z.infer<ResolveValue<(typeof _default$4)["~type"], "responses">["200"]>;
interface RefreshPlayerIdentityRequestConfig extends ValorantAxiosRequestConfig<Data$4> {
}
declare class RefreshPlayerIdentityEndpoint {
    /**
     * Refresh the identity of the specified player
     *
     * @EndpointType glz
     */
    postRefreshPlayerIdentity<T = Response$4>(this: RemoteApiClient, config: RefreshPlayerIdentityRequestConfig): Promise<AxiosResponse<T>>;
}

declare const _default$3: Omit<{
    requirements: string[];
    type: "auth" | "local" | "pd" | "glz" | "shared";
    name: string;
    method: "PUT" | "GET" | "DELETE" | "POST";
    url: string;
    description?: string | undefined;
    headers?: Record<string, string> | undefined;
    body?: zod.ZodType<any, zod.ZodTypeDef, any> | undefined;
    query?: zod.ZodType<any, zod.ZodTypeDef, any> | undefined;
    responses?: Record<string, zod.ZodType<any, zod.ZodTypeDef, any>> | undefined;
}, "type" | "name" | "url"> & Pick<{
    readonly name: "Select Character";
    readonly description: string;
    readonly type: "glz";
    readonly method: "POST";
    readonly url: "pregame/v1/matches/:pregameMatchId/select/:agentId";
    readonly responses: {
        readonly "200": zod.ZodObject<{
            ID: zod.ZodString;
            Version: zod.ZodNumber;
            Teams: zod.ZodArray<zod.ZodObject<{
                TeamID: zod.ZodUnion<[zod.ZodEnum<["Blue", "Red"]>, zod.ZodString]>;
                Players: zod.ZodArray<zod.ZodObject<{
                    Subject: zod.ZodString;
                    CharacterID: zod.ZodString;
                    CharacterSelectionState: zod.ZodEnum<["", "selected", "locked"]>;
                    PregamePlayerState: zod.ZodEnum<["joined"]>;
                    CompetitiveTier: zod.ZodNumber;
                    PlayerIdentity: zod.ZodObject<{
                        Subject: zod.ZodString;
                        PlayerCardID: zod.ZodString;
                        PlayerTitleID: zod.ZodString;
                        AccountLevel: zod.ZodNumber;
                        PreferredLevelBorderID: zod.ZodUnion<[zod.ZodString, zod.ZodLiteral<"">]>;
                        Incognito: zod.ZodBoolean;
                        HideAccountLevel: zod.ZodBoolean;
                    }, "strip", zod.ZodTypeAny, {
                        Subject: string;
                        PlayerCardID: string;
                        PlayerTitleID: string;
                        AccountLevel: number;
                        PreferredLevelBorderID: string;
                        Incognito: boolean;
                        HideAccountLevel: boolean;
                    }, {
                        Subject: string;
                        PlayerCardID: string;
                        PlayerTitleID: string;
                        AccountLevel: number;
                        PreferredLevelBorderID: string;
                        Incognito: boolean;
                        HideAccountLevel: boolean;
                    }>;
                    SeasonalBadgeInfo: zod.ZodObject<{
                        SeasonID: zod.ZodUnion<[zod.ZodString, zod.ZodLiteral<"">]>;
                        NumberOfWins: zod.ZodNumber;
                        WinsByTier: zod.ZodNull;
                        Rank: zod.ZodNumber;
                        LeaderboardRank: zod.ZodNumber;
                    }, "strip", zod.ZodTypeAny, {
                        SeasonID: string;
                        NumberOfWins: number;
                        WinsByTier: null;
                        Rank: number;
                        LeaderboardRank: number;
                    }, {
                        SeasonID: string;
                        NumberOfWins: number;
                        WinsByTier: null;
                        Rank: number;
                        LeaderboardRank: number;
                    }>;
                    IsCaptain: zod.ZodBoolean;
                }, "strip", zod.ZodTypeAny, {
                    CharacterID: string;
                    Subject: string;
                    PlayerIdentity: {
                        Subject: string;
                        PlayerCardID: string;
                        PlayerTitleID: string;
                        AccountLevel: number;
                        PreferredLevelBorderID: string;
                        Incognito: boolean;
                        HideAccountLevel: boolean;
                    };
                    SeasonalBadgeInfo: {
                        SeasonID: string;
                        NumberOfWins: number;
                        WinsByTier: null;
                        Rank: number;
                        LeaderboardRank: number;
                    };
                    CompetitiveTier: number;
                    CharacterSelectionState: "" | "selected" | "locked";
                    PregamePlayerState: "joined";
                    IsCaptain: boolean;
                }, {
                    CharacterID: string;
                    Subject: string;
                    PlayerIdentity: {
                        Subject: string;
                        PlayerCardID: string;
                        PlayerTitleID: string;
                        AccountLevel: number;
                        PreferredLevelBorderID: string;
                        Incognito: boolean;
                        HideAccountLevel: boolean;
                    };
                    SeasonalBadgeInfo: {
                        SeasonID: string;
                        NumberOfWins: number;
                        WinsByTier: null;
                        Rank: number;
                        LeaderboardRank: number;
                    };
                    CompetitiveTier: number;
                    CharacterSelectionState: "" | "selected" | "locked";
                    PregamePlayerState: "joined";
                    IsCaptain: boolean;
                }>, "many">;
            }, "strip", zod.ZodTypeAny, {
                Players: {
                    CharacterID: string;
                    Subject: string;
                    PlayerIdentity: {
                        Subject: string;
                        PlayerCardID: string;
                        PlayerTitleID: string;
                        AccountLevel: number;
                        PreferredLevelBorderID: string;
                        Incognito: boolean;
                        HideAccountLevel: boolean;
                    };
                    SeasonalBadgeInfo: {
                        SeasonID: string;
                        NumberOfWins: number;
                        WinsByTier: null;
                        Rank: number;
                        LeaderboardRank: number;
                    };
                    CompetitiveTier: number;
                    CharacterSelectionState: "" | "selected" | "locked";
                    PregamePlayerState: "joined";
                    IsCaptain: boolean;
                }[];
                TeamID: string;
            }, {
                Players: {
                    CharacterID: string;
                    Subject: string;
                    PlayerIdentity: {
                        Subject: string;
                        PlayerCardID: string;
                        PlayerTitleID: string;
                        AccountLevel: number;
                        PreferredLevelBorderID: string;
                        Incognito: boolean;
                        HideAccountLevel: boolean;
                    };
                    SeasonalBadgeInfo: {
                        SeasonID: string;
                        NumberOfWins: number;
                        WinsByTier: null;
                        Rank: number;
                        LeaderboardRank: number;
                    };
                    CompetitiveTier: number;
                    CharacterSelectionState: "" | "selected" | "locked";
                    PregamePlayerState: "joined";
                    IsCaptain: boolean;
                }[];
                TeamID: string;
            }>, "many">;
            AllyTeam: zod.ZodNullable<zod.ZodObject<{
                TeamID: zod.ZodUnion<[zod.ZodEnum<["Blue", "Red"]>, zod.ZodString]>;
                Players: zod.ZodArray<zod.ZodObject<{
                    Subject: zod.ZodString;
                    CharacterID: zod.ZodString;
                    CharacterSelectionState: zod.ZodEnum<["", "selected", "locked"]>;
                    PregamePlayerState: zod.ZodEnum<["joined"]>;
                    CompetitiveTier: zod.ZodNumber;
                    PlayerIdentity: zod.ZodObject<{
                        Subject: zod.ZodString;
                        PlayerCardID: zod.ZodString;
                        PlayerTitleID: zod.ZodString;
                        AccountLevel: zod.ZodNumber;
                        PreferredLevelBorderID: zod.ZodUnion<[zod.ZodString, zod.ZodLiteral<"">]>;
                        Incognito: zod.ZodBoolean;
                        HideAccountLevel: zod.ZodBoolean;
                    }, "strip", zod.ZodTypeAny, {
                        Subject: string;
                        PlayerCardID: string;
                        PlayerTitleID: string;
                        AccountLevel: number;
                        PreferredLevelBorderID: string;
                        Incognito: boolean;
                        HideAccountLevel: boolean;
                    }, {
                        Subject: string;
                        PlayerCardID: string;
                        PlayerTitleID: string;
                        AccountLevel: number;
                        PreferredLevelBorderID: string;
                        Incognito: boolean;
                        HideAccountLevel: boolean;
                    }>;
                    SeasonalBadgeInfo: zod.ZodObject<{
                        SeasonID: zod.ZodUnion<[zod.ZodString, zod.ZodLiteral<"">]>;
                        NumberOfWins: zod.ZodNumber;
                        WinsByTier: zod.ZodNull;
                        Rank: zod.ZodNumber;
                        LeaderboardRank: zod.ZodNumber;
                    }, "strip", zod.ZodTypeAny, {
                        SeasonID: string;
                        NumberOfWins: number;
                        WinsByTier: null;
                        Rank: number;
                        LeaderboardRank: number;
                    }, {
                        SeasonID: string;
                        NumberOfWins: number;
                        WinsByTier: null;
                        Rank: number;
                        LeaderboardRank: number;
                    }>;
                    IsCaptain: zod.ZodBoolean;
                }, "strip", zod.ZodTypeAny, {
                    CharacterID: string;
                    Subject: string;
                    PlayerIdentity: {
                        Subject: string;
                        PlayerCardID: string;
                        PlayerTitleID: string;
                        AccountLevel: number;
                        PreferredLevelBorderID: string;
                        Incognito: boolean;
                        HideAccountLevel: boolean;
                    };
                    SeasonalBadgeInfo: {
                        SeasonID: string;
                        NumberOfWins: number;
                        WinsByTier: null;
                        Rank: number;
                        LeaderboardRank: number;
                    };
                    CompetitiveTier: number;
                    CharacterSelectionState: "" | "selected" | "locked";
                    PregamePlayerState: "joined";
                    IsCaptain: boolean;
                }, {
                    CharacterID: string;
                    Subject: string;
                    PlayerIdentity: {
                        Subject: string;
                        PlayerCardID: string;
                        PlayerTitleID: string;
                        AccountLevel: number;
                        PreferredLevelBorderID: string;
                        Incognito: boolean;
                        HideAccountLevel: boolean;
                    };
                    SeasonalBadgeInfo: {
                        SeasonID: string;
                        NumberOfWins: number;
                        WinsByTier: null;
                        Rank: number;
                        LeaderboardRank: number;
                    };
                    CompetitiveTier: number;
                    CharacterSelectionState: "" | "selected" | "locked";
                    PregamePlayerState: "joined";
                    IsCaptain: boolean;
                }>, "many">;
            }, "strip", zod.ZodTypeAny, {
                Players: {
                    CharacterID: string;
                    Subject: string;
                    PlayerIdentity: {
                        Subject: string;
                        PlayerCardID: string;
                        PlayerTitleID: string;
                        AccountLevel: number;
                        PreferredLevelBorderID: string;
                        Incognito: boolean;
                        HideAccountLevel: boolean;
                    };
                    SeasonalBadgeInfo: {
                        SeasonID: string;
                        NumberOfWins: number;
                        WinsByTier: null;
                        Rank: number;
                        LeaderboardRank: number;
                    };
                    CompetitiveTier: number;
                    CharacterSelectionState: "" | "selected" | "locked";
                    PregamePlayerState: "joined";
                    IsCaptain: boolean;
                }[];
                TeamID: string;
            }, {
                Players: {
                    CharacterID: string;
                    Subject: string;
                    PlayerIdentity: {
                        Subject: string;
                        PlayerCardID: string;
                        PlayerTitleID: string;
                        AccountLevel: number;
                        PreferredLevelBorderID: string;
                        Incognito: boolean;
                        HideAccountLevel: boolean;
                    };
                    SeasonalBadgeInfo: {
                        SeasonID: string;
                        NumberOfWins: number;
                        WinsByTier: null;
                        Rank: number;
                        LeaderboardRank: number;
                    };
                    CompetitiveTier: number;
                    CharacterSelectionState: "" | "selected" | "locked";
                    PregamePlayerState: "joined";
                    IsCaptain: boolean;
                }[];
                TeamID: string;
            }>>;
            EnemyTeam: zod.ZodNullable<zod.ZodObject<{
                TeamID: zod.ZodUnion<[zod.ZodEnum<["Blue", "Red"]>, zod.ZodString]>;
                Players: zod.ZodArray<zod.ZodObject<{
                    Subject: zod.ZodString;
                    CharacterID: zod.ZodString;
                    CharacterSelectionState: zod.ZodEnum<["", "selected", "locked"]>;
                    PregamePlayerState: zod.ZodEnum<["joined"]>;
                    CompetitiveTier: zod.ZodNumber;
                    PlayerIdentity: zod.ZodObject<{
                        Subject: zod.ZodString;
                        PlayerCardID: zod.ZodString;
                        PlayerTitleID: zod.ZodString;
                        AccountLevel: zod.ZodNumber;
                        PreferredLevelBorderID: zod.ZodUnion<[zod.ZodString, zod.ZodLiteral<"">]>;
                        Incognito: zod.ZodBoolean;
                        HideAccountLevel: zod.ZodBoolean;
                    }, "strip", zod.ZodTypeAny, {
                        Subject: string;
                        PlayerCardID: string;
                        PlayerTitleID: string;
                        AccountLevel: number;
                        PreferredLevelBorderID: string;
                        Incognito: boolean;
                        HideAccountLevel: boolean;
                    }, {
                        Subject: string;
                        PlayerCardID: string;
                        PlayerTitleID: string;
                        AccountLevel: number;
                        PreferredLevelBorderID: string;
                        Incognito: boolean;
                        HideAccountLevel: boolean;
                    }>;
                    SeasonalBadgeInfo: zod.ZodObject<{
                        SeasonID: zod.ZodUnion<[zod.ZodString, zod.ZodLiteral<"">]>;
                        NumberOfWins: zod.ZodNumber;
                        WinsByTier: zod.ZodNull;
                        Rank: zod.ZodNumber;
                        LeaderboardRank: zod.ZodNumber;
                    }, "strip", zod.ZodTypeAny, {
                        SeasonID: string;
                        NumberOfWins: number;
                        WinsByTier: null;
                        Rank: number;
                        LeaderboardRank: number;
                    }, {
                        SeasonID: string;
                        NumberOfWins: number;
                        WinsByTier: null;
                        Rank: number;
                        LeaderboardRank: number;
                    }>;
                    IsCaptain: zod.ZodBoolean;
                }, "strip", zod.ZodTypeAny, {
                    CharacterID: string;
                    Subject: string;
                    PlayerIdentity: {
                        Subject: string;
                        PlayerCardID: string;
                        PlayerTitleID: string;
                        AccountLevel: number;
                        PreferredLevelBorderID: string;
                        Incognito: boolean;
                        HideAccountLevel: boolean;
                    };
                    SeasonalBadgeInfo: {
                        SeasonID: string;
                        NumberOfWins: number;
                        WinsByTier: null;
                        Rank: number;
                        LeaderboardRank: number;
                    };
                    CompetitiveTier: number;
                    CharacterSelectionState: "" | "selected" | "locked";
                    PregamePlayerState: "joined";
                    IsCaptain: boolean;
                }, {
                    CharacterID: string;
                    Subject: string;
                    PlayerIdentity: {
                        Subject: string;
                        PlayerCardID: string;
                        PlayerTitleID: string;
                        AccountLevel: number;
                        PreferredLevelBorderID: string;
                        Incognito: boolean;
                        HideAccountLevel: boolean;
                    };
                    SeasonalBadgeInfo: {
                        SeasonID: string;
                        NumberOfWins: number;
                        WinsByTier: null;
                        Rank: number;
                        LeaderboardRank: number;
                    };
                    CompetitiveTier: number;
                    CharacterSelectionState: "" | "selected" | "locked";
                    PregamePlayerState: "joined";
                    IsCaptain: boolean;
                }>, "many">;
            }, "strip", zod.ZodTypeAny, {
                Players: {
                    CharacterID: string;
                    Subject: string;
                    PlayerIdentity: {
                        Subject: string;
                        PlayerCardID: string;
                        PlayerTitleID: string;
                        AccountLevel: number;
                        PreferredLevelBorderID: string;
                        Incognito: boolean;
                        HideAccountLevel: boolean;
                    };
                    SeasonalBadgeInfo: {
                        SeasonID: string;
                        NumberOfWins: number;
                        WinsByTier: null;
                        Rank: number;
                        LeaderboardRank: number;
                    };
                    CompetitiveTier: number;
                    CharacterSelectionState: "" | "selected" | "locked";
                    PregamePlayerState: "joined";
                    IsCaptain: boolean;
                }[];
                TeamID: string;
            }, {
                Players: {
                    CharacterID: string;
                    Subject: string;
                    PlayerIdentity: {
                        Subject: string;
                        PlayerCardID: string;
                        PlayerTitleID: string;
                        AccountLevel: number;
                        PreferredLevelBorderID: string;
                        Incognito: boolean;
                        HideAccountLevel: boolean;
                    };
                    SeasonalBadgeInfo: {
                        SeasonID: string;
                        NumberOfWins: number;
                        WinsByTier: null;
                        Rank: number;
                        LeaderboardRank: number;
                    };
                    CompetitiveTier: number;
                    CharacterSelectionState: "" | "selected" | "locked";
                    PregamePlayerState: "joined";
                    IsCaptain: boolean;
                }[];
                TeamID: string;
            }>>;
            ObserverSubjects: zod.ZodArray<zod.ZodUnknown, "many">;
            MatchCoaches: zod.ZodArray<zod.ZodUnknown, "many">;
            EnemyTeamSize: zod.ZodNumber;
            EnemyTeamLockCount: zod.ZodNumber;
            PregameState: zod.ZodEnum<["character_select_active", "provisioned"]>;
            LastUpdated: zod.ZodEffects<zod.ZodString, Date, string>;
            MapID: zod.ZodString;
            MapSelectPool: zod.ZodArray<zod.ZodUnknown, "many">;
            BannedMapIDs: zod.ZodArray<zod.ZodUnknown, "many">;
            CastedVotes: zod.ZodUnknown;
            MapSelectSteps: zod.ZodArray<zod.ZodUnknown, "many">;
            MapSelectStep: zod.ZodNumber;
            Team1: zod.ZodUnion<[zod.ZodEnum<["Blue", "Red"]>, zod.ZodString]>;
            GamePodID: zod.ZodString;
            Mode: zod.ZodString;
            VoiceSessionID: zod.ZodString;
            MUCName: zod.ZodString;
            TeamMatchToken: zod.ZodString;
            QueueID: zod.ZodUnion<[zod.ZodString, zod.ZodLiteral<"">]>;
            ProvisioningFlowID: zod.ZodEnum<["Matchmaking", "CustomGame"]>;
            IsRanked: zod.ZodBoolean;
            PhaseTimeRemainingNS: zod.ZodNumber;
            StepTimeRemainingNS: zod.ZodNumber;
            altModesFlagADA: zod.ZodBoolean;
            TournamentMetadata: zod.ZodNull;
            RosterMetadata: zod.ZodNull;
        }, "strip", zod.ZodTypeAny, {
            ID: string;
            Version: number;
            QueueID: string;
            Mode: string;
            IsRanked: boolean;
            MapID: string;
            GamePodID: string;
            TeamMatchToken: string;
            MUCName: string;
            Teams: {
                Players: {
                    CharacterID: string;
                    Subject: string;
                    PlayerIdentity: {
                        Subject: string;
                        PlayerCardID: string;
                        PlayerTitleID: string;
                        AccountLevel: number;
                        PreferredLevelBorderID: string;
                        Incognito: boolean;
                        HideAccountLevel: boolean;
                    };
                    SeasonalBadgeInfo: {
                        SeasonID: string;
                        NumberOfWins: number;
                        WinsByTier: null;
                        Rank: number;
                        LeaderboardRank: number;
                    };
                    CompetitiveTier: number;
                    CharacterSelectionState: "" | "selected" | "locked";
                    PregamePlayerState: "joined";
                    IsCaptain: boolean;
                }[];
                TeamID: string;
            }[];
            AllyTeam: {
                Players: {
                    CharacterID: string;
                    Subject: string;
                    PlayerIdentity: {
                        Subject: string;
                        PlayerCardID: string;
                        PlayerTitleID: string;
                        AccountLevel: number;
                        PreferredLevelBorderID: string;
                        Incognito: boolean;
                        HideAccountLevel: boolean;
                    };
                    SeasonalBadgeInfo: {
                        SeasonID: string;
                        NumberOfWins: number;
                        WinsByTier: null;
                        Rank: number;
                        LeaderboardRank: number;
                    };
                    CompetitiveTier: number;
                    CharacterSelectionState: "" | "selected" | "locked";
                    PregamePlayerState: "joined";
                    IsCaptain: boolean;
                }[];
                TeamID: string;
            } | null;
            EnemyTeam: {
                Players: {
                    CharacterID: string;
                    Subject: string;
                    PlayerIdentity: {
                        Subject: string;
                        PlayerCardID: string;
                        PlayerTitleID: string;
                        AccountLevel: number;
                        PreferredLevelBorderID: string;
                        Incognito: boolean;
                        HideAccountLevel: boolean;
                    };
                    SeasonalBadgeInfo: {
                        SeasonID: string;
                        NumberOfWins: number;
                        WinsByTier: null;
                        Rank: number;
                        LeaderboardRank: number;
                    };
                    CompetitiveTier: number;
                    CharacterSelectionState: "" | "selected" | "locked";
                    PregamePlayerState: "joined";
                    IsCaptain: boolean;
                }[];
                TeamID: string;
            } | null;
            ObserverSubjects: unknown[];
            MatchCoaches: unknown[];
            EnemyTeamSize: number;
            EnemyTeamLockCount: number;
            PregameState: "character_select_active" | "provisioned";
            LastUpdated: Date;
            MapSelectPool: unknown[];
            BannedMapIDs: unknown[];
            MapSelectSteps: unknown[];
            MapSelectStep: number;
            Team1: string;
            VoiceSessionID: string;
            ProvisioningFlowID: "Matchmaking" | "CustomGame";
            PhaseTimeRemainingNS: number;
            StepTimeRemainingNS: number;
            altModesFlagADA: boolean;
            TournamentMetadata: null;
            RosterMetadata: null;
            CastedVotes?: unknown;
        }, {
            ID: string;
            Version: number;
            QueueID: string;
            Mode: string;
            IsRanked: boolean;
            MapID: string;
            GamePodID: string;
            TeamMatchToken: string;
            MUCName: string;
            Teams: {
                Players: {
                    CharacterID: string;
                    Subject: string;
                    PlayerIdentity: {
                        Subject: string;
                        PlayerCardID: string;
                        PlayerTitleID: string;
                        AccountLevel: number;
                        PreferredLevelBorderID: string;
                        Incognito: boolean;
                        HideAccountLevel: boolean;
                    };
                    SeasonalBadgeInfo: {
                        SeasonID: string;
                        NumberOfWins: number;
                        WinsByTier: null;
                        Rank: number;
                        LeaderboardRank: number;
                    };
                    CompetitiveTier: number;
                    CharacterSelectionState: "" | "selected" | "locked";
                    PregamePlayerState: "joined";
                    IsCaptain: boolean;
                }[];
                TeamID: string;
            }[];
            AllyTeam: {
                Players: {
                    CharacterID: string;
                    Subject: string;
                    PlayerIdentity: {
                        Subject: string;
                        PlayerCardID: string;
                        PlayerTitleID: string;
                        AccountLevel: number;
                        PreferredLevelBorderID: string;
                        Incognito: boolean;
                        HideAccountLevel: boolean;
                    };
                    SeasonalBadgeInfo: {
                        SeasonID: string;
                        NumberOfWins: number;
                        WinsByTier: null;
                        Rank: number;
                        LeaderboardRank: number;
                    };
                    CompetitiveTier: number;
                    CharacterSelectionState: "" | "selected" | "locked";
                    PregamePlayerState: "joined";
                    IsCaptain: boolean;
                }[];
                TeamID: string;
            } | null;
            EnemyTeam: {
                Players: {
                    CharacterID: string;
                    Subject: string;
                    PlayerIdentity: {
                        Subject: string;
                        PlayerCardID: string;
                        PlayerTitleID: string;
                        AccountLevel: number;
                        PreferredLevelBorderID: string;
                        Incognito: boolean;
                        HideAccountLevel: boolean;
                    };
                    SeasonalBadgeInfo: {
                        SeasonID: string;
                        NumberOfWins: number;
                        WinsByTier: null;
                        Rank: number;
                        LeaderboardRank: number;
                    };
                    CompetitiveTier: number;
                    CharacterSelectionState: "" | "selected" | "locked";
                    PregamePlayerState: "joined";
                    IsCaptain: boolean;
                }[];
                TeamID: string;
            } | null;
            ObserverSubjects: unknown[];
            MatchCoaches: unknown[];
            EnemyTeamSize: number;
            EnemyTeamLockCount: number;
            PregameState: "character_select_active" | "provisioned";
            LastUpdated: string;
            MapSelectPool: unknown[];
            BannedMapIDs: unknown[];
            MapSelectSteps: unknown[];
            MapSelectStep: number;
            Team1: string;
            VoiceSessionID: string;
            ProvisioningFlowID: "Matchmaking" | "CustomGame";
            PhaseTimeRemainingNS: number;
            StepTimeRemainingNS: number;
            altModesFlagADA: boolean;
            TournamentMetadata: null;
            RosterMetadata: null;
            CastedVotes?: unknown;
        }>;
    };
}, "type" | "name" | "url"> & {
    "~type": {
        readonly name: "Select Character";
        readonly description: string;
        readonly type: "glz";
        readonly method: "POST";
        readonly url: "pregame/v1/matches/:pregameMatchId/select/:agentId";
        readonly responses: {
            readonly "200": zod.ZodObject<{
                ID: zod.ZodString;
                Version: zod.ZodNumber;
                Teams: zod.ZodArray<zod.ZodObject<{
                    TeamID: zod.ZodUnion<[zod.ZodEnum<["Blue", "Red"]>, zod.ZodString]>;
                    Players: zod.ZodArray<zod.ZodObject<{
                        Subject: zod.ZodString;
                        CharacterID: zod.ZodString;
                        CharacterSelectionState: zod.ZodEnum<["", "selected", "locked"]>;
                        PregamePlayerState: zod.ZodEnum<["joined"]>;
                        CompetitiveTier: zod.ZodNumber;
                        PlayerIdentity: zod.ZodObject<{
                            Subject: zod.ZodString;
                            PlayerCardID: zod.ZodString;
                            PlayerTitleID: zod.ZodString;
                            AccountLevel: zod.ZodNumber;
                            PreferredLevelBorderID: zod.ZodUnion<[zod.ZodString, zod.ZodLiteral<"">]>;
                            Incognito: zod.ZodBoolean;
                            HideAccountLevel: zod.ZodBoolean;
                        }, "strip", zod.ZodTypeAny, {
                            Subject: string;
                            PlayerCardID: string;
                            PlayerTitleID: string;
                            AccountLevel: number;
                            PreferredLevelBorderID: string;
                            Incognito: boolean;
                            HideAccountLevel: boolean;
                        }, {
                            Subject: string;
                            PlayerCardID: string;
                            PlayerTitleID: string;
                            AccountLevel: number;
                            PreferredLevelBorderID: string;
                            Incognito: boolean;
                            HideAccountLevel: boolean;
                        }>;
                        SeasonalBadgeInfo: zod.ZodObject<{
                            SeasonID: zod.ZodUnion<[zod.ZodString, zod.ZodLiteral<"">]>;
                            NumberOfWins: zod.ZodNumber;
                            WinsByTier: zod.ZodNull;
                            Rank: zod.ZodNumber;
                            LeaderboardRank: zod.ZodNumber;
                        }, "strip", zod.ZodTypeAny, {
                            SeasonID: string;
                            NumberOfWins: number;
                            WinsByTier: null;
                            Rank: number;
                            LeaderboardRank: number;
                        }, {
                            SeasonID: string;
                            NumberOfWins: number;
                            WinsByTier: null;
                            Rank: number;
                            LeaderboardRank: number;
                        }>;
                        IsCaptain: zod.ZodBoolean;
                    }, "strip", zod.ZodTypeAny, {
                        CharacterID: string;
                        Subject: string;
                        PlayerIdentity: {
                            Subject: string;
                            PlayerCardID: string;
                            PlayerTitleID: string;
                            AccountLevel: number;
                            PreferredLevelBorderID: string;
                            Incognito: boolean;
                            HideAccountLevel: boolean;
                        };
                        SeasonalBadgeInfo: {
                            SeasonID: string;
                            NumberOfWins: number;
                            WinsByTier: null;
                            Rank: number;
                            LeaderboardRank: number;
                        };
                        CompetitiveTier: number;
                        CharacterSelectionState: "" | "selected" | "locked";
                        PregamePlayerState: "joined";
                        IsCaptain: boolean;
                    }, {
                        CharacterID: string;
                        Subject: string;
                        PlayerIdentity: {
                            Subject: string;
                            PlayerCardID: string;
                            PlayerTitleID: string;
                            AccountLevel: number;
                            PreferredLevelBorderID: string;
                            Incognito: boolean;
                            HideAccountLevel: boolean;
                        };
                        SeasonalBadgeInfo: {
                            SeasonID: string;
                            NumberOfWins: number;
                            WinsByTier: null;
                            Rank: number;
                            LeaderboardRank: number;
                        };
                        CompetitiveTier: number;
                        CharacterSelectionState: "" | "selected" | "locked";
                        PregamePlayerState: "joined";
                        IsCaptain: boolean;
                    }>, "many">;
                }, "strip", zod.ZodTypeAny, {
                    Players: {
                        CharacterID: string;
                        Subject: string;
                        PlayerIdentity: {
                            Subject: string;
                            PlayerCardID: string;
                            PlayerTitleID: string;
                            AccountLevel: number;
                            PreferredLevelBorderID: string;
                            Incognito: boolean;
                            HideAccountLevel: boolean;
                        };
                        SeasonalBadgeInfo: {
                            SeasonID: string;
                            NumberOfWins: number;
                            WinsByTier: null;
                            Rank: number;
                            LeaderboardRank: number;
                        };
                        CompetitiveTier: number;
                        CharacterSelectionState: "" | "selected" | "locked";
                        PregamePlayerState: "joined";
                        IsCaptain: boolean;
                    }[];
                    TeamID: string;
                }, {
                    Players: {
                        CharacterID: string;
                        Subject: string;
                        PlayerIdentity: {
                            Subject: string;
                            PlayerCardID: string;
                            PlayerTitleID: string;
                            AccountLevel: number;
                            PreferredLevelBorderID: string;
                            Incognito: boolean;
                            HideAccountLevel: boolean;
                        };
                        SeasonalBadgeInfo: {
                            SeasonID: string;
                            NumberOfWins: number;
                            WinsByTier: null;
                            Rank: number;
                            LeaderboardRank: number;
                        };
                        CompetitiveTier: number;
                        CharacterSelectionState: "" | "selected" | "locked";
                        PregamePlayerState: "joined";
                        IsCaptain: boolean;
                    }[];
                    TeamID: string;
                }>, "many">;
                AllyTeam: zod.ZodNullable<zod.ZodObject<{
                    TeamID: zod.ZodUnion<[zod.ZodEnum<["Blue", "Red"]>, zod.ZodString]>;
                    Players: zod.ZodArray<zod.ZodObject<{
                        Subject: zod.ZodString;
                        CharacterID: zod.ZodString;
                        CharacterSelectionState: zod.ZodEnum<["", "selected", "locked"]>;
                        PregamePlayerState: zod.ZodEnum<["joined"]>;
                        CompetitiveTier: zod.ZodNumber;
                        PlayerIdentity: zod.ZodObject<{
                            Subject: zod.ZodString;
                            PlayerCardID: zod.ZodString;
                            PlayerTitleID: zod.ZodString;
                            AccountLevel: zod.ZodNumber;
                            PreferredLevelBorderID: zod.ZodUnion<[zod.ZodString, zod.ZodLiteral<"">]>;
                            Incognito: zod.ZodBoolean;
                            HideAccountLevel: zod.ZodBoolean;
                        }, "strip", zod.ZodTypeAny, {
                            Subject: string;
                            PlayerCardID: string;
                            PlayerTitleID: string;
                            AccountLevel: number;
                            PreferredLevelBorderID: string;
                            Incognito: boolean;
                            HideAccountLevel: boolean;
                        }, {
                            Subject: string;
                            PlayerCardID: string;
                            PlayerTitleID: string;
                            AccountLevel: number;
                            PreferredLevelBorderID: string;
                            Incognito: boolean;
                            HideAccountLevel: boolean;
                        }>;
                        SeasonalBadgeInfo: zod.ZodObject<{
                            SeasonID: zod.ZodUnion<[zod.ZodString, zod.ZodLiteral<"">]>;
                            NumberOfWins: zod.ZodNumber;
                            WinsByTier: zod.ZodNull;
                            Rank: zod.ZodNumber;
                            LeaderboardRank: zod.ZodNumber;
                        }, "strip", zod.ZodTypeAny, {
                            SeasonID: string;
                            NumberOfWins: number;
                            WinsByTier: null;
                            Rank: number;
                            LeaderboardRank: number;
                        }, {
                            SeasonID: string;
                            NumberOfWins: number;
                            WinsByTier: null;
                            Rank: number;
                            LeaderboardRank: number;
                        }>;
                        IsCaptain: zod.ZodBoolean;
                    }, "strip", zod.ZodTypeAny, {
                        CharacterID: string;
                        Subject: string;
                        PlayerIdentity: {
                            Subject: string;
                            PlayerCardID: string;
                            PlayerTitleID: string;
                            AccountLevel: number;
                            PreferredLevelBorderID: string;
                            Incognito: boolean;
                            HideAccountLevel: boolean;
                        };
                        SeasonalBadgeInfo: {
                            SeasonID: string;
                            NumberOfWins: number;
                            WinsByTier: null;
                            Rank: number;
                            LeaderboardRank: number;
                        };
                        CompetitiveTier: number;
                        CharacterSelectionState: "" | "selected" | "locked";
                        PregamePlayerState: "joined";
                        IsCaptain: boolean;
                    }, {
                        CharacterID: string;
                        Subject: string;
                        PlayerIdentity: {
                            Subject: string;
                            PlayerCardID: string;
                            PlayerTitleID: string;
                            AccountLevel: number;
                            PreferredLevelBorderID: string;
                            Incognito: boolean;
                            HideAccountLevel: boolean;
                        };
                        SeasonalBadgeInfo: {
                            SeasonID: string;
                            NumberOfWins: number;
                            WinsByTier: null;
                            Rank: number;
                            LeaderboardRank: number;
                        };
                        CompetitiveTier: number;
                        CharacterSelectionState: "" | "selected" | "locked";
                        PregamePlayerState: "joined";
                        IsCaptain: boolean;
                    }>, "many">;
                }, "strip", zod.ZodTypeAny, {
                    Players: {
                        CharacterID: string;
                        Subject: string;
                        PlayerIdentity: {
                            Subject: string;
                            PlayerCardID: string;
                            PlayerTitleID: string;
                            AccountLevel: number;
                            PreferredLevelBorderID: string;
                            Incognito: boolean;
                            HideAccountLevel: boolean;
                        };
                        SeasonalBadgeInfo: {
                            SeasonID: string;
                            NumberOfWins: number;
                            WinsByTier: null;
                            Rank: number;
                            LeaderboardRank: number;
                        };
                        CompetitiveTier: number;
                        CharacterSelectionState: "" | "selected" | "locked";
                        PregamePlayerState: "joined";
                        IsCaptain: boolean;
                    }[];
                    TeamID: string;
                }, {
                    Players: {
                        CharacterID: string;
                        Subject: string;
                        PlayerIdentity: {
                            Subject: string;
                            PlayerCardID: string;
                            PlayerTitleID: string;
                            AccountLevel: number;
                            PreferredLevelBorderID: string;
                            Incognito: boolean;
                            HideAccountLevel: boolean;
                        };
                        SeasonalBadgeInfo: {
                            SeasonID: string;
                            NumberOfWins: number;
                            WinsByTier: null;
                            Rank: number;
                            LeaderboardRank: number;
                        };
                        CompetitiveTier: number;
                        CharacterSelectionState: "" | "selected" | "locked";
                        PregamePlayerState: "joined";
                        IsCaptain: boolean;
                    }[];
                    TeamID: string;
                }>>;
                EnemyTeam: zod.ZodNullable<zod.ZodObject<{
                    TeamID: zod.ZodUnion<[zod.ZodEnum<["Blue", "Red"]>, zod.ZodString]>;
                    Players: zod.ZodArray<zod.ZodObject<{
                        Subject: zod.ZodString;
                        CharacterID: zod.ZodString;
                        CharacterSelectionState: zod.ZodEnum<["", "selected", "locked"]>;
                        PregamePlayerState: zod.ZodEnum<["joined"]>;
                        CompetitiveTier: zod.ZodNumber;
                        PlayerIdentity: zod.ZodObject<{
                            Subject: zod.ZodString;
                            PlayerCardID: zod.ZodString;
                            PlayerTitleID: zod.ZodString;
                            AccountLevel: zod.ZodNumber;
                            PreferredLevelBorderID: zod.ZodUnion<[zod.ZodString, zod.ZodLiteral<"">]>;
                            Incognito: zod.ZodBoolean;
                            HideAccountLevel: zod.ZodBoolean;
                        }, "strip", zod.ZodTypeAny, {
                            Subject: string;
                            PlayerCardID: string;
                            PlayerTitleID: string;
                            AccountLevel: number;
                            PreferredLevelBorderID: string;
                            Incognito: boolean;
                            HideAccountLevel: boolean;
                        }, {
                            Subject: string;
                            PlayerCardID: string;
                            PlayerTitleID: string;
                            AccountLevel: number;
                            PreferredLevelBorderID: string;
                            Incognito: boolean;
                            HideAccountLevel: boolean;
                        }>;
                        SeasonalBadgeInfo: zod.ZodObject<{
                            SeasonID: zod.ZodUnion<[zod.ZodString, zod.ZodLiteral<"">]>;
                            NumberOfWins: zod.ZodNumber;
                            WinsByTier: zod.ZodNull;
                            Rank: zod.ZodNumber;
                            LeaderboardRank: zod.ZodNumber;
                        }, "strip", zod.ZodTypeAny, {
                            SeasonID: string;
                            NumberOfWins: number;
                            WinsByTier: null;
                            Rank: number;
                            LeaderboardRank: number;
                        }, {
                            SeasonID: string;
                            NumberOfWins: number;
                            WinsByTier: null;
                            Rank: number;
                            LeaderboardRank: number;
                        }>;
                        IsCaptain: zod.ZodBoolean;
                    }, "strip", zod.ZodTypeAny, {
                        CharacterID: string;
                        Subject: string;
                        PlayerIdentity: {
                            Subject: string;
                            PlayerCardID: string;
                            PlayerTitleID: string;
                            AccountLevel: number;
                            PreferredLevelBorderID: string;
                            Incognito: boolean;
                            HideAccountLevel: boolean;
                        };
                        SeasonalBadgeInfo: {
                            SeasonID: string;
                            NumberOfWins: number;
                            WinsByTier: null;
                            Rank: number;
                            LeaderboardRank: number;
                        };
                        CompetitiveTier: number;
                        CharacterSelectionState: "" | "selected" | "locked";
                        PregamePlayerState: "joined";
                        IsCaptain: boolean;
                    }, {
                        CharacterID: string;
                        Subject: string;
                        PlayerIdentity: {
                            Subject: string;
                            PlayerCardID: string;
                            PlayerTitleID: string;
                            AccountLevel: number;
                            PreferredLevelBorderID: string;
                            Incognito: boolean;
                            HideAccountLevel: boolean;
                        };
                        SeasonalBadgeInfo: {
                            SeasonID: string;
                            NumberOfWins: number;
                            WinsByTier: null;
                            Rank: number;
                            LeaderboardRank: number;
                        };
                        CompetitiveTier: number;
                        CharacterSelectionState: "" | "selected" | "locked";
                        PregamePlayerState: "joined";
                        IsCaptain: boolean;
                    }>, "many">;
                }, "strip", zod.ZodTypeAny, {
                    Players: {
                        CharacterID: string;
                        Subject: string;
                        PlayerIdentity: {
                            Subject: string;
                            PlayerCardID: string;
                            PlayerTitleID: string;
                            AccountLevel: number;
                            PreferredLevelBorderID: string;
                            Incognito: boolean;
                            HideAccountLevel: boolean;
                        };
                        SeasonalBadgeInfo: {
                            SeasonID: string;
                            NumberOfWins: number;
                            WinsByTier: null;
                            Rank: number;
                            LeaderboardRank: number;
                        };
                        CompetitiveTier: number;
                        CharacterSelectionState: "" | "selected" | "locked";
                        PregamePlayerState: "joined";
                        IsCaptain: boolean;
                    }[];
                    TeamID: string;
                }, {
                    Players: {
                        CharacterID: string;
                        Subject: string;
                        PlayerIdentity: {
                            Subject: string;
                            PlayerCardID: string;
                            PlayerTitleID: string;
                            AccountLevel: number;
                            PreferredLevelBorderID: string;
                            Incognito: boolean;
                            HideAccountLevel: boolean;
                        };
                        SeasonalBadgeInfo: {
                            SeasonID: string;
                            NumberOfWins: number;
                            WinsByTier: null;
                            Rank: number;
                            LeaderboardRank: number;
                        };
                        CompetitiveTier: number;
                        CharacterSelectionState: "" | "selected" | "locked";
                        PregamePlayerState: "joined";
                        IsCaptain: boolean;
                    }[];
                    TeamID: string;
                }>>;
                ObserverSubjects: zod.ZodArray<zod.ZodUnknown, "many">;
                MatchCoaches: zod.ZodArray<zod.ZodUnknown, "many">;
                EnemyTeamSize: zod.ZodNumber;
                EnemyTeamLockCount: zod.ZodNumber;
                PregameState: zod.ZodEnum<["character_select_active", "provisioned"]>;
                LastUpdated: zod.ZodEffects<zod.ZodString, Date, string>;
                MapID: zod.ZodString;
                MapSelectPool: zod.ZodArray<zod.ZodUnknown, "many">;
                BannedMapIDs: zod.ZodArray<zod.ZodUnknown, "many">;
                CastedVotes: zod.ZodUnknown;
                MapSelectSteps: zod.ZodArray<zod.ZodUnknown, "many">;
                MapSelectStep: zod.ZodNumber;
                Team1: zod.ZodUnion<[zod.ZodEnum<["Blue", "Red"]>, zod.ZodString]>;
                GamePodID: zod.ZodString;
                Mode: zod.ZodString;
                VoiceSessionID: zod.ZodString;
                MUCName: zod.ZodString;
                TeamMatchToken: zod.ZodString;
                QueueID: zod.ZodUnion<[zod.ZodString, zod.ZodLiteral<"">]>;
                ProvisioningFlowID: zod.ZodEnum<["Matchmaking", "CustomGame"]>;
                IsRanked: zod.ZodBoolean;
                PhaseTimeRemainingNS: zod.ZodNumber;
                StepTimeRemainingNS: zod.ZodNumber;
                altModesFlagADA: zod.ZodBoolean;
                TournamentMetadata: zod.ZodNull;
                RosterMetadata: zod.ZodNull;
            }, "strip", zod.ZodTypeAny, {
                ID: string;
                Version: number;
                QueueID: string;
                Mode: string;
                IsRanked: boolean;
                MapID: string;
                GamePodID: string;
                TeamMatchToken: string;
                MUCName: string;
                Teams: {
                    Players: {
                        CharacterID: string;
                        Subject: string;
                        PlayerIdentity: {
                            Subject: string;
                            PlayerCardID: string;
                            PlayerTitleID: string;
                            AccountLevel: number;
                            PreferredLevelBorderID: string;
                            Incognito: boolean;
                            HideAccountLevel: boolean;
                        };
                        SeasonalBadgeInfo: {
                            SeasonID: string;
                            NumberOfWins: number;
                            WinsByTier: null;
                            Rank: number;
                            LeaderboardRank: number;
                        };
                        CompetitiveTier: number;
                        CharacterSelectionState: "" | "selected" | "locked";
                        PregamePlayerState: "joined";
                        IsCaptain: boolean;
                    }[];
                    TeamID: string;
                }[];
                AllyTeam: {
                    Players: {
                        CharacterID: string;
                        Subject: string;
                        PlayerIdentity: {
                            Subject: string;
                            PlayerCardID: string;
                            PlayerTitleID: string;
                            AccountLevel: number;
                            PreferredLevelBorderID: string;
                            Incognito: boolean;
                            HideAccountLevel: boolean;
                        };
                        SeasonalBadgeInfo: {
                            SeasonID: string;
                            NumberOfWins: number;
                            WinsByTier: null;
                            Rank: number;
                            LeaderboardRank: number;
                        };
                        CompetitiveTier: number;
                        CharacterSelectionState: "" | "selected" | "locked";
                        PregamePlayerState: "joined";
                        IsCaptain: boolean;
                    }[];
                    TeamID: string;
                } | null;
                EnemyTeam: {
                    Players: {
                        CharacterID: string;
                        Subject: string;
                        PlayerIdentity: {
                            Subject: string;
                            PlayerCardID: string;
                            PlayerTitleID: string;
                            AccountLevel: number;
                            PreferredLevelBorderID: string;
                            Incognito: boolean;
                            HideAccountLevel: boolean;
                        };
                        SeasonalBadgeInfo: {
                            SeasonID: string;
                            NumberOfWins: number;
                            WinsByTier: null;
                            Rank: number;
                            LeaderboardRank: number;
                        };
                        CompetitiveTier: number;
                        CharacterSelectionState: "" | "selected" | "locked";
                        PregamePlayerState: "joined";
                        IsCaptain: boolean;
                    }[];
                    TeamID: string;
                } | null;
                ObserverSubjects: unknown[];
                MatchCoaches: unknown[];
                EnemyTeamSize: number;
                EnemyTeamLockCount: number;
                PregameState: "character_select_active" | "provisioned";
                LastUpdated: Date;
                MapSelectPool: unknown[];
                BannedMapIDs: unknown[];
                MapSelectSteps: unknown[];
                MapSelectStep: number;
                Team1: string;
                VoiceSessionID: string;
                ProvisioningFlowID: "Matchmaking" | "CustomGame";
                PhaseTimeRemainingNS: number;
                StepTimeRemainingNS: number;
                altModesFlagADA: boolean;
                TournamentMetadata: null;
                RosterMetadata: null;
                CastedVotes?: unknown;
            }, {
                ID: string;
                Version: number;
                QueueID: string;
                Mode: string;
                IsRanked: boolean;
                MapID: string;
                GamePodID: string;
                TeamMatchToken: string;
                MUCName: string;
                Teams: {
                    Players: {
                        CharacterID: string;
                        Subject: string;
                        PlayerIdentity: {
                            Subject: string;
                            PlayerCardID: string;
                            PlayerTitleID: string;
                            AccountLevel: number;
                            PreferredLevelBorderID: string;
                            Incognito: boolean;
                            HideAccountLevel: boolean;
                        };
                        SeasonalBadgeInfo: {
                            SeasonID: string;
                            NumberOfWins: number;
                            WinsByTier: null;
                            Rank: number;
                            LeaderboardRank: number;
                        };
                        CompetitiveTier: number;
                        CharacterSelectionState: "" | "selected" | "locked";
                        PregamePlayerState: "joined";
                        IsCaptain: boolean;
                    }[];
                    TeamID: string;
                }[];
                AllyTeam: {
                    Players: {
                        CharacterID: string;
                        Subject: string;
                        PlayerIdentity: {
                            Subject: string;
                            PlayerCardID: string;
                            PlayerTitleID: string;
                            AccountLevel: number;
                            PreferredLevelBorderID: string;
                            Incognito: boolean;
                            HideAccountLevel: boolean;
                        };
                        SeasonalBadgeInfo: {
                            SeasonID: string;
                            NumberOfWins: number;
                            WinsByTier: null;
                            Rank: number;
                            LeaderboardRank: number;
                        };
                        CompetitiveTier: number;
                        CharacterSelectionState: "" | "selected" | "locked";
                        PregamePlayerState: "joined";
                        IsCaptain: boolean;
                    }[];
                    TeamID: string;
                } | null;
                EnemyTeam: {
                    Players: {
                        CharacterID: string;
                        Subject: string;
                        PlayerIdentity: {
                            Subject: string;
                            PlayerCardID: string;
                            PlayerTitleID: string;
                            AccountLevel: number;
                            PreferredLevelBorderID: string;
                            Incognito: boolean;
                            HideAccountLevel: boolean;
                        };
                        SeasonalBadgeInfo: {
                            SeasonID: string;
                            NumberOfWins: number;
                            WinsByTier: null;
                            Rank: number;
                            LeaderboardRank: number;
                        };
                        CompetitiveTier: number;
                        CharacterSelectionState: "" | "selected" | "locked";
                        PregamePlayerState: "joined";
                        IsCaptain: boolean;
                    }[];
                    TeamID: string;
                } | null;
                ObserverSubjects: unknown[];
                MatchCoaches: unknown[];
                EnemyTeamSize: number;
                EnemyTeamLockCount: number;
                PregameState: "character_select_active" | "provisioned";
                LastUpdated: string;
                MapSelectPool: unknown[];
                BannedMapIDs: unknown[];
                MapSelectSteps: unknown[];
                MapSelectStep: number;
                Team1: string;
                VoiceSessionID: string;
                ProvisioningFlowID: "Matchmaking" | "CustomGame";
                PhaseTimeRemainingNS: number;
                StepTimeRemainingNS: number;
                altModesFlagADA: boolean;
                TournamentMetadata: null;
                RosterMetadata: null;
                CastedVotes?: unknown;
            }>;
        };
    };
};

type Params$3 = ResolveParams<(typeof _default$3)["~type"]["url"]>;
type Body$3 = z.infer<ResolveValue<(typeof _default$3)["~type"], "body">>;
type Data$3 = ResolveData<Params$3, Body$3>;
type Response$3 = z.infer<ResolveValue<(typeof _default$3)["~type"], "responses">["200"]>;
interface SelectCharacterRequestConfig extends ValorantAxiosRequestConfig<Data$3> {
}
declare class SelectCharacterEndpoint {
    /**
     * Select in an agent
     * DO NOT USE THIS FOR INSTALOCKING
     * Riot doesn't like this. You may get banned or get the API restricted for the rest of us
     *
     * @EndpointType glz
     */
    postSelectCharacter<T = Response$3>(this: RemoteApiClient, config: SelectCharacterRequestConfig): Promise<AxiosResponse<T>>;
}

declare const _default$2: Omit<{
    requirements: string[];
    type: "auth" | "local" | "pd" | "glz" | "shared";
    name: string;
    method: "PUT" | "GET" | "DELETE" | "POST";
    url: string;
    description?: string | undefined;
    headers?: Record<string, string> | undefined;
    body?: z.ZodType<any, z.ZodTypeDef, any> | undefined;
    query?: z.ZodType<any, z.ZodTypeDef, any> | undefined;
    responses?: Record<string, z.ZodType<any, z.ZodTypeDef, any>> | undefined;
}, "type" | "name" | "url"> & Pick<{
    readonly name: "Set Custom Game Settings";
    readonly description: "Changes the settings for a custom game";
    readonly type: "glz";
    readonly method: "POST";
    readonly url: "parties/v1/parties/:partyId/customgamesettings";
    readonly body: z.ZodObject<{
        Map: z.ZodString;
        Mode: z.ZodString;
        UseBots: z.ZodBoolean;
        GamePod: z.ZodString;
        GameRules: z.ZodObject<{
            AllowGameModifiers: z.ZodEnum<["true", "false"]>;
            PlayOutAllRounds: z.ZodEnum<["true", "false"]>;
            SkipMatchHistory: z.ZodEnum<["true", "false"]>;
            TournamentMode: z.ZodEnum<["true", "false"]>;
            IsOvertimeWinByTwo: z.ZodEnum<["true", "false"]>;
        }, "strip", z.ZodTypeAny, {
            AllowGameModifiers: "true" | "false";
            IsOvertimeWinByTwo: "true" | "false";
            PlayOutAllRounds: "true" | "false";
            SkipMatchHistory: "true" | "false";
            TournamentMode: "true" | "false";
        }, {
            AllowGameModifiers: "true" | "false";
            IsOvertimeWinByTwo: "true" | "false";
            PlayOutAllRounds: "true" | "false";
            SkipMatchHistory: "true" | "false";
            TournamentMode: "true" | "false";
        }>;
    }, "strip", z.ZodTypeAny, {
        Mode: string;
        GameRules: {
            AllowGameModifiers: "true" | "false";
            IsOvertimeWinByTwo: "true" | "false";
            PlayOutAllRounds: "true" | "false";
            SkipMatchHistory: "true" | "false";
            TournamentMode: "true" | "false";
        };
        Map: string;
        UseBots: boolean;
        GamePod: string;
    }, {
        Mode: string;
        GameRules: {
            AllowGameModifiers: "true" | "false";
            IsOvertimeWinByTwo: "true" | "false";
            PlayOutAllRounds: "true" | "false";
            SkipMatchHistory: "true" | "false";
            TournamentMode: "true" | "false";
        };
        Map: string;
        UseBots: boolean;
        GamePod: string;
    }>;
    readonly responses: {
        readonly "200": z.ZodObject<{
            ID: z.ZodString;
            MUCName: z.ZodString;
            VoiceRoomID: z.ZodString;
            Version: z.ZodNumber;
            ClientVersion: z.ZodString;
            Members: z.ZodArray<z.ZodObject<{
                Subject: z.ZodString;
                CompetitiveTier: z.ZodNumber;
                PlayerIdentity: z.ZodObject<{
                    Subject: z.ZodString;
                    PlayerCardID: z.ZodString;
                    PlayerTitleID: z.ZodString;
                    AccountLevel: z.ZodNumber;
                    PreferredLevelBorderID: z.ZodUnion<[z.ZodString, z.ZodLiteral<"">]>;
                    Incognito: z.ZodBoolean;
                    HideAccountLevel: z.ZodBoolean;
                }, "strip", z.ZodTypeAny, {
                    Subject: string;
                    PlayerCardID: string;
                    PlayerTitleID: string;
                    AccountLevel: number;
                    PreferredLevelBorderID: string;
                    Incognito: boolean;
                    HideAccountLevel: boolean;
                }, {
                    Subject: string;
                    PlayerCardID: string;
                    PlayerTitleID: string;
                    AccountLevel: number;
                    PreferredLevelBorderID: string;
                    Incognito: boolean;
                    HideAccountLevel: boolean;
                }>;
                SeasonalBadgeInfo: z.ZodNull;
                IsOwner: z.ZodOptional<z.ZodBoolean>;
                QueueEligibleRemainingAccountLevels: z.ZodNumber;
                Pings: z.ZodArray<z.ZodObject<{
                    Ping: z.ZodNumber;
                    GamePodID: z.ZodString;
                }, "strip", z.ZodTypeAny, {
                    GamePodID: string;
                    Ping: number;
                }, {
                    GamePodID: string;
                    Ping: number;
                }>, "many">;
                IsReady: z.ZodBoolean;
                IsModerator: z.ZodBoolean;
                UseBroadcastHUD: z.ZodBoolean;
                PlatformType: z.ZodLiteral<"PC">;
            }, "strip", z.ZodTypeAny, {
                Subject: string;
                PlayerIdentity: {
                    Subject: string;
                    PlayerCardID: string;
                    PlayerTitleID: string;
                    AccountLevel: number;
                    PreferredLevelBorderID: string;
                    Incognito: boolean;
                    HideAccountLevel: boolean;
                };
                SeasonalBadgeInfo: null;
                CompetitiveTier: number;
                QueueEligibleRemainingAccountLevels: number;
                Pings: {
                    GamePodID: string;
                    Ping: number;
                }[];
                IsReady: boolean;
                IsModerator: boolean;
                UseBroadcastHUD: boolean;
                PlatformType: "PC";
                IsOwner?: boolean | undefined;
            }, {
                Subject: string;
                PlayerIdentity: {
                    Subject: string;
                    PlayerCardID: string;
                    PlayerTitleID: string;
                    AccountLevel: number;
                    PreferredLevelBorderID: string;
                    Incognito: boolean;
                    HideAccountLevel: boolean;
                };
                SeasonalBadgeInfo: null;
                CompetitiveTier: number;
                QueueEligibleRemainingAccountLevels: number;
                Pings: {
                    GamePodID: string;
                    Ping: number;
                }[];
                IsReady: boolean;
                IsModerator: boolean;
                UseBroadcastHUD: boolean;
                PlatformType: "PC";
                IsOwner?: boolean | undefined;
            }>, "many">;
            State: z.ZodString;
            PreviousState: z.ZodString;
            StateTransitionReason: z.ZodString;
            Accessibility: z.ZodUnion<[z.ZodLiteral<"OPEN">, z.ZodLiteral<"CLOSED">]>;
            CustomGameData: z.ZodObject<{
                Settings: z.ZodObject<{
                    Map: z.ZodString;
                    Mode: z.ZodString;
                    UseBots: z.ZodBoolean;
                    GamePod: z.ZodString;
                    GameRules: z.ZodNullable<z.ZodObject<{
                        AllowGameModifiers: z.ZodOptional<z.ZodEffects<z.ZodString, boolean, string>>;
                        IsOvertimeWinByTwo: z.ZodOptional<z.ZodEffects<z.ZodString, boolean, string>>;
                        PlayOutAllRounds: z.ZodOptional<z.ZodEffects<z.ZodString, boolean, string>>;
                        SkipMatchHistory: z.ZodOptional<z.ZodEffects<z.ZodString, boolean, string>>;
                        TournamentMode: z.ZodOptional<z.ZodEffects<z.ZodString, boolean, string>>;
                    }, "strip", z.ZodTypeAny, {
                        AllowGameModifiers?: boolean | undefined;
                        IsOvertimeWinByTwo?: boolean | undefined;
                        PlayOutAllRounds?: boolean | undefined;
                        SkipMatchHistory?: boolean | undefined;
                        TournamentMode?: boolean | undefined;
                    }, {
                        AllowGameModifiers?: string | undefined;
                        IsOvertimeWinByTwo?: string | undefined;
                        PlayOutAllRounds?: string | undefined;
                        SkipMatchHistory?: string | undefined;
                        TournamentMode?: string | undefined;
                    }>>;
                }, "strip", z.ZodTypeAny, {
                    Mode: string;
                    GameRules: {
                        AllowGameModifiers?: boolean | undefined;
                        IsOvertimeWinByTwo?: boolean | undefined;
                        PlayOutAllRounds?: boolean | undefined;
                        SkipMatchHistory?: boolean | undefined;
                        TournamentMode?: boolean | undefined;
                    } | null;
                    Map: string;
                    UseBots: boolean;
                    GamePod: string;
                }, {
                    Mode: string;
                    GameRules: {
                        AllowGameModifiers?: string | undefined;
                        IsOvertimeWinByTwo?: string | undefined;
                        PlayOutAllRounds?: string | undefined;
                        SkipMatchHistory?: string | undefined;
                        TournamentMode?: string | undefined;
                    } | null;
                    Map: string;
                    UseBots: boolean;
                    GamePod: string;
                }>;
                Membership: z.ZodObject<{
                    teamOne: z.ZodNullable<z.ZodArray<z.ZodObject<{
                        Subject: z.ZodString;
                    }, "strip", z.ZodTypeAny, {
                        Subject: string;
                    }, {
                        Subject: string;
                    }>, "many">>;
                    teamTwo: z.ZodNullable<z.ZodArray<z.ZodObject<{
                        Subject: z.ZodString;
                    }, "strip", z.ZodTypeAny, {
                        Subject: string;
                    }, {
                        Subject: string;
                    }>, "many">>;
                    teamSpectate: z.ZodNullable<z.ZodArray<z.ZodObject<{
                        Subject: z.ZodString;
                    }, "strip", z.ZodTypeAny, {
                        Subject: string;
                    }, {
                        Subject: string;
                    }>, "many">>;
                    teamOneCoaches: z.ZodNullable<z.ZodArray<z.ZodObject<{
                        Subject: z.ZodString;
                    }, "strip", z.ZodTypeAny, {
                        Subject: string;
                    }, {
                        Subject: string;
                    }>, "many">>;
                    teamTwoCoaches: z.ZodNullable<z.ZodArray<z.ZodObject<{
                        Subject: z.ZodString;
                    }, "strip", z.ZodTypeAny, {
                        Subject: string;
                    }, {
                        Subject: string;
                    }>, "many">>;
                }, "strip", z.ZodTypeAny, {
                    teamOne: {
                        Subject: string;
                    }[] | null;
                    teamTwo: {
                        Subject: string;
                    }[] | null;
                    teamSpectate: {
                        Subject: string;
                    }[] | null;
                    teamOneCoaches: {
                        Subject: string;
                    }[] | null;
                    teamTwoCoaches: {
                        Subject: string;
                    }[] | null;
                }, {
                    teamOne: {
                        Subject: string;
                    }[] | null;
                    teamTwo: {
                        Subject: string;
                    }[] | null;
                    teamSpectate: {
                        Subject: string;
                    }[] | null;
                    teamOneCoaches: {
                        Subject: string;
                    }[] | null;
                    teamTwoCoaches: {
                        Subject: string;
                    }[] | null;
                }>;
                MaxPartySize: z.ZodNumber;
                AutobalanceEnabled: z.ZodBoolean;
                AutobalanceMinPlayers: z.ZodNumber;
                HasRecoveryData: z.ZodBoolean;
            }, "strip", z.ZodTypeAny, {
                MaxPartySize: number;
                Settings: {
                    Mode: string;
                    GameRules: {
                        AllowGameModifiers?: boolean | undefined;
                        IsOvertimeWinByTwo?: boolean | undefined;
                        PlayOutAllRounds?: boolean | undefined;
                        SkipMatchHistory?: boolean | undefined;
                        TournamentMode?: boolean | undefined;
                    } | null;
                    Map: string;
                    UseBots: boolean;
                    GamePod: string;
                };
                Membership: {
                    teamOne: {
                        Subject: string;
                    }[] | null;
                    teamTwo: {
                        Subject: string;
                    }[] | null;
                    teamSpectate: {
                        Subject: string;
                    }[] | null;
                    teamOneCoaches: {
                        Subject: string;
                    }[] | null;
                    teamTwoCoaches: {
                        Subject: string;
                    }[] | null;
                };
                AutobalanceEnabled: boolean;
                AutobalanceMinPlayers: number;
                HasRecoveryData: boolean;
            }, {
                MaxPartySize: number;
                Settings: {
                    Mode: string;
                    GameRules: {
                        AllowGameModifiers?: string | undefined;
                        IsOvertimeWinByTwo?: string | undefined;
                        PlayOutAllRounds?: string | undefined;
                        SkipMatchHistory?: string | undefined;
                        TournamentMode?: string | undefined;
                    } | null;
                    Map: string;
                    UseBots: boolean;
                    GamePod: string;
                };
                Membership: {
                    teamOne: {
                        Subject: string;
                    }[] | null;
                    teamTwo: {
                        Subject: string;
                    }[] | null;
                    teamSpectate: {
                        Subject: string;
                    }[] | null;
                    teamOneCoaches: {
                        Subject: string;
                    }[] | null;
                    teamTwoCoaches: {
                        Subject: string;
                    }[] | null;
                };
                AutobalanceEnabled: boolean;
                AutobalanceMinPlayers: number;
                HasRecoveryData: boolean;
            }>;
            MatchmakingData: z.ZodObject<{
                QueueID: z.ZodString;
                PreferredGamePods: z.ZodArray<z.ZodString, "many">;
                SkillDisparityRRPenalty: z.ZodNumber;
            }, "strip", z.ZodTypeAny, {
                QueueID: string;
                PreferredGamePods: string[];
                SkillDisparityRRPenalty: number;
            }, {
                QueueID: string;
                PreferredGamePods: string[];
                SkillDisparityRRPenalty: number;
            }>;
            Invites: z.ZodNull;
            Requests: z.ZodArray<z.ZodUnknown, "many">;
            QueueEntryTime: z.ZodEffects<z.ZodString, Date, string>;
            ErrorNotification: z.ZodObject<{
                ErrorType: z.ZodString;
                ErroredPlayers: z.ZodNullable<z.ZodArray<z.ZodObject<{
                    Subject: z.ZodString;
                }, "strip", z.ZodTypeAny, {
                    Subject: string;
                }, {
                    Subject: string;
                }>, "many">>;
            }, "strip", z.ZodTypeAny, {
                ErrorType: string;
                ErroredPlayers: {
                    Subject: string;
                }[] | null;
            }, {
                ErrorType: string;
                ErroredPlayers: {
                    Subject: string;
                }[] | null;
            }>;
            RestrictedSeconds: z.ZodNumber;
            EligibleQueues: z.ZodArray<z.ZodString, "many">;
            QueueIneligibilities: z.ZodArray<z.ZodString, "many">;
            CheatData: z.ZodObject<{
                GamePodOverride: z.ZodString;
                ForcePostGameProcessing: z.ZodBoolean;
            }, "strip", z.ZodTypeAny, {
                GamePodOverride: string;
                ForcePostGameProcessing: boolean;
            }, {
                GamePodOverride: string;
                ForcePostGameProcessing: boolean;
            }>;
            XPBonuses: z.ZodArray<z.ZodUnknown, "many">;
            InviteCode: z.ZodString;
        }, "strip", z.ZodTypeAny, {
            ID: string;
            Version: number;
            Invites: null;
            Requests: unknown[];
            State: string;
            MatchmakingData: {
                QueueID: string;
                PreferredGamePods: string[];
                SkillDisparityRRPenalty: number;
            };
            MUCName: string;
            VoiceRoomID: string;
            ClientVersion: string;
            Members: {
                Subject: string;
                PlayerIdentity: {
                    Subject: string;
                    PlayerCardID: string;
                    PlayerTitleID: string;
                    AccountLevel: number;
                    PreferredLevelBorderID: string;
                    Incognito: boolean;
                    HideAccountLevel: boolean;
                };
                SeasonalBadgeInfo: null;
                CompetitiveTier: number;
                QueueEligibleRemainingAccountLevels: number;
                Pings: {
                    GamePodID: string;
                    Ping: number;
                }[];
                IsReady: boolean;
                IsModerator: boolean;
                UseBroadcastHUD: boolean;
                PlatformType: "PC";
                IsOwner?: boolean | undefined;
            }[];
            PreviousState: string;
            StateTransitionReason: string;
            Accessibility: "OPEN" | "CLOSED";
            CustomGameData: {
                MaxPartySize: number;
                Settings: {
                    Mode: string;
                    GameRules: {
                        AllowGameModifiers?: boolean | undefined;
                        IsOvertimeWinByTwo?: boolean | undefined;
                        PlayOutAllRounds?: boolean | undefined;
                        SkipMatchHistory?: boolean | undefined;
                        TournamentMode?: boolean | undefined;
                    } | null;
                    Map: string;
                    UseBots: boolean;
                    GamePod: string;
                };
                Membership: {
                    teamOne: {
                        Subject: string;
                    }[] | null;
                    teamTwo: {
                        Subject: string;
                    }[] | null;
                    teamSpectate: {
                        Subject: string;
                    }[] | null;
                    teamOneCoaches: {
                        Subject: string;
                    }[] | null;
                    teamTwoCoaches: {
                        Subject: string;
                    }[] | null;
                };
                AutobalanceEnabled: boolean;
                AutobalanceMinPlayers: number;
                HasRecoveryData: boolean;
            };
            QueueEntryTime: Date;
            ErrorNotification: {
                ErrorType: string;
                ErroredPlayers: {
                    Subject: string;
                }[] | null;
            };
            RestrictedSeconds: number;
            EligibleQueues: string[];
            QueueIneligibilities: string[];
            CheatData: {
                GamePodOverride: string;
                ForcePostGameProcessing: boolean;
            };
            XPBonuses: unknown[];
            InviteCode: string;
        }, {
            ID: string;
            Version: number;
            Invites: null;
            Requests: unknown[];
            State: string;
            MatchmakingData: {
                QueueID: string;
                PreferredGamePods: string[];
                SkillDisparityRRPenalty: number;
            };
            MUCName: string;
            VoiceRoomID: string;
            ClientVersion: string;
            Members: {
                Subject: string;
                PlayerIdentity: {
                    Subject: string;
                    PlayerCardID: string;
                    PlayerTitleID: string;
                    AccountLevel: number;
                    PreferredLevelBorderID: string;
                    Incognito: boolean;
                    HideAccountLevel: boolean;
                };
                SeasonalBadgeInfo: null;
                CompetitiveTier: number;
                QueueEligibleRemainingAccountLevels: number;
                Pings: {
                    GamePodID: string;
                    Ping: number;
                }[];
                IsReady: boolean;
                IsModerator: boolean;
                UseBroadcastHUD: boolean;
                PlatformType: "PC";
                IsOwner?: boolean | undefined;
            }[];
            PreviousState: string;
            StateTransitionReason: string;
            Accessibility: "OPEN" | "CLOSED";
            CustomGameData: {
                MaxPartySize: number;
                Settings: {
                    Mode: string;
                    GameRules: {
                        AllowGameModifiers?: string | undefined;
                        IsOvertimeWinByTwo?: string | undefined;
                        PlayOutAllRounds?: string | undefined;
                        SkipMatchHistory?: string | undefined;
                        TournamentMode?: string | undefined;
                    } | null;
                    Map: string;
                    UseBots: boolean;
                    GamePod: string;
                };
                Membership: {
                    teamOne: {
                        Subject: string;
                    }[] | null;
                    teamTwo: {
                        Subject: string;
                    }[] | null;
                    teamSpectate: {
                        Subject: string;
                    }[] | null;
                    teamOneCoaches: {
                        Subject: string;
                    }[] | null;
                    teamTwoCoaches: {
                        Subject: string;
                    }[] | null;
                };
                AutobalanceEnabled: boolean;
                AutobalanceMinPlayers: number;
                HasRecoveryData: boolean;
            };
            QueueEntryTime: string;
            ErrorNotification: {
                ErrorType: string;
                ErroredPlayers: {
                    Subject: string;
                }[] | null;
            };
            RestrictedSeconds: number;
            EligibleQueues: string[];
            QueueIneligibilities: string[];
            CheatData: {
                GamePodOverride: string;
                ForcePostGameProcessing: boolean;
            };
            XPBonuses: unknown[];
            InviteCode: string;
        }>;
    };
}, "type" | "name" | "url"> & {
    "~type": {
        readonly name: "Set Custom Game Settings";
        readonly description: "Changes the settings for a custom game";
        readonly type: "glz";
        readonly method: "POST";
        readonly url: "parties/v1/parties/:partyId/customgamesettings";
        readonly body: z.ZodObject<{
            Map: z.ZodString;
            Mode: z.ZodString;
            UseBots: z.ZodBoolean;
            GamePod: z.ZodString;
            GameRules: z.ZodObject<{
                AllowGameModifiers: z.ZodEnum<["true", "false"]>;
                PlayOutAllRounds: z.ZodEnum<["true", "false"]>;
                SkipMatchHistory: z.ZodEnum<["true", "false"]>;
                TournamentMode: z.ZodEnum<["true", "false"]>;
                IsOvertimeWinByTwo: z.ZodEnum<["true", "false"]>;
            }, "strip", z.ZodTypeAny, {
                AllowGameModifiers: "true" | "false";
                IsOvertimeWinByTwo: "true" | "false";
                PlayOutAllRounds: "true" | "false";
                SkipMatchHistory: "true" | "false";
                TournamentMode: "true" | "false";
            }, {
                AllowGameModifiers: "true" | "false";
                IsOvertimeWinByTwo: "true" | "false";
                PlayOutAllRounds: "true" | "false";
                SkipMatchHistory: "true" | "false";
                TournamentMode: "true" | "false";
            }>;
        }, "strip", z.ZodTypeAny, {
            Mode: string;
            GameRules: {
                AllowGameModifiers: "true" | "false";
                IsOvertimeWinByTwo: "true" | "false";
                PlayOutAllRounds: "true" | "false";
                SkipMatchHistory: "true" | "false";
                TournamentMode: "true" | "false";
            };
            Map: string;
            UseBots: boolean;
            GamePod: string;
        }, {
            Mode: string;
            GameRules: {
                AllowGameModifiers: "true" | "false";
                IsOvertimeWinByTwo: "true" | "false";
                PlayOutAllRounds: "true" | "false";
                SkipMatchHistory: "true" | "false";
                TournamentMode: "true" | "false";
            };
            Map: string;
            UseBots: boolean;
            GamePod: string;
        }>;
        readonly responses: {
            readonly "200": z.ZodObject<{
                ID: z.ZodString;
                MUCName: z.ZodString;
                VoiceRoomID: z.ZodString;
                Version: z.ZodNumber;
                ClientVersion: z.ZodString;
                Members: z.ZodArray<z.ZodObject<{
                    Subject: z.ZodString;
                    CompetitiveTier: z.ZodNumber;
                    PlayerIdentity: z.ZodObject<{
                        Subject: z.ZodString;
                        PlayerCardID: z.ZodString;
                        PlayerTitleID: z.ZodString;
                        AccountLevel: z.ZodNumber;
                        PreferredLevelBorderID: z.ZodUnion<[z.ZodString, z.ZodLiteral<"">]>;
                        Incognito: z.ZodBoolean;
                        HideAccountLevel: z.ZodBoolean;
                    }, "strip", z.ZodTypeAny, {
                        Subject: string;
                        PlayerCardID: string;
                        PlayerTitleID: string;
                        AccountLevel: number;
                        PreferredLevelBorderID: string;
                        Incognito: boolean;
                        HideAccountLevel: boolean;
                    }, {
                        Subject: string;
                        PlayerCardID: string;
                        PlayerTitleID: string;
                        AccountLevel: number;
                        PreferredLevelBorderID: string;
                        Incognito: boolean;
                        HideAccountLevel: boolean;
                    }>;
                    SeasonalBadgeInfo: z.ZodNull;
                    IsOwner: z.ZodOptional<z.ZodBoolean>;
                    QueueEligibleRemainingAccountLevels: z.ZodNumber;
                    Pings: z.ZodArray<z.ZodObject<{
                        Ping: z.ZodNumber;
                        GamePodID: z.ZodString;
                    }, "strip", z.ZodTypeAny, {
                        GamePodID: string;
                        Ping: number;
                    }, {
                        GamePodID: string;
                        Ping: number;
                    }>, "many">;
                    IsReady: z.ZodBoolean;
                    IsModerator: z.ZodBoolean;
                    UseBroadcastHUD: z.ZodBoolean;
                    PlatformType: z.ZodLiteral<"PC">;
                }, "strip", z.ZodTypeAny, {
                    Subject: string;
                    PlayerIdentity: {
                        Subject: string;
                        PlayerCardID: string;
                        PlayerTitleID: string;
                        AccountLevel: number;
                        PreferredLevelBorderID: string;
                        Incognito: boolean;
                        HideAccountLevel: boolean;
                    };
                    SeasonalBadgeInfo: null;
                    CompetitiveTier: number;
                    QueueEligibleRemainingAccountLevels: number;
                    Pings: {
                        GamePodID: string;
                        Ping: number;
                    }[];
                    IsReady: boolean;
                    IsModerator: boolean;
                    UseBroadcastHUD: boolean;
                    PlatformType: "PC";
                    IsOwner?: boolean | undefined;
                }, {
                    Subject: string;
                    PlayerIdentity: {
                        Subject: string;
                        PlayerCardID: string;
                        PlayerTitleID: string;
                        AccountLevel: number;
                        PreferredLevelBorderID: string;
                        Incognito: boolean;
                        HideAccountLevel: boolean;
                    };
                    SeasonalBadgeInfo: null;
                    CompetitiveTier: number;
                    QueueEligibleRemainingAccountLevels: number;
                    Pings: {
                        GamePodID: string;
                        Ping: number;
                    }[];
                    IsReady: boolean;
                    IsModerator: boolean;
                    UseBroadcastHUD: boolean;
                    PlatformType: "PC";
                    IsOwner?: boolean | undefined;
                }>, "many">;
                State: z.ZodString;
                PreviousState: z.ZodString;
                StateTransitionReason: z.ZodString;
                Accessibility: z.ZodUnion<[z.ZodLiteral<"OPEN">, z.ZodLiteral<"CLOSED">]>;
                CustomGameData: z.ZodObject<{
                    Settings: z.ZodObject<{
                        Map: z.ZodString;
                        Mode: z.ZodString;
                        UseBots: z.ZodBoolean;
                        GamePod: z.ZodString;
                        GameRules: z.ZodNullable<z.ZodObject<{
                            AllowGameModifiers: z.ZodOptional<z.ZodEffects<z.ZodString, boolean, string>>;
                            IsOvertimeWinByTwo: z.ZodOptional<z.ZodEffects<z.ZodString, boolean, string>>;
                            PlayOutAllRounds: z.ZodOptional<z.ZodEffects<z.ZodString, boolean, string>>;
                            SkipMatchHistory: z.ZodOptional<z.ZodEffects<z.ZodString, boolean, string>>;
                            TournamentMode: z.ZodOptional<z.ZodEffects<z.ZodString, boolean, string>>;
                        }, "strip", z.ZodTypeAny, {
                            AllowGameModifiers?: boolean | undefined;
                            IsOvertimeWinByTwo?: boolean | undefined;
                            PlayOutAllRounds?: boolean | undefined;
                            SkipMatchHistory?: boolean | undefined;
                            TournamentMode?: boolean | undefined;
                        }, {
                            AllowGameModifiers?: string | undefined;
                            IsOvertimeWinByTwo?: string | undefined;
                            PlayOutAllRounds?: string | undefined;
                            SkipMatchHistory?: string | undefined;
                            TournamentMode?: string | undefined;
                        }>>;
                    }, "strip", z.ZodTypeAny, {
                        Mode: string;
                        GameRules: {
                            AllowGameModifiers?: boolean | undefined;
                            IsOvertimeWinByTwo?: boolean | undefined;
                            PlayOutAllRounds?: boolean | undefined;
                            SkipMatchHistory?: boolean | undefined;
                            TournamentMode?: boolean | undefined;
                        } | null;
                        Map: string;
                        UseBots: boolean;
                        GamePod: string;
                    }, {
                        Mode: string;
                        GameRules: {
                            AllowGameModifiers?: string | undefined;
                            IsOvertimeWinByTwo?: string | undefined;
                            PlayOutAllRounds?: string | undefined;
                            SkipMatchHistory?: string | undefined;
                            TournamentMode?: string | undefined;
                        } | null;
                        Map: string;
                        UseBots: boolean;
                        GamePod: string;
                    }>;
                    Membership: z.ZodObject<{
                        teamOne: z.ZodNullable<z.ZodArray<z.ZodObject<{
                            Subject: z.ZodString;
                        }, "strip", z.ZodTypeAny, {
                            Subject: string;
                        }, {
                            Subject: string;
                        }>, "many">>;
                        teamTwo: z.ZodNullable<z.ZodArray<z.ZodObject<{
                            Subject: z.ZodString;
                        }, "strip", z.ZodTypeAny, {
                            Subject: string;
                        }, {
                            Subject: string;
                        }>, "many">>;
                        teamSpectate: z.ZodNullable<z.ZodArray<z.ZodObject<{
                            Subject: z.ZodString;
                        }, "strip", z.ZodTypeAny, {
                            Subject: string;
                        }, {
                            Subject: string;
                        }>, "many">>;
                        teamOneCoaches: z.ZodNullable<z.ZodArray<z.ZodObject<{
                            Subject: z.ZodString;
                        }, "strip", z.ZodTypeAny, {
                            Subject: string;
                        }, {
                            Subject: string;
                        }>, "many">>;
                        teamTwoCoaches: z.ZodNullable<z.ZodArray<z.ZodObject<{
                            Subject: z.ZodString;
                        }, "strip", z.ZodTypeAny, {
                            Subject: string;
                        }, {
                            Subject: string;
                        }>, "many">>;
                    }, "strip", z.ZodTypeAny, {
                        teamOne: {
                            Subject: string;
                        }[] | null;
                        teamTwo: {
                            Subject: string;
                        }[] | null;
                        teamSpectate: {
                            Subject: string;
                        }[] | null;
                        teamOneCoaches: {
                            Subject: string;
                        }[] | null;
                        teamTwoCoaches: {
                            Subject: string;
                        }[] | null;
                    }, {
                        teamOne: {
                            Subject: string;
                        }[] | null;
                        teamTwo: {
                            Subject: string;
                        }[] | null;
                        teamSpectate: {
                            Subject: string;
                        }[] | null;
                        teamOneCoaches: {
                            Subject: string;
                        }[] | null;
                        teamTwoCoaches: {
                            Subject: string;
                        }[] | null;
                    }>;
                    MaxPartySize: z.ZodNumber;
                    AutobalanceEnabled: z.ZodBoolean;
                    AutobalanceMinPlayers: z.ZodNumber;
                    HasRecoveryData: z.ZodBoolean;
                }, "strip", z.ZodTypeAny, {
                    MaxPartySize: number;
                    Settings: {
                        Mode: string;
                        GameRules: {
                            AllowGameModifiers?: boolean | undefined;
                            IsOvertimeWinByTwo?: boolean | undefined;
                            PlayOutAllRounds?: boolean | undefined;
                            SkipMatchHistory?: boolean | undefined;
                            TournamentMode?: boolean | undefined;
                        } | null;
                        Map: string;
                        UseBots: boolean;
                        GamePod: string;
                    };
                    Membership: {
                        teamOne: {
                            Subject: string;
                        }[] | null;
                        teamTwo: {
                            Subject: string;
                        }[] | null;
                        teamSpectate: {
                            Subject: string;
                        }[] | null;
                        teamOneCoaches: {
                            Subject: string;
                        }[] | null;
                        teamTwoCoaches: {
                            Subject: string;
                        }[] | null;
                    };
                    AutobalanceEnabled: boolean;
                    AutobalanceMinPlayers: number;
                    HasRecoveryData: boolean;
                }, {
                    MaxPartySize: number;
                    Settings: {
                        Mode: string;
                        GameRules: {
                            AllowGameModifiers?: string | undefined;
                            IsOvertimeWinByTwo?: string | undefined;
                            PlayOutAllRounds?: string | undefined;
                            SkipMatchHistory?: string | undefined;
                            TournamentMode?: string | undefined;
                        } | null;
                        Map: string;
                        UseBots: boolean;
                        GamePod: string;
                    };
                    Membership: {
                        teamOne: {
                            Subject: string;
                        }[] | null;
                        teamTwo: {
                            Subject: string;
                        }[] | null;
                        teamSpectate: {
                            Subject: string;
                        }[] | null;
                        teamOneCoaches: {
                            Subject: string;
                        }[] | null;
                        teamTwoCoaches: {
                            Subject: string;
                        }[] | null;
                    };
                    AutobalanceEnabled: boolean;
                    AutobalanceMinPlayers: number;
                    HasRecoveryData: boolean;
                }>;
                MatchmakingData: z.ZodObject<{
                    QueueID: z.ZodString;
                    PreferredGamePods: z.ZodArray<z.ZodString, "many">;
                    SkillDisparityRRPenalty: z.ZodNumber;
                }, "strip", z.ZodTypeAny, {
                    QueueID: string;
                    PreferredGamePods: string[];
                    SkillDisparityRRPenalty: number;
                }, {
                    QueueID: string;
                    PreferredGamePods: string[];
                    SkillDisparityRRPenalty: number;
                }>;
                Invites: z.ZodNull;
                Requests: z.ZodArray<z.ZodUnknown, "many">;
                QueueEntryTime: z.ZodEffects<z.ZodString, Date, string>;
                ErrorNotification: z.ZodObject<{
                    ErrorType: z.ZodString;
                    ErroredPlayers: z.ZodNullable<z.ZodArray<z.ZodObject<{
                        Subject: z.ZodString;
                    }, "strip", z.ZodTypeAny, {
                        Subject: string;
                    }, {
                        Subject: string;
                    }>, "many">>;
                }, "strip", z.ZodTypeAny, {
                    ErrorType: string;
                    ErroredPlayers: {
                        Subject: string;
                    }[] | null;
                }, {
                    ErrorType: string;
                    ErroredPlayers: {
                        Subject: string;
                    }[] | null;
                }>;
                RestrictedSeconds: z.ZodNumber;
                EligibleQueues: z.ZodArray<z.ZodString, "many">;
                QueueIneligibilities: z.ZodArray<z.ZodString, "many">;
                CheatData: z.ZodObject<{
                    GamePodOverride: z.ZodString;
                    ForcePostGameProcessing: z.ZodBoolean;
                }, "strip", z.ZodTypeAny, {
                    GamePodOverride: string;
                    ForcePostGameProcessing: boolean;
                }, {
                    GamePodOverride: string;
                    ForcePostGameProcessing: boolean;
                }>;
                XPBonuses: z.ZodArray<z.ZodUnknown, "many">;
                InviteCode: z.ZodString;
            }, "strip", z.ZodTypeAny, {
                ID: string;
                Version: number;
                Invites: null;
                Requests: unknown[];
                State: string;
                MatchmakingData: {
                    QueueID: string;
                    PreferredGamePods: string[];
                    SkillDisparityRRPenalty: number;
                };
                MUCName: string;
                VoiceRoomID: string;
                ClientVersion: string;
                Members: {
                    Subject: string;
                    PlayerIdentity: {
                        Subject: string;
                        PlayerCardID: string;
                        PlayerTitleID: string;
                        AccountLevel: number;
                        PreferredLevelBorderID: string;
                        Incognito: boolean;
                        HideAccountLevel: boolean;
                    };
                    SeasonalBadgeInfo: null;
                    CompetitiveTier: number;
                    QueueEligibleRemainingAccountLevels: number;
                    Pings: {
                        GamePodID: string;
                        Ping: number;
                    }[];
                    IsReady: boolean;
                    IsModerator: boolean;
                    UseBroadcastHUD: boolean;
                    PlatformType: "PC";
                    IsOwner?: boolean | undefined;
                }[];
                PreviousState: string;
                StateTransitionReason: string;
                Accessibility: "OPEN" | "CLOSED";
                CustomGameData: {
                    MaxPartySize: number;
                    Settings: {
                        Mode: string;
                        GameRules: {
                            AllowGameModifiers?: boolean | undefined;
                            IsOvertimeWinByTwo?: boolean | undefined;
                            PlayOutAllRounds?: boolean | undefined;
                            SkipMatchHistory?: boolean | undefined;
                            TournamentMode?: boolean | undefined;
                        } | null;
                        Map: string;
                        UseBots: boolean;
                        GamePod: string;
                    };
                    Membership: {
                        teamOne: {
                            Subject: string;
                        }[] | null;
                        teamTwo: {
                            Subject: string;
                        }[] | null;
                        teamSpectate: {
                            Subject: string;
                        }[] | null;
                        teamOneCoaches: {
                            Subject: string;
                        }[] | null;
                        teamTwoCoaches: {
                            Subject: string;
                        }[] | null;
                    };
                    AutobalanceEnabled: boolean;
                    AutobalanceMinPlayers: number;
                    HasRecoveryData: boolean;
                };
                QueueEntryTime: Date;
                ErrorNotification: {
                    ErrorType: string;
                    ErroredPlayers: {
                        Subject: string;
                    }[] | null;
                };
                RestrictedSeconds: number;
                EligibleQueues: string[];
                QueueIneligibilities: string[];
                CheatData: {
                    GamePodOverride: string;
                    ForcePostGameProcessing: boolean;
                };
                XPBonuses: unknown[];
                InviteCode: string;
            }, {
                ID: string;
                Version: number;
                Invites: null;
                Requests: unknown[];
                State: string;
                MatchmakingData: {
                    QueueID: string;
                    PreferredGamePods: string[];
                    SkillDisparityRRPenalty: number;
                };
                MUCName: string;
                VoiceRoomID: string;
                ClientVersion: string;
                Members: {
                    Subject: string;
                    PlayerIdentity: {
                        Subject: string;
                        PlayerCardID: string;
                        PlayerTitleID: string;
                        AccountLevel: number;
                        PreferredLevelBorderID: string;
                        Incognito: boolean;
                        HideAccountLevel: boolean;
                    };
                    SeasonalBadgeInfo: null;
                    CompetitiveTier: number;
                    QueueEligibleRemainingAccountLevels: number;
                    Pings: {
                        GamePodID: string;
                        Ping: number;
                    }[];
                    IsReady: boolean;
                    IsModerator: boolean;
                    UseBroadcastHUD: boolean;
                    PlatformType: "PC";
                    IsOwner?: boolean | undefined;
                }[];
                PreviousState: string;
                StateTransitionReason: string;
                Accessibility: "OPEN" | "CLOSED";
                CustomGameData: {
                    MaxPartySize: number;
                    Settings: {
                        Mode: string;
                        GameRules: {
                            AllowGameModifiers?: string | undefined;
                            IsOvertimeWinByTwo?: string | undefined;
                            PlayOutAllRounds?: string | undefined;
                            SkipMatchHistory?: string | undefined;
                            TournamentMode?: string | undefined;
                        } | null;
                        Map: string;
                        UseBots: boolean;
                        GamePod: string;
                    };
                    Membership: {
                        teamOne: {
                            Subject: string;
                        }[] | null;
                        teamTwo: {
                            Subject: string;
                        }[] | null;
                        teamSpectate: {
                            Subject: string;
                        }[] | null;
                        teamOneCoaches: {
                            Subject: string;
                        }[] | null;
                        teamTwoCoaches: {
                            Subject: string;
                        }[] | null;
                    };
                    AutobalanceEnabled: boolean;
                    AutobalanceMinPlayers: number;
                    HasRecoveryData: boolean;
                };
                QueueEntryTime: string;
                ErrorNotification: {
                    ErrorType: string;
                    ErroredPlayers: {
                        Subject: string;
                    }[] | null;
                };
                RestrictedSeconds: number;
                EligibleQueues: string[];
                QueueIneligibilities: string[];
                CheatData: {
                    GamePodOverride: string;
                    ForcePostGameProcessing: boolean;
                };
                XPBonuses: unknown[];
                InviteCode: string;
            }>;
        };
    };
};

type Params$2 = ResolveParams<(typeof _default$2)["~type"]["url"]>;
type Body$2 = z.infer<ResolveValue<(typeof _default$2)["~type"], "body">>;
type Data$2 = ResolveData<Params$2, Body$2>;
type Response$2 = z.infer<ResolveValue<(typeof _default$2)["~type"], "responses">["200"]>;
interface SetCustomGameSettingsRequestConfig extends ValorantAxiosRequestConfig<Data$2> {
}
declare class SetCustomGameSettingsEndpoint {
    /**
     * Changes the settings for a custom game
     *
     * @EndpointType glz
     */
    postSetCustomGameSettings<T = Response$2>(this: RemoteApiClient, config: SetCustomGameSettingsRequestConfig): Promise<AxiosResponse<T>>;
}

declare const _default$1: Omit<{
    requirements: string[];
    type: "auth" | "local" | "pd" | "glz" | "shared";
    name: string;
    method: "PUT" | "GET" | "DELETE" | "POST";
    url: string;
    description?: string | undefined;
    headers?: Record<string, string> | undefined;
    body?: z.ZodType<any, z.ZodTypeDef, any> | undefined;
    query?: z.ZodType<any, z.ZodTypeDef, any> | undefined;
    responses?: Record<string, z.ZodType<any, z.ZodTypeDef, any>> | undefined;
}, "type" | "name" | "url"> & Pick<{
    readonly name: "Set Party Accessibility";
    readonly description: "Set the accessibility of the party";
    readonly type: "glz";
    readonly method: "POST";
    readonly url: "parties/v1/parties/:partyId/accessibility";
    readonly body: z.ZodObject<{
        accessibility: z.ZodEnum<["OPEN", "CLOSED"]>;
    }, "strip", z.ZodTypeAny, {
        accessibility: "OPEN" | "CLOSED";
    }, {
        accessibility: "OPEN" | "CLOSED";
    }>;
    readonly responses: {
        readonly "200": z.ZodObject<{
            ID: z.ZodString;
            MUCName: z.ZodString;
            VoiceRoomID: z.ZodString;
            Version: z.ZodNumber;
            ClientVersion: z.ZodString;
            Members: z.ZodArray<z.ZodObject<{
                Subject: z.ZodString;
                CompetitiveTier: z.ZodNumber;
                PlayerIdentity: z.ZodObject<{
                    Subject: z.ZodString;
                    PlayerCardID: z.ZodString;
                    PlayerTitleID: z.ZodString;
                    AccountLevel: z.ZodNumber;
                    PreferredLevelBorderID: z.ZodUnion<[z.ZodString, z.ZodLiteral<"">]>;
                    Incognito: z.ZodBoolean;
                    HideAccountLevel: z.ZodBoolean;
                }, "strip", z.ZodTypeAny, {
                    Subject: string;
                    PlayerCardID: string;
                    PlayerTitleID: string;
                    AccountLevel: number;
                    PreferredLevelBorderID: string;
                    Incognito: boolean;
                    HideAccountLevel: boolean;
                }, {
                    Subject: string;
                    PlayerCardID: string;
                    PlayerTitleID: string;
                    AccountLevel: number;
                    PreferredLevelBorderID: string;
                    Incognito: boolean;
                    HideAccountLevel: boolean;
                }>;
                SeasonalBadgeInfo: z.ZodNull;
                IsOwner: z.ZodOptional<z.ZodBoolean>;
                QueueEligibleRemainingAccountLevels: z.ZodNumber;
                Pings: z.ZodArray<z.ZodObject<{
                    Ping: z.ZodNumber;
                    GamePodID: z.ZodString;
                }, "strip", z.ZodTypeAny, {
                    GamePodID: string;
                    Ping: number;
                }, {
                    GamePodID: string;
                    Ping: number;
                }>, "many">;
                IsReady: z.ZodBoolean;
                IsModerator: z.ZodBoolean;
                UseBroadcastHUD: z.ZodBoolean;
                PlatformType: z.ZodLiteral<"PC">;
            }, "strip", z.ZodTypeAny, {
                Subject: string;
                PlayerIdentity: {
                    Subject: string;
                    PlayerCardID: string;
                    PlayerTitleID: string;
                    AccountLevel: number;
                    PreferredLevelBorderID: string;
                    Incognito: boolean;
                    HideAccountLevel: boolean;
                };
                SeasonalBadgeInfo: null;
                CompetitiveTier: number;
                QueueEligibleRemainingAccountLevels: number;
                Pings: {
                    GamePodID: string;
                    Ping: number;
                }[];
                IsReady: boolean;
                IsModerator: boolean;
                UseBroadcastHUD: boolean;
                PlatformType: "PC";
                IsOwner?: boolean | undefined;
            }, {
                Subject: string;
                PlayerIdentity: {
                    Subject: string;
                    PlayerCardID: string;
                    PlayerTitleID: string;
                    AccountLevel: number;
                    PreferredLevelBorderID: string;
                    Incognito: boolean;
                    HideAccountLevel: boolean;
                };
                SeasonalBadgeInfo: null;
                CompetitiveTier: number;
                QueueEligibleRemainingAccountLevels: number;
                Pings: {
                    GamePodID: string;
                    Ping: number;
                }[];
                IsReady: boolean;
                IsModerator: boolean;
                UseBroadcastHUD: boolean;
                PlatformType: "PC";
                IsOwner?: boolean | undefined;
            }>, "many">;
            State: z.ZodString;
            PreviousState: z.ZodString;
            StateTransitionReason: z.ZodString;
            Accessibility: z.ZodUnion<[z.ZodLiteral<"OPEN">, z.ZodLiteral<"CLOSED">]>;
            CustomGameData: z.ZodObject<{
                Settings: z.ZodObject<{
                    Map: z.ZodString;
                    Mode: z.ZodString;
                    UseBots: z.ZodBoolean;
                    GamePod: z.ZodString;
                    GameRules: z.ZodNullable<z.ZodObject<{
                        AllowGameModifiers: z.ZodOptional<z.ZodEffects<z.ZodString, boolean, string>>;
                        IsOvertimeWinByTwo: z.ZodOptional<z.ZodEffects<z.ZodString, boolean, string>>;
                        PlayOutAllRounds: z.ZodOptional<z.ZodEffects<z.ZodString, boolean, string>>;
                        SkipMatchHistory: z.ZodOptional<z.ZodEffects<z.ZodString, boolean, string>>;
                        TournamentMode: z.ZodOptional<z.ZodEffects<z.ZodString, boolean, string>>;
                    }, "strip", z.ZodTypeAny, {
                        AllowGameModifiers?: boolean | undefined;
                        IsOvertimeWinByTwo?: boolean | undefined;
                        PlayOutAllRounds?: boolean | undefined;
                        SkipMatchHistory?: boolean | undefined;
                        TournamentMode?: boolean | undefined;
                    }, {
                        AllowGameModifiers?: string | undefined;
                        IsOvertimeWinByTwo?: string | undefined;
                        PlayOutAllRounds?: string | undefined;
                        SkipMatchHistory?: string | undefined;
                        TournamentMode?: string | undefined;
                    }>>;
                }, "strip", z.ZodTypeAny, {
                    Mode: string;
                    GameRules: {
                        AllowGameModifiers?: boolean | undefined;
                        IsOvertimeWinByTwo?: boolean | undefined;
                        PlayOutAllRounds?: boolean | undefined;
                        SkipMatchHistory?: boolean | undefined;
                        TournamentMode?: boolean | undefined;
                    } | null;
                    Map: string;
                    UseBots: boolean;
                    GamePod: string;
                }, {
                    Mode: string;
                    GameRules: {
                        AllowGameModifiers?: string | undefined;
                        IsOvertimeWinByTwo?: string | undefined;
                        PlayOutAllRounds?: string | undefined;
                        SkipMatchHistory?: string | undefined;
                        TournamentMode?: string | undefined;
                    } | null;
                    Map: string;
                    UseBots: boolean;
                    GamePod: string;
                }>;
                Membership: z.ZodObject<{
                    teamOne: z.ZodNullable<z.ZodArray<z.ZodObject<{
                        Subject: z.ZodString;
                    }, "strip", z.ZodTypeAny, {
                        Subject: string;
                    }, {
                        Subject: string;
                    }>, "many">>;
                    teamTwo: z.ZodNullable<z.ZodArray<z.ZodObject<{
                        Subject: z.ZodString;
                    }, "strip", z.ZodTypeAny, {
                        Subject: string;
                    }, {
                        Subject: string;
                    }>, "many">>;
                    teamSpectate: z.ZodNullable<z.ZodArray<z.ZodObject<{
                        Subject: z.ZodString;
                    }, "strip", z.ZodTypeAny, {
                        Subject: string;
                    }, {
                        Subject: string;
                    }>, "many">>;
                    teamOneCoaches: z.ZodNullable<z.ZodArray<z.ZodObject<{
                        Subject: z.ZodString;
                    }, "strip", z.ZodTypeAny, {
                        Subject: string;
                    }, {
                        Subject: string;
                    }>, "many">>;
                    teamTwoCoaches: z.ZodNullable<z.ZodArray<z.ZodObject<{
                        Subject: z.ZodString;
                    }, "strip", z.ZodTypeAny, {
                        Subject: string;
                    }, {
                        Subject: string;
                    }>, "many">>;
                }, "strip", z.ZodTypeAny, {
                    teamOne: {
                        Subject: string;
                    }[] | null;
                    teamTwo: {
                        Subject: string;
                    }[] | null;
                    teamSpectate: {
                        Subject: string;
                    }[] | null;
                    teamOneCoaches: {
                        Subject: string;
                    }[] | null;
                    teamTwoCoaches: {
                        Subject: string;
                    }[] | null;
                }, {
                    teamOne: {
                        Subject: string;
                    }[] | null;
                    teamTwo: {
                        Subject: string;
                    }[] | null;
                    teamSpectate: {
                        Subject: string;
                    }[] | null;
                    teamOneCoaches: {
                        Subject: string;
                    }[] | null;
                    teamTwoCoaches: {
                        Subject: string;
                    }[] | null;
                }>;
                MaxPartySize: z.ZodNumber;
                AutobalanceEnabled: z.ZodBoolean;
                AutobalanceMinPlayers: z.ZodNumber;
                HasRecoveryData: z.ZodBoolean;
            }, "strip", z.ZodTypeAny, {
                MaxPartySize: number;
                Settings: {
                    Mode: string;
                    GameRules: {
                        AllowGameModifiers?: boolean | undefined;
                        IsOvertimeWinByTwo?: boolean | undefined;
                        PlayOutAllRounds?: boolean | undefined;
                        SkipMatchHistory?: boolean | undefined;
                        TournamentMode?: boolean | undefined;
                    } | null;
                    Map: string;
                    UseBots: boolean;
                    GamePod: string;
                };
                Membership: {
                    teamOne: {
                        Subject: string;
                    }[] | null;
                    teamTwo: {
                        Subject: string;
                    }[] | null;
                    teamSpectate: {
                        Subject: string;
                    }[] | null;
                    teamOneCoaches: {
                        Subject: string;
                    }[] | null;
                    teamTwoCoaches: {
                        Subject: string;
                    }[] | null;
                };
                AutobalanceEnabled: boolean;
                AutobalanceMinPlayers: number;
                HasRecoveryData: boolean;
            }, {
                MaxPartySize: number;
                Settings: {
                    Mode: string;
                    GameRules: {
                        AllowGameModifiers?: string | undefined;
                        IsOvertimeWinByTwo?: string | undefined;
                        PlayOutAllRounds?: string | undefined;
                        SkipMatchHistory?: string | undefined;
                        TournamentMode?: string | undefined;
                    } | null;
                    Map: string;
                    UseBots: boolean;
                    GamePod: string;
                };
                Membership: {
                    teamOne: {
                        Subject: string;
                    }[] | null;
                    teamTwo: {
                        Subject: string;
                    }[] | null;
                    teamSpectate: {
                        Subject: string;
                    }[] | null;
                    teamOneCoaches: {
                        Subject: string;
                    }[] | null;
                    teamTwoCoaches: {
                        Subject: string;
                    }[] | null;
                };
                AutobalanceEnabled: boolean;
                AutobalanceMinPlayers: number;
                HasRecoveryData: boolean;
            }>;
            MatchmakingData: z.ZodObject<{
                QueueID: z.ZodString;
                PreferredGamePods: z.ZodArray<z.ZodString, "many">;
                SkillDisparityRRPenalty: z.ZodNumber;
            }, "strip", z.ZodTypeAny, {
                QueueID: string;
                PreferredGamePods: string[];
                SkillDisparityRRPenalty: number;
            }, {
                QueueID: string;
                PreferredGamePods: string[];
                SkillDisparityRRPenalty: number;
            }>;
            Invites: z.ZodNull;
            Requests: z.ZodArray<z.ZodUnknown, "many">;
            QueueEntryTime: z.ZodEffects<z.ZodString, Date, string>;
            ErrorNotification: z.ZodObject<{
                ErrorType: z.ZodString;
                ErroredPlayers: z.ZodNullable<z.ZodArray<z.ZodObject<{
                    Subject: z.ZodString;
                }, "strip", z.ZodTypeAny, {
                    Subject: string;
                }, {
                    Subject: string;
                }>, "many">>;
            }, "strip", z.ZodTypeAny, {
                ErrorType: string;
                ErroredPlayers: {
                    Subject: string;
                }[] | null;
            }, {
                ErrorType: string;
                ErroredPlayers: {
                    Subject: string;
                }[] | null;
            }>;
            RestrictedSeconds: z.ZodNumber;
            EligibleQueues: z.ZodArray<z.ZodString, "many">;
            QueueIneligibilities: z.ZodArray<z.ZodString, "many">;
            CheatData: z.ZodObject<{
                GamePodOverride: z.ZodString;
                ForcePostGameProcessing: z.ZodBoolean;
            }, "strip", z.ZodTypeAny, {
                GamePodOverride: string;
                ForcePostGameProcessing: boolean;
            }, {
                GamePodOverride: string;
                ForcePostGameProcessing: boolean;
            }>;
            XPBonuses: z.ZodArray<z.ZodUnknown, "many">;
            InviteCode: z.ZodString;
        }, "strip", z.ZodTypeAny, {
            ID: string;
            Version: number;
            Invites: null;
            Requests: unknown[];
            State: string;
            MatchmakingData: {
                QueueID: string;
                PreferredGamePods: string[];
                SkillDisparityRRPenalty: number;
            };
            MUCName: string;
            VoiceRoomID: string;
            ClientVersion: string;
            Members: {
                Subject: string;
                PlayerIdentity: {
                    Subject: string;
                    PlayerCardID: string;
                    PlayerTitleID: string;
                    AccountLevel: number;
                    PreferredLevelBorderID: string;
                    Incognito: boolean;
                    HideAccountLevel: boolean;
                };
                SeasonalBadgeInfo: null;
                CompetitiveTier: number;
                QueueEligibleRemainingAccountLevels: number;
                Pings: {
                    GamePodID: string;
                    Ping: number;
                }[];
                IsReady: boolean;
                IsModerator: boolean;
                UseBroadcastHUD: boolean;
                PlatformType: "PC";
                IsOwner?: boolean | undefined;
            }[];
            PreviousState: string;
            StateTransitionReason: string;
            Accessibility: "OPEN" | "CLOSED";
            CustomGameData: {
                MaxPartySize: number;
                Settings: {
                    Mode: string;
                    GameRules: {
                        AllowGameModifiers?: boolean | undefined;
                        IsOvertimeWinByTwo?: boolean | undefined;
                        PlayOutAllRounds?: boolean | undefined;
                        SkipMatchHistory?: boolean | undefined;
                        TournamentMode?: boolean | undefined;
                    } | null;
                    Map: string;
                    UseBots: boolean;
                    GamePod: string;
                };
                Membership: {
                    teamOne: {
                        Subject: string;
                    }[] | null;
                    teamTwo: {
                        Subject: string;
                    }[] | null;
                    teamSpectate: {
                        Subject: string;
                    }[] | null;
                    teamOneCoaches: {
                        Subject: string;
                    }[] | null;
                    teamTwoCoaches: {
                        Subject: string;
                    }[] | null;
                };
                AutobalanceEnabled: boolean;
                AutobalanceMinPlayers: number;
                HasRecoveryData: boolean;
            };
            QueueEntryTime: Date;
            ErrorNotification: {
                ErrorType: string;
                ErroredPlayers: {
                    Subject: string;
                }[] | null;
            };
            RestrictedSeconds: number;
            EligibleQueues: string[];
            QueueIneligibilities: string[];
            CheatData: {
                GamePodOverride: string;
                ForcePostGameProcessing: boolean;
            };
            XPBonuses: unknown[];
            InviteCode: string;
        }, {
            ID: string;
            Version: number;
            Invites: null;
            Requests: unknown[];
            State: string;
            MatchmakingData: {
                QueueID: string;
                PreferredGamePods: string[];
                SkillDisparityRRPenalty: number;
            };
            MUCName: string;
            VoiceRoomID: string;
            ClientVersion: string;
            Members: {
                Subject: string;
                PlayerIdentity: {
                    Subject: string;
                    PlayerCardID: string;
                    PlayerTitleID: string;
                    AccountLevel: number;
                    PreferredLevelBorderID: string;
                    Incognito: boolean;
                    HideAccountLevel: boolean;
                };
                SeasonalBadgeInfo: null;
                CompetitiveTier: number;
                QueueEligibleRemainingAccountLevels: number;
                Pings: {
                    GamePodID: string;
                    Ping: number;
                }[];
                IsReady: boolean;
                IsModerator: boolean;
                UseBroadcastHUD: boolean;
                PlatformType: "PC";
                IsOwner?: boolean | undefined;
            }[];
            PreviousState: string;
            StateTransitionReason: string;
            Accessibility: "OPEN" | "CLOSED";
            CustomGameData: {
                MaxPartySize: number;
                Settings: {
                    Mode: string;
                    GameRules: {
                        AllowGameModifiers?: string | undefined;
                        IsOvertimeWinByTwo?: string | undefined;
                        PlayOutAllRounds?: string | undefined;
                        SkipMatchHistory?: string | undefined;
                        TournamentMode?: string | undefined;
                    } | null;
                    Map: string;
                    UseBots: boolean;
                    GamePod: string;
                };
                Membership: {
                    teamOne: {
                        Subject: string;
                    }[] | null;
                    teamTwo: {
                        Subject: string;
                    }[] | null;
                    teamSpectate: {
                        Subject: string;
                    }[] | null;
                    teamOneCoaches: {
                        Subject: string;
                    }[] | null;
                    teamTwoCoaches: {
                        Subject: string;
                    }[] | null;
                };
                AutobalanceEnabled: boolean;
                AutobalanceMinPlayers: number;
                HasRecoveryData: boolean;
            };
            QueueEntryTime: string;
            ErrorNotification: {
                ErrorType: string;
                ErroredPlayers: {
                    Subject: string;
                }[] | null;
            };
            RestrictedSeconds: number;
            EligibleQueues: string[];
            QueueIneligibilities: string[];
            CheatData: {
                GamePodOverride: string;
                ForcePostGameProcessing: boolean;
            };
            XPBonuses: unknown[];
            InviteCode: string;
        }>;
    };
}, "type" | "name" | "url"> & {
    "~type": {
        readonly name: "Set Party Accessibility";
        readonly description: "Set the accessibility of the party";
        readonly type: "glz";
        readonly method: "POST";
        readonly url: "parties/v1/parties/:partyId/accessibility";
        readonly body: z.ZodObject<{
            accessibility: z.ZodEnum<["OPEN", "CLOSED"]>;
        }, "strip", z.ZodTypeAny, {
            accessibility: "OPEN" | "CLOSED";
        }, {
            accessibility: "OPEN" | "CLOSED";
        }>;
        readonly responses: {
            readonly "200": z.ZodObject<{
                ID: z.ZodString;
                MUCName: z.ZodString;
                VoiceRoomID: z.ZodString;
                Version: z.ZodNumber;
                ClientVersion: z.ZodString;
                Members: z.ZodArray<z.ZodObject<{
                    Subject: z.ZodString;
                    CompetitiveTier: z.ZodNumber;
                    PlayerIdentity: z.ZodObject<{
                        Subject: z.ZodString;
                        PlayerCardID: z.ZodString;
                        PlayerTitleID: z.ZodString;
                        AccountLevel: z.ZodNumber;
                        PreferredLevelBorderID: z.ZodUnion<[z.ZodString, z.ZodLiteral<"">]>;
                        Incognito: z.ZodBoolean;
                        HideAccountLevel: z.ZodBoolean;
                    }, "strip", z.ZodTypeAny, {
                        Subject: string;
                        PlayerCardID: string;
                        PlayerTitleID: string;
                        AccountLevel: number;
                        PreferredLevelBorderID: string;
                        Incognito: boolean;
                        HideAccountLevel: boolean;
                    }, {
                        Subject: string;
                        PlayerCardID: string;
                        PlayerTitleID: string;
                        AccountLevel: number;
                        PreferredLevelBorderID: string;
                        Incognito: boolean;
                        HideAccountLevel: boolean;
                    }>;
                    SeasonalBadgeInfo: z.ZodNull;
                    IsOwner: z.ZodOptional<z.ZodBoolean>;
                    QueueEligibleRemainingAccountLevels: z.ZodNumber;
                    Pings: z.ZodArray<z.ZodObject<{
                        Ping: z.ZodNumber;
                        GamePodID: z.ZodString;
                    }, "strip", z.ZodTypeAny, {
                        GamePodID: string;
                        Ping: number;
                    }, {
                        GamePodID: string;
                        Ping: number;
                    }>, "many">;
                    IsReady: z.ZodBoolean;
                    IsModerator: z.ZodBoolean;
                    UseBroadcastHUD: z.ZodBoolean;
                    PlatformType: z.ZodLiteral<"PC">;
                }, "strip", z.ZodTypeAny, {
                    Subject: string;
                    PlayerIdentity: {
                        Subject: string;
                        PlayerCardID: string;
                        PlayerTitleID: string;
                        AccountLevel: number;
                        PreferredLevelBorderID: string;
                        Incognito: boolean;
                        HideAccountLevel: boolean;
                    };
                    SeasonalBadgeInfo: null;
                    CompetitiveTier: number;
                    QueueEligibleRemainingAccountLevels: number;
                    Pings: {
                        GamePodID: string;
                        Ping: number;
                    }[];
                    IsReady: boolean;
                    IsModerator: boolean;
                    UseBroadcastHUD: boolean;
                    PlatformType: "PC";
                    IsOwner?: boolean | undefined;
                }, {
                    Subject: string;
                    PlayerIdentity: {
                        Subject: string;
                        PlayerCardID: string;
                        PlayerTitleID: string;
                        AccountLevel: number;
                        PreferredLevelBorderID: string;
                        Incognito: boolean;
                        HideAccountLevel: boolean;
                    };
                    SeasonalBadgeInfo: null;
                    CompetitiveTier: number;
                    QueueEligibleRemainingAccountLevels: number;
                    Pings: {
                        GamePodID: string;
                        Ping: number;
                    }[];
                    IsReady: boolean;
                    IsModerator: boolean;
                    UseBroadcastHUD: boolean;
                    PlatformType: "PC";
                    IsOwner?: boolean | undefined;
                }>, "many">;
                State: z.ZodString;
                PreviousState: z.ZodString;
                StateTransitionReason: z.ZodString;
                Accessibility: z.ZodUnion<[z.ZodLiteral<"OPEN">, z.ZodLiteral<"CLOSED">]>;
                CustomGameData: z.ZodObject<{
                    Settings: z.ZodObject<{
                        Map: z.ZodString;
                        Mode: z.ZodString;
                        UseBots: z.ZodBoolean;
                        GamePod: z.ZodString;
                        GameRules: z.ZodNullable<z.ZodObject<{
                            AllowGameModifiers: z.ZodOptional<z.ZodEffects<z.ZodString, boolean, string>>;
                            IsOvertimeWinByTwo: z.ZodOptional<z.ZodEffects<z.ZodString, boolean, string>>;
                            PlayOutAllRounds: z.ZodOptional<z.ZodEffects<z.ZodString, boolean, string>>;
                            SkipMatchHistory: z.ZodOptional<z.ZodEffects<z.ZodString, boolean, string>>;
                            TournamentMode: z.ZodOptional<z.ZodEffects<z.ZodString, boolean, string>>;
                        }, "strip", z.ZodTypeAny, {
                            AllowGameModifiers?: boolean | undefined;
                            IsOvertimeWinByTwo?: boolean | undefined;
                            PlayOutAllRounds?: boolean | undefined;
                            SkipMatchHistory?: boolean | undefined;
                            TournamentMode?: boolean | undefined;
                        }, {
                            AllowGameModifiers?: string | undefined;
                            IsOvertimeWinByTwo?: string | undefined;
                            PlayOutAllRounds?: string | undefined;
                            SkipMatchHistory?: string | undefined;
                            TournamentMode?: string | undefined;
                        }>>;
                    }, "strip", z.ZodTypeAny, {
                        Mode: string;
                        GameRules: {
                            AllowGameModifiers?: boolean | undefined;
                            IsOvertimeWinByTwo?: boolean | undefined;
                            PlayOutAllRounds?: boolean | undefined;
                            SkipMatchHistory?: boolean | undefined;
                            TournamentMode?: boolean | undefined;
                        } | null;
                        Map: string;
                        UseBots: boolean;
                        GamePod: string;
                    }, {
                        Mode: string;
                        GameRules: {
                            AllowGameModifiers?: string | undefined;
                            IsOvertimeWinByTwo?: string | undefined;
                            PlayOutAllRounds?: string | undefined;
                            SkipMatchHistory?: string | undefined;
                            TournamentMode?: string | undefined;
                        } | null;
                        Map: string;
                        UseBots: boolean;
                        GamePod: string;
                    }>;
                    Membership: z.ZodObject<{
                        teamOne: z.ZodNullable<z.ZodArray<z.ZodObject<{
                            Subject: z.ZodString;
                        }, "strip", z.ZodTypeAny, {
                            Subject: string;
                        }, {
                            Subject: string;
                        }>, "many">>;
                        teamTwo: z.ZodNullable<z.ZodArray<z.ZodObject<{
                            Subject: z.ZodString;
                        }, "strip", z.ZodTypeAny, {
                            Subject: string;
                        }, {
                            Subject: string;
                        }>, "many">>;
                        teamSpectate: z.ZodNullable<z.ZodArray<z.ZodObject<{
                            Subject: z.ZodString;
                        }, "strip", z.ZodTypeAny, {
                            Subject: string;
                        }, {
                            Subject: string;
                        }>, "many">>;
                        teamOneCoaches: z.ZodNullable<z.ZodArray<z.ZodObject<{
                            Subject: z.ZodString;
                        }, "strip", z.ZodTypeAny, {
                            Subject: string;
                        }, {
                            Subject: string;
                        }>, "many">>;
                        teamTwoCoaches: z.ZodNullable<z.ZodArray<z.ZodObject<{
                            Subject: z.ZodString;
                        }, "strip", z.ZodTypeAny, {
                            Subject: string;
                        }, {
                            Subject: string;
                        }>, "many">>;
                    }, "strip", z.ZodTypeAny, {
                        teamOne: {
                            Subject: string;
                        }[] | null;
                        teamTwo: {
                            Subject: string;
                        }[] | null;
                        teamSpectate: {
                            Subject: string;
                        }[] | null;
                        teamOneCoaches: {
                            Subject: string;
                        }[] | null;
                        teamTwoCoaches: {
                            Subject: string;
                        }[] | null;
                    }, {
                        teamOne: {
                            Subject: string;
                        }[] | null;
                        teamTwo: {
                            Subject: string;
                        }[] | null;
                        teamSpectate: {
                            Subject: string;
                        }[] | null;
                        teamOneCoaches: {
                            Subject: string;
                        }[] | null;
                        teamTwoCoaches: {
                            Subject: string;
                        }[] | null;
                    }>;
                    MaxPartySize: z.ZodNumber;
                    AutobalanceEnabled: z.ZodBoolean;
                    AutobalanceMinPlayers: z.ZodNumber;
                    HasRecoveryData: z.ZodBoolean;
                }, "strip", z.ZodTypeAny, {
                    MaxPartySize: number;
                    Settings: {
                        Mode: string;
                        GameRules: {
                            AllowGameModifiers?: boolean | undefined;
                            IsOvertimeWinByTwo?: boolean | undefined;
                            PlayOutAllRounds?: boolean | undefined;
                            SkipMatchHistory?: boolean | undefined;
                            TournamentMode?: boolean | undefined;
                        } | null;
                        Map: string;
                        UseBots: boolean;
                        GamePod: string;
                    };
                    Membership: {
                        teamOne: {
                            Subject: string;
                        }[] | null;
                        teamTwo: {
                            Subject: string;
                        }[] | null;
                        teamSpectate: {
                            Subject: string;
                        }[] | null;
                        teamOneCoaches: {
                            Subject: string;
                        }[] | null;
                        teamTwoCoaches: {
                            Subject: string;
                        }[] | null;
                    };
                    AutobalanceEnabled: boolean;
                    AutobalanceMinPlayers: number;
                    HasRecoveryData: boolean;
                }, {
                    MaxPartySize: number;
                    Settings: {
                        Mode: string;
                        GameRules: {
                            AllowGameModifiers?: string | undefined;
                            IsOvertimeWinByTwo?: string | undefined;
                            PlayOutAllRounds?: string | undefined;
                            SkipMatchHistory?: string | undefined;
                            TournamentMode?: string | undefined;
                        } | null;
                        Map: string;
                        UseBots: boolean;
                        GamePod: string;
                    };
                    Membership: {
                        teamOne: {
                            Subject: string;
                        }[] | null;
                        teamTwo: {
                            Subject: string;
                        }[] | null;
                        teamSpectate: {
                            Subject: string;
                        }[] | null;
                        teamOneCoaches: {
                            Subject: string;
                        }[] | null;
                        teamTwoCoaches: {
                            Subject: string;
                        }[] | null;
                    };
                    AutobalanceEnabled: boolean;
                    AutobalanceMinPlayers: number;
                    HasRecoveryData: boolean;
                }>;
                MatchmakingData: z.ZodObject<{
                    QueueID: z.ZodString;
                    PreferredGamePods: z.ZodArray<z.ZodString, "many">;
                    SkillDisparityRRPenalty: z.ZodNumber;
                }, "strip", z.ZodTypeAny, {
                    QueueID: string;
                    PreferredGamePods: string[];
                    SkillDisparityRRPenalty: number;
                }, {
                    QueueID: string;
                    PreferredGamePods: string[];
                    SkillDisparityRRPenalty: number;
                }>;
                Invites: z.ZodNull;
                Requests: z.ZodArray<z.ZodUnknown, "many">;
                QueueEntryTime: z.ZodEffects<z.ZodString, Date, string>;
                ErrorNotification: z.ZodObject<{
                    ErrorType: z.ZodString;
                    ErroredPlayers: z.ZodNullable<z.ZodArray<z.ZodObject<{
                        Subject: z.ZodString;
                    }, "strip", z.ZodTypeAny, {
                        Subject: string;
                    }, {
                        Subject: string;
                    }>, "many">>;
                }, "strip", z.ZodTypeAny, {
                    ErrorType: string;
                    ErroredPlayers: {
                        Subject: string;
                    }[] | null;
                }, {
                    ErrorType: string;
                    ErroredPlayers: {
                        Subject: string;
                    }[] | null;
                }>;
                RestrictedSeconds: z.ZodNumber;
                EligibleQueues: z.ZodArray<z.ZodString, "many">;
                QueueIneligibilities: z.ZodArray<z.ZodString, "many">;
                CheatData: z.ZodObject<{
                    GamePodOverride: z.ZodString;
                    ForcePostGameProcessing: z.ZodBoolean;
                }, "strip", z.ZodTypeAny, {
                    GamePodOverride: string;
                    ForcePostGameProcessing: boolean;
                }, {
                    GamePodOverride: string;
                    ForcePostGameProcessing: boolean;
                }>;
                XPBonuses: z.ZodArray<z.ZodUnknown, "many">;
                InviteCode: z.ZodString;
            }, "strip", z.ZodTypeAny, {
                ID: string;
                Version: number;
                Invites: null;
                Requests: unknown[];
                State: string;
                MatchmakingData: {
                    QueueID: string;
                    PreferredGamePods: string[];
                    SkillDisparityRRPenalty: number;
                };
                MUCName: string;
                VoiceRoomID: string;
                ClientVersion: string;
                Members: {
                    Subject: string;
                    PlayerIdentity: {
                        Subject: string;
                        PlayerCardID: string;
                        PlayerTitleID: string;
                        AccountLevel: number;
                        PreferredLevelBorderID: string;
                        Incognito: boolean;
                        HideAccountLevel: boolean;
                    };
                    SeasonalBadgeInfo: null;
                    CompetitiveTier: number;
                    QueueEligibleRemainingAccountLevels: number;
                    Pings: {
                        GamePodID: string;
                        Ping: number;
                    }[];
                    IsReady: boolean;
                    IsModerator: boolean;
                    UseBroadcastHUD: boolean;
                    PlatformType: "PC";
                    IsOwner?: boolean | undefined;
                }[];
                PreviousState: string;
                StateTransitionReason: string;
                Accessibility: "OPEN" | "CLOSED";
                CustomGameData: {
                    MaxPartySize: number;
                    Settings: {
                        Mode: string;
                        GameRules: {
                            AllowGameModifiers?: boolean | undefined;
                            IsOvertimeWinByTwo?: boolean | undefined;
                            PlayOutAllRounds?: boolean | undefined;
                            SkipMatchHistory?: boolean | undefined;
                            TournamentMode?: boolean | undefined;
                        } | null;
                        Map: string;
                        UseBots: boolean;
                        GamePod: string;
                    };
                    Membership: {
                        teamOne: {
                            Subject: string;
                        }[] | null;
                        teamTwo: {
                            Subject: string;
                        }[] | null;
                        teamSpectate: {
                            Subject: string;
                        }[] | null;
                        teamOneCoaches: {
                            Subject: string;
                        }[] | null;
                        teamTwoCoaches: {
                            Subject: string;
                        }[] | null;
                    };
                    AutobalanceEnabled: boolean;
                    AutobalanceMinPlayers: number;
                    HasRecoveryData: boolean;
                };
                QueueEntryTime: Date;
                ErrorNotification: {
                    ErrorType: string;
                    ErroredPlayers: {
                        Subject: string;
                    }[] | null;
                };
                RestrictedSeconds: number;
                EligibleQueues: string[];
                QueueIneligibilities: string[];
                CheatData: {
                    GamePodOverride: string;
                    ForcePostGameProcessing: boolean;
                };
                XPBonuses: unknown[];
                InviteCode: string;
            }, {
                ID: string;
                Version: number;
                Invites: null;
                Requests: unknown[];
                State: string;
                MatchmakingData: {
                    QueueID: string;
                    PreferredGamePods: string[];
                    SkillDisparityRRPenalty: number;
                };
                MUCName: string;
                VoiceRoomID: string;
                ClientVersion: string;
                Members: {
                    Subject: string;
                    PlayerIdentity: {
                        Subject: string;
                        PlayerCardID: string;
                        PlayerTitleID: string;
                        AccountLevel: number;
                        PreferredLevelBorderID: string;
                        Incognito: boolean;
                        HideAccountLevel: boolean;
                    };
                    SeasonalBadgeInfo: null;
                    CompetitiveTier: number;
                    QueueEligibleRemainingAccountLevels: number;
                    Pings: {
                        GamePodID: string;
                        Ping: number;
                    }[];
                    IsReady: boolean;
                    IsModerator: boolean;
                    UseBroadcastHUD: boolean;
                    PlatformType: "PC";
                    IsOwner?: boolean | undefined;
                }[];
                PreviousState: string;
                StateTransitionReason: string;
                Accessibility: "OPEN" | "CLOSED";
                CustomGameData: {
                    MaxPartySize: number;
                    Settings: {
                        Mode: string;
                        GameRules: {
                            AllowGameModifiers?: string | undefined;
                            IsOvertimeWinByTwo?: string | undefined;
                            PlayOutAllRounds?: string | undefined;
                            SkipMatchHistory?: string | undefined;
                            TournamentMode?: string | undefined;
                        } | null;
                        Map: string;
                        UseBots: boolean;
                        GamePod: string;
                    };
                    Membership: {
                        teamOne: {
                            Subject: string;
                        }[] | null;
                        teamTwo: {
                            Subject: string;
                        }[] | null;
                        teamSpectate: {
                            Subject: string;
                        }[] | null;
                        teamOneCoaches: {
                            Subject: string;
                        }[] | null;
                        teamTwoCoaches: {
                            Subject: string;
                        }[] | null;
                    };
                    AutobalanceEnabled: boolean;
                    AutobalanceMinPlayers: number;
                    HasRecoveryData: boolean;
                };
                QueueEntryTime: string;
                ErrorNotification: {
                    ErrorType: string;
                    ErroredPlayers: {
                        Subject: string;
                    }[] | null;
                };
                RestrictedSeconds: number;
                EligibleQueues: string[];
                QueueIneligibilities: string[];
                CheatData: {
                    GamePodOverride: string;
                    ForcePostGameProcessing: boolean;
                };
                XPBonuses: unknown[];
                InviteCode: string;
            }>;
        };
    };
};

type Params$1 = ResolveParams<(typeof _default$1)["~type"]["url"]>;
type Body$1 = z.infer<ResolveValue<(typeof _default$1)["~type"], "body">>;
type Data$1 = ResolveData<Params$1, Body$1>;
type Response$1 = z.infer<ResolveValue<(typeof _default$1)["~type"], "responses">["200"]>;
interface SetPartyAccessibilityRequestConfig extends ValorantAxiosRequestConfig<Data$1> {
}
declare class SetPartyAccessibilityEndpoint {
    /**
     * Set the accessibility of the party
     *
     * @EndpointType glz
     */
    postSetPartyAccessibility<T = Response$1>(this: RemoteApiClient, config: SetPartyAccessibilityRequestConfig): Promise<AxiosResponse<T>>;
}

declare const _default: Omit<{
    requirements: string[];
    type: "auth" | "local" | "pd" | "glz" | "shared";
    name: string;
    method: "PUT" | "GET" | "DELETE" | "POST";
    url: string;
    description?: string | undefined;
    headers?: Record<string, string> | undefined;
    body?: zod.ZodType<any, zod.ZodTypeDef, any> | undefined;
    query?: zod.ZodType<any, zod.ZodTypeDef, any> | undefined;
    responses?: Record<string, zod.ZodType<any, zod.ZodTypeDef, any>> | undefined;
}, "type" | "name" | "url"> & Pick<{
    readonly name: "Start Custom Game";
    readonly description: "Start a custom game";
    readonly type: "glz";
    readonly method: "POST";
    readonly url: "parties/v1/parties/:partyId/startcustomgame";
    readonly responses: {
        readonly "200": zod.ZodObject<{
            ID: zod.ZodString;
            MUCName: zod.ZodString;
            VoiceRoomID: zod.ZodString;
            Version: zod.ZodNumber;
            ClientVersion: zod.ZodString;
            Members: zod.ZodArray<zod.ZodObject<{
                Subject: zod.ZodString;
                CompetitiveTier: zod.ZodNumber;
                PlayerIdentity: zod.ZodObject<{
                    Subject: zod.ZodString;
                    PlayerCardID: zod.ZodString;
                    PlayerTitleID: zod.ZodString;
                    AccountLevel: zod.ZodNumber;
                    PreferredLevelBorderID: zod.ZodUnion<[zod.ZodString, zod.ZodLiteral<"">]>;
                    Incognito: zod.ZodBoolean;
                    HideAccountLevel: zod.ZodBoolean;
                }, "strip", zod.ZodTypeAny, {
                    Subject: string;
                    PlayerCardID: string;
                    PlayerTitleID: string;
                    AccountLevel: number;
                    PreferredLevelBorderID: string;
                    Incognito: boolean;
                    HideAccountLevel: boolean;
                }, {
                    Subject: string;
                    PlayerCardID: string;
                    PlayerTitleID: string;
                    AccountLevel: number;
                    PreferredLevelBorderID: string;
                    Incognito: boolean;
                    HideAccountLevel: boolean;
                }>;
                SeasonalBadgeInfo: zod.ZodNull;
                IsOwner: zod.ZodOptional<zod.ZodBoolean>;
                QueueEligibleRemainingAccountLevels: zod.ZodNumber;
                Pings: zod.ZodArray<zod.ZodObject<{
                    Ping: zod.ZodNumber;
                    GamePodID: zod.ZodString;
                }, "strip", zod.ZodTypeAny, {
                    GamePodID: string;
                    Ping: number;
                }, {
                    GamePodID: string;
                    Ping: number;
                }>, "many">;
                IsReady: zod.ZodBoolean;
                IsModerator: zod.ZodBoolean;
                UseBroadcastHUD: zod.ZodBoolean;
                PlatformType: zod.ZodLiteral<"PC">;
            }, "strip", zod.ZodTypeAny, {
                Subject: string;
                PlayerIdentity: {
                    Subject: string;
                    PlayerCardID: string;
                    PlayerTitleID: string;
                    AccountLevel: number;
                    PreferredLevelBorderID: string;
                    Incognito: boolean;
                    HideAccountLevel: boolean;
                };
                SeasonalBadgeInfo: null;
                CompetitiveTier: number;
                QueueEligibleRemainingAccountLevels: number;
                Pings: {
                    GamePodID: string;
                    Ping: number;
                }[];
                IsReady: boolean;
                IsModerator: boolean;
                UseBroadcastHUD: boolean;
                PlatformType: "PC";
                IsOwner?: boolean | undefined;
            }, {
                Subject: string;
                PlayerIdentity: {
                    Subject: string;
                    PlayerCardID: string;
                    PlayerTitleID: string;
                    AccountLevel: number;
                    PreferredLevelBorderID: string;
                    Incognito: boolean;
                    HideAccountLevel: boolean;
                };
                SeasonalBadgeInfo: null;
                CompetitiveTier: number;
                QueueEligibleRemainingAccountLevels: number;
                Pings: {
                    GamePodID: string;
                    Ping: number;
                }[];
                IsReady: boolean;
                IsModerator: boolean;
                UseBroadcastHUD: boolean;
                PlatformType: "PC";
                IsOwner?: boolean | undefined;
            }>, "many">;
            State: zod.ZodString;
            PreviousState: zod.ZodString;
            StateTransitionReason: zod.ZodString;
            Accessibility: zod.ZodUnion<[zod.ZodLiteral<"OPEN">, zod.ZodLiteral<"CLOSED">]>;
            CustomGameData: zod.ZodObject<{
                Settings: zod.ZodObject<{
                    Map: zod.ZodString;
                    Mode: zod.ZodString;
                    UseBots: zod.ZodBoolean;
                    GamePod: zod.ZodString;
                    GameRules: zod.ZodNullable<zod.ZodObject<{
                        AllowGameModifiers: zod.ZodOptional<zod.ZodEffects<zod.ZodString, boolean, string>>;
                        IsOvertimeWinByTwo: zod.ZodOptional<zod.ZodEffects<zod.ZodString, boolean, string>>;
                        PlayOutAllRounds: zod.ZodOptional<zod.ZodEffects<zod.ZodString, boolean, string>>;
                        SkipMatchHistory: zod.ZodOptional<zod.ZodEffects<zod.ZodString, boolean, string>>;
                        TournamentMode: zod.ZodOptional<zod.ZodEffects<zod.ZodString, boolean, string>>;
                    }, "strip", zod.ZodTypeAny, {
                        AllowGameModifiers?: boolean | undefined;
                        IsOvertimeWinByTwo?: boolean | undefined;
                        PlayOutAllRounds?: boolean | undefined;
                        SkipMatchHistory?: boolean | undefined;
                        TournamentMode?: boolean | undefined;
                    }, {
                        AllowGameModifiers?: string | undefined;
                        IsOvertimeWinByTwo?: string | undefined;
                        PlayOutAllRounds?: string | undefined;
                        SkipMatchHistory?: string | undefined;
                        TournamentMode?: string | undefined;
                    }>>;
                }, "strip", zod.ZodTypeAny, {
                    Mode: string;
                    GameRules: {
                        AllowGameModifiers?: boolean | undefined;
                        IsOvertimeWinByTwo?: boolean | undefined;
                        PlayOutAllRounds?: boolean | undefined;
                        SkipMatchHistory?: boolean | undefined;
                        TournamentMode?: boolean | undefined;
                    } | null;
                    Map: string;
                    UseBots: boolean;
                    GamePod: string;
                }, {
                    Mode: string;
                    GameRules: {
                        AllowGameModifiers?: string | undefined;
                        IsOvertimeWinByTwo?: string | undefined;
                        PlayOutAllRounds?: string | undefined;
                        SkipMatchHistory?: string | undefined;
                        TournamentMode?: string | undefined;
                    } | null;
                    Map: string;
                    UseBots: boolean;
                    GamePod: string;
                }>;
                Membership: zod.ZodObject<{
                    teamOne: zod.ZodNullable<zod.ZodArray<zod.ZodObject<{
                        Subject: zod.ZodString;
                    }, "strip", zod.ZodTypeAny, {
                        Subject: string;
                    }, {
                        Subject: string;
                    }>, "many">>;
                    teamTwo: zod.ZodNullable<zod.ZodArray<zod.ZodObject<{
                        Subject: zod.ZodString;
                    }, "strip", zod.ZodTypeAny, {
                        Subject: string;
                    }, {
                        Subject: string;
                    }>, "many">>;
                    teamSpectate: zod.ZodNullable<zod.ZodArray<zod.ZodObject<{
                        Subject: zod.ZodString;
                    }, "strip", zod.ZodTypeAny, {
                        Subject: string;
                    }, {
                        Subject: string;
                    }>, "many">>;
                    teamOneCoaches: zod.ZodNullable<zod.ZodArray<zod.ZodObject<{
                        Subject: zod.ZodString;
                    }, "strip", zod.ZodTypeAny, {
                        Subject: string;
                    }, {
                        Subject: string;
                    }>, "many">>;
                    teamTwoCoaches: zod.ZodNullable<zod.ZodArray<zod.ZodObject<{
                        Subject: zod.ZodString;
                    }, "strip", zod.ZodTypeAny, {
                        Subject: string;
                    }, {
                        Subject: string;
                    }>, "many">>;
                }, "strip", zod.ZodTypeAny, {
                    teamOne: {
                        Subject: string;
                    }[] | null;
                    teamTwo: {
                        Subject: string;
                    }[] | null;
                    teamSpectate: {
                        Subject: string;
                    }[] | null;
                    teamOneCoaches: {
                        Subject: string;
                    }[] | null;
                    teamTwoCoaches: {
                        Subject: string;
                    }[] | null;
                }, {
                    teamOne: {
                        Subject: string;
                    }[] | null;
                    teamTwo: {
                        Subject: string;
                    }[] | null;
                    teamSpectate: {
                        Subject: string;
                    }[] | null;
                    teamOneCoaches: {
                        Subject: string;
                    }[] | null;
                    teamTwoCoaches: {
                        Subject: string;
                    }[] | null;
                }>;
                MaxPartySize: zod.ZodNumber;
                AutobalanceEnabled: zod.ZodBoolean;
                AutobalanceMinPlayers: zod.ZodNumber;
                HasRecoveryData: zod.ZodBoolean;
            }, "strip", zod.ZodTypeAny, {
                MaxPartySize: number;
                Settings: {
                    Mode: string;
                    GameRules: {
                        AllowGameModifiers?: boolean | undefined;
                        IsOvertimeWinByTwo?: boolean | undefined;
                        PlayOutAllRounds?: boolean | undefined;
                        SkipMatchHistory?: boolean | undefined;
                        TournamentMode?: boolean | undefined;
                    } | null;
                    Map: string;
                    UseBots: boolean;
                    GamePod: string;
                };
                Membership: {
                    teamOne: {
                        Subject: string;
                    }[] | null;
                    teamTwo: {
                        Subject: string;
                    }[] | null;
                    teamSpectate: {
                        Subject: string;
                    }[] | null;
                    teamOneCoaches: {
                        Subject: string;
                    }[] | null;
                    teamTwoCoaches: {
                        Subject: string;
                    }[] | null;
                };
                AutobalanceEnabled: boolean;
                AutobalanceMinPlayers: number;
                HasRecoveryData: boolean;
            }, {
                MaxPartySize: number;
                Settings: {
                    Mode: string;
                    GameRules: {
                        AllowGameModifiers?: string | undefined;
                        IsOvertimeWinByTwo?: string | undefined;
                        PlayOutAllRounds?: string | undefined;
                        SkipMatchHistory?: string | undefined;
                        TournamentMode?: string | undefined;
                    } | null;
                    Map: string;
                    UseBots: boolean;
                    GamePod: string;
                };
                Membership: {
                    teamOne: {
                        Subject: string;
                    }[] | null;
                    teamTwo: {
                        Subject: string;
                    }[] | null;
                    teamSpectate: {
                        Subject: string;
                    }[] | null;
                    teamOneCoaches: {
                        Subject: string;
                    }[] | null;
                    teamTwoCoaches: {
                        Subject: string;
                    }[] | null;
                };
                AutobalanceEnabled: boolean;
                AutobalanceMinPlayers: number;
                HasRecoveryData: boolean;
            }>;
            MatchmakingData: zod.ZodObject<{
                QueueID: zod.ZodString;
                PreferredGamePods: zod.ZodArray<zod.ZodString, "many">;
                SkillDisparityRRPenalty: zod.ZodNumber;
            }, "strip", zod.ZodTypeAny, {
                QueueID: string;
                PreferredGamePods: string[];
                SkillDisparityRRPenalty: number;
            }, {
                QueueID: string;
                PreferredGamePods: string[];
                SkillDisparityRRPenalty: number;
            }>;
            Invites: zod.ZodNull;
            Requests: zod.ZodArray<zod.ZodUnknown, "many">;
            QueueEntryTime: zod.ZodEffects<zod.ZodString, Date, string>;
            ErrorNotification: zod.ZodObject<{
                ErrorType: zod.ZodString;
                ErroredPlayers: zod.ZodNullable<zod.ZodArray<zod.ZodObject<{
                    Subject: zod.ZodString;
                }, "strip", zod.ZodTypeAny, {
                    Subject: string;
                }, {
                    Subject: string;
                }>, "many">>;
            }, "strip", zod.ZodTypeAny, {
                ErrorType: string;
                ErroredPlayers: {
                    Subject: string;
                }[] | null;
            }, {
                ErrorType: string;
                ErroredPlayers: {
                    Subject: string;
                }[] | null;
            }>;
            RestrictedSeconds: zod.ZodNumber;
            EligibleQueues: zod.ZodArray<zod.ZodString, "many">;
            QueueIneligibilities: zod.ZodArray<zod.ZodString, "many">;
            CheatData: zod.ZodObject<{
                GamePodOverride: zod.ZodString;
                ForcePostGameProcessing: zod.ZodBoolean;
            }, "strip", zod.ZodTypeAny, {
                GamePodOverride: string;
                ForcePostGameProcessing: boolean;
            }, {
                GamePodOverride: string;
                ForcePostGameProcessing: boolean;
            }>;
            XPBonuses: zod.ZodArray<zod.ZodUnknown, "many">;
            InviteCode: zod.ZodString;
        }, "strip", zod.ZodTypeAny, {
            ID: string;
            Version: number;
            Invites: null;
            Requests: unknown[];
            State: string;
            MatchmakingData: {
                QueueID: string;
                PreferredGamePods: string[];
                SkillDisparityRRPenalty: number;
            };
            MUCName: string;
            VoiceRoomID: string;
            ClientVersion: string;
            Members: {
                Subject: string;
                PlayerIdentity: {
                    Subject: string;
                    PlayerCardID: string;
                    PlayerTitleID: string;
                    AccountLevel: number;
                    PreferredLevelBorderID: string;
                    Incognito: boolean;
                    HideAccountLevel: boolean;
                };
                SeasonalBadgeInfo: null;
                CompetitiveTier: number;
                QueueEligibleRemainingAccountLevels: number;
                Pings: {
                    GamePodID: string;
                    Ping: number;
                }[];
                IsReady: boolean;
                IsModerator: boolean;
                UseBroadcastHUD: boolean;
                PlatformType: "PC";
                IsOwner?: boolean | undefined;
            }[];
            PreviousState: string;
            StateTransitionReason: string;
            Accessibility: "OPEN" | "CLOSED";
            CustomGameData: {
                MaxPartySize: number;
                Settings: {
                    Mode: string;
                    GameRules: {
                        AllowGameModifiers?: boolean | undefined;
                        IsOvertimeWinByTwo?: boolean | undefined;
                        PlayOutAllRounds?: boolean | undefined;
                        SkipMatchHistory?: boolean | undefined;
                        TournamentMode?: boolean | undefined;
                    } | null;
                    Map: string;
                    UseBots: boolean;
                    GamePod: string;
                };
                Membership: {
                    teamOne: {
                        Subject: string;
                    }[] | null;
                    teamTwo: {
                        Subject: string;
                    }[] | null;
                    teamSpectate: {
                        Subject: string;
                    }[] | null;
                    teamOneCoaches: {
                        Subject: string;
                    }[] | null;
                    teamTwoCoaches: {
                        Subject: string;
                    }[] | null;
                };
                AutobalanceEnabled: boolean;
                AutobalanceMinPlayers: number;
                HasRecoveryData: boolean;
            };
            QueueEntryTime: Date;
            ErrorNotification: {
                ErrorType: string;
                ErroredPlayers: {
                    Subject: string;
                }[] | null;
            };
            RestrictedSeconds: number;
            EligibleQueues: string[];
            QueueIneligibilities: string[];
            CheatData: {
                GamePodOverride: string;
                ForcePostGameProcessing: boolean;
            };
            XPBonuses: unknown[];
            InviteCode: string;
        }, {
            ID: string;
            Version: number;
            Invites: null;
            Requests: unknown[];
            State: string;
            MatchmakingData: {
                QueueID: string;
                PreferredGamePods: string[];
                SkillDisparityRRPenalty: number;
            };
            MUCName: string;
            VoiceRoomID: string;
            ClientVersion: string;
            Members: {
                Subject: string;
                PlayerIdentity: {
                    Subject: string;
                    PlayerCardID: string;
                    PlayerTitleID: string;
                    AccountLevel: number;
                    PreferredLevelBorderID: string;
                    Incognito: boolean;
                    HideAccountLevel: boolean;
                };
                SeasonalBadgeInfo: null;
                CompetitiveTier: number;
                QueueEligibleRemainingAccountLevels: number;
                Pings: {
                    GamePodID: string;
                    Ping: number;
                }[];
                IsReady: boolean;
                IsModerator: boolean;
                UseBroadcastHUD: boolean;
                PlatformType: "PC";
                IsOwner?: boolean | undefined;
            }[];
            PreviousState: string;
            StateTransitionReason: string;
            Accessibility: "OPEN" | "CLOSED";
            CustomGameData: {
                MaxPartySize: number;
                Settings: {
                    Mode: string;
                    GameRules: {
                        AllowGameModifiers?: string | undefined;
                        IsOvertimeWinByTwo?: string | undefined;
                        PlayOutAllRounds?: string | undefined;
                        SkipMatchHistory?: string | undefined;
                        TournamentMode?: string | undefined;
                    } | null;
                    Map: string;
                    UseBots: boolean;
                    GamePod: string;
                };
                Membership: {
                    teamOne: {
                        Subject: string;
                    }[] | null;
                    teamTwo: {
                        Subject: string;
                    }[] | null;
                    teamSpectate: {
                        Subject: string;
                    }[] | null;
                    teamOneCoaches: {
                        Subject: string;
                    }[] | null;
                    teamTwoCoaches: {
                        Subject: string;
                    }[] | null;
                };
                AutobalanceEnabled: boolean;
                AutobalanceMinPlayers: number;
                HasRecoveryData: boolean;
            };
            QueueEntryTime: string;
            ErrorNotification: {
                ErrorType: string;
                ErroredPlayers: {
                    Subject: string;
                }[] | null;
            };
            RestrictedSeconds: number;
            EligibleQueues: string[];
            QueueIneligibilities: string[];
            CheatData: {
                GamePodOverride: string;
                ForcePostGameProcessing: boolean;
            };
            XPBonuses: unknown[];
            InviteCode: string;
        }>;
    };
}, "type" | "name" | "url"> & {
    "~type": {
        readonly name: "Start Custom Game";
        readonly description: "Start a custom game";
        readonly type: "glz";
        readonly method: "POST";
        readonly url: "parties/v1/parties/:partyId/startcustomgame";
        readonly responses: {
            readonly "200": zod.ZodObject<{
                ID: zod.ZodString;
                MUCName: zod.ZodString;
                VoiceRoomID: zod.ZodString;
                Version: zod.ZodNumber;
                ClientVersion: zod.ZodString;
                Members: zod.ZodArray<zod.ZodObject<{
                    Subject: zod.ZodString;
                    CompetitiveTier: zod.ZodNumber;
                    PlayerIdentity: zod.ZodObject<{
                        Subject: zod.ZodString;
                        PlayerCardID: zod.ZodString;
                        PlayerTitleID: zod.ZodString;
                        AccountLevel: zod.ZodNumber;
                        PreferredLevelBorderID: zod.ZodUnion<[zod.ZodString, zod.ZodLiteral<"">]>;
                        Incognito: zod.ZodBoolean;
                        HideAccountLevel: zod.ZodBoolean;
                    }, "strip", zod.ZodTypeAny, {
                        Subject: string;
                        PlayerCardID: string;
                        PlayerTitleID: string;
                        AccountLevel: number;
                        PreferredLevelBorderID: string;
                        Incognito: boolean;
                        HideAccountLevel: boolean;
                    }, {
                        Subject: string;
                        PlayerCardID: string;
                        PlayerTitleID: string;
                        AccountLevel: number;
                        PreferredLevelBorderID: string;
                        Incognito: boolean;
                        HideAccountLevel: boolean;
                    }>;
                    SeasonalBadgeInfo: zod.ZodNull;
                    IsOwner: zod.ZodOptional<zod.ZodBoolean>;
                    QueueEligibleRemainingAccountLevels: zod.ZodNumber;
                    Pings: zod.ZodArray<zod.ZodObject<{
                        Ping: zod.ZodNumber;
                        GamePodID: zod.ZodString;
                    }, "strip", zod.ZodTypeAny, {
                        GamePodID: string;
                        Ping: number;
                    }, {
                        GamePodID: string;
                        Ping: number;
                    }>, "many">;
                    IsReady: zod.ZodBoolean;
                    IsModerator: zod.ZodBoolean;
                    UseBroadcastHUD: zod.ZodBoolean;
                    PlatformType: zod.ZodLiteral<"PC">;
                }, "strip", zod.ZodTypeAny, {
                    Subject: string;
                    PlayerIdentity: {
                        Subject: string;
                        PlayerCardID: string;
                        PlayerTitleID: string;
                        AccountLevel: number;
                        PreferredLevelBorderID: string;
                        Incognito: boolean;
                        HideAccountLevel: boolean;
                    };
                    SeasonalBadgeInfo: null;
                    CompetitiveTier: number;
                    QueueEligibleRemainingAccountLevels: number;
                    Pings: {
                        GamePodID: string;
                        Ping: number;
                    }[];
                    IsReady: boolean;
                    IsModerator: boolean;
                    UseBroadcastHUD: boolean;
                    PlatformType: "PC";
                    IsOwner?: boolean | undefined;
                }, {
                    Subject: string;
                    PlayerIdentity: {
                        Subject: string;
                        PlayerCardID: string;
                        PlayerTitleID: string;
                        AccountLevel: number;
                        PreferredLevelBorderID: string;
                        Incognito: boolean;
                        HideAccountLevel: boolean;
                    };
                    SeasonalBadgeInfo: null;
                    CompetitiveTier: number;
                    QueueEligibleRemainingAccountLevels: number;
                    Pings: {
                        GamePodID: string;
                        Ping: number;
                    }[];
                    IsReady: boolean;
                    IsModerator: boolean;
                    UseBroadcastHUD: boolean;
                    PlatformType: "PC";
                    IsOwner?: boolean | undefined;
                }>, "many">;
                State: zod.ZodString;
                PreviousState: zod.ZodString;
                StateTransitionReason: zod.ZodString;
                Accessibility: zod.ZodUnion<[zod.ZodLiteral<"OPEN">, zod.ZodLiteral<"CLOSED">]>;
                CustomGameData: zod.ZodObject<{
                    Settings: zod.ZodObject<{
                        Map: zod.ZodString;
                        Mode: zod.ZodString;
                        UseBots: zod.ZodBoolean;
                        GamePod: zod.ZodString;
                        GameRules: zod.ZodNullable<zod.ZodObject<{
                            AllowGameModifiers: zod.ZodOptional<zod.ZodEffects<zod.ZodString, boolean, string>>;
                            IsOvertimeWinByTwo: zod.ZodOptional<zod.ZodEffects<zod.ZodString, boolean, string>>;
                            PlayOutAllRounds: zod.ZodOptional<zod.ZodEffects<zod.ZodString, boolean, string>>;
                            SkipMatchHistory: zod.ZodOptional<zod.ZodEffects<zod.ZodString, boolean, string>>;
                            TournamentMode: zod.ZodOptional<zod.ZodEffects<zod.ZodString, boolean, string>>;
                        }, "strip", zod.ZodTypeAny, {
                            AllowGameModifiers?: boolean | undefined;
                            IsOvertimeWinByTwo?: boolean | undefined;
                            PlayOutAllRounds?: boolean | undefined;
                            SkipMatchHistory?: boolean | undefined;
                            TournamentMode?: boolean | undefined;
                        }, {
                            AllowGameModifiers?: string | undefined;
                            IsOvertimeWinByTwo?: string | undefined;
                            PlayOutAllRounds?: string | undefined;
                            SkipMatchHistory?: string | undefined;
                            TournamentMode?: string | undefined;
                        }>>;
                    }, "strip", zod.ZodTypeAny, {
                        Mode: string;
                        GameRules: {
                            AllowGameModifiers?: boolean | undefined;
                            IsOvertimeWinByTwo?: boolean | undefined;
                            PlayOutAllRounds?: boolean | undefined;
                            SkipMatchHistory?: boolean | undefined;
                            TournamentMode?: boolean | undefined;
                        } | null;
                        Map: string;
                        UseBots: boolean;
                        GamePod: string;
                    }, {
                        Mode: string;
                        GameRules: {
                            AllowGameModifiers?: string | undefined;
                            IsOvertimeWinByTwo?: string | undefined;
                            PlayOutAllRounds?: string | undefined;
                            SkipMatchHistory?: string | undefined;
                            TournamentMode?: string | undefined;
                        } | null;
                        Map: string;
                        UseBots: boolean;
                        GamePod: string;
                    }>;
                    Membership: zod.ZodObject<{
                        teamOne: zod.ZodNullable<zod.ZodArray<zod.ZodObject<{
                            Subject: zod.ZodString;
                        }, "strip", zod.ZodTypeAny, {
                            Subject: string;
                        }, {
                            Subject: string;
                        }>, "many">>;
                        teamTwo: zod.ZodNullable<zod.ZodArray<zod.ZodObject<{
                            Subject: zod.ZodString;
                        }, "strip", zod.ZodTypeAny, {
                            Subject: string;
                        }, {
                            Subject: string;
                        }>, "many">>;
                        teamSpectate: zod.ZodNullable<zod.ZodArray<zod.ZodObject<{
                            Subject: zod.ZodString;
                        }, "strip", zod.ZodTypeAny, {
                            Subject: string;
                        }, {
                            Subject: string;
                        }>, "many">>;
                        teamOneCoaches: zod.ZodNullable<zod.ZodArray<zod.ZodObject<{
                            Subject: zod.ZodString;
                        }, "strip", zod.ZodTypeAny, {
                            Subject: string;
                        }, {
                            Subject: string;
                        }>, "many">>;
                        teamTwoCoaches: zod.ZodNullable<zod.ZodArray<zod.ZodObject<{
                            Subject: zod.ZodString;
                        }, "strip", zod.ZodTypeAny, {
                            Subject: string;
                        }, {
                            Subject: string;
                        }>, "many">>;
                    }, "strip", zod.ZodTypeAny, {
                        teamOne: {
                            Subject: string;
                        }[] | null;
                        teamTwo: {
                            Subject: string;
                        }[] | null;
                        teamSpectate: {
                            Subject: string;
                        }[] | null;
                        teamOneCoaches: {
                            Subject: string;
                        }[] | null;
                        teamTwoCoaches: {
                            Subject: string;
                        }[] | null;
                    }, {
                        teamOne: {
                            Subject: string;
                        }[] | null;
                        teamTwo: {
                            Subject: string;
                        }[] | null;
                        teamSpectate: {
                            Subject: string;
                        }[] | null;
                        teamOneCoaches: {
                            Subject: string;
                        }[] | null;
                        teamTwoCoaches: {
                            Subject: string;
                        }[] | null;
                    }>;
                    MaxPartySize: zod.ZodNumber;
                    AutobalanceEnabled: zod.ZodBoolean;
                    AutobalanceMinPlayers: zod.ZodNumber;
                    HasRecoveryData: zod.ZodBoolean;
                }, "strip", zod.ZodTypeAny, {
                    MaxPartySize: number;
                    Settings: {
                        Mode: string;
                        GameRules: {
                            AllowGameModifiers?: boolean | undefined;
                            IsOvertimeWinByTwo?: boolean | undefined;
                            PlayOutAllRounds?: boolean | undefined;
                            SkipMatchHistory?: boolean | undefined;
                            TournamentMode?: boolean | undefined;
                        } | null;
                        Map: string;
                        UseBots: boolean;
                        GamePod: string;
                    };
                    Membership: {
                        teamOne: {
                            Subject: string;
                        }[] | null;
                        teamTwo: {
                            Subject: string;
                        }[] | null;
                        teamSpectate: {
                            Subject: string;
                        }[] | null;
                        teamOneCoaches: {
                            Subject: string;
                        }[] | null;
                        teamTwoCoaches: {
                            Subject: string;
                        }[] | null;
                    };
                    AutobalanceEnabled: boolean;
                    AutobalanceMinPlayers: number;
                    HasRecoveryData: boolean;
                }, {
                    MaxPartySize: number;
                    Settings: {
                        Mode: string;
                        GameRules: {
                            AllowGameModifiers?: string | undefined;
                            IsOvertimeWinByTwo?: string | undefined;
                            PlayOutAllRounds?: string | undefined;
                            SkipMatchHistory?: string | undefined;
                            TournamentMode?: string | undefined;
                        } | null;
                        Map: string;
                        UseBots: boolean;
                        GamePod: string;
                    };
                    Membership: {
                        teamOne: {
                            Subject: string;
                        }[] | null;
                        teamTwo: {
                            Subject: string;
                        }[] | null;
                        teamSpectate: {
                            Subject: string;
                        }[] | null;
                        teamOneCoaches: {
                            Subject: string;
                        }[] | null;
                        teamTwoCoaches: {
                            Subject: string;
                        }[] | null;
                    };
                    AutobalanceEnabled: boolean;
                    AutobalanceMinPlayers: number;
                    HasRecoveryData: boolean;
                }>;
                MatchmakingData: zod.ZodObject<{
                    QueueID: zod.ZodString;
                    PreferredGamePods: zod.ZodArray<zod.ZodString, "many">;
                    SkillDisparityRRPenalty: zod.ZodNumber;
                }, "strip", zod.ZodTypeAny, {
                    QueueID: string;
                    PreferredGamePods: string[];
                    SkillDisparityRRPenalty: number;
                }, {
                    QueueID: string;
                    PreferredGamePods: string[];
                    SkillDisparityRRPenalty: number;
                }>;
                Invites: zod.ZodNull;
                Requests: zod.ZodArray<zod.ZodUnknown, "many">;
                QueueEntryTime: zod.ZodEffects<zod.ZodString, Date, string>;
                ErrorNotification: zod.ZodObject<{
                    ErrorType: zod.ZodString;
                    ErroredPlayers: zod.ZodNullable<zod.ZodArray<zod.ZodObject<{
                        Subject: zod.ZodString;
                    }, "strip", zod.ZodTypeAny, {
                        Subject: string;
                    }, {
                        Subject: string;
                    }>, "many">>;
                }, "strip", zod.ZodTypeAny, {
                    ErrorType: string;
                    ErroredPlayers: {
                        Subject: string;
                    }[] | null;
                }, {
                    ErrorType: string;
                    ErroredPlayers: {
                        Subject: string;
                    }[] | null;
                }>;
                RestrictedSeconds: zod.ZodNumber;
                EligibleQueues: zod.ZodArray<zod.ZodString, "many">;
                QueueIneligibilities: zod.ZodArray<zod.ZodString, "many">;
                CheatData: zod.ZodObject<{
                    GamePodOverride: zod.ZodString;
                    ForcePostGameProcessing: zod.ZodBoolean;
                }, "strip", zod.ZodTypeAny, {
                    GamePodOverride: string;
                    ForcePostGameProcessing: boolean;
                }, {
                    GamePodOverride: string;
                    ForcePostGameProcessing: boolean;
                }>;
                XPBonuses: zod.ZodArray<zod.ZodUnknown, "many">;
                InviteCode: zod.ZodString;
            }, "strip", zod.ZodTypeAny, {
                ID: string;
                Version: number;
                Invites: null;
                Requests: unknown[];
                State: string;
                MatchmakingData: {
                    QueueID: string;
                    PreferredGamePods: string[];
                    SkillDisparityRRPenalty: number;
                };
                MUCName: string;
                VoiceRoomID: string;
                ClientVersion: string;
                Members: {
                    Subject: string;
                    PlayerIdentity: {
                        Subject: string;
                        PlayerCardID: string;
                        PlayerTitleID: string;
                        AccountLevel: number;
                        PreferredLevelBorderID: string;
                        Incognito: boolean;
                        HideAccountLevel: boolean;
                    };
                    SeasonalBadgeInfo: null;
                    CompetitiveTier: number;
                    QueueEligibleRemainingAccountLevels: number;
                    Pings: {
                        GamePodID: string;
                        Ping: number;
                    }[];
                    IsReady: boolean;
                    IsModerator: boolean;
                    UseBroadcastHUD: boolean;
                    PlatformType: "PC";
                    IsOwner?: boolean | undefined;
                }[];
                PreviousState: string;
                StateTransitionReason: string;
                Accessibility: "OPEN" | "CLOSED";
                CustomGameData: {
                    MaxPartySize: number;
                    Settings: {
                        Mode: string;
                        GameRules: {
                            AllowGameModifiers?: boolean | undefined;
                            IsOvertimeWinByTwo?: boolean | undefined;
                            PlayOutAllRounds?: boolean | undefined;
                            SkipMatchHistory?: boolean | undefined;
                            TournamentMode?: boolean | undefined;
                        } | null;
                        Map: string;
                        UseBots: boolean;
                        GamePod: string;
                    };
                    Membership: {
                        teamOne: {
                            Subject: string;
                        }[] | null;
                        teamTwo: {
                            Subject: string;
                        }[] | null;
                        teamSpectate: {
                            Subject: string;
                        }[] | null;
                        teamOneCoaches: {
                            Subject: string;
                        }[] | null;
                        teamTwoCoaches: {
                            Subject: string;
                        }[] | null;
                    };
                    AutobalanceEnabled: boolean;
                    AutobalanceMinPlayers: number;
                    HasRecoveryData: boolean;
                };
                QueueEntryTime: Date;
                ErrorNotification: {
                    ErrorType: string;
                    ErroredPlayers: {
                        Subject: string;
                    }[] | null;
                };
                RestrictedSeconds: number;
                EligibleQueues: string[];
                QueueIneligibilities: string[];
                CheatData: {
                    GamePodOverride: string;
                    ForcePostGameProcessing: boolean;
                };
                XPBonuses: unknown[];
                InviteCode: string;
            }, {
                ID: string;
                Version: number;
                Invites: null;
                Requests: unknown[];
                State: string;
                MatchmakingData: {
                    QueueID: string;
                    PreferredGamePods: string[];
                    SkillDisparityRRPenalty: number;
                };
                MUCName: string;
                VoiceRoomID: string;
                ClientVersion: string;
                Members: {
                    Subject: string;
                    PlayerIdentity: {
                        Subject: string;
                        PlayerCardID: string;
                        PlayerTitleID: string;
                        AccountLevel: number;
                        PreferredLevelBorderID: string;
                        Incognito: boolean;
                        HideAccountLevel: boolean;
                    };
                    SeasonalBadgeInfo: null;
                    CompetitiveTier: number;
                    QueueEligibleRemainingAccountLevels: number;
                    Pings: {
                        GamePodID: string;
                        Ping: number;
                    }[];
                    IsReady: boolean;
                    IsModerator: boolean;
                    UseBroadcastHUD: boolean;
                    PlatformType: "PC";
                    IsOwner?: boolean | undefined;
                }[];
                PreviousState: string;
                StateTransitionReason: string;
                Accessibility: "OPEN" | "CLOSED";
                CustomGameData: {
                    MaxPartySize: number;
                    Settings: {
                        Mode: string;
                        GameRules: {
                            AllowGameModifiers?: string | undefined;
                            IsOvertimeWinByTwo?: string | undefined;
                            PlayOutAllRounds?: string | undefined;
                            SkipMatchHistory?: string | undefined;
                            TournamentMode?: string | undefined;
                        } | null;
                        Map: string;
                        UseBots: boolean;
                        GamePod: string;
                    };
                    Membership: {
                        teamOne: {
                            Subject: string;
                        }[] | null;
                        teamTwo: {
                            Subject: string;
                        }[] | null;
                        teamSpectate: {
                            Subject: string;
                        }[] | null;
                        teamOneCoaches: {
                            Subject: string;
                        }[] | null;
                        teamTwoCoaches: {
                            Subject: string;
                        }[] | null;
                    };
                    AutobalanceEnabled: boolean;
                    AutobalanceMinPlayers: number;
                    HasRecoveryData: boolean;
                };
                QueueEntryTime: string;
                ErrorNotification: {
                    ErrorType: string;
                    ErroredPlayers: {
                        Subject: string;
                    }[] | null;
                };
                RestrictedSeconds: number;
                EligibleQueues: string[];
                QueueIneligibilities: string[];
                CheatData: {
                    GamePodOverride: string;
                    ForcePostGameProcessing: boolean;
                };
                XPBonuses: unknown[];
                InviteCode: string;
            }>;
        };
    };
};

type Params = ResolveParams<(typeof _default)["~type"]["url"]>;
type Body = z.infer<ResolveValue<(typeof _default)["~type"], "body">>;
type Data = ResolveData<Params, Body>;
type Response = z.infer<ResolveValue<(typeof _default)["~type"], "responses">["200"]>;
interface StartCustomGameRequestConfig extends ValorantAxiosRequestConfig<Data> {
}
declare class StartCustomGameEndpoint {
    /**
     * Start a custom game
     *
     * @EndpointType glz
     */
    postStartCustomGame<T = Response>(this: RemoteApiClient, config: StartCustomGameRequestConfig): Promise<AxiosResponse<T>>;
}

declare class RemoteApiEndpoints {
}
interface RemoteApiEndpoints extends FetchContentEndpoint, AccountXpEndpoint, ActivateContractEndpoint, CompetitiveUpdatesEndpoint, ConfigEndpoint, ContractsEndpoint, ItemUpgradesEndpoint, MatchDetailsEndpoint, MatchHistoryEndpoint, OwnedItemsEndpoint, PricesEndpoint, StorefrontEndpoint, WalletEndpoint, ChangeQueueEndpoint, CurrentGameLoadoutsEndpoint, CurrentGameMatchEndpoint, CurrentGamePlayerEndpoint, CurrentGameQuitEndpoint, CustomGameConfigsEndpoint, EnterMatchmakingQueueEndpoint, LeaveMatchmakingQueueEndpoint, LockCharacterEndpoint, PartyChatTokenEndpoint, PartyDeclineEndpoint, PartyDisableCodeEndpoint, PartyGenerateCodeEndpoint, PartyInviteEndpoint, PartyJoinByCodeEndpoint, PartyPlayerEndpoint, PartyRemovePlayerEndpoint, PartyRequestEndpoint, PartySetMemberReadyEndpoint, PartyVoiceTokenEndpoint, PartyEndpoint, PreGameLoadoutsEndpoint, PreGameMatchEndpoint, PreGamePlayerEndpoint, PreGameQuitEndpoint, RefreshCompetitiveTierEndpoint, RefreshPingsEndpoint, RefreshPlayerIdentityEndpoint, SelectCharacterEndpoint, SetCustomGameSettingsEndpoint, SetPartyAccessibilityEndpoint, StartCustomGameEndpoint {
}

declare const remoteApiClientOptionsSchema: z.ZodObject<{
    shard: z.ZodString;
    region: z.ZodString;
    accessToken: z.ZodString;
    entitlementsToken: z.ZodString;
    clientVersion: z.ZodString;
    userAgent: z.ZodDefault<z.ZodString>;
    platformInfo: z.ZodDefault<z.ZodObject<{
        platformType: z.ZodLiteral<"PC">;
        platformOS: z.ZodLiteral<"Windows">;
        platformOSVersion: z.ZodString;
        platformChipset: z.ZodLiteral<"Unknown">;
    }, "strip", z.ZodTypeAny, {
        platformType: "PC";
        platformOS: "Windows";
        platformOSVersion: string;
        platformChipset: "Unknown";
    }, {
        platformType: "PC";
        platformOS: "Windows";
        platformOSVersion: string;
        platformChipset: "Unknown";
    }>>;
}, "strip", z.ZodTypeAny, {
    clientVersion: string;
    region: string;
    shard: string;
    accessToken: string;
    entitlementsToken: string;
    userAgent: string;
    platformInfo: {
        platformType: "PC";
        platformOS: "Windows";
        platformOSVersion: string;
        platformChipset: "Unknown";
    };
}, {
    clientVersion: string;
    region: string;
    shard: string;
    accessToken: string;
    entitlementsToken: string;
    userAgent?: string | undefined;
    platformInfo?: {
        platformType: "PC";
        platformOS: "Windows";
        platformOSVersion: string;
        platformChipset: "Unknown";
    } | undefined;
}>;
type RemoteApiClientOptions = z.input<typeof remoteApiClientOptionsSchema>;
declare function createRemoteApiClient(options: RemoteApiClientOptions): RemoteApiClient;
declare class RemoteApiClient {
    #private;
    constructor(options: RemoteApiClientOptions);
    reinit(options: RemoteApiClientOptions): void;
    get puuid(): string;
    get axios(): AxiosInstance;
    get options(): {
        clientVersion: string;
        region: string;
        shard: string;
        accessToken: string;
        entitlementsToken: string;
        userAgent: string;
        platformInfo: {
            platformType: "PC";
            platformOS: "Windows";
            platformOSVersion: string;
            platformChipset: "Unknown";
        };
    };
    getServerUrl(type: RemoteServerType): string;
    request<T = any>(type: RemoteServerType, url: string, config?: AxiosRequestConfig): Promise<AxiosResponse<T>>;
    ["~request"]<T extends Pick<ValorantEndpoint & {
        type: RemoteServerType;
    }, "url" | "headers" | "type"> & {
        method?: string;
    }, TConfig extends AxiosRequestConfig>(endpoint: T, config: TConfig): Promise<AxiosResponse<any, any>>;
}
interface RemoteApiClient extends RemoteApiEndpoints {
}

type MaybePromise<T> = T | Promise<T>;

type ClientOptionsMap = {
    auth: {
        client: AuthApiClient;
        options: AuthApiClientOptions;
    };
    local: {
        client: LocalApiClient;
        options: LocalApiClientOptions;
    };
    remote: {
        client: RemoteApiClient;
        options: RemoteApiClientOptions;
    };
};
type VapicProvider<ReturnType = unknown> = (ctx: ValorantApiClient) => MaybePromise<ReturnType>;
type VapicOptions = {
    [client in keyof ClientOptionsMap]?: ClientOptionsMap[client]["options"];
};
type VapicOptionsWithProviders = {
    [type in keyof ClientOptionsMap]?: ClientOptionsMap[type] extends {
        options: infer O;
    } ? VapicProvider<O> | O : ClientOptionsMap[type]["options"];
};

declare const CLIENT_RESOLUTION_ORDER: readonly ["auth", "local", "remote"];
declare function createValorantApiClient<Options extends VapicOptionsWithProviders>(options: Options): Promise<ValorantApiClient>;
declare class ValorantApiClient {
    #private;
    constructor(options?: VapicOptions);
    static init(options: VapicOptionsWithProviders): Promise<ValorantApiClient>;
    reinit(options: VapicOptionsWithProviders): Promise<this>;
    reinitSync(options: VapicOptions): this;
    get auth(): AuthApiClient;
    get local(): LocalApiClient;
    get remote(): RemoteApiClient;
}

declare const presets: {
    local: {
        auth: (ctx: ValorantApiClient) => Promise<{
            clientVersion: string;
            rsoUserAgent: string;
        }>;
        local: (ctx: ValorantApiClient) => Promise<{
            user: string;
            pid: string;
            port: string;
            password: string;
            protocol: string;
        }>;
        remote: (ctx: ValorantApiClient) => Promise<{
            region: string;
            shard: string;
            clientVersion: string;
            servers: {
                glz: string;
                pd: string;
                shared: string;
            };
            accessToken: string;
            entitlementsToken: string;
        }>;
    };
};

declare const LOCK_FILE_PATH: string;
declare const lockfileSchema: z.ZodObject<{
    user: z.ZodString;
    pid: z.ZodString;
    port: z.ZodString;
    password: z.ZodString;
    protocol: z.ZodString;
}, "strip", z.ZodTypeAny, {
    user: string;
    pid: string;
    port: string;
    password: string;
    protocol: string;
}, {
    user: string;
    pid: string;
    port: string;
    password: string;
    protocol: string;
}>;
type LockFileData = z.output<typeof lockfileSchema>;
declare function getLockFileData(path?: string): Promise<LockFileData>;

declare const LOG_FILE_PATH: string;
type LogfileData = {
    clientVersion: string;
    servers: {
        glz: string;
        pd: string;
        shared: string;
    };
};
declare function getLogFileData(path?: string): Promise<LogfileData>;

declare function fetchPas(accessToken: string, idToken: string): Promise<{
    token: string;
    affinities: {
        pbe: string;
        live: string;
    };
}>;
declare const getRsoUserAgent: (clientBuild: string) => string;
declare function fetchClientVersionFromVAPI(): Promise<string>;

declare const platformSchema: z.ZodObject<{
    platformType: z.ZodLiteral<"PC">;
    platformOS: z.ZodLiteral<"Windows">;
    platformOSVersion: z.ZodString;
    platformChipset: z.ZodLiteral<"Unknown">;
}, "strip", z.ZodTypeAny, {
    platformType: "PC";
    platformOS: "Windows";
    platformOSVersion: string;
    platformChipset: "Unknown";
}, {
    platformType: "PC";
    platformOS: "Windows";
    platformOSVersion: string;
    platformChipset: "Unknown";
}>;
declare const partySchema: z.ZodObject<{
    ID: z.ZodString;
    MUCName: z.ZodString;
    VoiceRoomID: z.ZodString;
    Version: z.ZodNumber;
    ClientVersion: z.ZodString;
    Members: z.ZodArray<z.ZodObject<{
        Subject: z.ZodString;
        CompetitiveTier: z.ZodNumber;
        PlayerIdentity: z.ZodObject<{
            Subject: z.ZodString;
            PlayerCardID: z.ZodString;
            PlayerTitleID: z.ZodString;
            AccountLevel: z.ZodNumber;
            PreferredLevelBorderID: z.ZodUnion<[z.ZodString, z.ZodLiteral<"">]>;
            Incognito: z.ZodBoolean;
            HideAccountLevel: z.ZodBoolean;
        }, "strip", z.ZodTypeAny, {
            Subject: string;
            PlayerCardID: string;
            PlayerTitleID: string;
            AccountLevel: number;
            PreferredLevelBorderID: string;
            Incognito: boolean;
            HideAccountLevel: boolean;
        }, {
            Subject: string;
            PlayerCardID: string;
            PlayerTitleID: string;
            AccountLevel: number;
            PreferredLevelBorderID: string;
            Incognito: boolean;
            HideAccountLevel: boolean;
        }>;
        SeasonalBadgeInfo: z.ZodNull;
        IsOwner: z.ZodOptional<z.ZodBoolean>;
        QueueEligibleRemainingAccountLevels: z.ZodNumber;
        Pings: z.ZodArray<z.ZodObject<{
            Ping: z.ZodNumber;
            GamePodID: z.ZodString;
        }, "strip", z.ZodTypeAny, {
            GamePodID: string;
            Ping: number;
        }, {
            GamePodID: string;
            Ping: number;
        }>, "many">;
        IsReady: z.ZodBoolean;
        IsModerator: z.ZodBoolean;
        UseBroadcastHUD: z.ZodBoolean;
        PlatformType: z.ZodLiteral<"PC">;
    }, "strip", z.ZodTypeAny, {
        Subject: string;
        PlayerIdentity: {
            Subject: string;
            PlayerCardID: string;
            PlayerTitleID: string;
            AccountLevel: number;
            PreferredLevelBorderID: string;
            Incognito: boolean;
            HideAccountLevel: boolean;
        };
        SeasonalBadgeInfo: null;
        CompetitiveTier: number;
        QueueEligibleRemainingAccountLevels: number;
        Pings: {
            GamePodID: string;
            Ping: number;
        }[];
        IsReady: boolean;
        IsModerator: boolean;
        UseBroadcastHUD: boolean;
        PlatformType: "PC";
        IsOwner?: boolean | undefined;
    }, {
        Subject: string;
        PlayerIdentity: {
            Subject: string;
            PlayerCardID: string;
            PlayerTitleID: string;
            AccountLevel: number;
            PreferredLevelBorderID: string;
            Incognito: boolean;
            HideAccountLevel: boolean;
        };
        SeasonalBadgeInfo: null;
        CompetitiveTier: number;
        QueueEligibleRemainingAccountLevels: number;
        Pings: {
            GamePodID: string;
            Ping: number;
        }[];
        IsReady: boolean;
        IsModerator: boolean;
        UseBroadcastHUD: boolean;
        PlatformType: "PC";
        IsOwner?: boolean | undefined;
    }>, "many">;
    State: z.ZodString;
    PreviousState: z.ZodString;
    StateTransitionReason: z.ZodString;
    Accessibility: z.ZodUnion<[z.ZodLiteral<"OPEN">, z.ZodLiteral<"CLOSED">]>;
    CustomGameData: z.ZodObject<{
        Settings: z.ZodObject<{
            Map: z.ZodString;
            Mode: z.ZodString;
            UseBots: z.ZodBoolean;
            GamePod: z.ZodString;
            GameRules: z.ZodNullable<z.ZodObject<{
                AllowGameModifiers: z.ZodOptional<z.ZodEffects<z.ZodString, boolean, string>>;
                IsOvertimeWinByTwo: z.ZodOptional<z.ZodEffects<z.ZodString, boolean, string>>;
                PlayOutAllRounds: z.ZodOptional<z.ZodEffects<z.ZodString, boolean, string>>;
                SkipMatchHistory: z.ZodOptional<z.ZodEffects<z.ZodString, boolean, string>>;
                TournamentMode: z.ZodOptional<z.ZodEffects<z.ZodString, boolean, string>>;
            }, "strip", z.ZodTypeAny, {
                AllowGameModifiers?: boolean | undefined;
                IsOvertimeWinByTwo?: boolean | undefined;
                PlayOutAllRounds?: boolean | undefined;
                SkipMatchHistory?: boolean | undefined;
                TournamentMode?: boolean | undefined;
            }, {
                AllowGameModifiers?: string | undefined;
                IsOvertimeWinByTwo?: string | undefined;
                PlayOutAllRounds?: string | undefined;
                SkipMatchHistory?: string | undefined;
                TournamentMode?: string | undefined;
            }>>;
        }, "strip", z.ZodTypeAny, {
            Mode: string;
            GameRules: {
                AllowGameModifiers?: boolean | undefined;
                IsOvertimeWinByTwo?: boolean | undefined;
                PlayOutAllRounds?: boolean | undefined;
                SkipMatchHistory?: boolean | undefined;
                TournamentMode?: boolean | undefined;
            } | null;
            Map: string;
            UseBots: boolean;
            GamePod: string;
        }, {
            Mode: string;
            GameRules: {
                AllowGameModifiers?: string | undefined;
                IsOvertimeWinByTwo?: string | undefined;
                PlayOutAllRounds?: string | undefined;
                SkipMatchHistory?: string | undefined;
                TournamentMode?: string | undefined;
            } | null;
            Map: string;
            UseBots: boolean;
            GamePod: string;
        }>;
        Membership: z.ZodObject<{
            teamOne: z.ZodNullable<z.ZodArray<z.ZodObject<{
                Subject: z.ZodString;
            }, "strip", z.ZodTypeAny, {
                Subject: string;
            }, {
                Subject: string;
            }>, "many">>;
            teamTwo: z.ZodNullable<z.ZodArray<z.ZodObject<{
                Subject: z.ZodString;
            }, "strip", z.ZodTypeAny, {
                Subject: string;
            }, {
                Subject: string;
            }>, "many">>;
            teamSpectate: z.ZodNullable<z.ZodArray<z.ZodObject<{
                Subject: z.ZodString;
            }, "strip", z.ZodTypeAny, {
                Subject: string;
            }, {
                Subject: string;
            }>, "many">>;
            teamOneCoaches: z.ZodNullable<z.ZodArray<z.ZodObject<{
                Subject: z.ZodString;
            }, "strip", z.ZodTypeAny, {
                Subject: string;
            }, {
                Subject: string;
            }>, "many">>;
            teamTwoCoaches: z.ZodNullable<z.ZodArray<z.ZodObject<{
                Subject: z.ZodString;
            }, "strip", z.ZodTypeAny, {
                Subject: string;
            }, {
                Subject: string;
            }>, "many">>;
        }, "strip", z.ZodTypeAny, {
            teamOne: {
                Subject: string;
            }[] | null;
            teamTwo: {
                Subject: string;
            }[] | null;
            teamSpectate: {
                Subject: string;
            }[] | null;
            teamOneCoaches: {
                Subject: string;
            }[] | null;
            teamTwoCoaches: {
                Subject: string;
            }[] | null;
        }, {
            teamOne: {
                Subject: string;
            }[] | null;
            teamTwo: {
                Subject: string;
            }[] | null;
            teamSpectate: {
                Subject: string;
            }[] | null;
            teamOneCoaches: {
                Subject: string;
            }[] | null;
            teamTwoCoaches: {
                Subject: string;
            }[] | null;
        }>;
        MaxPartySize: z.ZodNumber;
        AutobalanceEnabled: z.ZodBoolean;
        AutobalanceMinPlayers: z.ZodNumber;
        HasRecoveryData: z.ZodBoolean;
    }, "strip", z.ZodTypeAny, {
        MaxPartySize: number;
        Settings: {
            Mode: string;
            GameRules: {
                AllowGameModifiers?: boolean | undefined;
                IsOvertimeWinByTwo?: boolean | undefined;
                PlayOutAllRounds?: boolean | undefined;
                SkipMatchHistory?: boolean | undefined;
                TournamentMode?: boolean | undefined;
            } | null;
            Map: string;
            UseBots: boolean;
            GamePod: string;
        };
        Membership: {
            teamOne: {
                Subject: string;
            }[] | null;
            teamTwo: {
                Subject: string;
            }[] | null;
            teamSpectate: {
                Subject: string;
            }[] | null;
            teamOneCoaches: {
                Subject: string;
            }[] | null;
            teamTwoCoaches: {
                Subject: string;
            }[] | null;
        };
        AutobalanceEnabled: boolean;
        AutobalanceMinPlayers: number;
        HasRecoveryData: boolean;
    }, {
        MaxPartySize: number;
        Settings: {
            Mode: string;
            GameRules: {
                AllowGameModifiers?: string | undefined;
                IsOvertimeWinByTwo?: string | undefined;
                PlayOutAllRounds?: string | undefined;
                SkipMatchHistory?: string | undefined;
                TournamentMode?: string | undefined;
            } | null;
            Map: string;
            UseBots: boolean;
            GamePod: string;
        };
        Membership: {
            teamOne: {
                Subject: string;
            }[] | null;
            teamTwo: {
                Subject: string;
            }[] | null;
            teamSpectate: {
                Subject: string;
            }[] | null;
            teamOneCoaches: {
                Subject: string;
            }[] | null;
            teamTwoCoaches: {
                Subject: string;
            }[] | null;
        };
        AutobalanceEnabled: boolean;
        AutobalanceMinPlayers: number;
        HasRecoveryData: boolean;
    }>;
    MatchmakingData: z.ZodObject<{
        QueueID: z.ZodString;
        PreferredGamePods: z.ZodArray<z.ZodString, "many">;
        SkillDisparityRRPenalty: z.ZodNumber;
    }, "strip", z.ZodTypeAny, {
        QueueID: string;
        PreferredGamePods: string[];
        SkillDisparityRRPenalty: number;
    }, {
        QueueID: string;
        PreferredGamePods: string[];
        SkillDisparityRRPenalty: number;
    }>;
    Invites: z.ZodNull;
    Requests: z.ZodArray<z.ZodUnknown, "many">;
    QueueEntryTime: z.ZodEffects<z.ZodString, Date, string>;
    ErrorNotification: z.ZodObject<{
        ErrorType: z.ZodString;
        ErroredPlayers: z.ZodNullable<z.ZodArray<z.ZodObject<{
            Subject: z.ZodString;
        }, "strip", z.ZodTypeAny, {
            Subject: string;
        }, {
            Subject: string;
        }>, "many">>;
    }, "strip", z.ZodTypeAny, {
        ErrorType: string;
        ErroredPlayers: {
            Subject: string;
        }[] | null;
    }, {
        ErrorType: string;
        ErroredPlayers: {
            Subject: string;
        }[] | null;
    }>;
    RestrictedSeconds: z.ZodNumber;
    EligibleQueues: z.ZodArray<z.ZodString, "many">;
    QueueIneligibilities: z.ZodArray<z.ZodString, "many">;
    CheatData: z.ZodObject<{
        GamePodOverride: z.ZodString;
        ForcePostGameProcessing: z.ZodBoolean;
    }, "strip", z.ZodTypeAny, {
        GamePodOverride: string;
        ForcePostGameProcessing: boolean;
    }, {
        GamePodOverride: string;
        ForcePostGameProcessing: boolean;
    }>;
    XPBonuses: z.ZodArray<z.ZodUnknown, "many">;
    InviteCode: z.ZodString;
}, "strip", z.ZodTypeAny, {
    ID: string;
    Version: number;
    Invites: null;
    Requests: unknown[];
    State: string;
    MatchmakingData: {
        QueueID: string;
        PreferredGamePods: string[];
        SkillDisparityRRPenalty: number;
    };
    MUCName: string;
    VoiceRoomID: string;
    ClientVersion: string;
    Members: {
        Subject: string;
        PlayerIdentity: {
            Subject: string;
            PlayerCardID: string;
            PlayerTitleID: string;
            AccountLevel: number;
            PreferredLevelBorderID: string;
            Incognito: boolean;
            HideAccountLevel: boolean;
        };
        SeasonalBadgeInfo: null;
        CompetitiveTier: number;
        QueueEligibleRemainingAccountLevels: number;
        Pings: {
            GamePodID: string;
            Ping: number;
        }[];
        IsReady: boolean;
        IsModerator: boolean;
        UseBroadcastHUD: boolean;
        PlatformType: "PC";
        IsOwner?: boolean | undefined;
    }[];
    PreviousState: string;
    StateTransitionReason: string;
    Accessibility: "OPEN" | "CLOSED";
    CustomGameData: {
        MaxPartySize: number;
        Settings: {
            Mode: string;
            GameRules: {
                AllowGameModifiers?: boolean | undefined;
                IsOvertimeWinByTwo?: boolean | undefined;
                PlayOutAllRounds?: boolean | undefined;
                SkipMatchHistory?: boolean | undefined;
                TournamentMode?: boolean | undefined;
            } | null;
            Map: string;
            UseBots: boolean;
            GamePod: string;
        };
        Membership: {
            teamOne: {
                Subject: string;
            }[] | null;
            teamTwo: {
                Subject: string;
            }[] | null;
            teamSpectate: {
                Subject: string;
            }[] | null;
            teamOneCoaches: {
                Subject: string;
            }[] | null;
            teamTwoCoaches: {
                Subject: string;
            }[] | null;
        };
        AutobalanceEnabled: boolean;
        AutobalanceMinPlayers: number;
        HasRecoveryData: boolean;
    };
    QueueEntryTime: Date;
    ErrorNotification: {
        ErrorType: string;
        ErroredPlayers: {
            Subject: string;
        }[] | null;
    };
    RestrictedSeconds: number;
    EligibleQueues: string[];
    QueueIneligibilities: string[];
    CheatData: {
        GamePodOverride: string;
        ForcePostGameProcessing: boolean;
    };
    XPBonuses: unknown[];
    InviteCode: string;
}, {
    ID: string;
    Version: number;
    Invites: null;
    Requests: unknown[];
    State: string;
    MatchmakingData: {
        QueueID: string;
        PreferredGamePods: string[];
        SkillDisparityRRPenalty: number;
    };
    MUCName: string;
    VoiceRoomID: string;
    ClientVersion: string;
    Members: {
        Subject: string;
        PlayerIdentity: {
            Subject: string;
            PlayerCardID: string;
            PlayerTitleID: string;
            AccountLevel: number;
            PreferredLevelBorderID: string;
            Incognito: boolean;
            HideAccountLevel: boolean;
        };
        SeasonalBadgeInfo: null;
        CompetitiveTier: number;
        QueueEligibleRemainingAccountLevels: number;
        Pings: {
            GamePodID: string;
            Ping: number;
        }[];
        IsReady: boolean;
        IsModerator: boolean;
        UseBroadcastHUD: boolean;
        PlatformType: "PC";
        IsOwner?: boolean | undefined;
    }[];
    PreviousState: string;
    StateTransitionReason: string;
    Accessibility: "OPEN" | "CLOSED";
    CustomGameData: {
        MaxPartySize: number;
        Settings: {
            Mode: string;
            GameRules: {
                AllowGameModifiers?: string | undefined;
                IsOvertimeWinByTwo?: string | undefined;
                PlayOutAllRounds?: string | undefined;
                SkipMatchHistory?: string | undefined;
                TournamentMode?: string | undefined;
            } | null;
            Map: string;
            UseBots: boolean;
            GamePod: string;
        };
        Membership: {
            teamOne: {
                Subject: string;
            }[] | null;
            teamTwo: {
                Subject: string;
            }[] | null;
            teamSpectate: {
                Subject: string;
            }[] | null;
            teamOneCoaches: {
                Subject: string;
            }[] | null;
            teamTwoCoaches: {
                Subject: string;
            }[] | null;
        };
        AutobalanceEnabled: boolean;
        AutobalanceMinPlayers: number;
        HasRecoveryData: boolean;
    };
    QueueEntryTime: string;
    ErrorNotification: {
        ErrorType: string;
        ErroredPlayers: {
            Subject: string;
        }[] | null;
    };
    RestrictedSeconds: number;
    EligibleQueues: string[];
    QueueIneligibilities: string[];
    CheatData: {
        GamePodOverride: string;
        ForcePostGameProcessing: boolean;
    };
    XPBonuses: unknown[];
    InviteCode: string;
}>;
declare const partyPlayerSchema: z.ZodObject<{
    Subject: z.ZodString;
    Version: z.ZodNumber;
    CurrentPartyID: z.ZodString;
    Invites: z.ZodNull;
    Requests: z.ZodArray<z.ZodObject<{
        ID: z.ZodString;
        PartyID: z.ZodString;
        RequestedBySubject: z.ZodString;
        Subjects: z.ZodArray<z.ZodString, "many">;
        CreatedAt: z.ZodEffects<z.ZodString, Date, string>;
        RefreshedAt: z.ZodEffects<z.ZodString, Date, string>;
        ExpiresIn: z.ZodNumber;
    }, "strip", z.ZodTypeAny, {
        ID: string;
        PartyID: string;
        RequestedBySubject: string;
        Subjects: string[];
        CreatedAt: Date;
        RefreshedAt: Date;
        ExpiresIn: number;
    }, {
        ID: string;
        PartyID: string;
        RequestedBySubject: string;
        Subjects: string[];
        CreatedAt: string;
        RefreshedAt: string;
        ExpiresIn: number;
    }>, "many">;
    PlatformInfo: z.ZodObject<{
        platformType: z.ZodLiteral<"PC">;
        platformOS: z.ZodLiteral<"Windows">;
        platformOSVersion: z.ZodString;
        platformChipset: z.ZodLiteral<"Unknown">;
    }, "strip", z.ZodTypeAny, {
        platformType: "PC";
        platformOS: "Windows";
        platformOSVersion: string;
        platformChipset: "Unknown";
    }, {
        platformType: "PC";
        platformOS: "Windows";
        platformOSVersion: string;
        platformChipset: "Unknown";
    }>;
}, "strip", z.ZodTypeAny, {
    Subject: string;
    Version: number;
    CurrentPartyID: string;
    Invites: null;
    Requests: {
        ID: string;
        PartyID: string;
        RequestedBySubject: string;
        Subjects: string[];
        CreatedAt: Date;
        RefreshedAt: Date;
        ExpiresIn: number;
    }[];
    PlatformInfo: {
        platformType: "PC";
        platformOS: "Windows";
        platformOSVersion: string;
        platformChipset: "Unknown";
    };
}, {
    Subject: string;
    Version: number;
    CurrentPartyID: string;
    Invites: null;
    Requests: {
        ID: string;
        PartyID: string;
        RequestedBySubject: string;
        Subjects: string[];
        CreatedAt: string;
        RefreshedAt: string;
        ExpiresIn: number;
    }[];
    PlatformInfo: {
        platformType: "PC";
        platformOS: "Windows";
        platformOSVersion: string;
        platformChipset: "Unknown";
    };
}>;
declare const pregameMatchSchema: z.ZodObject<{
    ID: z.ZodString;
    Version: z.ZodNumber;
    Teams: z.ZodArray<z.ZodObject<{
        TeamID: z.ZodUnion<[z.ZodEnum<["Blue", "Red"]>, z.ZodString]>;
        Players: z.ZodArray<z.ZodObject<{
            Subject: z.ZodString;
            CharacterID: z.ZodString;
            CharacterSelectionState: z.ZodEnum<["", "selected", "locked"]>;
            PregamePlayerState: z.ZodEnum<["joined"]>;
            CompetitiveTier: z.ZodNumber;
            PlayerIdentity: z.ZodObject<{
                Subject: z.ZodString;
                PlayerCardID: z.ZodString;
                PlayerTitleID: z.ZodString;
                AccountLevel: z.ZodNumber;
                PreferredLevelBorderID: z.ZodUnion<[z.ZodString, z.ZodLiteral<"">]>;
                Incognito: z.ZodBoolean;
                HideAccountLevel: z.ZodBoolean;
            }, "strip", z.ZodTypeAny, {
                Subject: string;
                PlayerCardID: string;
                PlayerTitleID: string;
                AccountLevel: number;
                PreferredLevelBorderID: string;
                Incognito: boolean;
                HideAccountLevel: boolean;
            }, {
                Subject: string;
                PlayerCardID: string;
                PlayerTitleID: string;
                AccountLevel: number;
                PreferredLevelBorderID: string;
                Incognito: boolean;
                HideAccountLevel: boolean;
            }>;
            SeasonalBadgeInfo: z.ZodObject<{
                SeasonID: z.ZodUnion<[z.ZodString, z.ZodLiteral<"">]>;
                NumberOfWins: z.ZodNumber;
                WinsByTier: z.ZodNull;
                Rank: z.ZodNumber;
                LeaderboardRank: z.ZodNumber;
            }, "strip", z.ZodTypeAny, {
                SeasonID: string;
                NumberOfWins: number;
                WinsByTier: null;
                Rank: number;
                LeaderboardRank: number;
            }, {
                SeasonID: string;
                NumberOfWins: number;
                WinsByTier: null;
                Rank: number;
                LeaderboardRank: number;
            }>;
            IsCaptain: z.ZodBoolean;
        }, "strip", z.ZodTypeAny, {
            CharacterID: string;
            Subject: string;
            PlayerIdentity: {
                Subject: string;
                PlayerCardID: string;
                PlayerTitleID: string;
                AccountLevel: number;
                PreferredLevelBorderID: string;
                Incognito: boolean;
                HideAccountLevel: boolean;
            };
            SeasonalBadgeInfo: {
                SeasonID: string;
                NumberOfWins: number;
                WinsByTier: null;
                Rank: number;
                LeaderboardRank: number;
            };
            CompetitiveTier: number;
            CharacterSelectionState: "" | "selected" | "locked";
            PregamePlayerState: "joined";
            IsCaptain: boolean;
        }, {
            CharacterID: string;
            Subject: string;
            PlayerIdentity: {
                Subject: string;
                PlayerCardID: string;
                PlayerTitleID: string;
                AccountLevel: number;
                PreferredLevelBorderID: string;
                Incognito: boolean;
                HideAccountLevel: boolean;
            };
            SeasonalBadgeInfo: {
                SeasonID: string;
                NumberOfWins: number;
                WinsByTier: null;
                Rank: number;
                LeaderboardRank: number;
            };
            CompetitiveTier: number;
            CharacterSelectionState: "" | "selected" | "locked";
            PregamePlayerState: "joined";
            IsCaptain: boolean;
        }>, "many">;
    }, "strip", z.ZodTypeAny, {
        Players: {
            CharacterID: string;
            Subject: string;
            PlayerIdentity: {
                Subject: string;
                PlayerCardID: string;
                PlayerTitleID: string;
                AccountLevel: number;
                PreferredLevelBorderID: string;
                Incognito: boolean;
                HideAccountLevel: boolean;
            };
            SeasonalBadgeInfo: {
                SeasonID: string;
                NumberOfWins: number;
                WinsByTier: null;
                Rank: number;
                LeaderboardRank: number;
            };
            CompetitiveTier: number;
            CharacterSelectionState: "" | "selected" | "locked";
            PregamePlayerState: "joined";
            IsCaptain: boolean;
        }[];
        TeamID: string;
    }, {
        Players: {
            CharacterID: string;
            Subject: string;
            PlayerIdentity: {
                Subject: string;
                PlayerCardID: string;
                PlayerTitleID: string;
                AccountLevel: number;
                PreferredLevelBorderID: string;
                Incognito: boolean;
                HideAccountLevel: boolean;
            };
            SeasonalBadgeInfo: {
                SeasonID: string;
                NumberOfWins: number;
                WinsByTier: null;
                Rank: number;
                LeaderboardRank: number;
            };
            CompetitiveTier: number;
            CharacterSelectionState: "" | "selected" | "locked";
            PregamePlayerState: "joined";
            IsCaptain: boolean;
        }[];
        TeamID: string;
    }>, "many">;
    AllyTeam: z.ZodNullable<z.ZodObject<{
        TeamID: z.ZodUnion<[z.ZodEnum<["Blue", "Red"]>, z.ZodString]>;
        Players: z.ZodArray<z.ZodObject<{
            Subject: z.ZodString;
            CharacterID: z.ZodString;
            CharacterSelectionState: z.ZodEnum<["", "selected", "locked"]>;
            PregamePlayerState: z.ZodEnum<["joined"]>;
            CompetitiveTier: z.ZodNumber;
            PlayerIdentity: z.ZodObject<{
                Subject: z.ZodString;
                PlayerCardID: z.ZodString;
                PlayerTitleID: z.ZodString;
                AccountLevel: z.ZodNumber;
                PreferredLevelBorderID: z.ZodUnion<[z.ZodString, z.ZodLiteral<"">]>;
                Incognito: z.ZodBoolean;
                HideAccountLevel: z.ZodBoolean;
            }, "strip", z.ZodTypeAny, {
                Subject: string;
                PlayerCardID: string;
                PlayerTitleID: string;
                AccountLevel: number;
                PreferredLevelBorderID: string;
                Incognito: boolean;
                HideAccountLevel: boolean;
            }, {
                Subject: string;
                PlayerCardID: string;
                PlayerTitleID: string;
                AccountLevel: number;
                PreferredLevelBorderID: string;
                Incognito: boolean;
                HideAccountLevel: boolean;
            }>;
            SeasonalBadgeInfo: z.ZodObject<{
                SeasonID: z.ZodUnion<[z.ZodString, z.ZodLiteral<"">]>;
                NumberOfWins: z.ZodNumber;
                WinsByTier: z.ZodNull;
                Rank: z.ZodNumber;
                LeaderboardRank: z.ZodNumber;
            }, "strip", z.ZodTypeAny, {
                SeasonID: string;
                NumberOfWins: number;
                WinsByTier: null;
                Rank: number;
                LeaderboardRank: number;
            }, {
                SeasonID: string;
                NumberOfWins: number;
                WinsByTier: null;
                Rank: number;
                LeaderboardRank: number;
            }>;
            IsCaptain: z.ZodBoolean;
        }, "strip", z.ZodTypeAny, {
            CharacterID: string;
            Subject: string;
            PlayerIdentity: {
                Subject: string;
                PlayerCardID: string;
                PlayerTitleID: string;
                AccountLevel: number;
                PreferredLevelBorderID: string;
                Incognito: boolean;
                HideAccountLevel: boolean;
            };
            SeasonalBadgeInfo: {
                SeasonID: string;
                NumberOfWins: number;
                WinsByTier: null;
                Rank: number;
                LeaderboardRank: number;
            };
            CompetitiveTier: number;
            CharacterSelectionState: "" | "selected" | "locked";
            PregamePlayerState: "joined";
            IsCaptain: boolean;
        }, {
            CharacterID: string;
            Subject: string;
            PlayerIdentity: {
                Subject: string;
                PlayerCardID: string;
                PlayerTitleID: string;
                AccountLevel: number;
                PreferredLevelBorderID: string;
                Incognito: boolean;
                HideAccountLevel: boolean;
            };
            SeasonalBadgeInfo: {
                SeasonID: string;
                NumberOfWins: number;
                WinsByTier: null;
                Rank: number;
                LeaderboardRank: number;
            };
            CompetitiveTier: number;
            CharacterSelectionState: "" | "selected" | "locked";
            PregamePlayerState: "joined";
            IsCaptain: boolean;
        }>, "many">;
    }, "strip", z.ZodTypeAny, {
        Players: {
            CharacterID: string;
            Subject: string;
            PlayerIdentity: {
                Subject: string;
                PlayerCardID: string;
                PlayerTitleID: string;
                AccountLevel: number;
                PreferredLevelBorderID: string;
                Incognito: boolean;
                HideAccountLevel: boolean;
            };
            SeasonalBadgeInfo: {
                SeasonID: string;
                NumberOfWins: number;
                WinsByTier: null;
                Rank: number;
                LeaderboardRank: number;
            };
            CompetitiveTier: number;
            CharacterSelectionState: "" | "selected" | "locked";
            PregamePlayerState: "joined";
            IsCaptain: boolean;
        }[];
        TeamID: string;
    }, {
        Players: {
            CharacterID: string;
            Subject: string;
            PlayerIdentity: {
                Subject: string;
                PlayerCardID: string;
                PlayerTitleID: string;
                AccountLevel: number;
                PreferredLevelBorderID: string;
                Incognito: boolean;
                HideAccountLevel: boolean;
            };
            SeasonalBadgeInfo: {
                SeasonID: string;
                NumberOfWins: number;
                WinsByTier: null;
                Rank: number;
                LeaderboardRank: number;
            };
            CompetitiveTier: number;
            CharacterSelectionState: "" | "selected" | "locked";
            PregamePlayerState: "joined";
            IsCaptain: boolean;
        }[];
        TeamID: string;
    }>>;
    EnemyTeam: z.ZodNullable<z.ZodObject<{
        TeamID: z.ZodUnion<[z.ZodEnum<["Blue", "Red"]>, z.ZodString]>;
        Players: z.ZodArray<z.ZodObject<{
            Subject: z.ZodString;
            CharacterID: z.ZodString;
            CharacterSelectionState: z.ZodEnum<["", "selected", "locked"]>;
            PregamePlayerState: z.ZodEnum<["joined"]>;
            CompetitiveTier: z.ZodNumber;
            PlayerIdentity: z.ZodObject<{
                Subject: z.ZodString;
                PlayerCardID: z.ZodString;
                PlayerTitleID: z.ZodString;
                AccountLevel: z.ZodNumber;
                PreferredLevelBorderID: z.ZodUnion<[z.ZodString, z.ZodLiteral<"">]>;
                Incognito: z.ZodBoolean;
                HideAccountLevel: z.ZodBoolean;
            }, "strip", z.ZodTypeAny, {
                Subject: string;
                PlayerCardID: string;
                PlayerTitleID: string;
                AccountLevel: number;
                PreferredLevelBorderID: string;
                Incognito: boolean;
                HideAccountLevel: boolean;
            }, {
                Subject: string;
                PlayerCardID: string;
                PlayerTitleID: string;
                AccountLevel: number;
                PreferredLevelBorderID: string;
                Incognito: boolean;
                HideAccountLevel: boolean;
            }>;
            SeasonalBadgeInfo: z.ZodObject<{
                SeasonID: z.ZodUnion<[z.ZodString, z.ZodLiteral<"">]>;
                NumberOfWins: z.ZodNumber;
                WinsByTier: z.ZodNull;
                Rank: z.ZodNumber;
                LeaderboardRank: z.ZodNumber;
            }, "strip", z.ZodTypeAny, {
                SeasonID: string;
                NumberOfWins: number;
                WinsByTier: null;
                Rank: number;
                LeaderboardRank: number;
            }, {
                SeasonID: string;
                NumberOfWins: number;
                WinsByTier: null;
                Rank: number;
                LeaderboardRank: number;
            }>;
            IsCaptain: z.ZodBoolean;
        }, "strip", z.ZodTypeAny, {
            CharacterID: string;
            Subject: string;
            PlayerIdentity: {
                Subject: string;
                PlayerCardID: string;
                PlayerTitleID: string;
                AccountLevel: number;
                PreferredLevelBorderID: string;
                Incognito: boolean;
                HideAccountLevel: boolean;
            };
            SeasonalBadgeInfo: {
                SeasonID: string;
                NumberOfWins: number;
                WinsByTier: null;
                Rank: number;
                LeaderboardRank: number;
            };
            CompetitiveTier: number;
            CharacterSelectionState: "" | "selected" | "locked";
            PregamePlayerState: "joined";
            IsCaptain: boolean;
        }, {
            CharacterID: string;
            Subject: string;
            PlayerIdentity: {
                Subject: string;
                PlayerCardID: string;
                PlayerTitleID: string;
                AccountLevel: number;
                PreferredLevelBorderID: string;
                Incognito: boolean;
                HideAccountLevel: boolean;
            };
            SeasonalBadgeInfo: {
                SeasonID: string;
                NumberOfWins: number;
                WinsByTier: null;
                Rank: number;
                LeaderboardRank: number;
            };
            CompetitiveTier: number;
            CharacterSelectionState: "" | "selected" | "locked";
            PregamePlayerState: "joined";
            IsCaptain: boolean;
        }>, "many">;
    }, "strip", z.ZodTypeAny, {
        Players: {
            CharacterID: string;
            Subject: string;
            PlayerIdentity: {
                Subject: string;
                PlayerCardID: string;
                PlayerTitleID: string;
                AccountLevel: number;
                PreferredLevelBorderID: string;
                Incognito: boolean;
                HideAccountLevel: boolean;
            };
            SeasonalBadgeInfo: {
                SeasonID: string;
                NumberOfWins: number;
                WinsByTier: null;
                Rank: number;
                LeaderboardRank: number;
            };
            CompetitiveTier: number;
            CharacterSelectionState: "" | "selected" | "locked";
            PregamePlayerState: "joined";
            IsCaptain: boolean;
        }[];
        TeamID: string;
    }, {
        Players: {
            CharacterID: string;
            Subject: string;
            PlayerIdentity: {
                Subject: string;
                PlayerCardID: string;
                PlayerTitleID: string;
                AccountLevel: number;
                PreferredLevelBorderID: string;
                Incognito: boolean;
                HideAccountLevel: boolean;
            };
            SeasonalBadgeInfo: {
                SeasonID: string;
                NumberOfWins: number;
                WinsByTier: null;
                Rank: number;
                LeaderboardRank: number;
            };
            CompetitiveTier: number;
            CharacterSelectionState: "" | "selected" | "locked";
            PregamePlayerState: "joined";
            IsCaptain: boolean;
        }[];
        TeamID: string;
    }>>;
    ObserverSubjects: z.ZodArray<z.ZodUnknown, "many">;
    MatchCoaches: z.ZodArray<z.ZodUnknown, "many">;
    EnemyTeamSize: z.ZodNumber;
    EnemyTeamLockCount: z.ZodNumber;
    PregameState: z.ZodEnum<["character_select_active", "provisioned"]>;
    LastUpdated: z.ZodEffects<z.ZodString, Date, string>;
    MapID: z.ZodString;
    MapSelectPool: z.ZodArray<z.ZodUnknown, "many">;
    BannedMapIDs: z.ZodArray<z.ZodUnknown, "many">;
    CastedVotes: z.ZodUnknown;
    MapSelectSteps: z.ZodArray<z.ZodUnknown, "many">;
    MapSelectStep: z.ZodNumber;
    Team1: z.ZodUnion<[z.ZodEnum<["Blue", "Red"]>, z.ZodString]>;
    GamePodID: z.ZodString;
    Mode: z.ZodString;
    VoiceSessionID: z.ZodString;
    MUCName: z.ZodString;
    TeamMatchToken: z.ZodString;
    QueueID: z.ZodUnion<[z.ZodString, z.ZodLiteral<"">]>;
    ProvisioningFlowID: z.ZodEnum<["Matchmaking", "CustomGame"]>;
    IsRanked: z.ZodBoolean;
    PhaseTimeRemainingNS: z.ZodNumber;
    StepTimeRemainingNS: z.ZodNumber;
    altModesFlagADA: z.ZodBoolean;
    TournamentMetadata: z.ZodNull;
    RosterMetadata: z.ZodNull;
}, "strip", z.ZodTypeAny, {
    ID: string;
    Version: number;
    QueueID: string;
    Mode: string;
    IsRanked: boolean;
    MapID: string;
    GamePodID: string;
    TeamMatchToken: string;
    MUCName: string;
    Teams: {
        Players: {
            CharacterID: string;
            Subject: string;
            PlayerIdentity: {
                Subject: string;
                PlayerCardID: string;
                PlayerTitleID: string;
                AccountLevel: number;
                PreferredLevelBorderID: string;
                Incognito: boolean;
                HideAccountLevel: boolean;
            };
            SeasonalBadgeInfo: {
                SeasonID: string;
                NumberOfWins: number;
                WinsByTier: null;
                Rank: number;
                LeaderboardRank: number;
            };
            CompetitiveTier: number;
            CharacterSelectionState: "" | "selected" | "locked";
            PregamePlayerState: "joined";
            IsCaptain: boolean;
        }[];
        TeamID: string;
    }[];
    AllyTeam: {
        Players: {
            CharacterID: string;
            Subject: string;
            PlayerIdentity: {
                Subject: string;
                PlayerCardID: string;
                PlayerTitleID: string;
                AccountLevel: number;
                PreferredLevelBorderID: string;
                Incognito: boolean;
                HideAccountLevel: boolean;
            };
            SeasonalBadgeInfo: {
                SeasonID: string;
                NumberOfWins: number;
                WinsByTier: null;
                Rank: number;
                LeaderboardRank: number;
            };
            CompetitiveTier: number;
            CharacterSelectionState: "" | "selected" | "locked";
            PregamePlayerState: "joined";
            IsCaptain: boolean;
        }[];
        TeamID: string;
    } | null;
    EnemyTeam: {
        Players: {
            CharacterID: string;
            Subject: string;
            PlayerIdentity: {
                Subject: string;
                PlayerCardID: string;
                PlayerTitleID: string;
                AccountLevel: number;
                PreferredLevelBorderID: string;
                Incognito: boolean;
                HideAccountLevel: boolean;
            };
            SeasonalBadgeInfo: {
                SeasonID: string;
                NumberOfWins: number;
                WinsByTier: null;
                Rank: number;
                LeaderboardRank: number;
            };
            CompetitiveTier: number;
            CharacterSelectionState: "" | "selected" | "locked";
            PregamePlayerState: "joined";
            IsCaptain: boolean;
        }[];
        TeamID: string;
    } | null;
    ObserverSubjects: unknown[];
    MatchCoaches: unknown[];
    EnemyTeamSize: number;
    EnemyTeamLockCount: number;
    PregameState: "character_select_active" | "provisioned";
    LastUpdated: Date;
    MapSelectPool: unknown[];
    BannedMapIDs: unknown[];
    MapSelectSteps: unknown[];
    MapSelectStep: number;
    Team1: string;
    VoiceSessionID: string;
    ProvisioningFlowID: "Matchmaking" | "CustomGame";
    PhaseTimeRemainingNS: number;
    StepTimeRemainingNS: number;
    altModesFlagADA: boolean;
    TournamentMetadata: null;
    RosterMetadata: null;
    CastedVotes?: unknown;
}, {
    ID: string;
    Version: number;
    QueueID: string;
    Mode: string;
    IsRanked: boolean;
    MapID: string;
    GamePodID: string;
    TeamMatchToken: string;
    MUCName: string;
    Teams: {
        Players: {
            CharacterID: string;
            Subject: string;
            PlayerIdentity: {
                Subject: string;
                PlayerCardID: string;
                PlayerTitleID: string;
                AccountLevel: number;
                PreferredLevelBorderID: string;
                Incognito: boolean;
                HideAccountLevel: boolean;
            };
            SeasonalBadgeInfo: {
                SeasonID: string;
                NumberOfWins: number;
                WinsByTier: null;
                Rank: number;
                LeaderboardRank: number;
            };
            CompetitiveTier: number;
            CharacterSelectionState: "" | "selected" | "locked";
            PregamePlayerState: "joined";
            IsCaptain: boolean;
        }[];
        TeamID: string;
    }[];
    AllyTeam: {
        Players: {
            CharacterID: string;
            Subject: string;
            PlayerIdentity: {
                Subject: string;
                PlayerCardID: string;
                PlayerTitleID: string;
                AccountLevel: number;
                PreferredLevelBorderID: string;
                Incognito: boolean;
                HideAccountLevel: boolean;
            };
            SeasonalBadgeInfo: {
                SeasonID: string;
                NumberOfWins: number;
                WinsByTier: null;
                Rank: number;
                LeaderboardRank: number;
            };
            CompetitiveTier: number;
            CharacterSelectionState: "" | "selected" | "locked";
            PregamePlayerState: "joined";
            IsCaptain: boolean;
        }[];
        TeamID: string;
    } | null;
    EnemyTeam: {
        Players: {
            CharacterID: string;
            Subject: string;
            PlayerIdentity: {
                Subject: string;
                PlayerCardID: string;
                PlayerTitleID: string;
                AccountLevel: number;
                PreferredLevelBorderID: string;
                Incognito: boolean;
                HideAccountLevel: boolean;
            };
            SeasonalBadgeInfo: {
                SeasonID: string;
                NumberOfWins: number;
                WinsByTier: null;
                Rank: number;
                LeaderboardRank: number;
            };
            CompetitiveTier: number;
            CharacterSelectionState: "" | "selected" | "locked";
            PregamePlayerState: "joined";
            IsCaptain: boolean;
        }[];
        TeamID: string;
    } | null;
    ObserverSubjects: unknown[];
    MatchCoaches: unknown[];
    EnemyTeamSize: number;
    EnemyTeamLockCount: number;
    PregameState: "character_select_active" | "provisioned";
    LastUpdated: string;
    MapSelectPool: unknown[];
    BannedMapIDs: unknown[];
    MapSelectSteps: unknown[];
    MapSelectStep: number;
    Team1: string;
    VoiceSessionID: string;
    ProvisioningFlowID: "Matchmaking" | "CustomGame";
    PhaseTimeRemainingNS: number;
    StepTimeRemainingNS: number;
    altModesFlagADA: boolean;
    TournamentMetadata: null;
    RosterMetadata: null;
    CastedVotes?: unknown;
}>;
declare const contractsResponse: z.ZodObject<{
    Version: z.ZodNumber;
    Subject: z.ZodString;
    Contracts: z.ZodArray<z.ZodObject<{
        ContractDefinitionID: z.ZodString;
        ContractProgression: z.ZodObject<{
            TotalProgressionEarned: z.ZodNumber;
            TotalProgressionEarnedVersion: z.ZodNumber;
            HighestRewardedLevel: z.ZodRecord<z.ZodString, z.ZodObject<{
                Amount: z.ZodNumber;
                Version: z.ZodNumber;
            }, "strip", z.ZodTypeAny, {
                Version: number;
                Amount: number;
            }, {
                Version: number;
                Amount: number;
            }>>;
        }, "strip", z.ZodTypeAny, {
            TotalProgressionEarned: number;
            TotalProgressionEarnedVersion: number;
            HighestRewardedLevel: Record<string, {
                Version: number;
                Amount: number;
            }>;
        }, {
            TotalProgressionEarned: number;
            TotalProgressionEarnedVersion: number;
            HighestRewardedLevel: Record<string, {
                Version: number;
                Amount: number;
            }>;
        }>;
        ProgressionLevelReached: z.ZodNumber;
        ProgressionTowardsNextLevel: z.ZodNumber;
    }, "strip", z.ZodTypeAny, {
        ContractDefinitionID: string;
        ContractProgression: {
            TotalProgressionEarned: number;
            TotalProgressionEarnedVersion: number;
            HighestRewardedLevel: Record<string, {
                Version: number;
                Amount: number;
            }>;
        };
        ProgressionLevelReached: number;
        ProgressionTowardsNextLevel: number;
    }, {
        ContractDefinitionID: string;
        ContractProgression: {
            TotalProgressionEarned: number;
            TotalProgressionEarnedVersion: number;
            HighestRewardedLevel: Record<string, {
                Version: number;
                Amount: number;
            }>;
        };
        ProgressionLevelReached: number;
        ProgressionTowardsNextLevel: number;
    }>, "many">;
    ProcessedMatches: z.ZodArray<z.ZodObject<{
        ID: z.ZodString;
        StartTime: z.ZodEffects<z.ZodNumber, Date, number>;
        XPGrants: z.ZodNullable<z.ZodObject<{
            GamePlayed: z.ZodNumber;
            GameWon: z.ZodNumber;
            RoundPlayed: z.ZodNumber;
            RoundWon: z.ZodNumber;
            Missions: z.ZodObject<{}, "strip", z.ZodTypeAny, {}, {}>;
            Modifier: z.ZodObject<{
                Value: z.ZodNumber;
                BaseMultiplierValue: z.ZodNumber;
                Modifiers: z.ZodArray<z.ZodObject<{
                    Value: z.ZodNumber;
                    Name: z.ZodEnum<["RESTRICTIONS_XP", "PREMIUM_CONTRACT_XP"]>;
                    BaseOnly: z.ZodBoolean;
                }, "strip", z.ZodTypeAny, {
                    Value: number;
                    Name: "RESTRICTIONS_XP" | "PREMIUM_CONTRACT_XP";
                    BaseOnly: boolean;
                }, {
                    Value: number;
                    Name: "RESTRICTIONS_XP" | "PREMIUM_CONTRACT_XP";
                    BaseOnly: boolean;
                }>, "many">;
            }, "strip", z.ZodTypeAny, {
                Value: number;
                BaseMultiplierValue: number;
                Modifiers: {
                    Value: number;
                    Name: "RESTRICTIONS_XP" | "PREMIUM_CONTRACT_XP";
                    BaseOnly: boolean;
                }[];
            }, {
                Value: number;
                BaseMultiplierValue: number;
                Modifiers: {
                    Value: number;
                    Name: "RESTRICTIONS_XP" | "PREMIUM_CONTRACT_XP";
                    BaseOnly: boolean;
                }[];
            }>;
            NumAFKRounds: z.ZodNumber;
        }, "strip", z.ZodTypeAny, {
            GamePlayed: number;
            GameWon: number;
            RoundPlayed: number;
            RoundWon: number;
            Missions: {};
            Modifier: {
                Value: number;
                BaseMultiplierValue: number;
                Modifiers: {
                    Value: number;
                    Name: "RESTRICTIONS_XP" | "PREMIUM_CONTRACT_XP";
                    BaseOnly: boolean;
                }[];
            };
            NumAFKRounds: number;
        }, {
            GamePlayed: number;
            GameWon: number;
            RoundPlayed: number;
            RoundWon: number;
            Missions: {};
            Modifier: {
                Value: number;
                BaseMultiplierValue: number;
                Modifiers: {
                    Value: number;
                    Name: "RESTRICTIONS_XP" | "PREMIUM_CONTRACT_XP";
                    BaseOnly: boolean;
                }[];
            };
            NumAFKRounds: number;
        }>>;
        RewardGrants: z.ZodNullable<z.ZodObject<{}, "strip", z.ZodTypeAny, {}, {}>>;
        MissionDeltas: z.ZodNullable<z.ZodRecord<z.ZodString, z.ZodObject<{
            ID: z.ZodString;
            Objectives: z.ZodRecord<z.ZodString, z.ZodNumber>;
            ObjectiveDeltas: z.ZodRecord<z.ZodString, z.ZodObject<{
                ID: z.ZodString;
                ProgressBefore: z.ZodNumber;
                ProgressAfter: z.ZodNumber;
            }, "strip", z.ZodTypeAny, {
                ID: string;
                ProgressBefore: number;
                ProgressAfter: number;
            }, {
                ID: string;
                ProgressBefore: number;
                ProgressAfter: number;
            }>>;
        }, "strip", z.ZodTypeAny, {
            ID: string;
            Objectives: Record<string, number>;
            ObjectiveDeltas: Record<string, {
                ID: string;
                ProgressBefore: number;
                ProgressAfter: number;
            }>;
        }, {
            ID: string;
            Objectives: Record<string, number>;
            ObjectiveDeltas: Record<string, {
                ID: string;
                ProgressBefore: number;
                ProgressAfter: number;
            }>;
        }>>>;
        ContractDeltas: z.ZodNullable<z.ZodRecord<z.ZodString, z.ZodObject<{
            ID: z.ZodString;
            TotalXPBefore: z.ZodNumber;
            TotalXPAfter: z.ZodNumber;
        }, "strip", z.ZodTypeAny, {
            ID: string;
            TotalXPBefore: number;
            TotalXPAfter: number;
        }, {
            ID: string;
            TotalXPBefore: number;
            TotalXPAfter: number;
        }>>>;
        CouldProgressMissions: z.ZodBoolean;
    }, "strip", z.ZodTypeAny, {
        ID: string;
        StartTime: Date;
        XPGrants: {
            GamePlayed: number;
            GameWon: number;
            RoundPlayed: number;
            RoundWon: number;
            Missions: {};
            Modifier: {
                Value: number;
                BaseMultiplierValue: number;
                Modifiers: {
                    Value: number;
                    Name: "RESTRICTIONS_XP" | "PREMIUM_CONTRACT_XP";
                    BaseOnly: boolean;
                }[];
            };
            NumAFKRounds: number;
        } | null;
        RewardGrants: {} | null;
        MissionDeltas: Record<string, {
            ID: string;
            Objectives: Record<string, number>;
            ObjectiveDeltas: Record<string, {
                ID: string;
                ProgressBefore: number;
                ProgressAfter: number;
            }>;
        }> | null;
        ContractDeltas: Record<string, {
            ID: string;
            TotalXPBefore: number;
            TotalXPAfter: number;
        }> | null;
        CouldProgressMissions: boolean;
    }, {
        ID: string;
        StartTime: number;
        XPGrants: {
            GamePlayed: number;
            GameWon: number;
            RoundPlayed: number;
            RoundWon: number;
            Missions: {};
            Modifier: {
                Value: number;
                BaseMultiplierValue: number;
                Modifiers: {
                    Value: number;
                    Name: "RESTRICTIONS_XP" | "PREMIUM_CONTRACT_XP";
                    BaseOnly: boolean;
                }[];
            };
            NumAFKRounds: number;
        } | null;
        RewardGrants: {} | null;
        MissionDeltas: Record<string, {
            ID: string;
            Objectives: Record<string, number>;
            ObjectiveDeltas: Record<string, {
                ID: string;
                ProgressBefore: number;
                ProgressAfter: number;
            }>;
        }> | null;
        ContractDeltas: Record<string, {
            ID: string;
            TotalXPBefore: number;
            TotalXPAfter: number;
        }> | null;
        CouldProgressMissions: boolean;
    }>, "many">;
    ActiveSpecialContract: z.ZodString;
    Missions: z.ZodArray<z.ZodObject<{
        ID: z.ZodString;
        Objectives: z.ZodRecord<z.ZodString, z.ZodNumber>;
        Complete: z.ZodBoolean;
        ExpirationTime: z.ZodEffects<z.ZodString, Date, string>;
    }, "strip", z.ZodTypeAny, {
        ID: string;
        Objectives: Record<string, number>;
        Complete: boolean;
        ExpirationTime: Date;
    }, {
        ID: string;
        Objectives: Record<string, number>;
        Complete: boolean;
        ExpirationTime: string;
    }>, "many">;
    MissionMetadata: z.ZodObject<{
        NPECompleted: z.ZodBoolean;
        WeeklyCheckpoint: z.ZodEffects<z.ZodString, Date, string>;
        WeeklyRefillTime: z.ZodEffects<z.ZodString, Date, string>;
    }, "strip", z.ZodTypeAny, {
        NPECompleted: boolean;
        WeeklyCheckpoint: Date;
        WeeklyRefillTime: Date;
    }, {
        NPECompleted: boolean;
        WeeklyCheckpoint: string;
        WeeklyRefillTime: string;
    }>;
}, "strip", z.ZodTypeAny, {
    Subject: string;
    Version: number;
    Contracts: {
        ContractDefinitionID: string;
        ContractProgression: {
            TotalProgressionEarned: number;
            TotalProgressionEarnedVersion: number;
            HighestRewardedLevel: Record<string, {
                Version: number;
                Amount: number;
            }>;
        };
        ProgressionLevelReached: number;
        ProgressionTowardsNextLevel: number;
    }[];
    ProcessedMatches: {
        ID: string;
        StartTime: Date;
        XPGrants: {
            GamePlayed: number;
            GameWon: number;
            RoundPlayed: number;
            RoundWon: number;
            Missions: {};
            Modifier: {
                Value: number;
                BaseMultiplierValue: number;
                Modifiers: {
                    Value: number;
                    Name: "RESTRICTIONS_XP" | "PREMIUM_CONTRACT_XP";
                    BaseOnly: boolean;
                }[];
            };
            NumAFKRounds: number;
        } | null;
        RewardGrants: {} | null;
        MissionDeltas: Record<string, {
            ID: string;
            Objectives: Record<string, number>;
            ObjectiveDeltas: Record<string, {
                ID: string;
                ProgressBefore: number;
                ProgressAfter: number;
            }>;
        }> | null;
        ContractDeltas: Record<string, {
            ID: string;
            TotalXPBefore: number;
            TotalXPAfter: number;
        }> | null;
        CouldProgressMissions: boolean;
    }[];
    Missions: {
        ID: string;
        Objectives: Record<string, number>;
        Complete: boolean;
        ExpirationTime: Date;
    }[];
    ActiveSpecialContract: string;
    MissionMetadata: {
        NPECompleted: boolean;
        WeeklyCheckpoint: Date;
        WeeklyRefillTime: Date;
    };
}, {
    Subject: string;
    Version: number;
    Contracts: {
        ContractDefinitionID: string;
        ContractProgression: {
            TotalProgressionEarned: number;
            TotalProgressionEarnedVersion: number;
            HighestRewardedLevel: Record<string, {
                Version: number;
                Amount: number;
            }>;
        };
        ProgressionLevelReached: number;
        ProgressionTowardsNextLevel: number;
    }[];
    ProcessedMatches: {
        ID: string;
        StartTime: number;
        XPGrants: {
            GamePlayed: number;
            GameWon: number;
            RoundPlayed: number;
            RoundWon: number;
            Missions: {};
            Modifier: {
                Value: number;
                BaseMultiplierValue: number;
                Modifiers: {
                    Value: number;
                    Name: "RESTRICTIONS_XP" | "PREMIUM_CONTRACT_XP";
                    BaseOnly: boolean;
                }[];
            };
            NumAFKRounds: number;
        } | null;
        RewardGrants: {} | null;
        MissionDeltas: Record<string, {
            ID: string;
            Objectives: Record<string, number>;
            ObjectiveDeltas: Record<string, {
                ID: string;
                ProgressBefore: number;
                ProgressAfter: number;
            }>;
        }> | null;
        ContractDeltas: Record<string, {
            ID: string;
            TotalXPBefore: number;
            TotalXPAfter: number;
        }> | null;
        CouldProgressMissions: boolean;
    }[];
    Missions: {
        ID: string;
        Objectives: Record<string, number>;
        Complete: boolean;
        ExpirationTime: string;
    }[];
    ActiveSpecialContract: string;
    MissionMetadata: {
        NPECompleted: boolean;
        WeeklyCheckpoint: string;
        WeeklyRefillTime: string;
    };
}>;
declare const conversationsSchema: z.ZodObject<{
    conversations: z.ZodArray<z.ZodObject<{
        cid: z.ZodString;
        direct_messages: z.ZodBoolean;
        global_readership: z.ZodBoolean;
        message_history: z.ZodBoolean;
        mid: z.ZodString;
        muted: z.ZodBoolean;
        mutedRestriction: z.ZodBoolean;
        type: z.ZodEnum<["groupchat", "chat"]>;
        uiState: z.ZodObject<{
            changedSinceHidden: z.ZodBoolean;
            hidden: z.ZodBoolean;
        }, "strip", z.ZodTypeAny, {
            changedSinceHidden: boolean;
            hidden: boolean;
        }, {
            changedSinceHidden: boolean;
            hidden: boolean;
        }>;
        unread_count: z.ZodNumber;
    }, "strip", z.ZodTypeAny, {
        type: "chat" | "groupchat";
        cid: string;
        muted: boolean;
        direct_messages: boolean;
        global_readership: boolean;
        message_history: boolean;
        mid: string;
        mutedRestriction: boolean;
        uiState: {
            changedSinceHidden: boolean;
            hidden: boolean;
        };
        unread_count: number;
    }, {
        type: "chat" | "groupchat";
        cid: string;
        muted: boolean;
        direct_messages: boolean;
        global_readership: boolean;
        message_history: boolean;
        mid: string;
        mutedRestriction: boolean;
        uiState: {
            changedSinceHidden: boolean;
            hidden: boolean;
        };
        unread_count: number;
    }>, "many">;
}, "strip", z.ZodTypeAny, {
    conversations: {
        type: "chat" | "groupchat";
        cid: string;
        muted: boolean;
        direct_messages: boolean;
        global_readership: boolean;
        message_history: boolean;
        mid: string;
        mutedRestriction: boolean;
        uiState: {
            changedSinceHidden: boolean;
            hidden: boolean;
        };
        unread_count: number;
    }[];
}, {
    conversations: {
        type: "chat" | "groupchat";
        cid: string;
        muted: boolean;
        direct_messages: boolean;
        global_readership: boolean;
        message_history: boolean;
        mid: string;
        mutedRestriction: boolean;
        uiState: {
            changedSinceHidden: boolean;
            hidden: boolean;
        };
        unread_count: number;
    }[];
}>;
declare const chatMessagesSchema: z.ZodObject<{
    messages: z.ZodArray<z.ZodObject<{
        body: z.ZodString;
        cid: z.ZodString;
        game_name: z.ZodString;
        game_tag: z.ZodString;
        id: z.ZodString;
        mid: z.ZodString;
        name: z.ZodString;
        pid: z.ZodString;
        puuid: z.ZodString;
        read: z.ZodBoolean;
        region: z.ZodString;
        time: z.ZodEffects<z.ZodString, Date, string>;
        type: z.ZodEnum<["chat", "groupchat"]>;
    }, "strip", z.ZodTypeAny, {
        pid: string;
        type: "chat" | "groupchat";
        name: string;
        body: string;
        time: Date;
        region: string;
        puuid: string;
        game_name: string;
        game_tag: string;
        cid: string;
        mid: string;
        id: string;
        read: boolean;
    }, {
        pid: string;
        type: "chat" | "groupchat";
        name: string;
        body: string;
        time: string;
        region: string;
        puuid: string;
        game_name: string;
        game_tag: string;
        cid: string;
        mid: string;
        id: string;
        read: boolean;
    }>, "many">;
}, "strip", z.ZodTypeAny, {
    messages: {
        pid: string;
        type: "chat" | "groupchat";
        name: string;
        body: string;
        time: Date;
        region: string;
        puuid: string;
        game_name: string;
        game_tag: string;
        cid: string;
        mid: string;
        id: string;
        read: boolean;
    }[];
}, {
    messages: {
        pid: string;
        type: "chat" | "groupchat";
        name: string;
        body: string;
        time: string;
        region: string;
        puuid: string;
        game_name: string;
        game_tag: string;
        cid: string;
        mid: string;
        id: string;
        read: boolean;
    }[];
}>;

type PlatformInfo = z.infer<typeof platformSchema>;
type RemoteHeaderOptions = {
    accessToken: string;
    entitlementsToken: string;
    clientVersion: string;
    platformInfo: PlatformInfo;
    userAgent: string;
};
declare class HeadersBuilder {
    private headers;
    static create(): HeadersBuilder;
    static remote(options: RemoteHeaderOptions): Record<string, string>;
    userAgent(userAgent: string): this;
    rsoUserAgent(clientBuild: string): this;
    localAuth(username: string, password: string): this;
    accessToken(accessToken: string): this;
    entitlementsJWT(entitlementsToken: string): this;
    clientVersion(clientVersion: string): this;
    clientPlatform(platformInfo: PlatformInfo): this;
    build(): Record<string, string>;
}
declare const generateBasicToken: (username: string, password: string) => string;

declare const regionShardMap: {
    readonly latam: readonly ["na"];
    readonly br: readonly ["na"];
    readonly na: readonly ["na", "pbe"];
    readonly eu: readonly ["eu"];
    readonly ap: readonly ["ap"];
    readonly kr: readonly ["kr"];
};
type Region = keyof typeof regionShardMap;
type RegionShard<R extends Region = Region> = (typeof regionShardMap)[R][number];
declare function getRegionOptions<R extends Region | Omit<string, Region>>(region: R, shard: R extends Region ? RegionShard<R> : string): {
    region: Region;
    shard: RegionShard;
};
declare function getRegionAndShardFromPas(accessToken: string, idToken: string): Promise<{
    region: string;
    shard: "pbe" | "na" | "eu" | "ap" | "kr";
}>;

declare function getPuuidFromAccessToken(accessToken: string): string;

declare function getUrlParams(url: string): string[];
declare function buildUrl(url: string, params: Record<string, unknown>): string;

type Provider<TContext = any, TOptions extends Record<string, any> = Record<string, any>> = (ctx: TContext) => MaybePromise<Partial<TOptions>>;
type ProvidersReturnType<Tproviders extends Provider[]> = Simplify<UnionToIntersection<Awaited<ReturnType<Tproviders[number]>>>>;
declare function useProviders<TContext, TProvider extends Provider<TContext>>(providers: TProvider[] | TProvider): (ctx: TContext) => Promise<ProvidersReturnType<TProvider[]>>;

/**
 * @client remote
 * @provides access-token, entitlements-token
 */
declare function provideAuthViaLocalApi(): ({ local }: ValorantApiClient) => Promise<{
    accessToken: string;
    entitlementsToken: string;
}>;
/**
 * @client remote
 * @provides access-token, entitlements-token
 */
declare function provideAuthViaTokens(accessToken: string, entitlementsToken: string): () => {
    accessToken: string;
    entitlementsToken: string;
};

/**
 * @client local
 * @provides user, password, port, pid, protocol
 */
declare function provideLockFile(lockfilePath?: string): () => Promise<{
    user: string;
    pid: string;
    port: string;
    password: string;
    protocol: string;
}>;
/**
 * @client remote
 * @provides shard, region, client-version
 */
declare function provideLogFile(logfilePath?: string): () => Promise<{
    region: string;
    shard: string;
    clientVersion: string;
    servers: {
        glz: string;
        pd: string;
        shared: string;
    };
}>;

/**
 * @client remote
 * @provides shard, region
 */
declare function provideRegion<R extends Region | Omit<string, Region>>(region: R, shard: R extends Region ? RegionShard<R> : string): () => {
    region: Region;
    shard: RegionShard;
};
/**
 * @client remote
 * @provides client-version
 */
declare function provideClientVersion(clientVersion: string): () => {
    clientVersion: string;
};
/**
 * @client remote
 * @provides client-version
 */
declare function provideClientVersionViaVAPI(): () => Promise<{
    clientVersion: string;
}>;
/**
 * @client remote
 * @provides client-version
 */
declare function provideClientVersionViaAuthApi(): ({ auth }: ValorantApiClient) => Promise<{
    clientVersion: string;
}>;
/**
 * @client auth
 * @provides rso-user-agent
 */
declare function provideRsoUserAgentViaVAPI(): () => Promise<{
    userAgent: string;
}>;
/**
 * @client auth
 * @provides client-version,rso-user-agent
 */
declare function provideClientVersionAndRsoUserAgentViaVAPI(): () => Promise<{
    clientVersion: string;
    rsoUserAgent: string;
}>;

type AuthRequestResponse = z.infer<typeof AuthRequestResponseSchema>;
type AuthEntitlementsTokenResponse = z.infer<typeof EntitlementsTokenResponseSchema>;
type PASTokenResponse = z.infer<typeof PasTokenResponseSchema>;
type PlayerInfoResponse = z.infer<typeof PlayerInfoResponseSchema>;
type RiotClientConfigResponse = z.infer<typeof RiotClientConfigResponseSchema>;
type RiotGeoResponse = z.infer<typeof RiotGeoResponseSchema>;
type AccountAliasResponse = z.infer<typeof AccountAliasResponseSchema>;
type AllChatInfoResponse = z.infer<typeof conversationsSchema>;
type ChatHistoryResponse = z.infer<typeof chatMessagesSchema>;
type ChatParticipantsResponse = z.infer<typeof ChatParticipantsResponseSchema>;
type ChatSessionResponse = z.infer<typeof ChatSessionResponseSchema>;
type ChatRegionResponse = z.infer<typeof ChatRegionSchema>;
type CurrentGameChatInfoResponse = z.infer<typeof conversationsSchema>;
type LocalEntitlementsTokenResponse = z.infer<typeof EntitlementsTokenResponseSchema>;
type FriendRequestsResponse = z.infer<typeof FriendRequestsResponseSchema>;
type FriendsResponse = z.infer<typeof FriendsResponseSchema>;
type HelpResponse = z.infer<typeof HelpResponseSchema>;
type PartyChatInfoResponse = z.infer<typeof conversationsSchema>;
type PregameChatInfoResponse = z.infer<typeof conversationsSchema>;
type PresenceResponse = z.infer<typeof PresenceResponseSchema>;
type LeagueOfLegendsPresence = z.infer<typeof leagueOfLegendsPresenceSchema>;
type ValorantPresence = z.infer<typeof valorantPresenceSchema>;
type SendChatMessageResponse = z.infer<typeof chatMessagesSchema>;
type SessionResponse = z.infer<typeof SessionsResponseSchema>;
type SettingsResponse = z.infer<typeof SettingsResponseSchema>;
type ChangeQueueResponse = z.infer<typeof partySchema>;
type CurrentGameLoadoutsResponse = z.infer<typeof CurrentGameLoadoutsResponseSchema>;
type CurrentGameMatchResponse = z.infer<typeof CurrentGameMatchResponseSchema>;
type CurrentGamePlayerResponse = z.infer<typeof CurrentGamePlayerResponseSchema>;
type CustomGameConfigResponse = z.infer<typeof CustomGameConfigResponseSchema>;
type EnterMatchmakingQueueResponse = z.infer<typeof partySchema>;
type LeaveMatchmakingQueueResponse = z.infer<typeof partySchema>;
type LockCharacterResponse = z.infer<typeof pregameMatchSchema>;
type PartyChatTokenResponse = z.infer<typeof PartyChatTokenResponseSchema>;
type PartyDeclineResponse = z.infer<typeof partySchema>;
type PartyDisableCodeResponse = z.infer<typeof partySchema>;
type PartyGenerateCodeResponse = z.infer<typeof partySchema>;
type PartyInviteResponse = z.infer<typeof partySchema>;
type PartyJoinByCodeResponse = z.infer<typeof PartyJoinByCodeResponseSchema>;
type PartyPlayerResponse = z.infer<typeof partyPlayerSchema>;
type PartySetMembersReadyResponse = z.infer<typeof partySchema>;
type PartyVoiceTokenResponse = z.infer<typeof PartyVoiceTokenResponseSchema>;
type PartyResponse = z.infer<typeof partySchema>;
type PreGameLoadoutsResponse = z.infer<typeof PreGameLoadoutsResponseSchema>;
type PreGameMatchResponse = z.infer<typeof pregameMatchSchema>;
type PreGamePlayerResponse = z.infer<typeof PreGamePlayerResponseSchema>;
type RefreshCompetitiveTierResponse = z.infer<typeof partySchema>;
type RefreshPingsResponse = z.infer<typeof partySchema>;
type RefreshPlayerIdentityResponse = z.infer<typeof partySchema>;
type SelectCharacterResponse = z.infer<typeof pregameMatchSchema>;
type SetCustomGameSettingsResponse = z.infer<typeof partySchema>;
type SetPartyAccessibilityResponse = z.infer<typeof partySchema>;
type StartCustomGameResponse = z.infer<typeof partySchema>;
type AccountXpResponse = z.infer<typeof accountXpResponseSchema>;
type ActivateContractResponse = z.infer<typeof contractsResponse>;
type CompetitiveUpdatesResponse = z.infer<typeof competitiveUpdatesResponseSchema>;
type ConfigResponse = z.infer<typeof configResponseSchema>;
type ContractsResponse = z.infer<typeof contractsResponse>;
type ItemUpgradesResponse = z.infer<typeof itemUpgradesResponseSchema>;
type MatchDetailsResponse = z.infer<typeof matchDetailsResponseSchema>;
type MatchInfo = z.infer<typeof matchInfoSchema>;
type MatchPlayer = z.infer<typeof matchPlayerSchema>;
type MatchHistoryResponse = z.infer<typeof matchHistoryResponseSchema>;
type OwnedItemsResponse = z.infer<typeof ownedItemsResponseSchema>;
type PricesResponse = z.infer<typeof pricesResponseSchema>;
type StorefrontResponse = z.infer<typeof storefrontResponseSchema>;
type WalletResponse = z.infer<typeof walletResponseSchema>;
type FetchContentResponse = z.infer<typeof FetchContentResponseSchema>;

export { AuthApiClient, CLIENT_RESOLUTION_ORDER, HeadersBuilder, LOCK_FILE_PATH, LOG_FILE_PATH, LocalApiClient, REMOTE_SERVER_TYPES, RemoteApiClient, ValorantApiClient, authApiClientOptionsSchema, buildUrl, createAuthApiClient, createLocalApiClient, createRemoteApiClient, createValorantApiClient, fetchClientVersionFromVAPI, fetchPas, generateBasicToken, getLockFileData, getLogFileData, getPuuidFromAccessToken, getRegionAndShardFromGlzServer, getRegionAndShardFromPas, getRegionOptions, getRsoUserAgent, getServerUrl, getUrlParams, localApiClientOptionsSchema, presets, provideAuthViaLocalApi, provideAuthViaTokens, provideClientVersion, provideClientVersionAndRsoUserAgentViaVAPI, provideClientVersionViaAuthApi, provideClientVersionViaVAPI, provideLockFile, provideLogFile, provideRegion, provideRsoUserAgentViaVAPI, regionShardMap, remoteApiClientOptionsSchema, useProviders };
export type { AccountAliasResponse, AccountXpResponse, ActivateContractResponse, AllChatInfoResponse, AuthApiClientOptions, AuthEntitlementsTokenResponse, AuthRequestResponse, ChangeQueueResponse, ChatHistoryResponse, ChatParticipantsResponse, ChatRegionResponse, ChatSessionResponse, CompetitiveUpdatesResponse, ConfigResponse, ContractsResponse, CurrentGameChatInfoResponse, CurrentGameLoadoutsResponse, CurrentGameMatchResponse, CurrentGamePlayerResponse, CustomGameConfigResponse, EnterMatchmakingQueueResponse, FetchContentResponse, FriendRequestsResponse, FriendsResponse, HelpResponse, ItemUpgradesResponse, LeagueOfLegendsPresence, LeaveMatchmakingQueueResponse, LocalApiClientOptions, LocalEntitlementsTokenResponse, LocalServerOptions, LockCharacterResponse, LockFileData, LogfileData, MatchDetailsResponse, MatchHistoryResponse, MatchInfo, MatchPlayer, OwnedItemsResponse, PASTokenResponse, PartyChatInfoResponse, PartyChatTokenResponse, PartyDeclineResponse, PartyDisableCodeResponse, PartyGenerateCodeResponse, PartyInviteResponse, PartyJoinByCodeResponse, PartyPlayerResponse, PartyResponse, PartySetMembersReadyResponse, PartyVoiceTokenResponse, PlatformInfo, PlayerInfoResponse, PreGameLoadoutsResponse, PreGameMatchResponse, PreGamePlayerResponse, PregameChatInfoResponse, PresenceResponse, PricesResponse, Provider, ProvidersReturnType, RefreshCompetitiveTierResponse, RefreshPingsResponse, RefreshPlayerIdentityResponse, Region, RegionShard, RemoteApiClientOptions, RemoteServerOptions, RemoteServerType, RiotClientConfigResponse, RiotGeoResponse, SelectCharacterResponse, SendChatMessageResponse, ServerOptions, SessionResponse, SetCustomGameSettingsResponse, SetPartyAccessibilityResponse, SettingsResponse, StartCustomGameResponse, StorefrontResponse, ValorantPresence, WalletResponse };