@schibsted/account-sdk-browser 6.0.0-alpha.2 → 6.0.0-alpha.4

package/dist/types/login.d.ts

@@ -0,0 +1,120 @@
+/**
+ * Options accepted by {@link Identity#login} and related login URL helpers.
+ */
+export type LoginOptions = {
+    /**
+     * An opaque value used by the client to maintain state between the request and callback.
+     * It's also recommended to prevent CSRF {@link https://tools.ietf.org/html/rfc6749#section-10.12}
+     */
+    state: string;
+    /**
+     * Authentication Context Class Reference Values. If omitted, the user will be asked to
+     * authenticate using username+password. For 2FA (Two-Factor Authentication) possible values
+     * are `sms`, `otp` (one time password), `password` (will force password confirmation, even if
+     * user is already logged in), `eid`. Those values might be mixed as space-separated string.
+     * To make sure that user has authenticated with 2FA you need to verify AMR (Authentication
+     * Methods References) claim in ID token. Might also be used to ensure additional acr
+     * (sms, otp, eid) for already logged in users. Supported value is also 'otp-email' means one
+     * time password using email.
+     */
+    acrValues?: 'password' | 'otp' | 'sms' | 'eid-dk' | 'eid-no' | 'eid-se' | 'eid-fi' | 'eid' | 'otp-email' | (string & {});
+    /**
+     * The OAuth scopes for the tokens. This is a list of scopes, separated by space. If the list
+     * of scopes contains `openid`, the generated tokens includes the id token which can be useful
+     * for getting information about the user. Omitting scope is allowed, while `invalid_scope` is
+     * returned when the client asks for a scope you aren't allowed to request.
+     * {@link https://tools.ietf.org/html/rfc6749#section-3.3}
+     * Defaults to `openid`.
+     */
+    scope?: 'openid' | (string & {});
+    /**
+     * Redirect uri that will receive the code. Must exactly match a redirectUri from your client
+     * in self-service
+     */
+    redirectUri?: string;
+    /** Should we try to open a popup window? Defaults to `false`. */
+    preferPopup?: boolean;
+    /** user email or UUID hint */
+    loginHint?: string;
+    /** Pulse tag */
+    tag?: string;
+    /** Teaser slug. Teaser with given slug will be displayed in place of default teaser */
+    teaser?: string;
+    /**
+     * Specifies the allowable elapsed time in seconds since the last time the End-User was actively
+     * authenticated. If last authentication time is more than maxAge seconds in the past,
+     * re-authentication will be required. See the OpenID Connect spec section 3.1.2.1 for more
+     * information. Prefer a number of seconds; strings remain accepted for legacy callers.
+     */
+    maxAge?: number | string;
+    /**
+     * Optional parameter to overwrite client locale setting.
+     * New flows supports nb_NO, fi_FI, sv_SE, en_US
+     */
+    locale?: 'nb_NO' | 'fi_FI' | 'sv_SE' | 'en_US';
+    /** display username and password on one screen. Defaults to `false`. */
+    oneStepLogin?: boolean;
+    /**
+     * String that specifies whether the Authorization Server prompts the End-User for
+     * reauthentication or confirm account screen. Supported values: `select_account` or `login`.
+     * Defaults to `select_account`.
+     */
+    prompt?: 'select_account' | 'login';
+    /** Identifier for cross-domain tracking in Pulse */
+    xDomainId?: string;
+    /** Environment for cross-domain tracking in Pulse */
+    xEnvironmentId?: string;
+    /** Campaign identifier for tracking in Pulse */
+    originCampaign?: string;
+};
+/**
+ * Identical to {@link LoginOptions} except that `state` may also be a (possibly async) function;
+ * all other fields reuse the `LoginOptions` documentation.
+ */
+export type SimplifiedLoginWidgetLoginOptions = Omit<LoginOptions, 'state'> & {
+    /**
+     * An opaque value used by the client to maintain state between the request and callback.
+     * It's also recommended to prevent CSRF {@link https://tools.ietf.org/html/rfc6749#section-10.12}
+     */
+    state: string | (() => string | Promise<string>);
+};
+/**
+ * Minimal user information used by the simplified login widget flow.
+ */
+export type SimplifiedLoginData = {
+    /** Deprecated: User UUID, to be be used as `loginHint` for {@link Identity#login} */
+    identifier: string;
+    /** Human-readable user identifier */
+    display_text: string;
+    /** Client name */
+    client_name: string;
+    /** Provider id used by the simplified login widget when supplied by the backend. */
+    provider_id?: string;
+};
+/**
+ * Configuration options for {@link Identity#showSimplifiedLoginWidget}.
+ */
+export type SimplifiedLoginWidgetOptions = {
+    /** expected encoding of simplified login widget. Could be utf-8 (default), iso-8859-1 or iso-8859-15 */
+    encoding?: string;
+    /**
+     * expected locale of simplified login widget. Should be provided in a short format like 'nb',
+     * 'sv'. If not set, a value from the env variable is used.
+     */
+    locale?: 'nb' | 'sv' | 'fi' | 'da' | 'en';
+};
+export type SimplifiedLoginWidgetInitialParams = {
+    displayText: string;
+    env: string;
+    clientName: string;
+    clientId: string;
+    providerId?: string;
+    locale?: SimplifiedLoginWidgetOptions['locale'];
+    windowWidth: () => number;
+    windowOnResize: (handler: () => void) => void;
+};
+export type SimplifiedLoginWidgetHandler = () => void | Promise<void>;
+export type OpenSimplifiedLoginWidget = (initialParams: SimplifiedLoginWidgetInitialParams, loginHandler: SimplifiedLoginWidgetHandler, loginNotYouHandler: SimplifiedLoginWidgetHandler, initHandler: SimplifiedLoginWidgetHandler, cancelLoginHandler: SimplifiedLoginWidgetHandler) => unknown;
+export declare const hasOpenSimplifiedLoginWidget: (targetWindow: Window) => targetWindow is Window & {
+    openSimplifiedLoginWidget: OpenSimplifiedLoginWidget;
+};

package/dist/types/monetization-guards.d.ts

@@ -0,0 +1,2 @@
+import { HasAccessResult } from './monetization.js';
+export declare function parseHasAccessResult(value: unknown): HasAccessResult;

package/dist/types/monetization.d.ts

@@ -0,0 +1,21 @@
+import { AccountBaseConfig } from './common';
+import { SessionUserId } from './session';
+/**
+ * Result returned by the Session Service `/hasAccess` endpoint, describing whether the user
+ * is entitled to a requested set of products/features.
+ * @internal
+ */
+export interface HasAccessResult {
+    /** Whether the user is entitled to at least one of the requested products/features. */
+    entitled: boolean;
+    /** How long this result stays valid, in seconds, before the cache entry expires. */
+    ttl: number;
+    allowedFeatures: string[];
+    userId: SessionUserId;
+    uuid: string;
+    sig: string;
+}
+/**
+ * Options accepted by the {@link Monetization} constructor.
+ */
+export type MonetizationOptions = Pick<AccountBaseConfig, 'clientId' | 'env' | 'window'> & Partial<Pick<AccountBaseConfig, 'redirectUri' | 'sessionDomain'>>;

package/dist/types/session-guards.d.ts

@@ -0,0 +1,36 @@
+import { ConnectedSessionResponse, ConnectedSessionWithUserIdResponse, SessionFailureResponse, SessionResponse, SessionSuccessResponse, UnrecognizedSessionResponse } from './session.js';
+type SessionObjectResponse = SessionSuccessResponse | SessionFailureResponse | UnrecognizedSessionResponse;
+type RedirectSessionPayload = {
+    redirectURL: string;
+};
+export type NormalizedSessionPayload = SessionObjectResponse | RedirectSessionPayload;
+export declare function isSessionSuccessResponse(value: unknown): value is SessionSuccessResponse;
+export declare function isConnectedSessionResponse(value: unknown): value is ConnectedSessionResponse;
+export declare function isSessionFailureResponse(value: unknown): value is SessionFailureResponse;
+export declare function isRedirectSessionPayload(value: unknown): value is RedirectSessionPayload;
+export declare function isConnectedSessionWithUserIdResponse(value: SessionResponse): value is ConnectedSessionWithUserIdResponse;
+/**
+ * Converts an unknown Session Service `hasSession` payload into one of the shapes the SDK knows how
+ * to handle.
+ *
+ * This function is intentionally tolerant because `hasSession()` historically resolved unknown
+ * object payloads instead of rejecting them. The SDK relies on that behavior for backwards
+ * compatibility with clients that check the raw response themselves.
+ *
+ * The normal cases are:
+ * - regular success payloads with a boolean `result`;
+ * - failure payloads wrapped as `{ error, response? }`;
+ * - Safari/session-refresh redirect payloads shaped as `{ redirectURL }`.
+ *
+ * Any other object is preserved as an unrecognized response so callers can still receive it.
+ * Non-object values are normalized to `{}`, matching the old "empty response" fallback used by
+ * `hasSession()` and cached-session reads.
+ *
+ * This is used both for network responses parsed by `RESTClient` and for values restored from the
+ * session cache, so the rest of the Identity flow can switch on typed guards instead of repeatedly
+ * re-validating unknown data.
+ *
+ * @internal
+ */
+export declare function normalizeSessionResponse(value: unknown): NormalizedSessionPayload;
+export {};

package/dist/types/session.d.ts

@@ -0,0 +1,124 @@
+/**
+ * User identifier returned by Session Service responses.
+ *
+ * Session Service historically returned numeric ids, while some integrations and tests use
+ * string ids. SDK convenience methods normalize this where they promise a string.
+ */
+export type SessionUserId = number | string;
+/**
+ * Successful response returned from {@link Identity#hasSession}.
+ *
+ * `result` means the has-session call itself succeeded. `result: true` means the user is
+ * connected to the merchant; `result: false` means a session may exist, but the user is not
+ * connected to this client.
+ */
+export type SessionSuccessResponse = {
+    /** Response status code. Example: 200. */
+    code?: number;
+    /** Response type. Example: 'OK'. */
+    type?: string;
+    /** Human-readable response description. Example: 'OK'. */
+    description?: string;
+    /**
+     * Is the user connected to the merchant? This means the merchant id is in the list of
+     * merchants connected to this user.
+     */
+    result: boolean;
+    /** Connection status string. Deprecated; use `Identity.isConnected()`. Example: 'connected'. */
+    userStatus?: string;
+    /** Cookie base domain used as the `SP_ID` cookie domain fallback. Example: 'spid.no'. */
+    baseDomain?: string;
+    /** Legacy session id. Obsolete. Example: '58eca10fdbb9f6df72c3368f'. */
+    id?: string;
+    /** A numeric user id which is unique per realm (country). Example: 37162 */
+    userId?: SessionUserId;
+    /** Globally unique user id. Example: 'b3b23aa7-34f2-5d02-a10e-5a3455c6ab2c' */
+    uuid?: string;
+    /** Session token used for the `SP_ID` cookie. Example: 'eyJjbGllbnRfaWQ...'. */
+    sp_id?: string;
+    /** Session response TTL in seconds. Example: 300. */
+    expiresIn?: number;
+    /** Server time as a Unix timestamp in seconds. Example: 1506285759. */
+    serverTime?: number;
+    /**
+     * Example: 'NCdzXaz4ZRb7...' The sig parameter is a concatenation of an HMAC SHA-256
+     * signature string, a dot (.) and a base64url encoded JSON object (session).
+     * {@link http://techdocs.spid.no/sdks/js/response-signature-and-validation/}
+     */
+    sig?: string;
+    /** User display name. Example: 'batman'. */
+    displayName?: string;
+    /** User given name. Example: 'Bruce'. */
+    givenName?: string;
+    /** User family name. Example: 'Wayne'. */
+    familyName?: string;
+    /** User gender value. Example: 'male', 'female', 'undisclosed'. */
+    gender?: string;
+    /** User profile photo URL. Example: 'http://www.srv.com/some/picture.jpg' . */
+    photo?: string;
+    /** Whether tracking is enabled for this session. Example: true. */
+    tracking?: boolean;
+    /** Whether the client agreement is accepted. Example: true. */
+    clientAgreementAccepted?: boolean;
+    /** Whether the default agreement is accepted. Example: true. */
+    defaultAgreementAccepted?: boolean;
+    /** Pairwise user id for this client. Example: 'b2a23caa...'. */
+    pairId?: string;
+    /** User SDRN. Example: 'sdrn:spid.no:user:12345'. */
+    sdrn?: string;
+};
+/**
+ * Successful has-session response for a user connected to the merchant.
+ */
+export type ConnectedSessionResponse = SessionSuccessResponse & {
+    result: true;
+};
+/**
+ * Connected session response that also carries a usable user id.
+ */
+export type ConnectedSessionWithUserIdResponse = ConnectedSessionResponse & {
+    userId: SessionUserId;
+};
+/**
+ * Failure payload returned by Session Service.
+ *
+ * API and network failures usually reject with {@link SDKError}; this shape represents a failure
+ * payload when one is returned by Session Service and reaches the has-session flow.
+ */
+export type SessionFailureResponse = {
+    /** Failure payload returned by Session Service. Usually an object, but tests also pass strings. */
+    error: string | number | boolean | object;
+    response?: {
+        /** Response status code. Example: 404. */
+        code: number;
+        /** Response type. Example: 'NOT_FOUND'. */
+        type: string;
+        /** Human-readable response description. Example: 'No session found'. */
+        description: string;
+        /** Cookie base domain used as the `SP_ID` cookie domain fallback. Example: 'spid.no'. */
+        baseDomain?: string;
+        /** Time span in milliseconds. Example: 30 * 60 * 1000 (for 30 minutes) */
+        expiresIn?: number;
+        result?: boolean;
+        /** Server time in seconds since the Unix Epoch. Example: 1506287788 */
+        serverTime?: number;
+        [key: string]: string | number | boolean | object | null | undefined;
+    };
+};
+/**
+ * Object response that does not match one of the SDK-known has-session shapes.
+ *
+ * This intentionally includes `{}`. Historically `hasSession()` could resolve an empty object or
+ * other object payloads that callers inspected themselves, so the SDK preserves those responses.
+ */
+export type UnrecognizedSessionResponse = object;
+export type RedirectSessionResponse = string;
+export type SessionObjectResponse = SessionSuccessResponse | SessionFailureResponse | UnrecognizedSessionResponse;
+export type RedirectSessionPayload = {
+    redirectURL: string;
+};
+export type NormalizedSessionPayload = SessionObjectResponse | RedirectSessionPayload;
+/**
+ * Public response union returned from {@link Identity#hasSession}.
+ */
+export type SessionResponse = SessionSuccessResponse | SessionFailureResponse | UnrecognizedSessionResponse | RedirectSessionResponse;

package/dist/version.d.ts

@@ -1,2 +1,2 @@
-declare const version = "6.0.0-alpha.2";
+declare const version = "6.0.0-alpha.4";
 export default version;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@schibsted/account-sdk-browser",
-  "version": "6.0.0-alpha.2",
+  "version": "6.0.0-alpha.4",
   "description": "Schibsted account SDK for browsers",
   "main": "dist/index.js",
   "type": "module",
@@ -8,14 +8,6 @@
     ".": {
       "default": "./dist/index.js",
       "types": "./dist/index.d.ts"
-    },
-    "./identity": {
-      "default": "./dist/identity.js",
-      "types": "./dist/identity.d.ts"
-    },
-    "./monetization": {
-      "default": "./dist/monetization.js",
-      "types": "./dist/monetization.d.ts"
     }
   },
   "scripts": {

package/src/account-sdk.ts

@@ -0,0 +1,74 @@
+/* Copyright 2026 Schibsted Products & Technology AS. Licensed under the terms of the MIT license.
+ * See LICENSE.md in the project root.
+ */
+
+import { Account } from './account.js';
+import { resolveBrowserWindow } from './resolve-browser-window.js';
+import type { AccountConfig } from './types/account.js';
+
+const ACCOUNT_READY_EVENT = 'schAccount:ready';
+const GET_ACCOUNT_SDK_TIMEOUT_MS = 4000;
+
+let pendingAccountPromise: Promise<Account> | undefined;
+
+const createUnavailableError = (): Error =>
+    new Error('Schibsted Account SDK is not available in this browser context');
+
+const createTimeoutError = (): Error =>
+    new Error(`Schibsted Account SDK was not initialized within ${GET_ACCOUNT_SDK_TIMEOUT_MS} ms`);
+
+export function createAccountSdk(config: AccountConfig): Account {
+    return new Account(config);
+}
+
+export function getAccountSdk(): Promise<Account> {
+    const browserWindow = resolveBrowserWindow();
+
+    if (!browserWindow) {
+        const error = createUnavailableError();
+        console.error(error.message);
+        return Promise.reject(error);
+    }
+
+    if (browserWindow.schAccount) {
+        return Promise.resolve(browserWindow.schAccount);
+    }
+
+    if (pendingAccountPromise) {
+        return pendingAccountPromise;
+    }
+
+    pendingAccountPromise = new Promise<Account>((resolve, reject) => {
+        let timeoutId: number | undefined;
+
+        const cleanup = () => {
+            browserWindow.removeEventListener(ACCOUNT_READY_EVENT, resolveRegisteredAccount);
+            if (timeoutId !== undefined) {
+                browserWindow.clearTimeout(timeoutId);
+            }
+            pendingAccountPromise = undefined;
+        };
+
+        const resolveRegisteredAccount = () => {
+            const account = browserWindow.schAccount;
+            if (!account) {
+                return;
+            }
+
+            cleanup();
+            resolve(account);
+        };
+
+        browserWindow.addEventListener(ACCOUNT_READY_EVENT, resolveRegisteredAccount);
+        timeoutId = browserWindow.setTimeout(() => {
+            const error = createTimeoutError();
+            console.error(error.message);
+            cleanup();
+            reject(error);
+        }, GET_ACCOUNT_SDK_TIMEOUT_MS);
+
+        resolveRegisteredAccount();
+    });
+
+    return pendingAccountPromise;
+}

package/src/account.ts

@@ -0,0 +1,153 @@
+/* Copyright 2026 Schibsted Products & Technology AS. Licensed under the terms of the MIT license.
+ * See LICENSE.md in the project root.
+ */
+
+import { registerAndDispatchInGlobal } from './global-registry.js';
+import Identity from './identity.js';
+import Monetization from './monetization.js';
+import { resolveBrowserWindow } from './resolve-browser-window.js';
+import SDKError from './sdk-error.js';
+import type { AccountConfig, AccountEventHandler, AccountEventName } from './types/account.js';
+import type {
+    LoginOptions,
+    SimplifiedLoginData,
+    SimplifiedLoginWidgetLoginOptions,
+    SimplifiedLoginWidgetOptions,
+} from './types/login.js';
+import type { HasAccessResult } from './types/monetization.js';
+import type { ConnectedSessionResponse, SessionResponse, SessionUserId } from './types/session.js';
+
+/**
+ * Unified client-side interface for a configured Schibsted Account integration.
+ */
+export class Account {
+    #identity: Identity;
+    #monetization: Monetization;
+
+    constructor(config: AccountConfig) {
+        const browserWindow = resolveBrowserWindow(config.window);
+
+        if (!browserWindow) {
+            throw new SDKError('Schibsted Account SDK is not available in this browser context');
+        }
+
+        if (browserWindow.schAccount) {
+            throw new SDKError('Schibsted Account SDK has already been initialized');
+        }
+
+        const { log, callbackBeforeRedirect, varnish } = config;
+        const sharedConfig = {
+            clientId: config.clientId,
+            redirectUri: config.redirectUri,
+            sessionDomain: config.sessionDomain,
+            env: config.env,
+            window: browserWindow,
+        };
+
+        this.#identity = new Identity({
+            ...sharedConfig,
+            log,
+            callbackBeforeRedirect,
+        });
+
+        if (varnish) {
+            if (typeof varnish !== 'object' || Array.isArray(varnish)) {
+                throw new SDKError('Account varnish config must be an object');
+            }
+            this.#identity.enableVarnishCookie(varnish);
+        }
+
+        this.#monetization = new Monetization(sharedConfig);
+
+        registerAndDispatchInGlobal(browserWindow, 'schAccount', this);
+    }
+
+    hasSession(): Promise<SessionResponse> {
+        return this.#identity.hasSession();
+    }
+
+    isLoggedIn(): Promise<boolean> {
+        return this.#identity.isLoggedIn();
+    }
+
+    isConnected(): Promise<boolean> {
+        return this.#identity.isConnected();
+    }
+
+    getUser(): Promise<ConnectedSessionResponse> {
+        return this.#identity.getUser();
+    }
+
+    getUserId(): Promise<string> {
+        return this.#identity.getUserId();
+    }
+
+    getUserSDRN(): Promise<string> {
+        return this.#identity.getUserSDRN();
+    }
+
+    getUserContextData(): Promise<SimplifiedLoginData | null> {
+        return this.#identity.getUserContextData();
+    }
+
+    getSpId(): Promise<string | null> {
+        return this.#identity.getSpId();
+    }
+
+    login(options: LoginOptions): Window | null {
+        return this.#identity.login(options);
+    }
+
+    logout(redirectUri?: string): void {
+        this.#identity.logout(redirectUri);
+    }
+
+    loginUrl(options: LoginOptions): string {
+        return this.#identity.loginUrl(options);
+    }
+
+    accountUrl(redirectUri?: string): string {
+        return this.#identity.accountUrl(redirectUri);
+    }
+
+    showSimplifiedLoginWidget(
+        loginParams: SimplifiedLoginWidgetLoginOptions,
+        options?: SimplifiedLoginWidgetOptions,
+    ): Promise<boolean> {
+        return this.#identity.showSimplifiedLoginWidget(loginParams, options);
+    }
+
+    clearCachedUserSession(): void {
+        this.#identity.clearCachedUserSession();
+    }
+
+    hasAccess(productIds: string[], userId: SessionUserId): Promise<HasAccessResult | null> {
+        return this.#monetization.hasAccess(productIds, userId);
+    }
+
+    clearCachedAccessResult(productIds: string[], userId: SessionUserId): void {
+        this.#monetization.clearCachedAccessResult(productIds, userId);
+    }
+
+    on(event: AccountEventName, callback: AccountEventHandler, ctx?: unknown): this {
+        if (event === 'hasAccess') {
+            this.#monetization.on(event, callback, ctx);
+        } else {
+            this.#identity.on(event, callback, ctx);
+        }
+
+        return this;
+    }
+
+    off(event: AccountEventName, callback?: AccountEventHandler): this {
+        if (event === 'hasAccess') {
+            this.#monetization.off(event, callback);
+        } else {
+            this.#identity.off(event, callback);
+        }
+
+        return this;
+    }
+}
+
+export default Account;

package/src/cache.ts

@@ -2,7 +2,7 @@
  * See LICENSE.md in the project root.
  */
 
-import SDKError from './SDKError.js';
+import SDKError from './sdk-error.js';
 
 /**
  * Check whether we are able to use web storage

package/src/global-registry.ts

@@ -3,7 +3,7 @@ import './globals.js';
 /**
  * Names of the SDK instance properties that can be registered on the global {@link Window} object.
  */
-type Property = 'schIdentity' | 'schMonetization';
+type Property = 'schAccount' | 'schIdentity' | 'schMonetization';
 
 /**
  * Registers an SDK instance on the global {@link Window} object's given property and dispatches a ready event.

package/src/globals.ts

@@ -1,8 +1,10 @@
+import type { Account } from './account.js';
 import type { Identity } from './identity.js';
 import type { Monetization } from './monetization.js';
 
 declare global {
     interface Window {
+        schAccount?: Account;
         schIdentity?: Identity;
         schMonetization?: Monetization;
         SPiD?: { Talk?: { response?: (callbackName: string, data: unknown) => unknown } };

package/src/has-access-response.ts

@@ -0,0 +1,35 @@
+/* Copyright 2026 Schibsted Products & Technology AS. Licensed under the terms of the MIT license.
+ * See LICENSE.md in the project root.
+ */
+
+import SDKError from './sdk-error.js';
+import type { HasAccessResult } from './types/monetization.js';
+import { isObject, isStr } from './validate.js';
+
+export function parseHasAccessResult(value: unknown): HasAccessResult {
+    if (!isObject(value)) {
+        throw new SDKError('Invalid hasAccess response');
+    }
+
+    const { entitled, ttl, allowedFeatures, userId, uuid, sig } = value;
+
+    if (
+        typeof entitled !== 'boolean' ||
+        typeof ttl !== 'number' ||
+        !Array.isArray(allowedFeatures) ||
+        (typeof userId !== 'number' && typeof userId !== 'string') ||
+        !isStr(uuid) ||
+        !isStr(sig)
+    ) {
+        throw new SDKError('Invalid hasAccess response');
+    }
+
+    return {
+        entitled,
+        ttl,
+        allowedFeatures: allowedFeatures.filter(isStr),
+        userId,
+        uuid,
+        sig,
+    };
+}