strapi-typed-client 1.0.0

package/dist/client.d.ts

@@ -0,0 +1,622 @@
+import type { Permission, PermissionGetPayload, PermissionPopulateParam, PermissionInput, Role, RoleGetPayload, RolePopulateParam, RoleInput, User, UserGetPayload, UserPopulateParam, UserInput, Access, AccessGetPayload, AccessPopulateParam, AccessInput, AiStudio, AiStudioGetPayload, AiStudioPopulateParam, AiStudioInput, Auth, AuthGetPayload, AuthPopulateParam, AuthInput, Banner, BannerGetPayload, BannerPopulateParam, BannerInput, Catalog, CatalogGetPayload, CatalogPopulateParam, CatalogInput, Category, CategoryGetPayload, CategoryPopulateParam, CategoryInput, Faq, FaqGetPayload, FaqPopulateParam, FaqInput, Gallery, GalleryGetPayload, GalleryPopulateParam, GalleryInput, Guide, GuideGetPayload, GuidePopulateParam, GuideInput, GuideCategory, GuideCategoryGetPayload, GuideCategoryPopulateParam, GuideCategoryInput, GuidePage, GuidePageGetPayload, GuidePagePopulateParam, GuidePageInput, Item, ItemGetPayload, ItemPopulateParam, ItemInput, Landing, LandingGetPayload, LandingPopulateParam, LandingInput, Legal, LegalInput, PartnerCommission, PartnerCommissionGetPayload, PartnerCommissionPopulateParam, PartnerCommissionInput, PartnerProfile, PartnerProfileGetPayload, PartnerProfilePopulateParam, PartnerProfileInput, PartnerSetting, PartnerSettingInput, Payment, PaymentGetPayload, PaymentPopulateParam, PaymentInput, Plan, PlanGetPayload, PlanPopulateParam, PlanInput, Project, ProjectGetPayload, ProjectPopulateParam, ProjectInput, ProjectChat, ProjectChatGetPayload, ProjectChatPopulateParam, ProjectChatInput, Referral, ReferralGetPayload, ReferralPopulateParam, ReferralInput, Subscription, SubscriptionGetPayload, SubscriptionPopulateParam, SubscriptionInput, Support, SupportGetPayload, SupportPopulateParam, SupportInput, SupportCategory, SupportCategoryGetPayload, SupportCategoryPopulateParam, SupportCategoryInput, SupportCenter, SupportCenterGetPayload, SupportCenterPopulateParam, SupportCenterInput, SupportTheme, SupportThemeGetPayload, SupportThemePopulateParam, SupportThemeInput, Team, TeamGetPayload, TeamPopulateParam, TeamInput, TeamInvitation, TeamInvitationGetPayload, TeamInvitationPopulateParam, TeamInvitationInput, TeamMember, TeamMemberGetPayload, TeamMemberPopulateParam, TeamMemberInput, TokenTransaction, TokenTransactionGetPayload, TokenTransactionPopulateParam, TokenTransactionInput, UserSession, UserSessionGetPayload, UserSessionPopulateParam, UserSessionInput, Website, WebsiteGetPayload, WebsitePopulateParam, WebsiteInput } from './types.js';
+import type { PermissionFilters, RoleFilters, UserFilters, AccessFilters, AiStudioFilters, AuthFilters, BannerFilters, CatalogFilters, CategoryFilters, FaqFilters, GalleryFilters, GuideFilters, GuideCategoryFilters, GuidePageFilters, ItemFilters, LandingFilters, LegalFilters, PartnerCommissionFilters, PartnerProfileFilters, PartnerSettingFilters, PaymentFilters, PlanFilters, ProjectFilters, ProjectChatFilters, ReferralFilters, SubscriptionFilters, SupportFilters, SupportCategoryFilters, SupportCenterFilters, SupportThemeFilters, TeamFilters, TeamInvitationFilters, TeamMemberFilters, TokenTransactionFilters, UserSessionFilters, WebsiteFilters } from './types.js';
+export declare namespace AIStudioAPI {
+    type SSEEvent = {
+        type: 'connected';
+    } | {
+        type: 'progress';
+        generationId: string;
+        progress: number;
+        status: string;
+    } | {
+        type: 'complete';
+        generationId: string;
+        outputUrl: string;
+    } | {
+        type: 'error';
+        generationId: string;
+        error: string;
+    };
+    type GetConfigRequest = void;
+    type GetConfigResponse = {
+        styles: Array<{
+            id: number;
+            name: string;
+            value: string;
+            subStyles?: Array<{
+                id: number;
+                name: string;
+                value: string;
+            }>;
+        }>;
+    };
+    type StreamRequest = void;
+    type StreamResponse = void;
+    type GenerateImageRequest = {
+        resolution?: string;
+        description?: string;
+        environment?: string;
+        objectsToAdd?: string;
+        modelName?: string;
+        modelSize?: string;
+        output_format?: string;
+        generationId?: string;
+    };
+    type GenerateImageResponse = {
+        generationId: string;
+        started: boolean;
+    };
+}
+export declare namespace CheckoutAPI {
+    type BuyPlanRequest = {
+        planId: number;
+        paymentProvider: 'stripe' | 'yookassa';
+        seats?: number;
+    };
+    type BuyPlanResponse = {
+        url: string;
+    };
+    type BuyTokensRequest = {
+        paymentProvider: 'stripe' | 'yookassa';
+        quantity: number;
+    };
+    type BuyTokensResponse = {
+        url: string;
+    };
+    type CancelRequest = void;
+    type CancelResponse = {
+        success: boolean;
+    };
+}
+export declare namespace ItemAPI {
+    type IncrementRunRequest = void;
+    type IncrementRunResponse = {
+        id: number;
+        run: string;
+    };
+}
+export declare namespace PartnerProfileAPI {
+    type UpdateCodeRequest = {
+        code: string;
+    };
+    type UpdateCodeResponse = {
+        status: 'ok';
+    };
+}
+export declare namespace TeamInvitationAPI {
+    type CreateRequest = {
+        email: string;
+    };
+    type CreateResponse = {
+        id: number;
+        email: string;
+    };
+    type CancelRequest = void;
+    type CancelResponse = {
+        cancelled: true;
+        email: string;
+    };
+    type InfoRequest = void;
+    type InfoResponse = {
+        id: number;
+        ownerEmail: string;
+        invitedEmail: string;
+        isRegistered: boolean;
+        wrongEmail: boolean;
+        auth: boolean;
+    };
+    type AcceptRequest = void;
+    type AcceptResponse = {
+        accepted: true;
+        teamMember: {
+            id: number;
+            role: string;
+        };
+    };
+    type DeclineRequest = void;
+    type DeclineResponse = {
+        declined: true;
+    };
+}
+export declare namespace TeamMemberAPI {
+    type GetTeamRequest = void;
+    type GetTeamResponse = {
+        members: Array<{
+            id: number;
+            type: 'member';
+            role: 'owner' | 'member';
+            joinedAt: string;
+            user: {
+                id: number;
+                email: string;
+                username: string;
+            };
+        }>;
+        pendingInvitations: Array<{
+            id: number;
+            type: 'invitation';
+            email: string;
+            invitedAt: string;
+            status: 'pending';
+        }>;
+        maxSeats: number;
+        usedSeats: number;
+    };
+    type RemoveRequest = void;
+    type RemoveResponse = {
+        removed: true;
+        email: string;
+    };
+    type LeaveRequest = void;
+    type LeaveResponse = {
+        left: true;
+    };
+}
+export declare namespace WebhookAPI {
+    type YooKassaRequest = {
+        type: string;
+        event: string;
+        object: {
+            id: string;
+            status: string;
+            paid: boolean;
+            amount: {
+                value: string;
+                currency: string;
+            };
+            metadata?: Record<string, any>;
+        };
+    };
+    type YooKassaResponse = {
+        status: 'ok';
+    };
+    type StripeRequest = {
+        id: string;
+        type: string;
+        data: {
+            object: any;
+        };
+    };
+    type StripeResponse = {
+        status: 'ok';
+    };
+}
+export interface StrapiResponse<T> {
+    data: T;
+    meta?: {
+        pagination?: {
+            page: number;
+            pageSize: number;
+            pageCount: number;
+            total: number;
+        };
+    };
+}
+export declare class StrapiError extends Error {
+    /** Clean user-friendly message from Strapi backend */
+    userMessage: string;
+    /** HTTP status code */
+    status: number;
+    /** HTTP status text */
+    statusText: string;
+    /** Additional error details from Strapi */
+    details?: any;
+    constructor(message: string, userMessage: string, status: number, statusText: string, details?: any);
+}
+declare class BaseAPI {
+    protected config: StrapiClientConfig;
+    constructor(config: StrapiClientConfig);
+    protected request<R>(url: string, options?: RequestInit, nextOptions?: NextOptions, errorPrefix?: string): Promise<R>;
+    protected buildQueryString(params?: QueryParams): string;
+}
+type StrapiSortOption<T> = Exclude<keyof T & string, '__typename'> | `${Exclude<keyof T & string, '__typename'>}:${'asc' | 'desc'}`;
+export interface QueryParams<TEntity = any, TFilters = Record<string, any>, TPopulate = any, TFields extends string = Exclude<keyof TEntity & string, '__typename'>> {
+    filters?: TFilters;
+    sort?: StrapiSortOption<TEntity> | StrapiSortOption<TEntity>[];
+    pagination?: {
+        page?: number;
+        pageSize?: number;
+        limit?: number;
+        start?: number;
+    };
+    populate?: TPopulate;
+    fields?: TFields[];
+}
+export interface NextOptions {
+    revalidate?: number | false;
+    tags?: string[];
+    cache?: RequestCache;
+}
+export interface StrapiClientConfig {
+    baseURL: string;
+    token?: string;
+    fetch?: typeof fetch;
+    debug?: boolean;
+    credentials?: RequestCredentials;
+    /** Enable schema validation on init (dev mode). Logs warning if types are outdated. */
+    validateSchema?: boolean;
+}
+type Equal<X, Y> = (<T>() => T extends X ? 1 : 2) extends <T>() => T extends Y ? 1 : 2 ? true : false;
+type GetPopulated<TBase, TPopulate> = Equal<TBase, Permission> extends true ? PermissionGetPayload<{
+    populate: TPopulate;
+}> : Equal<TBase, Role> extends true ? RoleGetPayload<{
+    populate: TPopulate;
+}> : Equal<TBase, User> extends true ? UserGetPayload<{
+    populate: TPopulate;
+}> : Equal<TBase, Access> extends true ? AccessGetPayload<{
+    populate: TPopulate;
+}> : Equal<TBase, AiStudio> extends true ? AiStudioGetPayload<{
+    populate: TPopulate;
+}> : Equal<TBase, Auth> extends true ? AuthGetPayload<{
+    populate: TPopulate;
+}> : Equal<TBase, Banner> extends true ? BannerGetPayload<{
+    populate: TPopulate;
+}> : Equal<TBase, Catalog> extends true ? CatalogGetPayload<{
+    populate: TPopulate;
+}> : Equal<TBase, Category> extends true ? CategoryGetPayload<{
+    populate: TPopulate;
+}> : Equal<TBase, Faq> extends true ? FaqGetPayload<{
+    populate: TPopulate;
+}> : Equal<TBase, Gallery> extends true ? GalleryGetPayload<{
+    populate: TPopulate;
+}> : Equal<TBase, Guide> extends true ? GuideGetPayload<{
+    populate: TPopulate;
+}> : Equal<TBase, GuideCategory> extends true ? GuideCategoryGetPayload<{
+    populate: TPopulate;
+}> : Equal<TBase, GuidePage> extends true ? GuidePageGetPayload<{
+    populate: TPopulate;
+}> : Equal<TBase, Item> extends true ? ItemGetPayload<{
+    populate: TPopulate;
+}> : Equal<TBase, Landing> extends true ? LandingGetPayload<{
+    populate: TPopulate;
+}> : Equal<TBase, PartnerCommission> extends true ? PartnerCommissionGetPayload<{
+    populate: TPopulate;
+}> : Equal<TBase, PartnerProfile> extends true ? PartnerProfileGetPayload<{
+    populate: TPopulate;
+}> : Equal<TBase, Payment> extends true ? PaymentGetPayload<{
+    populate: TPopulate;
+}> : Equal<TBase, Plan> extends true ? PlanGetPayload<{
+    populate: TPopulate;
+}> : Equal<TBase, Project> extends true ? ProjectGetPayload<{
+    populate: TPopulate;
+}> : Equal<TBase, ProjectChat> extends true ? ProjectChatGetPayload<{
+    populate: TPopulate;
+}> : Equal<TBase, Referral> extends true ? ReferralGetPayload<{
+    populate: TPopulate;
+}> : Equal<TBase, Subscription> extends true ? SubscriptionGetPayload<{
+    populate: TPopulate;
+}> : Equal<TBase, Support> extends true ? SupportGetPayload<{
+    populate: TPopulate;
+}> : Equal<TBase, SupportCategory> extends true ? SupportCategoryGetPayload<{
+    populate: TPopulate;
+}> : Equal<TBase, SupportCenter> extends true ? SupportCenterGetPayload<{
+    populate: TPopulate;
+}> : Equal<TBase, SupportTheme> extends true ? SupportThemeGetPayload<{
+    populate: TPopulate;
+}> : Equal<TBase, Team> extends true ? TeamGetPayload<{
+    populate: TPopulate;
+}> : Equal<TBase, TeamInvitation> extends true ? TeamInvitationGetPayload<{
+    populate: TPopulate;
+}> : Equal<TBase, TeamMember> extends true ? TeamMemberGetPayload<{
+    populate: TPopulate;
+}> : Equal<TBase, TokenTransaction> extends true ? TokenTransactionGetPayload<{
+    populate: TPopulate;
+}> : Equal<TBase, UserSession> extends true ? UserSessionGetPayload<{
+    populate: TPopulate;
+}> : Equal<TBase, Website> extends true ? WebsiteGetPayload<{
+    populate: TPopulate;
+}> : TBase;
+type SelectFields<TFull, TBase, TFields extends string> = [TFields] extends [never] ? TFull : Pick<TBase, Extract<TFields | 'id' | 'documentId', keyof TBase>> & Omit<TFull, keyof TBase>;
+export interface LoginCredentials {
+    identifier: string;
+    password: string;
+}
+export interface RegisterData {
+    username: string;
+    email: string;
+    password: string;
+    referralCode?: string;
+    referralSource?: 'code' | 'link' | 'share';
+}
+export interface AuthResponse {
+    jwt: string;
+    user: User;
+}
+export interface ForgotPasswordData {
+    email: string;
+}
+export interface ResetPasswordData {
+    code: string;
+    password: string;
+    passwordConfirmation: string;
+}
+export interface ChangePasswordData {
+    currentPassword: string;
+    password: string;
+    passwordConfirmation: string;
+}
+export interface EmailConfirmationResponse {
+    jwt: string;
+    user: User;
+}
+declare class CollectionAPI<TBase, TInput = Partial<TBase>, TFilters = Record<string, any>, TPopulateKeys extends Record<string, any> = Record<string, any>> extends BaseAPI {
+    private endpoint;
+    constructor(endpoint: string, config: StrapiClientConfig);
+    find<const TPopulate extends TPopulateKeys, const TFields extends Exclude<keyof TBase & string, '__typename'> = never>(params: {
+        populate: TPopulate;
+    } & QueryParams<TBase, TFilters, TPopulate, TFields>, nextOptions?: NextOptions): Promise<SelectFields<GetPopulated<TBase, TPopulate>, TBase, TFields>[]>;
+    find<const TFields extends Exclude<keyof TBase & string, '__typename'> = never>(params: {
+        populate: '*' | true;
+    } & QueryParams<TBase, TFilters, '*' | true, TFields>, nextOptions?: NextOptions): Promise<SelectFields<GetPopulated<TBase, '*'>, TBase, TFields>[]>;
+    find<const TFields extends Exclude<keyof TBase & string, '__typename'> = never>(params?: QueryParams<TBase, TFilters, TPopulateKeys | (keyof TPopulateKeys & string)[] | '*' | boolean, TFields>, nextOptions?: NextOptions): Promise<SelectFields<TBase, TBase, TFields>[]>;
+    findOne<const TPopulate extends TPopulateKeys, const TFields extends Exclude<keyof TBase & string, '__typename'> = never>(documentId: string, params: {
+        populate: TPopulate;
+    } & QueryParams<TBase, TFilters, TPopulate, TFields>, nextOptions?: NextOptions): Promise<SelectFields<GetPopulated<TBase, TPopulate>, TBase, TFields> | null>;
+    findOne<const TFields extends Exclude<keyof TBase & string, '__typename'> = never>(documentId: string, params: {
+        populate: '*' | true;
+    } & QueryParams<TBase, TFilters, '*' | true, TFields>, nextOptions?: NextOptions): Promise<SelectFields<GetPopulated<TBase, '*'>, TBase, TFields> | null>;
+    findOne<const TFields extends Exclude<keyof TBase & string, '__typename'> = never>(documentId: string, params?: QueryParams<TBase, TFilters, TPopulateKeys | (keyof TPopulateKeys & string)[] | '*' | boolean, TFields>, nextOptions?: NextOptions): Promise<SelectFields<TBase, TBase, TFields> | null>;
+    create(data: TInput | FormData, nextOptions?: NextOptions): Promise<TBase>;
+    update(documentId: string, data: TInput | FormData, nextOptions?: NextOptions): Promise<TBase>;
+    delete(documentId: string, nextOptions?: NextOptions): Promise<TBase | null>;
+}
+declare class SingleTypeAPI<TBase, TInput = Partial<TBase>, TFilters = Record<string, any>, TPopulateKeys extends Record<string, any> = Record<string, any>> extends BaseAPI {
+    private endpoint;
+    constructor(endpoint: string, config: StrapiClientConfig);
+    find<const TPopulate extends TPopulateKeys, const TFields extends Exclude<keyof TBase & string, '__typename'> = never>(params: {
+        populate: TPopulate;
+    } & QueryParams<TBase, TFilters, TPopulate, TFields>, nextOptions?: NextOptions): Promise<SelectFields<GetPopulated<TBase, TPopulate>, TBase, TFields>>;
+    find<const TFields extends Exclude<keyof TBase & string, '__typename'> = never>(params: {
+        populate: '*' | true;
+    } & QueryParams<TBase, TFilters, '*' | true, TFields>, nextOptions?: NextOptions): Promise<SelectFields<GetPopulated<TBase, '*'>, TBase, TFields>>;
+    find<const TFields extends Exclude<keyof TBase & string, '__typename'> = never>(params?: QueryParams<TBase, TFilters, TPopulateKeys | (keyof TPopulateKeys & string)[] | '*' | boolean, TFields>, nextOptions?: NextOptions): Promise<SelectFields<TBase, TBase, TFields>>;
+    update(data: TInput | FormData, nextOptions?: NextOptions): Promise<TBase>;
+}
+declare class AiStudioAPI extends SingleTypeAPI<AiStudio, AiStudioInput, AiStudioFilters, AiStudioPopulateParam> {
+    /**
+     * GET /ai-studio/config
+     * Handler: ai-studio.getConfig
+     */
+    getConfig(): Promise<AIStudioAPI.GetConfigResponse>;
+    /**
+     * GET /ai-studio/stream
+     * Handler: ai-studio.stream
+     */
+    stream(): Promise<AIStudioAPI.StreamResponse>;
+    /**
+     * POST /ai-studio/generate-image
+     * Handler: ai-studio.generateImage
+     */
+    generateImage(data?: AIStudioAPI.GenerateImageRequest | FormData): Promise<AIStudioAPI.GenerateImageResponse>;
+}
+declare class CheckoutAPI extends BaseAPI {
+    constructor(config: StrapiClientConfig);
+    /**
+     * POST /checkout/plan
+     * Handler: checkout.buyPlan
+     */
+    buyPlan(data?: CheckoutAPI.BuyPlanRequest | FormData): Promise<CheckoutAPI.BuyPlanResponse>;
+    /**
+     * POST /checkout/tokens
+     * Handler: checkout.buyTokens
+     */
+    buyTokens(data?: CheckoutAPI.BuyTokensRequest | FormData): Promise<CheckoutAPI.BuyTokensResponse>;
+    /**
+     * POST /checkout/cancel
+     * Handler: checkout.cancel
+     */
+    cancel(data?: CheckoutAPI.CancelRequest | FormData): Promise<CheckoutAPI.CancelResponse>;
+}
+declare class ItemAPI extends CollectionAPI<Item, ItemInput, ItemFilters, ItemPopulateParam> {
+    /**
+     * POST /items/:id/increment-run
+     * Handler: item.incrementRun
+     */
+    incrementRun(id: string, data?: ItemAPI.IncrementRunRequest | FormData): Promise<ItemAPI.IncrementRunResponse>;
+}
+declare class KickstarterAPI extends BaseAPI {
+    constructor(config: StrapiClientConfig);
+    /**
+     * POST /kickstarter
+     * Handler: kickstarter.notifyNewRequest
+     */
+    notifyNewRequest(data?: any | FormData): Promise<any>;
+}
+declare class PartnerProfileAPI extends CollectionAPI<PartnerProfile, PartnerProfileInput, PartnerProfileFilters, PartnerProfilePopulateParam> {
+    /**
+     * PUT /partner-profiles/update-code
+     * Handler: partner-profile.updateCode
+     */
+    updateCode(data?: PartnerProfileAPI.UpdateCodeRequest | FormData): Promise<PartnerProfileAPI.UpdateCodeResponse>;
+}
+declare class TeamInvitationAPI extends CollectionAPI<TeamInvitation, TeamInvitationInput, TeamInvitationFilters, TeamInvitationPopulateParam> {
+    /**
+     * POST /team-invitations
+     * Handler: team-invitation.create
+     */
+    create(data?: TeamInvitationAPI.CreateRequest | FormData): Promise<TeamInvitationAPI.CreateResponse>;
+    /**
+     * DELETE /team-invitations/:id
+     * Handler: team-invitation.cancel
+     */
+    cancel(id: string): Promise<TeamInvitationAPI.CancelResponse>;
+    /**
+     * GET /team-invitations/info/:token
+     * Handler: team-invitation.info
+     */
+    info(token: string): Promise<TeamInvitationAPI.InfoResponse>;
+    /**
+     * POST /team-invitations/accept/:token
+     * Handler: team-invitation.accept
+     */
+    accept(token: string, data?: TeamInvitationAPI.AcceptRequest | FormData): Promise<TeamInvitationAPI.AcceptResponse>;
+    /**
+     * POST /team-invitations/decline/:token
+     * Handler: team-invitation.decline
+     */
+    decline(token: string, data?: TeamInvitationAPI.DeclineRequest | FormData): Promise<TeamInvitationAPI.DeclineResponse>;
+}
+declare class TeamMemberAPI extends CollectionAPI<TeamMember, TeamMemberInput, TeamMemberFilters, TeamMemberPopulateParam> {
+    /**
+     * GET /team-members
+     * Handler: team-member.getTeam
+     */
+    getTeam(): Promise<TeamMemberAPI.GetTeamResponse>;
+    /**
+     * DELETE /team-members/:id
+     * Handler: team-member.remove
+     */
+    remove(id: string): Promise<TeamMemberAPI.RemoveResponse>;
+    /**
+     * POST /team-members/leave
+     * Handler: team-member.leave
+     */
+    leave(data?: TeamMemberAPI.LeaveRequest | FormData): Promise<TeamMemberAPI.LeaveResponse>;
+}
+declare class WebhookAPI extends BaseAPI {
+    constructor(config: StrapiClientConfig);
+    /**
+     * POST /webhook/yookassa
+     * Handler: webhook.yooKassa
+     */
+    yooKassa(data?: WebhookAPI.YooKassaRequest | FormData): Promise<WebhookAPI.YooKassaResponse>;
+    /**
+     * POST /webhook/stripe
+     * Handler: webhook.stripe
+     */
+    stripe(data?: WebhookAPI.StripeRequest | FormData): Promise<WebhookAPI.StripeResponse>;
+}
+declare class AuthAPI extends BaseAPI {
+    constructor(config: StrapiClientConfig);
+    /**
+     * Login with email/username and password
+     * POST /api/auth/local
+     */
+    login(credentials: LoginCredentials): Promise<AuthResponse>;
+    /**
+     * Register a new user
+     * POST /api/auth/local/register
+     */
+    register(data: RegisterData): Promise<AuthResponse>;
+    /**
+     * Get current authenticated user
+     * GET /api/users/me
+     * Supports populate with automatic type inference
+     */
+    me<const TPopulate extends UserPopulateParam, const TFields extends Exclude<keyof User & string, '__typename'> = never>(params: {
+        populate: TPopulate;
+    } & QueryParams<User, UserFilters, TPopulate, TFields>, nextOptions?: NextOptions): Promise<SelectFields<GetPopulated<User, TPopulate>, User, TFields>>;
+    me<const TFields extends Exclude<keyof User & string, '__typename'> = never>(params: {
+        populate: '*' | true;
+    } & QueryParams<User, UserFilters, '*' | true, TFields>, nextOptions?: NextOptions): Promise<SelectFields<GetPopulated<User, '*'>, User, TFields>>;
+    me<const TFields extends Exclude<keyof User & string, '__typename'> = never>(params?: QueryParams<User, UserFilters, UserPopulateParam | (keyof UserPopulateParam & string)[] | '*' | boolean, TFields>, nextOptions?: NextOptions): Promise<SelectFields<User, User, TFields>>;
+    /**
+     * Update current authenticated user
+     * PUT /api/users/me
+     * Supports populate with automatic type inference
+     */
+    updateMe<const TPopulate extends UserPopulateParam, const TFields extends Exclude<keyof User & string, '__typename'> = never>(data: Partial<User>, params: {
+        populate: TPopulate;
+    } & QueryParams<User, UserFilters, TPopulate, TFields>, nextOptions?: NextOptions): Promise<SelectFields<GetPopulated<User, TPopulate>, User, TFields>>;
+    updateMe<const TFields extends Exclude<keyof User & string, '__typename'> = never>(data: Partial<User>, params: {
+        populate: '*' | true;
+    } & QueryParams<User, UserFilters, '*' | true, TFields>, nextOptions?: NextOptions): Promise<SelectFields<GetPopulated<User, '*'>, User, TFields>>;
+    updateMe<const TFields extends Exclude<keyof User & string, '__typename'> = never>(data: Partial<User>, params?: QueryParams<User, UserFilters, UserPopulateParam | (keyof UserPopulateParam & string)[] | '*' | boolean, TFields>, nextOptions?: NextOptions): Promise<SelectFields<User, User, TFields>>;
+    /**
+     * OAuth callback
+     * GET /api/auth/:provider/callback
+     * @param provider - OAuth provider name (google, github, etc.)
+     * @param search - Query string (e.g., "access_token=xxx&code=yyy" or "?access_token=xxx")
+     */
+    callback(provider: string, search?: string, nextOptions?: NextOptions): Promise<AuthResponse>;
+    /**
+     * Logout current user (client-side token removal helper)
+     */
+    logout(): Promise<void>;
+    /**
+     * Request password reset email
+     * POST /api/auth/forgot-password
+     */
+    forgotPassword(data: ForgotPasswordData): Promise<{
+        ok: boolean;
+    }>;
+    /**
+     * Reset password using reset code
+     * POST /api/auth/reset-password
+     */
+    resetPassword(data: ResetPasswordData): Promise<AuthResponse>;
+    /**
+     * Change password for authenticated user
+     * POST /api/auth/change-password
+     */
+    changePassword(data: ChangePasswordData): Promise<AuthResponse>;
+    /**
+     * Confirm user email address
+     * GET /api/auth/email-confirmation?confirmation=TOKEN
+     */
+    confirmEmail(confirmationToken: string, nextOptions?: NextOptions): Promise<EmailConfirmationResponse>;
+    /**
+     * Send email confirmation
+     * POST /api/auth/send-email-confirmation
+     */
+    sendEmailConfirmation(email: string): Promise<{
+        ok: boolean;
+    }>;
+}
+export declare class StrapiClient {
+    private config;
+    authentication: AuthAPI;
+    permissions: CollectionAPI<Permission, PermissionInput, PermissionFilters, PermissionPopulateParam>;
+    roles: CollectionAPI<Role, RoleInput, RoleFilters, RolePopulateParam>;
+    users: CollectionAPI<User, UserInput, UserFilters, UserPopulateParam>;
+    accesses: CollectionAPI<Access, AccessInput, AccessFilters, AccessPopulateParam>;
+    aiStudio: AiStudioAPI;
+    auth: SingleTypeAPI<Auth, AuthInput, AuthFilters, AuthPopulateParam>;
+    banner: SingleTypeAPI<Banner, BannerInput, BannerFilters, BannerPopulateParam>;
+    catalog: SingleTypeAPI<Catalog, CatalogInput, CatalogFilters, CatalogPopulateParam>;
+    categories: CollectionAPI<Category, CategoryInput, CategoryFilters, CategoryPopulateParam>;
+    faq: SingleTypeAPI<Faq, FaqInput, FaqFilters, FaqPopulateParam>;
+    galleries: CollectionAPI<Gallery, GalleryInput, GalleryFilters, GalleryPopulateParam>;
+    guides: CollectionAPI<Guide, GuideInput, GuideFilters, GuidePopulateParam>;
+    guideCategories: CollectionAPI<GuideCategory, GuideCategoryInput, GuideCategoryFilters, GuideCategoryPopulateParam>;
+    guidePage: SingleTypeAPI<GuidePage, GuidePageInput, GuidePageFilters, GuidePagePopulateParam>;
+    items: ItemAPI;
+    landing: SingleTypeAPI<Landing, LandingInput, LandingFilters, LandingPopulateParam>;
+    legals: CollectionAPI<Legal, LegalInput, LegalFilters>;
+    partnerCommissions: CollectionAPI<PartnerCommission, PartnerCommissionInput, PartnerCommissionFilters, PartnerCommissionPopulateParam>;
+    partnerProfiles: PartnerProfileAPI;
+    partnerSetting: SingleTypeAPI<PartnerSetting, PartnerSettingInput, PartnerSettingFilters>;
+    payments: CollectionAPI<Payment, PaymentInput, PaymentFilters, PaymentPopulateParam>;
+    plans: CollectionAPI<Plan, PlanInput, PlanFilters, PlanPopulateParam>;
+    projects: CollectionAPI<Project, ProjectInput, ProjectFilters, ProjectPopulateParam>;
+    projectChats: CollectionAPI<ProjectChat, ProjectChatInput, ProjectChatFilters, ProjectChatPopulateParam>;
+    referrals: CollectionAPI<Referral, ReferralInput, ReferralFilters, ReferralPopulateParam>;
+    subscriptions: CollectionAPI<Subscription, SubscriptionInput, SubscriptionFilters, SubscriptionPopulateParam>;
+    supports: CollectionAPI<Support, SupportInput, SupportFilters, SupportPopulateParam>;
+    supportCategories: CollectionAPI<SupportCategory, SupportCategoryInput, SupportCategoryFilters, SupportCategoryPopulateParam>;
+    supportCenter: SingleTypeAPI<SupportCenter, SupportCenterInput, SupportCenterFilters, SupportCenterPopulateParam>;
+    supportThemes: CollectionAPI<SupportTheme, SupportThemeInput, SupportThemeFilters, SupportThemePopulateParam>;
+    teams: CollectionAPI<Team, TeamInput, TeamFilters, TeamPopulateParam>;
+    teamInvitations: TeamInvitationAPI;
+    teamMembers: TeamMemberAPI;
+    tokenTransactions: CollectionAPI<TokenTransaction, TokenTransactionInput, TokenTransactionFilters, TokenTransactionPopulateParam>;
+    userSessions: CollectionAPI<UserSession, UserSessionInput, UserSessionFilters, UserSessionPopulateParam>;
+    websites: CollectionAPI<Website, WebsiteInput, WebsiteFilters, WebsitePopulateParam>;
+    checkout: CheckoutAPI;
+    kickstarter: KickstarterAPI;
+    webhook: WebhookAPI;
+    constructor(config: StrapiClientConfig);
+    setToken(token: string): void;
+    /**
+     * Validate that local types match the remote Strapi schema.
+     * Useful for detecting schema drift in development.
+     * @returns Promise<{ valid: boolean; localHash: string; remoteHash?: string; error?: string }>
+     */
+    validateSchema(): Promise<{
+        valid: boolean;
+        localHash: string;
+        remoteHash?: string;
+        error?: string;
+    }>;
+}
+export {};