@stackframe/stack-shared 2.5.2 → 2.5.4

package/CHANGELOG.md

@@ -1,5 +1,21 @@
 # @stackframe/stack-shared
 
+## 2.5.4
+
+### Patch Changes
+
+- Backend rework
+- Updated dependencies
+  - @stackframe/stack-sc@2.5.4
+
+## 2.5.3
+
+### Patch Changes
+
+- Bugfixes
+- Updated dependencies
+  - @stackframe/stack-sc@2.5.3
+
 ## 2.5.2
 
 ### Patch Changes

package/dist/crud.d.ts

@@ -2,7 +2,9 @@ import * as yup from 'yup';
 import { NullishCoalesce } from './utils/types';
 export type AccessType = "client" | "server" | "admin";
 export type CrudOperation = "create" | "read" | "update" | "delete";
+export type CrudlOperation = "create" | "read" | "update" | "delete" | "list";
 export type AccessTypeXCrudOperation = `${AccessType}${Capitalize<CrudOperation>}`;
+export type AccessTypeXCrudlOperation = `${AccessType}${Capitalize<CrudlOperation>}`;
 declare module 'yup' {
     interface CustomSchemaMetadata {
         openapiField?: {
@@ -22,7 +24,7 @@ export type EndpointDocumentation = ({
 } & Partial<ShownEndpointDocumentation>) | ({
     hidden?: boolean;
 } & ShownEndpointDocumentation);
-type InnerCrudSchema<CreateSchema extends yup.Schema<any> | undefined = yup.Schema<any> | undefined, ReadSchema extends yup.Schema<any> | undefined = yup.Schema<any> | undefined, UpdateSchema extends yup.Schema<any> | undefined = yup.Schema<any> | undefined, DeleteSchema extends yup.Schema<any> | undefined = yup.Schema<any> | undefined> = {
+type InnerCrudSchema<CreateSchema extends yup.AnySchema | undefined = yup.AnySchema | undefined, ReadSchema extends yup.AnySchema | undefined = yup.AnySchema | undefined, UpdateSchema extends yup.AnySchema | undefined = yup.AnySchema | undefined, DeleteSchema extends yup.AnySchema | undefined = yup.AnySchema | undefined> = {
     createSchema: CreateSchema;
     createDocs: EndpointDocumentation | undefined;
     readSchema: ReadSchema;
@@ -43,7 +45,7 @@ export type CrudSchema<ClientSchema extends InnerCrudSchema = InnerCrudSchema, S
     hasDelete: boolean;
 };
 export type CrudSchemaCreationOptions = {
-    [K in AccessTypeXCrudOperation as `${K}Schema`]?: yup.Schema<any>;
+    [K in AccessTypeXCrudOperation as `${K}Schema`]?: yup.AnySchema;
 };
 type FillInOptionalsPrepareStep<O extends CrudSchemaCreationOptions> = {
     [K in keyof Required<CrudSchemaCreationOptions>]: K extends keyof O ? O[K] : undefined;
@@ -73,6 +75,11 @@ type InnerCrudTypeOf<S extends InnerCrudSchema> = (S['createSchema'] extends {}
     Update: yup.InferType<S['updateSchema']>;
 } : {}) & (S['deleteSchema'] extends {} ? {
     Delete: yup.InferType<S['deleteSchema']>;
+} : {}) & (S['readSchema'] extends {} ? {
+    List: {
+        items: yup.InferType<S['readSchema']>[];
+        is_paginated: boolean;
+    };
 } : {});
 export type CrudTypeOf<S extends CrudSchema> = {
     Client: InnerCrudTypeOf<S['client']>;
@@ -80,7 +87,7 @@ export type CrudTypeOf<S extends CrudSchema> = {
     Admin: InnerCrudTypeOf<S['admin']>;
 };
 type CrudDocsCreationOptions<SO extends CrudSchemaCreationOptions> = {
-    [X in AccessTypeXCrudOperation as (X extends `${infer A}Read` ? X | `${A}List` : X)]?: EndpointDocumentation;
+    [X in AccessTypeXCrudlOperation]?: EndpointDocumentation;
 };
 export declare function createCrud<SO extends CrudSchemaCreationOptions>(options: SO & {
     docs?: CrudDocsCreationOptions<SO>;

package/dist/helpers/production-mode.d.ts

@@ -0,0 +1,6 @@
+import { ProjectsCrud } from "../interface/crud/projects";
+export type ProductionModeError = {
+    message: string;
+    relativeFixUrl: `/${string}`;
+};
+export declare function getProductionModeErrors(project: ProjectsCrud["Admin"]["Read"]): ProductionModeError[];

package/dist/helpers/production-mode.js

@@ -0,0 +1,43 @@
+import { StackAssertionError } from "../utils/errors";
+import { isLocalhost } from "../utils/urls";
+export function getProductionModeErrors(project) {
+    const errors = [];
+    const domainsFixUrl = `/projects/${project.id}/domains`;
+    if (project.config.allow_localhost) {
+        errors.push({
+            message: "Localhost is not allowed in production mode, turn off 'Allow localhost' in project settings",
+            relativeFixUrl: domainsFixUrl,
+        });
+    }
+    for (const { domain } of project.config.domains) {
+        let url;
+        try {
+            url = new URL(domain);
+        }
+        catch (e) {
+            throw new StackAssertionError("Domain was somehow not a valid URL; we should've caught this when setting the domain in the first place", {
+                domain,
+                projectId: project
+            });
+        }
+        if (isLocalhost(url)) {
+            errors.push({
+                message: "Localhost domains are not allowed to be trusted in production mode: " + domain,
+                relativeFixUrl: domainsFixUrl,
+            });
+        }
+        else if (url.hostname.match(/^\d+(\.\d+)*$/)) {
+            errors.push({
+                message: "Direct IPs are not valid for trusted domains in production mode: " + domain,
+                relativeFixUrl: domainsFixUrl,
+            });
+        }
+        else if (url.protocol !== "https:") {
+            errors.push({
+                message: "Trusted domains should be HTTPS: " + domain,
+                relativeFixUrl: domainsFixUrl,
+            });
+        }
+    }
+    return errors;
+}

package/dist/index.d.ts

@@ -1,4 +1,4 @@
-export { StackClientInterface, UserJson as UserJson, ClientProjectJson, ProjectJson, OAuthProviderConfigJson, getProductionModeErrors, } from "./interface/clientInterface";
-export { StackServerInterface, ServerUserJson, } from "./interface/serverInterface";
-export { StackAdminInterface, ApiKeySetBaseJson, ApiKeySetFirstViewJson, ApiKeySetJson, } from "./interface/adminInterface";
-export { KnownError, KnownErrors, } from "./known-errors";
+export { StackAdminInterface } from "./interface/adminInterface";
+export { StackClientInterface } from "./interface/clientInterface";
+export { StackServerInterface } from "./interface/serverInterface";
+export { KnownError, KnownErrors } from "./known-errors";

package/dist/index.js

@@ -1,4 +1,4 @@
-export { StackClientInterface, getProductionModeErrors, } from "./interface/clientInterface";
-export { StackServerInterface, } from "./interface/serverInterface";
-export { StackAdminInterface, } from "./interface/adminInterface";
-export { KnownError, KnownErrors, } from "./known-errors";
+export { StackAdminInterface } from "./interface/adminInterface";
+export { StackClientInterface } from "./interface/clientInterface";
+export { StackServerInterface } from "./interface/serverInterface";
+export { KnownError, KnownErrors } from "./known-errors";

package/dist/interface/adminInterface.d.ts

@@ -1,69 +1,25 @@
-import { ServerAuthApplicationOptions, StackServerInterface } from "./serverInterface";
-import { EmailConfigJson, ProjectJson, SharedProvider, StandardProvider } from "./clientInterface";
 import { InternalSession } from "../sessions";
-export type AdminAuthApplicationOptions = Readonly<ServerAuthApplicationOptions & ({
+import { ApiKeysCrud } from "./crud/api-keys";
+import { EmailTemplateCrud, EmailTemplateType } from "./crud/email-templates";
+import { ProjectsCrud } from "./crud/projects";
+import { TeamPermissionDefinitionsCrud } from "./crud/team-permissions";
+import { ServerAuthApplicationOptions, StackServerInterface } from "./serverInterface";
+export type AdminAuthApplicationOptions = ServerAuthApplicationOptions & ({
     superSecretAdminKey: string;
 } | {
     projectOwnerSession: InternalSession;
-})>;
-export type OAuthProviderUpdateOptions = {
-    id: string;
-    enabled: boolean;
-} & ({
-    type: SharedProvider;
-} | {
-    type: StandardProvider;
-    clientId: string;
-    clientSecret: string;
 });
-export type ProjectUpdateOptions = {
-    displayName?: string;
-    description?: string;
-    isProductionMode?: boolean;
-    config?: {
-        domains?: {
-            domain: string;
-            handlerPath: string;
-        }[];
-        oauthProviders?: OAuthProviderUpdateOptions[];
-        credentialEnabled?: boolean;
-        magicLinkEnabled?: boolean;
-        allowLocalhost?: boolean;
-        createTeamOnSignUp?: boolean;
-        emailConfig?: EmailConfigJson;
-        teamCreatorDefaultPermissionIds?: string[];
-        teamMemberDefaultPermissionIds?: string[];
-    };
-};
-export type ApiKeySetBaseJson = {
-    id: string;
+export type ApiKeyCreateCrudRequest = {
+    has_publishable_client_key: boolean;
+    has_secret_server_key: boolean;
+    has_super_secret_admin_key: boolean;
+    expires_at_millis: number;
     description: string;
-    expiresAtMillis: number;
-    manuallyRevokedAtMillis: number | null;
-    createdAtMillis: number;
 };
-export type ApiKeySetFirstViewJson = ApiKeySetBaseJson & {
-    publishableClientKey?: string;
-    secretServerKey?: string;
-    superSecretAdminKey?: string;
-};
-export type ApiKeySetJson = ApiKeySetBaseJson & {
-    publishableClientKey: null | {
-        lastFour: string;
-    };
-    secretServerKey: null | {
-        lastFour: string;
-    };
-    superSecretAdminKey: null | {
-        lastFour: string;
-    };
-};
-export type ApiKeySetCreateOptions = {
-    hasPublishableClientKey: boolean;
-    hasSecretServerKey: boolean;
-    hasSuperSecretAdminKey: boolean;
-    expiresAt: Date;
-    description: string;
+export type ApiKeyCreateCrudResponse = ApiKeysCrud["Admin"]["Read"] & {
+    publishable_client_key?: string;
+    secret_server_key?: string;
+    super_secret_admin_key?: string;
 };
 export declare class StackAdminInterface extends StackServerInterface {
     readonly options: AdminAuthApplicationOptions;
@@ -74,12 +30,17 @@ export declare class StackAdminInterface extends StackServerInterface {
             refreshToken: import("../sessions").RefreshToken | null;
         } | null;
     }>;
-    getProject(options?: {
-        showDisabledOAuth?: boolean;
-    }): Promise<ProjectJson>;
-    updateProject(update: ProjectUpdateOptions): Promise<ProjectJson>;
-    createApiKeySet(options: ApiKeySetCreateOptions): Promise<ApiKeySetFirstViewJson>;
-    listApiKeySets(): Promise<ApiKeySetJson[]>;
-    revokeApiKeySetById(id: string): Promise<void>;
-    getApiKeySet(id: string, session: InternalSession): Promise<ApiKeySetJson>;
+    getProject(): Promise<ProjectsCrud["Admin"]["Read"]>;
+    updateProject(update: ProjectsCrud["Admin"]["Update"]): Promise<ProjectsCrud["Admin"]["Read"]>;
+    createApiKey(options: ApiKeyCreateCrudRequest): Promise<ApiKeyCreateCrudResponse>;
+    listApiKeys(): Promise<ApiKeysCrud["Admin"]["Read"][]>;
+    revokeApiKeyById(id: string): Promise<void>;
+    getApiKey(id: string, session: InternalSession): Promise<ApiKeysCrud["Admin"]["Read"]>;
+    listEmailTemplates(): Promise<EmailTemplateCrud['Admin']['Read'][]>;
+    updateEmailTemplate(type: EmailTemplateType, data: EmailTemplateCrud['Admin']['Update']): Promise<EmailTemplateCrud['Admin']['Read']>;
+    resetEmailTemplate(type: EmailTemplateType): Promise<void>;
+    listPermissionDefinitions(): Promise<TeamPermissionDefinitionsCrud['Admin']['Read'][]>;
+    createPermissionDefinition(data: TeamPermissionDefinitionsCrud['Admin']['Create']): Promise<TeamPermissionDefinitionsCrud['Admin']['Read']>;
+    updatePermissionDefinition(permissionId: string, data: TeamPermissionDefinitionsCrud['Admin']['Update']): Promise<TeamPermissionDefinitionsCrud['Admin']['Read']>;
+    deletePermissionDefinition(permissionId: string): Promise<void>;
 }

package/dist/interface/adminInterface.js

@@ -1,6 +1,5 @@
 import { StackServerInterface } from "./serverInterface";
 export class StackAdminInterface extends StackServerInterface {
-    options;
     constructor(options) {
         super(options);
         this.options = options;
@@ -14,19 +13,15 @@ export class StackAdminInterface extends StackServerInterface {
             },
         }, session, requestType);
     }
-    async getProject(options) {
-        const response = await this.sendAdminRequest("/projects/" + encodeURIComponent(this.projectId), {
-            method: "POST",
-            headers: {
-                "content-type": "application/json",
-            },
-            body: JSON.stringify(options ?? {}),
+    async getProject() {
+        const response = await this.sendAdminRequest("/projects/current", {
+            method: "GET",
         }, null);
         return await response.json();
     }
     async updateProject(update) {
-        const response = await this.sendAdminRequest("/projects/" + encodeURIComponent(this.projectId), {
-            method: "PUT",
+        const response = await this.sendAdminRequest("/projects/current", {
+            method: "PATCH",
             headers: {
                 "content-type": "application/json",
             },
@@ -34,8 +29,8 @@ export class StackAdminInterface extends StackServerInterface {
         }, null);
         return await response.json();
     }
-    async createApiKeySet(options) {
-        const response = await this.sendServerRequest("/api-keys", {
+    async createApiKey(options) {
+        const response = await this.sendServerRequest("/internal/api-keys", {
             method: "POST",
             headers: {
                 "content-type": "application/json",
@@ -44,24 +39,70 @@ export class StackAdminInterface extends StackServerInterface {
         }, null);
         return await response.json();
     }
-    async listApiKeySets() {
-        const response = await this.sendAdminRequest("/api-keys", {}, null);
-        const json = await response.json();
-        return json.map((k) => k);
+    async listApiKeys() {
+        const response = await this.sendAdminRequest("/internal/api-keys", {}, null);
+        const result = await response.json();
+        return result.items;
     }
-    async revokeApiKeySetById(id) {
-        await this.sendAdminRequest(`/api-keys/${id}`, {
-            method: "PUT",
+    async revokeApiKeyById(id) {
+        await this.sendAdminRequest(`/internal/api-keys/${id}`, {
+            method: "PATCH",
             headers: {
                 "content-type": "application/json",
             },
             body: JSON.stringify({
-                revoke: true,
+                revoked: true,
             }),
         }, null);
     }
-    async getApiKeySet(id, session) {
-        const response = await this.sendAdminRequest(`/api-keys/${id}`, {}, session);
+    async getApiKey(id, session) {
+        const response = await this.sendAdminRequest(`/internal/api-keys/${id}`, {}, session);
+        return await response.json();
+    }
+    async listEmailTemplates() {
+        const response = await this.sendAdminRequest(`/email-templates`, {}, null);
+        const result = await response.json();
+        return result.items;
+    }
+    async updateEmailTemplate(type, data) {
+        const result = await this.sendAdminRequest(`/email-templates/${type}`, {
+            method: "PATCH",
+            headers: {
+                "content-type": "application/json",
+            },
+            body: JSON.stringify(data),
+        }, null);
+        return await result.json();
+    }
+    async resetEmailTemplate(type) {
+        await this.sendAdminRequest(`/email-templates/${type}`, { method: "DELETE" }, null);
+    }
+    async listPermissionDefinitions() {
+        const response = await this.sendAdminRequest(`/team-permission-definitions`, {}, null);
+        const result = await response.json();
+        return result.items;
+    }
+    async createPermissionDefinition(data) {
+        const response = await this.sendAdminRequest("/team-permission-definitions", {
+            method: "POST",
+            headers: {
+                "content-type": "application/json",
+            },
+            body: JSON.stringify(data),
+        }, null);
+        return await response.json();
+    }
+    async updatePermissionDefinition(permissionId, data) {
+        const response = await this.sendAdminRequest(`/team-permission-definitions/${permissionId}`, {
+            method: "PATCH",
+            headers: {
+                "content-type": "application/json",
+            },
+            body: JSON.stringify(data),
+        }, null);
         return await response.json();
     }
+    async deletePermissionDefinition(permissionId) {
+        await this.sendAdminRequest(`/team-permission-definitions/${permissionId}`, { method: "DELETE" }, null);
+    }
 }

package/dist/interface/clientInterface.d.ts

@@ -1,42 +1,11 @@
-import { Result } from "../utils/results";
-import { ReadonlyJson } from '../utils/json';
 import { KnownErrors } from '../known-errors';
-import { ProjectUpdateOptions } from './adminInterface';
-import { AccessToken, RefreshToken, InternalSession } from '../sessions';
-type UserCustomizableJson = {
-    displayName: string | null;
-    clientMetadata: ReadonlyJson;
-    selectedTeamId: string | null;
-};
-export type UserJson = UserCustomizableJson & {
-    projectId: string;
-    id: string;
-    primaryEmail: string | null;
-    primaryEmailVerified: boolean;
-    displayName: string | null;
-    clientMetadata: ReadonlyJson;
-    profileImageUrl: string | null;
-    signedUpAtMillis: number;
-    /**
-     * not used anymore, for backwards compatibility
-     */
-    authMethod: "credential" | "oauth";
-    hasPassword: boolean;
-    authWithEmail: boolean;
-    oauthProviders: string[];
-    selectedTeamId: string | null;
-    selectedTeam: TeamJson | null;
-};
-export type UserUpdateJson = Partial<UserCustomizableJson>;
-export type ClientProjectJson = {
-    id: string;
-    credentialEnabled: boolean;
-    magicLinkEnabled: boolean;
-    oauthProviders: {
-        id: string;
-        enabled: boolean;
-    }[];
-};
+import { AccessToken, InternalSession, RefreshToken } from '../sessions';
+import { ReadonlyJson } from '../utils/json';
+import { Result } from "../utils/results";
+import { CurrentUserCrud } from './crud/current-user';
+import { InternalProjectsCrud, ProjectsCrud } from './crud/projects';
+import { TeamPermissionsCrud } from './crud/team-permissions';
+import { TeamsCrud } from './crud/teams';
 export type ClientInterfaceOptions = {
     clientVersion: string;
     baseUrl: string;
@@ -52,82 +21,6 @@ export type StandardProvider = "github" | "facebook" | "google" | "microsoft" |
 export declare const standardProviders: readonly ["github", "facebook", "google", "microsoft", "spotify"];
 export declare function toStandardProvider(provider: SharedProvider | StandardProvider): StandardProvider;
 export declare function toSharedProvider(provider: SharedProvider | StandardProvider): SharedProvider;
-export type ProjectJson = {
-    id: string;
-    displayName: string;
-    description?: string;
-    createdAtMillis: number;
-    userCount: number;
-    isProductionMode: boolean;
-    evaluatedConfig: {
-        id: string;
-        allowLocalhost: boolean;
-        credentialEnabled: boolean;
-        magicLinkEnabled: boolean;
-        oauthProviders: OAuthProviderConfigJson[];
-        emailConfig?: EmailConfigJson;
-        domains: DomainConfigJson[];
-        createTeamOnSignUp: boolean;
-        teamCreatorDefaultPermissions: PermissionDefinitionJson[];
-        teamMemberDefaultPermissions: PermissionDefinitionJson[];
-    };
-};
-export type OAuthProviderConfigJson = {
-    id: string;
-    enabled: boolean;
-} & ({
-    type: SharedProvider;
-} | {
-    type: StandardProvider;
-    clientId: string;
-    clientSecret: string;
-});
-export type EmailConfigJson = ({
-    type: "standard";
-    senderName: string;
-    senderEmail: string;
-    host: string;
-    port: number;
-    username: string;
-    password: string;
-} | {
-    type: "shared";
-});
-export type DomainConfigJson = {
-    domain: string;
-    handlerPath: string;
-};
-export type ProductionModeError = {
-    errorMessage: string;
-    fixUrlRelative: string;
-};
-export type OrglikeJson = {
-    id: string;
-    displayName: string;
-    profileImageUrl?: string;
-    createdAtMillis: number;
-};
-export type TeamJson = OrglikeJson;
-export type OrganizationJson = OrglikeJson;
-export type OrglikeCustomizableJson = Pick<OrglikeJson, "displayName" | "profileImageUrl">;
-export type TeamCustomizableJson = OrglikeCustomizableJson;
-export type TeamMemberJson = {
-    userId: string;
-    teamId: string;
-    displayName: string | null;
-};
-export type PermissionDefinitionScopeJson = {
-    type: "global";
-} | {
-    type: "any-team";
-} | {
-    type: "specific-team";
-    teamId: string;
-};
-export type PermissionDefinitionJson = {
-    id: string;
-    scope: PermissionDefinitionScopeJson;
-};
 export declare class StackClientInterface {
     readonly options: ClientInterfaceOptions;
     constructor(options: ClientInterfaceOptions);
@@ -152,9 +45,9 @@ export declare class StackClientInterface {
     checkFeatureSupport(options: {
         featureName?: string;
     } & ReadonlyJson): Promise<never>;
-    sendForgotPasswordEmail(email: string, redirectUrl: string): Promise<KnownErrors["UserNotFound"] | undefined>;
+    sendForgotPasswordEmail(email: string, callbackUrl: string): Promise<KnownErrors["UserNotFound"] | undefined>;
     sendVerificationEmail(emailVerificationRedirectUrl: string, session: InternalSession): Promise<KnownErrors["EmailAlreadyVerified"] | undefined>;
-    sendMagicLinkEmail(email: string, redirectUrl: string): Promise<KnownErrors["RedirectUrlNotWhitelisted"] | undefined>;
+    sendMagicLinkEmail(email: string, callbackUrl: string): Promise<KnownErrors["RedirectUrlNotWhitelisted"] | undefined>;
     resetPassword(options: {
         code: string;
     } & ({
@@ -165,7 +58,7 @@ export declare class StackClientInterface {
     updatePassword(options: {
         oldPassword: string;
         newPassword: string;
-    }, session: InternalSession): Promise<KnownErrors["PasswordMismatch"] | KnownErrors["PasswordRequirementsNotMet"] | undefined>;
+    }, session: InternalSession): Promise<KnownErrors["PasswordConfirmationMismatch"] | KnownErrors["PasswordRequirementsNotMet"] | undefined>;
     verifyPasswordResetCode(code: string): Promise<KnownErrors["VerificationCodeError"] | undefined>;
     verifyEmail(code: string): Promise<KnownErrors["VerificationCodeError"] | undefined>;
     signInWithCredential(email: string, password: string, session: InternalSession): Promise<KnownErrors["EmailPasswordMismatch"] | {
@@ -176,7 +69,7 @@ export declare class StackClientInterface {
         accessToken: string;
         refreshToken: string;
     }>;
-    signInWithMagicLink(code: string, session: InternalSession): Promise<KnownErrors["VerificationCodeError"] | {
+    signInWithMagicLink(code: string): Promise<KnownErrors["VerificationCodeError"] | {
         newUser: boolean;
         accessToken: string;
         refreshToken: string;
@@ -208,23 +101,18 @@ export declare class StackClientInterface {
         refreshToken: string;
     }>;
     signOut(session: InternalSession): Promise<void>;
-    getClientUserByToken(tokenStore: InternalSession): Promise<Result<UserJson>>;
-    listClientUserTeamPermissions(options: {
+    getClientUserByToken(session: InternalSession): Promise<CurrentUserCrud["Client"]["Read"] | null>;
+    listCurrentUserTeamPermissions(options: {
         teamId: string;
-        type: 'global' | 'team';
-        direct: boolean;
-    }, session: InternalSession): Promise<PermissionDefinitionJson[]>;
-    listClientUserTeams(session: InternalSession): Promise<TeamJson[]>;
-    getClientProject(): Promise<Result<ClientProjectJson>>;
-    setClientUserCustomizableData(update: UserUpdateJson, session: InternalSession): Promise<void>;
-    listProjects(session: InternalSession): Promise<ProjectJson[]>;
-    createProject(project: ProjectUpdateOptions & {
-        displayName: string;
-    }, session: InternalSession): Promise<ProjectJson>;
+        recursive: boolean;
+    }, session: InternalSession): Promise<TeamPermissionsCrud['Client']['Read'][]>;
+    listCurrentUserTeams(session: InternalSession): Promise<TeamsCrud["Client"]["Read"][]>;
+    getClientProject(): Promise<Result<ProjectsCrud['Client']['Read'], KnownErrors["ProjectNotFound"]>>;
+    updateClientUser(update: CurrentUserCrud["Client"]["Update"], session: InternalSession): Promise<void>;
+    listProjects(session: InternalSession): Promise<InternalProjectsCrud['Client']['Read'][]>;
+    createProject(project: InternalProjectsCrud['Client']['Create'], session: InternalSession): Promise<InternalProjectsCrud['Client']['Read']>;
     getAccessToken(provider: string, scope: string, session: InternalSession): Promise<{
         accessToken: string;
     }>;
-    createTeamForCurrentUser(data: TeamCustomizableJson, session: InternalSession): Promise<TeamJson>;
+    createTeamForCurrentUser(data: TeamsCrud['Client']['Create'], session: InternalSession): Promise<TeamsCrud['Client']['Read']>;
 }
-export declare function getProductionModeErrors(project: ProjectJson): ProductionModeError[];
-export {};