@unidy.io/sdk 1.1.4 → 1.2.0-alpha

package/dist/esm/{index-DSDkaHWI.js → index-2p1QEJrx.js}

@@ -1,36 +1,54 @@
-import { t } from './i18n-CLdWzy5J.js';
-import { e as createLogger, d as captureException } from './index-Ci3aTmzp.js';
-import './profile-store-RmZB2PTc.js';
-import { u as unidyState } from './unidy-store-BldTAtO0.js';
+import { d as captureException, e as createLogger } from './index-Ci3aTmzp.js';
+import { w as waitForConfig, u as unidyState } from './unidy-store-BldTAtO0.js';
+import { a as authStore, s as state } from './auth-store-BMqUdTpC.js';
+import { t } from './i18n-BANodpxG.js';
+import { s as state$1 } from './profile-store-RmZB2PTc.js';
+import { F as Flash } from './flash-store-CEvWSG0c.js';
+import { c as clearUrlParam } from './component-utils-D1lzXl_Z.js';
 
-class ApiClient {
-    baseUrl;
-    api_key;
+/**
+ * Base API client with shared functionality for both browser and standalone environments.
+ */
+/**
+ * Abstract base class for API clients.
+ * Provides shared functionality for making HTTP requests.
+ */
+class BaseApiClient {
+    /**
+     * Error messages that indicate a connection failure rather than a server error.
+     * Grouped by source/environment.
+     */
     static CONNECTION_ERROR_MESSAGES = [
-        "Failed to fetch",
-        "NetworkError",
-        "ERR_CONNECTION_REFUSED",
-        "ERR_NETWORK",
-        "ERR_INTERNET_DISCONNECTED",
+        // Browser fetch API errors
+        "Failed to fetch", // Generic browser fetch failure (Chrome)
+        "NetworkError", // Firefox network error
+        "Load failed", // Safari network error
+        "The network connection was lost", // Safari connection lost
+        // Chromium/V8 error codes (used by Node.js and Chrome)
+        "ERR_CONNECTION_REFUSED", // Server not accepting connections
+        "ERR_NETWORK", // General network error
+        "ERR_INTERNET_DISCONNECTED", // No internet connection
+        // Node.js system error codes
+        "ECONNREFUSED", // Connection refused by server
+        "ENOTFOUND", // DNS lookup failed
+        "EAI_AGAIN", // Temporary DNS failure
     ];
     onConnectionChange;
-    logger = createLogger("ApiClient");
-    constructor(baseUrl, api_key, onConnectionChange) {
-        this.baseUrl = baseUrl;
-        this.api_key = api_key;
-        this.api_key = api_key;
-        this.onConnectionChange = onConnectionChange;
+    baseUrl;
+    api_key;
+    constructor(config) {
+        this.baseUrl = config.baseUrl;
+        this.api_key = config.apiKey;
+        this.onConnectionChange = config.onConnectionChange;
     }
     isConnectionError(error) {
         if (error instanceof Error) {
-            return ApiClient.CONNECTION_ERROR_MESSAGES.some((msg) => error.message.includes(msg));
+            return BaseApiClient.CONNECTION_ERROR_MESSAGES.some((msg) => error.message.includes(msg));
         }
         return false;
     }
     setConnectionStatus(isConnected) {
-        if (this.onConnectionChange) {
-            this.onConnectionChange(isConnected);
-        }
+        this.onConnectionChange?.(isConnected);
     }
     baseHeaders() {
         const h = new Headers();
@@ -48,15 +66,27 @@ class ApiClient {
         }
         return out;
     }
+    /**
+     * Builds a query string from params, filtering out undefined/null values.
+     */
+    buildQueryString(params) {
+        if (!params)
+            return "";
+        const filtered = Object.entries(params)
+            .filter(([_, v]) => v !== undefined && v !== null)
+            .map(([k, v]) => [k, String(v)]);
+        if (filtered.length === 0)
+            return "";
+        return `?${new URLSearchParams(Object.fromEntries(filtered)).toString()}`;
+    }
     async request(method, endpoint, body, headers) {
         let res = null;
         try {
             res = await fetch(`${this.baseUrl}${endpoint}`, {
                 method,
-                mode: "cors",
-                credentials: "include",
+                ...this.getRequestOptions(),
                 headers: this.mergeHeaders(this.baseHeaders(), headers),
-                body: JSON.stringify(body) || undefined,
+                body: body ? JSON.stringify(body) : undefined,
             });
             let data;
             try {
@@ -66,37 +96,33 @@ class ApiClient {
                 data = undefined;
             }
             this.setConnectionStatus(true);
-            const response = {
+            return {
                 data,
                 status: res.status,
                 headers: res.headers,
                 success: res.ok,
                 connectionError: false,
             };
-            return response;
         }
         catch (error) {
             const connectionFailed = this.isConnectionError(error);
             if (connectionFailed) {
                 this.setConnectionStatus(false);
-                captureException(error, {
-                    tags: { error_type: "connection_error" },
-                    extra: { endpoint, method },
-                });
+                this.handleConnectionError(error, endpoint, method);
             }
-            const response = {
-                status: res ? res.status : connectionFailed ? 0 : 500,
+            return {
+                status: res?.status ?? (connectionFailed ? 0 : 500),
                 error: error instanceof Error ? error.message : String(error),
-                headers: res ? res.headers : new Headers(),
+                headers: res?.headers ?? new Headers(),
                 success: false,
                 data: undefined,
                 connectionError: connectionFailed,
             };
-            return response;
         }
     }
-    async get(endpoint, headers) {
-        return this.request("GET", endpoint, undefined, headers);
+    async get(endpoint, headers, params) {
+        const queryString = this.buildQueryString(params);
+        return this.request("GET", `${endpoint}${queryString}`, undefined, headers);
     }
     async post(endpoint, body, headers) {
         return this.request("POST", endpoint, body, headers);
@@ -107,40 +133,26 @@ class ApiClient {
     async delete(endpoint, headers) {
         return this.request("DELETE", endpoint, undefined, headers);
     }
-    getWithSchema(returnSchema, urlBuilder, paramSchema) {
-        const fn = async (args, params) => {
-            // Build URL
-            const baseUrl = urlBuilder(args);
-            // Validate and parse params with Zod if provided
-            let queryString = "";
-            if (paramSchema && params) {
-                const validatedParams = paramSchema.parse(params);
-                queryString = `?${new URLSearchParams(validatedParams).toString()}`;
-            }
-            const fullUrl = `${baseUrl}${queryString}`;
-            const response = await this.get(fullUrl);
-            if (!response.success || !response.data) {
-                return response;
-            }
-            const parsed = returnSchema.safeParse(response.data);
-            if (!parsed.success) {
-                this.logger.error("Invalid response format", parsed.error);
-                return {
-                    ...response,
-                    success: false,
-                    error: t("errors.invalid_response_format", {
-                        defaultValue: "Invalid response format",
-                    }),
-                    data: undefined,
-                };
-            }
-            return {
-                ...response,
-                data: parsed.data,
-            };
+}
+
+/**
+ * Browser-specific API client with CORS mode and Sentry error reporting.
+ */
+class ApiClient extends BaseApiClient {
+    constructor(baseUrl, apiKey, onConnectionChange) {
+        super({ baseUrl, apiKey, onConnectionChange });
+    }
+    getRequestOptions() {
+        return {
+            mode: "cors",
+            credentials: "include",
         };
-        // biome-ignore lint/suspicious/noExplicitAny: fn can literally be any function
-        return fn;
+    }
+    handleConnectionError(error, endpoint, method) {
+        captureException(error, {
+            tags: { error_type: "connection_error" },
+            extra: { endpoint, method },
+        });
     }
 }
 
@@ -684,7 +696,6 @@ const _parse = (_Err) => (schema, value, _ctx, _params) => {
     }
     return result.value;
 };
-const parse$1 = /* @__PURE__*/ _parse($ZodRealError);
 const _parseAsync = (_Err) => async (schema, value, _ctx, params) => {
     const ctx = _ctx ? Object.assign(_ctx, { async: true }) : { async: true };
     let result = schema._zod.run({ value, issues: [] }, ctx);
@@ -697,7 +708,6 @@ const _parseAsync = (_Err) => async (schema, value, _ctx, params) => {
     }
     return result.value;
 };
-const parseAsync$1 = /* @__PURE__*/ _parseAsync($ZodRealError);
 const _safeParse = (_Err) => (schema, value, _ctx) => {
     const ctx = _ctx ? { ..._ctx, async: false } : { async: false };
     const result = schema._zod.run({ value, issues: [] }, ctx);
@@ -820,14 +830,13 @@ function datetime$1(args) {
     const timeRegex = `${time}(?:${opts.join("|")})`;
     return new RegExp(`^${dateSource}T(?:${timeRegex})$`);
 }
-const string$2 = (params) => {
+const string$1 = (params) => {
     const regex = params ? `[\\s\\S]{${params?.minimum ?? 0},${params?.maximum ?? ""}}` : `[\\s\\S]*`;
     return new RegExp(`^${regex}$`);
 };
 const integer = /^-?\d+$/;
-const number$2 = /^-?\d+(?:\.\d+)?/;
-const boolean$2 = /^(?:true|false)$/i;
-const _null$3 = /^null$/i;
+const number$1 = /^-?\d+(?:\.\d+)?/;
+const boolean$1 = /^(?:true|false)$/i;
 // regex for string with no uppercase letters
 const lowercase = /^[^A-Z]*$/;
 // regex for string with no lowercase letters
@@ -1416,7 +1425,7 @@ const $ZodType = /*@__PURE__*/ $constructor("$ZodType", (inst, def) => {
 });
 const $ZodString = /*@__PURE__*/ $constructor("$ZodString", (inst, def) => {
     $ZodType.init(inst, def);
-    inst._zod.pattern = [...(inst?._zod.bag?.patterns ?? [])].pop() ?? string$2(inst._zod.bag);
+    inst._zod.pattern = [...(inst?._zod.bag?.patterns ?? [])].pop() ?? string$1(inst._zod.bag);
     inst._zod.parse = (payload, _) => {
         if (def.coerce)
             try {
@@ -1738,7 +1747,7 @@ const $ZodJWT = /*@__PURE__*/ $constructor("$ZodJWT", (inst, def) => {
 });
 const $ZodNumber = /*@__PURE__*/ $constructor("$ZodNumber", (inst, def) => {
     $ZodType.init(inst, def);
-    inst._zod.pattern = inst._zod.bag.pattern ?? number$2;
+    inst._zod.pattern = inst._zod.bag.pattern ?? number$1;
     inst._zod.parse = (payload, _ctx) => {
         if (def.coerce)
             try {
@@ -1772,7 +1781,7 @@ const $ZodNumberFormat = /*@__PURE__*/ $constructor("$ZodNumber", (inst, def) =>
 });
 const $ZodBoolean = /*@__PURE__*/ $constructor("$ZodBoolean", (inst, def) => {
     $ZodType.init(inst, def);
-    inst._zod.pattern = boolean$2;
+    inst._zod.pattern = boolean$1;
     inst._zod.parse = (payload, _ctx) => {
         if (def.coerce)
             try {
@@ -1791,23 +1800,6 @@ const $ZodBoolean = /*@__PURE__*/ $constructor("$ZodBoolean", (inst, def) => {
         return payload;
     };
 });
-const $ZodNull = /*@__PURE__*/ $constructor("$ZodNull", (inst, def) => {
-    $ZodType.init(inst, def);
-    inst._zod.pattern = _null$3;
-    inst._zod.values = new Set([null]);
-    inst._zod.parse = (payload, _ctx) => {
-        const input = payload.value;
-        if (input === null)
-            return payload;
-        payload.issues.push({
-            expected: "null",
-            code: "invalid_type",
-            input,
-            inst,
-        });
-        return payload;
-    };
-});
 const $ZodAny = /*@__PURE__*/ $constructor("$ZodAny", (inst, def) => {
     $ZodType.init(inst, def);
     inst._zod.parse = (payload) => payload;
@@ -3039,12 +3031,6 @@ function _boolean(Class, params) {
         ...normalizeParams(params),
     });
 }
-function _null$2(Class, params) {
-    return new Class({
-        type: "null",
-        ...normalizeParams(params),
-    });
-}
 function _any(Class) {
     return new Class({
         type: "any",
@@ -3376,12 +3362,12 @@ const ZodType = /*@__PURE__*/ $constructor("ZodType", (inst, def) => {
     inst.superRefine = (refinement) => inst.check(superRefine(refinement));
     inst.overwrite = (fn) => inst.check(_overwrite(fn));
     // wrappers
-    inst.optional = () => optional$1(inst);
+    inst.optional = () => optional(inst);
     inst.nullable = () => nullable(inst);
-    inst.nullish = () => optional$1(nullable(inst));
+    inst.nullish = () => optional(nullable(inst));
     inst.nonoptional = (params) => nonoptional(inst, params);
-    inst.array = () => array$1(inst);
-    inst.or = (arg) => union$1([inst, arg]);
+    inst.array = () => array(inst);
+    inst.or = (arg) => union([inst, arg]);
     inst.and = (arg) => intersection(inst, arg);
     inst.transform = (tx) => pipe(inst, transform(tx));
     inst.default = (def) => _default(inst, def);
@@ -3472,7 +3458,7 @@ const ZodString = /*@__PURE__*/ $constructor("ZodString", (inst, def) => {
     inst.time = (params) => inst.check(time(params));
     inst.duration = (params) => inst.check(duration(params));
 });
-function string$1(params) {
+function string(params) {
     return _string(ZodString, params);
 }
 const ZodStringFormat = /*@__PURE__*/ $constructor("ZodStringFormat", (inst, def) => {
@@ -3603,7 +3589,7 @@ const ZodNumber = /*@__PURE__*/ $constructor("ZodNumber", (inst, def) => {
     inst.isFinite = true;
     inst.format = bag.format ?? null;
 });
-function number$1(params) {
+function number(params) {
     return _number(ZodNumber, params);
 }
 const ZodNumberFormat = /*@__PURE__*/ $constructor("ZodNumberFormat", (inst, def) => {
@@ -3617,16 +3603,9 @@ const ZodBoolean = /*@__PURE__*/ $constructor("ZodBoolean", (inst, def) => {
     $ZodBoolean.init(inst, def);
     ZodType.init(inst, def);
 });
-function boolean$1(params) {
+function boolean(params) {
     return _boolean(ZodBoolean, params);
 }
-const ZodNull = /*@__PURE__*/ $constructor("ZodNull", (inst, def) => {
-    $ZodNull.init(inst, def);
-    ZodType.init(inst, def);
-});
-function _null$1(params) {
-    return _null$2(ZodNull, params);
-}
 const ZodAny = /*@__PURE__*/ $constructor("ZodAny", (inst, def) => {
     $ZodAny.init(inst, def);
     ZodType.init(inst, def);
@@ -3638,7 +3617,7 @@ const ZodUnknown = /*@__PURE__*/ $constructor("ZodUnknown", (inst, def) => {
     $ZodUnknown.init(inst, def);
     ZodType.init(inst, def);
 });
-function unknown$1() {
+function unknown() {
     return _unknown(ZodUnknown);
 }
 const ZodNever = /*@__PURE__*/ $constructor("ZodNever", (inst, def) => {
@@ -3667,7 +3646,7 @@ const ZodArray = /*@__PURE__*/ $constructor("ZodArray", (inst, def) => {
     inst.length = (len, params) => inst.check(_length(len, params));
     inst.unwrap = () => inst.element;
 });
-function array$1(element, params) {
+function array(element, params) {
     return _array(ZodArray, element, params);
 }
 const ZodObject = /*@__PURE__*/ $constructor("ZodObject", (inst, def) => {
@@ -3678,8 +3657,8 @@ const ZodObject = /*@__PURE__*/ $constructor("ZodObject", (inst, def) => {
     });
     inst.keyof = () => _enum(Object.keys(inst._zod.def.shape));
     inst.catchall = (catchall) => inst.clone({ ...inst._zod.def, catchall: catchall });
-    inst.passthrough = () => inst.clone({ ...inst._zod.def, catchall: unknown$1() });
-    inst.loose = () => inst.clone({ ...inst._zod.def, catchall: unknown$1() });
+    inst.passthrough = () => inst.clone({ ...inst._zod.def, catchall: unknown() });
+    inst.loose = () => inst.clone({ ...inst._zod.def, catchall: unknown() });
     inst.strict = () => inst.clone({ ...inst._zod.def, catchall: never() });
     inst.strip = () => inst.clone({ ...inst._zod.def, catchall: undefined });
     inst.extend = (incoming) => {
@@ -3694,7 +3673,7 @@ const ZodObject = /*@__PURE__*/ $constructor("ZodObject", (inst, def) => {
     inst.partial = (...args) => partial(ZodOptional, inst, args[0]);
     inst.required = (...args) => required(ZodNonOptional, inst, args[0]);
 });
-function object$1(shape, params) {
+function object(shape, params) {
     const def = {
         type: "object",
         shape: shape ?? {},
@@ -3707,7 +3686,7 @@ const ZodUnion = /*@__PURE__*/ $constructor("ZodUnion", (inst, def) => {
     ZodType.init(inst, def);
     inst.options = def.options;
 });
-function union$1(options, params) {
+function union(options, params) {
     return new ZodUnion({
         type: "union",
         options: options,
@@ -3750,7 +3729,7 @@ const ZodRecord = /*@__PURE__*/ $constructor("ZodRecord", (inst, def) => {
     inst.keyType = def.keyType;
     inst.valueType = def.valueType;
 });
-function record$1(keyType, valueType, params) {
+function record(keyType, valueType, params) {
     return new ZodRecord({
         type: "record",
         keyType,
@@ -3818,7 +3797,7 @@ const ZodLiteral = /*@__PURE__*/ $constructor("ZodLiteral", (inst, def) => {
         },
     });
 });
-function literal$1(value, params) {
+function literal(value, params) {
     return new ZodLiteral({
         type: "literal",
         values: Array.isArray(value) ? value : [value],
@@ -3870,7 +3849,7 @@ const ZodOptional = /*@__PURE__*/ $constructor("ZodOptional", (inst, def) => {
     ZodType.init(inst, def);
     inst.unwrap = () => inst._zod.def.innerType;
 });
-function optional$1(innerType) {
+function optional(innerType) {
     return new ZodOptional({
         type: "optional",
         innerType: innerType,
@@ -3982,57 +3961,110 @@ function date(params) {
     return _coercedDate(ZodDate, params);
 }
 
-const FieldType = _enum(["text", "textarea", "number", "boolean", "select", "radio", "date", "datetime-local", "checkbox", "tel"]);
-const BaseFieldDataSchema = object$1({
-    required: boolean$1(),
-    label: string$1(),
-    attr_name: string$1(),
-    locked: boolean$1().optional(),
-    locked_text: string$1().optional(),
+/**
+ * Base error schema that all API errors extend from.
+ * Contains the common error_identifier field.
+ */
+const BaseErrorSchema = object({
+    error_identifier: string(),
+});
+/**
+ * Schema validation error extends base error with an array of error messages.
+ */
+const SchemaValidationErrorSchema = BaseErrorSchema.extend({
+    errors: array(string()),
+});
+const PaginationMetaSchema = object({
+    count: number(),
+    page: number(),
+    limit: number(),
+    last: number(),
+    prev: number().nullable(),
+    next: number().nullable(),
+});
+const PaginationParamsSchema = object({
+    page: number().int().min(1),
+    limit: number().int().min(0).max(250),
+});
+
+// Field type enum
+const FieldTypeEnum = _enum([
+    "text",
+    "textarea",
+    "number",
+    "boolean",
+    "select",
+    "radio",
+    "date",
+    "datetime-local",
+    "checkbox",
+    "tel",
+]);
+// Base field data schema
+const BaseFieldDataSchema = object({
+    required: boolean(),
+    label: string(),
+    attr_name: string(),
+    locked: boolean().optional(),
+    locked_text: string().optional(),
 })
     .strict();
-const SelectOptionSchema = object$1({
-    value: string$1(),
-    label: string$1(),
+// Select option schema
+const SelectOptionSchema = object({
+    value: string(),
+    label: string(),
 })
     .strict();
-const RadioValue = union$1([string$1(), literal$1("_NOT_SET_"), boolean$1()]).nullable();
-const RadioOptionSchema = object$1({
+// Radio value type
+const RadioValue = union([string(), literal("_NOT_SET_"), boolean()]).nullable();
+// Radio option schema
+const RadioOptionSchema = object({
     value: RadioValue,
-    label: string$1(),
-    checked: boolean$1(),
+    label: string(),
+    checked: boolean(),
 })
     .strict();
+// Text field type enum
+const TextFieldTypeEnum = _enum(["text", "textarea"]);
+// Text field schema
 const TextFieldSchema = BaseFieldDataSchema.extend({
-    value: union$1([string$1(), _null$1()]),
-    type: _enum(["text", "textarea"]),
+    value: string().nullable(),
+    type: TextFieldTypeEnum,
 }).strict();
+// Phone field schema
 const PhoneFieldSchema = BaseFieldDataSchema.extend({
-    value: union$1([string$1().nullable()]),
-    type: _enum(["tel"]),
+    value: string().nullable(),
+    type: literal("tel"),
 }).strict();
+// Radio field schema
 const RadioFieldSchema = BaseFieldDataSchema.extend({
     value: RadioValue,
-    type: _enum(["radio"]),
-    radio_options: array$1(RadioOptionSchema),
+    type: literal("radio"),
+    radio_options: array(RadioOptionSchema),
 }).strict();
+// Select field schema
 const SelectFieldSchema = BaseFieldDataSchema.extend({
-    value: string$1().nullable(),
-    type: _enum(["select"]),
-    options: array$1(SelectOptionSchema),
+    value: string().nullable(),
+    type: literal("select"),
+    options: array(SelectOptionSchema),
 }).strict();
+// Date field type enum
+const DateFieldTypeEnum = _enum(["date", "datetime-local"]);
+// Date field schema
 const DateFieldSchema = BaseFieldDataSchema.extend({
-    value: union$1([string$1(), _null$1()]),
-    type: _enum(["date", "datetime-local"]),
+    value: string().nullable(),
+    type: DateFieldTypeEnum,
 }).strict();
+// Custom field schema
 const CustomFieldSchema = BaseFieldDataSchema.extend({
-    value: union$1([string$1(), _null$1(), boolean$1(), number$1(), array$1(string$1())]),
-    type: FieldType,
-    readonly: boolean$1(),
-    radio_options: array$1(RadioOptionSchema).optional(),
-    options: array$1(SelectOptionSchema).optional(),
+    value: union([string(), boolean(), number(), array(string())]).nullable(),
+    type: FieldTypeEnum,
+    readonly: boolean(),
+    radio_options: array(RadioOptionSchema).optional(),
+    options: array(SelectOptionSchema).optional(),
 }).strict();
-const UserProfileSchema = object$1({
+// User profile schema
+const UserProfileSchema = object({
     salutation: RadioFieldSchema,
     first_name: TextFieldSchema,
     last_name: TextFieldSchema,
@@ -4046,15 +4078,16 @@ const UserProfileSchema = object$1({
     country_code: SelectFieldSchema,
     date_of_birth: DateFieldSchema,
     preferred_language: TextFieldSchema.optional(),
-    custom_attributes: record$1(string$1(), CustomFieldSchema),
-});
-const UserProfileErrorSchema = object$1({
-    error_identifier: string$1(),
-})
-    .strict();
-const FormErrorsValue = union$1([array$1(string$1()), array$1(tuple([number$1(), array$1(string$1())]))]);
-const FormErrorsRawSchema = record$1(string$1(), FormErrorsValue);
-const UserProfileFormErrorSchema = object$1({
+    custom_attributes: record(string(), CustomFieldSchema),
+});
+// Profile error response schema extends base error
+const ProfileErrorResponseSchema = BaseErrorSchema;
+// Form errors value type
+const FormErrorsValue = union([array(string()), array(tuple([number(), array(string())]))]);
+// Form errors raw schema
+const FormErrorsRawSchema = record(string(), FormErrorsValue);
+// User profile form error schema with transformation
+const UserProfileFormErrorSchema = object({
     errors: FormErrorsRawSchema,
 })
     .strict()
@@ -4067,144 +4100,157 @@ const UserProfileFormErrorSchema = object$1({
     }));
     return { errors, flatErrors };
 });
-const UserProfileRailsFormErrorSchema = object$1({
-    error_details: FormErrorsRawSchema,
-})
-    .loose()
-    .transform(({ error_details }) => ({ errors: error_details }))
-    .pipe(UserProfileFormErrorSchema);
-const ProfileResultSchema = union$1([
-    UserProfileSchema,
-    UserProfileErrorSchema,
-    UserProfileFormErrorSchema,
-    UserProfileRailsFormErrorSchema,
-]);
-class ProfileService {
-    client;
-    constructor(client) {
-        this.client = client;
+
+class ProfileService extends BaseService {
+    constructor(client, deps) {
+        super(client, "ProfileService", deps);
     }
-    async fetchProfile({ idToken, lang }) {
+    async get() {
+        const idToken = await this.getIdToken();
         if (!idToken) {
-            return { status: 401, success: false, headers: new Headers(), error: "missing id_token" };
+            return ["missing_id_token", null];
         }
-        try {
-            const resp = await this.client.get(`/api/sdk/v1/profile${lang ? `?lang=${lang}` : ""}`, { "X-ID-Token": idToken });
-            const parsed = ProfileResultSchema.safeParse(resp.data);
-            if (!parsed.success) {
-                return { status: 400, success: false, headers: new Headers(), error: "invalid profile data" };
+        const lang = this.getLocale();
+        const response = await this.client.get(`/api/sdk/v1/profile${lang ? `?lang=${lang}` : ""}`, this.buildAuthHeaders({ "X-ID-Token": idToken }));
+        return this.handleResponse(response, () => {
+            if (!response.success) {
+                const error = ProfileErrorResponseSchema.safeParse(response.data);
+                if (error.success) {
+                    if (response.status === 401) {
+                        return ["unauthorized", error.data];
+                    }
+                    return ["server_error", error.data];
+                }
+                return ["server_error", null];
             }
-            const data = parsed.data;
-            if ("error_identifier" in data) {
-                return { ...resp, data, error: data.error_identifier };
+            const parsed = UserProfileSchema.safeParse(response.data);
+            if (!parsed.success) {
+                this.logger.error("Invalid profile data", parsed.error);
+                return ["invalid_profile_data", null];
             }
-            return { ...resp, data };
-        }
-        catch (error) {
-            captureException(error);
-            return {
-                status: error instanceof TypeError ? 0 : 500,
-                success: false,
-                headers: new Headers(),
-                error: error instanceof Error ? error.message : String(error),
-            };
-        }
+            return [null, parsed.data];
+        });
     }
-    async updateProfile({ idToken, data, lang }) {
+    async update(args) {
+        const idToken = await this.getIdToken();
         if (!idToken) {
-            return { status: 401, success: false, headers: new Headers(), error: "missing id_token" };
+            return ["missing_id_token", null];
         }
-        const payload = data;
-        try {
-            const resp = await this.client.patch(`/api/sdk/v1/profile${lang ? `?lang=${lang}` : ""}`, { ...payload }, { "X-ID-Token": idToken });
-            const parsed = ProfileResultSchema.safeParse(resp.data);
-            if (!parsed.success) {
-                return { status: 400, success: false, headers: new Headers(), error: "invalid profile data" };
-            }
-            const result = parsed.data;
-            if ("errors" in result) {
-                return { ...resp, data: result };
+        const { payload } = args;
+        const lang = this.getLocale();
+        const response = await this.client.patch(`/api/sdk/v1/profile${lang ? `?lang=${lang}` : ""}`, { ...payload }, this.buildAuthHeaders({ "X-ID-Token": idToken }));
+        return this.handleResponse(response, () => {
+            if (!response.success) {
+                // Check for form validation errors first
+                const formErrors = UserProfileFormErrorSchema.safeParse(response.data);
+                if (formErrors.success) {
+                    return ["validation_error", formErrors.data];
+                }
+                // Check for API error response
+                const error = ProfileErrorResponseSchema.safeParse(response.data);
+                if (error.success) {
+                    if (response.status === 401) {
+                        return ["unauthorized", error.data];
+                    }
+                    return ["server_error", error.data];
+                }
+                return ["server_error", null];
             }
-            if ("error_identifier" in result) {
-                return { ...resp, data: result, error: result.error_identifier };
+            const parsed = UserProfileSchema.safeParse(response.data);
+            if (!parsed.success) {
+                this.logger.error("Invalid profile data", parsed.error);
+                return ["invalid_profile_data", null];
             }
-            return { ...resp, data: result };
-        }
-        catch (error) {
-            captureException(error);
-            return {
-                status: error instanceof TypeError ? 0 : 500,
-                success: false,
-                headers: new Headers(),
-                error: error instanceof Error ? error.message : String(error),
-            };
-        }
+            return [null, parsed.data];
+        });
     }
 }
 
-const LoginOptionsSchema = object$1({
-    magic_link: boolean$1(),
-    password: boolean$1(),
-    social_logins: array$1(string$1()),
-    passkey: boolean$1(),
-});
-const CreateSignInResponseSchema = object$1({
-    sid: string$1(),
-    status: _enum(["pending_verification", "authenticated", "completed"]),
-    email: string$1(),
-    expired: boolean$1(),
+// Sign-in status enum
+const SignInStatusEnum = _enum(["pending_verification", "authenticated", "completed"]);
+// Login options for sign-in response
+const LoginOptionsSchema = object({
+    magic_link: boolean(),
+    password: boolean(),
+    social_logins: array(string()),
+    passkey: boolean(),
+});
+// Sign-in creation response
+const CreateSignInResponseSchema = object({
+    sid: string(),
+    status: SignInStatusEnum,
+    email: string(),
+    expired: boolean(),
     login_options: LoginOptionsSchema,
 });
-const ErrorSchema = object$1({
-    error_identifier: string$1(),
-});
-const SendMagicCodeResponseSchema = object$1({
-    enable_resend_after: number$1(),
-    sid: string$1().optional(),
-});
-const SendMagicCodeErrorSchema = object$1({
-    error_identifier: string$1(),
-    enable_resend_after: number$1(),
-});
-const TokenResponseSchema = object$1({
-    jwt: string$1(),
-    sid: string$1().optional(),
-});
-const RequiredFieldsResponseSchema = object$1({
-    error_identifier: literal$1("missing_required_fields"),
-    fields: UserProfileSchema.omit({ custom_attributes: true }).partial().extend({
-        custom_attributes: UserProfileSchema.shape.custom_attributes?.optional(),
+// Generic error response (re-export of base error for backwards compatibility)
+const ErrorSchema = BaseErrorSchema;
+// Magic code response
+const SendMagicCodeResponseSchema = object({
+    enable_resend_after: number(),
+    sid: string().optional(),
+});
+// Magic code error extends base error with resend timing
+const SendMagicCodeErrorSchema = BaseErrorSchema.extend({
+    enable_resend_after: number(),
+});
+// JWT token response
+const TokenResponseSchema = object({
+    jwt: string(),
+    sid: string().optional(),
+});
+// Missing required fields response extends base error with specific error_identifier
+const RequiredFieldsResponseSchema = object({
+    error_identifier: literal("missing_required_fields"),
+    meta: object({
+        fields: UserProfileSchema.omit({ custom_attributes: true }).partial().extend({
+            custom_attributes: UserProfileSchema.shape.custom_attributes?.optional(),
+        }),
+        sid: string().optional(),
     }),
-    sid: string$1().optional(),
-});
-object$1({
-    error_details: object$1({
-        password: array$1(string$1()),
+})
+    .transform(({ error_identifier, meta }) => ({
+    error_identifier,
+    fields: meta.fields,
+    sid: meta.sid,
+}));
+// Invalid password response with field-level errors
+const InvalidPasswordResponseSchema = object({
+    error_details: object({
+        password: array(string()),
     }),
 });
-const PasskeyOptionsResponseSchema = object$1({
-    challenge: string$1(),
-    timeout: number$1(),
-    rpId: string$1(),
-    userVerification: string$1(),
-    allowCredentials: array$1(any()),
-});
-object$1({
-    id: string$1(),
-    rawId: string$1(),
-    response: object$1({
-        authenticatorData: string$1(),
-        clientDataJSON: string$1(),
-        signature: string$1(),
+// Passkey authentication options
+const PasskeyOptionsResponseSchema = object({
+    challenge: string(),
+    timeout: number(),
+    rpId: string(),
+    userVerification: string(),
+    allowCredentials: array(any()),
+});
+// Passkey credential for authentication
+object({
+    id: string(),
+    rawId: string(),
+    response: object({
+        authenticatorData: string(),
+        clientDataJSON: string(),
+        signature: string(),
     }),
-    type: string$1(),
+    type: string(),
 });
-class AuthService {
-    client;
-    constructor(client) {
-        this.client = client;
+
+class AuthService extends BaseService {
+    constructor(client, deps) {
+        super(client, "AuthService", deps);
     }
-    async createSignIn(email, password, sendMagicCode) {
+    /** Safely parse error response, returning a fallback if parsing fails */
+    parseErrorResponse(data) {
+        const parsed = ErrorSchema.safeParse(data);
+        return parsed.success ? parsed.data : { error_identifier: "unknown_error" };
+    }
+    async createSignIn(args) {
+        const { email, password, sendMagicCode } = args.payload;
         const response = await this.client.post("/api/sdk/v1/sign_ins", { email, password, sendMagicCode });
         return this.handleResponse(response, () => {
             if (!response.success) {
@@ -4212,7 +4258,7 @@ class AuthService {
                 if (missing_fields_check.success) {
                     return ["missing_required_fields", missing_fields_check.data];
                 }
-                const error_response = ErrorSchema.parse(response.data);
+                const error_response = this.parseErrorResponse(response.data);
                 return [
                     error_response.error_identifier,
                     error_response,
@@ -4227,25 +4273,25 @@ class AuthService {
             return [null, CreateSignInResponseSchema.parse(response.data)];
         });
     }
-    async sendMagicCode(signInId) {
+    async sendMagicCode(args) {
+        const { signInId } = args;
         const response = await this.client.post(`/api/sdk/v1/sign_ins/${signInId}/send_magic_code`, {});
         return this.handleResponse(response, () => {
             if (!response.success) {
-                try {
-                    const error_response = SendMagicCodeErrorSchema.parse(response.data);
-                    return ["magic_code_recently_created", error_response];
-                }
-                catch {
-                    const error_response = ErrorSchema.parse(response.data);
-                    return [error_response.error_identifier, error_response];
+                const magicCodeError = SendMagicCodeErrorSchema.safeParse(response.data);
+                if (magicCodeError.success) {
+                    return ["magic_code_recently_created", magicCodeError.data];
                 }
+                const error_response = this.parseErrorResponse(response.data);
+                return [error_response.error_identifier, error_response];
             }
             return [null, SendMagicCodeResponseSchema.parse(response.data)];
         });
     }
-    async authenticateWithPassword(signInId, password) {
+    async authenticateWithPassword(args) {
+        const { signInId, payload } = args;
         const response = await this.client.post(`/api/sdk/v1/sign_ins/${signInId}/authenticate`, {
-            password,
+            password: payload.password,
         });
         return this.handleResponse(response, () => {
             if (!response.success) {
@@ -4253,7 +4299,7 @@ class AuthService {
                 if (missing_fields_check.success) {
                     return ["missing_required_fields", missing_fields_check.data];
                 }
-                const error_response = ErrorSchema.parse(response.data);
+                const error_response = this.parseErrorResponse(response.data);
                 return [
                     error_response.error_identifier,
                     error_response,
@@ -4262,10 +4308,10 @@ class AuthService {
             return [null, TokenResponseSchema.parse(response.data)];
         });
     }
-    // biome-ignore lint/suspicious/noExplicitAny: user fields are dynamic
-    async updateMissingFields(signInId, user) {
+    async updateMissingFields(args) {
+        const { signInId, payload } = args;
         const response = await this.client.patch(`/api/sdk/v1/sign_ins/${signInId}/update_required_fields`, {
-            user,
+            user: payload.user,
         });
         return this.handleResponse(response, () => {
             if (!response.success) {
@@ -4273,15 +4319,16 @@ class AuthService {
                 if (missing_fields_check.success) {
                     return ["missing_required_fields", missing_fields_check.data];
                 }
-                const error_response = ErrorSchema.parse(response.data);
+                const error_response = this.parseErrorResponse(response.data);
                 return [error_response.error_identifier, error_response];
             }
             return [null, TokenResponseSchema.parse(response.data)];
         });
     }
-    async authenticateWithMagicCode(signInId, code) {
+    async authenticateWithMagicCode(args) {
+        const { signInId, payload } = args;
         const response = await this.client.post(`/api/sdk/v1/sign_ins/${signInId}/authenticate`, {
-            code,
+            code: payload.code,
         });
         return this.handleResponse(response, () => {
             if (!response.success) {
@@ -4289,7 +4336,7 @@ class AuthService {
                 if (missing_fields_check.success) {
                     return ["missing_required_fields", missing_fields_check.data];
                 }
-                const error_response = ErrorSchema.parse(response.data);
+                const error_response = this.parseErrorResponse(response.data);
                 return [
                     error_response.error_identifier,
                     error_response,
@@ -4298,21 +4345,25 @@ class AuthService {
             return [null, TokenResponseSchema.parse(response.data)];
         });
     }
-    async refreshToken(signInId) {
+    async refreshToken(args) {
+        const { signInId } = args;
         const response = await this.client.post(`/api/sdk/v1/sign_ins/${signInId}/refresh_token`, {});
         return this.handleResponse(response, () => {
             if (!response.success) {
-                const error_response = ErrorSchema.parse(response.data);
+                const error_response = this.parseErrorResponse(response.data);
                 return [error_response.error_identifier, error_response];
             }
             return [null, TokenResponseSchema.parse(response.data)];
         });
     }
-    async sendResetPasswordEmail(signInId, returnTo) {
-        const response = await this.client.post(`/api/sdk/v1/sign_ins/${signInId}/password_reset/send`, { return_to: returnTo });
+    async sendResetPasswordEmail(args) {
+        const { signInId, payload } = args;
+        const response = await this.client.post(`/api/sdk/v1/sign_ins/${signInId}/password_reset/send`, {
+            return_to: payload.returnTo,
+        });
         return this.handleResponse(response, () => {
             if (!response.success) {
-                const error_response = ErrorSchema.parse(response.data);
+                const error_response = this.parseErrorResponse(response.data);
                 return [
                     error_response.error_identifier,
                     error_response,
@@ -4321,61 +4372,68 @@ class AuthService {
             return [null, null];
         });
     }
-    async resetPassword(signInId, token, password, passwordConfirmation) {
+    async resetPassword(args) {
+        const { signInId, token, payload } = args;
         const response = await this.client.patch(`/api/sdk/v1/sign_ins/${signInId}/password_reset`, {
             token,
-            password,
-            password_confirmation: passwordConfirmation,
+            password: payload.password,
+            password_confirmation: payload.passwordConfirmation,
         });
         return this.handleResponse(response, () => {
             if (!response.success) {
-                const error_response = ErrorSchema.parse(response.data);
-                return [
-                    error_response.error_identifier,
-                    response.data,
-                ];
+                // invalid_password has a different response shape (error_details.password)
+                const invalidPasswordParsed = InvalidPasswordResponseSchema.safeParse(response.data);
+                if (invalidPasswordParsed.success) {
+                    return ["invalid_password", invalidPasswordParsed.data];
+                }
+                const error_response = this.parseErrorResponse(response.data);
+                return [error_response.error_identifier, error_response];
             }
             return [null, null];
         });
     }
-    async validateResetPasswordToken(signInId, token) {
+    async validateResetPasswordToken(args) {
+        const { signInId, token } = args;
         const response = await this.client.get(`/api/sdk/v1/sign_ins/${signInId}/password_reset?token=${encodeURIComponent(token)}`);
         return this.handleResponse(response, () => {
             if (!response.success) {
-                const error_response = ErrorSchema.parse(response.data);
+                const error_response = this.parseErrorResponse(response.data);
                 return [error_response.error_identifier, error_response];
             }
             return [null, null];
         });
     }
-    async signOut(signInId) {
+    async signOut(args) {
+        const { signInId } = args;
         const response = await this.client.post(`/api/sdk/v1/sign_ins/${signInId}/sign_out`, {});
         return this.handleResponse(response, () => {
             if (!response.success) {
-                const error_response = ErrorSchema.parse(response.data);
+                const error_response = this.parseErrorResponse(response.data);
                 return [error_response.error_identifier, error_response];
             }
             return [null, null];
         });
     }
-    async getPasskeyOptions(sid) {
-        const endpoint = sid ? `/api/sdk/v1/passkeys/new?sid=${encodeURIComponent(sid)}` : "/api/sdk/v1/passkeys/new";
+    async getPasskeyOptions(args) {
+        const signInId = args?.signInId;
+        const endpoint = signInId ? `/api/sdk/v1/passkeys/new?sid=${encodeURIComponent(signInId)}` : "/api/sdk/v1/passkeys/new";
         const response = await this.client.get(endpoint);
         return this.handleResponse(response, () => {
             if (!response.success) {
-                const error_response = ErrorSchema.parse(response.data);
+                const error_response = this.parseErrorResponse(response.data);
                 return ["bad_request", error_response];
             }
             return [null, PasskeyOptionsResponseSchema.parse(response.data)];
         });
     }
-    async authenticateWithPasskey(credential) {
+    async authenticateWithPasskey(args) {
+        const { payload } = args;
         const response = await this.client.post("/api/sdk/v1/passkeys", {
-            publicKeyCredential: credential,
+            publicKeyCredential: payload.credential,
         });
         return this.handleResponse(response, () => {
             if (!response.success) {
-                const error_response = ErrorSchema.parse(response.data);
+                const error_response = this.parseErrorResponse(response.data);
                 return [
                     error_response.error_identifier,
                     error_response,
@@ -4384,841 +4442,1151 @@ class AuthService {
             return [null, TokenResponseSchema.parse(response.data)];
         });
     }
-    handleResponse(
-    // biome-ignore lint/suspicious/noExplicitAny: generic handler for all responses
-    response, handler) {
-        if (response.connectionError) {
-            unidyState.backendConnected = false;
-            return ["connection_failed", null];
-        }
-        try {
-            return handler();
-        }
-        catch (error) {
-            captureException(error);
-            return ["schema_validation_error", SchemaValidationErrorSchema.parse(response.data)];
-        }
-    }
 }
 
-const ZodMiniType = /*@__PURE__*/ $constructor("ZodMiniType", (inst, def) => {
-    if (!inst._zod)
-        throw new Error("Uninitialized schema in ZodMiniType.");
-    $ZodType.init(inst, def);
-    inst.def = def;
-    inst.type = def.type;
-    inst.parse = (data, params) => parse$1(inst, data, params, { callee: inst.parse });
-    inst.safeParse = (data, params) => safeParse$1(inst, data, params);
-    inst.parseAsync = async (data, params) => parseAsync$1(inst, data, params, { callee: inst.parseAsync });
-    inst.safeParseAsync = async (data, params) => safeParseAsync$1(inst, data, params);
-    inst.check = (...checks) => {
-        return inst.clone({
-            ...def,
-            checks: [
-                ...(def.checks ?? []),
-                ...checks.map((ch) => typeof ch === "function" ? { _zod: { check: ch, def: { check: "custom" }, onattach: [] } } : ch),
-            ],
-        }
-        // { parent: true }
-        );
-    };
-    inst.clone = (_def, params) => clone(inst, _def, params);
-    inst.brand = () => inst;
-    inst.register = ((reg, meta) => {
-        reg.add(inst, meta);
-        return inst;
-    });
-});
-const ZodMiniString = /*@__PURE__*/ $constructor("ZodMiniString", (inst, def) => {
-    $ZodString.init(inst, def);
-    ZodMiniType.init(inst, def);
+// Salutation enum
+const SalutationEnum = _enum(["mr", "mrs", "mx"]);
+// Newsletter subscription from API
+const NewsletterSubscriptionSchema = object({
+    id: number(),
+    email: string(),
+    newsletter_internal_name: string(),
+    preference_identifiers: array(string()),
+    preference_token: string(),
+    confirmed_at: string().nullable(),
 });
-function string(params) {
-    return _string(ZodMiniString, params);
-}
-const ZodMiniNumber = /*@__PURE__*/ $constructor("ZodMiniNumber", (inst, def) => {
-    $ZodNumber.init(inst, def);
-    ZodMiniType.init(inst, def);
+// Newsletter subscription error extends base error with typed meta
+const NewsletterSubscriptionErrorSchema = BaseErrorSchema.extend({
+    error_details: record(string(), array(string())).optional(),
+    meta: object({
+        newsletter_internal_name: string(),
+    }),
 });
-function number(params) {
-    return _number(ZodMiniNumber, params);
-}
-const ZodMiniBoolean = /*@__PURE__*/ $constructor("ZodMiniBoolean", (inst, def) => {
-    $ZodBoolean.init(inst, def);
-    ZodMiniType.init(inst, def);
+// Create subscriptions response
+const CreateSubscriptionsResponseSchema = object({
+    results: array(NewsletterSubscriptionSchema),
+    errors: array(NewsletterSubscriptionErrorSchema),
 });
-function boolean(params) {
-    return _boolean(ZodMiniBoolean, params);
-}
-const ZodMiniNull = /*@__PURE__*/ $constructor("ZodMiniNull", (inst, def) => {
-    $ZodNull.init(inst, def);
-    ZodMiniType.init(inst, def);
+// Additional fields for subscription creation - using .partial() for all optional fields
+const AdditionalFieldsSchema = object({
+    first_name: string().nullable(),
+    last_name: string().nullable(),
+    salutation: SalutationEnum.nullable(),
+    phone_number: string().nullable(),
+    date_of_birth: string().nullable(),
+    company_name: string().nullable(),
+    address_line_1: string().nullable(),
+    address_line_2: string().nullable(),
+    city: string().nullable(),
+    postal_code: string().nullable(),
+    country_code: string().nullable(),
+    preferred_language: string().nullable(),
+    custom_attributes: record(string(), unknown()).nullable(),
+})
+    .partial();
+// Create subscriptions payload
+const CreateSubscriptionsPayloadSchema = object({
+    email: string(),
+    additional_fields: optional(AdditionalFieldsSchema),
+    newsletter_subscriptions: array(object({
+        newsletter_internal_name: string(),
+        preference_identifiers: optional(array(string())),
+    })),
+    redirect_to_after_confirmation: optional(string()),
 });
-function _null(params) {
-    return _null$2(ZodMiniNull, params);
-}
-const ZodMiniUnknown = /*@__PURE__*/ $constructor("ZodMiniUnknown", (inst, def) => {
-    $ZodUnknown.init(inst, def);
-    ZodMiniType.init(inst, def);
+// Update subscription payload
+const UpdateSubscriptionPayloadSchema = object({
+    preference_identifiers: array(string()),
 });
-function unknown() {
-    return _unknown(ZodMiniUnknown);
-}
-const ZodMiniArray = /*@__PURE__*/ $constructor("ZodMiniArray", (inst, def) => {
-    $ZodArray.init(inst, def);
-    ZodMiniType.init(inst, def);
+// Login email payload
+const LoginEmailPayloadSchema = object({
+    email: string(),
+    redirect_uri: string(),
 });
-function array(element, params) {
-    return new ZodMiniArray({
-        type: "array",
-        element: element,
-        ...normalizeParams(params),
-    });
-}
-const ZodMiniObject = /*@__PURE__*/ $constructor("ZodMiniObject", (inst, def) => {
-    $ZodObject.init(inst, def);
-    ZodMiniType.init(inst, def);
-    defineLazy(inst, "shape", () => def.shape);
+// Resend DOI payload
+const ResendDoiPayloadSchema = object({
+    redirect_to_after_confirmation: string(),
+})
+    .partial();
+// Preference schema
+const PreferenceSchema = object({
+    id: number(),
+    name: string(),
+    description: string().nullable(),
+    plugin_identifier: string().nullable(),
+    position: number(),
+    default: boolean(),
+    hidden: boolean(),
 });
-function object(shape, params) {
-    const def = {
-        type: "object",
-        shape: shape ?? {},
-        ...normalizeParams(params),
-    };
-    return new ZodMiniObject(def);
-}
-const ZodMiniUnion = /*@__PURE__*/ $constructor("ZodMiniUnion", (inst, def) => {
-    $ZodUnion.init(inst, def);
-    ZodMiniType.init(inst, def);
+// Preference group schema
+const PreferenceGroupSchema = object({
+    id: number(),
+    name: string(),
+    position: number(),
+    flat: boolean(),
+    preferences: array(PreferenceSchema),
 });
-function union(options, params) {
-    return new ZodMiniUnion({
-        type: "union",
-        options: options,
-        ...normalizeParams(params),
-    });
-}
-const ZodMiniRecord = /*@__PURE__*/ $constructor("ZodMiniRecord", (inst, def) => {
-    $ZodRecord.init(inst, def);
-    ZodMiniType.init(inst, def);
+// Newsletter schema
+const NewsletterSchema = object({
+    id: number(),
+    internal_name: string(),
+    default: boolean(),
+    position: number(),
+    opt_in_type: string(),
+    title: string(),
+    description: string().nullable(),
+    created_at: string(),
+    updated_at: string(),
+    preference_groups: array(PreferenceGroupSchema),
 });
-function record(keyType, valueType, params) {
-    return new ZodMiniRecord({
-        type: "record",
-        keyType,
-        valueType: valueType,
-        ...normalizeParams(params),
-    });
-}
-const ZodMiniLiteral = /*@__PURE__*/ $constructor("ZodMiniLiteral", (inst, def) => {
-    $ZodLiteral.init(inst, def);
-    ZodMiniType.init(inst, def);
+// Newsletters list response
+const NewslettersResponseSchema = object({
+    newsletters: array(NewsletterSchema),
 });
-function literal(value, params) {
-    return new ZodMiniLiteral({
-        type: "literal",
-        values: Array.isArray(value) ? value : [value],
-        ...normalizeParams(params),
-    });
-}
-const ZodMiniOptional = /*@__PURE__*/ $constructor("ZodMiniOptional", (inst, def) => {
-    $ZodOptional.init(inst, def);
-    ZodMiniType.init(inst, def);
-});
-function optional(innerType) {
-    return new ZodMiniOptional({
-        type: "optional",
-        innerType: innerType,
-    });
-}
-
-function getDefaultExportFromCjs (x) {
-	return x && x.__esModule && Object.prototype.hasOwnProperty.call(x, 'default') ? x['default'] : x;
-}
-
-var eventemitter3 = {exports: {}};
-
-var hasRequiredEventemitter3;
-
-function requireEventemitter3 () {
-	if (hasRequiredEventemitter3) return eventemitter3.exports;
-	hasRequiredEventemitter3 = 1;
-	(function (module) {
-
-		var has = Object.prototype.hasOwnProperty
-		  , prefix = '~';
-
-		/**
-		 * Constructor to create a storage for our `EE` objects.
-		 * An `Events` instance is a plain object whose properties are event names.
-		 *
-		 * @constructor
-		 * @private
-		 */
-		function Events() {}
-
-		//
-		// We try to not inherit from `Object.prototype`. In some engines creating an
-		// instance in this way is faster than calling `Object.create(null)` directly.
-		// If `Object.create(null)` is not supported we prefix the event names with a
-		// character to make sure that the built-in object properties are not
-		// overridden or used as an attack vector.
-		//
-		if (Object.create) {
-		  Events.prototype = Object.create(null);
-
-		  //
-		  // This hack is needed because the `__proto__` property is still inherited in
-		  // some old browsers like Android 4, iPhone 5.1, Opera 11 and Safari 5.
-		  //
-		  if (!new Events().__proto__) prefix = false;
-		}
-
-		/**
-		 * Representation of a single event listener.
-		 *
-		 * @param {Function} fn The listener function.
-		 * @param {*} context The context to invoke the listener with.
-		 * @param {Boolean} [once=false] Specify if the listener is a one-time listener.
-		 * @constructor
-		 * @private
-		 */
-		function EE(fn, context, once) {
-		  this.fn = fn;
-		  this.context = context;
-		  this.once = once || false;
-		}
-
-		/**
-		 * Add a listener for a given event.
-		 *
-		 * @param {EventEmitter} emitter Reference to the `EventEmitter` instance.
-		 * @param {(String|Symbol)} event The event name.
-		 * @param {Function} fn The listener function.
-		 * @param {*} context The context to invoke the listener with.
-		 * @param {Boolean} once Specify if the listener is a one-time listener.
-		 * @returns {EventEmitter}
-		 * @private
-		 */
-		function addListener(emitter, event, fn, context, once) {
-		  if (typeof fn !== 'function') {
-		    throw new TypeError('The listener must be a function');
-		  }
-
-		  var listener = new EE(fn, context || emitter, once)
-		    , evt = prefix ? prefix + event : event;
-
-		  if (!emitter._events[evt]) emitter._events[evt] = listener, emitter._eventsCount++;
-		  else if (!emitter._events[evt].fn) emitter._events[evt].push(listener);
-		  else emitter._events[evt] = [emitter._events[evt], listener];
-
-		  return emitter;
-		}
-
-		/**
-		 * Clear event by name.
-		 *
-		 * @param {EventEmitter} emitter Reference to the `EventEmitter` instance.
-		 * @param {(String|Symbol)} evt The Event name.
-		 * @private
-		 */
-		function clearEvent(emitter, evt) {
-		  if (--emitter._eventsCount === 0) emitter._events = new Events();
-		  else delete emitter._events[evt];
-		}
-
-		/**
-		 * Minimal `EventEmitter` interface that is molded against the Node.js
-		 * `EventEmitter` interface.
-		 *
-		 * @constructor
-		 * @public
-		 */
-		function EventEmitter() {
-		  this._events = new Events();
-		  this._eventsCount = 0;
-		}
-
-		/**
-		 * Return an array listing the events for which the emitter has registered
-		 * listeners.
-		 *
-		 * @returns {Array}
-		 * @public
-		 */
-		EventEmitter.prototype.eventNames = function eventNames() {
-		  var names = []
-		    , events
-		    , name;
-
-		  if (this._eventsCount === 0) return names;
-
-		  for (name in (events = this._events)) {
-		    if (has.call(events, name)) names.push(prefix ? name.slice(1) : name);
-		  }
-
-		  if (Object.getOwnPropertySymbols) {
-		    return names.concat(Object.getOwnPropertySymbols(events));
-		  }
-
-		  return names;
-		};
-
-		/**
-		 * Return the listeners registered for a given event.
-		 *
-		 * @param {(String|Symbol)} event The event name.
-		 * @returns {Array} The registered listeners.
-		 * @public
-		 */
-		EventEmitter.prototype.listeners = function listeners(event) {
-		  var evt = prefix ? prefix + event : event
-		    , handlers = this._events[evt];
-
-		  if (!handlers) return [];
-		  if (handlers.fn) return [handlers.fn];
-
-		  for (var i = 0, l = handlers.length, ee = new Array(l); i < l; i++) {
-		    ee[i] = handlers[i].fn;
-		  }
-
-		  return ee;
-		};
-
-		/**
-		 * Return the number of listeners listening to a given event.
-		 *
-		 * @param {(String|Symbol)} event The event name.
-		 * @returns {Number} The number of listeners.
-		 * @public
-		 */
-		EventEmitter.prototype.listenerCount = function listenerCount(event) {
-		  var evt = prefix ? prefix + event : event
-		    , listeners = this._events[evt];
-
-		  if (!listeners) return 0;
-		  if (listeners.fn) return 1;
-		  return listeners.length;
-		};
-
-		/**
-		 * Calls each of the listeners registered for a given event.
-		 *
-		 * @param {(String|Symbol)} event The event name.
-		 * @returns {Boolean} `true` if the event had listeners, else `false`.
-		 * @public
-		 */
-		EventEmitter.prototype.emit = function emit(event, a1, a2, a3, a4, a5) {
-		  var evt = prefix ? prefix + event : event;
-
-		  if (!this._events[evt]) return false;
-
-		  var listeners = this._events[evt]
-		    , len = arguments.length
-		    , args
-		    , i;
-
-		  if (listeners.fn) {
-		    if (listeners.once) this.removeListener(event, listeners.fn, undefined, true);
-
-		    switch (len) {
-		      case 1: return listeners.fn.call(listeners.context), true;
-		      case 2: return listeners.fn.call(listeners.context, a1), true;
-		      case 3: return listeners.fn.call(listeners.context, a1, a2), true;
-		      case 4: return listeners.fn.call(listeners.context, a1, a2, a3), true;
-		      case 5: return listeners.fn.call(listeners.context, a1, a2, a3, a4), true;
-		      case 6: return listeners.fn.call(listeners.context, a1, a2, a3, a4, a5), true;
-		    }
-
-		    for (i = 1, args = new Array(len -1); i < len; i++) {
-		      args[i - 1] = arguments[i];
-		    }
-
-		    listeners.fn.apply(listeners.context, args);
-		  } else {
-		    var length = listeners.length
-		      , j;
-
-		    for (i = 0; i < length; i++) {
-		      if (listeners[i].once) this.removeListener(event, listeners[i].fn, undefined, true);
-
-		      switch (len) {
-		        case 1: listeners[i].fn.call(listeners[i].context); break;
-		        case 2: listeners[i].fn.call(listeners[i].context, a1); break;
-		        case 3: listeners[i].fn.call(listeners[i].context, a1, a2); break;
-		        case 4: listeners[i].fn.call(listeners[i].context, a1, a2, a3); break;
-		        default:
-		          if (!args) for (j = 1, args = new Array(len -1); j < len; j++) {
-		            args[j - 1] = arguments[j];
-		          }
-
-		          listeners[i].fn.apply(listeners[i].context, args);
-		      }
-		    }
-		  }
-
-		  return true;
-		};
-
-		/**
-		 * Add a listener for a given event.
-		 *
-		 * @param {(String|Symbol)} event The event name.
-		 * @param {Function} fn The listener function.
-		 * @param {*} [context=this] The context to invoke the listener with.
-		 * @returns {EventEmitter} `this`.
-		 * @public
-		 */
-		EventEmitter.prototype.on = function on(event, fn, context) {
-		  return addListener(this, event, fn, context, false);
-		};
-
-		/**
-		 * Add a one-time listener for a given event.
-		 *
-		 * @param {(String|Symbol)} event The event name.
-		 * @param {Function} fn The listener function.
-		 * @param {*} [context=this] The context to invoke the listener with.
-		 * @returns {EventEmitter} `this`.
-		 * @public
-		 */
-		EventEmitter.prototype.once = function once(event, fn, context) {
-		  return addListener(this, event, fn, context, true);
-		};
-
-		/**
-		 * Remove the listeners of a given event.
-		 *
-		 * @param {(String|Symbol)} event The event name.
-		 * @param {Function} fn Only remove the listeners that match this function.
-		 * @param {*} context Only remove the listeners that have this context.
-		 * @param {Boolean} once Only remove one-time listeners.
-		 * @returns {EventEmitter} `this`.
-		 * @public
-		 */
-		EventEmitter.prototype.removeListener = function removeListener(event, fn, context, once) {
-		  var evt = prefix ? prefix + event : event;
-
-		  if (!this._events[evt]) return this;
-		  if (!fn) {
-		    clearEvent(this, evt);
-		    return this;
-		  }
-
-		  var listeners = this._events[evt];
-
-		  if (listeners.fn) {
-		    if (
-		      listeners.fn === fn &&
-		      (!once || listeners.once) &&
-		      (!context || listeners.context === context)
-		    ) {
-		      clearEvent(this, evt);
-		    }
-		  } else {
-		    for (var i = 0, events = [], length = listeners.length; i < length; i++) {
-		      if (
-		        listeners[i].fn !== fn ||
-		        (once && !listeners[i].once) ||
-		        (context && listeners[i].context !== context)
-		      ) {
-		        events.push(listeners[i]);
-		      }
-		    }
-
-		    //
-		    // Reset the array, or remove it completely if we have no more listeners.
-		    //
-		    if (events.length) this._events[evt] = events.length === 1 ? events[0] : events;
-		    else clearEvent(this, evt);
-		  }
-
-		  return this;
-		};
-
-		/**
-		 * Remove all listeners, or those of the specified event.
-		 *
-		 * @param {(String|Symbol)} [event] The event name.
-		 * @returns {EventEmitter} `this`.
-		 * @public
-		 */
-		EventEmitter.prototype.removeAllListeners = function removeAllListeners(event) {
-		  var evt;
-
-		  if (event) {
-		    evt = prefix ? prefix + event : event;
-		    if (this._events[evt]) clearEvent(this, evt);
-		  } else {
-		    this._events = new Events();
-		    this._eventsCount = 0;
-		  }
-
-		  return this;
-		};
-
-		//
-		// Alias methods names because people roll like that.
-		//
-		EventEmitter.prototype.off = EventEmitter.prototype.removeListener;
-		EventEmitter.prototype.addListener = EventEmitter.prototype.on;
-
-		//
-		// Expose the prefix.
-		//
-		EventEmitter.prefixed = prefix;
-
-		//
-		// Allow `EventEmitter` to be imported as module namespace.
-		//
-		EventEmitter.EventEmitter = EventEmitter;
-
-		//
-		// Expose the module.
-		//
-		{
-		  module.exports = EventEmitter;
-		} 
-	} (eventemitter3));
-	return eventemitter3.exports;
-}
-
-var eventemitter3Exports = requireEventemitter3();
-var EventEmitter = /*@__PURE__*/getDefaultExportFromCjs(eventemitter3Exports);
+// Delete subscription response
+const DeleteSubscriptionResponseSchema = object({
+    new_preference_token: string(),
+})
+    .nullable();
+// Generic newsletter error response (extends base error)
+const NewsletterErrorResponseSchema = BaseErrorSchema;
 
-const NewsletterSubscriptionSchema = object({
-    id: number(),
-    email: string(),
-    newsletter_internal_name: string(),
-    preference_identifiers: array(string()),
-    preference_token: string(),
-    confirmed_at: union([string(), _null()]),
-});
-const NewsletterSubscriptionErrorSchema = object({
-    error_identifier: string(),
-    error_details: optional(record(string(), array(string()))),
-    meta: object({
-        newsletter_internal_name: string(),
-    }),
-});
-const CreateSubscriptionsResponseSchema = object({
-    results: array(NewsletterSubscriptionSchema),
-    errors: array(NewsletterSubscriptionErrorSchema),
-});
-const AdditionalFieldsSchema = object({
-    first_name: optional(union([string(), _null()])),
-    last_name: optional(union([string(), _null()])),
-    salutation: optional(union([literal("mr"), literal("mrs"), literal("mx"), _null()])),
-    phone_number: optional(union([string(), _null()])),
-    date_of_birth: optional(union([string(), _null()])),
-    company_name: optional(union([string(), _null()])),
-    address_line_1: optional(union([string(), _null()])),
-    address_line_2: optional(union([string(), _null()])),
-    city: optional(union([string(), _null()])),
-    postal_code: optional(union([string(), _null()])),
-    country_code: optional(union([string(), _null()])),
-    preferred_language: optional(union([string(), _null()])),
-    custom_attributes: optional(union([record(string(), unknown()), _null()])),
-});
-const CreateSubscriptionsPayloadSchema = object({
-    email: string(),
-    additional_fields: optional(AdditionalFieldsSchema),
-    newsletter_subscriptions: array(object({
-        newsletter_internal_name: string(),
-        preference_identifiers: optional(array(string())),
-    })),
-    redirect_to_after_confirmation: optional(string()),
-});
-const UpdateSubscriptionPayloadSchema = object({
-    preference_identifiers: array(string()),
-});
-const LoginEmailPayloadSchema = object({
-    email: string(),
-    redirect_uri: string(),
-});
-const ResendDoiPayloadSchema = object({
-    redirect_to_after_confirmation: optional(string()),
-});
-const PreferenceSchema = object({
-    id: number(),
-    name: string(),
-    description: union([string(), _null()]),
-    plugin_identifier: union([string(), _null()]),
-    position: number(),
-    default: boolean(),
-    hidden: boolean(),
-});
-const PreferenceGroupSchema = object({
-    id: number(),
-    name: string(),
-    position: number(),
-    flat: boolean(),
-    preferences: array(PreferenceSchema),
-});
-const NewsletterSchema = object({
-    id: number(),
-    internal_name: string(),
-    default: boolean(),
-    position: number(),
-    opt_in_type: string(),
-    title: string(),
-    description: union([string(), _null()]),
-    created_at: string(),
-    updated_at: string(),
-    preference_groups: array(PreferenceGroupSchema),
-});
-object({
-    newsletters: array(NewsletterSchema),
-});
-class NewsletterService extends EventEmitter {
-    client;
-    logger = createLogger("NewsletterService");
-    constructor(client) {
-        super();
-        this.client = client;
+class NewsletterService extends BaseService {
+    constructor(client, deps) {
+        super(client, "NewsletterService", deps);
     }
-    buildAuthHeaders(auth) {
-        if (!auth)
-            return undefined;
-        const headers = {};
-        if (auth.idToken) {
-            headers["X-ID-Token"] = auth.idToken;
-        }
-        if (auth.preferenceToken) {
-            headers["X-Preference-Token"] = auth.preferenceToken;
-        }
-        return Object.keys(headers).length > 0 ? headers : undefined;
+    async buildNewsletterAuthHeaders(options) {
+        const idToken = await this.getIdToken();
+        return this.buildAuthHeaders({
+            "X-ID-Token": idToken ?? undefined,
+            "X-Preference-Token": options?.preferenceToken,
+        });
     }
-    async createSubscriptions(payload, auth) {
+    /**
+     * Create newsletter subscriptions for a user
+     */
+    async create(args) {
+        const { payload, options } = args;
         CreateSubscriptionsPayloadSchema.parse(payload);
-        const response = await this.client.post("/api/sdk/v1/newsletters/newsletter_subscription", payload, this.buildAuthHeaders(auth));
-        switch (response.status) {
-            case 401:
-                this.emit("unauthorized", response);
-                return ["unauthorized", response];
-            case 429:
-                this.logger.warn("Rate limit exceeded");
-                this.emit("rate_limit_exceeded", response);
-                return ["rate_limit_exceeded", response];
-            case 500:
-                captureException(response);
-                return ["server_error", response];
-            case 0:
-                return ["network_error", response];
-            default:
-                if (response.data) {
-                    try {
-                        const validatedData = CreateSubscriptionsResponseSchema.parse(response.data);
-                        if (validatedData.errors.length > 0) {
-                            this.emit("newsletter_error", response);
-                            return ["newsletter_error", response];
-                        }
-                        return [null, response];
-                    }
-                    catch (_validationError) {
-                        return ["schema_validation_error", response];
-                    }
+        const headers = await this.buildNewsletterAuthHeaders(options);
+        const response = await this.client.post("/api/sdk/v1/newsletters/newsletter_subscription", payload, headers);
+        return this.handleResponse(response, () => {
+            if (!response.success) {
+                const parsed = NewsletterErrorResponseSchema.safeParse(response.data);
+                const error = parsed.success ? parsed.data : { error_identifier: "unknown_error" };
+                switch (response.status) {
+                    case 401:
+                        return ["unauthorized", error];
+                    case 429:
+                        this.logger.warn("Rate limit exceeded");
+                        return ["rate_limit_exceeded", error];
+                    case 500:
+                        this.errorReporter.captureException(response);
+                        return ["server_error", error];
+                    default:
+                        return ["server_error", error];
                 }
-                return ["error", response];
-        }
+            }
+            const data = CreateSubscriptionsResponseSchema.parse(response.data);
+            if (data.errors.length > 0) {
+                return ["newsletter_error", data];
+            }
+            return [null, data];
+        });
     }
-    async listSubscriptions(auth) {
-        return this.client.get("/api/sdk/v1/newsletters/newsletter_subscription", this.buildAuthHeaders(auth));
+    /**
+     * List all subscriptions for the authenticated user
+     */
+    async list(args) {
+        const headers = await this.buildNewsletterAuthHeaders(args?.options);
+        const response = await this.client.get("/api/sdk/v1/newsletters/newsletter_subscription", headers);
+        return this.handleResponse(response, () => {
+            if (!response.success) {
+                const parsed = NewsletterErrorResponseSchema.safeParse(response.data);
+                const error = parsed.success ? parsed.data : { error_identifier: "unknown_error" };
+                if (response.status === 401) {
+                    return ["unauthorized", error];
+                }
+                return ["server_error", error];
+            }
+            const data = array(NewsletterSubscriptionSchema).parse(response.data);
+            return [null, data];
+        });
     }
-    async getSubscription(internalName, auth) {
-        return this.client.get(`/api/sdk/v1/newsletters/${internalName}/newsletter_subscription`, this.buildAuthHeaders(auth));
+    /**
+     * Get a specific subscription by newsletter internal name
+     */
+    async get(args) {
+        const { internalName, options } = args;
+        const headers = await this.buildNewsletterAuthHeaders(options);
+        const response = await this.client.get(`/api/sdk/v1/newsletters/${internalName}/newsletter_subscription`, headers);
+        return this.handleResponse(response, () => {
+            if (!response.success) {
+                const parsed = NewsletterErrorResponseSchema.safeParse(response.data);
+                const error = parsed.success ? parsed.data : { error_identifier: "unknown_error" };
+                if (response.status === 401) {
+                    return ["unauthorized", error];
+                }
+                if (response.status === 404) {
+                    return ["not_found", error];
+                }
+                return ["server_error", error];
+            }
+            const data = NewsletterSubscriptionSchema.parse(response.data);
+            return [null, data];
+        });
     }
-    async updateSubscription(internalName, payload, auth) {
+    /**
+     * Update a subscription's preferences
+     */
+    async update(args) {
+        const { internalName, payload, options } = args;
         UpdateSubscriptionPayloadSchema.parse(payload);
-        return this.client.patch(`/api/sdk/v1/newsletters/${internalName}/newsletter_subscription`, payload, this.buildAuthHeaders(auth));
+        const headers = await this.buildNewsletterAuthHeaders(options);
+        const response = await this.client.patch(`/api/sdk/v1/newsletters/${internalName}/newsletter_subscription`, payload, headers);
+        return this.handleResponse(response, () => {
+            if (!response.success) {
+                const parsed = NewsletterErrorResponseSchema.safeParse(response.data);
+                const error = parsed.success ? parsed.data : { error_identifier: "unknown_error" };
+                if (response.status === 401) {
+                    return ["unauthorized", error];
+                }
+                if (response.status === 404) {
+                    return ["not_found", error];
+                }
+                return ["server_error", error];
+            }
+            const data = NewsletterSubscriptionSchema.parse(response.data);
+            return [null, data];
+        });
     }
-    async deleteSubscription(internalName, auth) {
-        return this.client.delete(`/api/sdk/v1/newsletters/${internalName}/newsletter_subscription`, this.buildAuthHeaders(auth));
+    /**
+     * Delete a subscription
+     */
+    async delete(args) {
+        const { internalName, options } = args;
+        const headers = await this.buildNewsletterAuthHeaders(options);
+        const response = await this.client.delete(`/api/sdk/v1/newsletters/${internalName}/newsletter_subscription`, headers);
+        return this.handleResponse(response, () => {
+            if (!response.success) {
+                const parsed = NewsletterErrorResponseSchema.safeParse(response.data);
+                const error = parsed.success ? parsed.data : { error_identifier: "unknown_error" };
+                if (response.status === 401) {
+                    return ["unauthorized", error];
+                }
+                if (response.status === 404) {
+                    return ["not_found", error];
+                }
+                return ["server_error", error];
+            }
+            const data = DeleteSubscriptionResponseSchema.parse(response.data);
+            return [null, data];
+        });
     }
-    async resendDoi(internalName, payload, auth) {
+    /**
+     * Resend double opt-in confirmation email
+     */
+    async resendDoi(args) {
+        const { internalName, payload, options } = args;
         ResendDoiPayloadSchema.parse(payload);
-        return this.client.post(`/api/sdk/v1/newsletters/${internalName}/newsletter_subscription/resend_doi`, payload, this.buildAuthHeaders(auth));
+        const headers = await this.buildNewsletterAuthHeaders(options);
+        const response = await this.client.post(`/api/sdk/v1/newsletters/${internalName}/newsletter_subscription/resend_doi`, payload, headers);
+        return this.handleResponse(response, () => {
+            if (!response.success) {
+                const parsed = NewsletterErrorResponseSchema.safeParse(response.data);
+                const error = parsed.success ? parsed.data : { error_identifier: "unknown_error" };
+                if (response.status === 401) {
+                    return ["unauthorized", error];
+                }
+                if (response.status === 404) {
+                    return ["not_found", error];
+                }
+                if (error.error_identifier === "already_confirmed") {
+                    return ["already_confirmed", error];
+                }
+                return ["server_error", error];
+            }
+            return [null, null];
+        });
     }
-    async sendLoginEmail(payload) {
+    /**
+     * Send a login email for newsletter management
+     */
+    async sendLoginEmail(args) {
+        const { payload } = args;
         LoginEmailPayloadSchema.parse(payload);
-        return this.client.post("/api/sdk/v1/newsletters/newsletter_subscription/login_email", payload);
-    }
-    async listNewsletters() {
-        return this.client.get("/api/sdk/v1/newsletters");
-    }
-    async getNewsletter(internalName) {
-        return this.client.get(`/api/sdk/v1/newsletters/${internalName}`);
-    }
-    onError(callback, errorIdentifier) {
-        this.on("newsletter_error", (response) => {
-            if (!response.data?.errors) {
-                return;
+        const response = await this.client.post("/api/sdk/v1/newsletters/newsletter_subscription/login_email", payload);
+        return this.handleResponse(response, () => {
+            if (!response.success) {
+                const parsed = NewsletterErrorResponseSchema.safeParse(response.data);
+                const error = parsed.success ? parsed.data : { error_identifier: "unknown_error" };
+                if (response.status === 429) {
+                    return ["rate_limit_exceeded", error];
+                }
+                return ["server_error", error];
             }
-            const errors = errorIdentifier
-                ? response.data.errors.filter((error) => error.error_identifier === errorIdentifier)
-                : response.data.errors;
-            if (errors.length > 0) {
-                callback(errors);
+            return [null, null];
+        });
+    }
+    /**
+     * List all available newsletters
+     */
+    async listAll() {
+        const response = await this.client.get("/api/sdk/v1/newsletters");
+        return this.handleResponse(response, () => {
+            if (!response.success) {
+                return ["server_error", null];
             }
+            const data = NewslettersResponseSchema.parse(response.data);
+            return [null, data];
         });
     }
-    onRateLimitError(callback) {
-        this.on("rate_limit_exceeded", (response) => {
-            if (response.status === 429) {
-                callback();
+    /**
+     * Get a newsletter by its internal name
+     */
+    async getByName(args) {
+        const { internalName } = args;
+        const response = await this.client.get(`/api/sdk/v1/newsletters/${internalName}`);
+        return this.handleResponse(response, () => {
+            if (!response.success) {
+                const parsed = NewsletterErrorResponseSchema.safeParse(response.data);
+                const error = parsed.success ? parsed.data : { error_identifier: "unknown_error" };
+                if (response.status === 404) {
+                    return ["not_found", error];
+                }
+                return ["server_error", error];
             }
+            const data = NewsletterSchema.parse(response.data);
+            return [null, data];
         });
     }
 }
 
-const SchemaValidationErrorSchema = object$1({
-    error_identifier: string$1(), // unprocessable entity etc. TODO we can define enum later
-    errors: array$1(string$1()),
-});
-const PaginationMetaSchema = object$1({
-    count: number$1(),
-    page: number$1(),
-    limit: number$1(),
-    last: number$1(),
-    prev: number$1().nullable(),
-    next: number$1().nullable(),
-});
-const PaginationParamsSchema = object$1({
-    page: number$1().int().min(1),
-    limit: number$1().int().min(0).max(250),
-});
-
-const TicketableListParamsBaseSchema = object$1({
-    service_id: number$1().nullable(),
-    state: string$1(),
-    payment_state: string$1(),
-    order_by: _enum(["starts_at", "ends_at", "reference", "created_at"]),
-    order_direction: _enum(["asc", "desc"]),
-})
-    .merge(PaginationParamsSchema);
-
-function getWithSchema(client, returnSchema, urlBuilder, paramSchema) {
-    const fn = async (args, params) => {
-        // Build URL
-        const baseUrl = urlBuilder(args);
-        // Validate and parse params with Zod if provided
-        let queryString = "";
-        if (paramSchema && params) {
-            const validatedParams = paramSchema.parse(params);
-            queryString = `?${new URLSearchParams(validatedParams).toString()}`;
-        }
-        const fullUrl = `${baseUrl}${queryString}`;
-        const response = await client.get(fullUrl);
-        if (!response.success || !response.data) {
-            return response;
-        }
-        const parsed = returnSchema.safeParse(response.data);
-        if (!parsed.success) {
-            captureException(parsed.error);
-            return {
-                ...response,
-                success: false,
-                error: "Invalid response format",
-                data: undefined,
-            };
-        }
-        return {
-            ...response,
-            data: parsed.data,
-        };
-    };
-    // biome-ignore lint/suspicious/noExplicitAny: fn can literally be any function
-    return fn;
-}
-
 // Date transformer for ISO8601 strings
-const dateTransformer$1 = date();
-const nullableDateTransformer$1 = date().nullable();
-// Ticket types based on TicketSerializer
-const TicketSchema = object$1({
+const dateTransformer = date();
+const nullableDateTransformer = date().nullable();
+// Ticket schema based on TicketSerializer
+const TicketSchema = object({
     id: uuid(), // unidy_id
-    title: string$1(),
-    text: string$1().nullable(),
-    reference: string$1(),
-    metadata: record$1(string$1(), unknown$1()).nullable(),
-    wallet_export: record$1(string$1(), unknown$1()).nullable(),
-    state: string$1(),
-    payment_state: string$1().nullable(),
-    button_cta_url: string$1().nullable(),
-    info_banner: string$1().nullable(),
-    seating: string$1().nullable(),
-    venue: string$1().nullable(),
-    currency: string$1().nullable(),
-    starts_at: dateTransformer$1, // ISO8601(3) -> Date
-    ends_at: nullableDateTransformer$1, // ISO8601(3) -> Date | null
-    created_at: dateTransformer$1, // ISO8601(3) -> Date
-    updated_at: dateTransformer$1, // ISO8601(3) -> Date
-    price: number$1(), // decimal(8, 2) -> float
+    title: string(),
+    text: string().nullable(),
+    reference: string(),
+    metadata: record(string(), unknown()).nullable(),
+    wallet_export: record(string(), unknown()).nullable(),
+    state: string(),
+    payment_state: string().nullable(),
+    button_cta_url: string().nullable(),
+    info_banner: string().nullable(),
+    seating: string().nullable(),
+    venue: string().nullable(),
+    currency: string().nullable(),
+    starts_at: dateTransformer, // ISO8601(3) -> Date
+    ends_at: nullableDateTransformer, // ISO8601(3) -> Date | null
+    created_at: dateTransformer, // ISO8601(3) -> Date
+    updated_at: dateTransformer, // ISO8601(3) -> Date
+    price: number(), // decimal(8, 2) -> float
     user_id: uuid(),
     ticket_category_id: uuid(),
 });
-// List response
-const TicketsListResponseSchema = object$1({
+// Tickets list response schema
+const TicketsListResponseSchema = object({
     meta: PaginationMetaSchema,
-    results: array$1(TicketSchema),
+    results: array(TicketSchema),
 });
-// Query params schema with validations
-const TicketsListParamsSchema = TicketableListParamsBaseSchema.extend({ ticket_category_id: string$1().uuid() }).partial();
-class TicketsService {
-    client;
-    list;
-    get;
-    constructor(client) {
-        this.client = client;
-        this.list = getWithSchema(this.client, TicketsListResponseSchema, (_args) => "/api/sdk/v1/tickets", TicketsListParamsSchema);
-        this.get = getWithSchema(this.client, TicketSchema, (args) => `/api/sdk/v1/tickets/${args.id}`);
-    }
-}
-
-// Date transformer for ISO8601 strings
-const dateTransformer = date();
-const nullableDateTransformer = date().nullable();
-// Subscription types based on SubscriptionSerializer
-const SubscriptionSchema = object$1({
+// Subscription schema based on SubscriptionSerializer
+const SubscriptionSchema = object({
     id: uuid(), // unidy_id
-    title: string$1(),
-    text: string$1(),
-    payment_frequency: string$1().nullable(),
-    metadata: record$1(string$1(), unknown$1()).nullable(),
-    wallet_export: record$1(string$1(), unknown$1()).nullable(),
-    state: string$1(),
-    reference: string$1(),
-    payment_state: string$1().nullable(),
-    currency: string$1().nullable(),
-    button_cta_url: string$1().nullable(),
+    title: string(),
+    text: string(),
+    payment_frequency: string().nullable(),
+    metadata: record(string(), unknown()).nullable(),
+    wallet_export: record(string(), unknown()).nullable(),
+    state: string(),
+    reference: string(),
+    payment_state: string().nullable(),
+    currency: string().nullable(),
+    button_cta_url: string().nullable(),
     created_at: dateTransformer, // ISO8601(3) -> Date
     updated_at: dateTransformer, // ISO8601(3) -> Date
     starts_at: nullableDateTransformer, // ISO8601(3) -> Date | null
     ends_at: nullableDateTransformer, // ISO8601(3) -> Date | null
     next_payment_at: nullableDateTransformer, // ISO8601(3) -> Date | null
-    price: number$1(), // decimal(8, 2) -> float
+    price: number(), // decimal(8, 2) -> float
     user_id: uuid(),
     subscription_category_id: uuid(),
 });
-// List response
-const SubscriptionsListResponseSchema = object$1({
+// Subscriptions list response schema
+const SubscriptionsListResponseSchema = object({
     meta: PaginationMetaSchema,
-    results: array$1(SubscriptionSchema),
+    results: array(SubscriptionSchema),
 });
-// Query params schema with validations
-const SubscriptionsListParamsSchema = TicketableListParamsBaseSchema.extend({ subscription_category_id: string$1().uuid() }).partial();
-class SubscriptionsService {
+
+/**
+ * Base service for ticketable resources (tickets and subscriptions).
+ * Handles common query parameter building and response parsing.
+ */
+class TicketableService extends BaseService {
+    /**
+     * Builds query params from args, mapping camelCase to snake_case.
+     * Returns undefined values filtered out.
+     */
+    buildListParams(args = {}, categoryIdKey, categoryIdValue) {
+        return {
+            page: args.page,
+            limit: args.perPage,
+            state: args.state,
+            payment_state: args.paymentState,
+            order_by: args.orderBy,
+            order_direction: args.orderDirection,
+            service_id: args.serviceId,
+            [categoryIdKey]: categoryIdValue,
+        };
+    }
+    /**
+     * Converts params to query string, filtering undefined/null and converting to strings.
+     */
+    toQueryString(params) {
+        const filtered = Object.entries(params)
+            .filter(([_, v]) => v !== undefined && v !== null)
+            .map(([k, v]) => [k, String(v)]);
+        if (filtered.length === 0)
+            return "";
+        return `?${new URLSearchParams(Object.fromEntries(filtered)).toString()}`;
+    }
+    /**
+     * Generic list handler with schema validation.
+     */
+    async handleList(endpoint, queryString, schema, resourceName) {
+        const response = await this.client.get(`${endpoint}${queryString}`);
+        return this.handleResponse(response, () => {
+            if (!response.success) {
+                this.logger.error(`Failed to fetch ${resourceName}`, response);
+                return ["server_error", null];
+            }
+            const parsed = schema.safeParse(response.data);
+            if (!parsed.success) {
+                this.logger.error("Invalid response format", parsed.error);
+                return ["invalid_response", null];
+            }
+            return [null, parsed.data];
+        });
+    }
+    /**
+     * Generic get handler with schema validation.
+     */
+    async handleGet(endpoint, schema, resourceName) {
+        const response = await this.client.get(endpoint);
+        return this.handleResponse(response, () => {
+            if (!response.success) {
+                if (response.status === 404) {
+                    return ["not_found", null];
+                }
+                this.logger.error(`Failed to fetch ${resourceName}`, response);
+                return ["server_error", null];
+            }
+            const parsed = schema.safeParse(response.data);
+            if (!parsed.success) {
+                this.logger.error("Invalid response format", parsed.error);
+                return ["invalid_response", null];
+            }
+            return [null, parsed.data];
+        });
+    }
+}
+
+class TicketsService extends TicketableService {
+    constructor(client, deps) {
+        super(client, "TicketsService", deps);
+    }
+    async list(args = {}) {
+        const params = this.buildListParams(args, "ticket_category_id", args.ticketCategoryId);
+        const queryString = this.toQueryString(params);
+        return this.handleList("/api/sdk/v1/tickets", queryString, TicketsListResponseSchema, "tickets");
+    }
+    async get(args) {
+        return this.handleGet(`/api/sdk/v1/tickets/${args.id}`, TicketSchema, "ticket");
+    }
+}
+
+class SubscriptionsService extends TicketableService {
+    constructor(client, deps) {
+        super(client, "SubscriptionsService", deps);
+    }
+    async list(args = {}) {
+        const params = this.buildListParams(args, "subscription_category_id", args.subscriptionCategoryId);
+        const queryString = this.toQueryString(params);
+        return this.handleList("/api/sdk/v1/subscriptions", queryString, SubscriptionsListResponseSchema, "subscriptions");
+    }
+    async get(args) {
+        return this.handleGet(`/api/sdk/v1/subscriptions/${args.id}`, SubscriptionSchema, "subscription");
+    }
+}
+
+class InvalidTokenError extends Error {
+}
+InvalidTokenError.prototype.name = "InvalidTokenError";
+function b64DecodeUnicode(str) {
+    return decodeURIComponent(atob(str).replace(/(.)/g, (m, p) => {
+        let code = p.charCodeAt(0).toString(16).toUpperCase();
+        if (code.length < 2) {
+            code = "0" + code;
+        }
+        return "%" + code;
+    }));
+}
+function base64UrlDecode(str) {
+    let output = str.replace(/-/g, "+").replace(/_/g, "/");
+    switch (output.length % 4) {
+        case 0:
+            break;
+        case 2:
+            output += "==";
+            break;
+        case 3:
+            output += "=";
+            break;
+        default:
+            throw new Error("base64 string is not of the correct length");
+    }
+    try {
+        return b64DecodeUnicode(output);
+    }
+    catch (err) {
+        return atob(output);
+    }
+}
+function jwtDecode(token, options) {
+    if (typeof token !== "string") {
+        throw new InvalidTokenError("Invalid token specified: must be a string");
+    }
+    options || (options = {});
+    const pos = options.header === true ? 0 : 1;
+    const part = token.split(".")[pos];
+    if (typeof part !== "string") {
+        throw new InvalidTokenError(`Invalid token specified: missing part #${pos + 1}`);
+    }
+    let decoded;
+    try {
+        decoded = base64UrlDecode(part);
+    }
+    catch (e) {
+        throw new InvalidTokenError(`Invalid token specified: invalid base64 for part #${pos + 1} (${e.message})`);
+    }
+    try {
+        return JSON.parse(decoded);
+    }
+    catch (e) {
+        throw new InvalidTokenError(`Invalid token specified: invalid json for part #${pos + 1} (${e.message})`);
+    }
+}
+
+const logger = createLogger("PasskeyAuth");
+const PASSKEY_ERRORS = {
+    NotSupportedError: "passkey_not_supported",
+    NotAllowedError: "passkey_cancelled",
+    SecurityError: "passkey_security_error",
+    InvalidStateError: "passkey_invalid_state",
+};
+function decodeBase64Url(base64url) {
+    const base64 = base64url.replace(/-/g, "+").replace(/_/g, "/");
+    const padded = base64 + "=".repeat((4 - (base64.length % 4)) % 4);
+    return Uint8Array.from(atob(padded), (c) => c.charCodeAt(0));
+}
+function buildPublicKeyOptions(options) {
+    return {
+        challenge: Uint8Array.from(atob(options.challenge), (c) => c.charCodeAt(0)),
+        timeout: options.timeout || 60000,
+        rpId: options.rpId,
+        userVerification: options.userVerification || "required",
+        allowCredentials: options.allowCredentials?.map((cred) => ({
+            ...cred,
+            id: decodeBase64Url(cred.id),
+        })),
+    };
+}
+function formatCredentialForServer(credential) {
+    const response = credential.response;
+    return {
+        id: credential.id,
+        rawId: btoa(String.fromCharCode(...new Uint8Array(credential.rawId))),
+        response: {
+            authenticatorData: btoa(String.fromCharCode(...new Uint8Array(response.authenticatorData))),
+            clientDataJSON: btoa(String.fromCharCode(...new Uint8Array(response.clientDataJSON))),
+            signature: btoa(String.fromCharCode(...new Uint8Array(response.signature))),
+        },
+        type: credential.type,
+    };
+}
+function extractAndSetSignInId(tokenResponse) {
+    if (tokenResponse.sid) {
+        authStore.setSignInId(tokenResponse.sid);
+        return;
+    }
+    // Fallback: extract sid from JWT token payload
+    try {
+        const decoded = jwtDecode(tokenResponse.jwt);
+        if (decoded.sid) {
+            authStore.setSignInId(decoded.sid);
+        }
+    }
+    catch {
+        // Failed to decode JWT token to extract sid, continue without it
+    }
+}
+function handlePasskeyError(error) {
+    logger.error("Passkey error:", error);
+    let errorMessage = "passkey_error";
+    if (error instanceof DOMException) {
+        errorMessage = PASSKEY_ERRORS[error.name] || "passkey_error";
+    }
+    authStore.setGlobalError("auth", errorMessage);
+    authStore.setLoading(false);
+}
+async function authenticateWithPasskey(client, onSuccess) {
+    authStore.setLoading(true);
+    authStore.clearErrors();
+    if (!window.PublicKeyCredential) {
+        authStore.setGlobalError("auth", "passkey_not_supported");
+        authStore.setLoading(false);
+        return;
+    }
+    try {
+        const [optionsError, options] = await client.auth.getPasskeyOptions(state.sid ? { signInId: state.sid } : undefined);
+        if (optionsError || !options) {
+            authStore.setGlobalError("auth", optionsError || "bad_request");
+            authStore.setLoading(false);
+            return;
+        }
+        const publicKeyOptions = buildPublicKeyOptions(options);
+        const credential = (await navigator.credentials.get({
+            publicKey: publicKeyOptions,
+        }));
+        if (!credential) {
+            authStore.setGlobalError("auth", "passkey_cancelled");
+            authStore.setLoading(false);
+            return;
+        }
+        const formattedCredential = formatCredentialForServer(credential);
+        const [verifyError, tkResponse] = await client.auth.authenticateWithPasskey({
+            payload: { credential: formattedCredential },
+        });
+        const tokenResponse = tkResponse;
+        if (verifyError || !tokenResponse) {
+            authStore.setGlobalError("auth", verifyError || "authentication_failed");
+            authStore.setLoading(false);
+            return;
+        }
+        authStore.setToken(tokenResponse.jwt);
+        extractAndSetSignInId(tokenResponse);
+        onSuccess(tokenResponse);
+    }
+    catch (error) {
+        handlePasskeyError(error);
+    }
+}
+
+class AuthHelpers {
     client;
-    list;
-    get;
+    logger = createLogger("AuthHelpers");
     constructor(client) {
         this.client = client;
-        this.list = getWithSchema(this.client, SubscriptionsListResponseSchema, (_args) => "/api/sdk/v1/subscriptions", SubscriptionsListParamsSchema);
-        this.get = getWithSchema(this.client, SubscriptionSchema, (args) => `/api/sdk/v1/subscriptions/${args.id}`);
+    }
+    async createSignIn(email, password, sendMagicCode) {
+        if (!email) {
+            throw new Error(t("errors.required_field", { field: "Email" }));
+        }
+        authStore.setLoading(true);
+        authStore.clearErrors();
+        const [error, response] = await this.client.auth.createSignIn({ payload: { email, password, sendMagicCode } });
+        if (error) {
+            this.handleAuthError(error, response);
+            return;
+        }
+        if (password) {
+            const token = jwtDecode(response.jwt);
+            authStore.setSignInId(token.sid);
+            authStore.setToken(response.jwt);
+            authStore.setLoading(false);
+            authStore.getRootComponentRef()?.onAuth(response);
+            return;
+        }
+        if (sendMagicCode) {
+            authStore.setSignInId(response.sid);
+            authStore.setMagicCodeStep("sent");
+            authStore.setStep("magic-code");
+            authStore.setLoading(false);
+            return [error, response];
+        }
+        const signInResponse = response;
+        authStore.setStep("verification");
+        authStore.setEmail(email);
+        authStore.setSignInId(signInResponse.sid);
+        authStore.setLoginOptions(signInResponse.login_options);
+        authStore.setLoading(false);
+    }
+    async authenticateWithPassword(password) {
+        if (!state.sid) {
+            throw new Error(t("errors.no_sign_in_id"));
+        }
+        if (!password) {
+            throw new Error(t("errors.required_field", { field: "Password" }));
+        }
+        authStore.setLoading(true);
+        authStore.clearErrors();
+        const [error, response] = await this.client.auth.authenticateWithPassword({
+            signInId: state.sid,
+            payload: { password },
+        });
+        if (error) {
+            this.handleAuthError(error, response);
+        }
+        else {
+            authStore.setLoading(false);
+            this.handleAuthSuccess(response);
+            return;
+        }
+    }
+    handleAuthError(error, response) {
+        if (error === "account_not_found") {
+            authStore.setFieldError("email", error);
+            authStore.setLoading(false);
+            return;
+        }
+        if (error === "missing_required_fields") {
+            authStore.setMissingFields(response.fields);
+            state$1.data = response.fields;
+            if (response.sid) {
+                authStore.setSignInId(response.sid);
+            }
+            authStore.setStep("missing-fields");
+            authStore.setLoading(false);
+            return;
+        }
+        if (error === "account_locked") {
+            authStore.setGlobalError("auth", error);
+        }
+        else {
+            authStore.setFieldError("password", error);
+        }
+        authStore.setLoading(false);
+    }
+    async logout() {
+        const [error, _] = await this.client.auth.signOut({ signInId: state.sid });
+        if (error) {
+            authStore.setGlobalError("auth", error);
+        }
+        return [error, _];
+    }
+    async refreshToken() {
+        if (state.step === "missing-fields") {
+            return;
+        }
+        this.extractSignInIdFromQuery();
+        if (!state.sid) {
+            this.logger.warn("No sign-in ID in the session");
+            return;
+        }
+        const [error, response] = await this.client.auth.refreshToken({ signInId: state.sid });
+        if (error) {
+            authStore.reset();
+            authStore.setGlobalError("auth", error);
+        }
+        else {
+            authStore.setToken(response.jwt);
+        }
+    }
+    handleSocialAuthRedirect() {
+        // missing required fields flow
+        const url = new URL(window.location.href);
+        const params = url.searchParams;
+        const error = params.get("error");
+        if (error !== "missing_required_fields") {
+            return;
+        }
+        const fieldsFromUrl = params.get("fields");
+        if (!fieldsFromUrl) {
+            return;
+        }
+        const signInId = params.get("sid");
+        if (signInId) {
+            authStore.setSignInId(signInId);
+        }
+        else {
+            return;
+        }
+        try {
+            const fields = JSON.parse(fieldsFromUrl);
+            authStore.setMissingFields(fields);
+            state$1.data = fields;
+            authStore.setStep("missing-fields");
+            params.delete("error");
+            params.delete("fields");
+            const cleanUrl = `${url.origin}${url.pathname}${url.hash}`;
+            window.history.replaceState(null, "", cleanUrl);
+        }
+        catch (e) {
+            this.logger.error("Failed to parse missing fields payload:", e);
+            authStore.setGlobalError("auth", "invalid_required_fields_payload");
+        }
+    }
+    async sendMagicCode() {
+        if (!state.sid && state.step !== "single-login") {
+            throw new Error(t("errors.no_sign_in_id"));
+        }
+        authStore.setMagicCodeStep("requested");
+        authStore.setLoading(true);
+        authStore.clearErrors();
+        if (state.step === "single-login") {
+            const [error, response] = await this.createSignIn(state.email, undefined, true);
+            authStore.setLoading(false);
+            return [error, response];
+        }
+        const [error, response] = await this.client.auth.sendMagicCode({ signInId: state.sid });
+        authStore.setLoading(false);
+        authStore.setStep("magic-code");
+        if (!error) {
+            authStore.setMagicCodeStep("sent");
+            return [null, response];
+        }
+        authStore.setFieldError("magicCode", error);
+        if (error === "magic_code_recently_created") {
+            authStore.setMagicCodeStep("sent");
+        }
+        return [error, response];
+    }
+    async authenticateWithMagicCode(code) {
+        if (!state.sid) {
+            throw new Error(t("errors.no_sign_in_id"));
+        }
+        if (!code) {
+            throw new Error(t("errors.magic_code_is_missing"));
+        }
+        authStore.setLoading(true);
+        authStore.clearErrors();
+        const [error, response] = await this.client.auth.authenticateWithMagicCode({
+            signInId: state.sid,
+            payload: { code },
+        });
+        if (!error) {
+            this.handleAuthSuccess(response);
+            return;
+        }
+        if (error === "missing_required_fields") {
+            this.handleMissingFields(response);
+            return;
+        }
+        authStore.setLoading(false);
+        authStore.setFieldError("magicCode", error);
+    }
+    async sendResetPasswordEmail() {
+        if (!state.sid) {
+            throw new Error(t("errors.no_sign_in_id"));
+        }
+        authStore.setLoading(true);
+        authStore.setResetPasswordStep("requested");
+        const [error, _] = await this.client.auth.sendResetPasswordEmail({
+            signInId: state.sid,
+            payload: { returnTo: window.location.href },
+        });
+        if (error) {
+            authStore.setFieldError("resetPassword", error);
+        }
+        else {
+            authStore.setResetPasswordStep("sent");
+            authStore.clearErrors();
+        }
+        authStore.setLoading(false);
+    }
+    async handleResetPasswordRedirect() {
+        const url = new URL(window.location.href);
+        const params = url.searchParams;
+        const resetToken = params.get("reset_password_token");
+        if (!resetToken) {
+            return false;
+        }
+        if (state.sid) {
+            authStore.setLoading(true);
+            const [error] = await this.client.auth.validateResetPasswordToken({
+                signInId: state.sid,
+                token: resetToken,
+            });
+            if (error) {
+                authStore.setFieldError("resetPassword", error);
+                authStore.setStep("reset-password");
+                authStore.setLoading(false);
+                return false;
+            }
+        }
+        authStore.setResetToken(resetToken);
+        authStore.setStep("reset-password");
+        authStore.setLoading(false);
+        return true;
+    }
+    async resetPassword() {
+        if (!state.resetPassword.token) {
+            throw new Error("No reset token available");
+        }
+        if (!state.resetPassword.newPassword) {
+            authStore.setFieldError("resetPassword", "password_required");
+            return;
+        }
+        if (state.resetPassword.passwordConfirmation &&
+            state.resetPassword.newPassword !== state.resetPassword.passwordConfirmation) {
+            authStore.setFieldError("resetPassword", "passwords_do_not_match");
+            return;
+        }
+        authStore.setLoading(true);
+        authStore.clearErrors();
+        const [error, response] = await this.client.auth.resetPassword({
+            signInId: state.sid,
+            token: state.resetPassword.token,
+            payload: {
+                password: state.resetPassword.newPassword,
+                passwordConfirmation: state.resetPassword.passwordConfirmation,
+            },
+        });
+        if (error) {
+            authStore.setFieldError("resetPassword", error);
+            // TODO: add proper password requirements handling --> for now this is fine
+            if (error === "invalid_password") {
+                authStore.setFieldError("password", response.error_details?.password.map((p) => t(`errors.password_requirements.${p}`)).join("\n"));
+            }
+        }
+        else {
+            authStore.setStep("email");
+            authStore.updateResetPassword({
+                step: "completed",
+                token: null,
+                newPassword: "",
+                passwordConfirmation: "",
+            });
+            clearUrlParam("reset_password_token");
+            Flash.success.addMessage("Password reset successfully");
+        }
+        authStore.setLoading(false);
+    }
+    authenticateWithPasskey() {
+        return authenticateWithPasskey(this.client, (response) => this.handleAuthSuccess(response));
+    }
+    extractSignInIdFromQuery() {
+        const sid = clearUrlParam("sid");
+        if (sid) {
+            authStore.setSignInId(sid);
+        }
+    }
+    handleMissingFields(response) {
+        authStore.setMissingFields(response.fields);
+        state$1.data = response.fields;
+        authStore.setStep("missing-fields");
+        authStore.setLoading(false);
+    }
+    handleAuthSuccess(response) {
+        authStore.setToken(response.jwt);
+        authStore.setLoading(false);
+        authStore.getRootComponentRef()?.onAuth(response);
     }
 }
 
+class Auth {
+    static instance;
+    helpers;
+    constructor(client) {
+        this.helpers = new AuthHelpers(client);
+        this.helpers.handleSocialAuthRedirect();
+        this.helpers.handleResetPasswordRedirect();
+    }
+    static Errors = {
+        email: {
+            NOT_FOUND: "account_not_found",
+        },
+        magicCode: {
+            RECENTLY_CREATED: "magic_code_recently_created",
+            NOT_VALID: "magic_code_not_valid",
+            EXPIRED: "magic_code_expired",
+            USED: "magic_code_used",
+        },
+        password: {
+            INVALID: "invalid_password",
+            NOT_SET: "password_not_set",
+            RESET_PASSWORD_ALREADY_SENT: "reset_password_already_sent",
+        },
+        general: {
+            ACCOUNT_LOCKED: "account_locked",
+            SIGN_IN_EXPIRED: "sign_in_expired",
+        },
+    };
+    static async getInstance() {
+        if (!Auth.isInitialized()) {
+            await waitForConfig();
+            return Auth.initialize(getUnidyClient());
+        }
+        return Auth.instance;
+    }
+    static initialize(client) {
+        Auth.instance = new Auth(client);
+        if (Auth.instance.isTokenValid(state.token)) {
+            authStore.setAuthenticated(true);
+        }
+        return Auth.instance;
+    }
+    static isInitialized() {
+        return !!Auth.instance;
+    }
+    isTokenValid(token) {
+        try {
+            let decoded;
+            if (typeof token === "string") {
+                decoded = jwtDecode(token);
+            }
+            else {
+                decoded = token;
+            }
+            if (!decoded)
+                return false;
+            const currentTime = Date.now() / 1000;
+            return decoded.exp > currentTime;
+        }
+        catch (error) {
+            captureException(error);
+            return false;
+        }
+    }
+    async isAuthenticated() {
+        const token = await this.getToken();
+        return typeof token === "string";
+    }
+    async getToken() {
+        const currentToken = state.token;
+        if (currentToken && this.isTokenValid(currentToken)) {
+            return currentToken;
+        }
+        await this.helpers.refreshToken();
+        if (state.globalErrors.auth || !state.token) {
+            return this.createAuthError(t("errors.refresh_failed"), "REFRESH_FAILED", true);
+        }
+        return state.token;
+    }
+    async userData() {
+        const token = await this.getToken();
+        if (typeof token !== "string") {
+            return null;
+        }
+        if (!token) {
+            return null;
+        }
+        try {
+            return jwtDecode(token);
+        }
+        catch (error) {
+            captureException(error);
+            return null;
+        }
+    }
+    async logout() {
+        const [error, _] = await this.helpers.logout();
+        if (error) {
+            return this.createAuthError(t("errors.sign_out_failed", { reason: error }), "SIGN_OUT_FAILED", false);
+        }
+        authStore.reset();
+        return true;
+    }
+    getEmail() {
+        return state.email;
+    }
+    createAuthError(message, code, requiresReauth = false) {
+        const error = new Error(message);
+        error.code = code;
+        error.requiresReauth = requiresReauth;
+        return error;
+    }
+}
+
+/** Default no-op error reporter */
+const noopErrorReporter = {
+    captureException: () => { },
+};
+/**
+ * Default console logger for services.
+ *
+ * Note: This intentionally doesn't use the logger.ts module because:
+ * 1. Services need to work in non-browser environments (standalone/Node.js)
+ * 2. logger.ts is designed for Stencil components with browser-specific features
+ *    (localStorage-based log levels, UnidyComponent mixin)
+ * 3. Services allow dependency injection of custom loggers for flexibility
+ */
+const consoleLogger = {
+    error: console.error.bind(console),
+    warn: console.warn.bind(console),
+    info: console.info.bind(console),
+    debug: console.debug.bind(console),
+};
+class BaseService {
+    client;
+    logger;
+    errorReporter;
+    getIdToken;
+    getLocale;
+    constructor(client, serviceName, deps) {
+        this.client = client;
+        // Use injected dependencies or defaults
+        this.logger = deps?.logger ?? consoleLogger;
+        this.errorReporter = deps?.errorReporter ?? noopErrorReporter;
+        this.getIdToken = deps?.getIdToken ?? (async () => null);
+        this.getLocale = deps?.getLocale ?? (() => "en");
+        // Prefix logger if using console
+        if (!deps?.logger) {
+            this.logger = {
+                error: (...args) => console.error(`[${serviceName}]`, ...args),
+                warn: (...args) => console.warn(`[${serviceName}]`, ...args),
+                info: (...args) => console.info(`[${serviceName}]`, ...args),
+                debug: (...args) => console.debug(`[${serviceName}]`, ...args),
+            };
+        }
+    }
+    handleResponse(response, handler) {
+        if (response.connectionError) {
+            return ["connection_failed", null];
+        }
+        try {
+            return handler();
+        }
+        catch (error) {
+            this.logger.error("Schema validation error", error);
+            this.errorReporter.captureException(error);
+            // Use safeParse to avoid throwing if response.data doesn't match the schema
+            const parsed = SchemaValidationErrorSchema.safeParse(response.data);
+            const schemaError = parsed.success
+                ? parsed.data
+                : { error_identifier: "schema_validation_error", errors: [String(error)] };
+            return ["schema_validation_error", schemaError];
+        }
+    }
+    buildAuthHeaders(headers) {
+        const filtered = Object.entries(headers).reduce((acc, [key, value]) => {
+            if (value !== undefined) {
+                acc[key] = value;
+            }
+            return acc;
+        }, {});
+        return Object.keys(filtered).length > 0 ? filtered : undefined;
+    }
+}
+
+/** Default browser dependencies using Sentry and the SDK logger */
+function createBrowserDeps(serviceName) {
+    return {
+        logger: createLogger(serviceName),
+        errorReporter: {
+            captureException: (error, context) => captureException(error, { extra: context }),
+        },
+        getIdToken: async () => {
+            const auth = await Auth.getInstance();
+            const token = await auth.getToken();
+            return typeof token === "string" ? token : null;
+        },
+        getLocale: () => unidyState.locale,
+    };
+}
 class UnidyClient {
     apiClient;
     newsletters;
@@ -5230,11 +5598,12 @@ class UnidyClient {
         this.apiClient = new ApiClient(baseUrl, apiKey, (isConnected) => {
             unidyState.backendConnected = isConnected;
         });
-        this.newsletters = new NewsletterService(this.apiClient);
-        this.profile = new ProfileService(this.apiClient);
-        this.auth = new AuthService(this.apiClient);
-        this.tickets = new TicketsService(this.apiClient);
-        this.subscriptions = new SubscriptionsService(this.apiClient);
+        // Initialize services with browser-specific dependencies
+        this.newsletters = new NewsletterService(this.apiClient, createBrowserDeps("NewsletterService"));
+        this.profile = new ProfileService(this.apiClient, createBrowserDeps("ProfileService"));
+        this.auth = new AuthService(this.apiClient, createBrowserDeps("AuthService"));
+        this.tickets = new TicketsService(this.apiClient, createBrowserDeps("TicketsService"));
+        this.subscriptions = new SubscriptionsService(this.apiClient, createBrowserDeps("SubscriptionsService"));
     }
 }
 let instance = null;
@@ -5248,7 +5617,7 @@ function getUnidyClient() {
     return instance;
 }
 
-export { ApiClient as A, NewsletterService as N, ProfileService as P, SchemaValidationErrorSchema as S, TicketsService as T, UnidyClient as U, AuthService as a, UserProfileSchema as b, PaginationMetaSchema as c, PaginationParamsSchema as d, SubscriptionsService as e, getUnidyClient as g };
-//# sourceMappingURL=index-DSDkaHWI.js.map
+export { ApiClient as A, BaseErrorSchema as B, NewsletterService as N, ProfileService as P, SchemaValidationErrorSchema as S, TicketsService as T, UnidyClient as U, AuthService as a, UserProfileSchema as b, PaginationMetaSchema as c, PaginationParamsSchema as d, BaseService as e, SubscriptionsService as f, getUnidyClient as g, Auth as h };
+//# sourceMappingURL=index-2p1QEJrx.js.map
 
-//# sourceMappingURL=index-DSDkaHWI.js.map
+//# sourceMappingURL=index-2p1QEJrx.js.map