@taico/client 0.2.17 → 0.3.0

package/dist/contracts/types.d.ts

@@ -381,6 +381,92 @@ export interface paths {
         patch?: never;
         trace?: never;
     };
+    "/api/v1/auth/users": {
+        parameters: {
+            query?: never;
+            header?: never;
+            path?: never;
+            cookie?: never;
+        };
+        /** List human users for admin user management */
+        get: operations["WebAuthController_listUsers"];
+        put?: never;
+        /** Create an invited human user */
+        post: operations["WebAuthController_createUser"];
+        delete?: never;
+        options?: never;
+        head?: never;
+        patch?: never;
+        trace?: never;
+    };
+    "/api/v1/auth/users/{userId}/reset-password": {
+        parameters: {
+            query?: never;
+            header?: never;
+            path?: never;
+            cookie?: never;
+        };
+        get?: never;
+        put?: never;
+        /** Reset a managed user password so they can set a new one */
+        post: operations["WebAuthController_resetUserPassword"];
+        delete?: never;
+        options?: never;
+        head?: never;
+        patch?: never;
+        trace?: never;
+    };
+    "/api/v1/auth/users/{userId}": {
+        parameters: {
+            query?: never;
+            header?: never;
+            path?: never;
+            cookie?: never;
+        };
+        get?: never;
+        put?: never;
+        post?: never;
+        /** Deactivate a managed user */
+        delete: operations["WebAuthController_deleteUser"];
+        options?: never;
+        head?: never;
+        patch?: never;
+        trace?: never;
+    };
+    "/api/v1/auth/account-setup-status": {
+        parameters: {
+            query?: never;
+            header?: never;
+            path?: never;
+            cookie?: never;
+        };
+        get?: never;
+        put?: never;
+        /** Check whether an invited or reset account can be set up */
+        post: operations["WebAuthController_getAccountSetupStatus"];
+        delete?: never;
+        options?: never;
+        head?: never;
+        patch?: never;
+        trace?: never;
+    };
+    "/api/v1/auth/setup-account": {
+        parameters: {
+            query?: never;
+            header?: never;
+            path?: never;
+            cookie?: never;
+        };
+        get?: never;
+        put?: never;
+        /** Set up an invited or reset account and log in */
+        post: operations["WebAuthController_setupAccount"];
+        delete?: never;
+        options?: never;
+        head?: never;
+        patch?: never;
+        trace?: never;
+    };
     "/api/v1/auth/refresh": {
         parameters: {
             query?: never;
@@ -2749,6 +2835,85 @@ export interface components {
              */
             expiresIn: number;
         };
+        ManagedUserResponseDto: {
+            /** @description User ID */
+            id: string;
+            /** @description User email address */
+            email: string;
+            /** @description Display name from the associated human actor */
+            displayName: string;
+            /** @description Actor slug/username */
+            slug: string;
+            /** @description Actor ID associated with this user */
+            actorId: string;
+            /**
+             * @description User role
+             * @enum {string}
+             */
+            role: "admin" | "standard";
+            /** @description Whether this user can currently sign in */
+            isActive: boolean;
+            /** @description Whether this user still needs to set a password */
+            passwordSetupPending: boolean;
+            /**
+             * Format: date-time
+             * @description Creation timestamp
+             */
+            createdAt: string;
+            /**
+             * Format: date-time
+             * @description Last update timestamp
+             */
+            updatedAt: string;
+        };
+        CreateManagedUserRequestDto: {
+            /**
+             * @description Email address to invite
+             * @example user@example.com
+             */
+            email: string;
+            /**
+             * @description Role for the new user
+             * @example standard
+             * @enum {string}
+             */
+            role: "admin" | "standard";
+        };
+        AccountSetupStatusRequestDto: {
+            /**
+             * @description Email address to check
+             * @example user@example.com
+             */
+            email: string;
+        };
+        AccountSetupStatusResponseDto: {
+            /** @description Normalized email address */
+            email: string;
+            /** @description Whether an invited or reset account can be set up */
+            canSetup: boolean;
+        };
+        SetupManagedUserRequestDto: {
+            /**
+             * @description Invited or reset account email address
+             * @example user@example.com
+             */
+            email: string;
+            /**
+             * @description Display name for the user
+             * @example Jane User
+             */
+            displayName: string;
+            /**
+             * @description Slug/username for the user
+             * @example jane
+             */
+            slug: string;
+            /**
+             * @description New password for the account
+             * @example securepassword123
+             */
+            password: string;
+        };
         ChangePasswordRequestDto: {
             /**
              * @description Current password
@@ -3670,12 +3835,12 @@ export interface components {
              */
             page: number;
             /**
-             * @description Number of items per page
+             * @description Number of items per status per page when no status filter is provided
              * @example 20
              */
             limit: number;
             /**
-             * @description Total number of pages
+             * @description Total number of pages based on the largest matching status bucket
              * @example 3
              */
             totalPages: number;
@@ -6819,6 +6984,136 @@ export interface operations {
             };
         };
     };
+    WebAuthController_listUsers: {
+        parameters: {
+            query?: never;
+            header?: never;
+            path?: never;
+            cookie?: never;
+        };
+        requestBody?: never;
+        responses: {
+            200: {
+                headers: {
+                    [name: string]: unknown;
+                };
+                content: {
+                    "application/json": components["schemas"]["ManagedUserResponseDto"][];
+                };
+            };
+        };
+    };
+    WebAuthController_createUser: {
+        parameters: {
+            query?: never;
+            header?: never;
+            path?: never;
+            cookie?: never;
+        };
+        requestBody: {
+            content: {
+                "application/json": components["schemas"]["CreateManagedUserRequestDto"];
+            };
+        };
+        responses: {
+            201: {
+                headers: {
+                    [name: string]: unknown;
+                };
+                content: {
+                    "application/json": components["schemas"]["ManagedUserResponseDto"];
+                };
+            };
+        };
+    };
+    WebAuthController_resetUserPassword: {
+        parameters: {
+            query?: never;
+            header?: never;
+            path: {
+                userId: string;
+            };
+            cookie?: never;
+        };
+        requestBody?: never;
+        responses: {
+            200: {
+                headers: {
+                    [name: string]: unknown;
+                };
+                content: {
+                    "application/json": components["schemas"]["ManagedUserResponseDto"];
+                };
+            };
+        };
+    };
+    WebAuthController_deleteUser: {
+        parameters: {
+            query?: never;
+            header?: never;
+            path: {
+                userId: string;
+            };
+            cookie?: never;
+        };
+        requestBody?: never;
+        responses: {
+            200: {
+                headers: {
+                    [name: string]: unknown;
+                };
+                content: {
+                    "application/json": components["schemas"]["ManagedUserResponseDto"];
+                };
+            };
+        };
+    };
+    WebAuthController_getAccountSetupStatus: {
+        parameters: {
+            query?: never;
+            header?: never;
+            path?: never;
+            cookie?: never;
+        };
+        requestBody: {
+            content: {
+                "application/json": components["schemas"]["AccountSetupStatusRequestDto"];
+            };
+        };
+        responses: {
+            200: {
+                headers: {
+                    [name: string]: unknown;
+                };
+                content: {
+                    "application/json": components["schemas"]["AccountSetupStatusResponseDto"];
+                };
+            };
+        };
+    };
+    WebAuthController_setupAccount: {
+        parameters: {
+            query?: never;
+            header?: never;
+            path?: never;
+            cookie?: never;
+        };
+        requestBody: {
+            content: {
+                "application/json": components["schemas"]["SetupManagedUserRequestDto"];
+            };
+        };
+        responses: {
+            200: {
+                headers: {
+                    [name: string]: unknown;
+                };
+                content: {
+                    "application/json": components["schemas"]["LoginResponseDto"];
+                };
+            };
+        };
+    };
     WebAuthController_refresh: {
         parameters: {
             query?: never;

package/dist/src/v1/client/index.d.ts

@@ -2,6 +2,8 @@ export { ApiError } from './core/ApiError.js';
 export { CancelablePromise, CancelError } from './core/CancelablePromise.js';
 export { OpenAPI } from './core/OpenAPI.js';
 export type { OpenAPIConfig } from './core/OpenAPI.js';
+export type { AccountSetupStatusRequestDto } from './models/AccountSetupStatusRequestDto.js';
+export type { AccountSetupStatusResponseDto } from './models/AccountSetupStatusResponseDto.js';
 export type { ActiveTaskExecutionListResponseDto } from './models/ActiveTaskExecutionListResponseDto.js';
 export { ActiveTaskExecutionResponseDto } from './models/ActiveTaskExecutionResponseDto.js';
 export type { ActiveTaskExecutionTagSnapshotResponseDto } from './models/ActiveTaskExecutionTagSnapshotResponseDto.js';
@@ -51,6 +53,7 @@ export { CreateChatProviderDto } from './models/CreateChatProviderDto.js';
 export type { CreateCommentDto } from './models/CreateCommentDto.js';
 export type { CreateConnectionDto } from './models/CreateConnectionDto.js';
 export type { CreateInputRequestDto } from './models/CreateInputRequestDto.js';
+export { CreateManagedUserRequestDto } from './models/CreateManagedUserRequestDto.js';
 export type { CreateMappingDto } from './models/CreateMappingDto.js';
 export type { CreateProjectDto } from './models/CreateProjectDto.js';
 export type { CreateScheduledTaskDto } from './models/CreateScheduledTaskDto.js';
@@ -83,6 +86,7 @@ export type { JwksResponseDto } from './models/JwksResponseDto.js';
 export type { ListThreadMessagesResponseDto } from './models/ListThreadMessagesResponseDto.js';
 export type { LoginRequestDto } from './models/LoginRequestDto.js';
 export type { LoginResponseDto } from './models/LoginResponseDto.js';
+export { ManagedUserResponseDto } from './models/ManagedUserResponseDto.js';
 export type { MappingResponseDto } from './models/MappingResponseDto.js';
 export { McpFlowResponseDto } from './models/McpFlowResponseDto.js';
 export type { MetaTagResponseDto } from './models/MetaTagResponseDto.js';
@@ -107,6 +111,7 @@ export type { SecretValueResponseDto } from './models/SecretValueResponseDto.js'
 export type { ServerListResponseDto } from './models/ServerListResponseDto.js';
 export { ServerResponseDto } from './models/ServerResponseDto.js';
 export type { SetActiveChatProviderDto } from './models/SetActiveChatProviderDto.js';
+export type { SetupManagedUserRequestDto } from './models/SetupManagedUserRequestDto.js';
 export { StopActiveTaskExecutionDto } from './models/StopActiveTaskExecutionDto.js';
 export type { TagResponseDto } from './models/TagResponseDto.js';
 export type { TaskBlueprintListResponseDto } from './models/TaskBlueprintListResponseDto.js';

package/dist/src/v1/client/index.js

@@ -18,11 +18,13 @@ export { ClientRegistrationResponseDto } from './models/ClientRegistrationRespon
 export { ConnectionFlowResponseDto } from './models/ConnectionFlowResponseDto.js';
 export { CreateAgentDto } from './models/CreateAgentDto.js';
 export { CreateChatProviderDto } from './models/CreateChatProviderDto.js';
+export { CreateManagedUserRequestDto } from './models/CreateManagedUserRequestDto.js';
 export { CreateServerDto } from './models/CreateServerDto.js';
 export { GetConsentMetadataResponseDto } from './models/GetConsentMetadataResponseDto.js';
 export { GlobalSearchResultDto } from './models/GlobalSearchResultDto.js';
 export { IntrospectTokenRequestDto } from './models/IntrospectTokenRequestDto.js';
 export { IntrospectTokenResponseDto } from './models/IntrospectTokenResponseDto.js';
+export { ManagedUserResponseDto } from './models/ManagedUserResponseDto.js';
 export { McpFlowResponseDto } from './models/McpFlowResponseDto.js';
 export { PatchAgentDto } from './models/PatchAgentDto.js';
 export { RegisterClientDto } from './models/RegisterClientDto.js';

package/dist/src/v1/client/models/AccountSetupStatusRequestDto.d.ts

@@ -0,0 +1,6 @@
+export type AccountSetupStatusRequestDto = {
+    /**
+     * Email address to check
+     */
+    email: string;
+};

package/dist/src/v1/client/models/AccountSetupStatusRequestDto.js

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

package/dist/src/v1/client/models/AccountSetupStatusResponseDto.d.ts

@@ -0,0 +1,10 @@
+export type AccountSetupStatusResponseDto = {
+    /**
+     * Normalized email address
+     */
+    email: string;
+    /**
+     * Whether an invited or reset account can be set up
+     */
+    canSetup: boolean;
+};

package/dist/src/v1/client/models/AccountSetupStatusResponseDto.js

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

package/dist/src/v1/client/models/CreateManagedUserRequestDto.d.ts

@@ -0,0 +1,19 @@
+export type CreateManagedUserRequestDto = {
+    /**
+     * Email address to invite
+     */
+    email: string;
+    /**
+     * Role for the new user
+     */
+    role: CreateManagedUserRequestDto.role;
+};
+export declare namespace CreateManagedUserRequestDto {
+    /**
+     * Role for the new user
+     */
+    enum role {
+        ADMIN = "admin",
+        STANDARD = "standard"
+    }
+}

package/dist/src/v1/client/models/CreateManagedUserRequestDto.js

@@ -0,0 +1,11 @@
+export var CreateManagedUserRequestDto;
+(function (CreateManagedUserRequestDto) {
+    /**
+     * Role for the new user
+     */
+    let role;
+    (function (role) {
+        role["ADMIN"] = "admin";
+        role["STANDARD"] = "standard";
+    })(role = CreateManagedUserRequestDto.role || (CreateManagedUserRequestDto.role = {}));
+})(CreateManagedUserRequestDto || (CreateManagedUserRequestDto = {}));

package/dist/src/v1/client/models/ManagedUserResponseDto.d.ts

@@ -0,0 +1,51 @@
+export type ManagedUserResponseDto = {
+    /**
+     * User ID
+     */
+    id: string;
+    /**
+     * User email address
+     */
+    email: string;
+    /**
+     * Display name from the associated human actor
+     */
+    displayName: string;
+    /**
+     * Actor slug/username
+     */
+    slug: string;
+    /**
+     * Actor ID associated with this user
+     */
+    actorId: string;
+    /**
+     * User role
+     */
+    role: ManagedUserResponseDto.role;
+    /**
+     * Whether this user can currently sign in
+     */
+    isActive: boolean;
+    /**
+     * Whether this user still needs to set a password
+     */
+    passwordSetupPending: boolean;
+    /**
+     * Creation timestamp
+     */
+    createdAt: string;
+    /**
+     * Last update timestamp
+     */
+    updatedAt: string;
+};
+export declare namespace ManagedUserResponseDto {
+    /**
+     * User role
+     */
+    enum role {
+        ADMIN = "admin",
+        STANDARD = "standard"
+    }
+}

package/dist/src/v1/client/models/ManagedUserResponseDto.js

@@ -0,0 +1,11 @@
+export var ManagedUserResponseDto;
+(function (ManagedUserResponseDto) {
+    /**
+     * User role
+     */
+    let role;
+    (function (role) {
+        role["ADMIN"] = "admin";
+        role["STANDARD"] = "standard";
+    })(role = ManagedUserResponseDto.role || (ManagedUserResponseDto.role = {}));
+})(ManagedUserResponseDto || (ManagedUserResponseDto = {}));

package/dist/src/v1/client/models/SetupManagedUserRequestDto.d.ts

@@ -0,0 +1,18 @@
+export type SetupManagedUserRequestDto = {
+    /**
+     * Invited or reset account email address
+     */
+    email: string;
+    /**
+     * Display name for the user
+     */
+    displayName: string;
+    /**
+     * Slug/username for the user
+     */
+    slug: string;
+    /**
+     * New password for the account
+     */
+    password: string;
+};

package/dist/src/v1/client/models/SetupManagedUserRequestDto.js

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

package/dist/src/v1/client/models/TaskListResponseDto.d.ts

@@ -13,11 +13,11 @@ export type TaskListResponseDto = {
      */
     page: number;
     /**
-     * Number of items per page
+     * Number of items per status per page when no status filter is provided
      */
     limit: number;
     /**
-     * Total number of pages
+     * Total number of pages based on the largest matching status bucket
      */
     totalPages: number;
 };

package/dist/src/v1/client/services/WebAuthenticationService.d.ts

@@ -1,8 +1,13 @@
+import type { AccountSetupStatusRequestDto } from '../models/AccountSetupStatusRequestDto.js';
+import type { AccountSetupStatusResponseDto } from '../models/AccountSetupStatusResponseDto.js';
 import type { ChangePasswordRequestDto } from '../models/ChangePasswordRequestDto.js';
+import type { CreateManagedUserRequestDto } from '../models/CreateManagedUserRequestDto.js';
 import type { LoginRequestDto } from '../models/LoginRequestDto.js';
 import type { LoginResponseDto } from '../models/LoginResponseDto.js';
+import type { ManagedUserResponseDto } from '../models/ManagedUserResponseDto.js';
 import type { OnboardingRequestDto } from '../models/OnboardingRequestDto.js';
 import type { OnboardingStatusResponseDto } from '../models/OnboardingStatusResponseDto.js';
+import type { SetupManagedUserRequestDto } from '../models/SetupManagedUserRequestDto.js';
 import type { UserResponseDto } from '../models/UserResponseDto.js';
 import type { CancelablePromise } from '../core/CancelablePromise.js';
 import type { OpenAPIConfig } from '../core/OpenAPI.js';
@@ -14,6 +19,47 @@ export declare class WebAuthenticationService {
      * @throws ApiError
      */
     static webAuthControllerLogin(requestBody: LoginRequestDto, config?: OpenAPIConfig): CancelablePromise<LoginResponseDto>;
+    /**
+     * List human users for admin user management
+     * @returns ManagedUserResponseDto
+     * @throws ApiError
+     */
+    static webAuthControllerListUsers(config?: OpenAPIConfig): CancelablePromise<Array<ManagedUserResponseDto>>;
+    /**
+     * Create an invited human user
+     * @param requestBody
+     * @returns ManagedUserResponseDto
+     * @throws ApiError
+     */
+    static webAuthControllerCreateUser(requestBody: CreateManagedUserRequestDto, config?: OpenAPIConfig): CancelablePromise<ManagedUserResponseDto>;
+    /**
+     * Reset a managed user password so they can set a new one
+     * @param userId
+     * @returns ManagedUserResponseDto
+     * @throws ApiError
+     */
+    static webAuthControllerResetUserPassword(userId: string, config?: OpenAPIConfig): CancelablePromise<ManagedUserResponseDto>;
+    /**
+     * Deactivate a managed user
+     * @param userId
+     * @returns ManagedUserResponseDto
+     * @throws ApiError
+     */
+    static webAuthControllerDeleteUser(userId: string, config?: OpenAPIConfig): CancelablePromise<ManagedUserResponseDto>;
+    /**
+     * Check whether an invited or reset account can be set up
+     * @param requestBody
+     * @returns AccountSetupStatusResponseDto
+     * @throws ApiError
+     */
+    static webAuthControllerGetAccountSetupStatus(requestBody: AccountSetupStatusRequestDto, config?: OpenAPIConfig): CancelablePromise<AccountSetupStatusResponseDto>;
+    /**
+     * Set up an invited or reset account and log in
+     * @param requestBody
+     * @returns LoginResponseDto
+     * @throws ApiError
+     */
+    static webAuthControllerSetupAccount(requestBody: SetupManagedUserRequestDto, config?: OpenAPIConfig): CancelablePromise<LoginResponseDto>;
     /**
      * Refresh access token using refresh token
      * @returns LoginResponseDto Token refreshed successfully, new tokens set in cookies

package/dist/src/v1/client/services/WebAuthenticationService.js

@@ -18,6 +18,89 @@ export class WebAuthenticationService {
             },
         });
     }
+    /**
+     * List human users for admin user management
+     * @returns ManagedUserResponseDto
+     * @throws ApiError
+     */
+    static webAuthControllerListUsers(config = OpenAPI) {
+        return __request(config, {
+            method: 'GET',
+            url: '/api/v1/auth/users',
+        });
+    }
+    /**
+     * Create an invited human user
+     * @param requestBody
+     * @returns ManagedUserResponseDto
+     * @throws ApiError
+     */
+    static webAuthControllerCreateUser(requestBody, config = OpenAPI) {
+        return __request(config, {
+            method: 'POST',
+            url: '/api/v1/auth/users',
+            body: requestBody,
+            mediaType: 'application/json',
+        });
+    }
+    /**
+     * Reset a managed user password so they can set a new one
+     * @param userId
+     * @returns ManagedUserResponseDto
+     * @throws ApiError
+     */
+    static webAuthControllerResetUserPassword(userId, config = OpenAPI) {
+        return __request(config, {
+            method: 'POST',
+            url: '/api/v1/auth/users/{userId}/reset-password',
+            path: {
+                'userId': userId,
+            },
+        });
+    }
+    /**
+     * Deactivate a managed user
+     * @param userId
+     * @returns ManagedUserResponseDto
+     * @throws ApiError
+     */
+    static webAuthControllerDeleteUser(userId, config = OpenAPI) {
+        return __request(config, {
+            method: 'DELETE',
+            url: '/api/v1/auth/users/{userId}',
+            path: {
+                'userId': userId,
+            },
+        });
+    }
+    /**
+     * Check whether an invited or reset account can be set up
+     * @param requestBody
+     * @returns AccountSetupStatusResponseDto
+     * @throws ApiError
+     */
+    static webAuthControllerGetAccountSetupStatus(requestBody, config = OpenAPI) {
+        return __request(config, {
+            method: 'POST',
+            url: '/api/v1/auth/account-setup-status',
+            body: requestBody,
+            mediaType: 'application/json',
+        });
+    }
+    /**
+     * Set up an invited or reset account and log in
+     * @param requestBody
+     * @returns LoginResponseDto
+     * @throws ApiError
+     */
+    static webAuthControllerSetupAccount(requestBody, config = OpenAPI) {
+        return __request(config, {
+            method: 'POST',
+            url: '/api/v1/auth/setup-account',
+            body: requestBody,
+            mediaType: 'application/json',
+        });
+    }
     /**
      * Refresh access token using refresh token
      * @returns LoginResponseDto Token refreshed successfully, new tokens set in cookies

package/dist/src/v2/types.d.ts

@@ -158,6 +158,35 @@ export interface LoginResponseDto {
     user: UserResponseDto;
     expiresIn: number;
 }
+export interface ManagedUserResponseDto {
+    id: string;
+    email: string;
+    displayName: string;
+    slug: string;
+    actorId: string;
+    role: 'admin' | 'standard';
+    isActive: boolean;
+    passwordSetupPending: boolean;
+    createdAt: string;
+    updatedAt: string;
+}
+export interface CreateManagedUserRequestDto {
+    email: string;
+    role: 'admin' | 'standard';
+}
+export interface AccountSetupStatusRequestDto {
+    email: string;
+}
+export interface AccountSetupStatusResponseDto {
+    email: string;
+    canSetup: boolean;
+}
+export interface SetupManagedUserRequestDto {
+    email: string;
+    displayName: string;
+    slug: string;
+    password: string;
+}
 export interface ChangePasswordRequestDto {
     currentPassword: string;
     newPassword: string;

package/dist/src/v2/web-authentication-resource.d.ts

@@ -1,5 +1,5 @@
 import { BaseClient, ClientConfig } from './base-client.js';
-import type { ChangePasswordRequestDto, LoginRequestDto, LoginResponseDto, OnboardingRequestDto, OnboardingStatusResponseDto, UserResponseDto } from './types.js';
+import type { AccountSetupStatusRequestDto, AccountSetupStatusResponseDto, ChangePasswordRequestDto, CreateManagedUserRequestDto, LoginRequestDto, LoginResponseDto, ManagedUserResponseDto, OnboardingRequestDto, OnboardingStatusResponseDto, SetupManagedUserRequestDto, UserResponseDto } from './types.js';
 export declare class WebAuthenticationResource extends BaseClient {
     constructor(config: ClientConfig);
     /** Login with email and password */
@@ -7,6 +7,35 @@ export declare class WebAuthenticationResource extends BaseClient {
         body: LoginRequestDto;
         signal?: AbortSignal;
     }): Promise<LoginResponseDto>;
+    /** List human users for admin user management */
+    WebAuthController_listUsers(params?: {
+        signal?: AbortSignal;
+    }): Promise<ManagedUserResponseDto[]>;
+    /** Create an invited human user */
+    WebAuthController_createUser(params: {
+        body: CreateManagedUserRequestDto;
+        signal?: AbortSignal;
+    }): Promise<ManagedUserResponseDto>;
+    /** Reset a managed user password so they can set a new one */
+    WebAuthController_resetUserPassword(params: {
+        userId: string;
+        signal?: AbortSignal;
+    }): Promise<ManagedUserResponseDto>;
+    /** Deactivate a managed user */
+    WebAuthController_deleteUser(params: {
+        userId: string;
+        signal?: AbortSignal;
+    }): Promise<ManagedUserResponseDto>;
+    /** Check whether an invited or reset account can be set up */
+    WebAuthController_getAccountSetupStatus(params: {
+        body: AccountSetupStatusRequestDto;
+        signal?: AbortSignal;
+    }): Promise<AccountSetupStatusResponseDto>;
+    /** Set up an invited or reset account and log in */
+    WebAuthController_setupAccount(params: {
+        body: SetupManagedUserRequestDto;
+        signal?: AbortSignal;
+    }): Promise<LoginResponseDto>;
     /** Refresh access token using refresh token */
     WebAuthController_refresh(params?: {
         signal?: AbortSignal;

package/dist/src/v2/web-authentication-resource.js

@@ -7,6 +7,30 @@ export class WebAuthenticationResource extends BaseClient {
     async WebAuthController_login(params) {
         return this.request('POST', '/api/v1/auth/login', { body: params.body, signal: params?.signal });
     }
+    /** List human users for admin user management */
+    async WebAuthController_listUsers(params) {
+        return this.request('GET', '/api/v1/auth/users', { signal: params?.signal });
+    }
+    /** Create an invited human user */
+    async WebAuthController_createUser(params) {
+        return this.request('POST', '/api/v1/auth/users', { body: params.body, signal: params?.signal });
+    }
+    /** Reset a managed user password so they can set a new one */
+    async WebAuthController_resetUserPassword(params) {
+        return this.request('POST', `/api/v1/auth/users/${params.userId}/reset-password`, { signal: params?.signal });
+    }
+    /** Deactivate a managed user */
+    async WebAuthController_deleteUser(params) {
+        return this.request('DELETE', `/api/v1/auth/users/${params.userId}`, { signal: params?.signal });
+    }
+    /** Check whether an invited or reset account can be set up */
+    async WebAuthController_getAccountSetupStatus(params) {
+        return this.request('POST', '/api/v1/auth/account-setup-status', { body: params.body, signal: params?.signal });
+    }
+    /** Set up an invited or reset account and log in */
+    async WebAuthController_setupAccount(params) {
+        return this.request('POST', '/api/v1/auth/setup-account', { body: params.body, signal: params?.signal });
+    }
     /** Refresh access token using refresh token */
     async WebAuthController_refresh(params) {
         return this.request('POST', '/api/v1/auth/refresh', { signal: params?.signal });

package/package.json

@@ -1,9 +1,9 @@
 {
   "name": "@taico/client",
-  "version": "0.2.17",
+  "version": "0.3.0",
   "type": "module",
   "private": false,
-  "license": "MIT",
+  "license": "PolyForm-Small-Business-1.0.0",
   "main": "./dist/src/index.js",
   "types": "./dist/src/index.d.ts",
   "files": [