@ngx-smz/core 19.2.0

package/lib/modules/smz-access/modules/users/tables/users-table-state.d.ts

@@ -0,0 +1,3 @@
+import { SmzTableBuilder } from '../../../../../builders/smz-tables/state-builder';
+import { UserDetails } from '../../../models/user-details';
+export declare function SmzAuthorizationUsersTableBuilder(): SmzTableBuilder<UserDetails>;

package/lib/modules/smz-access/modules/users/users.module.d.ts

@@ -0,0 +1,22 @@
+import { RouterModule } from '@angular/router';
+import * as i0 from "@angular/core";
+import * as i1 from "./containers/users/users-page.component";
+import * as i2 from "./components/user-claims/user-claims.component";
+import * as i3 from "@angular/common";
+import * as i4 from "@angular/router";
+import * as i5 from "@angular/forms";
+import * as i6 from "primeng/button";
+import * as i7 from "primeng/selectbutton";
+import * as i8 from "../../../smz-tables/ngx-smz-tables.module";
+import * as i9 from "../../../rbk-utils/auth/guards/access-control.module";
+import * as i10 from "primeng/picklist";
+import * as i11 from "../../../smz-menu/smz-menu.module";
+import * as i12 from "../../../../common/data-pipes/data-pipes.module";
+import * as i13 from "../../../../common/directives/ng-var/ng-var.module";
+export declare const routerModuleForChildUsersModule: import("@angular/core").ModuleWithProviders<RouterModule>;
+export declare class UsersModule {
+    constructor();
+    static ɵfac: i0.ɵɵFactoryDeclaration<UsersModule, never>;
+    static ɵmod: i0.ɵɵNgModuleDeclaration<UsersModule, [typeof i1.UsersPageComponent, typeof i2.UserClaimsComponent], [typeof i3.CommonModule, typeof i4.RouterModule, typeof i5.FormsModule, typeof i6.ButtonModule, typeof i7.SelectButtonModule, typeof i8.NgxSmzTablesModule, typeof i9.RbkAccessControlModule, typeof i10.PickListModule, typeof i11.NgxSmzMenuModule, typeof i12.NgxSmzDataPipesModule, typeof i13.NgVarModule], never>;
+    static ɵinj: i0.ɵɵInjectorDeclaration<UsersModule>;
+}

package/lib/modules/smz-access/public-api.d.ts

@@ -0,0 +1,57 @@
+export * from './modules/users/users.module';
+export * from './modules/users/models/smz-authorization-user-state';
+export * from './modules/users/tables/users-table-state';
+export * from './modules/users/tables/deactivated-users-table-state';
+export * from './modules/claims/claims.module';
+export * from './modules/roles/roles.module';
+export * from './modules/tenants/tenants.module';
+export * from './models/activate-user';
+export * from './models/add-claims-override';
+export * from './models/auth-claim-definitions';
+export * from './models/change-password';
+export * from './models/claim-access-type';
+export * from './models/claim-details';
+export * from './models/claim-override';
+export * from './models/create-claim';
+export * from './models/create-role';
+export * from './models/create-tenant-admin-user';
+export * from './models/create-tenant';
+export * from './models/create-user';
+export * from './models/deativate-user';
+export * from './models/delete-user';
+export * from './models/jwt-response';
+export * from './models/protect-claim';
+export * from './models/redefine-password';
+export * from './models/register';
+export * from './models/remove-claims-override';
+export * from './models/rename-role';
+export * from './models/replace-user-roles';
+export * from './models/request-password-reset';
+export * from './models/resend-email-confirmation';
+export * from './models/role-mode';
+export * from './models/role-source';
+export * from './models/roles-details';
+export * from './models/switch-tenant';
+export * from './models/tenant-details';
+export * from './models/unprotect-claim';
+export * from './models/update-claim';
+export * from './models/update-role-claims';
+export * from './models/update-tenant';
+export * from './models/user-data';
+export * from './models/user-details';
+export * from './routes';
+export * from './services/authorization.service';
+export * from './services/authentication.service';
+export * from './state/state-parameters';
+export * from './state/roles/roles.actions';
+export * from './state/roles/roles.selectors';
+export * from './state/roles/roles.state';
+export * from './state/claims/claims.actions';
+export * from './state/claims/claims.selectors';
+export * from './state/claims/claims.state';
+export * from './state/users/users.actions';
+export * from './state/users/users.selectors';
+export * from './state/users/users.state';
+export * from './state/tenants/tenants.actions';
+export * from './state/tenants/tenants.selectors';
+export * from './state/tenants/tenants.state';

package/lib/modules/smz-access/routes.d.ts

@@ -0,0 +1,9 @@
+export declare const MAIN_LAYOUT_PATH = "";
+export declare const USERS_PATH = "users";
+export declare const ROLES_PATH = "roles";
+export declare const CLAIMS_PATH = "claims";
+export declare const TENANTS_PATH = "tenants";
+export declare const USERS_PAGE_ROUTE: string[];
+export declare const ROLES_PAGE_ROUTE: string[];
+export declare const CLAIMS_PAGE_ROUTE: string[];
+export declare const TENANTS_PAGE_ROUTE: string[];

package/lib/modules/smz-access/services/authentication.service.d.ts

@@ -0,0 +1,40 @@
+import { HttpClient } from '@angular/common/http';
+import { Observable } from 'rxjs/internal/Observable';
+import { BaseApiService } from '../../rbk-utils/http/base-api.service';
+import { JwtResponse } from '../models/jwt-response';
+import { RedefinePassword } from '../models/redefine-password';
+import { RequestPasswordReset } from '../models/request-password-reset';
+import { ResendEmailConfirmation } from '../models/resend-email-confirmation';
+import { SwitchTenant } from '../models/switch-tenant';
+import { CreateUser } from '../models/create-user';
+import { UserDetails } from '../models/user-details';
+import { ChangePassword } from '../models/change-password';
+import { Register } from '../models/register';
+import { DeleteUser } from '../models/delete-user';
+import { DeativateUser } from '../models/deativate-user';
+import { ActivateUser } from '../models/activate-user';
+import * as i0 from "@angular/core";
+export declare class AuthenticationService extends BaseApiService {
+    private http;
+    private readonly environment;
+    private endpoint;
+    constructor(http: HttpClient);
+    private getEndpoint;
+    login(): Observable<JwtResponse>;
+    refreshToken(): Observable<JwtResponse>;
+    sendResetPasswordEmail(data: RequestPasswordReset): Observable<void>;
+    redefinePassword(data: RedefinePassword): Observable<void>;
+    resendEmailConfirmation(data: ResendEmailConfirmation): Observable<void>;
+    confirmEmail(): Observable<void>;
+    switchTenant(data: SwitchTenant): Observable<JwtResponse>;
+    changePassword(data: ChangePassword): Observable<void>;
+    registerAnonymously(data: Register): Observable<void>;
+    createUser<TMetadata extends {
+        [key: string]: string;
+    }>(data: CreateUser<TMetadata>): Observable<UserDetails>;
+    deleteUser(data: DeleteUser): Observable<void>;
+    deactivateUser(data: DeativateUser): Observable<UserDetails>;
+    activateUser(data: ActivateUser): Observable<UserDetails>;
+    static ɵfac: i0.ɵɵFactoryDeclaration<AuthenticationService, never>;
+    static ɵprov: i0.ɵɵInjectableDeclaration<AuthenticationService>;
+}

package/lib/modules/smz-access/services/authorization.service.d.ts

@@ -0,0 +1,46 @@
+import { HttpClient } from '@angular/common/http';
+import { Observable } from 'rxjs/internal/Observable';
+import { ClaimDetails } from '../models/claim-details';
+import { RolesDetails } from '../models/roles-details';
+import { UserDetails } from '../models/user-details';
+import { TenantDetails } from '../models/tenant-details';
+import { CreateClaim } from '../models/create-claim';
+import { UpdateClaim } from '../models/update-claim';
+import { ProtectClaim } from '../models/protect-claim';
+import { UnprotectClaim } from '../models/unprotect-claim';
+import { CreateRole } from '../models/create-role';
+import { RenameRole } from '../models/rename-role';
+import { UpdateRoleClaims } from '../models/update-role-claims';
+import { ReplaceUserRoles } from '../models/replace-user-roles';
+import { AddClaimsOverride } from '../models/add-claims-override';
+import { RemoveClaimsOverride } from '../models/remove-claims-override';
+import { CreateTenant } from '../models/create-tenant';
+import { UpdateTenant } from '../models/update-tenant';
+import { BaseApiService } from '../../rbk-utils/http/base-api.service';
+import * as i0 from "@angular/core";
+export declare class AuthorizationService extends BaseApiService {
+    private http;
+    private endpoint;
+    constructor(http: HttpClient);
+    getAllClaims(): Observable<ClaimDetails[]>;
+    createClaim(data: CreateClaim): Observable<ClaimDetails>;
+    updateClaim(data: UpdateClaim): Observable<ClaimDetails>;
+    deleteClaim(id: string): Observable<void>;
+    protectClaim(data: ProtectClaim): Observable<ClaimDetails>;
+    unprotectClaim(data: UnprotectClaim): Observable<ClaimDetails>;
+    getAllRoles(): Observable<RolesDetails[]>;
+    createRole(data: CreateRole): Observable<RolesDetails>;
+    updateRole(data: RenameRole): Observable<RolesDetails>;
+    deleteRole(id: string): Observable<void>;
+    updateRoleClaims(data: UpdateRoleClaims): Observable<RolesDetails>;
+    getAllUsers(): Observable<UserDetails[]>;
+    updateUserRoles(data: ReplaceUserRoles): Observable<UserDetails>;
+    addClaimsToUser(data: AddClaimsOverride): Observable<UserDetails>;
+    removeClaimsFromUser(data: RemoveClaimsOverride): Observable<UserDetails>;
+    getAllTenants(): Observable<TenantDetails[]>;
+    createTenant(data: CreateTenant): Observable<TenantDetails>;
+    updateTenant(data: UpdateTenant): Observable<TenantDetails>;
+    deleteTenant(id: string): Observable<void>;
+    static ɵfac: i0.ɵɵFactoryDeclaration<AuthorizationService, never>;
+    static ɵprov: i0.ɵɵInjectableDeclaration<AuthorizationService>;
+}

package/lib/modules/smz-access/state/claims/claims.actions.d.ts

@@ -0,0 +1,37 @@
+import { CreateClaim } from '../../models/create-claim';
+import { ProtectClaim } from '../../models/protect-claim';
+import { UnprotectClaim } from '../../models/unprotect-claim';
+import { UpdateClaim } from '../../models/update-claim';
+export declare namespace ClaimsActions {
+    class LoadAll {
+        static readonly type = "[Claims API] LoadAll";
+    }
+    class Create {
+        data: CreateClaim;
+        static readonly type = "[Claims API] Create";
+        constructor(data: CreateClaim);
+    }
+    class Update {
+        data: UpdateClaim;
+        static readonly type = "[Claims API] Update";
+        constructor(data: UpdateClaim);
+    }
+    class Protect {
+        data: ProtectClaim;
+        static readonly type = "[Claims API] Protect";
+        constructor(data: ProtectClaim);
+    }
+    class Unprotect {
+        data: UnprotectClaim;
+        static readonly type = "[Claims API] Unprotect";
+        constructor(data: UnprotectClaim);
+    }
+    class Delete {
+        id: string;
+        static readonly type = "[Claims API] Delete";
+        constructor(id: string);
+    }
+    class Clear {
+        static readonly type = "[Claims API] Clear";
+    }
+}

package/lib/modules/smz-access/state/claims/claims.selectors.d.ts

@@ -0,0 +1,7 @@
+import { ClaimsStateModel } from './claims.state';
+import { ClaimDetails } from '../../models/claim-details';
+export declare class ClaimsSelectors {
+    static all(state: ClaimsStateModel): ClaimDetails[];
+    static allUnprotected(state: ClaimsStateModel): ClaimDetails[];
+    static single(id: string): (state: ClaimsStateModel) => ClaimDetails;
+}

package/lib/modules/smz-access/state/claims/claims.state.d.ts

@@ -0,0 +1,24 @@
+import { StateContext } from '@ngxs/store';
+import { Observable } from 'rxjs';
+import { ClaimsActions } from './claims.actions';
+import { ClaimDetails } from '../../models/claim-details';
+import { AuthorizationService } from '../../services/authorization.service';
+import * as i0 from "@angular/core";
+export declare const CLAIMS_STATE_NAME = "claims";
+export interface ClaimsStateModel {
+    items: ClaimDetails[];
+    lastUpdated?: Date;
+}
+export declare class ClaimsState {
+    private apiService;
+    constructor(apiService: AuthorizationService);
+    loadAll$(ctx: StateContext<ClaimsStateModel>): Observable<ClaimDetails[]>;
+    create$(ctx: StateContext<ClaimsStateModel>, action: ClaimsActions.Create): Observable<ClaimDetails>;
+    update$(ctx: StateContext<ClaimsStateModel>, action: ClaimsActions.Update): Observable<ClaimDetails>;
+    protect$(ctx: StateContext<ClaimsStateModel>, action: ClaimsActions.Protect): Observable<ClaimDetails>;
+    unprotect$(ctx: StateContext<ClaimsStateModel>, action: ClaimsActions.Unprotect): Observable<ClaimDetails>;
+    delete$(ctx: StateContext<ClaimsStateModel>, action: ClaimsActions.Delete): Observable<void>;
+    clear$(ctx: StateContext<ClaimsStateModel>): void;
+    static ɵfac: i0.ɵɵFactoryDeclaration<ClaimsState, never>;
+    static ɵprov: i0.ɵɵInjectableDeclaration<ClaimsState>;
+}

package/lib/modules/smz-access/state/roles/roles.actions.d.ts

@@ -0,0 +1,31 @@
+import { CreateRole } from '../../models/create-role';
+import { RenameRole } from '../../models/rename-role';
+import { UpdateRoleClaims } from '../../models/update-role-claims';
+export declare namespace RolesActions {
+    class LoadAll {
+        static readonly type = "[Roles API] LoadAll";
+    }
+    class Create {
+        data: CreateRole;
+        static readonly type = "[Roles API] Create";
+        constructor(data: CreateRole);
+    }
+    class Update {
+        data: RenameRole;
+        static readonly type = "[Roles API] Update";
+        constructor(data: RenameRole);
+    }
+    class Delete {
+        id: string;
+        static readonly type = "[Roles API] Delete";
+        constructor(id: string);
+    }
+    class UpdateClaims {
+        data: UpdateRoleClaims;
+        static readonly type = "[Roles API] Update Claims";
+        constructor(data: UpdateRoleClaims);
+    }
+    class Clear {
+        static readonly type = "[Roles API] Clear";
+    }
+}

package/lib/modules/smz-access/state/roles/roles.selectors.d.ts

@@ -0,0 +1,6 @@
+import { RolesStateModel } from './roles.state';
+import { RolesDetails } from '../../models/roles-details';
+export declare class RolesSelectors {
+    static all(state: RolesStateModel): RolesDetails[];
+    static single(id: string): (state: RolesStateModel) => RolesDetails;
+}

package/lib/modules/smz-access/state/roles/roles.state.d.ts

@@ -0,0 +1,23 @@
+import { StateContext } from '@ngxs/store';
+import { Observable } from 'rxjs';
+import { RolesActions } from './roles.actions';
+import { AuthorizationService } from '../../services/authorization.service';
+import { RolesDetails } from '../../models/roles-details';
+import * as i0 from "@angular/core";
+export declare const ROLES_STATE_NAME = "roles";
+export interface RolesStateModel {
+    items: RolesDetails[];
+    lastUpdated?: Date;
+}
+export declare class RolesState {
+    private apiService;
+    constructor(apiService: AuthorizationService);
+    loadAll$(ctx: StateContext<RolesStateModel>): Observable<RolesDetails[]>;
+    create$(ctx: StateContext<RolesStateModel>, action: RolesActions.Create): Observable<RolesDetails>;
+    update$(ctx: StateContext<RolesStateModel>, action: RolesActions.Update): Observable<RolesDetails>;
+    delete$(ctx: StateContext<RolesStateModel>, action: RolesActions.Delete): Observable<void>;
+    updateClaims$(ctx: StateContext<RolesStateModel>, action: RolesActions.UpdateClaims): Observable<RolesDetails>;
+    clear$(ctx: StateContext<RolesStateModel>): void;
+    static ɵfac: i0.ɵɵFactoryDeclaration<RolesState, never>;
+    static ɵprov: i0.ɵɵInjectableDeclaration<RolesState>;
+}

package/lib/modules/smz-access/state/state-parameters.d.ts

@@ -0,0 +1,7 @@
+import { DatabaseStateParameters } from '../../rbk-utils/ngx-rbk-utils.config';
+export declare const databaseSmzAccessStates: {
+    [name: string]: DatabaseStateParameters;
+};
+export declare const featureSmzAccessStates: {
+    [name: string]: DatabaseStateParameters;
+};

package/lib/modules/smz-access/state/tenants/tenants.actions.d.ts

@@ -0,0 +1,25 @@
+import { CreateTenant } from '../../models/create-tenant';
+import { UpdateTenant } from '../../models/update-tenant';
+export declare namespace TenantsActions {
+    class LoadAll {
+        static readonly type = "[Tenants API] LoadAll";
+    }
+    class Create {
+        data: CreateTenant;
+        static readonly type = "[Tenants API] Create";
+        constructor(data: CreateTenant);
+    }
+    class Update {
+        data: UpdateTenant;
+        static readonly type = "[Tenants API] Update";
+        constructor(data: UpdateTenant);
+    }
+    class Delete {
+        alias: string;
+        static readonly type = "[Tenants API] Delete";
+        constructor(alias: string);
+    }
+    class Clear {
+        static readonly type = "[Tenants API] Clear";
+    }
+}

package/lib/modules/smz-access/state/tenants/tenants.selectors.d.ts

@@ -0,0 +1,10 @@
+import { TenantsStateModel } from './tenants.state';
+import { TenantDetails } from '../../models/tenant-details';
+import { AuthenticationStateModel } from '../../../../state/global/authentication/authentication.state';
+import { BaseUserData } from '../../models/base-user-data';
+export declare class TenantsSelectors {
+    static all(state: TenantsStateModel): TenantDetails[];
+    static single(id: string): (state: TenantsStateModel) => TenantDetails;
+    static userAllowedTenants(state: TenantsStateModel, auth: AuthenticationStateModel<BaseUserData>): TenantDetails[];
+    static currentTenant(state: TenantsStateModel, auth: AuthenticationStateModel<BaseUserData>): TenantDetails;
+}

package/lib/modules/smz-access/state/tenants/tenants.state.d.ts

@@ -0,0 +1,22 @@
+import { StateContext } from '@ngxs/store';
+import { Observable } from 'rxjs';
+import { TenantsActions } from './tenants.actions';
+import { TenantDetails } from '../../models/tenant-details';
+import { AuthorizationService } from '../../services/authorization.service';
+import * as i0 from "@angular/core";
+export declare const TENANTS_STATE_NAME = "tenants";
+export interface TenantsStateModel {
+    items: TenantDetails[];
+    lastUpdated?: Date;
+}
+export declare class TenantsState {
+    private apiService;
+    constructor(apiService: AuthorizationService);
+    loadAll$(ctx: StateContext<TenantsStateModel>): Observable<TenantDetails[]>;
+    create$(ctx: StateContext<TenantsStateModel>, action: TenantsActions.Create): Observable<TenantDetails>;
+    update$(ctx: StateContext<TenantsStateModel>, action: TenantsActions.Update): Observable<TenantDetails>;
+    delete$(ctx: StateContext<TenantsStateModel>, action: TenantsActions.Delete): Observable<void>;
+    clear$(ctx: StateContext<TenantsStateModel>): void;
+    static ɵfac: i0.ɵɵFactoryDeclaration<TenantsState, never>;
+    static ɵprov: i0.ɵɵInjectableDeclaration<TenantsState>;
+}

package/lib/modules/smz-access/state/users/users.actions.d.ts

@@ -0,0 +1,80 @@
+import { ReplaceUserRoles as ReplaceUserRolesPayload } from '../../models/replace-user-roles';
+import { UserDetails } from '../../models/user-details';
+import { AddClaimsOverride as AddClaimOverridePayload } from '../../models/add-claims-override';
+import { RemoveClaimsOverride as RemoveClaimOverridePayload } from '../../models/remove-claims-override';
+import { RedefinePassword as RedefinePasswordPayload } from '../../models/redefine-password';
+import { RequestPasswordReset as ResetPasswordPayload } from '../../models/request-password-reset';
+import { CreateUser } from '../../models/create-user';
+import { DeleteUser } from '../../models/delete-user';
+import { DeativateUser } from '../../models/deativate-user';
+import { ActivateUser } from '../../models/activate-user';
+export declare namespace UsersActions {
+    class LoadAll {
+        static readonly type = "[Users API] Load All";
+    }
+    class ReplaceUserRoles {
+        data: ReplaceUserRolesPayload;
+        static readonly type = "[Users API] Update User Roles";
+        constructor(data: ReplaceUserRolesPayload);
+    }
+    class AddClaimsOverride {
+        data: AddClaimOverridePayload;
+        static readonly type = "[Users API] Add Claims Override";
+        constructor(data: AddClaimOverridePayload);
+    }
+    class RemoveClaimsOverride {
+        data: RemoveClaimOverridePayload;
+        static readonly type = "[Users API] Remove Claims Override";
+        constructor(data: RemoveClaimOverridePayload);
+    }
+    class Create<TMetadata extends {
+        [key: string]: string;
+    }> {
+        data: CreateUser<TMetadata>;
+        constructor(data: CreateUser<TMetadata>);
+        static readonly type = "[Users API] Create User";
+    }
+    class Delete {
+        data: DeleteUser;
+        constructor(data: DeleteUser);
+        static readonly type = "[Users API] Delete";
+    }
+    class Deactivate {
+        data: DeativateUser;
+        constructor(data: DeativateUser);
+        static readonly type = "[Users API] Deactivate";
+    }
+    class Activate {
+        data: ActivateUser;
+        constructor(data: ActivateUser);
+        static readonly type = "[Users API] Activate";
+    }
+    class LocalCreate<TUser extends UserDetails> {
+        data: TUser;
+        constructor(data: TUser);
+        static readonly type = "[Users API] Local Create";
+    }
+    class LocalUpdate<TUser extends UserDetails> {
+        data: TUser;
+        constructor(data: TUser);
+        static readonly type = "[Users API] Local Update";
+    }
+    class LocalDelete {
+        id: string;
+        constructor(id: string);
+        static readonly type = "[Users API] Local Delete";
+    }
+    class ResetPassword {
+        data: ResetPasswordPayload;
+        static readonly type = "[Users API] Reset Password";
+        constructor(data: ResetPasswordPayload);
+    }
+    class RedefinePassword {
+        data: RedefinePasswordPayload;
+        static readonly type = "[Users API] Redefine Password";
+        constructor(data: RedefinePasswordPayload);
+    }
+    class Clear {
+        static readonly type = "[Users API] Clear";
+    }
+}

package/lib/modules/smz-access/state/users/users.selectors.d.ts

@@ -0,0 +1,8 @@
+import { UsersStateModel } from './users.state';
+import { UserDetails } from '../../models/user-details';
+export declare class UsersSelectors {
+    static all(state: UsersStateModel): UserDetails[];
+    static activated(state: UsersStateModel): UserDetails[];
+    static deactivated(state: UsersStateModel): UserDetails[];
+    static single(username: string): (state: UsersStateModel) => UserDetails;
+}

package/lib/modules/smz-access/state/users/users.state.d.ts

@@ -0,0 +1,34 @@
+import { StateContext } from '@ngxs/store';
+import { Observable } from 'rxjs';
+import { UsersActions } from './users.actions';
+import { AuthorizationService } from '../../services/authorization.service';
+import { UserDetails } from '../../models/user-details';
+import { AuthenticationService } from '../../services/authentication.service';
+import * as i0 from "@angular/core";
+export declare const USERS_STATE_NAME = "users";
+export interface UsersStateModel {
+    items: UserDetails[];
+    lastUpdated?: Date;
+}
+export declare const getUsersInitialState: () => UsersStateModel;
+export declare class UsersState {
+    private authorizationService;
+    private authenticationService;
+    constructor(authorizationService: AuthorizationService, authenticationService: AuthenticationService);
+    loadAll$(ctx: StateContext<UsersStateModel>): Observable<UserDetails[]>;
+    onReplaceUserRoles$(ctx: StateContext<UsersStateModel>, action: UsersActions.ReplaceUserRoles): Observable<UserDetails>;
+    onAddClaimsOverride$(ctx: StateContext<UsersStateModel>, action: UsersActions.AddClaimsOverride): Observable<UserDetails>;
+    onRemoveClaimsOverride$(ctx: StateContext<UsersStateModel>, action: UsersActions.RemoveClaimsOverride): Observable<UserDetails>;
+    onRedefinePassword$(ctx: StateContext<UsersStateModel>, action: UsersActions.RedefinePassword): Observable<void>;
+    onResetPassword$(ctx: StateContext<UsersStateModel>, action: UsersActions.ResetPassword): Observable<void>;
+    onCreate$(ctx: StateContext<UsersStateModel>, action: UsersActions.Create<any>): Observable<UserDetails>;
+    onDelete$(ctx: StateContext<UsersStateModel>, action: UsersActions.Delete): Observable<void>;
+    onActivate$(ctx: StateContext<UsersStateModel>, action: UsersActions.Activate): Observable<UserDetails>;
+    onDeactivate$(ctx: StateContext<UsersStateModel>, action: UsersActions.Activate): Observable<UserDetails>;
+    onLocalCreate$(ctx: StateContext<UsersStateModel>, action: UsersActions.LocalCreate<UserDetails>): void;
+    onLocalUpdate$(ctx: StateContext<UsersStateModel>, action: UsersActions.LocalUpdate<UserDetails>): void;
+    LocalDelete$(ctx: StateContext<UsersStateModel>, action: UsersActions.LocalDelete): void;
+    clear$(ctx: StateContext<UsersStateModel>): void;
+    static ɵfac: i0.ɵɵFactoryDeclaration<UsersState, never>;
+    static ɵprov: i0.ɵɵInjectableDeclaration<UsersState>;
+}

package/lib/modules/smz-cards/components/contents/image/image-content.component.d.ts

@@ -0,0 +1,11 @@
+import { OnInit } from '@angular/core';
+import { SmzCardsImageContent } from '../../../models/smz-cards-contents';
+import * as i0 from "@angular/core";
+export declare class SmzImageContentComponent implements OnInit {
+    content: SmzCardsImageContent<unknown>;
+    data: unknown;
+    constructor();
+    ngOnInit(): void;
+    static ɵfac: i0.ɵɵFactoryDeclaration<SmzImageContentComponent, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<SmzImageContentComponent, "smz-image-content", never, { "content": { "alias": "content"; "required": false; }; "data": { "alias": "data"; "required": false; }; }, {}, never, never, false, never>;
+}

package/lib/modules/smz-cards/components/contents/text/text-content.component.d.ts

@@ -0,0 +1,11 @@
+import { OnInit } from '@angular/core';
+import { SmzCardsTextContent } from '../../../models/smz-cards-contents';
+import * as i0 from "@angular/core";
+export declare class SmzTextContentComponent implements OnInit {
+    content: SmzCardsTextContent<unknown>;
+    data: unknown;
+    constructor();
+    ngOnInit(): void;
+    static ɵfac: i0.ɵɵFactoryDeclaration<SmzTextContentComponent, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<SmzTextContentComponent, "smz-text-content", never, { "content": { "alias": "content"; "required": false; }; "data": { "alias": "data"; "required": false; }; }, {}, never, never, false, never>;
+}

package/lib/modules/smz-cards/components/grid-item/grid-item.component.d.ts

@@ -0,0 +1,18 @@
+import { OnInit } from '@angular/core';
+import { SmzCardActions } from '../../models/smz-cards-state';
+import { SmzCardsView } from '../../models/smz-cards-types';
+import { SmzCardsTemplate, SmzCardsTemplates } from '../../models/smz-cards-templates';
+import * as i0 from "@angular/core";
+export declare class SmzGridItemComponent implements OnInit {
+    isDebug: boolean;
+    template: SmzCardsTemplates<unknown>;
+    buttons: SmzCardActions<any>;
+    menu: SmzCardActions<any>;
+    data: unknown;
+    type: typeof SmzCardsTemplate;
+    mode: SmzCardsView;
+    constructor();
+    ngOnInit(): void;
+    static ɵfac: i0.ɵɵFactoryDeclaration<SmzGridItemComponent, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<SmzGridItemComponent, "smz-grid-item", never, { "isDebug": { "alias": "isDebug"; "required": false; }; "template": { "alias": "template"; "required": false; }; "buttons": { "alias": "buttons"; "required": false; }; "menu": { "alias": "menu"; "required": false; }; "data": { "alias": "data"; "required": false; }; }, {}, never, never, false, never>;
+}

package/lib/modules/smz-cards/components/list-item/list-item.component.d.ts

@@ -0,0 +1,18 @@
+import { OnInit } from '@angular/core';
+import { SmzCardActions } from '../../models/smz-cards-state';
+import { SmzCardsView } from '../../models/smz-cards-types';
+import { SmzCardsTemplate, SmzCardsTemplates } from '../../models/smz-cards-templates';
+import * as i0 from "@angular/core";
+export declare class SmzListItemComponent implements OnInit {
+    isDebug: boolean;
+    template: SmzCardsTemplates<unknown>;
+    buttons: SmzCardActions<any>;
+    menu: SmzCardActions<any>;
+    data: unknown;
+    type: typeof SmzCardsTemplate;
+    mode: SmzCardsView;
+    constructor();
+    ngOnInit(): void;
+    static ɵfac: i0.ɵɵFactoryDeclaration<SmzListItemComponent, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<SmzListItemComponent, "smz-list-item", never, { "isDebug": { "alias": "isDebug"; "required": false; }; "template": { "alias": "template"; "required": false; }; "buttons": { "alias": "buttons"; "required": false; }; "menu": { "alias": "menu"; "required": false; }; "data": { "alias": "data"; "required": false; }; }, {}, never, never, false, never>;
+}

package/lib/modules/smz-cards/components/types/flip-card/flip-card-type.component.d.ts

@@ -0,0 +1,23 @@
+import { OnInit } from '@angular/core';
+import { SmzCardActions } from '../../../models/smz-cards-state';
+import { SmzCardsView } from '../../../models/smz-cards-types';
+import { FlipCardTemplate } from '../../../models/smz-cards-templates';
+import { SmzCardsImageContent, SmzCardsTextContent } from '../../../models/smz-cards-contents';
+import * as i0 from "@angular/core";
+export declare class SmzFlipCardTypeComponent implements OnInit {
+    template: FlipCardTemplate<unknown>;
+    data: unknown;
+    mode: SmzCardsView;
+    isDebug: boolean;
+    buttons: SmzCardActions<any>;
+    menu: SmzCardActions<any>;
+    FlipCardTemplate: FlipCardTemplate<unknown>;
+    SmzCardsImageContent: SmzCardsImageContent<unknown>;
+    SmzCardsTextContent: SmzCardsTextContent<unknown>;
+    modes: typeof SmzCardsView;
+    constructor();
+    ngOnInit(): void;
+    flip(): void;
+    static ɵfac: i0.ɵɵFactoryDeclaration<SmzFlipCardTypeComponent, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<SmzFlipCardTypeComponent, "smz-flip-card-type", never, { "template": { "alias": "template"; "required": false; }; "data": { "alias": "data"; "required": false; }; "mode": { "alias": "mode"; "required": false; }; "isDebug": { "alias": "isDebug"; "required": false; }; "buttons": { "alias": "buttons"; "required": false; }; "menu": { "alias": "menu"; "required": false; }; }, {}, never, never, false, never>;
+}

package/lib/modules/smz-cards/components/types/image-with-details/image-with-details-type.component.d.ts

@@ -0,0 +1,22 @@
+import { OnInit } from '@angular/core';
+import { SmzCardActions } from '../../../models/smz-cards-state';
+import { SmzCardsView } from '../../../models/smz-cards-types';
+import { ImageWithDetailsTemplate } from '../../../models/smz-cards-templates';
+import { SmzCardsImageContent, SmzCardsTextContent } from '../../../models/smz-cards-contents';
+import * as i0 from "@angular/core";
+export declare class SmzImageWithDetailsTypeComponent implements OnInit {
+    template: ImageWithDetailsTemplate<unknown>;
+    data: unknown;
+    mode: SmzCardsView;
+    isDebug: boolean;
+    buttons: SmzCardActions<any>;
+    menu: SmzCardActions<any>;
+    ImageWithDetailsTemplate: ImageWithDetailsTemplate<unknown>;
+    SmzCardsImageContent: SmzCardsImageContent<unknown>;
+    SmzCardsTextContent: SmzCardsTextContent<unknown>;
+    modes: typeof SmzCardsView;
+    constructor();
+    ngOnInit(): void;
+    static ɵfac: i0.ɵɵFactoryDeclaration<SmzImageWithDetailsTypeComponent, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<SmzImageWithDetailsTypeComponent, "smz-image-with-details-type", never, { "template": { "alias": "template"; "required": false; }; "data": { "alias": "data"; "required": false; }; "mode": { "alias": "mode"; "required": false; }; "isDebug": { "alias": "isDebug"; "required": false; }; "buttons": { "alias": "buttons"; "required": false; }; "menu": { "alias": "menu"; "required": false; }; }, {}, never, never, false, never>;
+}