@go-mondo/identity-sdk 0.0.2-beta.86 → 0.0.2-beta.87

package/dist/cjs/authentication/strategies/resources.js

@@ -41,18 +41,18 @@ class StrategyResources {
 }
 exports.StrategyResources = StrategyResources;
 async function listStrategies(instance, pagination) {
-    const url = (0, utils_js_1.addPaginationToURL)(new URL(StrategyResources.buildPath(), instance.config.host), pagination);
+    const url = (0, utils_js_1.addPaginationToURL)(new URL(StrategyResources.buildPath(), instance.baseUrl), pagination);
     return (0, collection_js_1.PaginationCollectionSchema)(schema_js_1.StrategySchema).parse(await (0, operations_js_1.getItemWithAuthorization)(url, instance.authorize));
 }
 async function getStrategy(instance, id) {
-    return schema_js_1.StrategySchema.parse(await (0, operations_js_1.getItemWithAuthorization)(new URL(StrategyResources.buildItemPath(id), instance.config.host), instance.authorize));
+    return schema_js_1.StrategySchema.parse(await (0, operations_js_1.getItemWithAuthorization)(new URL(StrategyResources.buildItemPath(id), instance.baseUrl), instance.authorize));
 }
 async function insertStrategy(instance, item) {
-    return schema_js_1.StrategySchema.parse(await (0, operations_js_1.postItemWithAuthorization)(new URL(StrategyResources.buildPath(), instance.config.host), instance.authorize, schema_js_1.InsertStrategyPayloadSchema.parse(item)));
+    return schema_js_1.StrategySchema.parse(await (0, operations_js_1.postItemWithAuthorization)(new URL(StrategyResources.buildPath(), instance.baseUrl), instance.authorize, schema_js_1.InsertStrategyPayloadSchema.parse(item)));
 }
 async function updateStrategy(instance, id, item) {
-    return schema_js_1.StrategySchema.parse(await (0, operations_js_1.patchItemWithAuthorization)(new URL(StrategyResources.buildItemPath(id), instance.config.host), instance.authorize, schema_js_1.UpdateStrategyPayloadSchema.parse(item)));
+    return schema_js_1.StrategySchema.parse(await (0, operations_js_1.patchItemWithAuthorization)(new URL(StrategyResources.buildItemPath(id), instance.baseUrl), instance.authorize, schema_js_1.UpdateStrategyPayloadSchema.parse(item)));
 }
 async function deleteStrategy(instance, id) {
-    return schema_js_1.StrategySchema.parse(await (0, operations_js_1.deleteItemWithAuthorization)(new URL(StrategyResources.buildItemPath(id), instance.config.host), instance.authorize));
+    return schema_js_1.StrategySchema.parse(await (0, operations_js_1.deleteItemWithAuthorization)(new URL(StrategyResources.buildItemPath(id), instance.baseUrl), instance.authorize));
 }

package/dist/cjs/authorization/permissions/resources.d.ts

@@ -1,10 +1,10 @@
-import type { MondoIdentity } from '../../common/resources/init.js';
+import type { MondoInstance } from '../../common/resources/init.js';
 import { type PaginationCollection } from '../../common/schema/collection.js';
 import type { Pagination } from '../../common/schema/pagination.js';
 import { type InsertPermissionInput, type Permission, type UpdatePermissionInput } from './schema.js';
 export declare class PermissionResources {
     private readonly instance;
-    constructor(instance: MondoIdentity);
+    constructor(instance: MondoInstance);
     static buildPath(id?: string): string;
     listItems(pagination?: Pagination): Promise<PaginationCollection<Permission>>;
     getItem(id: string): Promise<Permission>;
@@ -12,9 +12,9 @@ export declare class PermissionResources {
     updateItem(id: string, item: UpdatePermissionInput): Promise<Permission>;
     deleteItem(id: string): Promise<Permission>;
 }
-export declare function listPermissions(instance: MondoIdentity, pagination?: Pagination): Promise<PaginationCollection<Permission>>;
-export declare function getPermission(instance: MondoIdentity, id: string): Promise<Permission>;
-export declare function insertPermission(instance: MondoIdentity, item: InsertPermissionInput): Promise<Permission>;
-export declare function updatePermission(instance: MondoIdentity, id: string, item: UpdatePermissionInput): Promise<Permission>;
-export declare function deletePermission(instance: MondoIdentity, id: string): Promise<Permission>;
+export declare function listPermissions(instance: MondoInstance, pagination?: Pagination): Promise<PaginationCollection<Permission>>;
+export declare function getPermission(instance: MondoInstance, id: string): Promise<Permission>;
+export declare function insertPermission(instance: MondoInstance, item: InsertPermissionInput): Promise<Permission>;
+export declare function updatePermission(instance: MondoInstance, id: string, item: UpdatePermissionInput): Promise<Permission>;
+export declare function deletePermission(instance: MondoInstance, id: string): Promise<Permission>;
 //# sourceMappingURL=resources.d.ts.map

package/dist/cjs/authorization/permissions/resources.js

@@ -40,18 +40,18 @@ class PermissionResources {
 }
 exports.PermissionResources = PermissionResources;
 async function listPermissions(instance, pagination) {
-    const url = (0, utils_js_1.addPaginationToURL)(new URL(PermissionResources.buildPath(), instance.config.host), pagination);
+    const url = (0, utils_js_1.addPaginationToURL)(new URL(PermissionResources.buildPath(), instance.baseUrl), pagination);
     return (0, collection_js_1.PaginationCollectionSchema)(schema_js_1.PermissionSchema).parse(await (0, operations_js_1.getItemWithAuthorization)(url, instance.authorize));
 }
 async function getPermission(instance, id) {
-    return schema_js_1.PermissionSchema.parse(await (0, operations_js_1.getItemWithAuthorization)(new URL(PermissionResources.buildPath(id), instance.config.host), instance.authorize));
+    return schema_js_1.PermissionSchema.parse(await (0, operations_js_1.getItemWithAuthorization)(new URL(PermissionResources.buildPath(id), instance.baseUrl), instance.authorize));
 }
 async function insertPermission(instance, item) {
-    return schema_js_1.PermissionSchema.parse(await (0, operations_js_1.postItemWithAuthorization)(new URL(PermissionResources.buildPath(), instance.config.host), instance.authorize, schema_js_1.InsertPermissionPayloadSchema.parse(item)));
+    return schema_js_1.PermissionSchema.parse(await (0, operations_js_1.postItemWithAuthorization)(new URL(PermissionResources.buildPath(), instance.baseUrl), instance.authorize, schema_js_1.InsertPermissionPayloadSchema.parse(item)));
 }
 async function updatePermission(instance, id, item) {
-    return schema_js_1.PermissionSchema.parse(await (0, operations_js_1.patchItemWithAuthorization)(new URL(PermissionResources.buildPath(id), instance.config.host), instance.authorize, schema_js_1.UpdatePermissionPayloadSchema.parse(item)));
+    return schema_js_1.PermissionSchema.parse(await (0, operations_js_1.patchItemWithAuthorization)(new URL(PermissionResources.buildPath(id), instance.baseUrl), instance.authorize, schema_js_1.UpdatePermissionPayloadSchema.parse(item)));
 }
 async function deletePermission(instance, id) {
-    return schema_js_1.PermissionSchema.parse(await (0, operations_js_1.deleteItemWithAuthorization)(new URL(PermissionResources.buildPath(id), instance.config.host), instance.authorize));
+    return schema_js_1.PermissionSchema.parse(await (0, operations_js_1.deleteItemWithAuthorization)(new URL(PermissionResources.buildPath(id), instance.baseUrl), instance.authorize));
 }

package/dist/cjs/authorization/roles/resources.d.ts

@@ -1,10 +1,10 @@
-import type { MondoIdentity } from '../../common/resources/init.js';
+import type { MondoInstance } from '../../common/resources/init.js';
 import { type PaginationCollection } from '../../common/schema/collection.js';
 import type { Pagination } from '../../common/schema/pagination.js';
 import { type InsertRoleInput, type Role, type UpdateRoleInput } from './schema.js';
 export declare class RoleResources {
     private readonly instance;
-    constructor(instance: MondoIdentity);
+    constructor(instance: MondoInstance);
     static buildPath(id?: string): string;
     listItems(pagination?: Pagination): Promise<PaginationCollection<Role>>;
     getItem(id: string): Promise<Role>;
@@ -12,9 +12,9 @@ export declare class RoleResources {
     updateItem(id: string, item: UpdateRoleInput): Promise<Role>;
     deleteItem(id: string): Promise<Role>;
 }
-export declare function listRoles(instance: MondoIdentity, pagination?: Pagination): Promise<PaginationCollection<Role>>;
-export declare function getRole(instance: MondoIdentity, id: string): Promise<Role>;
-export declare function insertRole(instance: MondoIdentity, item: InsertRoleInput): Promise<Role>;
-export declare function updateRole(instance: MondoIdentity, id: string, item: UpdateRoleInput): Promise<Role>;
-export declare function deleteRole(instance: MondoIdentity, id: string): Promise<Role>;
+export declare function listRoles(instance: MondoInstance, pagination?: Pagination): Promise<PaginationCollection<Role>>;
+export declare function getRole(instance: MondoInstance, id: string): Promise<Role>;
+export declare function insertRole(instance: MondoInstance, item: InsertRoleInput): Promise<Role>;
+export declare function updateRole(instance: MondoInstance, id: string, item: UpdateRoleInput): Promise<Role>;
+export declare function deleteRole(instance: MondoInstance, id: string): Promise<Role>;
 //# sourceMappingURL=resources.d.ts.map

package/dist/cjs/authorization/roles/resources.js

@@ -40,18 +40,18 @@ class RoleResources {
 }
 exports.RoleResources = RoleResources;
 async function listRoles(instance, pagination) {
-    const url = (0, utils_js_1.addPaginationToURL)(new URL(RoleResources.buildPath(), instance.config.host), pagination);
+    const url = (0, utils_js_1.addPaginationToURL)(new URL(RoleResources.buildPath(), instance.baseUrl), pagination);
     return (0, collection_js_1.PaginationCollectionSchema)(schema_js_1.RoleSchema).parse(await (0, operations_js_1.getItemWithAuthorization)(url, instance.authorize));
 }
 async function getRole(instance, id) {
-    return schema_js_1.RoleSchema.parse(await (0, operations_js_1.getItemWithAuthorization)(new URL(RoleResources.buildPath(id), instance.config.host), instance.authorize));
+    return schema_js_1.RoleSchema.parse(await (0, operations_js_1.getItemWithAuthorization)(new URL(RoleResources.buildPath(id), instance.baseUrl), instance.authorize));
 }
 async function insertRole(instance, item) {
-    return schema_js_1.RoleSchema.parse(await (0, operations_js_1.postItemWithAuthorization)(new URL(RoleResources.buildPath(), instance.config.host), instance.authorize, schema_js_1.InsertRolePayloadSchema.parse(item)));
+    return schema_js_1.RoleSchema.parse(await (0, operations_js_1.postItemWithAuthorization)(new URL(RoleResources.buildPath(), instance.baseUrl), instance.authorize, schema_js_1.InsertRolePayloadSchema.parse(item)));
 }
 async function updateRole(instance, id, item) {
-    return schema_js_1.RoleSchema.parse(await (0, operations_js_1.patchItemWithAuthorization)(new URL(RoleResources.buildPath(id), instance.config.host), instance.authorize, schema_js_1.UpdateRolePayloadSchema.parse(item)));
+    return schema_js_1.RoleSchema.parse(await (0, operations_js_1.patchItemWithAuthorization)(new URL(RoleResources.buildPath(id), instance.baseUrl), instance.authorize, schema_js_1.UpdateRolePayloadSchema.parse(item)));
 }
 async function deleteRole(instance, id) {
-    return schema_js_1.RoleSchema.parse(await (0, operations_js_1.deleteItemWithAuthorization)(new URL(RoleResources.buildPath(id), instance.config.host), instance.authorize));
+    return schema_js_1.RoleSchema.parse(await (0, operations_js_1.deleteItemWithAuthorization)(new URL(RoleResources.buildPath(id), instance.baseUrl), instance.authorize));
 }

package/dist/cjs/customer/users/resources.d.ts

@@ -1,10 +1,10 @@
-import type { MondoIdentity } from '../../common/resources/init.js';
+import type { MondoInstance } from '../../common/resources/init.js';
 import { type PaginationCollection } from '../../common/schema/collection.js';
 import type { Pagination } from '../../common/schema/pagination.js';
 import { type InsertUserInput, type UpdateUserInput, type User } from './schema.js';
 export declare class UserResources {
     private readonly instance;
-    constructor(instance: MondoIdentity);
+    constructor(instance: MondoInstance);
     static buildPath(id?: string): string;
     listItems(pagination?: Pagination): Promise<PaginationCollection<User>>;
     getItem(id: string): Promise<User>;
@@ -12,9 +12,9 @@ export declare class UserResources {
     updateItem(id: string, item: UpdateUserInput): Promise<User>;
     deleteItem(id: string): Promise<User>;
 }
-export declare function listUsers(instance: MondoIdentity, pagination?: Pagination): Promise<PaginationCollection<User>>;
-export declare function getUser(instance: MondoIdentity, id: string): Promise<User>;
-export declare function insertUser(instance: MondoIdentity, item: InsertUserInput): Promise<User>;
-export declare function updateUser(instance: MondoIdentity, id: string, item: UpdateUserInput): Promise<User>;
-export declare function deleteUser(instance: MondoIdentity, id: string): Promise<User>;
+export declare function listUsers(instance: MondoInstance, pagination?: Pagination): Promise<PaginationCollection<User>>;
+export declare function getUser(instance: MondoInstance, id: string): Promise<User>;
+export declare function insertUser(instance: MondoInstance, item: InsertUserInput): Promise<User>;
+export declare function updateUser(instance: MondoInstance, id: string, item: UpdateUserInput): Promise<User>;
+export declare function deleteUser(instance: MondoInstance, id: string): Promise<User>;
 //# sourceMappingURL=resources.d.ts.map

package/dist/cjs/customer/users/resources.js

@@ -40,18 +40,18 @@ class UserResources {
 }
 exports.UserResources = UserResources;
 async function listUsers(instance, pagination) {
-    const url = (0, utils_js_1.addPaginationToURL)(new URL(UserResources.buildPath(), instance.config.host), pagination);
+    const url = (0, utils_js_1.addPaginationToURL)(new URL(UserResources.buildPath(), instance.baseUrl), pagination);
     return (0, collection_js_1.PaginationCollectionSchema)(schema_js_1.UserSchema).parse(await (0, operations_js_1.listItemsWithAuthorization)(url, instance.authorize));
 }
 async function getUser(instance, id) {
-    return schema_js_1.UserSchema.parse(await (0, operations_js_1.getItemWithAuthorization)(new URL(UserResources.buildPath(id), instance.config.host), instance.authorize));
+    return schema_js_1.UserSchema.parse(await (0, operations_js_1.getItemWithAuthorization)(new URL(UserResources.buildPath(id), instance.baseUrl), instance.authorize));
 }
 async function insertUser(instance, item) {
-    return schema_js_1.UserSchema.parse(await (0, operations_js_1.postItemWithAuthorization)(new URL(UserResources.buildPath(), instance.config.host), instance.authorize, schema_js_1.InsertUserPayloadSchema.parse(item)));
+    return schema_js_1.UserSchema.parse(await (0, operations_js_1.postItemWithAuthorization)(new URL(UserResources.buildPath(), instance.baseUrl), instance.authorize, schema_js_1.InsertUserPayloadSchema.parse(item)));
 }
 async function updateUser(instance, id, item) {
-    return schema_js_1.UserSchema.parse(await (0, operations_js_1.patchItemWithAuthorization)(new URL(UserResources.buildPath(id), instance.config.host), instance.authorize, schema_js_1.UpdateUserPayloadSchema.parse(item)));
+    return schema_js_1.UserSchema.parse(await (0, operations_js_1.patchItemWithAuthorization)(new URL(UserResources.buildPath(id), instance.baseUrl), instance.authorize, schema_js_1.UpdateUserPayloadSchema.parse(item)));
 }
 async function deleteUser(instance, id) {
-    return schema_js_1.UserSchema.parse(await (0, operations_js_1.deleteItemWithAuthorization)(new URL(UserResources.buildPath(id), instance.config.host), instance.authorize));
+    return schema_js_1.UserSchema.parse(await (0, operations_js_1.deleteItemWithAuthorization)(new URL(UserResources.buildPath(id), instance.baseUrl), instance.authorize));
 }

package/dist/esm/activity/resources.d.ts

@@ -1,13 +1,13 @@
-import type { MondoIdentity } from '../common/resources/init.js';
+import type { MondoInstance } from '../common/resources/init.js';
 import { type PaginationCollection } from '../common/schema/collection.js';
 import type { Pagination } from '../common/schema/pagination.js';
 import { type Activity } from './schema/schema.js';
 export declare const PATH = "/v1/activities";
 export declare class ActivityResources {
     private readonly instance;
-    constructor(instance: MondoIdentity);
+    constructor(instance: MondoInstance);
     static buildPath(source: string): string;
     listItems(source: string, pagination?: Pagination): Promise<PaginationCollection<Activity>>;
 }
-export declare function listActivities(instance: MondoIdentity, source: string, pagination?: Pagination): Promise<PaginationCollection<Activity>>;
+export declare function listActivities(instance: MondoInstance, source: string, pagination?: Pagination): Promise<PaginationCollection<Activity>>;
 //# sourceMappingURL=resources.d.ts.map

package/dist/esm/activity/resources.js

@@ -19,6 +19,6 @@ export class ActivityResources {
     }
 }
 export async function listActivities(instance, source, pagination) {
-    const url = addPaginationToURL(new URL(ActivityResources.buildPath(source), instance.config.host), pagination);
+    const url = addPaginationToURL(new URL(ActivityResources.buildPath(source), instance.baseUrl), pagination);
     return PaginationCollectionSchema(ActivitySchema).parse(await getItemWithAuthorization(url, instance.authorize));
 }

package/dist/esm/activity/resources.test.js

@@ -5,8 +5,9 @@ describe('Activity Resources', () => {
     let activityResources;
     beforeEach(() => {
         vi.clearAllMocks();
-        // Mock MondoIdentity instance
+        // Mock MondoInstance instance
         mockInstance = {
+            baseUrl: new URL('https://api.example.com'),
             config: {
                 host: 'https://api.example.com',
                 accessToken: 'test-token',
@@ -16,7 +17,7 @@ describe('Activity Resources', () => {
         activityResources = new ActivityResources(mockInstance);
     });
     describe('ActivityResources class', () => {
-        test('should initialize with MondoIdentity instance', () => {
+        test('should initialize with MondoInstance instance', () => {
             expect(activityResources).toBeInstanceOf(ActivityResources);
             // biome-ignore lint/complexity/useLiteralKeys: <explanation>
             expect(activityResources['instance']).toBe(mockInstance);
@@ -136,13 +137,12 @@ describe('Activity Resources', () => {
             }
         });
     });
-    describe('Integration with MondoIdentity instance', () => {
-        test('should store MondoIdentity instance internally', () => {
+    describe('Integration with MondoInstance instance', () => {
+        test('should store MondoInstance instance internally', () => {
             // biome-ignore lint/complexity/useLiteralKeys: <explanation>
             const internalInstance = activityResources['instance'];
             expect(internalInstance).toBe(mockInstance);
-            expect(internalInstance.config.host).toBe('https://api.example.com');
-            expect(internalInstance.config.accessToken).toBe('test-token');
+            expect(internalInstance.baseUrl.toString()).toBe('https://api.example.com/');
         });
         test('should maintain reference to authorize function', () => {
             // biome-ignore lint/complexity/useLiteralKeys: <explanation>
@@ -150,8 +150,9 @@ describe('Activity Resources', () => {
             expect(typeof internalInstance.authorize).toBe('function');
             expect(internalInstance.authorize).toBe(mockInstance.authorize);
         });
-        test('should work with different MondoIdentity configurations', () => {
+        test('should work with different MondoInstance configurations', () => {
             const customInstance = {
+                baseUrl: new URL('https://custom.api.com'),
                 config: {
                     host: 'https://custom.api.com',
                     accessToken: 'custom-token',
@@ -162,7 +163,7 @@ describe('Activity Resources', () => {
             // biome-ignore lint/complexity/useLiteralKeys: <explanation>
             expect(customResources['instance']).toBe(customInstance);
             // biome-ignore lint/complexity/useLiteralKeys: <explanation>
-            expect(customResources['instance'].config.host).toBe('https://custom.api.com');
+            expect(customResources['instance'].baseUrl.toString()).toBe('https://custom.api.com/');
         });
     });
     describe('Class inheritance and structure', () => {

package/dist/esm/app/authorization/resources.d.ts

@@ -1,12 +1,12 @@
-import type { MondoIdentity } from '../../common/resources/init.js';
+import type { MondoInstance } from '../../common/resources/init.js';
 import { type Authorization, type UpsertAuthorizationInput } from './schema.js';
 export declare class AuthorizationResources {
     private readonly instance;
-    constructor(instance: MondoIdentity);
+    constructor(instance: MondoInstance);
     static buildPath(appId: string): string;
     getItem(id: string): Promise<Authorization>;
     upsertItem(appId: string, item: UpsertAuthorizationInput): Promise<Authorization>;
 }
-export declare function getAuthorization(instance: MondoIdentity, appId: string): Promise<Authorization>;
-export declare function upsertAuthorization(instance: MondoIdentity, appId: string, item: UpsertAuthorizationInput): Promise<Authorization>;
+export declare function getAuthorization(instance: MondoInstance, appId: string): Promise<Authorization>;
+export declare function upsertAuthorization(instance: MondoInstance, appId: string, item: UpsertAuthorizationInput): Promise<Authorization>;
 //# sourceMappingURL=resources.d.ts.map

package/dist/esm/app/authorization/resources.js

@@ -18,8 +18,8 @@ export class AuthorizationResources {
     }
 }
 export async function getAuthorization(instance, appId) {
-    return AuthorizationSchema.parse(await getItemWithAuthorization(new URL(AuthorizationResources.buildPath(appId), instance.config.host), instance.authorize));
+    return AuthorizationSchema.parse(await getItemWithAuthorization(new URL(AuthorizationResources.buildPath(appId), instance.baseUrl), instance.authorize));
 }
 export async function upsertAuthorization(instance, appId, item) {
-    return AuthorizationSchema.parse(await putItemWithAuthorization(new URL(AuthorizationResources.buildPath(appId), instance.config.host), instance.authorize, UpsertAuthorizationPayloadSchema.parse(item)));
+    return AuthorizationSchema.parse(await putItemWithAuthorization(new URL(AuthorizationResources.buildPath(appId), instance.baseUrl), instance.authorize, UpsertAuthorizationPayloadSchema.parse(item)));
 }

package/dist/esm/app/oauth/resources.d.ts

@@ -1,12 +1,12 @@
-import type { MondoIdentity } from '../../common/resources/init.js';
+import type { MondoInstance } from '../../common/resources/init.js';
 import { type InsertOAuthInput, type OAuth } from './schema.js';
 export declare class OAuthResources {
     private readonly instance;
-    constructor(instance: MondoIdentity);
+    constructor(instance: MondoInstance);
     static buildPath(appId: string): string;
     getItem(id: string): Promise<OAuth>;
     rotateItemSecret(id: string): Promise<OAuth>;
 }
-export declare function getOAuth(instance: MondoIdentity, appId: string): Promise<OAuth>;
-export declare function rotateOAuthSecret(instance: MondoIdentity, appId: string, item?: InsertOAuthInput): Promise<OAuth>;
+export declare function getOAuth(instance: MondoInstance, appId: string): Promise<OAuth>;
+export declare function rotateOAuthSecret(instance: MondoInstance, appId: string, item?: InsertOAuthInput): Promise<OAuth>;
 //# sourceMappingURL=resources.d.ts.map

package/dist/esm/app/oauth/resources.js

@@ -21,8 +21,8 @@ export class OAuthResources {
     }
 }
 export async function getOAuth(instance, appId) {
-    return OAuthSchema.parse(await getItemWithAuthorization(new URL(OAuthResources.buildPath(appId), instance.config.host), instance.authorize));
+    return OAuthSchema.parse(await getItemWithAuthorization(new URL(OAuthResources.buildPath(appId), instance.baseUrl), instance.authorize));
 }
 export async function rotateOAuthSecret(instance, appId, item) {
-    return OAuthSchema.parse(await postItemWithAuthorization(new URL(OAuthResources.buildPath(appId), instance.config.host), instance.authorize, InsertOAuthPayloadSchema.parse(item)));
+    return OAuthSchema.parse(await postItemWithAuthorization(new URL(OAuthResources.buildPath(appId), instance.baseUrl), instance.authorize, InsertOAuthPayloadSchema.parse(item)));
 }

package/dist/esm/app/oidc/resources.d.ts

@@ -1,16 +1,16 @@
-import type { MondoIdentity } from '../../common/resources/init.js';
+import type { MondoInstance } from '../../common/resources/init.js';
 import { type InsertOIDCInput, type OIDC, type UpdateOIDCInput } from './schema.js';
 export declare class OIDCResources {
     private readonly instance;
-    constructor(instance: MondoIdentity);
+    constructor(instance: MondoInstance);
     static buildPath(appId: string): string;
     getItem(appId: string): Promise<OIDC>;
     insertItem(appId: string, item?: InsertOIDCInput): Promise<OIDC>;
     updateItem(appId: string, item: UpdateOIDCInput): Promise<OIDC>;
     deleteItem(appId: string): Promise<OIDC>;
 }
-export declare function getOIDC(instance: MondoIdentity, appId: string): Promise<OIDC>;
-export declare function insertOIDC(instance: MondoIdentity, appId: string, item?: InsertOIDCInput): Promise<OIDC>;
-export declare function updateOIDC(instance: MondoIdentity, appId: string, item: UpdateOIDCInput): Promise<OIDC>;
-export declare function deleteOIDC(instance: MondoIdentity, appId: string): Promise<OIDC>;
+export declare function getOIDC(instance: MondoInstance, appId: string): Promise<OIDC>;
+export declare function insertOIDC(instance: MondoInstance, appId: string, item?: InsertOIDCInput): Promise<OIDC>;
+export declare function updateOIDC(instance: MondoInstance, appId: string, item: UpdateOIDCInput): Promise<OIDC>;
+export declare function deleteOIDC(instance: MondoInstance, appId: string): Promise<OIDC>;
 //# sourceMappingURL=resources.d.ts.map

package/dist/esm/app/oidc/resources.js

@@ -27,14 +27,14 @@ export class OIDCResources {
     }
 }
 export async function getOIDC(instance, appId) {
-    return OIDCSchema.parse(await getItemWithAuthorization(new URL(OIDCResources.buildPath(appId), instance.config.host), instance.authorize));
+    return OIDCSchema.parse(await getItemWithAuthorization(new URL(OIDCResources.buildPath(appId), instance.baseUrl), instance.authorize));
 }
 export async function insertOIDC(instance, appId, item) {
-    return OIDCSchema.parse(await postItemWithAuthorization(new URL(OIDCResources.buildPath(appId), instance.config.host), instance.authorize, item ? InsertOIDCPayloadSchema.parse(item) : undefined));
+    return OIDCSchema.parse(await postItemWithAuthorization(new URL(OIDCResources.buildPath(appId), instance.baseUrl), instance.authorize, item ? InsertOIDCPayloadSchema.parse(item) : undefined));
 }
 export async function updateOIDC(instance, appId, item) {
-    return OIDCSchema.parse(await patchItemWithAuthorization(new URL(OIDCResources.buildPath(appId), instance.config.host), instance.authorize, UpdateOIDCPayloadSchema.parse(item)));
+    return OIDCSchema.parse(await patchItemWithAuthorization(new URL(OIDCResources.buildPath(appId), instance.baseUrl), instance.authorize, UpdateOIDCPayloadSchema.parse(item)));
 }
 export async function deleteOIDC(instance, appId) {
-    return OIDCSchema.parse(await deleteItemWithAuthorization(new URL(OIDCResources.buildPath(appId), instance.config.host), instance.authorize));
+    return OIDCSchema.parse(await deleteItemWithAuthorization(new URL(OIDCResources.buildPath(appId), instance.baseUrl), instance.authorize));
 }

package/dist/esm/app/registration/resources.d.ts

@@ -1,12 +1,12 @@
-import type { MondoIdentity } from '../../common/resources/init.js';
+import type { MondoInstance } from '../../common/resources/init.js';
 import { type Registration, type UpsertRegistrationInput } from './schema.js';
 export declare class RegistrationResources {
     private readonly instance;
-    constructor(instance: MondoIdentity);
+    constructor(instance: MondoInstance);
     static buildPath(id: string): string;
     getItem(id: string): Promise<Registration>;
     upsertItem(id: string, item: UpsertRegistrationInput): Promise<Registration>;
 }
-export declare function getRegistration(instance: MondoIdentity, id: string): Promise<Registration>;
-export declare function upsertRegistration(instance: MondoIdentity, id: string, item: UpsertRegistrationInput): Promise<Registration>;
+export declare function getRegistration(instance: MondoInstance, id: string): Promise<Registration>;
+export declare function upsertRegistration(instance: MondoInstance, id: string, item: UpsertRegistrationInput): Promise<Registration>;
 //# sourceMappingURL=resources.d.ts.map

package/dist/esm/app/registration/resources.js

@@ -21,8 +21,8 @@ export class RegistrationResources {
     }
 }
 export async function getRegistration(instance, id) {
-    return RegistrationSchema.parse(await getItemWithAuthorization(new URL(RegistrationResources.buildPath(id), instance.config.host), instance.authorize));
+    return RegistrationSchema.parse(await getItemWithAuthorization(new URL(RegistrationResources.buildPath(id), instance.baseUrl), instance.authorize));
 }
 export async function upsertRegistration(instance, id, item) {
-    return RegistrationSchema.parse(await postItemWithAuthorization(new URL(RegistrationResources.buildPath(id), instance.config.host), instance.authorize, UpsertRegistrationPayloadSchema.parse(item)));
+    return RegistrationSchema.parse(await postItemWithAuthorization(new URL(RegistrationResources.buildPath(id), instance.baseUrl), instance.authorize, UpsertRegistrationPayloadSchema.parse(item)));
 }

package/dist/esm/app/registration/resources.test.js

@@ -5,8 +5,9 @@ describe('App Registration Resources', () => {
     let registrationResources;
     beforeEach(() => {
         vi.clearAllMocks();
-        // Mock MondoIdentity instance
+        // Mock MondoInstance instance
         mockInstance = {
+            baseUrl: new URL('https://api.example.com'),
             config: {
                 host: 'https://api.example.com',
                 accessToken: 'test-token',
@@ -16,7 +17,7 @@ describe('App Registration Resources', () => {
         registrationResources = new RegistrationResources(mockInstance);
     });
     describe('RegistrationResources class', () => {
-        test('should initialize with MondoIdentity instance', () => {
+        test('should initialize with MondoInstance instance', () => {
             expect(registrationResources).toBeInstanceOf(RegistrationResources);
             // biome-ignore lint/complexity/useLiteralKeys: <explanation>
             expect(registrationResources['instance']).toBe(mockInstance);
@@ -141,13 +142,12 @@ describe('App Registration Resources', () => {
             }
         });
     });
-    describe('Integration with MondoIdentity instance', () => {
-        test('should store MondoIdentity instance internally', () => {
+    describe('Integration with MondoInstance instance', () => {
+        test('should store MondoInstance instance internally', () => {
             // biome-ignore lint/complexity/useLiteralKeys: <explanation>
             const internalInstance = registrationResources['instance'];
             expect(internalInstance).toBe(mockInstance);
-            expect(internalInstance.config.host).toBe('https://api.example.com');
-            expect(internalInstance.config.accessToken).toBe('test-token');
+            expect(internalInstance.baseUrl.toString()).toBe('https://api.example.com/');
         });
         test('should maintain reference to authorize function', () => {
             // biome-ignore lint/complexity/useLiteralKeys: <explanation>
@@ -155,8 +155,9 @@ describe('App Registration Resources', () => {
             expect(typeof internalInstance.authorize).toBe('function');
             expect(internalInstance.authorize).toBe(mockInstance.authorize);
         });
-        test('should work with different MondoIdentity configurations', () => {
+        test('should work with different MondoInstance configurations', () => {
             const customInstance = {
+                baseUrl: new URL('https://custom-registration.api.com'),
                 config: {
                     host: 'https://custom-registration.api.com',
                     accessToken: 'custom-registration-token',
@@ -167,7 +168,7 @@ describe('App Registration Resources', () => {
             // biome-ignore lint/complexity/useLiteralKeys: <explanation>
             expect(customResources['instance']).toBe(customInstance);
             // biome-ignore lint/complexity/useLiteralKeys: <explanation>
-            expect(customResources['instance'].config.host).toBe('https://custom-registration.api.com');
+            expect(customResources['instance'].baseUrl.toString()).toBe('https://custom-registration.api.com/');
         });
     });
     describe('Class structure and inheritance', () => {

package/dist/esm/app/resources.d.ts

@@ -1,11 +1,11 @@
-import type { MondoIdentity } from '../common/resources/init.js';
+import type { MondoInstance } from '../common/resources/init.js';
 import { type PaginationCollection } from '../common/schema/collection.js';
 import type { Pagination } from '../common/schema/pagination.js';
 import { type App, type InsertAppInput, type UpdateAppInput } from './schema.js';
 export declare const PATH = "/v1/apps";
 export declare class AppResources {
     private readonly instance;
-    constructor(instance: MondoIdentity);
+    constructor(instance: MondoInstance);
     static buildPath(id?: string): string;
     listItems(pagination?: Pagination): Promise<PaginationCollection<App>>;
     getItem(id: string): Promise<App>;
@@ -13,9 +13,9 @@ export declare class AppResources {
     updateItem(id: string, item: UpdateAppInput): Promise<App>;
     deleteItem(id: string): Promise<App>;
 }
-export declare function listApps(instance: MondoIdentity, pagination?: Pagination): Promise<PaginationCollection<App>>;
-export declare function getApp(instance: MondoIdentity, id: string): Promise<App>;
-export declare function insertApp(instance: MondoIdentity, item: InsertAppInput): Promise<App>;
-export declare function updateApp(instance: MondoIdentity, id: string, item: UpdateAppInput): Promise<App>;
-export declare function deleteApp(instance: MondoIdentity, id: string): Promise<App>;
+export declare function listApps(instance: MondoInstance, pagination?: Pagination): Promise<PaginationCollection<App>>;
+export declare function getApp(instance: MondoInstance, id: string): Promise<App>;
+export declare function insertApp(instance: MondoInstance, item: InsertAppInput): Promise<App>;
+export declare function updateApp(instance: MondoInstance, id: string, item: UpdateAppInput): Promise<App>;
+export declare function deleteApp(instance: MondoInstance, id: string): Promise<App>;
 //# sourceMappingURL=resources.d.ts.map

package/dist/esm/app/resources.js

@@ -31,18 +31,18 @@ export class AppResources {
     }
 }
 export async function listApps(instance, pagination) {
-    const url = addPaginationToURL(new URL(AppResources.buildPath(), instance.config.host), pagination);
+    const url = addPaginationToURL(new URL(AppResources.buildPath(), instance.baseUrl), pagination);
     return PaginationCollectionSchema(AppSchema).parse(await getItemWithAuthorization(url, instance.authorize));
 }
 export async function getApp(instance, id) {
-    return AppSchema.parse(await getItemWithAuthorization(new URL(AppResources.buildPath(id), instance.config.host), instance.authorize));
+    return AppSchema.parse(await getItemWithAuthorization(new URL(AppResources.buildPath(id), instance.baseUrl), instance.authorize));
 }
 export async function insertApp(instance, item) {
-    return AppSchema.parse(await postItemWithAuthorization(new URL(AppResources.buildPath(), instance.config.host), instance.authorize, InsertAppPayloadSchema.parse(item)));
+    return AppSchema.parse(await postItemWithAuthorization(new URL(AppResources.buildPath(), instance.baseUrl), instance.authorize, InsertAppPayloadSchema.parse(item)));
 }
 export async function updateApp(instance, id, item) {
-    return AppSchema.parse(await patchItemWithAuthorization(new URL(AppResources.buildPath(id), instance.config.host), instance.authorize, UpdateAppPayloadSchema.parse(item)));
+    return AppSchema.parse(await patchItemWithAuthorization(new URL(AppResources.buildPath(id), instance.baseUrl), instance.authorize, UpdateAppPayloadSchema.parse(item)));
 }
 export async function deleteApp(instance, id) {
-    return AppSchema.parse(await deleteItemWithAuthorization(new URL(AppResources.buildPath(id), instance.config.host), instance.authorize));
+    return AppSchema.parse(await deleteItemWithAuthorization(new URL(AppResources.buildPath(id), instance.baseUrl), instance.authorize));
 }

package/dist/esm/app/resources.test.js

@@ -5,8 +5,9 @@ describe('App Resources', () => {
     let appResources;
     beforeEach(() => {
         vi.clearAllMocks();
-        // Mock MondoIdentity instance
+        // Mock MondoInstance instance
         mockInstance = {
+            baseUrl: new URL('https://api.example.com'),
             config: {
                 host: 'https://api.example.com',
                 accessToken: 'test-token',
@@ -16,7 +17,7 @@ describe('App Resources', () => {
         appResources = new AppResources(mockInstance);
     });
     describe('AppResources class', () => {
-        test('should initialize with MondoIdentity instance', () => {
+        test('should initialize with MondoInstance instance', () => {
             expect(appResources).toBeInstanceOf(AppResources);
             // biome-ignore lint/complexity/useLiteralKeys: <explanation>
             expect(appResources['instance']).toBe(mockInstance);
@@ -133,13 +134,12 @@ describe('App Resources', () => {
             }
         });
     });
-    describe('Integration with MondoIdentity instance', () => {
-        test('should store MondoIdentity instance internally', () => {
+    describe('Integration with MondoInstance instance', () => {
+        test('should store MondoInstance instance internally', () => {
             // biome-ignore lint/complexity/useLiteralKeys: <explanation>
             const internalInstance = appResources['instance'];
             expect(internalInstance).toBe(mockInstance);
-            expect(internalInstance.config.host).toBe('https://api.example.com');
-            expect(internalInstance.config.accessToken).toBe('test-token');
+            expect(internalInstance.baseUrl.toString()).toBe('https://api.example.com/');
         });
         test('should maintain reference to authorize function', () => {
             // biome-ignore lint/complexity/useLiteralKeys: <explanation>
@@ -147,8 +147,9 @@ describe('App Resources', () => {
             expect(typeof internalInstance.authorize).toBe('function');
             expect(internalInstance.authorize).toBe(mockInstance.authorize);
         });
-        test('should work with different MondoIdentity configurations', () => {
+        test('should work with different MondoInstance configurations', () => {
             const customInstance = {
+                baseUrl: new URL('https://custom-apps.api.com'),
                 config: {
                     host: 'https://custom-apps.api.com',
                     accessToken: 'custom-app-token',
@@ -159,7 +160,7 @@ describe('App Resources', () => {
             // biome-ignore lint/complexity/useLiteralKeys: <explanation>
             expect(customResources['instance']).toBe(customInstance);
             // biome-ignore lint/complexity/useLiteralKeys: <explanation>
-            expect(customResources['instance'].config.host).toBe('https://custom-apps.api.com');
+            expect(customResources['instance'].baseUrl.toString()).toBe('https://custom-apps.api.com/');
         });
     });
     describe('Class structure and inheritance', () => {

package/dist/esm/app/saml/resources.d.ts

@@ -1,16 +1,16 @@
-import type { MondoIdentity } from '../../common/resources/init.js';
+import type { MondoInstance } from '../../common/resources/init.js';
 import { type InsertSAMLInput, type SAML, type UpdateSAMLInput } from './schema.js';
 export declare class SAMLResources {
     private readonly instance;
-    constructor(instance: MondoIdentity);
+    constructor(instance: MondoInstance);
     static buildPath(appId: string): string;
     getItem(appId: string): Promise<SAML>;
     insertItem(appId: string, item?: InsertSAMLInput): Promise<SAML>;
     updateItem(appId: string, item: UpdateSAMLInput): Promise<SAML>;
     deleteItem(appId: string): Promise<SAML>;
 }
-export declare function getSAML(instance: MondoIdentity, appId: string): Promise<SAML>;
-export declare function insertSAML(instance: MondoIdentity, appId: string, item?: InsertSAMLInput): Promise<SAML>;
-export declare function updateSAML(instance: MondoIdentity, appId: string, item: UpdateSAMLInput): Promise<SAML>;
-export declare function deleteSAML(instance: MondoIdentity, appId: string): Promise<SAML>;
+export declare function getSAML(instance: MondoInstance, appId: string): Promise<SAML>;
+export declare function insertSAML(instance: MondoInstance, appId: string, item?: InsertSAMLInput): Promise<SAML>;
+export declare function updateSAML(instance: MondoInstance, appId: string, item: UpdateSAMLInput): Promise<SAML>;
+export declare function deleteSAML(instance: MondoInstance, appId: string): Promise<SAML>;
 //# sourceMappingURL=resources.d.ts.map