keevo-api-services-hcm 0.0.33 → 0.0.34

package/lib/services/dominio/tipo-admissao-caged.service.d.ts

@@ -0,0 +1,18 @@
+import { BaseApiService, HostEnvironment } from "keevo-api-services";
+import { HttpClient } from '@angular/common/http';
+import { Observable } from 'rxjs';
+import TipoAdmissaoCagedModel from "../../models/dominio/tipoadmissaocaged.model";
+import * as i0 from "@angular/core";
+export declare class TipoAdmissaoCagedService extends BaseApiService {
+    private httpClient;
+    private hostEnv;
+    private rotaListar;
+    private rotaExisteID;
+    private rotaSelecionar;
+    constructor(httpClient: HttpClient, hostEnv: HostEnvironment);
+    Listar(): Observable<TipoAdmissaoCagedModel[]>;
+    ExisteID(idtipoadmissaocaged: number): Observable<boolean>;
+    Selecionar(idtipoadmissaocaged: number): Observable<TipoAdmissaoCagedModel>;
+    static ɵfac: i0.ɵɵFactoryDeclaration<TipoAdmissaoCagedService, never>;
+    static ɵprov: i0.ɵɵInjectableDeclaration<TipoAdmissaoCagedService>;
+}

package/lib/services/dominio/tipo-admissao-e-social.service.d.ts

@@ -0,0 +1,18 @@
+import { BaseApiService, HostEnvironment } from "keevo-api-services";
+import { HttpClient } from '@angular/common/http';
+import { Observable } from 'rxjs';
+import TipoAdmissaoESocialModel from "../../models/dominio/tipoadmissaoesocial.model";
+import * as i0 from "@angular/core";
+export declare class TipoAdmissaoESocialService extends BaseApiService {
+    private httpClient;
+    private hostEnv;
+    private rotaListar;
+    private rotaExisteID;
+    private rotaSelecionar;
+    constructor(httpClient: HttpClient, hostEnv: HostEnvironment);
+    Listar(): Observable<TipoAdmissaoESocialModel[]>;
+    ExisteID(idtipoadmissaoesocial: number): Observable<boolean>;
+    Selecionar(idtipoadmissaoesocial: number): Observable<TipoAdmissaoESocialModel>;
+    static ɵfac: i0.ɵɵFactoryDeclaration<TipoAdmissaoESocialService, never>;
+    static ɵprov: i0.ɵɵInjectableDeclaration<TipoAdmissaoESocialService>;
+}

package/lib/services/dominio/tipo-admissao.service.d.ts

@@ -0,0 +1,18 @@
+import { BaseApiService, HostEnvironment } from "keevo-api-services";
+import { HttpClient } from '@angular/common/http';
+import { Observable } from 'rxjs';
+import TipoAdmissaoModel from "../../models/dominio/tipoadmissao.model";
+import * as i0 from "@angular/core";
+export declare class TipoAdmissaoService extends BaseApiService {
+    private httpClient;
+    private hostEnv;
+    private rotaListar;
+    private rotaExisteID;
+    private rotaSelecionar;
+    constructor(httpClient: HttpClient, hostEnv: HostEnvironment);
+    Listar(): Observable<TipoAdmissaoModel[]>;
+    ExisteID(idtipoadmissao: number): Observable<boolean>;
+    Selecionar(idtipoadmissao: number): Observable<TipoAdmissaoModel>;
+    static ɵfac: i0.ɵɵFactoryDeclaration<TipoAdmissaoService, never>;
+    static ɵprov: i0.ɵɵInjectableDeclaration<TipoAdmissaoService>;
+}

package/lib/services/dominio/tipo-afastamento-esocial.service.d.ts

@@ -0,0 +1,18 @@
+import { BaseApiService, HostEnvironment } from "keevo-api-services";
+import { HttpClient } from '@angular/common/http';
+import { Observable } from 'rxjs';
+import TipoAfastamentoESocialModel from "../../models/dominio/tipoafastamentoesocial.model";
+import * as i0 from "@angular/core";
+export declare class TipoAfastamentoESocialService extends BaseApiService {
+    private httpClient;
+    private hostEnv;
+    private rotaListar;
+    private rotaExisteID;
+    private rotaSelecionar;
+    constructor(httpClient: HttpClient, hostEnv: HostEnvironment);
+    Listar(): Observable<TipoAfastamentoESocialModel[]>;
+    ExisteID(idtipoafastamentoesocial: number): Observable<boolean>;
+    Selecionar(idtipoafastamentoesocial: number): Observable<TipoAfastamentoESocialModel>;
+    static ɵfac: i0.ɵɵFactoryDeclaration<TipoAfastamentoESocialService, never>;
+    static ɵprov: i0.ɵɵInjectableDeclaration<TipoAfastamentoESocialService>;
+}

package/lib/services/dominio/tipo-afastamento.service.d.ts

@@ -0,0 +1,18 @@
+import { BaseApiService, HostEnvironment } from "keevo-api-services";
+import { HttpClient } from '@angular/common/http';
+import { Observable } from 'rxjs';
+import TipoAfastamentoModel from "../../models/dominio/tipoafastamento.model";
+import * as i0 from "@angular/core";
+export declare class TipoAfastamentoService extends BaseApiService {
+    private httpClient;
+    private hostEnv;
+    private rotaListar;
+    private rotaExisteID;
+    private rotaSelecionar;
+    constructor(httpClient: HttpClient, hostEnv: HostEnvironment);
+    Listar(): Observable<TipoAfastamentoModel[]>;
+    ExisteID(idtipoafastamento: number): Observable<boolean>;
+    Selecionar(idtipoafastamento: number): Observable<TipoAfastamentoModel>;
+    static ɵfac: i0.ɵɵFactoryDeclaration<TipoAfastamentoService, never>;
+    static ɵprov: i0.ɵɵInjectableDeclaration<TipoAfastamentoService>;
+}

package/lib/services/dominio/tipo-apuracao-media.service.d.ts

@@ -0,0 +1,18 @@
+import { BaseApiService, HostEnvironment } from "keevo-api-services";
+import { HttpClient } from '@angular/common/http';
+import { Observable } from 'rxjs';
+import TipoApuracaoMediaModel from "../../models/dominio/tipoapuracaomedia.model";
+import * as i0 from "@angular/core";
+export declare class TipoApuracaoMediaService extends BaseApiService {
+    private httpClient;
+    private hostEnv;
+    private rotaListar;
+    private rotaExisteID;
+    private rotaSelecionar;
+    constructor(httpClient: HttpClient, hostEnv: HostEnvironment);
+    Listar(): Observable<TipoApuracaoMediaModel[]>;
+    ExisteID(idtipoapuracaomedia: number): Observable<boolean>;
+    Selecionar(idtipoapuracaomedia: number): Observable<TipoApuracaoMediaModel>;
+    static ɵfac: i0.ɵɵFactoryDeclaration<TipoApuracaoMediaService, never>;
+    static ɵprov: i0.ɵɵInjectableDeclaration<TipoApuracaoMediaService>;
+}

package/lib/services/dominio/tipo-caepf.service.d.ts

@@ -0,0 +1,18 @@
+import { BaseApiService, HostEnvironment } from "keevo-api-services";
+import { HttpClient } from '@angular/common/http';
+import { Observable } from 'rxjs';
+import TipoCaepfModel from "../../models/dominio/tipocaepf.model";
+import * as i0 from "@angular/core";
+export declare class TipoCaepfService extends BaseApiService {
+    private httpClient;
+    private hostEnv;
+    private rotaListar;
+    private rotaExisteID;
+    private rotaSelecionar;
+    constructor(httpClient: HttpClient, hostEnv: HostEnvironment);
+    Listar(): Observable<TipoCaepfModel[]>;
+    ExisteID(idtipocaepf: number): Observable<boolean>;
+    Selecionar(idtipocaepf: number): Observable<TipoCaepfModel>;
+    static ɵfac: i0.ɵɵFactoryDeclaration<TipoCaepfService, never>;
+    static ɵprov: i0.ɵɵInjectableDeclaration<TipoCaepfService>;
+}

package/lib/services/dominio/tipo-calculo.service.d.ts

@@ -0,0 +1,18 @@
+import { BaseApiService, HostEnvironment } from "keevo-api-services";
+import { HttpClient } from '@angular/common/http';
+import { Observable } from 'rxjs';
+import TipoCalculoModel from "../../models/dominio/tipoacalculo.model";
+import * as i0 from "@angular/core";
+export declare class TipoCalculoService extends BaseApiService {
+    private httpClient;
+    private hostEnv;
+    private rotaListar;
+    private rotaExisteID;
+    private rotaSelecionar;
+    constructor(httpClient: HttpClient, hostEnv: HostEnvironment);
+    Listar(): Observable<TipoCalculoModel[]>;
+    ExisteID(idtipocalculo: number): Observable<boolean>;
+    Selecionar(idtipocalculo: number): Observable<TipoCalculoModel>;
+    static ɵfac: i0.ɵɵFactoryDeclaration<TipoCalculoService, never>;
+    static ɵprov: i0.ɵɵInjectableDeclaration<TipoCalculoService>;
+}

package/lib/services/dominio/tipo-comissionista.service.d.ts

@@ -0,0 +1,18 @@
+import { BaseApiService, HostEnvironment } from "keevo-api-services";
+import { HttpClient } from '@angular/common/http';
+import { Observable } from 'rxjs';
+import TipoComissionistaModel from "../../models/dominio/tipocomissionista.model";
+import * as i0 from "@angular/core";
+export declare class TipoComissionistaService extends BaseApiService {
+    private httpClient;
+    private hostEnv;
+    private rotaListar;
+    private rotaExisteID;
+    private rotaSelecionar;
+    constructor(httpClient: HttpClient, hostEnv: HostEnvironment);
+    Listar(): Observable<TipoComissionistaModel[]>;
+    ExisteID(idtipocomissionista: number): Observable<boolean>;
+    Selecionar(idtipocomissionista: number): Observable<TipoComissionistaModel>;
+    static ɵfac: i0.ɵɵFactoryDeclaration<TipoComissionistaService, never>;
+    static ɵprov: i0.ɵɵInjectableDeclaration<TipoComissionistaService>;
+}

package/lib/services/dominio/tipo-contratacao.service.d.ts

@@ -0,0 +1,18 @@
+import { BaseApiService, HostEnvironment } from "keevo-api-services";
+import { HttpClient } from '@angular/common/http';
+import { Observable } from 'rxjs';
+import TipoContratacaoModel from "../../models/dominio/tipocontratacao.model";
+import * as i0 from "@angular/core";
+export declare class TipoContratacaoService extends BaseApiService {
+    private httpClient;
+    private hostEnv;
+    private rotaListar;
+    private rotaExisteID;
+    private rotaSelecionar;
+    constructor(httpClient: HttpClient, hostEnv: HostEnvironment);
+    Listar(): Observable<TipoContratacaoModel[]>;
+    ExisteID(idtipocontratacao: number): Observable<boolean>;
+    Selecionar(idtipocontratacao: number): Observable<TipoContratacaoModel>;
+    static ɵfac: i0.ɵɵFactoryDeclaration<TipoContratacaoService, never>;
+    static ɵprov: i0.ɵɵInjectableDeclaration<TipoContratacaoService>;
+}

package/lib/services/dominio/tipo-contrato-tempo-parcial.service.d.ts

@@ -0,0 +1,18 @@
+import { BaseApiService, HostEnvironment } from "keevo-api-services";
+import { HttpClient } from '@angular/common/http';
+import { Observable } from 'rxjs';
+import TipoContratoTempoParcialModel from "../../models/dominio/tipocontratotempoparcial.model";
+import * as i0 from "@angular/core";
+export declare class TipoContratoTempoParcialService extends BaseApiService {
+    private httpClient;
+    private hostEnv;
+    private rotaListar;
+    private rotaExisteID;
+    private rotaSelecionar;
+    constructor(httpClient: HttpClient, hostEnv: HostEnvironment);
+    Listar(): Observable<TipoContratoTempoParcialModel[]>;
+    ExisteID(idtipocontratotempoparcial: number): Observable<boolean>;
+    Selecionar(idtipocontratotempoparcial: number): Observable<TipoContratoTempoParcialModel>;
+    static ɵfac: i0.ɵɵFactoryDeclaration<TipoContratoTempoParcialService, never>;
+    static ɵprov: i0.ɵɵInjectableDeclaration<TipoContratoTempoParcialService>;
+}

package/lib/services/dominio/tipo-contrato-trabalho.service.d.ts

@@ -0,0 +1,18 @@
+import { BaseApiService, HostEnvironment } from "keevo-api-services";
+import { HttpClient } from '@angular/common/http';
+import { Observable } from 'rxjs';
+import TipoContratoTrabalhoModel from "../../models/dominio/tipocontratotrabalho.model";
+import * as i0 from "@angular/core";
+export declare class TipoContratoTrabalhoService extends BaseApiService {
+    private httpClient;
+    private hostEnv;
+    private rotaListar;
+    private rotaExisteID;
+    private rotaSelecionar;
+    constructor(httpClient: HttpClient, hostEnv: HostEnvironment);
+    Listar(): Observable<TipoContratoTrabalhoModel[]>;
+    ExisteID(idtipocontratotrabalho: number): Observable<boolean>;
+    Selecionar(idtipocontratotrabalho: number): Observable<TipoContratoTrabalhoModel>;
+    static ɵfac: i0.ɵɵFactoryDeclaration<TipoContratoTrabalhoService, never>;
+    static ɵprov: i0.ɵɵInjectableDeclaration<TipoContratoTrabalhoService>;
+}

package/lib/services/dominio/tipo-dados-pessoa.service.d.ts

@@ -0,0 +1,18 @@
+import { BaseApiService, HostEnvironment } from "keevo-api-services";
+import { HttpClient } from '@angular/common/http';
+import { Observable } from 'rxjs';
+import TipoDadosPessoaModel from "../../models/dominio/tipodadospessoa.model";
+import * as i0 from "@angular/core";
+export declare class TipoDadosPessoaService extends BaseApiService {
+    private httpClient;
+    private hostEnv;
+    private rotaListar;
+    private rotaExisteID;
+    private rotaSelecionar;
+    constructor(httpClient: HttpClient, hostEnv: HostEnvironment);
+    Listar(): Observable<TipoDadosPessoaModel[]>;
+    ExisteID(idtipodadospessoa: number): Observable<boolean>;
+    Selecionar(idtipodadospessoa: number): Observable<TipoDadosPessoaModel>;
+    static ɵfac: i0.ɵɵFactoryDeclaration<TipoDadosPessoaService, never>;
+    static ɵprov: i0.ɵɵInjectableDeclaration<TipoDadosPessoaService>;
+}

package/lib/services/dominio/tipo-dependencia-irrf.service.d.ts

@@ -0,0 +1,18 @@
+import { BaseApiService, HostEnvironment } from "keevo-api-services";
+import { HttpClient } from '@angular/common/http';
+import { Observable } from 'rxjs';
+import TipoDependenciaIrrfModel from "../../models/dominio/tipodependenciairrf.model";
+import * as i0 from "@angular/core";
+export declare class TipoDependenciaIrrfService extends BaseApiService {
+    private httpClient;
+    private hostEnv;
+    private rotaListar;
+    private rotaExisteID;
+    private rotaSelecionar;
+    constructor(httpClient: HttpClient, hostEnv: HostEnvironment);
+    Listar(): Observable<TipoDependenciaIrrfModel[]>;
+    ExisteID(idtipodependenciairrf: number): Observable<boolean>;
+    Selecionar(idtipodependenciairrf: number): Observable<TipoDependenciaIrrfModel>;
+    static ɵfac: i0.ɵɵFactoryDeclaration<TipoDependenciaIrrfService, never>;
+    static ɵprov: i0.ɵɵInjectableDeclaration<TipoDependenciaIrrfService>;
+}

package/lib/services/dominio/tipo-dependente-esocial.service.d.ts

@@ -0,0 +1,18 @@
+import { BaseApiService, HostEnvironment } from "keevo-api-services";
+import { HttpClient } from '@angular/common/http';
+import { Observable } from 'rxjs';
+import { TipoDependenteESocialModel } from "../../models/dominio/tipodependenteesocial.model";
+import * as i0 from "@angular/core";
+export declare class TipoDependenteESocialService extends BaseApiService {
+    private httpClient;
+    private hostEnv;
+    private rotaListar;
+    private rotaExisteID;
+    private rotaSelecionar;
+    constructor(httpClient: HttpClient, hostEnv: HostEnvironment);
+    Listar(): Observable<TipoDependenteESocialModel[]>;
+    ExisteID(idtipodependente: number): Observable<boolean>;
+    Selecionar(idtipodependente: number): Observable<TipoDependenteESocialModel>;
+    static ɵfac: i0.ɵɵFactoryDeclaration<TipoDependenteESocialService, never>;
+    static ɵprov: i0.ɵɵInjectableDeclaration<TipoDependenteESocialService>;
+}

package/lib/services/dominio/tipo-dia-trabalhado.service.d.ts

@@ -0,0 +1,18 @@
+import { BaseApiService, HostEnvironment } from "keevo-api-services";
+import { HttpClient } from '@angular/common/http';
+import { Observable } from 'rxjs';
+import TipoDiaTrabalhadoModel from "../../models/dominio/tipodiatrabalhado.model";
+import * as i0 from "@angular/core";
+export declare class TipoDiaTrabalhadoService extends BaseApiService {
+    private httpClient;
+    private hostEnv;
+    private rotaListar;
+    private rotaExisteID;
+    private rotaSelecionar;
+    constructor(httpClient: HttpClient, hostEnv: HostEnvironment);
+    Listar(): Observable<TipoDiaTrabalhadoModel[]>;
+    ExisteID(idtipodiatrabalhado: number): Observable<boolean>;
+    Selecionar(idtipodiatrabalhado: number): Observable<TipoDiaTrabalhadoModel>;
+    static ɵfac: i0.ɵɵFactoryDeclaration<TipoDiaTrabalhadoService, never>;
+    static ɵprov: i0.ɵɵInjectableDeclaration<TipoDiaTrabalhadoService>;
+}

package/lib/services/dominio/tipo-entidade-hcm.service.d.ts

@@ -0,0 +1,18 @@
+import { BaseApiService, HostEnvironment } from "keevo-api-services";
+import { HttpClient } from '@angular/common/http';
+import { Observable } from 'rxjs';
+import TipoEntidadeHcmModel from "../../models/dominio/tipoentidadehcm.model";
+import * as i0 from "@angular/core";
+export declare class TipoEntidadeHcmService extends BaseApiService {
+    private httpClient;
+    private hostEnv;
+    private rotaListar;
+    private rotaExisteID;
+    private rotaSelecionar;
+    constructor(httpClient: HttpClient, hostEnv: HostEnvironment);
+    Listar(): Observable<TipoEntidadeHcmModel[]>;
+    ExisteID(idtipoentidadehcm: number): Observable<boolean>;
+    Selecionar(idtipoentidadehcm: number): Observable<TipoEntidadeHcmModel>;
+    static ɵfac: i0.ɵɵFactoryDeclaration<TipoEntidadeHcmService, never>;
+    static ɵprov: i0.ɵɵInjectableDeclaration<TipoEntidadeHcmService>;
+}

package/lib/services/dominio/tipo-folha.service.d.ts

@@ -0,0 +1,18 @@
+import { BaseApiService, HostEnvironment } from "keevo-api-services";
+import { HttpClient } from '@angular/common/http';
+import { Observable } from 'rxjs';
+import { TipoFolhaModel } from "../../models/dominio/tipofolha.model";
+import * as i0 from "@angular/core";
+export declare class TipoFolhaService extends BaseApiService {
+    private httpClient;
+    private hostEnv;
+    private rotaListar;
+    private rotaExisteID;
+    private rotaSelecionar;
+    constructor(httpClient: HttpClient, hostEnv: HostEnvironment);
+    Listar(): Observable<TipoFolhaModel[]>;
+    ExisteID(idtipofolha: number): Observable<boolean>;
+    Selecionar(idtipofolha: number): Observable<TipoFolhaModel>;
+    static ɵfac: i0.ɵɵFactoryDeclaration<TipoFolhaService, never>;
+    static ɵprov: i0.ɵɵInjectableDeclaration<TipoFolhaService>;
+}

package/lib/services/dominio/tipo-funcionario.service.d.ts

@@ -0,0 +1,18 @@
+import { BaseApiService, HostEnvironment } from "keevo-api-services";
+import { HttpClient } from '@angular/common/http';
+import { Observable } from 'rxjs';
+import TipoFuncionarioModel from "../../models/dominio/tipofuncionario.model";
+import * as i0 from "@angular/core";
+export declare class TipoFuncionarioService extends BaseApiService {
+    private httpClient;
+    private hostEnv;
+    private rotaListar;
+    private rotaExisteID;
+    private rotaSelecionar;
+    constructor(httpClient: HttpClient, hostEnv: HostEnvironment);
+    Listar(): Observable<TipoFuncionarioModel[]>;
+    ExisteID(idtipofuncionario: number): Observable<boolean>;
+    Selecionar(idtipofuncionario: number): Observable<TipoFuncionarioModel>;
+    static ɵfac: i0.ɵɵFactoryDeclaration<TipoFuncionarioService, never>;
+    static ɵprov: i0.ɵɵInjectableDeclaration<TipoFuncionarioService>;
+}

package/lib/services/dominio/tipo-inss.service.d.ts

@@ -0,0 +1,18 @@
+import { BaseApiService, HostEnvironment } from "keevo-api-services";
+import { HttpClient } from '@angular/common/http';
+import { Observable } from 'rxjs';
+import TipoInssModel from "../../models/dominio/tipoinss.model";
+import * as i0 from "@angular/core";
+export declare class TipoInssService extends BaseApiService {
+    private httpClient;
+    private hostEnv;
+    private rotaListar;
+    private rotaExisteID;
+    private rotaSelecionar;
+    constructor(httpClient: HttpClient, hostEnv: HostEnvironment);
+    Listar(): Observable<TipoInssModel[]>;
+    ExisteID(idtipoinss: number): Observable<boolean>;
+    Selecionar(idtipoinss: number): Observable<TipoInssModel>;
+    static ɵfac: i0.ɵɵFactoryDeclaration<TipoInssService, never>;
+    static ɵprov: i0.ɵɵInjectableDeclaration<TipoInssService>;
+}

package/lib/services/dominio/tipo-jornada.service.d.ts

@@ -0,0 +1,18 @@
+import { BaseApiService, HostEnvironment } from "keevo-api-services";
+import { HttpClient } from '@angular/common/http';
+import { Observable } from 'rxjs';
+import TipoJornadaModel from "../../models/dominio/tipojornada.model";
+import * as i0 from "@angular/core";
+export declare class TipoJornadaService extends BaseApiService {
+    private httpClient;
+    private hostEnv;
+    private rotaListar;
+    private rotaExisteID;
+    private rotaSelecionar;
+    constructor(httpClient: HttpClient, hostEnv: HostEnvironment);
+    Listar(): Observable<TipoJornadaModel[]>;
+    ExisteID(idtipojornada: number): Observable<boolean>;
+    Selecionar(idtipojornada: number): Observable<TipoJornadaModel>;
+    static ɵfac: i0.ɵɵFactoryDeclaration<TipoJornadaService, never>;
+    static ɵprov: i0.ɵɵInjectableDeclaration<TipoJornadaService>;
+}

package/lib/services/dominio/tipo-lotacao.service.d.ts

@@ -0,0 +1,18 @@
+import { BaseApiService, HostEnvironment } from "keevo-api-services";
+import { HttpClient } from '@angular/common/http';
+import { Observable } from 'rxjs';
+import TipoLotacaoModel from "../../models/dominio/tipolotacao.model";
+import * as i0 from "@angular/core";
+export declare class TipoLotacaoService extends BaseApiService {
+    private httpClient;
+    private hostEnv;
+    private rotaListar;
+    private rotaExisteID;
+    private rotaSelecionar;
+    constructor(httpClient: HttpClient, hostEnv: HostEnvironment);
+    Listar(): Observable<TipoLotacaoModel[]>;
+    ExisteID(idtipolotacao: number): Observable<boolean>;
+    Selecionar(idtipolotacao: number): Observable<TipoLotacaoModel>;
+    static ɵfac: i0.ɵɵFactoryDeclaration<TipoLotacaoService, never>;
+    static ɵprov: i0.ɵɵInjectableDeclaration<TipoLotacaoService>;
+}

package/lib/services/dominio/tipo-motivo-salario-familia.service.d.ts

@@ -0,0 +1,18 @@
+import { BaseApiService, HostEnvironment } from "keevo-api-services";
+import { HttpClient } from '@angular/common/http';
+import { Observable } from 'rxjs';
+import TipoMotivoSalarioFamiliaModel from "../../models/dominio/tipomotivosalariofamilia.model";
+import * as i0 from "@angular/core";
+export declare class TipoMotivoSalarioFamiliaService extends BaseApiService {
+    private httpClient;
+    private hostEnv;
+    private rotaListar;
+    private rotaExisteID;
+    private rotaSelecionar;
+    constructor(httpClient: HttpClient, hostEnv: HostEnvironment);
+    Listar(): Observable<TipoMotivoSalarioFamiliaModel[]>;
+    ExisteID(idtipomotivosalariofamilia: number): Observable<boolean>;
+    Selecionar(idtipomotivosalariofamilia: number): Observable<TipoMotivoSalarioFamiliaModel>;
+    static ɵfac: i0.ɵɵFactoryDeclaration<TipoMotivoSalarioFamiliaService, never>;
+    static ɵprov: i0.ɵɵInjectableDeclaration<TipoMotivoSalarioFamiliaService>;
+}

package/lib/services/dominio/tipo-pagamento-salario.service.d.ts

@@ -0,0 +1,18 @@
+import { BaseApiService, HostEnvironment } from "keevo-api-services";
+import { HttpClient } from '@angular/common/http';
+import { Observable } from 'rxjs';
+import TipoPagamentoSalarioModel from "../../models/dominio/tipopagamentosalario.model";
+import * as i0 from "@angular/core";
+export declare class TipoPagamentoSalarioService extends BaseApiService {
+    private httpClient;
+    private hostEnv;
+    private rotaListar;
+    private rotaExisteID;
+    private rotaSelecionar;
+    constructor(httpClient: HttpClient, hostEnv: HostEnvironment);
+    Listar(): Observable<TipoPagamentoSalarioModel[]>;
+    ExisteID(idtipopagamentosalario: number): Observable<boolean>;
+    Selecionar(idtipopagamentosalario: number): Observable<TipoPagamentoSalarioModel>;
+    static ɵfac: i0.ɵɵFactoryDeclaration<TipoPagamentoSalarioService, never>;
+    static ɵprov: i0.ɵɵInjectableDeclaration<TipoPagamentoSalarioService>;
+}

package/lib/services/dominio/tipo-regime-previdenciario.service.d.ts

@@ -0,0 +1,18 @@
+import { BaseApiService, HostEnvironment } from "keevo-api-services";
+import { HttpClient } from '@angular/common/http';
+import { Observable } from 'rxjs';
+import TipoRegimePrevidenciarioModel from "../../models/dominio/tiporegimeprevidenciario.model";
+import * as i0 from "@angular/core";
+export declare class TipoRegimePrevidenciarioService extends BaseApiService {
+    private httpClient;
+    private hostEnv;
+    private rotaListar;
+    private rotaExisteID;
+    private rotaSelecionar;
+    constructor(httpClient: HttpClient, hostEnv: HostEnvironment);
+    Listar(): Observable<TipoRegimePrevidenciarioModel[]>;
+    ExisteID(idtiporegimetrabalhista: number): Observable<boolean>;
+    Selecionar(idtiporegimetrabalhista: number): Observable<TipoRegimePrevidenciarioModel>;
+    static ɵfac: i0.ɵɵFactoryDeclaration<TipoRegimePrevidenciarioService, never>;
+    static ɵprov: i0.ɵɵInjectableDeclaration<TipoRegimePrevidenciarioService>;
+}

package/lib/services/dominio/tipo-regime-trabalhista.service.d.ts

@@ -0,0 +1,18 @@
+import { BaseApiService, HostEnvironment } from "keevo-api-services";
+import { HttpClient } from '@angular/common/http';
+import { Observable } from 'rxjs';
+import TipoRegimeTrabalhistaModel from "../../models/dominio/tiporegimetrabalhista.model";
+import * as i0 from "@angular/core";
+export declare class TipoRegimeTrabalhistaService extends BaseApiService {
+    private httpClient;
+    private hostEnv;
+    private rotaListar;
+    private rotaExisteID;
+    private rotaSelecionar;
+    constructor(httpClient: HttpClient, hostEnv: HostEnvironment);
+    Listar(): Observable<TipoRegimeTrabalhistaModel[]>;
+    ExisteID(idtiporegimetrabalhista: number): Observable<boolean>;
+    Selecionar(idtiporegimetrabalhista: number): Observable<TipoRegimeTrabalhistaModel>;
+    static ɵfac: i0.ɵɵFactoryDeclaration<TipoRegimeTrabalhistaService, never>;
+    static ɵprov: i0.ɵɵInjectableDeclaration<TipoRegimeTrabalhistaService>;
+}

package/lib/services/dominio/tipo-reintegracao.service.d.ts

@@ -0,0 +1,18 @@
+import { BaseApiService, HostEnvironment } from "keevo-api-services";
+import { HttpClient } from '@angular/common/http';
+import { Observable } from 'rxjs';
+import TipoReintegracaoModel from "../../models/dominio/tiporeintegracao.model";
+import * as i0 from "@angular/core";
+export declare class TipoReintegracaoService extends BaseApiService {
+    private httpClient;
+    private hostEnv;
+    private rotaListar;
+    private rotaExisteID;
+    private rotaSelecionar;
+    constructor(httpClient: HttpClient, hostEnv: HostEnvironment);
+    Listar(): Observable<TipoReintegracaoModel[]>;
+    ExisteID(idtipotomador: number): Observable<boolean>;
+    Selecionar(idtipotomador: number): Observable<TipoReintegracaoModel>;
+    static ɵfac: i0.ɵɵFactoryDeclaration<TipoReintegracaoService, never>;
+    static ɵprov: i0.ɵɵInjectableDeclaration<TipoReintegracaoService>;
+}

package/lib/services/dominio/tipo-salario.service.d.ts

@@ -0,0 +1,18 @@
+import { BaseApiService, HostEnvironment } from "keevo-api-services";
+import { HttpClient } from '@angular/common/http';
+import { Observable } from 'rxjs';
+import { TipoSalarioModel } from "../../models/dominio/tiposalario.model";
+import * as i0 from "@angular/core";
+export declare class TipoSalarioService extends BaseApiService {
+    private httpClient;
+    private hostEnv;
+    private rotaListar;
+    private rotaExisteID;
+    private rotaSelecionar;
+    constructor(httpClient: HttpClient, hostEnv: HostEnvironment);
+    Listar(): Observable<TipoSalarioModel[]>;
+    ExisteID(idtipopagamentosalario: number): Observable<boolean>;
+    Selecionar(idtipopagamentosalario: number): Observable<TipoSalarioModel>;
+    static ɵfac: i0.ɵɵFactoryDeclaration<TipoSalarioService, never>;
+    static ɵprov: i0.ɵɵInjectableDeclaration<TipoSalarioService>;
+}

package/lib/services/dominio/tipo-sindicato.service.d.ts

@@ -0,0 +1,18 @@
+import { BaseApiService, HostEnvironment } from "keevo-api-services";
+import { HttpClient } from '@angular/common/http';
+import { Observable } from 'rxjs';
+import TipoSindicatoModel from "../../models/dominio/tiposindicato.model";
+import * as i0 from "@angular/core";
+export declare class TipoSindicatoService extends BaseApiService {
+    private httpClient;
+    private hostEnv;
+    private rotaListar;
+    private rotaExisteID;
+    private rotaSelecionar;
+    constructor(httpClient: HttpClient, hostEnv: HostEnvironment);
+    Listar(): Observable<TipoSindicatoModel[]>;
+    ExisteID(idtiposindicato: number): Observable<boolean>;
+    Selecionar(idtiposindicato: number): Observable<TipoSindicatoModel>;
+    static ɵfac: i0.ɵɵFactoryDeclaration<TipoSindicatoService, never>;
+    static ɵprov: i0.ɵɵInjectableDeclaration<TipoSindicatoService>;
+}

package/lib/services/dominio/tipo-tomador.service.d.ts

@@ -0,0 +1,18 @@
+import { BaseApiService, HostEnvironment } from "keevo-api-services";
+import { HttpClient } from '@angular/common/http';
+import { Observable } from 'rxjs';
+import TipoTomadorModel from "../../models/dominio/tipotomador.model";
+import * as i0 from "@angular/core";
+export declare class TipoTomadorService extends BaseApiService {
+    private httpClient;
+    private hostEnv;
+    private rotaListar;
+    private rotaExisteID;
+    private rotaSelecionar;
+    constructor(httpClient: HttpClient, hostEnv: HostEnvironment);
+    Listar(): Observable<TipoTomadorModel[]>;
+    ExisteID(idtipotomador: number): Observable<boolean>;
+    Selecionar(idtipotomador: number): Observable<TipoTomadorModel>;
+    static ɵfac: i0.ɵɵFactoryDeclaration<TipoTomadorService, never>;
+    static ɵprov: i0.ɵɵInjectableDeclaration<TipoTomadorService>;
+}

package/lib/services/dominio/tipo-transporte.service.d.ts

@@ -0,0 +1,18 @@
+import { BaseApiService, HostEnvironment } from "keevo-api-services";
+import { HttpClient } from '@angular/common/http';
+import { Observable } from 'rxjs';
+import TipoTransporteModel from "../../models/dominio/tipotransporte.model";
+import * as i0 from "@angular/core";
+export declare class TipoTransporteService extends BaseApiService {
+    private httpClient;
+    private hostEnv;
+    private rotaListar;
+    private rotaExisteID;
+    private rotaSelecionar;
+    constructor(httpClient: HttpClient, hostEnv: HostEnvironment);
+    Listar(): Observable<TipoTransporteModel[]>;
+    ExisteID(idtipotransporte: number): Observable<boolean>;
+    Selecionar(idtipotransporte: number): Observable<TipoTransporteModel>;
+    static ɵfac: i0.ɵɵFactoryDeclaration<TipoTransporteService, never>;
+    static ɵprov: i0.ɵɵInjectableDeclaration<TipoTransporteService>;
+}

package/lib/services/dominio/tipo-vinculo-empregaticio.service.d.ts

@@ -0,0 +1,18 @@
+import { BaseApiService, HostEnvironment } from "keevo-api-services";
+import { HttpClient } from '@angular/common/http';
+import { Observable } from 'rxjs';
+import TipoVinculoEmpregaticioModel from "../../models/dominio/tipovinculoempregaticio.model";
+import * as i0 from "@angular/core";
+export declare class TipoVinculoEmpregaticioService extends BaseApiService {
+    private httpClient;
+    private hostEnv;
+    private rotaListar;
+    private rotaExisteID;
+    private rotaSelecionar;
+    constructor(httpClient: HttpClient, hostEnv: HostEnvironment);
+    Listar(): Observable<TipoVinculoEmpregaticioModel[]>;
+    ExisteID(idtipovinculoempregaticio: number): Observable<boolean>;
+    Selecionar(idtipovinculoempregaticio: number): Observable<TipoVinculoEmpregaticioModel>;
+    static ɵfac: i0.ɵɵFactoryDeclaration<TipoVinculoEmpregaticioService, never>;
+    static ɵprov: i0.ɵɵInjectableDeclaration<TipoVinculoEmpregaticioService>;
+}