@unidy.io/sdk 1.1.4 → 1.2.0-alpha2

package/dist/cjs/{index-R2MKLaem.js → index-CvFbf5-D.js}

@@ -1,38 +1,56 @@
 'use strict';
 
-var i18n = require('./i18n-BoDZ8kd2.js');
 var index = require('./index-B_N5xKgH.js');
-require('./profile-store-P_BcYkef.js');
 var unidyStore = require('./unidy-store-7AbWnZ6g.js');
+var authStore = require('./auth-store-DC9EVec8.js');
+var i18n = require('./i18n-BAZB-eHh.js');
+var profileStore = require('./profile-store-P_BcYkef.js');
+var flashStore = require('./flash-store-BuIBuQDx.js');
+var componentUtils = require('./component-utils-BpMyeVQo.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 = index.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();
@@ -50,15 +68,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 {
@@ -68,37 +98,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);
-                index.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);
@@ -109,40 +135,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: i18n.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) {
+        index.captureException(error, {
+            tags: { error_type: "connection_error" },
+            extra: { endpoint, method },
+        });
     }
 }
 
@@ -686,7 +698,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);
@@ -699,7 +710,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);
@@ -822,14 +832,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
@@ -1418,7 +1427,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 {
@@ -1740,7 +1749,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 {
@@ -1774,7 +1783,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 {
@@ -1793,23 +1802,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;
@@ -3041,12 +3033,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",
@@ -3378,12 +3364,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);
@@ -3474,7 +3460,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) => {
@@ -3605,7 +3591,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) => {
@@ -3619,16 +3605,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);
@@ -3640,7 +3619,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) => {
@@ -3669,7 +3648,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) => {
@@ -3680,8 +3659,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) => {
@@ -3696,7 +3675,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 ?? {},
@@ -3709,7 +3688,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,
@@ -3752,7 +3731,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,
@@ -3820,7 +3799,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],
@@ -3872,7 +3851,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,
@@ -3984,57 +3963,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,
@@ -4048,15 +4080,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()
@@ -4069,144 +4102,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) {
-            index.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) {
-            index.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) {
@@ -4214,7 +4260,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,
@@ -4229,25 +4275,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) {
@@ -4255,7 +4301,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,
@@ -4264,10 +4310,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) {
@@ -4275,15 +4321,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) {
@@ -4291,7 +4338,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,
@@ -4300,21 +4347,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,
@@ -4323,61 +4374,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,
@@ -4386,841 +4444,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) {
-            unidyStore.unidyState.backendConnected = false;
-            return ["connection_failed", null];
-        }
-        try {
-            return handler();
-        }
-        catch (error) {
-            index.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 = index.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:
-                index.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) {
-            index.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 = index.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.authStore.setSignInId(tokenResponse.sid);
+        return;
+    }
+    // Fallback: extract sid from JWT token payload
+    try {
+        const decoded = jwtDecode(tokenResponse.jwt);
+        if (decoded.sid) {
+            authStore.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.authStore.setGlobalError("auth", errorMessage);
+    authStore.authStore.setLoading(false);
+}
+async function authenticateWithPasskey(client, onSuccess) {
+    authStore.authStore.setLoading(true);
+    authStore.authStore.clearErrors();
+    if (!window.PublicKeyCredential) {
+        authStore.authStore.setGlobalError("auth", "passkey_not_supported");
+        authStore.authStore.setLoading(false);
+        return;
+    }
+    try {
+        const [optionsError, options] = await client.auth.getPasskeyOptions(authStore.state.sid ? { signInId: authStore.state.sid } : undefined);
+        if (optionsError || !options) {
+            authStore.authStore.setGlobalError("auth", optionsError || "bad_request");
+            authStore.authStore.setLoading(false);
+            return;
+        }
+        const publicKeyOptions = buildPublicKeyOptions(options);
+        const credential = (await navigator.credentials.get({
+            publicKey: publicKeyOptions,
+        }));
+        if (!credential) {
+            authStore.authStore.setGlobalError("auth", "passkey_cancelled");
+            authStore.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.authStore.setGlobalError("auth", verifyError || "authentication_failed");
+            authStore.authStore.setLoading(false);
+            return;
+        }
+        authStore.authStore.setToken(tokenResponse.jwt);
+        extractAndSetSignInId(tokenResponse);
+        onSuccess(tokenResponse);
+    }
+    catch (error) {
+        handlePasskeyError(error);
+    }
+}
+
+class AuthHelpers {
     client;
-    list;
-    get;
+    logger = index.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(i18n.t("errors.required_field", { field: "Email" }));
+        }
+        authStore.authStore.setLoading(true);
+        authStore.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.authStore.setSignInId(token.sid);
+            authStore.authStore.setToken(response.jwt);
+            authStore.authStore.setLoading(false);
+            authStore.authStore.getRootComponentRef()?.onAuth(response);
+            return;
+        }
+        if (sendMagicCode) {
+            authStore.authStore.setSignInId(response.sid);
+            authStore.authStore.setMagicCodeStep("sent");
+            authStore.authStore.setStep("magic-code");
+            authStore.authStore.setLoading(false);
+            return [error, response];
+        }
+        const signInResponse = response;
+        authStore.authStore.setStep("verification");
+        authStore.authStore.setEmail(email);
+        authStore.authStore.setSignInId(signInResponse.sid);
+        authStore.authStore.setLoginOptions(signInResponse.login_options);
+        authStore.authStore.setLoading(false);
+    }
+    async authenticateWithPassword(password) {
+        if (!authStore.state.sid) {
+            throw new Error(i18n.t("errors.no_sign_in_id"));
+        }
+        if (!password) {
+            throw new Error(i18n.t("errors.required_field", { field: "Password" }));
+        }
+        authStore.authStore.setLoading(true);
+        authStore.authStore.clearErrors();
+        const [error, response] = await this.client.auth.authenticateWithPassword({
+            signInId: authStore.state.sid,
+            payload: { password },
+        });
+        if (error) {
+            this.handleAuthError(error, response);
+        }
+        else {
+            authStore.authStore.setLoading(false);
+            this.handleAuthSuccess(response);
+            return;
+        }
+    }
+    handleAuthError(error, response) {
+        if (error === "account_not_found") {
+            authStore.authStore.setFieldError("email", error);
+            authStore.authStore.setLoading(false);
+            return;
+        }
+        if (error === "missing_required_fields") {
+            authStore.authStore.setMissingFields(response.fields);
+            profileStore.state.data = response.fields;
+            if (response.sid) {
+                authStore.authStore.setSignInId(response.sid);
+            }
+            authStore.authStore.setStep("missing-fields");
+            authStore.authStore.setLoading(false);
+            return;
+        }
+        if (error === "account_locked") {
+            authStore.authStore.setGlobalError("auth", error);
+        }
+        else {
+            authStore.authStore.setFieldError("password", error);
+        }
+        authStore.authStore.setLoading(false);
+    }
+    async logout() {
+        const [error, _] = await this.client.auth.signOut({ signInId: authStore.state.sid });
+        if (error) {
+            authStore.authStore.setGlobalError("auth", error);
+        }
+        return [error, _];
+    }
+    async refreshToken() {
+        if (authStore.state.step === "missing-fields") {
+            return;
+        }
+        this.extractSignInIdFromQuery();
+        if (!authStore.state.sid) {
+            this.logger.warn("No sign-in ID in the session");
+            return;
+        }
+        const [error, response] = await this.client.auth.refreshToken({ signInId: authStore.state.sid });
+        if (error) {
+            authStore.authStore.reset();
+            authStore.authStore.setGlobalError("auth", error);
+        }
+        else {
+            authStore.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.authStore.setSignInId(signInId);
+        }
+        else {
+            return;
+        }
+        try {
+            const fields = JSON.parse(fieldsFromUrl);
+            authStore.authStore.setMissingFields(fields);
+            profileStore.state.data = fields;
+            authStore.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.authStore.setGlobalError("auth", "invalid_required_fields_payload");
+        }
+    }
+    async sendMagicCode() {
+        if (!authStore.state.sid && authStore.state.step !== "single-login") {
+            throw new Error(i18n.t("errors.no_sign_in_id"));
+        }
+        authStore.authStore.setMagicCodeStep("requested");
+        authStore.authStore.setLoading(true);
+        authStore.authStore.clearErrors();
+        if (authStore.state.step === "single-login") {
+            const [error, response] = await this.createSignIn(authStore.state.email, undefined, true);
+            authStore.authStore.setLoading(false);
+            return [error, response];
+        }
+        const [error, response] = await this.client.auth.sendMagicCode({ signInId: authStore.state.sid });
+        authStore.authStore.setLoading(false);
+        authStore.authStore.setStep("magic-code");
+        if (!error) {
+            authStore.authStore.setMagicCodeStep("sent");
+            return [null, response];
+        }
+        authStore.authStore.setFieldError("magicCode", error);
+        if (error === "magic_code_recently_created") {
+            authStore.authStore.setMagicCodeStep("sent");
+        }
+        return [error, response];
+    }
+    async authenticateWithMagicCode(code) {
+        if (!authStore.state.sid) {
+            throw new Error(i18n.t("errors.no_sign_in_id"));
+        }
+        if (!code) {
+            throw new Error(i18n.t("errors.magic_code_is_missing"));
+        }
+        authStore.authStore.setLoading(true);
+        authStore.authStore.clearErrors();
+        const [error, response] = await this.client.auth.authenticateWithMagicCode({
+            signInId: authStore.state.sid,
+            payload: { code },
+        });
+        if (!error) {
+            this.handleAuthSuccess(response);
+            return;
+        }
+        if (error === "missing_required_fields") {
+            this.handleMissingFields(response);
+            return;
+        }
+        authStore.authStore.setLoading(false);
+        authStore.authStore.setFieldError("magicCode", error);
+    }
+    async sendResetPasswordEmail() {
+        if (!authStore.state.sid) {
+            throw new Error(i18n.t("errors.no_sign_in_id"));
+        }
+        authStore.authStore.setLoading(true);
+        authStore.authStore.setResetPasswordStep("requested");
+        const [error, _] = await this.client.auth.sendResetPasswordEmail({
+            signInId: authStore.state.sid,
+            payload: { returnTo: window.location.href },
+        });
+        if (error) {
+            authStore.authStore.setFieldError("resetPassword", error);
+        }
+        else {
+            authStore.authStore.setResetPasswordStep("sent");
+            authStore.authStore.clearErrors();
+        }
+        authStore.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 (authStore.state.sid) {
+            authStore.authStore.setLoading(true);
+            const [error] = await this.client.auth.validateResetPasswordToken({
+                signInId: authStore.state.sid,
+                token: resetToken,
+            });
+            if (error) {
+                authStore.authStore.setFieldError("resetPassword", error);
+                authStore.authStore.setStep("reset-password");
+                authStore.authStore.setLoading(false);
+                return false;
+            }
+        }
+        authStore.authStore.setResetToken(resetToken);
+        authStore.authStore.setStep("reset-password");
+        authStore.authStore.setLoading(false);
+        return true;
+    }
+    async resetPassword() {
+        if (!authStore.state.resetPassword.token) {
+            throw new Error("No reset token available");
+        }
+        if (!authStore.state.resetPassword.newPassword) {
+            authStore.authStore.setFieldError("resetPassword", "password_required");
+            return;
+        }
+        if (authStore.state.resetPassword.passwordConfirmation &&
+            authStore.state.resetPassword.newPassword !== authStore.state.resetPassword.passwordConfirmation) {
+            authStore.authStore.setFieldError("resetPassword", "passwords_do_not_match");
+            return;
+        }
+        authStore.authStore.setLoading(true);
+        authStore.authStore.clearErrors();
+        const [error, response] = await this.client.auth.resetPassword({
+            signInId: authStore.state.sid,
+            token: authStore.state.resetPassword.token,
+            payload: {
+                password: authStore.state.resetPassword.newPassword,
+                passwordConfirmation: authStore.state.resetPassword.passwordConfirmation,
+            },
+        });
+        if (error) {
+            authStore.authStore.setFieldError("resetPassword", error);
+            // TODO: add proper password requirements handling --> for now this is fine
+            if (error === "invalid_password") {
+                authStore.authStore.setFieldError("password", response.error_details?.password.map((p) => i18n.t(`errors.password_requirements.${p}`)).join("\n"));
+            }
+        }
+        else {
+            authStore.authStore.setStep("email");
+            authStore.authStore.updateResetPassword({
+                step: "completed",
+                token: null,
+                newPassword: "",
+                passwordConfirmation: "",
+            });
+            componentUtils.clearUrlParam("reset_password_token");
+            flashStore.Flash.success.addMessage("Password reset successfully");
+        }
+        authStore.authStore.setLoading(false);
+    }
+    authenticateWithPasskey() {
+        return authenticateWithPasskey(this.client, (response) => this.handleAuthSuccess(response));
+    }
+    extractSignInIdFromQuery() {
+        const sid = componentUtils.clearUrlParam("sid");
+        if (sid) {
+            authStore.authStore.setSignInId(sid);
+        }
+    }
+    handleMissingFields(response) {
+        authStore.authStore.setMissingFields(response.fields);
+        profileStore.state.data = response.fields;
+        authStore.authStore.setStep("missing-fields");
+        authStore.authStore.setLoading(false);
+    }
+    handleAuthSuccess(response) {
+        authStore.authStore.setToken(response.jwt);
+        authStore.authStore.setLoading(false);
+        authStore.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 unidyStore.waitForConfig();
+            return Auth.initialize(getUnidyClient());
+        }
+        return Auth.instance;
+    }
+    static initialize(client) {
+        Auth.instance = new Auth(client);
+        if (Auth.instance.isTokenValid(authStore.state.token)) {
+            authStore.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) {
+            index.captureException(error);
+            return false;
+        }
+    }
+    async isAuthenticated() {
+        const token = await this.getToken();
+        return typeof token === "string";
+    }
+    async getToken() {
+        const currentToken = authStore.state.token;
+        if (currentToken && this.isTokenValid(currentToken)) {
+            return currentToken;
+        }
+        await this.helpers.refreshToken();
+        if (authStore.state.globalErrors.auth || !authStore.state.token) {
+            return this.createAuthError(i18n.t("errors.refresh_failed"), "REFRESH_FAILED", true);
+        }
+        return authStore.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) {
+            index.captureException(error);
+            return null;
+        }
+    }
+    async logout() {
+        const [error, _] = await this.helpers.logout();
+        if (error) {
+            return this.createAuthError(i18n.t("errors.sign_out_failed", { reason: error }), "SIGN_OUT_FAILED", false);
+        }
+        authStore.authStore.reset();
+        return true;
+    }
+    getEmail() {
+        return authStore.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: index.createLogger(serviceName),
+        errorReporter: {
+            captureException: (error, context) => index.captureException(error, { extra: context }),
+        },
+        getIdToken: async () => {
+            const auth = await Auth.getInstance();
+            const token = await auth.getToken();
+            return typeof token === "string" ? token : null;
+        },
+        getLocale: () => unidyStore.unidyState.locale,
+    };
+}
 class UnidyClient {
     apiClient;
     newsletters;
@@ -5232,11 +5600,12 @@ class UnidyClient {
         this.apiClient = new ApiClient(baseUrl, apiKey, (isConnected) => {
             unidyStore.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;
@@ -5251,7 +5620,10 @@ function getUnidyClient() {
 }
 
 exports.ApiClient = ApiClient;
+exports.Auth = Auth;
 exports.AuthService = AuthService;
+exports.BaseErrorSchema = BaseErrorSchema;
+exports.BaseService = BaseService;
 exports.NewsletterService = NewsletterService;
 exports.PaginationMetaSchema = PaginationMetaSchema;
 exports.PaginationParamsSchema = PaginationParamsSchema;
@@ -5262,6 +5634,6 @@ exports.TicketsService = TicketsService;
 exports.UnidyClient = UnidyClient;
 exports.UserProfileSchema = UserProfileSchema;
 exports.getUnidyClient = getUnidyClient;
-//# sourceMappingURL=index-R2MKLaem.js.map
+//# sourceMappingURL=index-CvFbf5-D.js.map
 
-//# sourceMappingURL=index-R2MKLaem.js.map
+//# sourceMappingURL=index-CvFbf5-D.js.map