API Banner Messages
Print
Created by: Guillaume Isselin
Modified on: Wed, 9 Oct, 2024 at 11:48 AM
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
Guillaume is the author of this solution article.
Did you find it helpful?
Yes
No
Send feedback Sorry we couldn't be helpful. Help us improve this article with your feedback.
