@unidy.io/sdk 1.1.4 → 1.2.0-alpha2

package/dist/types/api/base-client.d.ts

@@ -0,0 +1,54 @@
+/**
+ * Base API client with shared functionality for both browser and standalone environments.
+ */
+export interface ApiResponse<T> {
+    data?: T;
+    success: boolean;
+    status: number;
+    headers: Headers;
+    error?: Error | string;
+    connectionError?: boolean;
+}
+export interface ApiClientConfig {
+    baseUrl: string;
+    apiKey: string;
+    onConnectionChange?: (isConnected: boolean) => void;
+}
+/** Query parameters that can be passed to GET requests */
+export type QueryParams = Record<string, string | number | boolean | undefined | null>;
+/**
+ * Abstract base class for API clients.
+ * Provides shared functionality for making HTTP requests.
+ */
+export declare abstract class BaseApiClient {
+    /**
+     * Error messages that indicate a connection failure rather than a server error.
+     * Grouped by source/environment.
+     */
+    protected static readonly CONNECTION_ERROR_MESSAGES: string[];
+    protected onConnectionChange?: (isConnected: boolean) => void;
+    baseUrl: string;
+    api_key: string;
+    constructor(config: ApiClientConfig);
+    protected isConnectionError(error: unknown): boolean;
+    protected setConnectionStatus(isConnected: boolean): void;
+    protected baseHeaders(): Headers;
+    protected mergeHeaders(base: Headers, extra?: HeadersInit): Headers;
+    /**
+     * Builds a query string from params, filtering out undefined/null values.
+     */
+    protected buildQueryString(params?: QueryParams): string;
+    /**
+     * Override this in subclasses to add environment-specific request options.
+     */
+    protected abstract getRequestOptions(): RequestInit;
+    /**
+     * Override this in subclasses to handle connection errors (e.g., Sentry reporting).
+     */
+    protected abstract handleConnectionError(error: unknown, endpoint: string, method: string): void;
+    protected request<T>(method: string, endpoint: string, body?: object, headers?: HeadersInit): Promise<ApiResponse<T>>;
+    get<T>(endpoint: string, headers?: HeadersInit, params?: QueryParams): Promise<ApiResponse<T>>;
+    post<T>(endpoint: string, body: object, headers?: HeadersInit): Promise<ApiResponse<T>>;
+    patch<T>(endpoint: string, body: object, headers?: HeadersInit): Promise<ApiResponse<T>>;
+    delete<T>(endpoint: string, headers?: HeadersInit): Promise<ApiResponse<T>>;
+}

package/dist/types/api/base-service.d.ts

@@ -0,0 +1,62 @@
+import type { ApiResponse, QueryParams } from "./base-client";
+import { type SchemaValidationError } from "./shared";
+/**
+ * Minimal logger interface that services depend on
+ */
+export interface Logger {
+    error: (...args: any[]) => void;
+    warn: (...args: any[]) => void;
+    info: (...args: any[]) => void;
+    debug: (...args: any[]) => void;
+}
+/**
+ * Error reporter interface for capturing exceptions
+ */
+export interface ErrorReporter {
+    captureException: (error: unknown, context?: Record<string, unknown>) => void;
+}
+/**
+ * Dependencies that can be injected into services
+ */
+export interface ServiceDependencies {
+    /** Logger instance - defaults to console */
+    logger?: Logger;
+    /** Error reporter (e.g., Sentry) - defaults to no-op */
+    errorReporter?: ErrorReporter;
+    /** Get the current ID token for authenticated requests */
+    getIdToken?: () => Promise<string | null>;
+    /** Get the current locale for i18n */
+    getLocale?: () => string;
+}
+export type Payload<T> = {
+    payload: T;
+};
+export type Options<T> = {
+    options?: Partial<T>;
+};
+/**
+ * API Client interface that services depend on
+ */
+export interface ApiClientInterface {
+    baseUrl: string;
+    api_key: string;
+    get<T>(endpoint: string, headers?: HeadersInit, params?: QueryParams): Promise<ApiResponse<T>>;
+    post<T>(endpoint: string, body: object, headers?: HeadersInit): Promise<ApiResponse<T>>;
+    patch<T>(endpoint: string, body: object, headers?: HeadersInit): Promise<ApiResponse<T>>;
+    delete<T>(endpoint: string, headers?: HeadersInit): Promise<ApiResponse<T>>;
+}
+export type CommonErrors = ["connection_failed", null] | ["schema_validation_error", SchemaValidationError];
+export type ServiceResult<TSuccess, TError extends string = never> = CommonErrors | (TError extends never ? never : [TError, {
+    error_identifier: string;
+    [key: string]: unknown;
+}]) | [null, TSuccess];
+export declare abstract class BaseService {
+    protected client: ApiClientInterface;
+    protected logger: Logger;
+    protected errorReporter: ErrorReporter;
+    protected getIdToken: () => Promise<string | null>;
+    protected getLocale: () => string;
+    constructor(client: ApiClientInterface, serviceName: string, deps?: ServiceDependencies);
+    protected handleResponse<T>(response: ApiResponse<unknown>, handler: () => T): T | ["connection_failed", null] | ["schema_validation_error", SchemaValidationError];
+    protected buildAuthHeaders(headers: Record<string, string | undefined>): HeadersInit | undefined;
+}

package/dist/types/api/client.d.ts

@@ -1,32 +1,10 @@
-import type * as z from "zod";
-export interface ApiResponse<T> {
-    data?: T;
-    success: boolean;
-    status: number;
-    headers: Headers;
-    error?: Error | string;
-    connectionError?: boolean;
-}
-export type ApiConfig = {
-    baseUrl: string;
-    apiKey: string;
-    onConnectionChange?: (isConnected: boolean) => void;
-};
-export declare class ApiClient {
-    baseUrl: string;
-    api_key: string;
-    private static readonly CONNECTION_ERROR_MESSAGES;
-    private onConnectionChange?;
-    private logger;
-    constructor(baseUrl: string, api_key: string, onConnectionChange?: (isConnected: boolean) => void);
-    private isConnectionError;
-    private setConnectionStatus;
-    private baseHeaders;
-    private mergeHeaders;
-    private request;
-    get<T>(endpoint: string, headers?: HeadersInit): Promise<ApiResponse<T>>;
-    post<T>(endpoint: string, body: object, headers?: HeadersInit): Promise<ApiResponse<T>>;
-    patch<T>(endpoint: string, body: object, headers?: HeadersInit): Promise<ApiResponse<T>>;
-    delete<T>(endpoint: string, headers?: HeadersInit): Promise<ApiResponse<T>>;
-    getWithSchema<TReturn, TArgs extends object, TParams = undefined>(returnSchema: z.ZodSchema<TReturn>, urlBuilder: (args: TArgs) => string, paramSchema?: z.ZodSchema<TParams>): TParams extends undefined ? (args: TArgs) => Promise<ApiResponse<TReturn>> : (args: TArgs, params?: TParams) => Promise<ApiResponse<TReturn>>;
+import { BaseApiClient } from "./base-client";
+export type { ApiResponse, ApiClientConfig, QueryParams } from "./base-client";
+/**
+ * Browser-specific API client with CORS mode and Sentry error reporting.
+ */
+export declare class ApiClient extends BaseApiClient {
+    constructor(baseUrl: string, apiKey: string, onConnectionChange?: (isConnected: boolean) => void);
+    protected getRequestOptions(): RequestInit;
+    protected handleConnectionError(error: unknown, endpoint: string, method: string): void;
 }

package/dist/types/api/index.d.ts

@@ -7,6 +7,7 @@ export * from "../auth/api/auth";
 export * from "../newsletter/api/newsletters";
 export * from "../profile/api/profile";
 export * from "./shared";
+export * from "./base-service";
 export * from "../ticketable/api/subscriptions";
 export * from "../ticketable/api/tickets";
 export declare class UnidyClient {

package/dist/types/api/shared.d.ts

@@ -1,4 +1,15 @@
 import * as z from "zod";
+/**
+ * Base error schema that all API errors extend from.
+ * Contains the common error_identifier field.
+ */
+export declare const BaseErrorSchema: z.ZodObject<{
+    error_identifier: z.ZodString;
+}, z.core.$strip>;
+export type BaseError = z.infer<typeof BaseErrorSchema>;
+/**
+ * Schema validation error extends base error with an array of error messages.
+ */
 export declare const SchemaValidationErrorSchema: z.ZodObject<{
     error_identifier: z.ZodString;
     errors: z.ZodArray<z.ZodString>;

package/dist/types/api/standalone.d.ts

@@ -0,0 +1,105 @@
+import { AuthService } from "../auth/api/auth";
+import { NewsletterService } from "../newsletter/api/newsletters";
+import { ProfileService } from "../profile/api/profile";
+import { TicketsService } from "../ticketable/api/tickets";
+import { SubscriptionsService } from "../ticketable/api/subscriptions";
+import { BaseApiClient } from "./base-client";
+import type { ServiceDependencies } from "./base-service";
+/**
+ * Standalone API client and services for use outside of Stencil components.
+ * This module can be used in Node.js or any other JavaScript environment.
+ *
+ * @example
+ * ```typescript
+ * import {
+ *   StandaloneApiClient,
+ *   AuthService,
+ *   NewsletterService,
+ * } from '@unidy.io/sdk/standalone';
+ *
+ * // Create the API client
+ * const client = new StandaloneApiClient({
+ *   baseUrl: 'https://api.unidy.io',
+ *   apiKey: 'your-api-key',
+ * });
+ *
+ * // Create services with optional custom logger/error reporter
+ * const auth = new AuthService(client, {
+ *   logger: console,
+ *   errorReporter: { captureException: (e) => myErrorTracker.capture(e) },
+ * });
+ *
+ * // Use the services
+ * const result = await auth.createSignIn({ payload: { email: 'user@example.com' } });
+ * ```
+ */
+export { AuthService } from "../auth/api/auth";
+export { NewsletterService } from "../newsletter/api/newsletters";
+export { ProfileService } from "../profile/api/profile";
+export { TicketsService } from "../ticketable/api/tickets";
+export { SubscriptionsService } from "../ticketable/api/subscriptions";
+export type * from "../auth/api/auth";
+export type * from "../newsletter/api/newsletters";
+export type * from "../profile/api/profile";
+export type * from "../ticketable/api/tickets";
+export type * from "../ticketable/api/subscriptions";
+export type { SchemaValidationError, PaginationMeta, PaginationParams } from "./shared";
+export type { CommonErrors, ServiceResult, Logger, ErrorReporter, ServiceDependencies, ApiClientInterface, } from "./base-service";
+export type { ApiResponse, ApiClientConfig, QueryParams } from "./base-client";
+/**
+ * Standalone API client without browser-specific dependencies.
+ *
+ * This client provides the same interface as the browser ApiClient but without
+ * dependencies on Sentry, i18n, localStorage, or other browser APIs.
+ *
+ * @example
+ * ```typescript
+ * import { StandaloneApiClient, AuthService } from '@unidy.io/sdk/standalone';
+ *
+ * const client = new StandaloneApiClient({
+ *   baseUrl: 'https://api.unidy.io',
+ *   apiKey: 'your-api-key',
+ * });
+ *
+ * const auth = new AuthService(client);
+ * const result = await auth.createSignIn({ payload: { email: 'user@example.com' } });
+ * ```
+ */
+export declare class StandaloneApiClient extends BaseApiClient {
+    protected getRequestOptions(): RequestInit;
+    protected handleConnectionError(_error: unknown, _endpoint: string, _method: string): void;
+}
+import type { ApiClientConfig } from "./base-client";
+/**
+ * Creates a standalone Unidy client with all services for use outside of Stencil.
+ *
+ * @example
+ * ```typescript
+ * import { createStandaloneClient } from '@unidy.io/sdk/standalone';
+ *
+ * const client = createStandaloneClient({
+ *   baseUrl: 'https://api.unidy.io',
+ *   apiKey: 'your-api-key',
+ *   // Optional: inject custom dependencies
+ *   deps: {
+ *     logger: myLogger,
+ *     errorReporter: { captureException: (e) => Sentry.captureException(e) },
+ *   },
+ * });
+ *
+ * const signIn = await client.auth.createSignIn({ payload: { email: 'user@example.com' } });
+ * ```
+ */
+export interface StandaloneUnidyClientConfig extends ApiClientConfig {
+    /** Optional dependencies to inject into all services */
+    deps?: ServiceDependencies;
+}
+export declare class StandaloneUnidyClient {
+    auth: AuthService;
+    newsletters: NewsletterService;
+    profile: ProfileService;
+    tickets: TicketsService;
+    subscriptions: SubscriptionsService;
+    constructor(config: StandaloneUnidyClientConfig);
+}
+export declare function createStandaloneClient(config: StandaloneUnidyClientConfig): StandaloneUnidyClient;

package/dist/types/auth/api/auth.d.ts

@@ -1,253 +1,58 @@
-import * as z from "zod";
-import { type ApiClient, type SchemaValidationError } from "../../api";
-declare const LoginOptionsSchema: z.ZodObject<{
-    magic_link: z.ZodBoolean;
-    password: z.ZodBoolean;
-    social_logins: z.ZodArray<z.ZodString>;
-    passkey: z.ZodBoolean;
-}, z.core.$strip>;
-declare const CreateSignInResponseSchema: z.ZodObject<{
-    sid: z.ZodString;
-    status: z.ZodEnum<{
-        pending_verification: "pending_verification";
-        authenticated: "authenticated";
-        completed: "completed";
-    }>;
-    email: z.ZodString;
-    expired: z.ZodBoolean;
-    login_options: z.ZodObject<{
-        magic_link: z.ZodBoolean;
-        password: z.ZodBoolean;
-        social_logins: z.ZodArray<z.ZodString>;
-        passkey: z.ZodBoolean;
-    }, z.core.$strip>;
-}, z.core.$strip>;
-declare const ErrorSchema: z.ZodObject<{
-    error_identifier: z.ZodString;
-}, z.core.$strip>;
-declare const SendMagicCodeResponseSchema: z.ZodObject<{
-    enable_resend_after: z.ZodNumber;
-    sid: z.ZodOptional<z.ZodString>;
-}, z.core.$strip>;
-declare const SendMagicCodeErrorSchema: z.ZodObject<{
-    error_identifier: z.ZodString;
-    enable_resend_after: z.ZodNumber;
-}, z.core.$strip>;
-declare const TokenResponseSchema: z.ZodObject<{
-    jwt: z.ZodString;
-    sid: z.ZodOptional<z.ZodString>;
-}, z.core.$strip>;
-declare const RequiredFieldsResponseSchema: z.ZodObject<{
-    error_identifier: z.ZodLiteral<"missing_required_fields">;
-    fields: z.ZodObject<{
-        email: z.ZodOptional<z.ZodObject<{
-            required: z.ZodBoolean;
-            label: z.ZodString;
-            attr_name: z.ZodString;
-            locked: z.ZodOptional<z.ZodBoolean>;
-            locked_text: z.ZodOptional<z.ZodString>;
-            value: z.ZodUnion<readonly [z.ZodString, z.ZodNull]>;
-            type: z.ZodEnum<{
-                text: "text";
-                textarea: "textarea";
-            }>;
-        }, z.core.$strict>>;
-        salutation: z.ZodOptional<z.ZodObject<{
-            required: z.ZodBoolean;
-            label: z.ZodString;
-            attr_name: z.ZodString;
-            locked: z.ZodOptional<z.ZodBoolean>;
-            locked_text: z.ZodOptional<z.ZodString>;
-            value: z.ZodNullable<z.ZodUnion<readonly [z.ZodString, z.ZodLiteral<"_NOT_SET_">, z.ZodBoolean]>>;
-            type: z.ZodEnum<{
-                radio: "radio";
-            }>;
-            radio_options: z.ZodArray<z.ZodObject<{
-                value: z.ZodNullable<z.ZodUnion<readonly [z.ZodString, z.ZodLiteral<"_NOT_SET_">, z.ZodBoolean]>>;
-                label: z.ZodString;
-                checked: z.ZodBoolean;
-            }, z.core.$strict>>;
-        }, z.core.$strict>>;
-        first_name: z.ZodOptional<z.ZodObject<{
-            required: z.ZodBoolean;
-            label: z.ZodString;
-            attr_name: z.ZodString;
-            locked: z.ZodOptional<z.ZodBoolean>;
-            locked_text: z.ZodOptional<z.ZodString>;
-            value: z.ZodUnion<readonly [z.ZodString, z.ZodNull]>;
-            type: z.ZodEnum<{
-                text: "text";
-                textarea: "textarea";
-            }>;
-        }, z.core.$strict>>;
-        last_name: z.ZodOptional<z.ZodObject<{
-            required: z.ZodBoolean;
-            label: z.ZodString;
-            attr_name: z.ZodString;
-            locked: z.ZodOptional<z.ZodBoolean>;
-            locked_text: z.ZodOptional<z.ZodString>;
-            value: z.ZodUnion<readonly [z.ZodString, z.ZodNull]>;
-            type: z.ZodEnum<{
-                text: "text";
-                textarea: "textarea";
-            }>;
-        }, z.core.$strict>>;
-        phone_number: z.ZodOptional<z.ZodObject<{
-            required: z.ZodBoolean;
-            label: z.ZodString;
-            attr_name: z.ZodString;
-            locked: z.ZodOptional<z.ZodBoolean>;
-            locked_text: z.ZodOptional<z.ZodString>;
-            value: z.ZodUnion<readonly [z.ZodNullable<z.ZodString>]>;
-            type: z.ZodEnum<{
-                tel: "tel";
-            }>;
-        }, z.core.$strict>>;
-        company_name: z.ZodOptional<z.ZodObject<{
-            required: z.ZodBoolean;
-            label: z.ZodString;
-            attr_name: z.ZodString;
-            locked: z.ZodOptional<z.ZodBoolean>;
-            locked_text: z.ZodOptional<z.ZodString>;
-            value: z.ZodUnion<readonly [z.ZodString, z.ZodNull]>;
-            type: z.ZodEnum<{
-                text: "text";
-                textarea: "textarea";
-            }>;
-        }, z.core.$strict>>;
-        address_line_1: z.ZodOptional<z.ZodObject<{
-            required: z.ZodBoolean;
-            label: z.ZodString;
-            attr_name: z.ZodString;
-            locked: z.ZodOptional<z.ZodBoolean>;
-            locked_text: z.ZodOptional<z.ZodString>;
-            value: z.ZodUnion<readonly [z.ZodString, z.ZodNull]>;
-            type: z.ZodEnum<{
-                text: "text";
-                textarea: "textarea";
-            }>;
-        }, z.core.$strict>>;
-        address_line_2: z.ZodOptional<z.ZodObject<{
-            required: z.ZodBoolean;
-            label: z.ZodString;
-            attr_name: z.ZodString;
-            locked: z.ZodOptional<z.ZodBoolean>;
-            locked_text: z.ZodOptional<z.ZodString>;
-            value: z.ZodUnion<readonly [z.ZodString, z.ZodNull]>;
-            type: z.ZodEnum<{
-                text: "text";
-                textarea: "textarea";
-            }>;
-        }, z.core.$strict>>;
-        city: z.ZodOptional<z.ZodObject<{
-            required: z.ZodBoolean;
-            label: z.ZodString;
-            attr_name: z.ZodString;
-            locked: z.ZodOptional<z.ZodBoolean>;
-            locked_text: z.ZodOptional<z.ZodString>;
-            value: z.ZodUnion<readonly [z.ZodString, z.ZodNull]>;
-            type: z.ZodEnum<{
-                text: "text";
-                textarea: "textarea";
-            }>;
-        }, z.core.$strict>>;
-        postal_code: z.ZodOptional<z.ZodObject<{
-            required: z.ZodBoolean;
-            label: z.ZodString;
-            attr_name: z.ZodString;
-            locked: z.ZodOptional<z.ZodBoolean>;
-            locked_text: z.ZodOptional<z.ZodString>;
-            value: z.ZodUnion<readonly [z.ZodString, z.ZodNull]>;
-            type: z.ZodEnum<{
-                text: "text";
-                textarea: "textarea";
-            }>;
-        }, z.core.$strict>>;
-        country_code: z.ZodOptional<z.ZodObject<{
-            required: z.ZodBoolean;
-            label: z.ZodString;
-            attr_name: z.ZodString;
-            locked: z.ZodOptional<z.ZodBoolean>;
-            locked_text: z.ZodOptional<z.ZodString>;
-            value: z.ZodNullable<z.ZodString>;
-            type: z.ZodEnum<{
-                select: "select";
-            }>;
-            options: z.ZodArray<z.ZodObject<{
-                value: z.ZodString;
-                label: z.ZodString;
-            }, z.core.$strict>>;
-        }, z.core.$strict>>;
-        date_of_birth: z.ZodOptional<z.ZodObject<{
-            required: z.ZodBoolean;
-            label: z.ZodString;
-            attr_name: z.ZodString;
-            locked: z.ZodOptional<z.ZodBoolean>;
-            locked_text: z.ZodOptional<z.ZodString>;
-            value: z.ZodUnion<readonly [z.ZodString, z.ZodNull]>;
-            type: z.ZodEnum<{
-                date: "date";
-                "datetime-local": "datetime-local";
-            }>;
-        }, z.core.$strict>>;
-        preferred_language: z.ZodOptional<z.ZodOptional<z.ZodObject<{
-            required: z.ZodBoolean;
-            label: z.ZodString;
-            attr_name: z.ZodString;
-            locked: z.ZodOptional<z.ZodBoolean>;
-            locked_text: z.ZodOptional<z.ZodString>;
-            value: z.ZodUnion<readonly [z.ZodString, z.ZodNull]>;
-            type: z.ZodEnum<{
-                text: "text";
-                textarea: "textarea";
-            }>;
-        }, z.core.$strict>>>;
-        custom_attributes: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodObject<{
-            required: z.ZodBoolean;
-            label: z.ZodString;
-            attr_name: z.ZodString;
-            locked: z.ZodOptional<z.ZodBoolean>;
-            locked_text: z.ZodOptional<z.ZodString>;
-            value: z.ZodUnion<readonly [z.ZodString, z.ZodNull, z.ZodBoolean, z.ZodNumber, z.ZodArray<z.ZodString>]>;
-            type: z.ZodEnum<{
-                number: "number";
-                boolean: "boolean";
-                date: "date";
-                radio: "radio";
-                text: "text";
-                textarea: "textarea";
-                tel: "tel";
-                select: "select";
-                "datetime-local": "datetime-local";
-                checkbox: "checkbox";
-            }>;
-            readonly: z.ZodBoolean;
-            radio_options: z.ZodOptional<z.ZodArray<z.ZodObject<{
-                value: z.ZodNullable<z.ZodUnion<readonly [z.ZodString, z.ZodLiteral<"_NOT_SET_">, z.ZodBoolean]>>;
-                label: z.ZodString;
-                checked: z.ZodBoolean;
-            }, z.core.$strict>>>;
-            options: z.ZodOptional<z.ZodArray<z.ZodObject<{
-                value: z.ZodString;
-                label: z.ZodString;
-            }, z.core.$strict>>>;
-        }, z.core.$strict>>>;
-    }, z.core.$strip>;
-    sid: z.ZodOptional<z.ZodString>;
-}, z.core.$strip>;
-declare const InvalidPasswordResponseSchema: z.ZodObject<{
-    error_details: z.ZodObject<{
-        password: z.ZodArray<z.ZodString>;
-    }, z.core.$strip>;
-}, z.core.$strip>;
-export type ErrorResponse = z.infer<typeof ErrorSchema>;
-export type LoginOptions = z.infer<typeof LoginOptionsSchema>;
-export type CreateSignInResponse = z.infer<typeof CreateSignInResponseSchema>;
-export type TokenResponse = z.infer<typeof TokenResponseSchema>;
-export type SendMagicCodeResponse = z.infer<typeof SendMagicCodeResponseSchema>;
-export type RequiredFieldsResponse = z.infer<typeof RequiredFieldsResponseSchema>;
-export type SendMagicCodeError = z.infer<typeof SendMagicCodeErrorSchema>;
-type CommonErrors = ["connection_failed", null] | ["schema_validation_error", SchemaValidationError];
+import { type ApiClientInterface, BaseService, type CommonErrors, type ServiceDependencies, type Payload } from "../../api";
+import { type CreateSignInResponse, type ErrorResponse, type InvalidPasswordResponse, type PasskeyCredential, type PasskeyOptionsResponse, type RequiredFieldsResponse, type SendMagicCodeError, type SendMagicCodeResponse, type TokenResponse } from "./schemas";
+export type { ErrorResponse, CreateSignInResponse, TokenResponse, SendMagicCodeResponse, RequiredFieldsResponse, SendMagicCodeError, InvalidPasswordResponse, PasskeyOptionsResponse, PasskeyCredential, } from "./schemas";
+export type { LoginOptions } from "./schemas";
+export type CreateSignInArgs = Payload<{
+    email: string;
+    password?: string;
+    sendMagicCode?: boolean;
+}>;
+export type SendMagicCodeArgs = {
+    signInId: string;
+};
+export type AuthenticateWithPasswordArgs = {
+    signInId: string;
+} & Payload<{
+    password: string;
+}>;
+export type AuthenticateWithMagicCodeArgs = {
+    signInId: string;
+} & Payload<{
+    code: string;
+}>;
+export type UpdateMissingFieldsArgs = {
+    signInId: string;
+} & Payload<{
+    user: Record<string, any>;
+}>;
+export type RefreshTokenArgs = {
+    signInId: string;
+};
+export type SendResetPasswordEmailArgs = {
+    signInId: string;
+} & Payload<{
+    returnTo: string;
+}>;
+export type ResetPasswordArgs = {
+    signInId: string;
+    token: string;
+} & Payload<{
+    password: string;
+    passwordConfirmation: string;
+}>;
+export type ValidateResetPasswordTokenArgs = {
+    signInId: string;
+    token: string;
+};
+export type SignOutArgs = {
+    signInId: string;
+};
+export type GetPasskeyOptionsArgs = {
+    signInId?: string;
+};
+export type AuthenticateWithPasskeyArgs = Payload<{
+    credential: PasskeyCredential;
+}>;
 export type CreateSignInResult = CommonErrors | ["account_not_found", ErrorResponse] | [null, CreateSignInResponse] | AuthenticateWithPasswordResult | SendMagicCodeResult;
 export type AuthenticateResultShared = CommonErrors | ["sign_in_not_found", ErrorResponse] | ["sign_in_expired", ErrorResponse] | ["account_locked", ErrorResponse] | ["missing_required_fields", RequiredFieldsResponse] | [null, TokenResponse];
 export type SendMagicCodeResult = CommonErrors | ["magic_code_recently_created", SendMagicCodeError] | ["sign_in_not_found", ErrorResponse] | ["sign_in_expired", ErrorResponse] | ["account_locked", ErrorResponse] | [null, SendMagicCodeResponse];
@@ -255,46 +60,25 @@ export type AuthenticateWithPasswordResult = ["invalid_password", ErrorResponse]
 export type AuthenticateWithMagicCodeResult = ["not_valid", ErrorResponse] | ["used", ErrorResponse] | ["expired", ErrorResponse] | AuthenticateResultShared;
 export type RefreshTokenResult = CommonErrors | ["invalid_refresh_token", ErrorResponse] | ["refresh_token_revoked", ErrorResponse] | ["sign_in_not_found", ErrorResponse] | [null, TokenResponse];
 export type SendResetPasswordEmailResult = CommonErrors | ["password_not_set", ErrorResponse] | ["reset_password_already_sent", ErrorResponse] | ["sign_in_not_found", ErrorResponse] | ["invalid_return_to", ErrorResponse] | ["return_to_required", ErrorResponse] | [null, null];
-export type InvalidPasswordResponse = z.infer<typeof InvalidPasswordResponseSchema>;
 export type ResetPasswordResult = CommonErrors | ["reset_token_missing", ErrorResponse] | ["invalid_reset_token", ErrorResponse] | ["reset_token_expired", ErrorResponse] | ["invalid_password", InvalidPasswordResponse] | [null, null];
 export type ValidateResetPasswordTokenResult = CommonErrors | ["reset_token_missing", ErrorResponse] | ["invalid_reset_token", ErrorResponse] | ["reset_token_expired", ErrorResponse] | [null, null];
 export type SignOutResult = CommonErrors | ["sign_in_not_found", ErrorResponse] | ["missing_id_token", ErrorResponse] | ["invalid_id_token", ErrorResponse] | [null, null];
-declare const PasskeyOptionsResponseSchema: z.ZodObject<{
-    challenge: z.ZodString;
-    timeout: z.ZodNumber;
-    rpId: z.ZodString;
-    userVerification: z.ZodString;
-    allowCredentials: z.ZodArray<z.ZodAny>;
-}, z.core.$strip>;
-declare const PasskeyCredentialSchema: z.ZodObject<{
-    id: z.ZodString;
-    rawId: z.ZodString;
-    response: z.ZodObject<{
-        authenticatorData: z.ZodString;
-        clientDataJSON: z.ZodString;
-        signature: z.ZodString;
-    }, z.core.$strip>;
-    type: z.ZodString;
-}, z.core.$strip>;
-export type PasskeyOptionsResponse = z.infer<typeof PasskeyOptionsResponseSchema>;
-export type PasskeyCredential = z.infer<typeof PasskeyCredentialSchema>;
 export type GetPasskeyOptionsResult = CommonErrors | ["bad_request", ErrorResponse] | [null, PasskeyOptionsResponse];
 export type AuthenticateWithPasskeyResult = CommonErrors | ["invalid_passkey", ErrorResponse] | ["verification_failed", ErrorResponse] | ["authentication_failed", ErrorResponse] | ["bad_request", ErrorResponse] | [null, TokenResponse];
-export declare class AuthService {
-    private client;
-    constructor(client: ApiClient);
-    createSignIn(email: string, password?: string, sendMagicCode?: boolean): Promise<CreateSignInResult>;
-    sendMagicCode(signInId: string): Promise<SendMagicCodeResult>;
-    authenticateWithPassword(signInId: string, password: string): Promise<AuthenticateWithPasswordResult>;
-    updateMissingFields(signInId: string, user: Record<string, any>): Promise<AuthenticateResultShared>;
-    authenticateWithMagicCode(signInId: string, code: string): Promise<AuthenticateWithMagicCodeResult>;
-    refreshToken(signInId: string): Promise<RefreshTokenResult>;
-    sendResetPasswordEmail(signInId: string, returnTo: string): Promise<SendResetPasswordEmailResult>;
-    resetPassword(signInId: string, token: string, password: string, passwordConfirmation: string): Promise<ResetPasswordResult>;
-    validateResetPasswordToken(signInId: string, token: string): Promise<ValidateResetPasswordTokenResult>;
-    signOut(signInId: string): Promise<SignOutResult>;
-    getPasskeyOptions(sid?: string): Promise<GetPasskeyOptionsResult>;
-    authenticateWithPasskey(credential: PasskeyCredential): Promise<AuthenticateWithPasskeyResult>;
-    private handleResponse;
+export declare class AuthService extends BaseService {
+    constructor(client: ApiClientInterface, deps?: ServiceDependencies);
+    /** Safely parse error response, returning a fallback if parsing fails */
+    private parseErrorResponse;
+    createSignIn(args: CreateSignInArgs): Promise<CreateSignInResult>;
+    sendMagicCode(args: SendMagicCodeArgs): Promise<SendMagicCodeResult>;
+    authenticateWithPassword(args: AuthenticateWithPasswordArgs): Promise<AuthenticateWithPasswordResult>;
+    updateMissingFields(args: UpdateMissingFieldsArgs): Promise<AuthenticateResultShared>;
+    authenticateWithMagicCode(args: AuthenticateWithMagicCodeArgs): Promise<AuthenticateWithMagicCodeResult>;
+    refreshToken(args: RefreshTokenArgs): Promise<RefreshTokenResult>;
+    sendResetPasswordEmail(args: SendResetPasswordEmailArgs): Promise<SendResetPasswordEmailResult>;
+    resetPassword(args: ResetPasswordArgs): Promise<ResetPasswordResult>;
+    validateResetPasswordToken(args: ValidateResetPasswordTokenArgs): Promise<ValidateResetPasswordTokenResult>;
+    signOut(args: SignOutArgs): Promise<SignOutResult>;
+    getPasskeyOptions(args?: GetPasskeyOptionsArgs): Promise<GetPasskeyOptionsResult>;
+    authenticateWithPasskey(args: AuthenticateWithPasskeyArgs): Promise<AuthenticateWithPasskeyResult>;
 }
-export {};