@junobuild/core-standalone 1.2.1 → 2.0.0

package/dist/types/{constants → auth/constants}/auth.constants.d.ts

@@ -1,3 +1,4 @@
+export declare const DELEGATION_IDENTITY_EXPIRATION_IN_MILLISECONDS: number;
 export declare const DELEGATION_IDENTITY_EXPIRATION: bigint;
 export declare const ALLOW_PIN_AUTHENTICATION = false;
 export declare const II_POPUP: {

package/dist/types/auth/helpers/progress.helpers.d.ts

@@ -0,0 +1,6 @@
+import type { SignProgressFn } from '../types/progress';
+export declare const execute: <T, Step>({ fn, step, onProgress }: {
+    fn: () => Promise<T>;
+    step: Step;
+    onProgress?: SignProgressFn<Step>;
+}) => Promise<T>;

package/dist/types/auth/helpers/window.helpers.d.ts

@@ -0,0 +1,3 @@
+export declare const executeWithWindowGuard: <T>({ fn }: {
+    fn: () => Promise<T>;
+}) => Promise<T>;

package/dist/types/auth/providers/_auth-client.providers.d.ts

@@ -0,0 +1,74 @@
+import { type AuthClient } from '@dfinity/auth-client';
+import { type AuthClientSignInOptions } from '../types/auth-client';
+import type { Provider } from '../types/provider';
+/**
+ * Common traits for all authentication providers
+ * @interface AuthProvider
+ */
+export interface AuthProvider {
+    /**
+     * The unique identifier of the provider.
+     */
+    readonly id: Provider;
+}
+/**
+ * Options for signing in with an authentication provider.
+ * @interface AuthProviderSignInOptions
+ */
+export interface AuthProviderSignInOptions {
+    /**
+     * The URL of the identity provider - commonly Internet Identity.
+     */
+    identityProvider: string;
+    /**
+     * Optional features for the window opener.
+     */
+    windowOpenerFeatures?: string;
+}
+/**
+ * Abstract base class for all authentication providers that integrate with the `@dfinity/auth-client`.
+ *
+ * @abstract
+ * @class AuthClientProvider
+ * @implements {AuthProvider}
+ */
+export declare abstract class AuthClientProvider implements AuthProvider {
+    #private;
+    /**
+     * The unique identifier of the provider.
+     *
+     * @abstract
+     * @type {Provider}
+     */
+    abstract get id(): Provider;
+    /**
+     * Returns the sign-in options for the provider.
+     *
+     * Note: set as public instead of protected for testing purposes.
+     *
+     * @abstract
+     * @param {Pick<SignInOptions, 'windowed'>} options - Options controlling window behavior.
+     * @returns {AuthProviderSignInOptions} Provider-specific sign-in options.
+     */
+    abstract signInOptions(options: Pick<AuthClientSignInOptions, 'windowed'>): AuthProviderSignInOptions;
+    /**
+     * Signs in a user with the given authentication provider.
+     *
+     * @param {Object} params - The sign-in parameters.
+     * @param {AuthClientSignInOptions} [params.options] - Optional configuration for the login request.
+     * @param {AuthClient | undefined | null} params.authClient - The AuthClient instance in its current state.
+     * @param {initAuth} params.initAuth - The function to load or initialize the user. Provided as a callback to avoid recursive import.
+     *
+     * @returns {Promise<void>} Resolves if the sign-in is successful. Rejects with:
+     * - {@link SignInInitError} if no AuthClient is available.
+     * - {@link SignInUserInterruptError} if the user cancels the login.
+     * - {@link SignInError} for other errors during sign-in.
+     */
+    signIn({ options, authClient, initAuth }: {
+        options?: AuthClientSignInOptions;
+        authClient: AuthClient | undefined | null;
+        initAuth: (params: {
+            provider: Provider;
+        }) => Promise<void>;
+    }): Promise<void>;
+}

package/dist/types/auth/providers/internet-identity.providers.d.ts

@@ -0,0 +1,28 @@
+import type { AuthClientSignInOptions } from '../types/auth-client';
+import type { InternetIdentityConfig } from '../types/internet-identity';
+import type { Provider } from '../types/provider';
+import { AuthClientProvider, type AuthProviderSignInOptions } from './_auth-client.providers';
+/**
+ * Internet Identity authentication provider.
+ * @class InternetIdentityProvider
+ * @implements {AuthProvider}
+ */
+export declare class InternetIdentityProvider extends AuthClientProvider {
+    #private;
+    /**
+     * Creates an instance of InternetIdentityProvider.
+     * @param {InternetIdentityConfig} config - The configuration for Internet Identity.
+     */
+    constructor({ domain }: InternetIdentityConfig);
+    /**
+     * Gets the identifier of the provider.
+     * @returns {Provider} The identifier of the provider - `internet_identity`.
+     */
+    get id(): Provider;
+    /**
+     * Gets the sign-in options for Internet Identity.
+     * @param {Pick<SignInOptions, 'windowed'>} options - The sign-in options.
+     * @returns {AuthProviderSignInOptions} The sign-in options for Internet Identity.
+     */
+    signInOptions({ windowed }: Pick<AuthClientSignInOptions, 'windowed'>): AuthProviderSignInOptions;
+}

package/dist/types/auth/providers/nfid.providers.d.ts

@@ -0,0 +1,28 @@
+import type { AuthClientSignInOptions } from '../types/auth-client';
+import type { NFIDConfig } from '../types/nfid';
+import type { Provider } from '../types/provider';
+import { AuthClientProvider, type AuthProviderSignInOptions } from './_auth-client.providers';
+/**
+ * NFID authentication provider.
+ * @class NFIDProvider
+ * @implements {AuthProvider}
+ */
+export declare class NFIDProvider extends AuthClientProvider {
+    #private;
+    /**
+     * Creates an instance of NFIDProvider.
+     * @param {NFIDConfig} config - The configuration for NFID.
+     */
+    constructor({ appName, logoUrl }: NFIDConfig);
+    /**
+     * Gets the identifier of the provider.
+     * @returns {Provider} The identifier of the provider- nfid.
+     */
+    get id(): Provider;
+    /**
+     * Gets the sign-in options for NFID.
+     * @param {Pick<SignInOptions, 'windowed'>} options - The sign-in options.
+     * @returns {AuthProviderSignInOptions} The sign-in options to effectively sign-in with NFID.
+     */
+    signInOptions({ windowed }: Pick<AuthClientSignInOptions, 'windowed'>): AuthProviderSignInOptions;
+}

package/dist/types/auth/providers/webauthn.providers.d.ts

@@ -0,0 +1,40 @@
+import type { Provider } from '../types/provider';
+import type { User } from '../types/user';
+import { type WebAuthnSignInOptions, type WebAuthnSignUpOptions } from '../types/webauthn';
+import type { AuthProvider } from './_auth-client.providers';
+export declare class WebAuthnProvider implements AuthProvider {
+    #private;
+    /**
+     * Gets the identifier of the provider.
+     * @returns {Provider} The identifier of the provider is webauthn.
+     */
+    get id(): Provider;
+    /**
+     * Signs up a user by creating a new passkey.
+     *
+     * @param {Object} params - The sign-up parameters.
+     * @param {WebAuthnSignUpOptions} [params.options] - Optional configuration for the login request.
+     * @param {loadAuth} params.loadAuthWithUser - The function to load the authentication with the user. Provided as a callback to avoid recursive import.
+     *
+     * @returns {Promise<void>} Resolves if the sign-up is successful.
+     */
+    signUp({ options: { onProgress, maxTimeToLiveInMilliseconds, passkey: passkeyOptions }, loadAuthWithUser }: {
+        options?: WebAuthnSignUpOptions;
+        loadAuthWithUser: (params: {
+            user: User;
+        }) => Promise<void>;
+    }): Promise<void>;
+    /**
+     * Signs in a user with an existing passkey.
+     *
+     * @param {Object} params - The sign-in parameters.
+     * @param {WebAuthnSignInOptions} [params.options] - Optional configuration for the login request.
+     * @param {loadAuth} params.loadAuth - The function to load the user. Provided as a callback to avoid recursive import.
+     *
+     * @returns {Promise<void>} Resolves if the sign-in is successful.
+     */
+    signIn({ options: { onProgress, maxTimeToLiveInMilliseconds }, loadAuth }: {
+        options?: WebAuthnSignInOptions;
+        loadAuth: () => Promise<void>;
+    }): Promise<void>;
+}

package/dist/types/auth/services/_user.services.d.ts

@@ -0,0 +1,11 @@
+import type { Provider } from '../types/provider';
+import type { User } from '../types/user';
+type UserId = string;
+export declare const initUser: ({ provider }: {
+    provider: Provider;
+}) => Promise<User>;
+export declare const loadUser: () => Promise<{
+    userId: UserId;
+    user: User | undefined;
+}>;
+export {};

package/dist/types/auth/services/auth-timout.services.d.ts

@@ -0,0 +1,3 @@
+import type { EnvironmentWorker } from '../../core/types/env';
+import type { Unsubscribe } from '../../core/types/subscription';
+export declare const initAuthTimeoutWorker: (auth: EnvironmentWorker) => Unsubscribe;

package/dist/types/{services → auth/services}/auth.services.d.ts

@@ -1,19 +1,38 @@
 import type { Identity } from '@dfinity/agent';
-import type { Provider, SignInOptions } from '../types/auth';
-export declare const initAuth: (provider?: Provider) => Promise<void>;
+import type { SignInOptions, SignOutOptions, SignUpOptions } from '../types/auth';
+import type { Provider } from '../types/provider';
+/**
+ * Initialize the authClient and load the existing user.
+ * Executed when the library is initialized through initSatellite.
+ */
+export declare const loadAuth: () => Promise<void>;
+/**
+ * Initialize the authClient, load or create a new user.
+ * Executed on sign-in.
+ */
+export declare const createAuth: ({ provider }: {
+    provider: Provider;
+}) => Promise<void>;
 /**
  * Signs in a user with the specified options.
  *
- * @param {SignInOptions} [options] - The options for signing in.
+ * @default Signs in by default with Internet Identity
+ * @param {SignInOptions} [options] - The options for signing in including the provider to use for the process.
  * @returns {Promise<void>} A promise that resolves when the sign-in process is complete and the authenticated user is initialized.
- * @throws {SignInError} If the sign-in process fails or no authentication client is available.
  */
-export declare const signIn: (options?: SignInOptions) => Promise<void>;
+export declare const signIn: (options: SignInOptions) => Promise<void>;
+/**
+ * Signs up to create a new user with the specified options.
+ *
+ * @param {SignUpOptions} [options] - The options for signing up including the provider to use for the process.
+ * @returns {Promise<void>} A promise that resolves when the sign-up process is complete and the user is authenticated.
+ */
+export declare const signUp: (options: SignUpOptions) => Promise<void>;
 /**
  * Signs out the current user.
  * @returns {Promise<void>} A promise that resolves when the sign-out process is complete.
  */
-export declare const signOut: () => Promise<void>;
+export declare const signOut: (options?: SignOutOptions) => Promise<void>;
 /**
  * ℹ️ Exposed for testing purpose only. Should not be leaked to consumer or used by the library.
  */

package/dist/types/auth/services/user-webauthn.services.d.ts

@@ -0,0 +1,8 @@
+import type { Identity } from '@dfinity/agent';
+import type { WebAuthnIdentity, WebAuthnNewCredential } from '@junobuild/ic-client/webauthn';
+import type { Environment } from '../../core/types/env';
+import type { User } from '../types/user';
+export declare const createWebAuthnUser: ({ delegationIdentity, passkeyIdentity, satelliteId }: {
+    delegationIdentity: Identity;
+    passkeyIdentity: WebAuthnIdentity<WebAuthnNewCredential>;
+} & Pick<Environment, "satelliteId">) => Promise<User>;

package/dist/types/{stores → auth/stores}/auth.store.d.ts

@@ -1,6 +1,6 @@
-import type { User } from '../types/auth';
-import type { Unsubscribe } from '../types/subscription';
-import { Store } from './_store';
+import { Store } from '../../core/stores/_store';
+import type { Unsubscribe } from '../../core/types/subscription';
+import type { User } from '../types/user';
 export declare class AuthStore extends Store<User | null> {
     private static instance;
     private authUser;

package/dist/types/auth/types/auth-client.d.ts

@@ -0,0 +1,43 @@
+import type { SignProgressFn } from './progress';
+/**
+ * Enum representing the different steps of the sign-in flow with Internet Identity or NFID.
+ */
+export declare enum AuthClientSignInProgressStep {
+    /** User is authenticating with the identity provider (II / NFID). */
+    AuthorizingWithProvider = 0,
+    /** App is creating a new user or retrieving an existing one after authorization. */
+    CreatingOrRetrievingUser = 1
+}
+/**
+ * Interface representing sign-in options when using an AuthClient based provider.
+ * @interface AuthClientSignInOptions
+ */
+export interface AuthClientSignInOptions {
+    /**
+     * Maximum time to live for the session in nanoseconds. Cannot be extended.
+     * @type {bigint}
+     */
+    maxTimeToLiveInNanoseconds?: bigint;
+    /**
+     * Origin for derivation. Useful when sign-in using the same domain - e.g. sign-in on www.hello.com for hello.com.
+     * @type {(string | URL)}
+     */
+    derivationOrigin?: string | URL;
+    /**
+     * Whether to open the sign-in window.
+     * @default true
+     * @type {boolean}
+     */
+    windowed?: boolean;
+    /**
+     * Whether to allow the infamous PIN authentication.
+     * @default false
+     * @type {boolean}
+     */
+    allowPin?: boolean;
+    /**
+     * Optional callback to receive progress updates about the sign-in flow.
+     * Useful for showing UI feedback such as loading indicators or status messages.
+     */
+    onProgress?: SignProgressFn<AuthClientSignInProgressStep>;
+}

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

@@ -0,0 +1,63 @@
+import type { InternetIdentitySignInOptions } from './internet-identity';
+import type { NFIDSignInOptions } from './nfid';
+import type { WebAuthnSignInOptions, WebAuthnSignUpOptions } from './webauthn';
+/**
+ * Options for the context of the sign-in flow.
+ */
+export interface SignInContext {
+    /**
+     * Opt out of the beforeunload window guard for the sign-in which prevents
+     * the user to closing the current window/tab while the sign-in flow is in progress.
+     *
+     * Disabling it is discouraged.
+     *
+     * @default true
+     */
+    windowGuard?: boolean;
+}
+/**
+ * The options for sign-in.
+ *
+ * - `internetIdentity`: Internet Identity options
+ * - `nfid`: NFID options
+ * - `webauthn`: WebAuthn/Passkey options
+ */
+export type SignInOptions = {
+    internet_identity: {
+        options?: InternetIdentitySignInOptions;
+        context?: SignInContext;
+    };
+} | {
+    nfid: {
+        options: NFIDSignInOptions;
+        context?: SignInContext;
+    };
+} | {
+    webauthn: {
+        options?: WebAuthnSignInOptions;
+        context?: SignInContext;
+    };
+};
+/**
+ * The options for sign-up.
+ *
+ * - `webauthn`: WebAuthn/Passkey options
+ */
+export interface SignUpOptions {
+    webauthn: {
+        options?: WebAuthnSignUpOptions;
+        context?: SignInContext;
+    };
+}
+/**
+ * The options for sign-out.
+ */
+export interface SignOutOptions {
+    /**
+     * Opt out of reloading the window after state and authentication
+     * have been successfully cleared.
+     *
+     * @default true
+     */
+    windowReload?: boolean;
+}

package/dist/types/{types → auth/types}/errors.d.ts

@@ -4,6 +4,12 @@ export declare class SignInInitError extends Error {
 }
 export declare class SignInUserInterruptError extends Error {
 }
+export declare class SignInProviderNotSupportedError extends Error {
+}
+export declare class WebAuthnSignInRetrievePublicKeyError extends Error {
+}
+export declare class SignUpProviderNotSupportedError extends Error {
+}
 export declare class InitError extends Error {
 }
 export declare class ListError extends Error {

package/dist/types/auth/types/internet-identity.d.ts

@@ -0,0 +1,23 @@
+import type { AuthClientSignInOptions } from './auth-client';
+/**
+ * Type representing the available Internet Identity domains.
+ * @typedef {('internetcomputer.org' | 'ic0.app')} InternetIdentityDomain
+ */
+export type InternetIdentityDomain = 'internetcomputer.org' | 'ic0.app';
+/**
+ * Interface representing the specific configuration for Internet Identity.
+ * @interface InternetIdentityConfig
+ */
+export interface InternetIdentityConfig {
+    /**
+     * The domain for Internet Identity.
+     * @default internetcomputer.org
+     * @type {InternetIdentityDomain}
+     */
+    domain?: InternetIdentityDomain;
+}
+/**
+ * Interface representing sign-in options when using the Internet Identity provider.
+ * @interface InternetIdentitySignInOptions
+ */
+export type InternetIdentitySignInOptions = InternetIdentityConfig & AuthClientSignInOptions;

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

@@ -0,0 +1,22 @@
+import type { AuthClientSignInOptions } from './auth-client';
+/**
+ * Interface representing the specific configuration for NFID.
+ * @interface NFIDConfig
+ */
+export interface NFIDConfig {
+    /**
+     * The name of the application.
+     * @type {string}
+     */
+    appName: string;
+    /**
+     * The URL of the application's logo.
+     * @type {string}
+     */
+    logoUrl: string;
+}
+/**
+ * Interface representing sign-in options when using the NFID provider.
+ * @interface NFIDSignInOptions
+ */
+export type NFIDSignInOptions = NFIDConfig & AuthClientSignInOptions;

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

@@ -0,0 +1,20 @@
+/**
+ * Represents the state of a sign-in or sign-up progress step.
+ * - `in_progress`: The step is currently being executed.
+ * - `success`: The step completed successfully.
+ * - `error`: The step failed.
+ */
+export type SignProgressState = 'in_progress' | 'success' | 'error';
+/**
+ * Progress event emitted during a sign-in or sign-up flow.
+ */
+export interface SignProgress<Step> {
+    /** Current step in the flow */
+    step: Step;
+    /** State of the current step */
+    state: SignProgressState;
+}
+/**
+ * Callback type for receiving progress updates during the sign-in or sign-up process.
+ */
+export type SignProgressFn<Step> = (progress: SignProgress<Step>) => void;

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

@@ -0,0 +1,32 @@
+/**
+ * Type representing the available authentication providers.
+ * @typedef {('internet_identity' | 'nfid' | 'webauthn')} Provider
+ */
+export type Provider = 'internet_identity' | 'nfid' | 'webauthn';
+/**
+ * Metadata for WebAuthn authentication.
+ * @interface ProviderDataWebAuthn
+ */
+export interface ProviderDataWebAuthn {
+    /**
+     * Authenticator Attestation GUID (AAGUID).
+     *
+     * If available, a 16-byte identifier that uniquely represents the model of the authenticator,
+     * unlesss the provider explicitly set it to zeros.
+     */
+    aaguid: Uint8Array | number[];
+}
+/**
+ * Container for provider-specific metadata.
+ *
+ * Currently only `webauthn` is supported, but this type
+ * can be extended in the future.
+ *
+ * @interface ProviderData
+ */
+export interface ProviderData {
+    /**
+     * Metadata specific to WebAuthn (passkey) authentication.
+     */
+    webauthn: ProviderDataWebAuthn;
+}

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

@@ -0,0 +1,23 @@
+import type { Doc } from '../../datastore/types/doc';
+import type { Provider, ProviderData } from './provider';
+/**
+ * Interface representing user data.
+ * @interface UserData
+ */
+export interface UserData {
+    /**
+     * The potential provider used to sign-in. There is no absolute guarantee that the information can be set by the browser during the sign-in flow, therefore it is optional.
+     * @type {Provider}
+     */
+    provider?: Provider;
+    /**
+     * The optional provider-specific metadata. This is only set if the frontend was able to supply it during the sign-in flow.
+     * @type {ProviderData}
+     */
+    providerData?: ProviderData;
+}
+/**
+ * Type representing a user document.
+ * @typedef {Doc<UserData>} User
+ */
+export type User = Doc<UserData>;

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

@@ -0,0 +1,74 @@
+import type { CreatePasskeyOptions } from '@junobuild/ic-client/webauthn';
+import type { SignProgressFn } from './progress';
+/**
+ * Enum representing the different steps of the WebAuthn sign-in flow.
+ */
+export declare enum WebAuthnSignInProgressStep {
+    /** Requesting a passkey (credential) from the user */
+    RequestingUserCredential = 0,
+    /** Validating and finalizing the credential provided by the user */
+    FinalizingCredential = 1,
+    /** Signing the authentication challenge with the user's credential */
+    Signing = 2,
+    /** Completing the session setup after signing */
+    FinalizingSession = 3,
+    /** Retrieving the authenticated user information */
+    RetrievingUser = 4
+}
+/**
+ * Enum representing the different steps of the WebAuthn sign-up (registration) flow.
+ */
+export declare enum WebAuthnSignUpProgressStep {
+    /** Creating a new passkey (credential) for the user */
+    CreatingUserCredential = 0,
+    /** Validating the created credential */
+    ValidatingUserCredential = 1,
+    /** Finalizing the credential for use */
+    FinalizingCredential = 2,
+    /** Signing the registration challenge. Requires the user to interact again with the authenticator for confirmation. */
+    Signing = 3,
+    /** Completing the session setup after signing */
+    FinalizingSession = 4,
+    /** Registering the new user in the system */
+    RegisteringUser = 5
+}
+/**
+ * Interface representing common sign-in and sing-up options when using a WebAuthn (passkey) based provider.
+ * @interface WebAuthnSignOptions
+ */
+export interface WebAuthnSignOptions {
+    /**
+     * Maximum time to live for the session in milliseconds. Cannot be extended.
+     * @type {number}
+     */
+    maxTimeToLiveInMilliseconds?: number;
+}
+/**
+ * Interface representing sign-in options when using a WebAuthn (passkey) based provider.
+ * @interface WebAuthnSignInOptions
+ */
+export interface WebAuthnSignInOptions extends WebAuthnSignOptions {
+    /**
+     * Optional callback to receive progress updates about the sign-in flow.
+     * Useful for showing UI feedback such as loading indicators or status messages.
+     */
+    onProgress?: SignProgressFn<WebAuthnSignInProgressStep>;
+}
+/**
+ * Interface representing sign-up options when using a WebAuthn (passkey) based provider.
+ * @interface WebAuthnSignUpSessionOptions
+ */
+export interface WebAuthnSignUpOptions extends WebAuthnSignOptions {
+    /**
+     * Optional callback to receive progress updates about the sign-up flow.
+     * Useful for showing UI feedback such as loading indicators or status messages.
+     */
+    onProgress?: SignProgressFn<WebAuthnSignUpProgressStep>;
+    /**
+     * Options for creating the passkey credential.
+     *
+     * For example, you can provide a user-friendly display name so the passkey
+     * is easier to recognize later.
+     */
+    passkey?: CreatePasskeyOptions;
+}

package/dist/types/{utils → auth/utils}/auth.utils.d.ts

@@ -1,2 +1,3 @@
 import { AuthClient } from '@dfinity/auth-client';
 export declare const createAuthClient: () => Promise<AuthClient>;
+export declare const resetAuthClient: () => Promise<AuthClient>;

package/dist/types/{api → datastore/api}/doc.api.d.ts

@@ -1,6 +1,6 @@
-import type { ActorReadParams, ActorUpdateParams } from '../types/actor';
+import type { ActorReadParams, ActorUpdateParams } from '../../core/types/actor';
+import type { ListParams, ListResults } from '../../core/types/list';
 import type { Doc } from '../types/doc';
-import type { ListParams, ListResults } from '../types/list';
 export declare const getDoc: <D>({ collection, key, ...rest }: {
     collection: string;
 } & ActorReadParams & Pick<Doc<D>, "key">) => Promise<Doc<D> | undefined>;

package/dist/types/{services → datastore/services}/doc.services.d.ts

@@ -1,7 +1,7 @@
-import type { ReadOptions } from '../types/call-options';
+import type { ReadOptions } from '../../core/types/call-options';
+import type { ListParams, ListResults } from '../../core/types/list';
+import type { SatelliteOptions } from '../../core/types/satellite';
 import type { Doc } from '../types/doc';
-import type { ListParams, ListResults } from '../types/list';
-import type { SatelliteOptions } from '../types/satellite';
 /**
  * Retrieves a single document from a collection.
  *

package/dist/types/{types → datastore/types}/doc.d.ts

@@ -1,4 +1,4 @@
-import type { ExcludeDate } from './utility';
+import type { ExcludeDate } from '../../core/types/utility';
 /**
  * Represents a document stored in a collection.
  * @template D - The type of data contained in the document.

package/dist/types/{services → functions/services}/functions.services.d.ts

@@ -1,7 +1,7 @@
 import type { ActorSubclass } from '@dfinity/agent';
 import type { ActorMethod } from '@dfinity/agent/lib/esm/actor';
 import type { IDL } from '@dfinity/candid';
-import type { SatelliteOptions } from '../types/satellite';
+import type { SatelliteOptions } from '../../core/types/satellite';
 /**
  * Returns an extended satellite actor instance using the provided IDL factory and satellite options.
  *