@logto/schemas 1.14.0 → 1.16.0

package/lib/types/logto-config/jwt-customizer.js

@@ -0,0 +1,92 @@
+import { jsonObjectGuard } from '@logto/connector-kit';
+import { z } from 'zod';
+import { Organizations, Roles, UserSsoIdentities } from '../../db-entries/index.js';
+import { mfaFactorsGuard } from '../../foundations/index.js';
+import { scopeResponseGuard } from '../scope.js';
+import { userInfoGuard } from '../user.js';
+import { accessTokenPayloadGuard, clientCredentialsPayloadGuard } from './oidc-provider.js';
+export const jwtCustomizerGuard = z.object({
+    script: z.string(),
+    environmentVariables: z.record(z.string()).optional(),
+    contextSample: jsonObjectGuard.optional(),
+});
+export var LogtoJwtTokenKeyType;
+(function (LogtoJwtTokenKeyType) {
+    LogtoJwtTokenKeyType["AccessToken"] = "access-token";
+    LogtoJwtTokenKeyType["ClientCredentials"] = "client-credentials";
+})(LogtoJwtTokenKeyType || (LogtoJwtTokenKeyType = {}));
+export const jwtCustomizerUserContextGuard = userInfoGuard.extend({
+    ssoIdentities: UserSsoIdentities.guard
+        .pick({ issuer: true, identityId: true, detail: true })
+        .array(),
+    mfaVerificationFactors: mfaFactorsGuard,
+    roles: Roles.guard
+        .pick({ id: true, name: true, description: true })
+        .extend({
+        scopes: scopeResponseGuard
+            .pick({ id: true, name: true, description: true, resourceId: true, resource: true })
+            .array(),
+    })
+        .array(),
+    organizations: Organizations.guard.pick({ id: true, name: true, description: true }).array(),
+    organizationRoles: z
+        .object({
+        organizationId: z.string(),
+        roleId: z.string(),
+        roleName: z.string(),
+    })
+        .array(),
+});
+export const accessTokenJwtCustomizerGuard = jwtCustomizerGuard
+    .extend({
+    // Use partial token guard since users customization may not rely on all fields.
+    tokenSample: accessTokenPayloadGuard.partial().optional(),
+    contextSample: z.object({ user: jwtCustomizerUserContextGuard.partial() }).optional(),
+})
+    .strict();
+export const clientCredentialsJwtCustomizerGuard = jwtCustomizerGuard
+    .extend({
+    // Use partial token guard since users customization may not rely on all fields.
+    tokenSample: clientCredentialsPayloadGuard.partial().optional(),
+})
+    .strict();
+/**
+ * This guard is for the core JWT customizer testing API request body guard.
+ * Unlike the DB guard
+ *
+ * - rename the `tokenSample` to `token` and is required for testing.
+ * - rename the `contextSample` to `context` and is required for AccessToken testing.
+ */
+export const jwtCustomizerTestRequestBodyGuard = z.discriminatedUnion('tokenType', [
+    z.object({
+        tokenType: z.literal(LogtoJwtTokenKeyType.AccessToken),
+        ...accessTokenJwtCustomizerGuard.pick({ environmentVariables: true, script: true }).shape,
+        token: accessTokenJwtCustomizerGuard.required().shape.tokenSample,
+        context: accessTokenJwtCustomizerGuard.required().shape.contextSample,
+    }),
+    z.object({
+        tokenType: z.literal(LogtoJwtTokenKeyType.ClientCredentials),
+        ...clientCredentialsJwtCustomizerGuard.pick({ environmentVariables: true, script: true }).shape,
+        token: clientCredentialsJwtCustomizerGuard.required().shape.tokenSample,
+    }),
+]);
+/**
+ * This guard is for cloud API use (request body guard).
+ * Since the cloud API will be use by both testing and production, should keep the fields as general as possible.
+ * The response guard for the cloud API is `jsonObjectGuard` since it extends the `token` with extra claims.
+ */
+const commonJwtCustomizerGuard = jwtCustomizerGuard
+    .pick({ script: true, environmentVariables: true })
+    .required({ script: true })
+    .extend({
+    token: jsonObjectGuard,
+});
+export const customJwtFetcherGuard = z.discriminatedUnion('tokenType', [
+    commonJwtCustomizerGuard.extend({
+        tokenType: z.literal(LogtoJwtTokenKeyType.AccessToken),
+        context: jsonObjectGuard,
+    }),
+    commonJwtCustomizerGuard.extend({
+        tokenType: z.literal(LogtoJwtTokenKeyType.ClientCredentials),
+    }),
+]);

package/lib/types/logto-config/jwt-customizer.test.d.ts

@@ -0,0 +1 @@
+export {};

package/lib/types/logto-config/jwt-customizer.test.js

@@ -0,0 +1,78 @@
+import { pick } from '@silverhand/essentials';
+import { describe, expect, it } from 'vitest';
+import { accessTokenJwtCustomizerGuard, clientCredentialsJwtCustomizerGuard, } from './jwt-customizer.js';
+const allFields = ['script', 'environmentVariables', 'contextSample', 'tokenSample'];
+const requiredFields = ['script'];
+const optionalFields = ['environmentVariables', 'contextSample', 'tokenSample'];
+const testClientCredentialsTokenPayload = {
+    script: '',
+    environmentVariables: {},
+    contextSample: {},
+    tokenSample: {},
+};
+const testAccessTokenPayload = {
+    ...testClientCredentialsTokenPayload,
+    contextSample: {
+        user: {
+            id: '123',
+            username: 'foo',
+            primaryEmail: 'foo@logto.io',
+            primaryPhone: '+1234567890',
+            name: 'Foo Bar',
+            avatar: 'https://example.com/avatar.png',
+            customData: {},
+            identities: {},
+            profile: {},
+            applicationId: 'my-app',
+            ssoIdentities: [],
+            mfaVerificationFactors: [],
+            roles: [],
+            organizations: [],
+            organizationRoles: [],
+        },
+    },
+};
+describe('test token sample guard', () => {
+    it.each(optionalFields)('should pass guard with any of the optionalFields not specified', (droppedField) => {
+        const resultAccessToken = accessTokenJwtCustomizerGuard.safeParse(pick(testAccessTokenPayload, ...allFields.filter((field) => field !== droppedField)));
+        if (!resultAccessToken.success) {
+            console.log('resultAccessToken.error', resultAccessToken.error);
+        }
+        expect(resultAccessToken.success).toBe(true);
+        const resultClientCredentials = clientCredentialsJwtCustomizerGuard.safeParse(pick(testClientCredentialsTokenPayload, ...allFields.filter((field) => field !== droppedField)));
+        if (!resultClientCredentials.success) {
+            console.log('resultClientCredentials.error', resultClientCredentials.error);
+        }
+        expect(resultClientCredentials.success).toBe(true);
+    });
+    it.each(requiredFields)('should throw when required field is not specified', (droppedField) => {
+        const resultAccessToken = accessTokenJwtCustomizerGuard.safeParse(pick(testAccessTokenPayload, ...allFields.filter((field) => field !== droppedField)));
+        expect(resultAccessToken.success).toBe(false);
+        const resultClientCredentials = clientCredentialsJwtCustomizerGuard.safeParse(pick(testClientCredentialsTokenPayload, ...allFields.filter((field) => field !== droppedField)));
+        expect(resultClientCredentials.success).toBe(false);
+    });
+    it.each(allFields)('should pass partial guard with any of the field not specified', (droppedField) => {
+        const resultAccessToken = accessTokenJwtCustomizerGuard
+            .partial()
+            .safeParse(pick(testAccessTokenPayload, ...allFields.filter((field) => field !== droppedField)));
+        expect(resultAccessToken.success).toBe(true);
+        const resultClientCredentials = clientCredentialsJwtCustomizerGuard
+            .partial()
+            .safeParse(pick(testClientCredentialsTokenPayload, ...allFields.filter((field) => field !== droppedField)));
+        expect(resultClientCredentials.success).toBe(true);
+    });
+    it('should throw when unwanted fields presented (access token)', () => {
+        const result = accessTokenJwtCustomizerGuard.safeParse({
+            ...testAccessTokenPayload,
+            abc: 'abc',
+        });
+        expect(result.success).toBe(false);
+    });
+    it('should throw when unwanted fields presented (client credentials token)', () => {
+        const result = clientCredentialsJwtCustomizerGuard.safeParse({
+            ...testClientCredentialsTokenPayload,
+            abc: 'abc',
+        });
+        expect(result.success).toBe(false);
+    });
+});

package/lib/types/logto-config/oidc-provider.d.ts

@@ -0,0 +1,67 @@
+/**
+ * Manually implement zod guards of some node OIDC provider types.
+ *
+ * Please note that we defined `accessTokenPayloadGuard` and `clientCredentialsPayloadGuard` in this file, they are used to make the user-defined token
+ * sample to be aligned with the real token payload given by the OIDC provider in a real use case.
+ *
+ * Only keep the least necessary fields in the guards to align with the raw token payload that can be used for `extraTokenClaims` method.
+ */
+import { z } from 'zod';
+export declare const accessTokenPayloadGuard: z.ZodObject<{
+    accountId: z.ZodString;
+    expiresWithSession: z.ZodOptional<z.ZodBoolean>;
+    grantId: z.ZodString;
+    gty: z.ZodString;
+    sessionUid: z.ZodOptional<z.ZodString>;
+    sid: z.ZodOptional<z.ZodString>;
+    kind: z.ZodLiteral<"AccessToken">;
+    jti: z.ZodString;
+    aud: z.ZodUnion<[z.ZodString, z.ZodArray<z.ZodString, "many">]>;
+    scope: z.ZodOptional<z.ZodString>;
+    clientId: z.ZodOptional<z.ZodString>;
+}, "strict", z.ZodTypeAny, {
+    grantId: string;
+    accountId: string;
+    gty: string;
+    kind: "AccessToken";
+    jti: string;
+    aud: (string | string[]) & (string | string[] | undefined);
+    expiresWithSession?: boolean | undefined;
+    sessionUid?: string | undefined;
+    sid?: string | undefined;
+    scope?: string | undefined;
+    clientId?: string | undefined;
+}, {
+    grantId: string;
+    accountId: string;
+    gty: string;
+    kind: "AccessToken";
+    jti: string;
+    aud: (string | string[]) & (string | string[] | undefined);
+    expiresWithSession?: boolean | undefined;
+    sessionUid?: string | undefined;
+    sid?: string | undefined;
+    scope?: string | undefined;
+    clientId?: string | undefined;
+}>;
+export type AccessTokenPayload = z.infer<typeof accessTokenPayloadGuard>;
+export declare const clientCredentialsPayloadGuard: z.ZodObject<{
+    kind: z.ZodLiteral<"ClientCredentials">;
+    jti: z.ZodString;
+    aud: z.ZodUnion<[z.ZodString, z.ZodArray<z.ZodString, "many">]>;
+    scope: z.ZodOptional<z.ZodString>;
+    clientId: z.ZodOptional<z.ZodString>;
+}, "strict", z.ZodTypeAny, {
+    kind: "ClientCredentials";
+    jti: string;
+    aud: (string | string[]) & (string | string[] | undefined);
+    scope?: string | undefined;
+    clientId?: string | undefined;
+}, {
+    kind: "ClientCredentials";
+    jti: string;
+    aud: (string | string[]) & (string | string[] | undefined);
+    scope?: string | undefined;
+    clientId?: string | undefined;
+}>;
+export type ClientCredentialsPayload = z.infer<typeof clientCredentialsPayloadGuard>;

package/lib/types/logto-config/oidc-provider.js

@@ -0,0 +1,33 @@
+/**
+ * Manually implement zod guards of some node OIDC provider types.
+ *
+ * Please note that we defined `accessTokenPayloadGuard` and `clientCredentialsPayloadGuard` in this file, they are used to make the user-defined token
+ * sample to be aligned with the real token payload given by the OIDC provider in a real use case.
+ *
+ * Only keep the least necessary fields in the guards to align with the raw token payload that can be used for `extraTokenClaims` method.
+ */
+import { z } from 'zod';
+const baseTokenPayloadGuardObject = {
+    jti: z.string(),
+    aud: z.union([z.string(), z.string().array()]),
+    scope: z.string().optional(),
+    clientId: z.string().optional(),
+};
+export const accessTokenPayloadGuard = z
+    .object({
+    ...baseTokenPayloadGuardObject,
+    accountId: z.string(),
+    expiresWithSession: z.boolean().optional(),
+    grantId: z.string(),
+    gty: z.string(),
+    sessionUid: z.string().optional(),
+    sid: z.string().optional(),
+    kind: z.literal('AccessToken'),
+})
+    .strict();
+export const clientCredentialsPayloadGuard = z
+    .object({
+    ...baseTokenPayloadGuardObject,
+    kind: z.literal('ClientCredentials'),
+})
+    .strict();

package/lib/types/onboarding.d.ts

@@ -0,0 +1,144 @@
+import { z } from 'zod';
+export declare const userOnboardingDataKey = "onboarding";
+export declare enum Project {
+    Personal = "personal",
+    Company = "company"
+}
+/** @deprecated Open-source options was for cloud preview use, no longer needed. Use default `Cloud` value for placeholder. */
+declare enum DeploymentType {
+    OpenSource = "open-source",
+    Cloud = "cloud"
+}
+/** @deprecated */
+export declare enum Title {
+    Developer = "developer",
+    TeamLead = "team-lead",
+    Ceo = "ceo",
+    Cto = "cto",
+    Product = "product",
+    Others = "others"
+}
+/** @deprecated */
+export declare enum CompanySize {
+    Scale1 = "1",
+    Scale2 = "2-49",
+    Scale3 = "50-199",
+    Scale4 = "200-999",
+    Scale5 = "1000+"
+}
+/** @deprecated */
+export declare enum Reason {
+    Passwordless = "passwordless",
+    Efficiency = "efficiency",
+    AccessControl = "access-control",
+    MultiTenancy = "multi-tenancy",
+    Enterprise = "enterprise",
+    Others = "others"
+}
+export declare enum Stage {
+    NewProduct = "new-product",
+    ExistingProduct = "existing-product",
+    TargetEnterpriseReady = "target-enterprise-ready"
+}
+export declare enum AdditionalFeatures {
+    CustomizeUiAndFlow = "customize-ui-and-flow",
+    Compliance = "compliance",
+    ExportUserDataFromLogto = "export-user-data-from-logto",
+    BudgetControl = "budget-control",
+    BringOwnAuth = "bring-own-auth",
+    Others = "others"
+}
+declare const questionnaireGuard: z.ZodObject<{
+    project: z.ZodOptional<z.ZodNativeEnum<typeof Project>>;
+    /** @deprecated Open-source options was for cloud preview use, no longer needed. Use default `Cloud` value for placeholder. */
+    deploymentType: z.ZodDefault<z.ZodOptional<z.ZodNativeEnum<typeof DeploymentType>>>;
+    /** @deprecated */
+    titles: z.ZodOptional<z.ZodArray<z.ZodNativeEnum<typeof Title>, "many">>;
+    companyName: z.ZodOptional<z.ZodString>;
+    /** @deprecated */
+    companySize: z.ZodOptional<z.ZodNativeEnum<typeof CompanySize>>;
+    /** @deprecated */
+    reasons: z.ZodOptional<z.ZodArray<z.ZodNativeEnum<typeof Reason>, "many">>;
+    stage: z.ZodOptional<z.ZodNativeEnum<typeof Stage>>;
+    additionalFeatures: z.ZodOptional<z.ZodArray<z.ZodNativeEnum<typeof AdditionalFeatures>, "many">>;
+}, "strip", z.ZodTypeAny, {
+    deploymentType: DeploymentType;
+    project?: Project | undefined;
+    titles?: Title[] | undefined;
+    companyName?: string | undefined;
+    companySize?: CompanySize | undefined;
+    reasons?: Reason[] | undefined;
+    stage?: Stage | undefined;
+    additionalFeatures?: AdditionalFeatures[] | undefined;
+}, {
+    project?: Project | undefined;
+    deploymentType?: DeploymentType | undefined;
+    titles?: Title[] | undefined;
+    companyName?: string | undefined;
+    companySize?: CompanySize | undefined;
+    reasons?: Reason[] | undefined;
+    stage?: Stage | undefined;
+    additionalFeatures?: AdditionalFeatures[] | undefined;
+}>;
+export type Questionnaire = z.infer<typeof questionnaireGuard>;
+export declare const userOnboardingDataGuard: z.ZodObject<{
+    questionnaire: z.ZodOptional<z.ZodObject<{
+        project: z.ZodOptional<z.ZodNativeEnum<typeof Project>>;
+        /** @deprecated Open-source options was for cloud preview use, no longer needed. Use default `Cloud` value for placeholder. */
+        deploymentType: z.ZodDefault<z.ZodOptional<z.ZodNativeEnum<typeof DeploymentType>>>;
+        /** @deprecated */
+        titles: z.ZodOptional<z.ZodArray<z.ZodNativeEnum<typeof Title>, "many">>;
+        companyName: z.ZodOptional<z.ZodString>;
+        /** @deprecated */
+        companySize: z.ZodOptional<z.ZodNativeEnum<typeof CompanySize>>;
+        /** @deprecated */
+        reasons: z.ZodOptional<z.ZodArray<z.ZodNativeEnum<typeof Reason>, "many">>;
+        stage: z.ZodOptional<z.ZodNativeEnum<typeof Stage>>;
+        additionalFeatures: z.ZodOptional<z.ZodArray<z.ZodNativeEnum<typeof AdditionalFeatures>, "many">>;
+    }, "strip", z.ZodTypeAny, {
+        deploymentType: DeploymentType;
+        project?: Project | undefined;
+        titles?: Title[] | undefined;
+        companyName?: string | undefined;
+        companySize?: CompanySize | undefined;
+        reasons?: Reason[] | undefined;
+        stage?: Stage | undefined;
+        additionalFeatures?: AdditionalFeatures[] | undefined;
+    }, {
+        project?: Project | undefined;
+        deploymentType?: DeploymentType | undefined;
+        titles?: Title[] | undefined;
+        companyName?: string | undefined;
+        companySize?: CompanySize | undefined;
+        reasons?: Reason[] | undefined;
+        stage?: Stage | undefined;
+        additionalFeatures?: AdditionalFeatures[] | undefined;
+    }>>;
+    isOnboardingDone: z.ZodOptional<z.ZodBoolean>;
+}, "strip", z.ZodTypeAny, {
+    questionnaire?: {
+        deploymentType: DeploymentType;
+        project?: Project | undefined;
+        titles?: Title[] | undefined;
+        companyName?: string | undefined;
+        companySize?: CompanySize | undefined;
+        reasons?: Reason[] | undefined;
+        stage?: Stage | undefined;
+        additionalFeatures?: AdditionalFeatures[] | undefined;
+    } | undefined;
+    isOnboardingDone?: boolean | undefined;
+}, {
+    questionnaire?: {
+        project?: Project | undefined;
+        deploymentType?: DeploymentType | undefined;
+        titles?: Title[] | undefined;
+        companyName?: string | undefined;
+        companySize?: CompanySize | undefined;
+        reasons?: Reason[] | undefined;
+        stage?: Stage | undefined;
+        additionalFeatures?: AdditionalFeatures[] | undefined;
+    } | undefined;
+    isOnboardingDone?: boolean | undefined;
+}>;
+export type UserOnboardingData = z.infer<typeof userOnboardingDataGuard>;
+export {};

package/lib/types/onboarding.js

@@ -0,0 +1,75 @@
+import { z } from 'zod';
+export const userOnboardingDataKey = 'onboarding';
+export var Project;
+(function (Project) {
+    Project["Personal"] = "personal";
+    Project["Company"] = "company";
+})(Project || (Project = {}));
+/** @deprecated Open-source options was for cloud preview use, no longer needed. Use default `Cloud` value for placeholder. */
+var DeploymentType;
+(function (DeploymentType) {
+    DeploymentType["OpenSource"] = "open-source";
+    DeploymentType["Cloud"] = "cloud";
+})(DeploymentType || (DeploymentType = {}));
+/** @deprecated */
+export var Title;
+(function (Title) {
+    Title["Developer"] = "developer";
+    Title["TeamLead"] = "team-lead";
+    Title["Ceo"] = "ceo";
+    Title["Cto"] = "cto";
+    Title["Product"] = "product";
+    Title["Others"] = "others";
+})(Title || (Title = {}));
+/** @deprecated */
+export var CompanySize;
+(function (CompanySize) {
+    CompanySize["Scale1"] = "1";
+    CompanySize["Scale2"] = "2-49";
+    CompanySize["Scale3"] = "50-199";
+    CompanySize["Scale4"] = "200-999";
+    CompanySize["Scale5"] = "1000+";
+})(CompanySize || (CompanySize = {}));
+/** @deprecated */
+export var Reason;
+(function (Reason) {
+    Reason["Passwordless"] = "passwordless";
+    Reason["Efficiency"] = "efficiency";
+    Reason["AccessControl"] = "access-control";
+    Reason["MultiTenancy"] = "multi-tenancy";
+    Reason["Enterprise"] = "enterprise";
+    Reason["Others"] = "others";
+})(Reason || (Reason = {}));
+export var Stage;
+(function (Stage) {
+    Stage["NewProduct"] = "new-product";
+    Stage["ExistingProduct"] = "existing-product";
+    Stage["TargetEnterpriseReady"] = "target-enterprise-ready";
+})(Stage || (Stage = {}));
+export var AdditionalFeatures;
+(function (AdditionalFeatures) {
+    AdditionalFeatures["CustomizeUiAndFlow"] = "customize-ui-and-flow";
+    AdditionalFeatures["Compliance"] = "compliance";
+    AdditionalFeatures["ExportUserDataFromLogto"] = "export-user-data-from-logto";
+    AdditionalFeatures["BudgetControl"] = "budget-control";
+    AdditionalFeatures["BringOwnAuth"] = "bring-own-auth";
+    AdditionalFeatures["Others"] = "others";
+})(AdditionalFeatures || (AdditionalFeatures = {}));
+const questionnaireGuard = z.object({
+    project: z.nativeEnum(Project).optional(),
+    /** @deprecated Open-source options was for cloud preview use, no longer needed. Use default `Cloud` value for placeholder. */
+    deploymentType: z.nativeEnum(DeploymentType).optional().default(DeploymentType.Cloud),
+    /** @deprecated */
+    titles: z.array(z.nativeEnum(Title)).optional(),
+    companyName: z.string().optional(),
+    /** @deprecated */
+    companySize: z.nativeEnum(CompanySize).optional(),
+    /** @deprecated */
+    reasons: z.array(z.nativeEnum(Reason)).optional(),
+    stage: z.nativeEnum(Stage).optional(),
+    additionalFeatures: z.array(z.nativeEnum(AdditionalFeatures)).optional(),
+});
+export const userOnboardingDataGuard = z.object({
+    questionnaire: questionnaireGuard.optional(),
+    isOnboardingDone: z.boolean().optional(),
+});

package/lib/types/organization.d.ts

@@ -1,5 +1,5 @@
-import { z } from 'zod';
 import { type OrganizationRole, type Organization, type OrganizationInvitation } from '../db-entries/index.js';
+import { type ToZodObject } from '../utils/zod.js';
 import { type UserInfo, type FeaturedUser } from './user.js';
 /**
  * The simplified organization scope entity that is returned for some endpoints.
@@ -8,10 +8,22 @@ export type OrganizationScopeEntity = {
     id: string;
     name: string;
 };
+/**
+ * The simplified resource scope entity that is returned for some endpoints.
+ */
+export type ResourceScopeEntity = {
+    id: string;
+    name: string;
+    resource: {
+        id: string;
+        name: string;
+    };
+};
 export type OrganizationRoleWithScopes = OrganizationRole & {
     scopes: OrganizationScopeEntity[];
+    resourceScopes: ResourceScopeEntity[];
 };
-export declare const organizationRoleWithScopesGuard: z.ZodType<OrganizationRoleWithScopes>;
+export declare const organizationRoleWithScopesGuard: ToZodObject<OrganizationRoleWithScopes>;
 /**
  * The simplified organization role entity that is returned in the `roles` field
  * of the organization.
@@ -28,7 +40,7 @@ export type OrganizationWithRoles = Organization & {
     /** The roles of the current member of the organization. */
     organizationRoles: OrganizationRoleEntity[];
 };
-export declare const organizationWithOrganizationRolesGuard: z.ZodType<OrganizationWithRoles>;
+export declare const organizationWithOrganizationRolesGuard: ToZodObject<OrganizationWithRoles>;
 /**
  * The user entity with the `organizationRoles` field that contains the roles of
  * the user in a specific organization.
@@ -37,7 +49,7 @@ export type UserWithOrganizationRoles = UserInfo & {
     /** The roles of the user in a specific organization. */
     organizationRoles: OrganizationRoleEntity[];
 };
-export declare const userWithOrganizationRolesGuard: z.ZodType<UserWithOrganizationRoles>;
+export declare const userWithOrganizationRolesGuard: ToZodObject<UserWithOrganizationRoles>;
 /**
  * The organization entity with optional `usersCount` and `featuredUsers` fields.
  * They are useful for displaying the organization list in the frontend.
@@ -54,4 +66,4 @@ export type OrganizationWithFeatured = Organization & {
 export type OrganizationInvitationEntity = OrganizationInvitation & {
     organizationRoles: OrganizationRoleEntity[];
 };
-export declare const organizationInvitationEntityGuard: z.ZodType<OrganizationInvitationEntity>;
+export declare const organizationInvitationEntityGuard: ToZodObject<OrganizationInvitationEntity>;

package/lib/types/organization.js

@@ -8,6 +8,16 @@ export const organizationRoleWithScopesGuard = OrganizationRoles.guard.extend({
         name: z.string(),
     })
         .array(),
+    resourceScopes: z
+        .object({
+        id: z.string(),
+        name: z.string(),
+        resource: z.object({
+            id: z.string(),
+            name: z.string(),
+        }),
+    })
+        .array(),
 });
 const organizationRoleEntityGuard = z.object({
     id: z.string(),

package/lib/types/scope.d.ts

@@ -4,7 +4,7 @@ export declare const scopeResponseGuard: z.ZodObject<{
     id: z.ZodType<string, z.ZodTypeDef, string>;
     tenantId: z.ZodType<string, z.ZodTypeDef, string>;
     createdAt: z.ZodType<number, z.ZodTypeDef, number>;
-    description: z.ZodType<string, z.ZodTypeDef, string>;
+    description: z.ZodType<string | null, z.ZodTypeDef, string | null>;
     resourceId: z.ZodType<string, z.ZodTypeDef, string>;
     resource: import("../index.js").Guard<import("../db-entries/resource.js").Resource>;
 }, "strip", z.ZodTypeAny, {
@@ -12,7 +12,7 @@ export declare const scopeResponseGuard: z.ZodObject<{
     id: string;
     tenantId: string;
     createdAt: number;
-    description: string;
+    description: string | null;
     resource: import("../db-entries/resource.js").Resource;
     resourceId: string;
 }, {
@@ -20,7 +20,7 @@ export declare const scopeResponseGuard: z.ZodObject<{
     id: string;
     tenantId: string;
     createdAt: number;
-    description: string;
+    description: string | null;
     resource: import("../db-entries/resource.js").Resource;
     resourceId: string;
 }>;

package/lib/types/service-log.d.ts

@@ -1,4 +1,5 @@
 export declare enum ServiceLogType {
     SendEmail = "sendEmail",
-    SendSms = "sendSms"
+    SendSms = "sendSms",
+    FetchCustomJwt = "fetchCustomJwt"
 }

package/lib/types/service-log.js

@@ -2,4 +2,5 @@ export var ServiceLogType;
 (function (ServiceLogType) {
     ServiceLogType["SendEmail"] = "sendEmail";
     ServiceLogType["SendSms"] = "sendSms";
+    ServiceLogType["FetchCustomJwt"] = "fetchCustomJwt";
 })(ServiceLogType || (ServiceLogType = {}));