@saritasa/crm-delmar-core-sdk 0.0.14

package/api/sso-api.service.d.ts

@@ -0,0 +1,82 @@
+import { HttpClient, HttpHeaders, HttpResponse, HttpEvent, HttpParameterCodec, HttpContext } from "@angular/common/http";
+import { Observable } from "rxjs";
+import { OpenIDRedirectDto } from "../model/open-id-redirect.dto";
+import { TokenObtainPairDto } from "../model/token-obtain-pair.dto";
+import { Configuration } from "../configuration";
+import { SsoApiServiceInterface, SsoCodeExchangeCreateRequestParams, SsoDebugCreateRequestParams, SsoStartCreateRequestParams } from "./sso-api.serviceInterface";
+import * as i0 from "@angular/core";
+export declare class SsoApiService implements SsoApiServiceInterface {
+    protected httpClient: HttpClient;
+    protected basePath: string;
+    defaultHeaders: HttpHeaders;
+    configuration: Configuration;
+    encoder: HttpParameterCodec;
+    constructor(httpClient: HttpClient, basePath: string | string[], configuration: Configuration);
+    private addToHttpParams;
+    private addToHttpParamsRecursive;
+    /**
+     * Exchange openid code on jwt token.
+     * @param requestParameters
+     * @param observe set whether or not to return the data Observable as the body, response or events. defaults to returning the body.
+     * @param reportProgress flag to report request and response progress.
+     */
+    ssoCodeExchangeCreate(requestParameters?: SsoCodeExchangeCreateRequestParams, observe?: "body", reportProgress?: boolean, options?: {
+        httpHeaderAccept?: "application/json";
+        context?: HttpContext;
+        transferCache?: boolean;
+    }): Observable<TokenObtainPairDto>;
+    ssoCodeExchangeCreate(requestParameters?: SsoCodeExchangeCreateRequestParams, observe?: "response", reportProgress?: boolean, options?: {
+        httpHeaderAccept?: "application/json";
+        context?: HttpContext;
+        transferCache?: boolean;
+    }): Observable<HttpResponse<TokenObtainPairDto>>;
+    ssoCodeExchangeCreate(requestParameters?: SsoCodeExchangeCreateRequestParams, observe?: "events", reportProgress?: boolean, options?: {
+        httpHeaderAccept?: "application/json";
+        context?: HttpContext;
+        transferCache?: boolean;
+    }): Observable<HttpEvent<TokenObtainPairDto>>;
+    /**
+     * Login via email(only available in debug mode).
+     * @param requestParameters
+     * @param observe set whether or not to return the data Observable as the body, response or events. defaults to returning the body.
+     * @param reportProgress flag to report request and response progress.
+     */
+    ssoDebugCreate(requestParameters?: SsoDebugCreateRequestParams, observe?: "body", reportProgress?: boolean, options?: {
+        httpHeaderAccept?: "application/json";
+        context?: HttpContext;
+        transferCache?: boolean;
+    }): Observable<TokenObtainPairDto>;
+    ssoDebugCreate(requestParameters?: SsoDebugCreateRequestParams, observe?: "response", reportProgress?: boolean, options?: {
+        httpHeaderAccept?: "application/json";
+        context?: HttpContext;
+        transferCache?: boolean;
+    }): Observable<HttpResponse<TokenObtainPairDto>>;
+    ssoDebugCreate(requestParameters?: SsoDebugCreateRequestParams, observe?: "events", reportProgress?: boolean, options?: {
+        httpHeaderAccept?: "application/json";
+        context?: HttpContext;
+        transferCache?: boolean;
+    }): Observable<HttpEvent<TokenObtainPairDto>>;
+    /**
+     * Get url to start auth process via openid.  Workflow of authentication via sso: First you use this endpoint to get url for authentication and redirect user to it. After authentication sso, with redirect user to uri you specified. In redirect\&#39;s queries params you will find &#x60;code&#x60; which can be used to get jwt token.
+     * @param requestParameters
+     * @param observe set whether or not to return the data Observable as the body, response or events. defaults to returning the body.
+     * @param reportProgress flag to report request and response progress.
+     */
+    ssoStartCreate(requestParameters?: SsoStartCreateRequestParams, observe?: "body", reportProgress?: boolean, options?: {
+        httpHeaderAccept?: "application/json";
+        context?: HttpContext;
+        transferCache?: boolean;
+    }): Observable<OpenIDRedirectDto>;
+    ssoStartCreate(requestParameters?: SsoStartCreateRequestParams, observe?: "response", reportProgress?: boolean, options?: {
+        httpHeaderAccept?: "application/json";
+        context?: HttpContext;
+        transferCache?: boolean;
+    }): Observable<HttpResponse<OpenIDRedirectDto>>;
+    ssoStartCreate(requestParameters?: SsoStartCreateRequestParams, observe?: "events", reportProgress?: boolean, options?: {
+        httpHeaderAccept?: "application/json";
+        context?: HttpContext;
+        transferCache?: boolean;
+    }): Observable<HttpEvent<OpenIDRedirectDto>>;
+    static ɵfac: i0.ɵɵFactoryDeclaration<SsoApiService, [null, { optional: true; }, { optional: true; }]>;
+    static ɵprov: i0.ɵɵInjectableDeclaration<SsoApiService>;
+}

package/api/sso-api.serviceInterface.d.ts

@@ -0,0 +1,48 @@
+/**
+ * Delmar Api
+ *
+ *
+ *
+ * NOTE: This class is auto generated by OpenAPI Generator (https://openapi-generator.tech).
+ * https://openapi-generator.tech
+ * Do not edit the class manually.
+ */
+import { HttpHeaders } from "@angular/common/http";
+import { Observable } from "rxjs";
+import { DebugLoginRequestDto } from "../model/models";
+import { LoginOpenIDRequestDto } from "../model/models";
+import { OpenIDCodeExchangeRequestDto } from "../model/models";
+import { OpenIDRedirectDto } from "../model/models";
+import { TokenObtainPairDto } from "../model/models";
+import { Configuration } from "../configuration";
+export interface SsoCodeExchangeCreateRequestParams {
+    openIDCodeExchangeRequestDto: OpenIDCodeExchangeRequestDto;
+}
+export interface SsoDebugCreateRequestParams {
+    debugLoginRequestDto: DebugLoginRequestDto;
+}
+export interface SsoStartCreateRequestParams {
+    loginOpenIDRequestDto?: LoginOpenIDRequestDto;
+}
+export interface SsoApiServiceInterface {
+    defaultHeaders: HttpHeaders;
+    configuration: Configuration;
+    /**
+     *
+     * Exchange openid code on jwt token.
+     * @param requestParameters
+     */
+    ssoCodeExchangeCreate(requestParameters: SsoCodeExchangeCreateRequestParams, extraHttpRequestParams?: any): Observable<TokenObtainPairDto>;
+    /**
+     *
+     * Login via email(only available in debug mode).
+     * @param requestParameters
+     */
+    ssoDebugCreate(requestParameters: SsoDebugCreateRequestParams, extraHttpRequestParams?: any): Observable<TokenObtainPairDto>;
+    /**
+     *
+     * Get url to start auth process via openid.  Workflow of authentication via sso: First you use this endpoint to get url for authentication and redirect user to it. After authentication sso, with redirect user to uri you specified. In redirect\&#39;s queries params you will find &#x60;code&#x60; which can be used to get jwt token.
+     * @param requestParameters
+     */
+    ssoStartCreate(requestParameters: SsoStartCreateRequestParams, extraHttpRequestParams?: any): Observable<OpenIDRedirectDto>;
+}

package/api/token-api.service.d.ts

@@ -0,0 +1,60 @@
+import { HttpClient, HttpHeaders, HttpResponse, HttpEvent, HttpParameterCodec, HttpContext } from "@angular/common/http";
+import { Observable } from "rxjs";
+import { TokenRefreshDto } from "../model/token-refresh.dto";
+import { Configuration } from "../configuration";
+import { TokenApiServiceInterface, TokenRefreshCreateRequestParams, TokenVerifyCreateRequestParams } from "./token-api.serviceInterface";
+import * as i0 from "@angular/core";
+export declare class TokenApiService implements TokenApiServiceInterface {
+    protected httpClient: HttpClient;
+    protected basePath: string;
+    defaultHeaders: HttpHeaders;
+    configuration: Configuration;
+    encoder: HttpParameterCodec;
+    constructor(httpClient: HttpClient, basePath: string | string[], configuration: Configuration);
+    private addToHttpParams;
+    private addToHttpParamsRecursive;
+    /**
+     * Takes a refresh type JSON web token and returns an access type JSON web token if the refresh token is valid.
+     * @param requestParameters
+     * @param observe set whether or not to return the data Observable as the body, response or events. defaults to returning the body.
+     * @param reportProgress flag to report request and response progress.
+     */
+    tokenRefreshCreate(requestParameters?: TokenRefreshCreateRequestParams, observe?: "body", reportProgress?: boolean, options?: {
+        httpHeaderAccept?: "application/json";
+        context?: HttpContext;
+        transferCache?: boolean;
+    }): Observable<TokenRefreshDto>;
+    tokenRefreshCreate(requestParameters?: TokenRefreshCreateRequestParams, observe?: "response", reportProgress?: boolean, options?: {
+        httpHeaderAccept?: "application/json";
+        context?: HttpContext;
+        transferCache?: boolean;
+    }): Observable<HttpResponse<TokenRefreshDto>>;
+    tokenRefreshCreate(requestParameters?: TokenRefreshCreateRequestParams, observe?: "events", reportProgress?: boolean, options?: {
+        httpHeaderAccept?: "application/json";
+        context?: HttpContext;
+        transferCache?: boolean;
+    }): Observable<HttpEvent<TokenRefreshDto>>;
+    /**
+     * Takes a token and indicates if it is valid.  This view provides no information about a token\&#39;s fitness for a particular use.
+     * @param requestParameters
+     * @param observe set whether or not to return the data Observable as the body, response or events. defaults to returning the body.
+     * @param reportProgress flag to report request and response progress.
+     */
+    tokenVerifyCreate(requestParameters?: TokenVerifyCreateRequestParams, observe?: "body", reportProgress?: boolean, options?: {
+        httpHeaderAccept?: "application/json";
+        context?: HttpContext;
+        transferCache?: boolean;
+    }): Observable<any>;
+    tokenVerifyCreate(requestParameters?: TokenVerifyCreateRequestParams, observe?: "response", reportProgress?: boolean, options?: {
+        httpHeaderAccept?: "application/json";
+        context?: HttpContext;
+        transferCache?: boolean;
+    }): Observable<HttpResponse<any>>;
+    tokenVerifyCreate(requestParameters?: TokenVerifyCreateRequestParams, observe?: "events", reportProgress?: boolean, options?: {
+        httpHeaderAccept?: "application/json";
+        context?: HttpContext;
+        transferCache?: boolean;
+    }): Observable<HttpEvent<any>>;
+    static ɵfac: i0.ɵɵFactoryDeclaration<TokenApiService, [null, { optional: true; }, { optional: true; }]>;
+    static ɵprov: i0.ɵɵInjectableDeclaration<TokenApiService>;
+}

package/api/token-api.serviceInterface.d.ts

@@ -0,0 +1,37 @@
+/**
+ * Delmar Api
+ *
+ *
+ *
+ * NOTE: This class is auto generated by OpenAPI Generator (https://openapi-generator.tech).
+ * https://openapi-generator.tech
+ * Do not edit the class manually.
+ */
+import { HttpHeaders } from "@angular/common/http";
+import { Observable } from "rxjs";
+import { TokenRefreshDto } from "../model/models";
+import { TokenRefreshRequestDto } from "../model/models";
+import { TokenVerifyRequestDto } from "../model/models";
+import { Configuration } from "../configuration";
+export interface TokenRefreshCreateRequestParams {
+    tokenRefreshRequestDto: TokenRefreshRequestDto;
+}
+export interface TokenVerifyCreateRequestParams {
+    tokenVerifyRequestDto: TokenVerifyRequestDto;
+}
+export interface TokenApiServiceInterface {
+    defaultHeaders: HttpHeaders;
+    configuration: Configuration;
+    /**
+     *
+     * Takes a refresh type JSON web token and returns an access type JSON web token if the refresh token is valid.
+     * @param requestParameters
+     */
+    tokenRefreshCreate(requestParameters: TokenRefreshCreateRequestParams, extraHttpRequestParams?: any): Observable<TokenRefreshDto>;
+    /**
+     *
+     * Takes a token and indicates if it is valid.  This view provides no information about a token\&#39;s fitness for a particular use.
+     * @param requestParameters
+     */
+    tokenVerifyCreate(requestParameters: TokenVerifyCreateRequestParams, extraHttpRequestParams?: any): Observable<{}>;
+}

package/api/user-capacities-api.service.d.ts

@@ -0,0 +1,104 @@
+import { HttpClient, HttpHeaders, HttpResponse, HttpEvent, HttpParameterCodec, HttpContext } from "@angular/common/http";
+import { Observable } from "rxjs";
+import { PaginatedUserCapacityListDto } from "../model/paginated-user-capacity-list.dto";
+import { PaginatedUserSumCapacityListDto } from "../model/paginated-user-sum-capacity-list.dto";
+import { UserCapacityDto } from "../model/user-capacity.dto";
+import { Configuration } from "../configuration";
+import { UserCapacitiesApiServiceInterface, UserCapacitiesCalculateCapacityCreateRequestParams, UserCapacitiesGetPeriodCapacityListRequestParams, UserCapacitiesListRequestParams, UserCapacitiesRetrieveRequestParams } from "./user-capacities-api.serviceInterface";
+import * as i0 from "@angular/core";
+export declare class UserCapacitiesApiService implements UserCapacitiesApiServiceInterface {
+    protected httpClient: HttpClient;
+    protected basePath: string;
+    defaultHeaders: HttpHeaders;
+    configuration: Configuration;
+    encoder: HttpParameterCodec;
+    constructor(httpClient: HttpClient, basePath: string | string[], configuration: Configuration);
+    private addToHttpParams;
+    private addToHttpParamsRecursive;
+    /**
+     * Run calculate capacity task.
+     * @param requestParameters
+     * @param observe set whether or not to return the data Observable as the body, response or events. defaults to returning the body.
+     * @param reportProgress flag to report request and response progress.
+     */
+    userCapacitiesCalculateCapacityCreate(requestParameters?: UserCapacitiesCalculateCapacityCreateRequestParams, observe?: "body", reportProgress?: boolean, options?: {
+        httpHeaderAccept?: "application/json";
+        context?: HttpContext;
+        transferCache?: boolean;
+    }): Observable<UserCapacityDto>;
+    userCapacitiesCalculateCapacityCreate(requestParameters?: UserCapacitiesCalculateCapacityCreateRequestParams, observe?: "response", reportProgress?: boolean, options?: {
+        httpHeaderAccept?: "application/json";
+        context?: HttpContext;
+        transferCache?: boolean;
+    }): Observable<HttpResponse<UserCapacityDto>>;
+    userCapacitiesCalculateCapacityCreate(requestParameters?: UserCapacitiesCalculateCapacityCreateRequestParams, observe?: "events", reportProgress?: boolean, options?: {
+        httpHeaderAccept?: "application/json";
+        context?: HttpContext;
+        transferCache?: boolean;
+    }): Observable<HttpEvent<UserCapacityDto>>;
+    /**
+     * Get capacity sum for period.
+     * @param requestParameters
+     * @param observe set whether or not to return the data Observable as the body, response or events. defaults to returning the body.
+     * @param reportProgress flag to report request and response progress.
+     */
+    userCapacitiesGetPeriodCapacityList(requestParameters?: UserCapacitiesGetPeriodCapacityListRequestParams, observe?: "body", reportProgress?: boolean, options?: {
+        httpHeaderAccept?: "application/json";
+        context?: HttpContext;
+        transferCache?: boolean;
+    }): Observable<PaginatedUserSumCapacityListDto>;
+    userCapacitiesGetPeriodCapacityList(requestParameters?: UserCapacitiesGetPeriodCapacityListRequestParams, observe?: "response", reportProgress?: boolean, options?: {
+        httpHeaderAccept?: "application/json";
+        context?: HttpContext;
+        transferCache?: boolean;
+    }): Observable<HttpResponse<PaginatedUserSumCapacityListDto>>;
+    userCapacitiesGetPeriodCapacityList(requestParameters?: UserCapacitiesGetPeriodCapacityListRequestParams, observe?: "events", reportProgress?: boolean, options?: {
+        httpHeaderAccept?: "application/json";
+        context?: HttpContext;
+        transferCache?: boolean;
+    }): Observable<HttpEvent<PaginatedUserSumCapacityListDto>>;
+    /**
+     * Readonly view set for UserCapacity model.
+     * @param requestParameters
+     * @param observe set whether or not to return the data Observable as the body, response or events. defaults to returning the body.
+     * @param reportProgress flag to report request and response progress.
+     */
+    userCapacitiesList(requestParameters?: UserCapacitiesListRequestParams, observe?: "body", reportProgress?: boolean, options?: {
+        httpHeaderAccept?: "application/json";
+        context?: HttpContext;
+        transferCache?: boolean;
+    }): Observable<PaginatedUserCapacityListDto>;
+    userCapacitiesList(requestParameters?: UserCapacitiesListRequestParams, observe?: "response", reportProgress?: boolean, options?: {
+        httpHeaderAccept?: "application/json";
+        context?: HttpContext;
+        transferCache?: boolean;
+    }): Observable<HttpResponse<PaginatedUserCapacityListDto>>;
+    userCapacitiesList(requestParameters?: UserCapacitiesListRequestParams, observe?: "events", reportProgress?: boolean, options?: {
+        httpHeaderAccept?: "application/json";
+        context?: HttpContext;
+        transferCache?: boolean;
+    }): Observable<HttpEvent<PaginatedUserCapacityListDto>>;
+    /**
+     * Readonly view set for UserCapacity model.
+     * @param requestParameters
+     * @param observe set whether or not to return the data Observable as the body, response or events. defaults to returning the body.
+     * @param reportProgress flag to report request and response progress.
+     */
+    userCapacitiesRetrieve(requestParameters?: UserCapacitiesRetrieveRequestParams, observe?: "body", reportProgress?: boolean, options?: {
+        httpHeaderAccept?: "application/json";
+        context?: HttpContext;
+        transferCache?: boolean;
+    }): Observable<UserCapacityDto>;
+    userCapacitiesRetrieve(requestParameters?: UserCapacitiesRetrieveRequestParams, observe?: "response", reportProgress?: boolean, options?: {
+        httpHeaderAccept?: "application/json";
+        context?: HttpContext;
+        transferCache?: boolean;
+    }): Observable<HttpResponse<UserCapacityDto>>;
+    userCapacitiesRetrieve(requestParameters?: UserCapacitiesRetrieveRequestParams, observe?: "events", reportProgress?: boolean, options?: {
+        httpHeaderAccept?: "application/json";
+        context?: HttpContext;
+        transferCache?: boolean;
+    }): Observable<HttpEvent<UserCapacityDto>>;
+    static ɵfac: i0.ɵɵFactoryDeclaration<UserCapacitiesApiService, [null, { optional: true; }, { optional: true; }]>;
+    static ɵprov: i0.ɵɵInjectableDeclaration<UserCapacitiesApiService>;
+}

package/api/user-capacities-api.serviceInterface.d.ts

@@ -0,0 +1,78 @@
+/**
+ * Delmar Api
+ *
+ *
+ *
+ * NOTE: This class is auto generated by OpenAPI Generator (https://openapi-generator.tech).
+ * https://openapi-generator.tech
+ * Do not edit the class manually.
+ */
+import { HttpHeaders } from "@angular/common/http";
+import { Observable } from "rxjs";
+import { PaginatedUserCapacityListDto } from "../model/models";
+import { PaginatedUserSumCapacityListDto } from "../model/models";
+import { UserCapacityDto } from "../model/models";
+import { UserCapacityRequestDto } from "../model/models";
+import { Configuration } from "../configuration";
+export interface UserCapacitiesCalculateCapacityCreateRequestParams {
+    userCapacityRequestDto: UserCapacityRequestDto;
+}
+export interface UserCapacitiesGetPeriodCapacityListRequestParams {
+    periodType: "branch" | "department" | "user" | "work_type";
+    dateGte?: string;
+    dateLte?: string;
+    limit?: number;
+    objectIds?: Array<number>;
+    offset?: number;
+    ordering?: string;
+    search?: string;
+}
+export interface UserCapacitiesListRequestParams {
+    branchId?: number;
+    branchIdIn?: Array<number>;
+    dateGte?: string;
+    dateLte?: string;
+    departmentId?: number;
+    departmentIdIn?: Array<number>;
+    id?: number;
+    idIn?: Array<number>;
+    limit?: number;
+    offset?: number;
+    ordering?: string;
+    search?: string;
+    userId?: number;
+    userIdIn?: Array<number>;
+    workTypeId?: number;
+    workTypeIdIn?: Array<number>;
+}
+export interface UserCapacitiesRetrieveRequestParams {
+    id: number;
+}
+export interface UserCapacitiesApiServiceInterface {
+    defaultHeaders: HttpHeaders;
+    configuration: Configuration;
+    /**
+     *
+     * Run calculate capacity task.
+     * @param requestParameters
+     */
+    userCapacitiesCalculateCapacityCreate(requestParameters: UserCapacitiesCalculateCapacityCreateRequestParams, extraHttpRequestParams?: any): Observable<UserCapacityDto>;
+    /**
+     *
+     * Get capacity sum for period.
+     * @param requestParameters
+     */
+    userCapacitiesGetPeriodCapacityList(requestParameters: UserCapacitiesGetPeriodCapacityListRequestParams, extraHttpRequestParams?: any): Observable<PaginatedUserSumCapacityListDto>;
+    /**
+     *
+     * Readonly view set for UserCapacity model.
+     * @param requestParameters
+     */
+    userCapacitiesList(requestParameters: UserCapacitiesListRequestParams, extraHttpRequestParams?: any): Observable<PaginatedUserCapacityListDto>;
+    /**
+     *
+     * Readonly view set for UserCapacity model.
+     * @param requestParameters
+     */
+    userCapacitiesRetrieve(requestParameters: UserCapacitiesRetrieveRequestParams, extraHttpRequestParams?: any): Observable<UserCapacityDto>;
+}

package/api/user-logins-api.service.d.ts

@@ -0,0 +1,82 @@
+import { HttpClient, HttpHeaders, HttpResponse, HttpEvent, HttpParameterCodec, HttpContext } from "@angular/common/http";
+import { Observable } from "rxjs";
+import { PaginatedUserLoginListDto } from "../model/paginated-user-login-list.dto";
+import { UserLoginDto } from "../model/user-login.dto";
+import { Configuration } from "../configuration";
+import { UserLoginsApiServiceInterface, UserLoginsListRequestParams, UserLoginsRetrieveRequestParams, UserLoginsUpdateRequestParams } from "./user-logins-api.serviceInterface";
+import * as i0 from "@angular/core";
+export declare class UserLoginsApiService implements UserLoginsApiServiceInterface {
+    protected httpClient: HttpClient;
+    protected basePath: string;
+    defaultHeaders: HttpHeaders;
+    configuration: Configuration;
+    encoder: HttpParameterCodec;
+    constructor(httpClient: HttpClient, basePath: string | string[], configuration: Configuration);
+    private addToHttpParams;
+    private addToHttpParamsRecursive;
+    /**
+     * ViewSet for viewing info about users.  Separate endpoint because it\'s used by admins only to manage permissions.
+     * @param requestParameters
+     * @param observe set whether or not to return the data Observable as the body, response or events. defaults to returning the body.
+     * @param reportProgress flag to report request and response progress.
+     */
+    userLoginsList(requestParameters?: UserLoginsListRequestParams, observe?: "body", reportProgress?: boolean, options?: {
+        httpHeaderAccept?: "application/json";
+        context?: HttpContext;
+        transferCache?: boolean;
+    }): Observable<PaginatedUserLoginListDto>;
+    userLoginsList(requestParameters?: UserLoginsListRequestParams, observe?: "response", reportProgress?: boolean, options?: {
+        httpHeaderAccept?: "application/json";
+        context?: HttpContext;
+        transferCache?: boolean;
+    }): Observable<HttpResponse<PaginatedUserLoginListDto>>;
+    userLoginsList(requestParameters?: UserLoginsListRequestParams, observe?: "events", reportProgress?: boolean, options?: {
+        httpHeaderAccept?: "application/json";
+        context?: HttpContext;
+        transferCache?: boolean;
+    }): Observable<HttpEvent<PaginatedUserLoginListDto>>;
+    /**
+     * ViewSet for viewing info about users.  Separate endpoint because it\&#39;s used by admins only to manage permissions.
+     * @param requestParameters
+     * @param observe set whether or not to return the data Observable as the body, response or events. defaults to returning the body.
+     * @param reportProgress flag to report request and response progress.
+     */
+    userLoginsRetrieve(requestParameters?: UserLoginsRetrieveRequestParams, observe?: "body", reportProgress?: boolean, options?: {
+        httpHeaderAccept?: "application/json";
+        context?: HttpContext;
+        transferCache?: boolean;
+    }): Observable<UserLoginDto>;
+    userLoginsRetrieve(requestParameters?: UserLoginsRetrieveRequestParams, observe?: "response", reportProgress?: boolean, options?: {
+        httpHeaderAccept?: "application/json";
+        context?: HttpContext;
+        transferCache?: boolean;
+    }): Observable<HttpResponse<UserLoginDto>>;
+    userLoginsRetrieve(requestParameters?: UserLoginsRetrieveRequestParams, observe?: "events", reportProgress?: boolean, options?: {
+        httpHeaderAccept?: "application/json";
+        context?: HttpContext;
+        transferCache?: boolean;
+    }): Observable<HttpEvent<UserLoginDto>>;
+    /**
+     * ViewSet for viewing info about users.  Separate endpoint because it\&#39;s used by admins only to manage permissions.
+     * @param requestParameters
+     * @param observe set whether or not to return the data Observable as the body, response or events. defaults to returning the body.
+     * @param reportProgress flag to report request and response progress.
+     */
+    userLoginsUpdate(requestParameters?: UserLoginsUpdateRequestParams, observe?: "body", reportProgress?: boolean, options?: {
+        httpHeaderAccept?: "application/json";
+        context?: HttpContext;
+        transferCache?: boolean;
+    }): Observable<UserLoginDto>;
+    userLoginsUpdate(requestParameters?: UserLoginsUpdateRequestParams, observe?: "response", reportProgress?: boolean, options?: {
+        httpHeaderAccept?: "application/json";
+        context?: HttpContext;
+        transferCache?: boolean;
+    }): Observable<HttpResponse<UserLoginDto>>;
+    userLoginsUpdate(requestParameters?: UserLoginsUpdateRequestParams, observe?: "events", reportProgress?: boolean, options?: {
+        httpHeaderAccept?: "application/json";
+        context?: HttpContext;
+        transferCache?: boolean;
+    }): Observable<HttpEvent<UserLoginDto>>;
+    static ɵfac: i0.ɵɵFactoryDeclaration<UserLoginsApiService, [null, { optional: true; }, { optional: true; }]>;
+    static ɵprov: i0.ɵɵInjectableDeclaration<UserLoginsApiService>;
+}

package/api/user-logins-api.serviceInterface.d.ts

@@ -0,0 +1,58 @@
+/**
+ * Delmar Api
+ *
+ *
+ *
+ * NOTE: This class is auto generated by OpenAPI Generator (https://openapi-generator.tech).
+ * https://openapi-generator.tech
+ * Do not edit the class manually.
+ */
+import { HttpHeaders } from "@angular/common/http";
+import { Observable } from "rxjs";
+import { PaginatedUserLoginListDto } from "../model/models";
+import { UserLoginDto } from "../model/models";
+import { UserLoginRequestDto } from "../model/models";
+import { Configuration } from "../configuration";
+export interface UserLoginsListRequestParams {
+    branch?: number;
+    branchIn?: Array<number>;
+    department?: number;
+    departmentIn?: Array<number>;
+    limit?: number;
+    offset?: number;
+    ordering?: string;
+    role?: number;
+    roleIn?: Array<number>;
+    search?: string;
+    workType?: number;
+    workTypeIn?: Array<number>;
+}
+export interface UserLoginsRetrieveRequestParams {
+    id: number;
+}
+export interface UserLoginsUpdateRequestParams {
+    id: number;
+    userLoginRequestDto: UserLoginRequestDto;
+}
+export interface UserLoginsApiServiceInterface {
+    defaultHeaders: HttpHeaders;
+    configuration: Configuration;
+    /**
+     *
+     * ViewSet for viewing info about users.  Separate endpoint because it\&#39;s used by admins only to manage permissions.
+     * @param requestParameters
+     */
+    userLoginsList(requestParameters: UserLoginsListRequestParams, extraHttpRequestParams?: any): Observable<PaginatedUserLoginListDto>;
+    /**
+     *
+     * ViewSet for viewing info about users.  Separate endpoint because it\&#39;s used by admins only to manage permissions.
+     * @param requestParameters
+     */
+    userLoginsRetrieve(requestParameters: UserLoginsRetrieveRequestParams, extraHttpRequestParams?: any): Observable<UserLoginDto>;
+    /**
+     *
+     * ViewSet for viewing info about users.  Separate endpoint because it\&#39;s used by admins only to manage permissions.
+     * @param requestParameters
+     */
+    userLoginsUpdate(requestParameters: UserLoginsUpdateRequestParams, extraHttpRequestParams?: any): Observable<UserLoginDto>;
+}

package/api/user-periods-api.service.d.ts

@@ -0,0 +1,61 @@
+import { HttpClient, HttpHeaders, HttpResponse, HttpEvent, HttpParameterCodec, HttpContext } from "@angular/common/http";
+import { Observable } from "rxjs";
+import { PaginatedUserPeriodListDto } from "../model/paginated-user-period-list.dto";
+import { UserPeriodDto } from "../model/user-period.dto";
+import { Configuration } from "../configuration";
+import { UserPeriodsApiServiceInterface, UserPeriodsListRequestParams, UserPeriodsRetrieveRequestParams } from "./user-periods-api.serviceInterface";
+import * as i0 from "@angular/core";
+export declare class UserPeriodsApiService implements UserPeriodsApiServiceInterface {
+    protected httpClient: HttpClient;
+    protected basePath: string;
+    defaultHeaders: HttpHeaders;
+    configuration: Configuration;
+    encoder: HttpParameterCodec;
+    constructor(httpClient: HttpClient, basePath: string | string[], configuration: Configuration);
+    private addToHttpParams;
+    private addToHttpParamsRecursive;
+    /**
+     * Api viewset for UserPeriod model.
+     * @param requestParameters
+     * @param observe set whether or not to return the data Observable as the body, response or events. defaults to returning the body.
+     * @param reportProgress flag to report request and response progress.
+     */
+    userPeriodsList(requestParameters?: UserPeriodsListRequestParams, observe?: "body", reportProgress?: boolean, options?: {
+        httpHeaderAccept?: "application/json";
+        context?: HttpContext;
+        transferCache?: boolean;
+    }): Observable<PaginatedUserPeriodListDto>;
+    userPeriodsList(requestParameters?: UserPeriodsListRequestParams, observe?: "response", reportProgress?: boolean, options?: {
+        httpHeaderAccept?: "application/json";
+        context?: HttpContext;
+        transferCache?: boolean;
+    }): Observable<HttpResponse<PaginatedUserPeriodListDto>>;
+    userPeriodsList(requestParameters?: UserPeriodsListRequestParams, observe?: "events", reportProgress?: boolean, options?: {
+        httpHeaderAccept?: "application/json";
+        context?: HttpContext;
+        transferCache?: boolean;
+    }): Observable<HttpEvent<PaginatedUserPeriodListDto>>;
+    /**
+     * Api viewset for UserPeriod model.
+     * @param requestParameters
+     * @param observe set whether or not to return the data Observable as the body, response or events. defaults to returning the body.
+     * @param reportProgress flag to report request and response progress.
+     */
+    userPeriodsRetrieve(requestParameters?: UserPeriodsRetrieveRequestParams, observe?: "body", reportProgress?: boolean, options?: {
+        httpHeaderAccept?: "application/json";
+        context?: HttpContext;
+        transferCache?: boolean;
+    }): Observable<UserPeriodDto>;
+    userPeriodsRetrieve(requestParameters?: UserPeriodsRetrieveRequestParams, observe?: "response", reportProgress?: boolean, options?: {
+        httpHeaderAccept?: "application/json";
+        context?: HttpContext;
+        transferCache?: boolean;
+    }): Observable<HttpResponse<UserPeriodDto>>;
+    userPeriodsRetrieve(requestParameters?: UserPeriodsRetrieveRequestParams, observe?: "events", reportProgress?: boolean, options?: {
+        httpHeaderAccept?: "application/json";
+        context?: HttpContext;
+        transferCache?: boolean;
+    }): Observable<HttpEvent<UserPeriodDto>>;
+    static ɵfac: i0.ɵɵFactoryDeclaration<UserPeriodsApiService, [null, { optional: true; }, { optional: true; }]>;
+    static ɵprov: i0.ɵɵInjectableDeclaration<UserPeriodsApiService>;
+}

package/api/user-periods-api.serviceInterface.d.ts

@@ -0,0 +1,39 @@
+/**
+ * Delmar Api
+ *
+ *
+ *
+ * NOTE: This class is auto generated by OpenAPI Generator (https://openapi-generator.tech).
+ * https://openapi-generator.tech
+ * Do not edit the class manually.
+ */
+import { HttpHeaders } from "@angular/common/http";
+import { Observable } from "rxjs";
+import { PaginatedUserPeriodListDto } from "../model/models";
+import { UserPeriodDto } from "../model/models";
+import { Configuration } from "../configuration";
+export interface UserPeriodsListRequestParams {
+    limit?: number;
+    offset?: number;
+    ordering?: string;
+    search?: string;
+}
+export interface UserPeriodsRetrieveRequestParams {
+    id: number;
+}
+export interface UserPeriodsApiServiceInterface {
+    defaultHeaders: HttpHeaders;
+    configuration: Configuration;
+    /**
+     *
+     * Api viewset for UserPeriod model.
+     * @param requestParameters
+     */
+    userPeriodsList(requestParameters: UserPeriodsListRequestParams, extraHttpRequestParams?: any): Observable<PaginatedUserPeriodListDto>;
+    /**
+     *
+     * Api viewset for UserPeriod model.
+     * @param requestParameters
+     */
+    userPeriodsRetrieve(requestParameters: UserPeriodsRetrieveRequestParams, extraHttpRequestParams?: any): Observable<UserPeriodDto>;
+}