a:2:{s:14:"__file_content";s:19:"alb-saved-templates";s:10:"faq-france";s:38652:"[av_section min_height='50' min_height_px='500px' padding='default' shadow='no-border-styling' bottom_border='no-border-styling' bottom_border_diagonal_color='#333333' bottom_border_diagonal_direction='' bottom_border_style='' custom_margin='0px' custom_margin_sync='true' custom_arrow_bg='' id='' color='main_color' background='bg_color' custom_bg='' background_gradient_color1='' background_gradient_color2='' background_gradient_direction='vertical' src='https://icas-france.com/wp-content/uploads/2019/06/FAQ_sw.jpg' attachment='558' attachment_size='full' attach='scroll' position='top right' repeat='stretch' video='' video_ratio='16:9' overlay_enable='aviaTBoverlay_enable' overlay_opacity='0.3' overlay_color='#212121' overlay_pattern='' overlay_custom_pattern='' av_element_hidden_in_editor='0' av_uid='av-jvx5oxmt' custom_class='sub-hero hide-tablet']
[av_one_full first min_height='' vertical_alignment='av-align-top' space='' margin='0px' margin_sync='true' row_boxshadow_color='' row_boxshadow_width='10' link='' linktarget='' link_hover='' padding='0px' padding_sync='true' highlight_size='1.1' border='' border_color='' radius='0px' radius_sync='true' column_boxshadow_color='' column_boxshadow_width='10' background='bg_color' background_color='' background_gradient_color1='' background_gradient_color2='' background_gradient_direction='vertical' src='' attachment='' attachment_size='' background_position='top left' background_repeat='no-repeat' animation='' mobile_breaking='av-break-at-tablet' mobile_display='' av_uid='av-dgqsb' custom_class='']

[av_heading heading='Qui sommes-nous ?' tag='h1' link_apply='' link='manually,http://' link_target='' style='blockquote modern-quote' size='55' subheading_active='' subheading_size='15' margin='' padding='10' color='custom-color-heading' custom_font='#ffffff' custom_class='' admin_preview_bg='' av-desktop-hide='' av-medium-hide='' av-small-hide='' av-mini-hide='' av-medium-font-size-title='35' av-small-font-size-title='35' av-mini-font-size-title='35' av-medium-font-size='' av-small-font-size='' av-mini-font-size='' av_uid='av-dv62t'][/av_heading]

[/av_one_full]
[/av_section]

[av_one_full first min_height='' vertical_alignment='av-align-top' space='no_margin' margin='0px' margin_sync='true' row_boxshadow_color='' row_boxshadow_width='10' link='' linktarget='' link_hover='' padding='0px' padding_sync='true' highlight_size='1.1' border='' border_color='' radius='0px' radius_sync='true' column_boxshadow_color='' column_boxshadow_width='10' background='bg_color' background_color='' background_gradient_color1='' background_gradient_color2='' background_gradient_direction='vertical' src='' attachment='' attachment_size='' background_position='top left' background_repeat='no-repeat' animation='' mobile_breaking='' mobile_display='' av_uid='av-9xphh' custom_class='']
[av_heading heading='ICAS est une organisation internationale, presque mondiale, qui a commencé il y a des décennies à s‘imposer comme un pionnier du PAE en Europe. Afin de pouvoir soutenir la clientèle, souvent composée de grandes entreprises internationales, de manière égale dans tous les pays, des sociétés nationales ICAS ont été progressivement créées dans toute l’Europe.  C‘est également le cas en France. Outre la France, nous couvrons aussi la Suisse, l’Allemagne, l‘Autriche, l’Italie et le Luxembourg. Grâce à notre réseau couvrant ces 6 pays, nous sommes qualifiés et habitués à comprendre et à traiter les questions transfrontalières ainsi qu‘à communiquer avec des personnes de pays et de cultures différents. Nous desservons maintenant des entreprises de toutes tailles et de tous les secteurs d’activité, avec un total de plus de 240 000 employés. Nous sommes le seul fournisseur de PAE certifié selon la norme ISO 9001 en termes du management de la qualité et nous portons également le label GoodPriv@cy pour la protection des données, conformément aux exigences du RGPD.' tag='h3' link_apply='' link='manually,http://' link_target='' style='blockquote modern-quote modern-centered' size='' subheading_active='' subheading_size='15' margin='' margin_sync='true' padding='0' color='' custom_font='#000000' av-medium-font-size-title='' av-small-font-size-title='' av-mini-font-size-title='' av-medium-font-size='' av-small-font-size='' av-mini-font-size='' av_uid='av-k2vtnrwd' custom_class='' admin_preview_bg=''][/av_heading]

[av_heading heading='Notre programme d’aide aux employés PAE, via une ligne d’écoute accessible 24h/24 7 jours/7, permet à tous les collaborateurs, ainsi qu’à leurs familles, de bénéficier d’un soutien psychologique ponctuel, d’un accompagnement à court ou moyen terme, ou de conseils juridiques ou professionnels, et ce avant que leurs problématiques n’aient des répercussions négatives sur leur concentration et leurs performances. Grâce à cette approche, vos collaborateurs restent en bonne santé, concentrés, performants et motivés.' tag='h3' link_apply='' link='manually,http://' link_target='' style='blockquote modern-quote modern-centered' size='' subheading_active='' subheading_size='15' margin='' padding='0' color='' custom_font='' custom_class='' admin_preview_bg='' av-desktop-hide='' av-medium-hide='' av-small-hide='' av-mini-hide='' av-medium-font-size-title='' av-small-font-size-title='' av-mini-font-size-title='' av-medium-font-size='' av-small-font-size='' av-mini-font-size='' av_uid='av-12zpx'][/av_heading]
[/av_one_full]

[av_section min_height='' min_height_px='500px' padding='huge' shadow='no-border-styling' bottom_border='no-border-styling' bottom_border_diagonal_color='#333333' bottom_border_diagonal_direction='' bottom_border_style='' custom_margin='0px' custom_margin_sync='true' custom_arrow_bg='' id='' color='main_color' background='bg_color' custom_bg='' background_gradient_color1='' background_gradient_color2='' background_gradient_direction='vertical' src='https://icas-france.com/wp-content/uploads/2019/07/half-left-large-color-box-yellow.png' attachment='903' attachment_size='full' attach='fixed' position='top left' repeat='no-repeat' video='' video_ratio='16:9' overlay_opacity='0.7' overlay_color='#ffffff' overlay_pattern='' overlay_custom_pattern='' av_element_hidden_in_editor='0' av_uid='av-162fy' custom_class='moving-bg']
[av_one_full first min_height='av-equal-height-column' vertical_alignment='av-align-middle' space='' margin='0px' margin_sync='true' row_boxshadow_color='' row_boxshadow_width='10' link='' linktarget='' link_hover='' padding='0px' padding_sync='true' highlight_size='1.1' border='' border_color='' radius='0px' radius_sync='true' column_boxshadow_color='' column_boxshadow_width='10' background='bg_color' background_color='' background_gradient_color1='' background_gradient_color2='' background_gradient_direction='vertical' src='' attachment='' attachment_size='' background_position='center center' background_repeat='contain' animation='bottom-to-top' mobile_breaking='' mobile_display='' av_uid='av-51gvu' custom_class='custom-linear-box']

[av_heading heading='INFORMATIONS DE BASE <br>RELATIVES AU FOURNISSEUR' tag='h2' link_apply='' link='manually,http://' link_target='' style='blockquote modern-quote modern-centered' size='50' subheading_active='' subheading_size='15' margin='' padding='10' color='' custom_font='' custom_class='' admin_preview_bg='' av-desktop-hide='' av-medium-hide='' av-small-hide='' av-mini-hide='' av-medium-font-size-title='30' av-small-font-size-title='30' av-mini-font-size-title='30' av-medium-font-size='' av-small-font-size='' av-mini-font-size='' av_uid='av-cplxp'][/av_heading]

[av_hr class='custom' height='50' shadow='no-shadow' position='center' custom_border='av-border-fat' custom_width='300px' custom_border_color='#0093d0' custom_margin_top='10px' custom_margin_bottom='60px' icon_select='no' custom_icon_color='' icon='ue808' font='entypo-fontello' av_uid='av-jvvteztx' custom_class='' admin_preview_bg='']

[/av_one_full][av_one_full first min_height='av-equal-height-column' vertical_alignment='av-align-middle' space='' margin='0px' margin_sync='true' row_boxshadow_color='' row_boxshadow_width='10' link='' linktarget='' link_hover='' padding='0px' padding_sync='true' highlight_size='1.1' border='' border_color='' radius='0px' radius_sync='true' column_boxshadow_color='' column_boxshadow_width='10' background='bg_color' background_color='' background_gradient_color1='' background_gradient_color2='' background_gradient_direction='vertical' src='' attachment='' attachment_size='' background_position='center center' background_repeat='contain' animation='bottom-to-top' mobile_breaking='av-break-at-tablet' mobile_display='' av_uid='av-51gvu' custom_class='custom-linear-box']

[av_toggle_container initial='0' mode='accordion' sort='' styling='av-minimal-toggle' colors='custom' font_color='#0a0a0a' background_color='' border_color='' hover_colors='' hover_background_color='#fee202' hover_font_color='#ffffff' colors_current='custom' font_color_current='' background_current='' background_color_current='#fee202' background_gradient_current_color1='' background_gradient_current_color2='' background_gradient_current_direction='vertical' av_uid='av-jvx8czm0' custom_class='custom-toggle']
[av_toggle title='Depuis quand votre entreprise existe-t-elle ?' tags='' av_uid='av-12qzb1']
Depuis 1987
[/av_toggle]
[av_toggle title='Combien de collaborateurs employez-vous ? Combien d‘entre eux travaillent à leur compte ? Combien d’entre eux occupent un poste permanent ?' tags='' av_uid='av-a01l9']
<strong>54 collaborateurs permanents</strong>

Contrats de coopération avec :
<ul>
 	<li>4 cabinets d'avocats</li>
 	<li>psychothérapeutes ou psychologues
<ul>
 	<li>France: 684</li>
 	<li>Allemagne : 237</li>
 	<li>Suisse : 153</li>
 	<li>Luxembourg : 16</li>
 	<li>Italie : 47</li>
 	<li>Autriche : 36</li>
</ul>
</li>
</ul>
[/av_toggle]
[av_toggle title='Combien d’entreprises tirent parti de votre offre et combien de collaborateurs emploient-elles ?' tags='' av_uid='av-2q4kt']
286 entreprises employant 244 000 collaborateurs
(Au 31/12/2018)
[/av_toggle]
[av_toggle title='Sur quel site vos conseillers sont-ils actifs ?' tags='' av_uid='av-mxfg5']
<p dir="ltr"><strong>France: </strong></p>

<ul>
 	<li dir="ltr">Psychologues au centre d’assistance de Zurich/Wallisellen</li>
 	<li dir="ltr">Avocats en France</li>
 	<li dir="ltr">Psychothérapeutes ou psychologues dans toute la France</li>
</ul>
<strong>Allemagne:</strong>
<ul>
 	<li>Psychologues au centre d'assistance de Zurich/Wallisellen</li>
 	<li>Avocats en Rhénanie-du-Nord-Westphalie</li>
 	<li>Psychothérapeutes sur l'ensemble du territoire fédéral</li>
</ul>
<strong>Suisse:</strong>
<ul>
 	<li>Psychologues et juristes au centre d'assistance de Zurich/Wallisellen</li>
 	<li>Psychothérapeutes dans toute la Suisse</li>
</ul>
<strong>Luxembourg:</strong>
<ul>
 	<li>Psychologues au centre d'assistance de Zurich/Wallisellen</li>
 	<li>Avocats au Luxembourg</li>
 	<li>Psychothérapeutes dans tout le Luxembourg</li>
</ul>
<strong>Italie:</strong>
<ul>
 	<li>Psychologues au centre d'assistance de Zurich/Wallisellen</li>
 	<li>Avocats à Milan</li>
 	<li>Psychothérapeutes dans toute l'Italie</li>
</ul>
<strong>Autriche:</strong>
<ul>
 	<li>Psychologues au centre d'assistance de Zurich/Wallisellen</li>
 	<li>Avocats à Dornbirn</li>
 	<li>Psychothérapeutes dans toute l'Autriche</li>
</ul>
[/av_toggle]
[av_toggle title='Disposez-vous d’un management de qualité ? Si oui, avez-vous obtenu une certification correspondante ?' tags='' av_uid='av-eru05']
<strong>Oui.</strong>
<ul>
 	<li>Certification de management de qualité ISO9001</li>
 	<li>Certification de protection des données GoodPriv@cy</li>
</ul>
<strong>Notre infrastructure informatique dispose par ailleurs de la certification :</strong>
<ul>
 	<li>Système de gestion de la qualité ISO9001</li>
 	<li>Sécurité informatique et de l'information ISO27001</li>
 	<li>Certificat de conformité RGPD</li>
</ul>
[/av_toggle]
[av_toggle title='Pouvez-vous fournir des références ?' tags='' av_uid='av-7rayd']
Oui. À l'issue d'un entretien individuel, nous vous fournirons volontiers les coordonnées des personnes référentes.
[/av_toggle]
[/av_toggle_container]

[/av_one_full]
[/av_section]

[av_section min_height='' min_height_px='500px' padding='huge' shadow='no-border-styling' bottom_border='no-border-styling' bottom_border_diagonal_color='#333333' bottom_border_diagonal_direction='' bottom_border_style='' custom_margin='0px' custom_margin_sync='true' custom_arrow_bg='' id='' color='main_color' background='bg_color' custom_bg='#0093d0' background_gradient_color1='' background_gradient_color2='' background_gradient_direction='vertical' src='https://icas-france.com/wp-content/uploads/2019/07/half-left-large-color-box-darkblue.png' attachment='908' attachment_size='full' attach='fixed' position='top left' repeat='no-repeat' video='' video_ratio='16:9' overlay_opacity='0.7' overlay_color='#ffffff' overlay_pattern='' overlay_custom_pattern='' av_element_hidden_in_editor='0' av_uid='av-162fy' custom_class='moving-bg']
[av_one_full first min_height='av-equal-height-column' vertical_alignment='av-align-middle' space='' margin='0px' margin_sync='true' row_boxshadow_color='' row_boxshadow_width='10' link='' linktarget='' link_hover='' padding='0px' padding_sync='true' highlight_size='1.1' border='' border_color='' radius='0px' radius_sync='true' column_boxshadow_color='' column_boxshadow_width='10' background='bg_color' background_color='' background_gradient_color1='' background_gradient_color2='' background_gradient_direction='vertical' src='' attachment='' attachment_size='' background_position='center center' background_repeat='contain' animation='bottom-to-top' mobile_breaking='' mobile_display='' av_uid='av-51gvu' custom_class='custom-linear-box']

[av_heading heading='AU SUJET DE LA <br>PRATIQUE DE CONSULTATION' tag='h2' link_apply='' link='manually,http://' link_target='' style='blockquote modern-quote modern-centered' size='50' subheading_active='' subheading_size='15' margin='' padding='10' color='custom-color-heading' custom_font='#ffffff' custom_class='' admin_preview_bg='' av-desktop-hide='' av-medium-hide='' av-small-hide='' av-mini-hide='' av-medium-font-size-title='30' av-small-font-size-title='30' av-mini-font-size-title='30' av-medium-font-size='' av-small-font-size='' av-mini-font-size='' av_uid='av-r0dkl'][/av_heading]

[av_hr class='custom' height='50' shadow='no-shadow' position='center' custom_border='av-border-fat' custom_width='300px' custom_border_color='#fee202' custom_margin_top='10px' custom_margin_bottom='60px' icon_select='no' custom_icon_color='' icon='ue808' font='entypo-fontello' av_uid='av-jvvteztx' custom_class='' admin_preview_bg='']

[/av_one_full][av_one_full first min_height='av-equal-height-column' vertical_alignment='av-align-top' space='' margin='0px' margin_sync='true' row_boxshadow_color='' row_boxshadow_width='10' link='' linktarget='' link_hover='' padding='0px' padding_sync='true' highlight_size='1.1' border='' border_color='' radius='0px' radius_sync='true' column_boxshadow_color='' column_boxshadow_width='10' background='bg_color' background_color='' background_gradient_color1='' background_gradient_color2='' background_gradient_direction='vertical' src='' attachment='' attachment_size='' background_position='center center' background_repeat='contain' animation='bottom-to-top' mobile_breaking='av-break-at-tablet' mobile_display='' av_uid='av-51gvu' custom_class='custom-linear-box']

[av_toggle_container initial='0' mode='accordion' sort='' styling='av-minimal-toggle' colors='' font_color='' background_color='' border_color='' hover_colors='' hover_background_color='' hover_font_color='' colors_current='' font_color_current='' background_current='' background_color_current='' background_gradient_current_color1='' background_gradient_current_color2='' background_gradient_current_direction='vertical' av_uid='av-jvx8czm0' custom_class='custom-toggle']
[av_toggle title='Pouvez-vous décrire deux ou trois cas typiques de votre quotidien en matière d’assistance aux employés ?' tags='' av_uid='av-3cc2n9']
<strong>Les sujets les plus abordés en relation avec le travail sont :</strong>
<ul>
 	<li>Les collaborateurs qui se plaignent d'une surcharge de travail et qui présentent déjà des symptômes tels que la démotivation, les troubles du sommeil, l'irritabilité, les troubles physiques, etc.</li>
 	<li>Les conflits sur le lieu de travail avec des collègues ou des supérieurs hiérarchiques sont, pour les personnes concernées, très pénibles et surviennent fréquemment.</li>
 	<li>Les supérieurs hiérarchiques et responsables RH font de plus en plus appel à nous car ils s'inquiètent pour leurs collaborateurs. Pour les motifs suivants par exemple :
<ul>
 	<li>Comportement particulier/changé</li>
 	<li>Forte prise ou perte de poids</li>
 	<li>Suspicion de problèmes d'alcool</li>
</ul>
</li>
</ul>
Dans ces cas, nous prodiguons des conseils à l'appelant sur la manière dont il pourrait organiser un entretien avec le collaborateur concerné, sur l'assistance qu'il pourrait lui fournir et sur les exigences qu'il pourrait lui imposer.

<strong>Comptent parmi les préoccupations privées les plus courantes :</strong>
<ul>
 	<li>Les problèmes relationnels, les conflits et les séparations.</li>
</ul>
[/av_toggle]
[av_toggle title='Quels cas sont les plus durs à traiter pour vous ?' tags='' av_uid='av-3728jh']
Porter assistance peut s'avérer compliqué lorsque le client ne demande pas spontanément de l'aide ou qu'il ne réalise pas la situation dans laquelle il se trouve.

Bien que nos conseillers soient en mesure de résoudre les cas de tendance suicidaire de par leur grande expérience et à l'aide de procédures éprouvées ainsi que d'une étroite collaboration, ceux-ci n'en sont pas moins affectés.
[/av_toggle]
[av_toggle title='Combien de temps au maximum peut durer une consultation ?' tags='' av_uid='av-34832l']
Cela varie. Une consultation peut ne durer que 30 minutes, mais il se peut aussi que nous accompagnions durant plusieurs mois un client traversant une période difficile.
[/av_toggle]
[av_toggle title='Comment assurez-vous la disponibilité continue de votre service d’assistance téléphonique ?' tags='' av_uid='av-2w6thp']
Grâce à un plan de travail et une présence d'effectifs calculée. Des remplaçants se tiennent également à disposition sur demande.

De plus, deux installations téléphoniques indépendantes l'une de l'autre garantissent une disponibilité technique.
[/av_toggle]
[av_toggle title='Disposez-vous d‘une gestion de l’assistance ?  Si oui, comment fonctionne-t-elle exactement ?  Y a-t-il une procédure en place ? ' tags='' av_uid='av-2p58mt']
Oui. Un accompagnement rigoureux réalisé par nos soins et/ou par nos psychothérapeutes garantit l'assistance dont ont besoin nos clients.

Oui, en tant que fournisseur ayant obtenu la certification ISO9001, nous disposons d'une procédure pour chaque processus de travail.
[/av_toggle]
[av_toggle title='Si non, comment procédez-vous lorsque la consultation est terminée mais que le client nécessite encore de l’aide ?' tags='' av_uid='av-9ig3p']
Notre consultation n'est pas terminée tant que le client a besoin d'aide.
[/av_toggle]
[av_toggle title='Disposez-vous d’une gestion systématique des plaintes ? Si oui, pouvez-vous nous la décrire ?' tags='' av_uid='av-2dgrad']
Oui. Nos responsables de la protection des données et de la qualité ainsi que la direction sont informés de chaque plainte et lancent la procédure correspondante. Un taux de moins de 0,1 % de plainte par cas a été fixé comme objectif à atteindre par les collaborateurs.
[/av_toggle]
[av_toggle title='Comment gérez-vous les cas d‘extrême urgence comme un appel au milieu de la nuit d’une personne suicidaire ?' tags='' av_uid='av-2b3sn9']
Notre centre d'assistance emploie des psychologues chevronnés qui sont joignables 24 heures sur 24, 7 jours sur 7 durant toute l'année. En cas de risques de danger, des procédures éprouvées sont lancées afin de secourir la personne en détresse.
[/av_toggle]
[av_toggle title='Que pouvons-nous attendre de vous si ce cas de figure ou un autre évènement survient sur notre site ?' tags='' av_uid='av-245zl9']
Nous pouvons envoyer sur demande des psychologues et/ou des psychothérapeutes sur place.

Ceux-ci jouissent d'une vaste expérience et ont suivi des formations continues en matière de psychologie d'urgence, de gestion des traumatismes, de prévention de la violence, etc.
[/av_toggle]
[av_toggle title='Comment procédez-vous si vous constatez un fait délictuel au sein de l’entreprise ?' tags='' av_uid='av-1ucfyt']
La protection des données prévoit les exceptions suivantes au secret professionnel :
<ul>
 	<li>Danger menaçant la vie ou l'intégrité corporelle de la personne ou d'autrui (par ex. menaces de mort et de blessures, crise suicidaire, terrorisme)</li>
</ul>
Conformément à la loi, nous ne pouvons informer nos entreprises clientes en cas de vol, d'escroquerie ou encore de détournement. Nos conseillers soulignent néanmoins aux clients l'importance de notifier l'entreprise de telles informations et les accompagnent lors de cette démarche le cas échéant.
[/av_toggle]
[av_toggle title='Comment documentez-vous votre travail ?' tags='' av_uid='av-1o9zrp']
Chaque client obtient un rapport semestriel et/ou annuel anonyme. Y figurent le nombre de cas de recours à nos services et les sujets traités (répartis selon leur caractère professionnel ou privé). Le rapport comprend une analyse poussée, des comparaisons par rapport à des résultats de référence et, si besoin est, des propositions de mesures.

Les rapports sont anonymes et ne permettent aucunement de déduire l'identité des appelants. Afin de protéger l'anonymat des appelants, des rapports ne sont créés que pour les entreprises employant plus de 100 collaborateurs.
[/av_toggle]
[/av_toggle_container]

[/av_one_full]
[/av_section]

[av_section min_height='' min_height_px='500px' padding='huge' shadow='no-border-styling' bottom_border='no-border-styling' bottom_border_diagonal_color='#333333' bottom_border_diagonal_direction='' bottom_border_style='' custom_margin='0px' custom_margin_sync='true' custom_arrow_bg='' id='' color='main_color' background='bg_color' custom_bg='' background_gradient_color1='' background_gradient_color2='' background_gradient_direction='vertical' src='https://icas-france.com/wp-content/uploads/2019/07/half-right-large-color-box-yellow.png' attachment='905' attachment_size='full' attach='fixed' position='top right' repeat='no-repeat' video='' video_ratio='16:9' overlay_opacity='0.7' overlay_color='#ffffff' overlay_pattern='' overlay_custom_pattern='' av_element_hidden_in_editor='0' av_uid='av-162fy' custom_class='moving-bg']
[av_one_full first min_height='av-equal-height-column' vertical_alignment='av-align-middle' space='' margin='0px' margin_sync='true' row_boxshadow_color='' row_boxshadow_width='10' link='' linktarget='' link_hover='' padding='0px' padding_sync='true' highlight_size='1.1' border='' border_color='' radius='0px' radius_sync='true' column_boxshadow_color='' column_boxshadow_width='10' background='bg_color' background_color='' background_gradient_color1='' background_gradient_color2='' background_gradient_direction='vertical' src='' attachment='' attachment_size='' background_position='center center' background_repeat='contain' animation='bottom-to-top' mobile_breaking='' mobile_display='' av_uid='av-51gvu' custom_class='custom-linear-box']

[av_heading heading='QUALIFICATIONS <br>DES CONSEILLERS' tag='h2' link_apply='' link='manually,http://' link_target='' style='blockquote modern-quote modern-centered' size='50' subheading_active='' subheading_size='15' margin='' padding='10' color='' custom_font='' custom_class='' admin_preview_bg='' av-desktop-hide='' av-medium-hide='' av-small-hide='' av-mini-hide='' av-medium-font-size-title='30' av-small-font-size-title='30' av-mini-font-size-title='30' av-medium-font-size='' av-small-font-size='' av-mini-font-size='' av_uid='av-ljq3h'][/av_heading]

[av_hr class='custom' height='50' shadow='no-shadow' position='center' custom_border='av-border-fat' custom_width='300px' custom_border_color='#0093d0' custom_margin_top='10px' custom_margin_bottom='60px' icon_select='no' custom_icon_color='' icon='ue808' font='entypo-fontello' av_uid='av-jvvteztx' custom_class='' admin_preview_bg='']

[/av_one_full][av_one_full first min_height='av-equal-height-column' vertical_alignment='av-align-middle' space='' margin='0px' margin_sync='true' row_boxshadow_color='' row_boxshadow_width='10' link='' linktarget='' link_hover='' padding='0px' padding_sync='true' highlight_size='1.1' border='' border_color='' radius='0px' radius_sync='true' column_boxshadow_color='' column_boxshadow_width='10' background='bg_color' background_color='' background_gradient_color1='' background_gradient_color2='' background_gradient_direction='vertical' src='' attachment='' attachment_size='' background_position='center center' background_repeat='contain' animation='bottom-to-top' mobile_breaking='av-break-at-tablet' mobile_display='' av_uid='av-51gvu' custom_class='custom-linear-box']

[av_toggle_container initial='0' mode='accordion' sort='' styling='av-minimal-toggle' colors='custom' font_color='#0a0a0a' background_color='' border_color='' hover_colors='' hover_background_color='' hover_font_color='' colors_current='' font_color_current='' background_current='' background_color_current='' background_gradient_current_color1='' background_gradient_current_color2='' background_gradient_current_direction='vertical' av_uid='av-jvx8czm0' custom_class='custom-toggle']
[av_toggle title='Quelles sont les qualifications minimales requises pour vos conseillers ?' tags='' av_uid='av-eq84t']
<strong>Psychologues :</strong>
<ul>
 	<li>Diplôme universitaire de psychologie</li>
 	<li>Expérience professionnelle de plusieurs années</li>
 	<li>Formation continue en psychothérapie ou en aide psychologique</li>
</ul>
<p dir="ltr"><strong>Juristes en France :</strong></p>

<ul>
 	<li dir="ltr">Admission au Barreau local</li>
 	<li dir="ltr">Titre d’avocat spécialisé en droit du travail, en droit du bail, en droit matrimonial, en droit de la famille, etc.</li>
</ul>
<strong>Juristes en Allemagne :</strong>
<ul>
 	<li>Admission au Barreau local</li>
 	<li>Titre d'avocat spécialisé en droit du travail, en droit du bail, en droit matrimonial, en droit de la famille, etc. conformément à la Loi sur les services juridiques en droit allemand, entrée en vigueur le 01/07/2008.</li>
</ul>
<strong>Juristes en Suisse :</strong>
<ul>
 	<li>Accomplissement d'études juridiques complètes</li>
 	<li>Formations continues réussies dans divers domaines juridiques</li>
</ul>
[/av_toggle]
[av_toggle title='Collaborez-vous également avec des travailleurs indépendants ? Si oui, comment garantissez-vous la qualité de leur travail ?' tags='' av_uid='av-betit']
Oui, avec des psychothérapeutes au sein de nos réseaux nationaux.

Les psychologues et psychothérapeutes (France), les psychologues psychothérapeutes (Allemagne) et psychothérapeutes (Suisse)
<ul>
 	<li>doivent être membres d'une association professionnelle</li>
 	<li>nécessitent une autorisation d'exercer</li>
 	<li>supervision obligatoire</li>
 	<li>respect de nos normes de qualité</li>
 	<li>contrôle de la qualité au travers d'évaluations anonymes faites par nos clients</li>
</ul>
[/av_toggle]
[av_toggle title='Quelles mesures de garantie de la qualité mettez-vous en œuvre ?' tags='' av_uid='av-19el2t']
Nous avons obtenu la certification ISO9001 relative à la gestion de la qualité et faisons continuellement l'objet d'audits internes et externes.

Notre gestionnaire de la qualité veille à l'observation stricte de nos normes de qualité élevées.
[/av_toggle]
[av_toggle title='Quelles mesures de formation continue de vos collaborateurs mettez-vous en œuvre ?' tags='' av_uid='av-12yput']
Notre concept de formation continue comprend 6 à 8 formations internes par an.

De plus, chaque collaborateur se voit allouer un budget annuel de formations externes.

Nos collaborateurs du centre d'assistance sont par ailleurs tenus de recourir à une supervision interne et externe.
[/av_toggle]
[/av_toggle_container]

[/av_one_full]
[/av_section]

[av_section min_height='' min_height_px='500px' padding='huge' shadow='no-border-styling' bottom_border='no-border-styling' bottom_border_diagonal_color='#333333' bottom_border_diagonal_direction='' bottom_border_style='' custom_margin='0px' custom_margin_sync='true' custom_arrow_bg='' id='' color='main_color' background='bg_color' custom_bg='#0093d0' background_gradient_color1='' background_gradient_color2='' background_gradient_direction='vertical' src='https://icas-france.com/wp-content/uploads/2019/07/half-right-large-color-box-darkblue.png' attachment='1040' attachment_size='full' attach='fixed' position='top right' repeat='no-repeat' video='' video_ratio='16:9' overlay_opacity='0.7' overlay_color='#ffffff' overlay_pattern='' overlay_custom_pattern='' av_element_hidden_in_editor='0' av_uid='av-162fy' custom_class='moving-bg']
[av_one_full first min_height='av-equal-height-column' vertical_alignment='av-align-middle' space='' margin='0px' margin_sync='true' row_boxshadow_color='' row_boxshadow_width='10' link='' linktarget='' link_hover='' padding='0px' padding_sync='true' highlight_size='1.1' border='' border_color='' radius='0px' radius_sync='true' column_boxshadow_color='' column_boxshadow_width='10' background='bg_color' background_color='' background_gradient_color1='' background_gradient_color2='' background_gradient_direction='vertical' src='' attachment='' attachment_size='' background_position='center center' background_repeat='contain' animation='bottom-to-top' mobile_breaking='' mobile_display='' av_uid='av-51gvu' custom_class='custom-linear-box']

[av_heading heading='RESPECT DE LA <br>PROTECTION DES DONNÉES' tag='h2' link_apply='' link='manually,http://' link_target='' style='blockquote modern-quote modern-centered' size='50' subheading_active='' subheading_size='15' margin='' padding='10' color='custom-color-heading' custom_font='#ffffff' custom_class='' admin_preview_bg='' av-desktop-hide='' av-medium-hide='' av-small-hide='' av-mini-hide='' av-medium-font-size-title='30' av-small-font-size-title='30' av-mini-font-size-title='30' av-medium-font-size='' av-small-font-size='' av-mini-font-size='' av_uid='av-fmsz1'][/av_heading]

[av_hr class='custom' height='50' shadow='no-shadow' position='center' custom_border='av-border-fat' custom_width='300px' custom_border_color='#fee202' custom_margin_top='10px' custom_margin_bottom='60px' icon_select='no' custom_icon_color='' icon='ue808' font='entypo-fontello' av_uid='av-jvvteztx' custom_class='' admin_preview_bg='']

[/av_one_full][av_one_full first min_height='av-equal-height-column' vertical_alignment='av-align-middle' space='' margin='0px' margin_sync='true' row_boxshadow_color='' row_boxshadow_width='10' link='' linktarget='' link_hover='' padding='0px' padding_sync='true' highlight_size='1.1' border='' border_color='' radius='0px' radius_sync='true' column_boxshadow_color='' column_boxshadow_width='10' background='bg_color' background_color='' background_gradient_color1='' background_gradient_color2='' background_gradient_direction='vertical' src='' attachment='' attachment_size='' background_position='center center' background_repeat='contain' animation='bottom-to-top' mobile_breaking='' mobile_display='' av_uid='av-51gvu' custom_class='custom-linear-box']

[av_toggle_container initial='0' mode='accordion' sort='' styling='av-minimal-toggle' colors='' font_color='' background_color='' border_color='' hover_colors='' hover_background_color='' hover_font_color='' colors_current='' font_color_current='' background_current='' background_color_current='' background_gradient_current_color1='' background_gradient_current_color2='' background_gradient_current_direction='vertical' av_uid='av-jvx8czm0' custom_class='custom-toggle']
[av_toggle title='Comment se déroule l’enregistrement des données personnelles de nos collaborateurs et qui en est responsable ?' tags='' av_uid='av-8d1d1']
Nous disposons d'une solution de base de données sur mesure qui remplit tous les critères de sécurité. Les cas y sont enregistrés de manière anonyme, c'est-à-dire sans la moindre donnée personnelle.

Si un psychothérapeute ou psychologue devait avoir besoin d'un numéro de téléphone ou d'une adresse e-mail en vue de l'organisation de séances de consultation individuelles, ceux-ci seraient supprimés à la clôture du cas.
[/av_toggle]
[av_toggle title='Qui veille au respect de la loi fédérale de protection des données ? Une procédure correspondante a-t-elle été mise en place de votre côté ?' tags='' av_uid='av-p0zct']
Nous faisons continuellement l'objet d'audits internes et externes suite à notre obtention de la certification de protection des données GoodPriv@cy mondialement reconnue, ce qui garantit le respect de la loi.

Notre responsable de la protection des données s'assure de l'observation rigoureuse des dispositions légales applicables, s'informe continuellement des amendements législatifs et apporte des modifications le cas échéant.
[/av_toggle]
[/av_toggle_container]

[/av_one_full]
[/av_section]

[av_section min_height='' min_height_px='500px' padding='huge' shadow='no-border-styling' bottom_border='no-border-styling' bottom_border_diagonal_color='#333333' bottom_border_diagonal_direction='' bottom_border_style='' custom_margin='0px' custom_margin_sync='true' custom_arrow_bg='' id='' color='main_color' background='bg_color' custom_bg='' background_gradient_color1='' background_gradient_color2='' background_gradient_direction='vertical' src='https://icas-france.com/wp-content/uploads/2019/07/half-left-large-color-box-yellow.png' attachment='903' attachment_size='full' attach='fixed' position='top left' repeat='no-repeat' video='' video_ratio='16:9' overlay_opacity='0.7' overlay_color='#ffffff' overlay_pattern='' overlay_custom_pattern='' av_element_hidden_in_editor='0' av_uid='av-162fy' custom_class='moving-bg']
[av_one_full first min_height='av-equal-height-column' vertical_alignment='av-align-middle' space='' margin='0px' margin_sync='true' row_boxshadow_color='' row_boxshadow_width='10' link='' linktarget='' link_hover='' padding='0px' padding_sync='true' highlight_size='1.1' border='' border_color='' radius='0px' radius_sync='true' column_boxshadow_color='' column_boxshadow_width='10' background='bg_color' background_color='' background_gradient_color1='' background_gradient_color2='' background_gradient_direction='vertical' src='' attachment='' attachment_size='' background_position='center center' background_repeat='contain' animation='bottom-to-top' mobile_breaking='' mobile_display='' av_uid='av-51gvu' custom_class='custom-linear-box']

[av_heading heading='VUE D’ENSEMBLE <br>DE LA COLLABORATION' tag='h2' link_apply='' link='manually,http://' link_target='' style='blockquote modern-quote modern-centered' size='50' subheading_active='' subheading_size='15' margin='' padding='10' color='' custom_font='' custom_class='' admin_preview_bg='' av-desktop-hide='' av-medium-hide='' av-small-hide='' av-mini-hide='' av-medium-font-size-title='30' av-small-font-size-title='30' av-mini-font-size-title='30' av-medium-font-size='' av-small-font-size='' av-mini-font-size='' av_uid='av-6vy3h'][/av_heading]

[av_hr class='custom' height='50' shadow='no-shadow' position='center' custom_border='av-border-fat' custom_width='300px' custom_border_color='#0093d0' custom_margin_top='10px' custom_margin_bottom='60px' icon_select='no' custom_icon_color='' icon='ue808' font='entypo-fontello' av_uid='av-jvvteztx' custom_class='' admin_preview_bg='']

[/av_one_full][av_one_full first min_height='av-equal-height-column' vertical_alignment='av-align-middle' space='' margin='0px' margin_sync='true' row_boxshadow_color='' row_boxshadow_width='10' link='' linktarget='' link_hover='' padding='0px' padding_sync='true' highlight_size='1.1' border='' border_color='' radius='0px' radius_sync='true' column_boxshadow_color='' column_boxshadow_width='10' background='bg_color' background_color='' background_gradient_color1='' background_gradient_color2='' background_gradient_direction='vertical' src='' attachment='' attachment_size='' background_position='center center' background_repeat='contain' animation='bottom-to-top' mobile_breaking='' mobile_display='' av_uid='av-51gvu' custom_class='custom-linear-box']

[av_toggle_container initial='0' mode='accordion' sort='' styling='av-minimal-toggle' colors='' font_color='' background_color='' border_color='' hover_colors='' hover_background_color='' hover_font_color='' colors_current='' font_color_current='' background_current='' background_color_current='' background_gradient_current_color1='' background_gradient_current_color2='' background_gradient_current_direction='vertical' av_uid='av-jvx8czm0' custom_class='custom-toggle']
[av_toggle title='Disposerez-vous de gestionnaires de grands comptes en cas de collaboration avec nous ?' tags='' av_uid='av-nqllp']
Oui. Nos gestionnaires de grands comptes sont des économistes d'entreprise chevronnés. Votre gestionnaire de comptes personnel se tient à votre disposition pour toutes demandes administratives.
[/av_toggle]
[av_toggle title='Pouvons-nous vous rendre visite pour nous faire notre propre opinion de votre travail ?' tags='' av_uid='av-fv4ct']
Oui, nous serons ravis de vous accueillir.

Nous attirons toutefois votre attention sur le fait que l'accès au centre d'assistance est interdit pour des raisons de protection des données.
[/av_toggle]
[av_toggle title='Nous connaissons actuellement deux personnes dans l‘entreprise qui sont confrontées à des problèmes personnels. Peuvent-elles bénéficier d’une consultation test pour que nous puissions nous faire une idée du fonctionnement de votre service ?' tags='' av_uid='av-8uukd']
Oui. Une fois le contrat conclu, ces cas entreront dans le cadre contractuel. En l'absence d'établissement d'un contrat, ces cas seront facturés en fonction de la charge de travail.
[/av_toggle]
[/av_toggle_container]

[/av_one_full]
[/av_section]";}