API Banner Messages
Print
Created by: Guillaume Isselin
Modified on: Wed, 22 Jan, 2025 at 9:59 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.
