text
stringlengths 1
22.8M
|
|---|
```java
/*
* DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
*
* This code is free software; you can redistribute it and/or modify it
* published by the Free Software Foundation. Oracle designates this
* particular file as subject to the "Classpath" exception as provided
* by Oracle in the LICENSE file that accompanied this code.
*
* This code is distributed in the hope that it will be useful, but WITHOUT
* ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
* version 2 for more details (a copy is included in the LICENSE file that
* accompanied this code).
*
* 2 along with this work; if not, write to the Free Software Foundation,
* Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
*
* Please contact Oracle, 500 Oracle Parkway, Redwood Shores, CA 94065 USA
* or visit www.oracle.com if you need additional information or have any
* questions.
*/
package org.graalvm.visualvm.lib.profiler.snaptracer.impl.timeline.items;
import org.graalvm.visualvm.lib.profiler.snaptracer.ItemValueFormatter;
import org.graalvm.visualvm.lib.profiler.snaptracer.ProbeItemDescriptor;
/**
*
* @author Jiri Sedlacek
*/
public abstract class ValueItemDescriptor extends ProbeItemDescriptor {
private final ItemValueFormatter formatter;
private final double dataFactor;
private final long minValue;
private final long maxValue;
ValueItemDescriptor(String name, String description,
ItemValueFormatter formatter, double dataFactor,
long minValue, long maxValue) {
super(name, description);
if (formatter == null) {
throw new IllegalArgumentException("formatter cannot be null"); // NOI18N
}
if (dataFactor == 0) {
throw new IllegalArgumentException("dataFactor cannot be 0"); // NOI18N
}
this.formatter = formatter;
this.dataFactor = dataFactor;
this.minValue = minValue;
this.maxValue = maxValue;
}
public final String getValueString(long value, int format) {
return formatter.formatValue(value, format);
}
public final String getUnitsString(int format) {
return formatter.getUnits(format);
}
public final double getDataFactor() {
return dataFactor;
}
public final long getMinValue() {
return minValue;
}
public final long getMaxValue() {
return maxValue;
}
}
```
|
Charles M. Fernandez (born February 8, 1962) is executive chairman and chief executive officer of NextPlat, an e-commerce platform company.
Early life and education
Fernandez was raised in Elmhurst, Queens. He is the son of Cuban immigrants. His father, Carlos, was an engineer for RCA. Fernandez moved to Miami in 1979. He attended Florida International University and graduated with a bachelor's degree in finance and international business.
Career
Fernandez began his career in the radio business. He served as President of Viva America Media Group which owned the newspaper, Mi Casa, along with Radio Mambi and Radio Ritmo in Miami, Fl. Viva was acquired by Heftel Broadcasting in 1989, and Fernandez became COO. They received the Marconi Radio Award by the National Association of Broadcasters. In 1995, Fernandez moved into the Healthcare sector and co-founded Continucare, an outpatient service management company, with Phillip Frost. In 1997, George Soros, became the largest shareholder of Continucare owning 19.5% via the Soros Fund. In 1999, Fernandez returned to media. He became president and CEO of Big City Radio after its acquisition of Hispanic Media Holdings, a Spanish language online service provider founded by Fernandez and business partner Phillip Frost. Fernandez also served in various positions within IVAX, a generic drugmaker, founded by Frost, including Director and Chairman of the Audit Committee of the Board of Directors
He became president and co-manager of the Fairholme Fund in 2008. In 2010, it was announced that Fernandez had joined the Board of Directors of the St. Joe Company along with former Florida Governor Charlie Crist and Carnival Corp. COO Howard Frank. That same year, Fortune Magazine called Fernandez, “a restructuring whiz”. He accumulated $1.8 billion General Growth Property bonds and alongside Bill Ackman’s Pershing Square and Brookfield Asset Management they recapitalized GGP’s stock. In 2012, he left the Fairholme Fund to launch his own, Barnstar Opportunities Fund. In 2016, Fernandez became chairman and CEO of eApeiron Solutions, an e-commerce company utilizing Kodak anti-counterfeiting technology and an investment from Chinese e-commerce company Alibaba to combat knock-offs and promote brand integrity. In 2019, was acquired by Smartrac, a unit of Avery Dennision Corporation with Fernandez serving on Smartrac's supervisory board of Directors.
Personal life
Fernandez lives in Coral Gables, Florida with his wife Lauren Sturges-Fernandez.
References
External links
NextPlat
Living people
1962 births
American chief executives
American people of Cuban descent
|
Jamestown is a village in Bienville Parish, Louisiana, United States. The population was 139 at the 2010 census and 130 in 2017.
Jamestown is west of Kepler Lake.
Notable people
Harvey Locke Carey, Louisiana lawyer and politician, spent his later years in a camp on Kepler Lake.
Lee Smith, a retired professional baseball Hall of Fame pitcher, was born there in 1957.
Enoch T. Nix, a banker in Bossier City and a 30-year member of the Louisiana State Board of Education and its replacement body, the Board of Elementary and Secondary Education, was born in Jamestown in 1920.
Geography
Jamestown is located in western Bienville Parish at (32.341201, -93.208366).
According to the United States Census Bureau, the village has a total area of , of which , or 1.19%, is water.
Climate
This climatic region is typified by large seasonal temperature differences, with warm to hot (and often humid) summers and mild winters. According to the Köppen Climate Classification system, Jamestown has a humid subtropical climate, abbreviated "Cfa" on climate maps.
Demographics
As of the census of 2000, there were 149 people, 60 households, and 36 families residing in the village. The population density was . There were 80 housing units at an average density of . The racial makeup of the village was 95.97% White, 3.36% African American and 0.67% Native American.
There were 60 households, out of which 26.7% had children under the age of 18 living with them, 48.3% were married couples living together, 6.7% had a female householder with no husband present, and 40.0% were non-families. 36.7% of all households were made up of individuals, and 16.7% had someone living alone who was 65 years of age or older. The average household size was 2.48 and the average family size was 3.33.
In the village, the population was spread out, with 26.8% under the age of 18, 8.7% from 18 to 24, 25.5% from 25 to 44, 22.1% from 45 to 64, and 16.8% who were 65 years of age or older. The median age was 37 years. For every 100 females, there were 75.3 males. For every 100 females age 18 and over, there were 81.7 males.
The median income for a household in the village was $23,125, and the median income for a family was $33,125. Males had a median income of $26,250 versus $21,875 for females. The per capita income for the village was $11,305. There were 6.9% of families and 9.1% of the population living below the poverty line, including no under eighteens and 33.3% of those over 64.
References
Villages in Bienville Parish, Louisiana
Villages in Louisiana
|
```c++
/*=============================================================================
file LICENSE_1_0.txt or copy at path_to_url
==============================================================================*/
#if !defined(BOOST_FUSION_AT_IMPL_20060223_2017)
#define BOOST_FUSION_AT_IMPL_20060223_2017
#include <string>
#include <boost/mpl/if.hpp>
#include <boost/mpl/int.hpp>
#include <boost/type_traits/is_const.hpp>
namespace example
{
struct example_sequence_tag;
}
namespace boost { namespace fusion {
namespace extension
{
template<typename Tag>
struct at_impl;
template<>
struct at_impl<example::example_sequence_tag>
{
template<typename Sequence, typename Key>
struct apply;
template<typename Sequence>
struct apply<Sequence, mpl::int_<0> >
{
typedef typename mpl::if_<
is_const<Sequence>,
std::string const&,
std::string&>::type type;
static type
call(Sequence& seq)
{
return seq.name;
};
};
template<typename Sequence>
struct apply<Sequence, mpl::int_<1> >
{
typedef typename mpl::if_<
is_const<Sequence>,
int const&,
int&>::type type;
static type
call(Sequence& seq)
{
return seq.age;
};
};
};
}
}}
#endif
```
|
Nanoor Assembly constituency is an assembly constituency in Birbhum district in the Indian state of West Bengal. It is reserved for scheduled castes.
Overview
As per orders of the Delimitation Commission, No. 287, Nanoor Assembly constituency (SC) is composed of the following: Nanoor CD Block, and Bahiri Panchshowa, Kankalitala, Kasba, Sarpalehana Albandha, Sian Muluk and Singhee gram panchayats of Bolpur Sriniketan CD Block.
Nanoor Assembly constituency is part of No. 41 Bolpur (Lok Sabha constituency) (SC).
Election results
2021
In the 2016 elections, Bidhan Chandra Majhi of Trinamool Congress defeated his nearest rival, Tarakeswar Saha of BJP.
2016
In the 2016 elections, Shyamali Pradhan of CPI(M) defeated her nearest rival Gadhadar Hazra of Trinamool Congress.
2011
In the 2011 elections, Gadhadar Hazra of Trinamool Congress defeated his nearest rival Shyamali Pradhan of CPI(M).
.# Swing calculated on Congress+Trinamool Congress vote percentages taken together in 2006.
1977–2006
In the 2006 state assembly elections, Joydeb Hazra of CPI(M) won the Nanoor (SC) seat defeating his nearest rival Gadadhar Hazra of Trinamool Congress. Contests in most years were multi cornered but only winners and runners are being mentioned. Ananda Gopal Das of CPI(M) defeated Krishnagopal Majhi of Trinamool Congress in 2001, Sibkinkar Saha of Congress in 1996 and 1991, and Adhir Kumar Saha of Congress in 1987. Banamali Das of CPI(M) defeated Sibkinkar Saha of Congress in 1982 and Dulal Saha of Congress in 1977.
1951–1972
Dulal Saha of Congress won in 1972. Banamali Das of CPI(M) won in 1971 and 1969. S.Jash of Congress won in 1967. The Nannor constituency was not there in 1962 and 1957. It was a joint seat in 1951. It was won by Sisir Kumar Saha and Basanta Lal Murarka, both of Congress.
References
Assembly constituencies of West Bengal
Politics of Birbhum district
|
Evo, in comics, may refer to:
EVO (comics), an Image Comics/Top Cow crossover
See also
Evo (disambiguation)
|
```xslt
<?xml version="1.0" encoding="utf-8"?>
<!--
(See accompanying file LICENSE_1_0.txt or copy at
path_to_url
-->
<xsl:stylesheet xmlns:xsl="path_to_url"
version="1.0">
<!-- Already included in the main style sheet -->
<!-- <xsl:import href="relative-href.xsl"/> -->
<!--
boost.defaults:
*none - only use explicitly set parameters
Boost - use standard boost settings, can be overridden
-->
<xsl:param name = "boost.defaults" select = "'none'"/>
<!--
how to render the Home | Libraries | ... | More contents
*none - do not display ("standalone" mode)
horizontal - display in old-Boost style format (default for Boost)
vertical - like the new Getting Started layout
-->
<xsl:param name = "nav.layout">
<xsl:choose>
<xsl:when test = "$boost.defaults='Boost'">horizontal</xsl:when>
<xsl:otherwise>none</xsl:otherwise>
</xsl:choose>
</xsl:param>
<!--
header border layout
Boost - place the old-Boost border around the header
Fullbleed - Simple CSS based full bleed header image
*none - do not place a border around the header
-->
<xsl:param name = "nav.border" select = "'none'" />
<!--
nav.flow:
none - do not display navigation at the header
DocBook - display the navigation after the header
*Spirit - display "mini" navigation on the right
-->
<xsl:param name = "nav.flow" select = "'Spirit'"/>
<!-- location of the various Boost elements -->
<xsl:param name = "boost.root" select = "'../..'"/>
<xsl:param name = "boost.website" select = "'path_to_url"/>
<!-- Logo image location, leave empty for no logo -->
<xsl:param name = "boost.image.src">
<xsl:if test = "$boost.defaults = 'Boost'">
<xsl:value-of select = "concat($boost.root, '/boost.png')"/>
</xsl:if>
</xsl:param>
<xsl:param name = "boost.image.alt">
<xsl:if test = "$boost.defaults = 'Boost'">
<xsl:value-of select = "'Boost C++ Libraries'"/>
</xsl:if>
</xsl:param>
<xsl:param name = "boost.image.w">
<xsl:if test = "$boost.defaults = 'Boost'">
<xsl:value-of select = "277"/>
</xsl:if>
</xsl:param>
<xsl:param name = "boost.image.h">
<xsl:if test = "$boost.defaults = 'Boost'">
<xsl:value-of select = "86"/>
</xsl:if>
</xsl:param>
<xsl:param name = "boost.libraries">
<xsl:if test = "$boost.defaults = 'Boost'">
<xsl:value-of select = "concat($boost.root, '/libs/libraries.htm')"/>
</xsl:if>
</xsl:param>
<!-- header -->
<xsl:template name = "header.navigation">
<xsl:param name = "prev" select = "/foo"/>
<xsl:param name = "next" select = "/foo"/>
<xsl:param name = "nav.context"/>
<xsl:variable name = "home" select = "/*[1]"/>
<xsl:variable name = "up" select = "parent::*"/>
<xsl:choose>
<xsl:when test = "$nav.border = 'Fullbleed'">
<xsl:if test = "boolean(normalize-space($boost.image.src))">
<div class="header-fullbleed">
<img alt="{$boost.image.alt}" width="{$boost.image.w}" height="{$boost.image.h}">
<xsl:attribute name="src">
<xsl:call-template name="href.target.relative">
<xsl:with-param name="target" select="$boost.image.src"/>
</xsl:call-template>
</xsl:attribute>
</img>
</div>
</xsl:if>
</xsl:when>
<xsl:when test = "boolean(normalize-space($boost.image.src)) or $nav.layout != 'none'">
<table cellpadding = "2" width = "100%"><tr>
<xsl:if test = "$nav.border = 'Boost'">
<xsl:attribute name = "class">boost-head</xsl:attribute>
</xsl:if>
<td valign = "top">
<xsl:if test = "$nav.border = 'Boost'">
<xsl:attribute name = "style">background-color: white; width: 50%;</xsl:attribute>
</xsl:if>
<xsl:if test = "boolean(normalize-space($boost.image.src))">
<img alt="{$boost.image.alt}" width="{$boost.image.w}" height="{$boost.image.h}">
<xsl:attribute name="src">
<xsl:call-template name="href.target.relative">
<xsl:with-param name="target" select="$boost.image.src"/>
</xsl:call-template>
</xsl:attribute>
</img>
</xsl:if>
</td><xsl:choose>
<xsl:when test = "$nav.layout = 'horizontal'">
<xsl:call-template name = "header.navdata-horiz"/>
</xsl:when><xsl:when test = "$nav.layout = 'vertical'">
<xsl:call-template name = "header.navdata-vert"/>
</xsl:when>
</xsl:choose>
</tr></table>
<hr/>
</xsl:when>
</xsl:choose>
<xsl:choose>
<xsl:when test = "$nav.flow = 'DocBook'">
<table width = "100%" class = "navheader">
<xsl:call-template name = "navbar.docbook-homeinfo">
<xsl:with-param name = "prev" select = "$prev"/>
<xsl:with-param name = "next" select = "$next"/>
<xsl:with-param name = "nav.context" select = "$nav.context"/>
</xsl:call-template>
<xsl:call-template name = "navbar.docbook-prevnext">
<xsl:with-param name = "prev" select = "$prev"/>
<xsl:with-param name = "next" select = "$next"/>
<xsl:with-param name = "nav.context" select = "$nav.context"/>
</xsl:call-template>
</table>
</xsl:when><xsl:when test = "$nav.flow = 'Spirit'">
<xsl:call-template name = "navbar.spirit">
<xsl:with-param name = "prev" select = "$prev"/>
<xsl:with-param name = "next" select = "$next"/>
<xsl:with-param name = "nav.context" select = "$nav.context"/>
</xsl:call-template>
</xsl:when>
</xsl:choose>
</xsl:template>
<xsl:template name = "header.navdata-horiz">
<xsl:variable name="home_link">
<xsl:call-template name="href.target.relative">
<xsl:with-param name="target" select="concat( $boost.root, '/index.html' )"/>
</xsl:call-template>
</xsl:variable>
<xsl:variable name="libraries_link">
<xsl:if test = "boolean($boost.libraries)">
<xsl:call-template name="href.target.relative">
<xsl:with-param name="target" select="$boost.libraries"/>
</xsl:call-template>
</xsl:if>
</xsl:variable>
<xsl:variable name="people_link">
<xsl:call-template name="href.target.relative">
<xsl:with-param name="target" select="concat( $boost.website, '/users/people.html' )"/>
</xsl:call-template>
</xsl:variable>
<xsl:variable name="faq_link">
<xsl:call-template name="href.target.relative">
<xsl:with-param name="target" select="concat( $boost.website, '/users/faq.html' )"/>
</xsl:call-template>
</xsl:variable>
<xsl:variable name="more_link">
<xsl:call-template name="href.target.relative">
<xsl:with-param name="target" select="concat( $boost.root, '/more/index.htm' )"/>
</xsl:call-template>
</xsl:variable>
<xsl:choose>
<xsl:when test = "$nav.border = 'Boost'">
<td align = "center" class = "boost-headtd"><a href = "{$home_link}" class = "boost-headelem">Home</a></td>
<xsl:if test = "boolean($libraries_link)">
<td align = "center" class = "boost-headtd"><a href = "{$libraries_link}" class = "boost-headelem">Libraries</a></td>
</xsl:if>
<td align = "center" class = "boost-headtd"><a href = "{$people_link}" class = "boost-headelem">People</a></td>
<td align = "center" class = "boost-headtd"><a href = "{$faq_link}" class = "boost-headelem">FAQ</a></td>
<td align = "center" class = "boost-headtd"><a href = "{$more_link}" class = "boost-headelem">More</a></td>
</xsl:when><xsl:otherwise>
<td align = "center"><a href = "{$home_link}">Home</a></td>
<td align = "center"><a href = "{$libraries_link}">Libraries</a></td>
<td align = "center"><a href = "{$people_link}">People</a></td>
<td align = "center"><a href = "{$faq_link}">FAQ</a></td>
<td align = "center"><a href = "{$more_link}">More</a></td>
</xsl:otherwise>
</xsl:choose>
</xsl:template>
<xsl:template name = "header.navdata-vert">
<xsl:variable name="home_link">
<xsl:call-template name="href.target.relative">
<xsl:with-param name="target" select="concat( $boost.root, '/index.html' )"/>
</xsl:call-template>
</xsl:variable>
<xsl:variable name="libraries_link">
<xsl:call-template name="href.target.relative">
<xsl:with-param name="target" select="$boost.libraries"/>
</xsl:call-template>
</xsl:variable>
<xsl:variable name="people_link">
<xsl:call-template name="href.target.relative">
<xsl:with-param name="target" select="concat( $boost.website, '/users/people.html' )"/>
</xsl:call-template>
</xsl:variable>
<xsl:variable name="faq_link">
<xsl:call-template name="href.target.relative">
<xsl:with-param name="target" select="concat( $boost.website, '/users/faq.html' )"/>
</xsl:call-template>
</xsl:variable>
<xsl:variable name="more_link">
<xsl:call-template name="href.target.relative">
<xsl:with-param name="target" select="concat( $boost.root, '/more/index.htm' )"/>
</xsl:call-template>
</xsl:variable>
<td><div>
<xsl:if test = "$nav.border != 'Boost'">
<xsl:attribute name = "class">boost-toc</xsl:attribute>
</xsl:if>
<div><a href = "{$home_link}">Home</a></div>
<div><a href = "{$libraries_link}">Libraries</a></div>
<div><a href = "{$people_link}">People</a></div>
<div><a href = "{$faq_link}">FAQ</a></div>
<div><a href = "{$more_link}">More</a></div>
</div></td>
</xsl:template>
<!-- footer -->
<xsl:template name = "footer.navigation">
<xsl:param name = "prev" select = "/foo"/>
<xsl:param name = "next" select = "/foo"/>
<xsl:param name = "nav.context"/>
<hr/>
<xsl:choose>
<xsl:when test = "$nav.flow = 'DocBook'">
<table width = "100%" class = "navheader">
<xsl:call-template name = "navbar.docbook-prevnext">
<xsl:with-param name = "prev" select = "$prev"/>
<xsl:with-param name = "next" select = "$next"/>
<xsl:with-param name = "nav.context" select = "$nav.context"/>
</xsl:call-template>
<xsl:call-template name = "navbar.docbook-homeinfo">
<xsl:with-param name = "prev" select = "$prev"/>
<xsl:with-param name = "next" select = "$next"/>
<xsl:with-param name = "nav.context" select = "$nav.context"/>
</xsl:call-template>
</table>
</xsl:when><xsl:when test = "$nav.flow = 'Spirit'">
<xsl:call-template name = "navbar.spirit">
<xsl:with-param name = "prev" select = "$prev"/>
<xsl:with-param name = "next" select = "$next"/>
<xsl:with-param name = "nav.context" select = "$nav.context"/>
</xsl:call-template>
</xsl:when>
</xsl:choose>
</xsl:template>
<!-- navbar -->
<xsl:template name = "navbar.docbook-homeinfo">
<xsl:param name = "prev" select = "/foo"/>
<xsl:param name = "next" select = "/foo"/>
<xsl:param name = "nav.context"/>
<xsl:variable name = "home" select = "/*[1]"/>
<tr>
<td align = "left" width = "40%">
<xsl:if test = "$navig.showtitles != 0"> <!-- prev:name -->
<xsl:apply-templates select = "$prev" mode = "object.title.markup"/>
</xsl:if>
</td><td align = "center" width = "20%">
<!-- home -->
<xsl:if test = "$home != . or $nav.context = 'toc'">
<a accesskey = "h">
<xsl:attribute name = "href"><xsl:call-template name = "href.target">
<xsl:with-param name = "object" select = "$home"/>
</xsl:call-template></xsl:attribute>
<xsl:call-template name = "navig.content">
<xsl:with-param name = "direction" select = "'home'"/>
</xsl:call-template>
</a>
<xsl:if test = "$chunk.tocs.and.lots != 0 and $nav.context != 'toc'">
<xsl:text>|</xsl:text>
</xsl:if>
</xsl:if>
<xsl:if test = "$chunk.tocs.and.lots != 0 and $nav.context != 'toc'"><a accesskey = "t">
<xsl:attribute name = "href">
<xsl:apply-templates select = "/*[1]" mode = "recursive-chunk-filename"/>
<xsl:text>-toc</xsl:text>
<xsl:value-of select = "$html.ext"/>
</xsl:attribute>
<xsl:call-template name = "gentext">
<xsl:with-param name = "key" select = "'nav-toc'"/>
</xsl:call-template>
</a></xsl:if>
</td><td align = "right" width = "40%">
<xsl:if test = "$navig.showtitles != 0"> <!-- next:name -->
<xsl:apply-templates select = "$next" mode = "object.title.markup"/>
</xsl:if>
</td>
</tr>
</xsl:template>
<xsl:template name = "navbar.docbook-prevnext">
<xsl:param name = "prev" select = "/foo"/>
<xsl:param name = "next" select = "/foo"/>
<xsl:param name = "nav.context"/>
<xsl:variable name = "up" select = "parent::*"/>
<tr>
<td align = "left" width = "40%">
<xsl:if test = "count($prev)>0"><a accesskey = "p"> <!-- prev -->
<xsl:attribute name = "href"><xsl:call-template name = "href.target">
<xsl:with-param name = "object" select = "$prev"/>
</xsl:call-template></xsl:attribute>
<xsl:call-template name = "navig.content">
<xsl:with-param name = "direction" select = "'prev'"/>
</xsl:call-template>
</a></xsl:if>
</td><td align = "center" width = "20%">
<xsl:if test = "count($up)>0"><a accesskey = "u"> <!-- up -->
<xsl:attribute name = "href"><xsl:call-template name = "href.target">
<xsl:with-param name = "object" select = "$up"/>
</xsl:call-template></xsl:attribute>
<xsl:call-template name = "navig.content">
<xsl:with-param name = "direction" select = "'up'"/>
</xsl:call-template>
</a></xsl:if>
</td><td align = "right" width = "40%">
<xsl:if test = "count($next)>0"><a accesskey = "n"> <!-- next -->
<xsl:attribute name = "href"><xsl:call-template name = "href.target">
<xsl:with-param name = "object" select = "$next"/>
</xsl:call-template></xsl:attribute>
<xsl:call-template name = "navig.content">
<xsl:with-param name = "direction" select = "'next'"/>
</xsl:call-template>
</a></xsl:if>
</td>
</tr>
</xsl:template>
<xsl:template name = "navbar.spirit">
<xsl:param name = "prev" select = "/foo"/>
<xsl:param name = "next" select = "/foo"/>
<xsl:param name = "nav.context"/>
<xsl:variable name = "home" select = "/*[1]"/>
<xsl:variable name = "up" select = "parent::*"/>
<div class = "spirit-nav">
<!-- prev -->
<xsl:if test = "count($prev)>0"><a accesskey = "p">
<xsl:attribute name = "href"><xsl:call-template name = "href.target">
<xsl:with-param name = "object" select = "$prev"/>
</xsl:call-template></xsl:attribute>
<xsl:call-template name = "navig.content">
<xsl:with-param name = "direction" select = "'prev'"/>
</xsl:call-template>
</a></xsl:if>
<!-- up -->
<xsl:if test = "count($up)>0"><a accesskey = "u">
<xsl:attribute name = "href"><xsl:call-template name = "href.target">
<xsl:with-param name = "object" select = "$up"/>
</xsl:call-template></xsl:attribute>
<xsl:call-template name = "navig.content">
<xsl:with-param name = "direction" select = "'up'"/>
</xsl:call-template>
</a></xsl:if>
<!-- home -->
<xsl:if test = "generate-id($home) != generate-id(.) or $nav.context = 'toc'">
<a accesskey = "h">
<xsl:attribute name = "href"><xsl:call-template name = "href.target">
<xsl:with-param name = "object" select = "$home"/>
</xsl:call-template></xsl:attribute>
<xsl:call-template name = "navig.content">
<xsl:with-param name = "direction" select = "'home'"/>
</xsl:call-template>
</a>
<xsl:if test = "$chunk.tocs.and.lots != 0 and $nav.context != 'toc'">
<xsl:text>|</xsl:text>
</xsl:if>
</xsl:if>
<xsl:if test = "$chunk.tocs.and.lots != 0 and $nav.context != 'toc'"><a accesskey = "t">
<xsl:attribute name = "href">
<xsl:apply-templates select = "/*[1]" mode = "recursive-chunk-filename"/>
<xsl:text>-toc</xsl:text>
<xsl:value-of select = "$html.ext"/>
</xsl:attribute>
<xsl:call-template name = "gentext">
<xsl:with-param name = "key" select = "'nav-toc'"/>
</xsl:call-template>
</a></xsl:if>
<!-- next -->
<xsl:if test = "count($next)>0"><a accesskey = "n">
<xsl:attribute name = "href"><xsl:call-template name = "href.target">
<xsl:with-param name = "object" select = "$next"/>
</xsl:call-template></xsl:attribute>
<xsl:call-template name = "navig.content">
<xsl:with-param name = "direction" select = "'next'"/>
</xsl:call-template>
</a></xsl:if>
</div>
</xsl:template>
</xsl:stylesheet>
```
|
```php
<?php
declare(strict_types=1);
namespace PhpOffice\PhpSpreadsheetTests\Reader\Csv;
use PhpOffice\PhpSpreadsheet\Reader\Csv;
use PhpOffice\PhpSpreadsheet\Shared\File;
use PHPUnit\Framework\TestCase;
class CsvLineEndingTest extends TestCase
{
private string $tempFile = '';
protected function tearDown(): void
{
if ($this->tempFile !== '') {
unlink($this->tempFile);
$this->tempFile = '';
}
}
/**
* @dataProvider providerEndings
*/
public function testEndings(string $ending): void
{
$this->tempFile = $filename = File::temporaryFilename();
$data = ['123', '456', '789'];
file_put_contents($filename, implode($ending, $data));
$reader = new Csv();
$spreadsheet = $reader->load($filename);
$sheet = $spreadsheet->getActiveSheet();
self::assertEquals($data[0], $sheet->getCell('A1')->getValue());
self::assertEquals($data[1], $sheet->getCell('A2')->getValue());
self::assertEquals($data[2], $sheet->getCell('A3')->getValue());
$spreadsheet->disconnectWorksheets();
}
/**
* @dataProvider providerEndings
*/
public function testEndingsNoDetect(string $ending): void
{
$this->tempFile = $filename = File::temporaryFilename();
$data = ['123', '456', '789'];
file_put_contents($filename, implode($ending, $data));
$reader = new Csv();
$reader->setTestAutoDetect(false);
$spreadsheet = $reader->load($filename);
$sheet = $spreadsheet->getActiveSheet();
if ($ending === "\r") {
// Can't handle Mac line endings without autoDetect
self::assertEquals(implode("\n", $data), $sheet->getCell('A1')->getValue());
self::assertNull($sheet->getCell('A2')->getValue());
self::assertNull($sheet->getCell('A3')->getValue());
} else {
self::assertEquals($data[0], $sheet->getCell('A1')->getValue());
self::assertEquals($data[1], $sheet->getCell('A2')->getValue());
self::assertEquals($data[2], $sheet->getCell('A3')->getValue());
}
$spreadsheet->disconnectWorksheets();
}
public static function providerEndings(): array
{
return [
'Unix endings' => ["\n"],
'Mac endings' => ["\r"],
'Windows endings' => ["\r\n"],
];
}
}
```
|
```javascript
Don't assume that HTML script tags are always run sequentially
Async and defer scripts
`top.location.href`
Navigation Timing API
Drag and Drop API
```
|
```yaml
---
features:
- |
Add support for new types of CI Visibility payloads to the Trace Agent, so
features that until now were Agentless-only are available as well when using
the Agent.
```
|
```php
<?php
declare(strict_types=1);
/**
* Passbolt ~ Open source password manager for teams
*
* For full copyright and license information, please see the LICENSE.txt
* Redistributions of files must retain the above copyright notice.
*
* @link path_to_url Passbolt(tm)
* @since 3.3.0
*/
namespace Passbolt\JwtAuthentication\Test\TestCase\Controller;
use App\Model\Entity\AuthenticationToken;
use App\Test\Factory\AuthenticationTokenFactory;
use App\Test\Factory\GpgkeyFactory;
use App\Test\Factory\RoleFactory;
use App\Test\Factory\UserFactory;
use App\Test\Lib\Model\EmailQueueTrait;
use App\Utility\UuidFactory;
use Cake\Database\Type\UuidType;
use Cake\Database\TypeFactory;
use Cake\Event\EventList;
use Cake\Event\EventManager;
use Cake\ORM\Locator\LocatorAwareTrait;
use Cake\Routing\Router;
use Cake\Validation\Validation;
use Passbolt\JwtAuthentication\Authenticator\GpgJwtAuthenticator;
use Passbolt\JwtAuthentication\JwtAuthenticationPlugin;
use Passbolt\JwtAuthentication\Test\Utility\JwtAuthenticationIntegrationTestCase;
use Passbolt\Log\Test\Lib\Traits\ActionLogsTestTrait;
/**
* Class AuthJwtLogoutControllerTest
*/
class JwtLoginControllerTest extends JwtAuthenticationIntegrationTestCase
{
use ActionLogsTestTrait;
use EmailQueueTrait;
use LocatorAwareTrait;
/**
* @var \App\Model\Table\AuthenticationTokensTable
*/
protected $AuthenticationTokens;
/**
* @var \App\Model\Table\UsersTable
*/
protected $Users;
/**
* @var \Passbolt\Log\Model\Table\ActionLogsTable
*/
protected $ActionLogs;
public function setUp(): void
{
parent::setUp();
$this->AuthenticationTokens = $this->fetchTable('AuthenticationTokens');
$this->Users = $this->fetchTable('Users');
$this->ActionLogs = $this->fetchTable('Passbolt/Log.ActionLogs');
$this->enableFeaturePlugin('Log');
$this->enableFeaturePlugin(JwtAuthenticationPlugin::class);
RoleFactory::make()->guest()->persist();
EventManager::instance()->setEventList(new EventList());
TypeFactory::map('uuid', UuidType::class);
}
public function testJwtLoginControllerTest_Success_With_Uppercase_Verify_Token()
{
$user = UserFactory::make()
->user()
->with('Gpgkeys', GpgkeyFactory::make()->validFingerprint())
->persist();
// The verify-token is on purpose here upper-cased to assert that it was not lower cased
// during the login action. This is required by Apple mobile devices
$verifyToken = strtoupper(UuidFactory::uuid());
$this->postJson('/auth/jwt/login.json', [
'user_id' => $user->id,
'challenge' => $this->makeChallenge($user, $verifyToken),
]);
$this->assertResponseOk('The authentication was a success.');
$this->assertEmailQueueCount(0);
$this->assertEventFired(GpgJwtAuthenticator::JWT_AUTHENTICATION_AFTER_IDENTIFY);
$challenge = json_decode($this->decryptChallenge($user, $this->_responseJsonBody->challenge));
$this->assertSame(Router::url('/', true), $challenge->domain);
$this->assertSame(GpgJwtAuthenticator::PROTOCOL_VERSION, $challenge->version);
$this->assertIsString($challenge->access_token);
$this->assertTrue(Validation::uuid($challenge->refresh_token));
$this->assertSame($verifyToken, $challenge->verify_token);
$this->assertSame(1, AuthenticationTokenFactory::find()->where(['token' => $challenge->refresh_token, 'user_id' => $user->id])->count());
$this->assertSame(1, AuthenticationTokenFactory::find()->where(['token' => $challenge->verify_token, 'user_id' => $user->id])->count());
// Assert login action log
$this->assertOneActionLog();
$this->assertActionLogExists([
'user_id' => $user->id,
'context' => 'POST /auth/jwt/login.json',
]);
}
public function testJwtLoginControllerTest_Consumed_Verify_Token()
{
$user = UserFactory::make()
->user()
->with('Gpgkeys', GpgkeyFactory::make()->validFingerprint())
->with(
'AuthenticationTokens',
AuthenticationTokenFactory::make()->type(AuthenticationToken::TYPE_VERIFY_TOKEN)
)
->persist();
$verifyToken = $user->authentication_tokens[0]->token;
$this->postJson('/auth/jwt/login.json', [
'user_id' => $user->id,
'challenge' => $this->makeChallenge($user, $verifyToken),
]);
$this->assertResponseError('The credentials are invalid.');
$this->assertEmailQueueCount(1);
$this->assertEmailIsInQueue([
'email' => $user->username,
'subject' => 'Authentication security alert',
'template' => 'Passbolt/JwtAuthentication.User/jwt_attack',
]);
$this->assertEmailInBatchContains('Verify token has been already used in the past.');
// Assert login action log
$this->assertOneActionLog();
$this->assertActionLogExists([
'user_id IS' => null,
'context' => 'POST /auth/jwt/login.json',
]);
}
public function testJwtLoginControllerTest_Failure_On_Deleted_User()
{
$user = UserFactory::make()
->user()
->with('Gpgkeys', GpgkeyFactory::make()->validFingerprint())
->persist();
$challenge = $this->makeChallenge($user, UuidFactory::uuid());
// Delete this user
$this->Users->softDelete($user);
$this->postJson('/auth/jwt/login.json', [
'user_id' => $user->id,
'challenge' => $challenge,
]);
$this->assertResponseError('The user does not exist or has been deleted.');
}
public function testJwtLoginControllerTest_Failure_On_Inactive_User()
{
$user = UserFactory::make()
->user()
->with('Gpgkeys', GpgkeyFactory::make()->validFingerprint())
->persist();
$challenge = $this->makeChallenge($user, UuidFactory::uuid());
// Deactivate this user
$this->Users->patchEntity($user, ['active' => false]);
$this->Users->saveOrFail($user);
$this->postJson('/auth/jwt/login.json', [
'user_id' => $user->id,
'challenge' => $challenge,
]);
$this->assertResponseError('The user does not exist or has been deleted.');
}
public function testJwtLoginControllerTest_FAILURE_CREDENTIALS_MISSING()
{
$this->postJson('/auth/jwt/login.json');
$this->assertResponseError('The credentials are missing.');
}
public function testJwtLoginControllerTest_FAILURE_IDENTITY_NOT_FOUND()
{
$this->postJson('/auth/jwt/login.json', [
'user_id' => UuidFactory::uuid(),
]);
$this->assertResponseError('The user does not exist or is not active or has been deleted.');
}
public function testJwtLoginControllerTest_User_Is_Already_LoggedIn_In_Session()
{
$user = UserFactory::make()
->user()
->with('Gpgkeys', GpgkeyFactory::make()->validFingerprint())
->persist();
$this->logInAs($user);
$this->getJson('/auth/is-authenticated.json');
$this->assertResponseOk();
$this->postJson('/auth/jwt/login.json', [
'user_id' => $user->id,
'challenge' => $this->makeChallenge($user, UuidFactory::uuid()),
]);
$this->assertResponseSuccess();
$challenge = json_decode($this->decryptChallenge($user, $this->_responseJsonBody->challenge));
$accessToken = $challenge->access_token;
$this->setJwtTokenInHeader($accessToken);
$this->getJson('/auth/is-authenticated.json');
$this->assertResponseOk();
$this->assertResponseOk('The authentication was a success.');
}
public function testSessionLoginWithJwtTokenInHeaderIsNotPermitted()
{
$this->createJwtTokenAndSetInHeader();
$this->getJson('/auth/login.json');
$this->assertResponseError('The route /auth/login is not permitted with JWT authentication.');
}
public function your_sha256_hashs_Token_Set_In_Header()
{
$user = UserFactory::make()
->user()
->with('Gpgkeys', GpgkeyFactory::make()->validFingerprint())
->persist();
$this->createJwtTokenAndSetInHeader($user->id);
$this->postJson('/auth/jwt/login.json', [
'user_id' => $user->id,
'challenge' => 'Bar',
]);
$this->assertBadRequestError('The credentials are invalid.');
}
}
```
|
```javascript
import Icon from '../../components/Icon.vue'
Icon.register({
'brands/app-store': {
width: 512,
height: 512,
paths: [
{
d: 'M255.9 120.9l9.1-15.7c5.6-9.8 18.1-13.1 27.9-7.5 9.8 5.6 13.1 18.1 7.5 27.9l-87.5 151.5h63.3c20.5 0 32 24.1 23.1 40.8h-185.5c-11.3 0-20.4-9.1-20.4-20.4s9.1-20.4 20.4-20.4h52l66.6-115.4-20.8-36.1c-5.6-9.8-2.3-22.2 7.5-27.9 9.8-5.6 22.2-2.3 27.9 7.5zM177.2 338.9l-19.6 34c-5.6 9.8-18.1 13.1-27.9 7.5-9.8-5.6-13.1-18.1-7.5-27.9l14.6-25.2c16.4-5.1 29.8-1.2 40.4 11.6zM346.1 277.2h53.1c11.3 0 20.4 9.1 20.4 20.4 0 11.3-9.1 20.4-20.4 20.4h-29.5l19.9 34.5c5.6 9.8 2.3 22.2-7.5 27.9-9.8 5.6-22.2 2.3-27.9-7.5-33.5-58.1-58.7-101.6-75.4-130.6-17.1-29.5-4.9-59.1 7.2-69.1 13.4 23 33.4 57.7 60.1 104zM256 8c137 0 248 111 248 248s-111 248-248 248-248-111-248-248 111-248 248-248zM472 256c0-119.9-97.3-216-216-216-119.9 0-216 97.3-216 216 0 119.9 97.3 216 216 216 119.9 0 216-97.3 216-216z'
}
]
}
})
```
|
Aaru Pushpangal () is a 1977 Indian Tamil-language film directed by K. M. Balakrishnan. It stars Rajinikanth, Vijayakumar and Srividya, with Y. Vijaya, Pandari Bai, S. V. Sahasranamam, Suruli Rajan and Manorama in supporting roles. It was released 10 November 1977.
Plot
Cast
Rajinikanth as Ravi
Y. Vijaya as Kumutha
Srividya as Mallika
Vijayakumar as Raja
Suruli Rajan as Kanthasamy
V. K. Ramasamy as Bangarusamy
Manorama as Meera (Guest appearance)
Pandari Bai as Malliga and Kumutha's mother
Production
Aaru Pushpangal is the first film where Rajinikanth and Vijayakumar acted together.
Soundtrack
The soundtrack was composed by M. S. Viswanathan. "Yendi Muthamma" is the debut of Chandrabose as a singer.
References
Bibliography
External links
1970s Tamil-language films
1977 films
Films scored by M. S. Viswanathan
Indian black-and-white films
|
Prof. Vicki Chen is an Australian engineer, a former Executive Dean for the Faculty of Engineering, Architecture and Information Technology at the University of Queensland, and current Provost and Senior Vice-President of the University of Technology Sydney.[10] In 2020 she was elected as the Fellow of Australian Academy of Technology and Engineering.
Chen was inspired to pursue engineering by her father, who also worked as a chemical engineer, viewing a path in engineering as "a career that could take [her] around the world and allow [her] to work in a wide variety of industries."
Chen received a Bachelor of Engineering degree from MIT, and went on to undertake her PhD in chemical engineering from the University of Minnesota in the area of surfactant self-assembly, including early work on microemulsion systems.
In recent years, Chen's research has focused on membrane science and engineering, with specific focus on nanocomposite membranes, fouling and advanced separations. This has facilitated a number of industry collaborations with partners including BASF, Dairy Innovation Australia, Australian Low Emission Coal R&D, Bluescope Steel, Coal Innovation NSW, Beijing OriginWater Technology, Printed Energy, and Sydney Water.
Chen is a prolific and highly cited engineer, having published more than 175 papers that have been cited >14,000 times, giving her an H-index of 64.
Chen spent nearly 30 years at UNSW in Sydney, Australia, going on to hold a number of senior administrative positions in research and higher education. She has been a full Professor since 2008, and acted as Head of the School of Chemical Engineering from 2014 to 2018. She was previously director of the UNESCO Centre for Membrane Science and Technology, at UNSW from 2006 to 2014.
Between August 2018 and November 2022, Chen was the Executive Dean for the Faculty of Engineering, Architecture and Information Technology at the University of Queensland, where she claimed to foster "a culture and ecosystem where our researchers and academics can flourish and contribute to the global thought leadership of their disciplines as well as translating the outcomes of their work to the wider community." During this time she was a driving force behind a Major Change proposal in the School of Architecture, that led to the disestablishment of all continuing academic appointments in the school, and the departure of seven senior architecture academics. In November 2022 Professor Chen commenced her position as the Provost and Senior Vice-President of the University of Technology Sydney.
References
Australian women engineers
Living people
Year of birth missing (living people)
Academic staff of the University of Queensland
MIT School of Engineering alumni
University of Minnesota College of Science and Engineering alumni
21st-century women engineers
|
```python
#
#
# path_to_url
#
# Unless required by applicable law or agreed to in writing, software
# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
"""Build BASNet models."""
from typing import Mapping
import tensorflow as tf, tf_keras
from official.modeling import tf_utils
from official.projects.basnet.modeling import nn_blocks
from official.vision.modeling.backbones import factory
# Specifications for BASNet encoder.
# Each element in the block configuration is in the following format:
# (num_filters, stride, block_repeats, maxpool)
BASNET_ENCODER_SPECS = [
(64, 1, 3, 0), # ResNet-34,
(128, 2, 4, 0), # ResNet-34,
(256, 2, 6, 0), # ResNet-34,
(512, 2, 3, 1), # ResNet-34,
(512, 1, 3, 1), # BASNet,
(512, 1, 3, 0), # BASNet,
]
# Specifications for BASNet decoder.
# Each element in the block configuration is in the following format:
# (conv1_nf, conv1_dr, convm_nf, convm_dr, conv2_nf, conv2_dr, scale_factor)
# nf : num_filters, dr : dilation_rate
BASNET_BRIDGE_SPECS = [
(512, 2, 512, 2, 512, 2, 32), # Sup0, Bridge
]
BASNET_DECODER_SPECS = [
(512, 1, 512, 2, 512, 2, 32), # Sup1, stage6d
(512, 1, 512, 1, 512, 1, 16), # Sup2, stage5d
(512, 1, 512, 1, 256, 1, 8), # Sup3, stage4d
(256, 1, 256, 1, 128, 1, 4), # Sup4, stage3d
(128, 1, 128, 1, 64, 1, 2), # Sup5, stage2d
(64, 1, 64, 1, 64, 1, 1) # Sup6, stage1d
]
@tf_keras.utils.register_keras_serializable(package='Vision')
class BASNetModel(tf_keras.Model):
"""A BASNet model.
Boundary-Awar network (BASNet) were proposed in:
[1] Qin, Xuebin, et al.
Basnet: Boundary-aware salient object detection.
Input images are passed through backbone first. Decoder network is then
applied, and finally, refinement module is applied on the output of the
decoder network.
"""
def __init__(self,
backbone,
decoder,
refinement=None,
**kwargs):
"""BASNet initialization function.
Args:
backbone: a backbone network. basnet_encoder.
decoder: a decoder network. basnet_decoder.
refinement: a module for salient map refinement.
**kwargs: keyword arguments to be passed.
"""
super(BASNetModel, self).__init__(**kwargs)
self._config_dict = {
'backbone': backbone,
'decoder': decoder,
'refinement': refinement,
}
self.backbone = backbone
self.decoder = decoder
self.refinement = refinement
def call(self, inputs, training=None): # pytype: disable=signature-mismatch # overriding-parameter-count-checks
features = self.backbone(inputs)
if self.decoder:
features = self.decoder(features)
levels = sorted(features.keys())
new_key = str(len(levels))
if self.refinement:
features[new_key] = self.refinement(features[levels[-1]])
return features
@property
def checkpoint_items(self):
"""Returns a dictionary of items to be additionally checkpointed."""
items = dict(backbone=self.backbone)
if self.decoder is not None:
items.update(decoder=self.decoder)
if self.refinement is not None:
items.update(refinement=self.refinement)
return items
def get_config(self):
return self._config_dict
@classmethod
def from_config(cls, config, custom_objects=None):
return cls(**config)
@tf_keras.utils.register_keras_serializable(package='Vision')
class BASNetEncoder(tf_keras.Model):
"""BASNet encoder."""
def __init__(
self,
input_specs=tf_keras.layers.InputSpec(shape=[None, None, None, 3]),
activation='relu',
use_sync_bn=False,
use_bias=True,
norm_momentum=0.99,
norm_epsilon=0.001,
kernel_initializer='VarianceScaling',
kernel_regularizer=None,
bias_regularizer=None,
**kwargs):
"""BASNet encoder initialization function.
Args:
input_specs: `tf_keras.layers.InputSpec` specs of the input tensor.
activation: `str` name of the activation function.
use_sync_bn: if True, use synchronized batch normalization.
use_bias: if True, use bias in conv2d.
norm_momentum: `float` normalization omentum for the moving average.
norm_epsilon: `float` small float added to variance to avoid dividing by
zero.
kernel_initializer: kernel_initializer for convolutional layers.
kernel_regularizer: tf_keras.regularizers.Regularizer object for Conv2D.
Default to None.
bias_regularizer: tf_keras.regularizers.Regularizer object for Conv2d.
Default to None.
**kwargs: keyword arguments to be passed.
"""
self._input_specs = input_specs
self._use_sync_bn = use_sync_bn
self._use_bias = use_bias
self._activation = activation
self._norm_momentum = norm_momentum
self._norm_epsilon = norm_epsilon
if use_sync_bn:
self._norm = tf_keras.layers.experimental.SyncBatchNormalization
else:
self._norm = tf_keras.layers.BatchNormalization
self._kernel_initializer = kernel_initializer
self._kernel_regularizer = kernel_regularizer
self._bias_regularizer = bias_regularizer
if tf_keras.backend.image_data_format() == 'channels_last':
bn_axis = -1
else:
bn_axis = 1
# Build BASNet Encoder.
inputs = tf_keras.Input(shape=input_specs.shape[1:])
x = tf_keras.layers.Conv2D(
filters=64, kernel_size=3, strides=1,
use_bias=self._use_bias, padding='same',
kernel_initializer=self._kernel_initializer,
kernel_regularizer=self._kernel_regularizer,
bias_regularizer=self._bias_regularizer)(
inputs)
x = self._norm(
axis=bn_axis, momentum=norm_momentum, epsilon=norm_epsilon)(
x)
x = tf_utils.get_activation(activation)(x)
endpoints = {}
for i, spec in enumerate(BASNET_ENCODER_SPECS):
x = self._block_group(
inputs=x,
filters=spec[0],
strides=spec[1],
block_repeats=spec[2],
name='block_group_l{}'.format(i + 2))
endpoints[str(i)] = x
if spec[3]:
x = tf_keras.layers.MaxPool2D(pool_size=2, strides=2, padding='same')(x)
self._output_specs = {l: endpoints[l].get_shape() for l in endpoints}
super(BASNetEncoder, self).__init__(
inputs=inputs, outputs=endpoints, **kwargs)
def _block_group(self,
inputs,
filters,
strides,
block_repeats=1,
name='block_group'):
"""Creates one group of residual blocks for the BASNet encoder model.
Args:
inputs: `Tensor` of size `[batch, channels, height, width]`.
filters: `int` number of filters for the first convolution of the layer.
strides: `int` stride to use for the first convolution of the layer. If
greater than 1, this layer will downsample the input.
block_repeats: `int` number of blocks contained in the layer.
name: `str`name for the block.
Returns:
The output `Tensor` of the block layer.
"""
x = nn_blocks.ResBlock(
filters=filters,
strides=strides,
use_projection=True,
kernel_initializer=self._kernel_initializer,
kernel_regularizer=self._kernel_regularizer,
bias_regularizer=self._bias_regularizer,
activation=self._activation,
use_sync_bn=self._use_sync_bn,
use_bias=self._use_bias,
norm_momentum=self._norm_momentum,
norm_epsilon=self._norm_epsilon)(
inputs)
for _ in range(1, block_repeats):
x = nn_blocks.ResBlock(
filters=filters,
strides=1,
use_projection=False,
kernel_initializer=self._kernel_initializer,
kernel_regularizer=self._kernel_regularizer,
bias_regularizer=self._bias_regularizer,
activation=self._activation,
use_sync_bn=self._use_sync_bn,
use_bias=self._use_bias,
norm_momentum=self._norm_momentum,
norm_epsilon=self._norm_epsilon)(
x)
return tf.identity(x, name=name)
@classmethod
def from_config(cls, config, custom_objects=None):
return cls(**config)
@property
def output_specs(self):
"""A dict of {level: TensorShape} pairs for the model output."""
return self._output_specs
@factory.register_backbone_builder('basnet_encoder')
def build_basnet_encoder(
input_specs: tf_keras.layers.InputSpec,
model_config,
l2_regularizer: tf_keras.regularizers.Regularizer = None) -> tf_keras.Model: # pytype: disable=annotation-type-mismatch # typed-keras
"""Builds BASNet Encoder backbone from a config."""
backbone_type = model_config.backbone.type
norm_activation_config = model_config.norm_activation
assert backbone_type == 'basnet_encoder', (f'Inconsistent backbone type '
f'{backbone_type}')
return BASNetEncoder(
input_specs=input_specs,
activation=norm_activation_config.activation,
use_sync_bn=norm_activation_config.use_sync_bn,
use_bias=norm_activation_config.use_bias,
norm_momentum=norm_activation_config.norm_momentum,
norm_epsilon=norm_activation_config.norm_epsilon,
kernel_regularizer=l2_regularizer)
@tf_keras.utils.register_keras_serializable(package='Vision')
class BASNetDecoder(tf_keras.layers.Layer):
"""BASNet decoder."""
def __init__(self,
activation='relu',
use_sync_bn=False,
use_bias=True,
norm_momentum=0.99,
norm_epsilon=0.001,
kernel_initializer='VarianceScaling',
kernel_regularizer=None,
bias_regularizer=None,
**kwargs):
"""BASNet decoder initialization function.
Args:
activation: `str` name of the activation function.
use_sync_bn: if True, use synchronized batch normalization.
use_bias: if True, use bias in convolution.
norm_momentum: `float` normalization omentum for the moving average.
norm_epsilon: `float` small float added to variance to avoid dividing by
zero.
kernel_initializer: kernel_initializer for convolutional layers.
kernel_regularizer: tf_keras.regularizers.Regularizer object for Conv2D.
bias_regularizer: tf_keras.regularizers.Regularizer object for Conv2d.
**kwargs: keyword arguments to be passed.
"""
super(BASNetDecoder, self).__init__(**kwargs)
self._config_dict = {
'activation': activation,
'use_sync_bn': use_sync_bn,
'use_bias': use_bias,
'norm_momentum': norm_momentum,
'norm_epsilon': norm_epsilon,
'kernel_initializer': kernel_initializer,
'kernel_regularizer': kernel_regularizer,
'bias_regularizer': bias_regularizer,
}
self._activation = tf_utils.get_activation(activation)
self._concat = tf_keras.layers.Concatenate(axis=-1)
self._sigmoid = tf_keras.layers.Activation(activation='sigmoid')
def build(self, input_shape):
"""Creates the variables of the BASNet decoder."""
conv_op = tf_keras.layers.Conv2D
conv_kwargs = {
'kernel_size': 3,
'strides': 1,
'use_bias': self._config_dict['use_bias'],
'kernel_initializer': self._config_dict['kernel_initializer'],
'kernel_regularizer': self._config_dict['kernel_regularizer'],
'bias_regularizer': self._config_dict['bias_regularizer'],
}
self._out_convs = []
self._out_usmps = []
# Bridge layers.
self._bdg_convs = []
for spec in BASNET_BRIDGE_SPECS:
blocks = []
for j in range(3):
blocks.append(nn_blocks.ConvBlock(
filters=spec[2*j],
dilation_rate=spec[2*j+1],
activation='relu',
use_sync_bn=self._config_dict['use_sync_bn'],
norm_momentum=0.99,
norm_epsilon=0.001,
**conv_kwargs))
self._bdg_convs.append(blocks)
self._out_convs.append(conv_op(
filters=1,
padding='same',
**conv_kwargs))
self._out_usmps.append(tf_keras.layers.UpSampling2D(
size=spec[6],
interpolation='bilinear'
))
# Decoder layers.
self._dec_convs = []
for spec in BASNET_DECODER_SPECS:
blocks = []
for j in range(3):
blocks.append(nn_blocks.ConvBlock(
filters=spec[2*j],
dilation_rate=spec[2*j+1],
activation='relu',
use_sync_bn=self._config_dict['use_sync_bn'],
norm_momentum=0.99,
norm_epsilon=0.001,
**conv_kwargs))
self._dec_convs.append(blocks)
self._out_convs.append(conv_op(
filters=1,
padding='same',
**conv_kwargs))
self._out_usmps.append(tf_keras.layers.UpSampling2D(
size=spec[6],
interpolation='bilinear'
))
def call(self, backbone_output: Mapping[str, tf.Tensor]):
"""Forward pass of the BASNet decoder.
Args:
backbone_output: A `dict` of tensors
- key: A `str` of the level of the multilevel features.
- values: A `tf.Tensor` of the feature map tensors, whose shape is
[batch, height_l, width_l, channels].
Returns:
sup: A `dict` of tensors
- key: A `str` of the level of the multilevel features.
- values: A `tf.Tensor` of the feature map tensors, whose shape is
[batch, height_l, width_l, channels].
"""
levels = sorted(backbone_output.keys(), reverse=True)
sup = {}
x = backbone_output[levels[0]]
for blocks in self._bdg_convs:
for block in blocks:
x = block(x)
sup['0'] = x
for i, blocks in enumerate(self._dec_convs):
x = self._concat([x, backbone_output[levels[i]]])
for block in blocks:
x = block(x)
sup[str(i+1)] = x
x = tf_keras.layers.UpSampling2D(
size=2,
interpolation='bilinear'
)(x)
for i, (conv, usmp) in enumerate(zip(self._out_convs, self._out_usmps)):
sup[str(i)] = self._sigmoid(usmp(conv(sup[str(i)])))
self._output_specs = {
str(order): sup[str(order)].get_shape()
for order in range(0, len(BASNET_DECODER_SPECS))
}
return sup
def get_config(self):
return self._config_dict
@classmethod
def from_config(cls, config, custom_objects=None):
return cls(**config)
@property
def output_specs(self):
"""A dict of {order: TensorShape} pairs for the model output."""
return self._output_specs
```
|
```objective-c
This program is free software; you can redistribute it and/or modify
the Free Software Foundation
This program is distributed in the hope that it will be useful,
but WITHOUT ANY WARRANTY; without even the implied warranty of
MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
with this program; if not, write to the Free Software Foundation, Inc.,
51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA. */
// Browser.h : header file
//
#ifndef BROWSER_H
#define BROWSER_H 1
#define VIRTUAL_TREE_VERSION "V008"
#define DIRECTORY_SHORTCT_CT 10
// Constants defining borders, tree and scroll bar sizes
#define H_BORDER 8
#define V_BORDER 8
#define CLOSED_TREE 40
#define OPEN_TREE 200
class CBrowser : public CDialogBar
{
// Construction
public:
CBrowser();
BOOL Create( CWnd* pParentWnd, UINT nIDTemplate, UINT nStyle,
UINT nID, BOOL = TRUE);
// Attributes
public:
CTString m_astrVTreeBuffer[DIRECTORY_SHORTCT_CT][32];
INDEX m_aiSubDirectoriesCt[DIRECTORY_SHORTCT_CT];
CSize m_Size;
SLONG m_TreeHeight;
PIXaabbox2D m_boxBrowseWnd;
PIXaabbox2D m_boxTreeWnd;
CBrowseWindow m_BrowseWindow;
CImageList m_IconsImageList;
CVirtualTreeCtrl m_TreeCtrl;
CVirtualTreeNode m_VirtualTree; // Internal virtual tree structure list head
BOOL m_bVirtualTreeChanged;
// Operations
void AddDirectoryRecursiv(CVirtualTreeNode *pOneDirectory, HTREEITEM hParent);
void LoadVirtualTree_t( CTFileName fnVirtulTree, CVirtualTreeNode *pvtnRoot);
// separate subdirectory names along current path
INDEX GetSelectedDirectory( CTString strArray[]);
// selects sub directory using given path
void SelectVirtualDirectory( CTString strArray[], INDEX iSubDirsCt);
HTREEITEM GetVirtualDirectoryItem( CTString strArray[], INDEX iSubDirsCt);
// functions for finding items inside virtal tree
void SelectItemDirectory( CTFileName fnItemFileName);
CVirtualTreeNode *FindItemDirectory( CVirtualTreeNode *pvtnInDirectory, CTFileName fnItem);
void SaveVirtualTree(CTFileName fnSave, CVirtualTreeNode *pvtn);
void DeleteDirectory(void);
CVirtualTreeNode *GetSelectedDirectory(void);
void OpenSelectedDirectory(void);
void CloseSelectedDirectory(void);
void OnLoadVirtualTreeInternal(CTFileName fnVirtulTree, CVirtualTreeNode *pvtnRoot);
CTFileName GetIOFileName(CTString strTitle, BOOL bSave);
// Overrides
// ClassWizard generated virtual function overrides
//{{AFX_VIRTUAL(CBrowser)
//}}AFX_VIRTUAL
// Implementation
public:
virtual CSize CalcDynamicLayout( int nLength, DWORD dwMode );
void OnUpdateVirtualTreeControl(void);
// Generated message map functions
//protected:
//{{AFX_MSG(CBrowser)
afx_msg void OnCreateDirectory();
afx_msg void OnDeleteDirectory();
afx_msg void OnSaveVirtualTree();
afx_msg void OnLoadVirtualTree();
afx_msg void OnRenameDirectory();
afx_msg void OnContextMenu(CWnd* pWnd, CPoint point);
afx_msg void OnSaveAsVirtualTree();
afx_msg void OnImportVirtualTree();
afx_msg void OnExportVirtualTree();
afx_msg void OnUpdateImportVirtualTree(CCmdUI* pCmdUI);
afx_msg void OnUpdateExportVirtualTree(CCmdUI* pCmdUI);
afx_msg void OnDumpVt();
//}}AFX_MSG
DECLARE_MESSAGE_MAP()
};
/////////////////////////////////////////////////////////////////////
#endif // BROWSER_H
```
|
Grenada Packet was launched in Cork in 1789 as a West Indiaman. A nominally French privateer captured her in 1794; she burnt accidentally at Savannah while awaiting trial. Later, the United States Government paid compensation to Grenada Packets owners as her captor had been fitted out as a privateer in the United States, in contravention of the post–5 June 1793 ban on the arming in the United States of French privateers.
Career
Grenada Packet first appeared in Lloyd's Register (LR) in 1789.
Fate
On 16 October 1793 Grenada Packet, Werryss, master, sailed from Gravesend, bound for Pensacola. Grenada Packet, Wemys, master, arrived in Jamaica from London, while bound to Pensacola.
Grenada Packet, Wemyss, master, was reported to have been taken and carried into Georgia. She had been on her way from Pensacola to London. Grenada Packet, a prize to Amie Point Petre, was reported to have burnt at Savannah.
Legal issues
The date of capture was 16 April 1794 and the captor was Ami de la Pointe-à-Pitre (henceforth Ami).
Ami was the former American schooner Fair Play, which William Talbot, Edward Ballard, and John Sinclair had purchased at Charleston, South Carolina and had armed and outfitted for privateering. The process involved sending Fair Play to Guadeloupe, and assuming French registry. It also required Talbot sailing her to Guadeloupe and there assuming French citizenship on 28 December 1793. The aim was to circumvent the Act of June 5, 1793, which sought to preserve the neutrality of the United States in the war between Britain and France by outlawing the arming of United States vessels to sail against Great Britain with letters of marque issued by France.
Ami received her French commission on 2 January 1794, with Talbot as master. She sailed that same day and by the time she returned to Charleston she had taken nine prizes, including Grenada Packet.
Grenada Packet, Francis Hamilton, master, arrived at Savannah on 19 April. The French consul advertised her condemnation trial for 25 April. Before she could be libelled, a tar pot overturned and set fire to her. The burning ship floated past wharves and warehouses, and sank. Her value had been estimated at £2,500, and the value of her cargo at £13,849 19s 7d. The reason for the taring was that she was being fitted out as a privateer.
The United States established a board of commissioners to hear claims for recompense by owners of vessels seized in contravention of the post–5 June 1793 ban on the arming in the United States of French privateers. The board awarded $18,498.09 to the owners of Grenada Packet, Wemyss, master.
Citations
References
1789 ships
Age of Sail merchant ships of England
Captured ships
Maritime incidents in 1794
|
Ministry of Dance is an Australian dance school based in Penrith, New South Wales. It established in 2006.
History
Ministry of Dance was founded by Jaclyn Bennett in April 2006. Ministry of Dance started with 20 students in a tiny church hall in Orchard Hills. In June 2006 Ministry of Dance moved into their very own purpose-built studios in Jamisontown. By 2010 Ministry had grown to over 500 students, making it one of the largest studios in Sydney.
During 2009 the school won multiple eisteddfods from around the wider Sydney area. They competed in the McDonald's challenge and received a Highly Commended in the open age lyrical event and placed 3rd in the open age Hip Hop, losing to Brent Street Studios (2nd) and Urban Dance Company (1st). Their greatest Achievement for the year was being crowned National Champions for Hip Hop and winning the Battle of the Stars in the Senior Small Group category. Both of these titles were won at the prestigious Peter Oxford’s 'Showcase' Australian Dance Championships.
Ministry offers a large variety of classes including Ballet, Jazz, Tap, Hip Hop, Breakdancing, Acrobatics, Circus classes, Silks and more.
Ministry of Dance have the largest Baby and Toddler department running over 20 classes per week for all children as young as 12 months old.
In 2012, due to the increasing success and popularity of her petite programs, Jaclyn launched her Baby and Toddler dance and movement studio Munchie Movers.
Munchie Movers continues to grow with studios in Pyrmont, Penrith and Bondi.
Footnotes
External links
Ministry of Dance official website
Munchie Movers official website
Showcase National Championships website
Sydney Eisteddford website
Dance schools in Australia
|
Haemodorum austroqueenslandicum is a shrub native to Southeastern Australia.
References
austroqueenslandicum
Flora of New South Wales
Flora of Queensland
Taxa named by Karel Domin
|
Tommy McHale is an English former professional footballer who played as a full back.
Career
McHale made 38 appearances in the Football League for Bradford City between 1971 and 1973. He also played non-league football with Prescot Cables and Wigan Athletic. He played two Northern Premier League games for Wigan before leaving the club.
References
1940s births
Living people
English men's footballers
Men's association football defenders
Prescot Cables F.C. players
Bradford City A.F.C. players
Wigan Athletic F.C. players
English Football League players
Place of birth missing (living people)
|
Songs for Daddy is a 2014 Jill Johnson studio album. The album is a tribute to her father's music taste.
Track listing
Crazy in Love
Hallelujah I Love Him So
Fly Me to the Moon
Moon River
Something's Gotta Give
That's Life
Love is Here to Stay
The Very thought of You
No other Daddy but You
After You've Gone
Everybody Loves Somebody
I Can't Give You Anything but Love
Charts
Weekly charts
Year-end charts
References
2014 albums
Jill Johnson albums
|
```c
/**
* @license Apache-2.0
*
*
*
* path_to_url
*
* Unless required by applicable law or agreed to in writing, software
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
*/
/*
* The following is auto-generated. Do not manually edit. See scripts/loops.js.
*/
#include "stdlib/strided/base/binary/us_d_as_dd_d.h"
#include "stdlib/strided/base/binary/macros.h"
#include <stdint.h>
/**
* Applies a binary callback to strided input array elements and assigns results to elements in a strided output array.
*
* @param arrays array whose first two elements are pointers to strided input arrays and whose last element is a pointer to a strided output array
* @param shape array whose only element is the number of elements over which to iterate
* @param strides array containing strides (in bytes) for each strided array
* @param fcn callback
*
* @example
* #include "stdlib/strided/base/binary/us_d_as_dd_d.h"
* #include <stdint.h>
*
* // Create underlying byte arrays:
* uint8_t x[] = { 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0 };
* uint8_t y[] = { 0, 0, 0 };
* uint8_t out[] = { 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0 };
*
* // Define a pointer to an array containing pointers to strided arrays:
* uint8_t *arrays[] = { x, y, out };
*
* // Define the strides:
* int64_t strides[] = { 4, 1, 8 };
*
* // Define the number of elements over which to iterate:
* int64_t shape[] = { 3 };
*
* // Define a callback:
* static double fcn( double x, double y ) {
* return x + y;
* }
*
* // Apply the callback:
* stdlib_strided_us_d_as_dd_d( arrays, shape, strides, (void *)fcn );
*/
void stdlib_strided_us_d_as_dd_d( uint8_t *arrays[], const int64_t *shape, const int64_t *strides, void *fcn ) {
typedef double func_type( const double x, const double y );
func_type *f = (func_type *)fcn;
STDLIB_STRIDED_BINARY_LOOP_CLBK_MIXED_ARG_CAST( uint32_t, int8_t, double, double, double )
}
```
|
```php
<?php
namespace Gui\Components;
/**
* This is the Checkbox Class
*
* It is a visual component for checkbox
*
* @author Rafael Reis @reisraff
* @since 0.1
*/
class Checkbox extends VisualObject
{
/**
* The lazarus class as string
*
* @var string $lazarusClass
*/
protected $lazarusClass = 'TCheckBox';
/**
* Get the Checkbox checked
*
* @return bool
*/
public function getChecked()
{
return $this->get('checked');
}
/**
* Set the Checkbox Checked
*
* @param bool $checked
*
* @return self
*/
public function setChecked($checked)
{
$this->set('checked', $checked);
return $this;
}
}
```
|
MK Balaji is an Indian singer, songwriter, composer and independent artist from Chennai. As a playback singer he has sung more than 200 songs in Tamil, Telugu and Kannada. His first song a lyricist was for the movie Sethupathi. He has hosted popular TV shows in Star Vijay and Zee Tamil. He made a debut as an indie artist with his single Good Naai bad Aadu that takes a fun jab at meat eating animal lovers.
Biography
MK Balaji is the voice behind many South Indian film songs including "Rettai Kathire" from the Tamil movie Maattrraan directed by K. V. Anand starring Surya Sivakumar. He has delivered many successful songs in Tamil and Telugu. He has also collaborated with music directors like D Imman, Karthik Raja, Sundar C. Babu, Taj Noor, James Vasanthan, Sirpy, Sabesh–Murali and Srikanth Deva.
Live shows and tours
MK Balaji is one very few South Indian singers to perform for the Indian Premier League. He is a prominent stage performer performing for award functions, television shows, college pro shows and corporate events. His tours overseas include shows in Paris, Japan, Dubai, Kuwait, Seychelles, Malaysia, Singapore and Sri Lanka to name a few. He has also toured with music directors Harris Jayaraj and Vijay Antony on their music shows.
TV host
As a television host he has hosted television shows like Paadum Office on STAR Vijay, a Tamil version of the popular Sa Re Ga Ma Pa on Zee Tamil and many other shows.
Early music
He started his singing career with reality shows on television. His band V3, of which he was the lead singer, presented a sound track in the Oohlalala album which consists of original compositions by the winners of the show Oohlalala aired on the Tamil channel Sun TV. It was judged by the Oscar winner AR Rahman. His band was judged the winning band and he eventually got the breakthrough as a playback singer.
Discography
Below is the partial discography of the songs sung by MK Balaji.
Film songs
Single
As lyricist
As TV Host
References
MK Balaji's official YouTube channel
MK Balaji on his Musical Journey in IndiaGlitz
Singer MK Balaji Exclusive Interview for IndiaInteracts
MK Balaji back in business – Times of India
Dr.PB Srinivas on MK Balaji
MK Balaji's Songs in Raaga
Silence is a source of power – MK Balaji
MK Balaji – on twitter
MK Balaji – on Facebook
MK Balaji – on Instagram
Living people
Indian male playback singers
Tamil playback singers
Singers from Chennai
Year of birth missing (living people)
|
```html
<div class="container d-flex flex-column justify-content-center">
<div class="row align-self-end">
<app-language></app-language>
</div>
<div class="row title align-self-center">
<h1><app-icon [width]="80"></app-icon>{{title}}</h1>
</div>
<div class="row card align-self-center">
<div class="card-body">
<div *ngIf="!(shareService.sharingIsValid | async)"
class="h3 text-center text-danger" i18n>Unknown sharing key.
</div>
<form *ngIf="(shareService.sharingIsValid | async)"
name="form" id="form" class="form-horizontal" #LoginForm="ngForm" (submit)="onLogin()">
<div class="error-message" [hidden]="loginError==false" i18n>Wrong password</div>
<div class="input-group mb-3">
<div class="input-group-text"><ng-icon name="ionLockClosedOutline"></ng-icon></div>
<input type="password"
i18n-placeholder
class="form-control"
name="password"
id="password"
placeholder="Password"
autocomplete="login-password"
autocorrect="off"
autocapitalize="none"
[(ngModel)]="password"
required>
</div>
<div class="col-sm-12 controls d-grid gap-2">
<button class="btn btn-primary btn-lg"
id="button-share-login"
[disabled]="!LoginForm.form.valid || inProgress"
type="submit"
name="action" i18n>Enter
</button>
</div>
</form>
</div>
</div>
</div>
```
|
Al-Azm family ( , ) is a prominent Damascene family. Their political influence in Ottoman Syria began in the 18th century when members of the family administered Maarrat al-Nu'man and Hama. A scion of the family, Ismail Pasha al-Azm, was appointed wāli of Damascus Eyalet in 1725. Between 1725 and 1783, members of the family, including As'ad Pasha al-Azm, held power in Damascus for 47 years, in addition to periodical appointments in Sidon Eyalet, Tripoli Eyalet, Hama, Aleppo Eyalet, and Egypt Eyalet. The family's influence declined in the 19th century, failing to establish a true dynasty.
Origins
The origins of the Azm family are relatively obscure and evidence has been described as "contradictory and generally unsatisfactory." One of the most prominent families in Ottoman Syria, the Al-Azm's may have originated from the region of Konya in Anatolia; hence, their roots in Turkey may shed light on recruitment and career patterns of the family members who held high positions as Ottoman officers in the Syrian provinces. The Al-Azm's began to emerge as a major influence in the region when Ibrahim al-'Azm, "a rural notable possibly of Turkish stock", went to Ma'arrat al-Nu'man to restore order in the mid-seventeenth century. Upon his death, Ibrahim al-'Azm's sons, Ismail Pasha al-Azm and Sulayman Pasha al-Azm, completed their father's task and were rewarded by the Ottoman administration with hereditary tax farms in Homs, Hama and Ma'arrat al-Nu'man.
In an article written by a member of the family, Professor Sadiq Jalal al-Azm, the introductory author, Jean-Pierre Rondas, describes Al-Azm as:
In addition to the Turkish origin theory, an Arab origin is believed to be possible. In particular, the Azm family is believed to be part of "the Banu Azm tribe of the northern Hijaz, [who] served the Ottomans in the sixteenth century by protecting the Damascus-Medina caravan route, and later migrated to Anatolia, then to Ma'arra." In fact, However, "there is no proof that the Azms themselves claimed to be of bedouin origin".
The controversy can be understood in light of statements made by Dr. Shamir Shimon and Dr. Abdul Karim Rafeq. Dr. Shimon Shamir states that "although none of the views is supported by definite proofs, the latter [that is, the Beduin theory] seems to be more acceptable. In the realities of Syria in the seventeenth and eighteenth centuries, it is more likely that a Beduin family in the Ottoman service should become partly turkicized and live for a while in Anatolia than that a Turkish family should seek to derive prestige by falsely attributing its origins to a Beduin tribe." On the other hand, Dr Abdul Karim Rafeq "opts for the local-origin theory without committing himself to the beduin part." In response to primary sources stating "that Sadeddin [Pasha al-Azm] was "un autre pacha arabe de nation"; and that Mehmed [Pasha al-Azm] was of an Arab family... [and] that the 'Azms were "Arabs" (awlad al-'Arab) from the Arab lands (al-bilad al-'Arabiyya)," Dr Rafeq advocates for treating these statements with great caution, especially the epithet "Arab", which he takes to mean "local" as opposed to Ottoman. Finally, it is important to note that there is evidence that "Sulayman Pasha al-Azm knew not a word of Arabic whereas Mehmed was apparently thoroughly Arabized".
Rise to power
Ismail Pasha, who later became wāli (governor) of Tripoli, was transferred to Damascus in 1725 at the request of the mufti, after fighting between different factions of janissaries prevented the Hajj caravan from departing on time. His brother became the wali of Tripoli, and his son became the wali of Sidon. In 1730 when Sultam Ahmed III was deposed they were all dismissed, but not for long. Sulayman Pasha al-Azm, brother of Ismail Pasha, became wali of Damascus between 1733 and 1738 and again from 1741 until his death in 1743. He was succeeded by his nephew As'ad Pasha al-Azm who reigned between 1743 and 1757, and was considered the greatest governor of Damascus in Ottoman times. As'ad Pasha overcame all his local adversaries after three years struggle. In his reign Hama and Homs were added to the province of Damascus.
Despite As'ad Pasha's ability to ensure the security of the pilgrim caravan, the new Ottoman authorities in Istanbul deposed him in 1757 after fourteen years of governance. The Grand Vizier at the time, Raghib Pasha, denounced him as a, "peasant son of a peasant," after a deal between the two of them failed. In addition, the Kizlar Agha of Istanbul disliked al-Azm for apparently not taking good care of him when he passed through Damascus on the pilgrim caravan. The Ottoman state was also interested in confiscating the wealth al-Azm accumulated during his tenure in office. The large amounts of money collected made the state revalue its currency. He was transferred to Aleppo and later dismissed and executed. This marked the end of the family's golden age. It continued to assert some influence, and many of its members served as walis later, but its great days were over. The last member of the family to govern Damascus was Abdullah Pasha al-Azm who served intermittently between 1795 and 1807.
Maintaining the family name
In the mid-18th century the al-Azm family reconciled itself to power centres outside the family. Consequently, two members of its family, Layla bint al-Sayyid Ibrahim al-Azm and Khadija bint Nasuh Pasha, were married to Turkish mamluks in the family's service to retain the Azm family name. The lineage descending from Layla indicates that this branch of the family were concentrated around Hama, and many held government posts there.
Legacy
Al-Azm's era brought a building boom to Damascus where dozens of baths, khans, schools and souqs were built, many of which still remain today. Most famous of them are the Azm Palace in Damascus, and the Azm Palace in Hama, both of which were built by As'ad Pasha al-Azm as palatial residences.
Different translation of surname
Last names were not used during the Ottoman era. Family members were using the name Azmzade in the nineteenth century, in reference to the Azm clan with the zade being an addition indicating nobility. The Latin inscription of the name translated from Arabic script has evolved over time and is now written in different ways. Some family members have the family name Azme, Aladem, Alazm, Aladam, Alzm or some other surnames, although they all belong to the same family. In addition, some members of the family that remained in Turkey have a variety of different last names which were selected following the promulgation of a 1934 law which made last names mandatory and banned the use to references of nobility. It is not clear whether some use the surname Kemikoğlu, literally meaning "the son the bone".
Members of the family
Ismail Pasha al-Azm, Ottoman governor of Hama, Homs, Tripoli and Damascus
Sulayman Pasha al-Azm, Ottoman governor of Tripoli, Sidon and Damascus, Ismail Pasha's brother
As'ad Pasha al-Azm, Ottoman governor of Hama and Damascus, Ismail Pasha's son
Sa'deddin Pasha al-Azm, Ottoman governor of Aleppo and Egypt (among others), Ismail Pasha's son
Muhammad Pasha al-Azm, Ottoman governor of Sidon and Damascus, As'ad Pasha's son
Abdullah Pasha al-Azm, Ottoman governor of Damascus, Muhammad Pasha's son
Azmzade Sadik Al Mouayad, Ottoman governor of Jeddah, Imperial Commissaire in Bulgaria, Salih Azdashir Bey's son
Haqqi al-Azm, former prime minister of Syria
Rafiq al-Azm, editor and politician
Khalid al-Azm, six-time former prime minister of Syria
Sadiq Jalal al-Azm, Professor Emeritus of Modern European Philosophy at the University of Damascus
Buildings named after the family
Khan Sulayman Pasha
Khan As'ad Pasha
Azm Palace, in Damascus
Azm Palace (Hama), in Hama
Books published by family members
Azmzade Sadik El Mueyyed, Habes Seyahatnamesi [The Abyssinia Book of Travels], Istanbul, 1904 translated to English by G. Gokkent and family 2021 https://www.amazon.com/Ethiopia-Book-Travels-Giyas-Gokkent/dp/1737129892
Azmzade Sadik El Mueyyed, Bir Osmanli Zabitinin Afrika Sahra-i Kebirinde Seyahati [An Ottoman Officer's Journey in the Grand Sahara of Africa], Istanbul, 1897 translated to English by G. Gokkent 2021 https://www.amazon.com/Journey-Grand-Sahara-Africa-Through/dp/1737129884/ref=sr_1_2?dchild=1&qid=1630652339&refinements=p_27%3AGiyas+M+Gokkent&s=books&sr=1-2&text=Giyas+M+Gokkent
References
Bibliography
Arabic-language surnames
Syrian families
History of Damascus
Syrian people of Turkish descent
Political families of Syria
|
Taufic Eduardo Guarch Rubio (born 4 October 1991) is a Mexican professional footballer who plays as a forward or winger for Liga Primera club Diriangén FC.
Club career
Estudiantes Tecos
Guarch debuted on the Torneo Apertura 2010, assisted 2 passes for goal in 10 appearances during this tournament. On the Torneo Clausura 2011 he appeared in 7 matches and gave one assist for goal.
Espanyol B
On August 30, 2011, Guarch joined Espanyol B on a season long loan.
International career
Guarch scored his first international goal for Mexico at the 2011 FIFA U-20 World Cup in Colombia on August 1, 2011, against North Korea, in the 54th minute.
During 2014, in awake of Lebanon's elimination in 2014 WC and 2015 Asian Cup qualifying, manager Giuseppe Giannini decided to contact to the Lebanese diaspora players from outside Lebanon. Taufic was captured by Giannini and his performance might have one day he will serve for Lebanese team.
Personal life
Guarch is of Lebanese descent.
Honours
Mexico U20
FIFA U-20 World Cup 3rd Place: 2011
CONCACAF Under-20 Championship: 2011
References
External links
Taufic Guarch, al Espanyol de Barcelona at mediotiempo.com
Tienen Estudiantes un Hijo de Dios at tecosuag.blogspot.com
1991 births
Living people
Mexican expatriate men's footballers
Mexican men's footballers
Mexico men's under-20 international footballers
Mexico men's youth international footballers
Mexican people of Lebanese descent
Mexican people of Cuban descent
Tecos F.C. footballers
RCD Espanyol B footballers
Tigres UANL footballers
Venados F.C. players
Tlaxcala F.C. players
Pioneros de Cancún footballers
Alebrijes de Oaxaca players
Atlante F.C. footballers
Real Estelí FC players
Liga MX players
Ascenso MX players
Segunda División B players
Footballers from Guadalajara, Jalisco
Men's association football forwards
Mexican expatriate sportspeople in Spain
Mexican expatriate sportspeople in Nicaragua
Expatriate men's footballers in Spain
Expatriate men's footballers in Nicaragua
Sportspeople of Lebanese descent
|
McIvor Highway is a short Victorian highway (44 km) linking Bendigo and Heathcote. Together with Hume Freeway (until Wallan) and Northern Highway (until Heathcote), it provides an alternative route between Melbourne and Bendigo. The name 'McIvor' refers to the original name of the Heathcote region, used during the Victorian Gold Rush.
History
The passing of the Highways and Vehicles Act of 1924 through the Parliament of Victoria provided for the declaration of State Highways, roads two-thirds financed by the State government through the Country Roads Board (later VicRoads). The Eppalock Highway was declared a State Highway in the 1959/60 financial year, from Heathcote to Bendigo (for a total of 27 miles); before this declaration, this road was referred to as Heathcote-Bendigo Road. The highway was later renamed McIvor Highway in 1962.
The McIvor Highway was signed as State Route 141 between Bendigo and Heathcote in 1986; with Victoria's conversion to the newer alphanumeric system in the late 1990s, this was replaced by route B280.
Major intersections and towns
The entire highway is in the City of Greater Bendigo local government area.
See also
Highways in Australia
Highways in Victoria
References
Highways in Australia
|
```c
/* source: xioexit.c */
/* this file contains the source for the extended exit function */
#include "xiosysincludes.h"
#include "compat.h"
#include "xio.h"
#include "error.h"
/* this function closes all open xio sockets on exit, if they are still open.
It must be registered with atexit(). */
void xioexit(void) {
int i;
diag_in_handler = 0;
Debug("starting xioexit()");
for (i = 0; i < XIO_MAXSOCK; ++i) {
if (sock[i] != NULL && sock[i]->tag != XIO_TAG_INVALID) {
xioclose(sock[i]);
}
}
Debug("finished xioexit()");
}
```
|
"The Night of the Tiger" is a short story by Stephen King. Originally written in the 1960s, it was first published in The Magazine of Fantasy & Science Fiction in February 1978.
Plot summary
The story is narrated by Eddie Johnston of Sauk City, who impulsively joins Farnum & Williams' All-American 3-Ring Circus and Side Show as a roustabout. Johnston enjoys circus life, but fears Mr. Indrasil, the fiery tempered lion tamer, who is rumored to have only nearly killed a roustabout who angered him. Mr. Indrasil in turn fears the circus' tiger, Green Terror, who once attacked him, leaving a scar on the back of his neck.
One night in Steubenville, Mr. Indrasil berates Johnston for not cleaning a cage properly. After Johnston protests, Mr. Indrasil attempts to hit him, but is stopped by a stranger, Mr. Legere. Later, other members of the circus tell Johnston that Mr. Legere has followed the circus from the Midwest to Little Rock nearly every year for the past two decades, and that he shares an unknown past with Mr. Indrasil. Mr Legere attends every performance by the circus, always standing next to Green Terror's cage.
During the following days, the circus experiences a heat wave, heightening tensions. On one night, Johnston witnesses Mr. Indrasil baiting Green Terror by jabbing him with a pike until being frightened away by a mysterious green-eyed shadow.
Events reach a climax in Wildwood Green, Oklahoma. Mr. Indrasil's act goes poorly after Green Terror roars at an inopportune time, resulting in one of the lions attempting to attack Mr. Indrasil. The evening performance is cancelled after the United States Weather Bureau issues a tornado warning. Johnston struggles to put Green Terror in his wagon; after he approaches Mr. Indrasil for help, a drunken and crazed Mr. Indrasil threatens him, saying he has no "juju" or "grisgris" to protect him, then begins rambling about his "nemesis", who he claims turned Green Terror against him and who "always had the power more'n me". After Green Terror begins roaring, Mr. Indrasil approaches the tiger's cage, where he is confronted by Mr. Legere. Mr. Legere releases Green Terror from his cage, and both men seemingly attempt to command the tiger using their willpower. Mr. Legere ultimately prevails; as the tiger advances on Mr. Indrasil, Johnston sees him fold-in on himself. As Johnston watches, he is lifted off his feet by the tornado and knocked unconscious.
When Johnston awakens, he learns that there is no sign of Mr. Indrasil or Mr. Legere, but Green Terror and another unknown tiger have fought one another to death. Johnston is told by a witness to the fight that the second tiger had a long scar on the back of its neck, implying it was a shapeshifted Mr. Indrasil.
Publication
King wrote "The Night of the Tiger" in 1963 at the age of 16, being inspired by an episode of The Fugitive. He submitted the story to The Magazine of Fantasy & Science Fiction and received a handwritten rejection note saying "This is good. Not for us, but good. You have talent. Submit again." In the 1970s, King found "The Night of the Tiger" in a box of manuscripts, rewrote it, and resubmitted it; this time, the story was accepted. "The Night of the Tiger" was first published in The Magazine of Fantasy & Science Fiction in February 1978. It was reprinted in the anthologies More Tales of Unknown Horror (1979), The Year's Best Horror Stories (1979), The Third Book of Unknown Tales of Horror (1980), Chamber of Horrors (1984), The Best Horror Stories from the Magazine of Fantasy & Science Fiction (1988), Horrorstory, Volume Three (1992), Tails of Wonder and Imagination (2010), and Midnight Under the Big Top (2020).
Reception
Tyson Blue described "The Night of the Tiger" as "enjoyable" but noted "the ultimately unsatisfying nature of the story, with its plethora of unresolved loose ends and plot inconsistencies." James Van Hise judged it to be "one of King's lesser stories although it contains some interesting ideas". Michael R. Collings remarked that "the story is too allusive" and that "too much is missing". Rocky Wood described the story as "unsatisfying and inconclusive". Introducing the story in Tails of Wonder and Imagination, Ellen Datlow suggested that the story "has a Ray Bradbury feel to it, but with a harder edge." Revisiting the story, King himself judged it to be "a perfectly respectable tale, albeit one obviously written by a guy who had only begun to learn his chops".
References
See also
Stephen King short fiction bibliography
External links
"The Night of the Tiger" at StephenKing.com
Short stories by Stephen King
1978 short stories
Books about tigers
Short stories set in circuses
Fiction about shapeshifting
Horror short stories
Oklahoma in fiction
Works originally published in The Magazine of Fantasy & Science Fiction
|
```html
<html lang="en">
<head>
<title>Overlay Commands - Debugging with GDB</title>
<meta http-equiv="Content-Type" content="text/html">
<meta name="description" content="Debugging with GDB">
<meta name="generator" content="makeinfo 4.8">
<link title="Top" rel="start" href="index.html#Top">
<link rel="up" href="Overlays.html#Overlays" title="Overlays">
<link rel="prev" href="How-Overlays-Work.html#How-Overlays-Work" title="How Overlays Work">
<link rel="next" href="Automatic-Overlay-Debugging.html#Automatic-Overlay-Debugging" title="Automatic Overlay Debugging">
<link href="path_to_url" rel="generator-home" title="Texinfo Homepage">
<!--
Permission is granted to copy, distribute and/or modify this document
any later version published by the Free Software Foundation; with the
Invariant Sections being ``Free Software'' and ``Free Software Needs
Free Documentation'', with the Front-Cover Texts being ``A GNU Manual,''
and with the Back-Cover Texts as in (a) below.
(a) The FSF's Back-Cover Text is: ``You are free to copy and modify
this GNU Manual. Buying copies from GNU Press supports the FSF in
developing GNU and promoting software freedom.''
-->
<meta http-equiv="Content-Style-Type" content="text/css">
<style type="text/css"><!--
pre.display { font-family:inherit }
pre.format { font-family:inherit }
pre.smalldisplay { font-family:inherit; font-size:smaller }
pre.smallformat { font-family:inherit; font-size:smaller }
pre.smallexample { font-size:smaller }
pre.smalllisp { font-size:smaller }
span.sc { font-variant:small-caps }
span.roman { font-family:serif; font-weight:normal; }
span.sansserif { font-family:sans-serif; font-weight:normal; }
--></style>
</head>
<body>
<div class="node">
<p>
<a name="Overlay-Commands"></a>
Next: <a rel="next" accesskey="n" href="Automatic-Overlay-Debugging.html#Automatic-Overlay-Debugging">Automatic Overlay Debugging</a>,
Previous: <a rel="previous" accesskey="p" href="How-Overlays-Work.html#How-Overlays-Work">How Overlays Work</a>,
Up: <a rel="up" accesskey="u" href="Overlays.html#Overlays">Overlays</a>
<hr>
</div>
<h3 class="section">14.2 Overlay Commands</h3>
<p>To use <span class="sc">gdb</span>'s overlay support, each overlay in your program must
correspond to a separate section of the executable file. The section's
virtual memory address and load memory address must be the overlay's
mapped and load addresses. Identifying overlays with sections allows
<span class="sc">gdb</span> to determine the appropriate address of a function or
variable, depending on whether the overlay is mapped or not.
<p><span class="sc">gdb</span>'s overlay commands all start with the word <code>overlay</code>;
you can abbreviate this as <code>ov</code> or <code>ovly</code>. The commands are:
<dl>
<dt><code>overlay off</code><dd><a name="index-overlay-906"></a>Disable <span class="sc">gdb</span>'s overlay support. When overlay support is
disabled, <span class="sc">gdb</span> assumes that all functions and variables are
always present at their mapped addresses. By default, <span class="sc">gdb</span>'s
overlay support is disabled.
<br><dt><code>overlay manual</code><dd><a name="index-manual-overlay-debugging-907"></a>Enable <dfn>manual</dfn> overlay debugging. In this mode, <span class="sc">gdb</span>
relies on you to tell it which overlays are mapped, and which are not,
using the <code>overlay map-overlay</code> and <code>overlay unmap-overlay</code>
commands described below.
<br><dt><code>overlay map-overlay </code><var>overlay</var><dt><code>overlay map </code><var>overlay</var><dd><a name="index-map-an-overlay-908"></a>Tell <span class="sc">gdb</span> that <var>overlay</var> is now mapped; <var>overlay</var> must
be the name of the object file section containing the overlay. When an
overlay is mapped, <span class="sc">gdb</span> assumes it can find the overlay's
functions and variables at their mapped addresses. <span class="sc">gdb</span> assumes
that any other overlays whose mapped ranges overlap that of
<var>overlay</var> are now unmapped.
<br><dt><code>overlay unmap-overlay </code><var>overlay</var><dt><code>overlay unmap </code><var>overlay</var><dd><a name="index-unmap-an-overlay-909"></a>Tell <span class="sc">gdb</span> that <var>overlay</var> is no longer mapped; <var>overlay</var>
must be the name of the object file section containing the overlay.
When an overlay is unmapped, <span class="sc">gdb</span> assumes it can find the
overlay's functions and variables at their load addresses.
<br><dt><code>overlay auto</code><dd>Enable <dfn>automatic</dfn> overlay debugging. In this mode, <span class="sc">gdb</span>
consults a data structure the overlay manager maintains in the inferior
to see which overlays are mapped. For details, see <a href="Automatic-Overlay-Debugging.html#Automatic-Overlay-Debugging">Automatic Overlay Debugging</a>.
<br><dt><code>overlay load-target</code><dt><code>overlay load</code><dd><a name="index-reloading-the-overlay-table-910"></a>Re-read the overlay table from the inferior. Normally, <span class="sc">gdb</span>
re-reads the table <span class="sc">gdb</span> automatically each time the inferior
stops, so this command should only be necessary if you have changed the
overlay mapping yourself using <span class="sc">gdb</span>. This command is only
useful when using automatic overlay debugging.
<br><dt><code>overlay list-overlays</code><dt><code>overlay list</code><dd><a name="index-listing-mapped-overlays-911"></a>Display a list of the overlays currently mapped, along with their mapped
addresses, load addresses, and sizes.
</dl>
<p>Normally, when <span class="sc">gdb</span> prints a code address, it includes the name
of the function the address falls in:
<pre class="smallexample"> (gdb) print main
$3 = {int ()} 0x11a0 <main>
</pre>
<p class="noindent">When overlay debugging is enabled, <span class="sc">gdb</span> recognizes code in
unmapped overlays, and prints the names of unmapped functions with
asterisks around them. For example, if <code>foo</code> is a function in an
unmapped overlay, <span class="sc">gdb</span> prints it this way:
<pre class="smallexample"> (gdb) overlay list
No sections are mapped.
(gdb) print foo
$5 = {int (int)} 0x100000 <*foo*>
</pre>
<p class="noindent">When <code>foo</code>'s overlay is mapped, <span class="sc">gdb</span> prints the function's
name normally:
<pre class="smallexample"> (gdb) overlay list
Section .ov.foo.text, loaded at 0x100000 - 0x100034,
mapped at 0x1016 - 0x104a
(gdb) print foo
$6 = {int (int)} 0x1016 <foo>
</pre>
<p>When overlay debugging is enabled, <span class="sc">gdb</span> can find the correct
address for functions and variables in an overlay, whether or not the
overlay is mapped. This allows most <span class="sc">gdb</span> commands, like
<code>break</code> and <code>disassemble</code>, to work normally, even on unmapped
code. However, <span class="sc">gdb</span>'s breakpoint support has some limitations:
<ul>
<li><a name="index-breakpoints-in-overlays-912"></a><a name="index-overlays_002c-setting-breakpoints-in-913"></a>You can set breakpoints in functions in unmapped overlays, as long as
<span class="sc">gdb</span> can write to the overlay at its load address.
<li><span class="sc">gdb</span> can not set hardware or simulator-based breakpoints in
unmapped overlays. However, if you set a breakpoint at the end of your
overlay manager (and tell <span class="sc">gdb</span> which overlays are now mapped, if
you are using manual overlay management), <span class="sc">gdb</span> will re-set its
breakpoints properly.
</ul>
</body></html>
```
|
Motor-paced racing and motor-paced cycling refer to cycling behind a pacer in a car or more usually on a motorcycle. The cyclist (or stayer in this case) follows as close as they can to benefit from the slipstream of their pacer. The first paced races were behind other cyclists, sometimes as many as five riders on the same tandem. Bordeaux-Paris and record attempts have been ridden behind cars. More usually races or training are behind motorcycles.
Origins of pacing
Cyclists started to use tandem bicycles as pacers in the late 19th century. There could be as many as five riders on the pacing machine. Because of the long distances covered when following a pacer, these cyclists were called stayers, a term used in long-distance horse racing. Companies such as Dunlop sponsored pacing teams, and "tens of thousands" turned out to watch. A south London rider, J. W. Stocks, set British record of in an hour behind a Dunlop quintuplet on 27 September 1897. The pacing tandems were ridden by professionals, of whom as many as 100 were under contract. Each competitor had six to eight pacing teams for races between .
Speeds rose when engines were added to pacing tandems. Arthur Chase and the Frenchman Émile Bouhours set English records behind powered tandems in 1898 and 1899. Chase used a motorcycle to pace him to in a private test at The Crystal Palace, south London, in July 1900 but riders in the USA and in Paris had already done better. Some races mixed pacing with solo bicycles, tandem and motorcycle, with the riders given different start points in compensation.
Pacing by car
Bordeaux–Paris, a race of nearly from south-west France to the capital, was paced part of the way by cars in 1897, 1898 and 1899. So was Paris–Roubaix. The historian Pierre Chany said: "Cars made only a brief appearance in Paris–Roubaix. On the roads of the north, these noisy cars, high with wooden wheels with their tires nailed in place, raised huge clouds of dust. The drivers, wearing leathers, their eyes protected by huge goggles, were stepping into the unknown! The riders hidden in all this chaos could see absolutely nothing and risked their life at on the edge of a razor. The noise was infernal and the column advanced in the stink of exhaust pipes."
Pacing by motorcycle
The first races were limited more by the speed a motorcycle could achieve than the ability of the rider to follow, with being a good average, according to the historian H. M. Ellis. The races became faster as the pacers became faster. Paced races kept audiences enthralled for many decades in Europe and, at one time, in North America. Tens of thousands watched, especially in Germany. The popularity of this form of pacing declined in the latter part of the 20th century.
There were few rules. Pacing machines had small rollers set sideways behind the back wheel to avoid crashes caused by the rider touching the back of the motorcycle, but there were few other regulations. Race distances extended to six days, although one-hour and contests were more common. Windshields were briefly allowed but abandoned after the world championship in 1904.
Speeds rose and accidents became commonplace. An American, Harry Elkes, died of his injuries from a crash in front of 10 000 spectators at Boston, Massachusetts, USA. His rear tire exploded at and he was thrown under another rider's pacing machine, which "crushed the prostrate man in a dreadful manner." George Leander of Chicago said, "Only the clumsy get themselves killed" before starting a race at the Parc des Princes in Paris. Leander was thrown into the air after , fell to the track, bounced into the seating and died 36 hours later. A crash in Berlin on 18 July 1909 killed nine when a motorcycle careered into the stands and exploded.
The historian Peter Nye wrote:
Motorpace racing was glamorous but dangerous. Falls were common, largely because bicycle tires tended to burst at speed. The riders wore neither helmets nor gloves. They depended on fast reflexes, the rude health of youth, and luck. Despite having all three, Bobby Walthour collected an impressive (or dismaying) inventory of injuries over his career: 28 fractures of the right collarbone, 18 of the left, 32 broken ribs, and 60 stitches to his face and head. Once, according to family history, he was given up for dead in Paris and taken to a morgue, where he regained consciousness on the slab.
The biggest machines were built by the pacers, using parts from other motorcycles, with engines as large as . The largest had two riders, one crouched over the handlebars to steer and the other sitting upright above the back wheel to protect the rider and to operate the engine. The pacers wore leathers, goggles and helmets but many riders wore a flat cap.
The world governing body, the Union Cycliste Internationale, set regulations for pacing motorcycles in 1920. Until then standards had been set by the police, particularly in Germany, or by the track promoters.
World championships were held annually, except during wars, for 100 years, often separately for amateurs and professionals. Carsten Podlesch, who won in 1994, is the last and reigning world champion. National championships continue in several European countries and European championships are conducted annually.
Motorcycles now used include the Triumph Tiger or BMW machines. The motorcycle for motor-pacing has a roller on a frame at the rear to create a uniform distance to the cyclist. Some riders objected when the UCI insisted on them in 1920. The pacer stands or sits upright to offer a maximum windbreak, and the handlebars are extended to facilitate the stance, in a standardized leather suit that allows for the same slipstream effect for any rider. Speeds of can be reached; the average is .
The bicycles are steel, sturdy and have a smaller front wheel to let the stayer bend forward into the slipstream.
Pacing by Derny
A Derny is a light motorbike typically driven by a Zurcher two-stroke engine and by being pedaled through a fixed gear, typically of 70 teeth on the front chainring and 11 on the sprocket on the back wheel. The combination allows for smooth acceleration and slowing, important when the rider taking pace is centimetres from the pacer's shielded back wheel. A coupling between the motor and the back wheel ensures the machine will not stop dead if the motor seizes.
The first Entraineur or Bordeaux–Paris models, with a petrol tank across the handlebars, were built by Roger Derny et Fils of the avenue de St Mandé, Paris, France in 1938. That closed in 1957, though another company, Derny Service of rue de Picpus serviced and rebuilt machines into the 1970s. Derny also built a street adaptation called the Solo as well as tandems and mopeds.
The name derny is now applied to all such vehicles, regardless of manufacturer. It is used by the Larousse dictionary as a generic term for a small pacing motorcycle used in cycle races. The machine has to be bump-started. It can then pace riders up to , although races rarely exceed . Riders behind Derny-pacers ride conventional track bicycles.
Bordeaux–Paris was paced by Dernys for part of its route from 1946 to 1985.
Pacers
Cooperation between pacer and stayer includes the use of terms and signals understood internationally, because pacers and stayers may be of different nationalities. The stayer needs to be close to the roller to gain maximum profit from the slipstream; if he gets too close he may hit the roller and fall, if he falls too far behind it, he loses the slipstream effect and will quickly fall further back. The pacer then has to slow down so he can catch up and then accelerate without again losing his rider.
Races
Races are in velodromes or on other oval and steeply banked tracks to allow high-speed racing. After a flying start the cyclists link up with their pacers. Riding counterclockwise, passing can only be done on the right, a blue line separating the longer passing lane from the inner. Typically four to six couples compete in a race, covering up to or racing over a set time.
Keirin
The keirin, a Japanese sprint with a paced start which has spread across the world, is a variation of motor-paced racing. A group of cyclists use a single pacer to get to speed and then sprint to the finish on their own.
Records
The first registered distance record behind pacers was by Frederick Lindley Dodds of Britain, who on a solid-tired bicycle rode close to in the grounds of Cambridge University in 1876 during a 20-mile scratch race. A south London rider, J. W. Stocks, set an unbeaten British record of in an hour behind pacers on 27 September 1897.
From 1893 to 1895, Hélène Dutrieu set several women's paced hour records, ending with 39.190 km at Vélodrome Roubaisien. In 1896, Amélie Le Gall set a new women's paced hour record of 43.461 at Vélodrome Buffalo.
The first hour record behind a motorcycle was set at by Harry Elkes of the USA in 1898. He rode behind a motor-powered tandem. The first record behind a pure motorcycle was by Tom Linton of Britain at the Parc des Princes track in northwest Paris in 1902. The speed increased but records become more hazy because some were made under restrictions imposed by the Union Cycliste Internationale and others with no rules at all.
On 12 October 1950, Karl-Heinz Kramer set the world record for absolute speed behind a motorcycle with on the Grenzlandring.
Frenchman José Meiffret, set a record behind a Mercedes-Benz 300 SL on an Autobahn at Freiburg, Germany, on 16 July 1962. His bicycle had a 130-tooth chainring and wooden rims. Fred Rompelberg, using a dragster with a large shield as pacer, achieved on the Bonneville Salt Flats on 15 October 1995.
The British absolute speed record is held by Neil Campbell, pedaling at a speed of on 25 April 2016 behind a modified Volkswagen Passat. He broke the previous record of set by Guy Martin in 2013 behind a modified racing truck.
Denise Mueller-Korenek claimed a women's bicycle land speed record at at the Bonneville Salt Flats on 12 September 2016. Mueller was coached by former record holder John Howard. It is not clear which authority was supervising the record attempt. On 16 September 2018, again at Bonneville, she took the world record with a top speed of 183.93 mph (296 km/h) behind a converted rail dragster with a fairing.
See also
UCI Motor-paced World Championships
British National Derny Championships
French National Stayers Championships
References
External links
Stayer.de - Information site (in German)
Film of failed attempt by Meiffret to set speed record in 1952
Clifford L. Graves: A Date with Death (1965). About Meiffret's 1962 record attempt
Events in track cycling
|
Lamsal is a Nepalese surname. Notable people with the surname include:
Arunima Lamsal (contemporary), Nepalese actress
Laxman Lamsal (fl. 2018–present), Nepalese politician
Naba Raj Lamsal (born 1969), Nepalese poet, journalist, and author
Nepali-language surnames
|
TW or tw may refer to:
Arts and entertainment
Tomorrow's World, a British TV series
Total War (series), a computer strategy game series
Trade Wars, a 1984 online space trading game
Tribal Wars, an online strategy game
The Wanted, a British boy band
James TW, English singer-songwriter
The Wiggles, an Australian children's band
Companies
Time Warner, a media company
Taylor Wimpey, a housebuilding company
Towers Watson, a consulting firm, NYSE and NASDAQ symbols TW
T'way Air, IATA code TW since 2010
Trans World Airlines, IATA code TW until 2001
Places
Tunbridge Wells, a town in Kent, UK
Twickenham postcode area, UK, in Greater London and Surrey, England
Taiwan (ISO code TW)
Tsuen Wan, in Hong Kong
Tumwater
Other uses
.tw, a top-level Internet domain (Taiwan)
Shorthand of Technical Writer or Technical Writing
Terawatt, a unit of power
Tiger Woods (born 1975), American golfer
Transgender woman
Trigger warning, alerting readers/viewers to a stress-related trauma trigger within content
Tupamaros West-Berlin, a Marxist organization
TouchWiz, a phone touch interface
Treatment week, a pharmacological phrase
Twi language (ISO 639-1 language code)
Wikipedia:Twinkle, a JavaScript Wikipedia gadget that assists autoconfirmed registered users to deal with acts of vandalism or unconstructive edits.
|
```javascript
/**
* @license Apache-2.0
*
*
*
* path_to_url
*
* Unless required by applicable law or agreed to in writing, software
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
*/
'use strict';
/**
* Compute the standard deviation of a strided array ignoring `NaN` values and using a one-pass algorithm proposed by Youngs and Cramer.
*
* @module @stdlib/stats/base/nanstdevyc
*
* @example
* var nanstdevyc = require( '@stdlib/stats/base/nanstdevyc' );
*
* var x = [ 1.0, -2.0, NaN, 2.0 ];
*
* var v = nanstdevyc( x.length, 1, x, 1 );
* // returns ~2.0817
*
* @example
* var floor = require( '@stdlib/math/base/special/floor' );
* var nanstdevyc = require( '@stdlib/stats/base/nanstdevyc' );
*
* var x = [ 2.0, 1.0, 2.0, -2.0, -2.0, 2.0, 3.0, 4.0, NaN, NaN ];
* var N = floor( x.length / 2 );
*
* var v = nanstdevyc.ndarray( N, 1, x, 2, 1 );
* // returns 2.5
*/
// MODULES //
var main = require( './main.js' );
// EXPORTS //
module.exports = main;
// exports: { "ndarray": "main.ndarray" }
```
|
```javascript
import React from 'react';
import { Provider } from 'react-redux';
import { ConnectedRouter } from 'react-router-redux';
import PropTypes from 'prop-types';
import routes from '../../routes';
import DevTools from './DevTools';
import App from '../../app';
export default class Root extends React.Component {
static propTypes = {
store: PropTypes.shape().isRequired,
history: PropTypes.shape().isRequired
};
render() {
return (
<div>
<Provider store={this.props.store}>
<div>
<App>
<ConnectedRouter history={this.props.history}>
{routes}
</ConnectedRouter>
</App>
<DevTools />
</div>
</Provider>
</div>
);
}
}
```
|
```swift
//
// StatusItemBuilder.swift
// SpotMenu
//
// Created by Mikls Kristyn on 2017. 05. 01..
//
import Foundation
final class StatusItemBuilder {
// MARK: - Properties
private var title = ""
private var artist = ""
private var albumName = ""
private var playingIcon = ""
private var isPlaying: Bool = false
private var hideWhenPaused = false
// MARK: - Lifecycle method
init(title: String?, artist: String?, albumName: String?, isPlaying: Bool) {
if let v = title {
self.title = v
}
if let v = artist {
self.artist = v
}
if let v = albumName {
self.albumName = v
}
self.isPlaying = isPlaying
}
// MARK: - Methods
func hideWhenPaused(v: Bool) -> StatusItemBuilder {
hideWhenPaused = v
return self
}
func showTitle(v: Bool) -> StatusItemBuilder {
if !v {
title = ""
return self
}
if !isPlaying && hideWhenPaused {
title = ""
return self
}
return self
}
func showArtist(v: Bool) -> StatusItemBuilder {
if !v {
artist = ""
return self
}
if !isPlaying && hideWhenPaused {
artist = ""
return self
}
return self
}
func showAlbumName(v: Bool) -> StatusItemBuilder {
if !v {
albumName = ""
return self
}
if !isPlaying && hideWhenPaused {
albumName = ""
return self
}
return self
}
func showPlayingIcon(v: Bool) -> StatusItemBuilder {
if !v {
playingIcon = ""
return self
}
if isPlaying {
playingIcon = " "
} else {
playingIcon = ""
}
return self
}
func getString() -> String {
if artist.count != 0 && title.count != 0 && albumName.count != 0 {
return "\(playingIcon)\(artist) - \(title) - \(albumName)"
} else if artist.count != 0 && title.count != 0 {
return "\(playingIcon)\(artist) - \(title)"
}
return "\(playingIcon)\(artist)\(title)"
}
}
```
|
```python
#!/usr/bin/env python3
#
#
# path_to_url
#
# Unless required by applicable law or agreed to in writing, software
# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
#
################################################################################
"""Script for generating an OSS-Fuzz job for a wycheproof project."""
import sys
def main():
"""Usage generate_job.py <project>."""
project = sys.argv[1]
print(f'Name: wycheproof_nosanitizer_{project}')
job_definition = f"""CUSTOM_BINARY = False
BAD_BUILD_CHECK = False
APP_NAME = WycheproofTarget.bash
THREAD_ALIVE_CHECK_INTERVAL = 10
TEST_TIMEOUT = 3600
CRASH_RETRIES = 1
AGGREGATE_COVERAGE = False
TESTCASE_COVERAGE = False
FILE_GITHUB_ISSUE = False
MANAGED = False
MAX_FUZZ_THREADS = 1
RELEASE_BUILD_BUCKET_PATH = gs://clusterfuzz-builds-wycheproof/{project}/{project}-none-([0-9]+).zip
PROJECT_NAME = {project}
SUMMARY_PREFIX = {project}
REVISION_VARS_URL = path_to_url{project}/{project}-none-%s.srcmap.json
FUZZ_LOGS_BUCKET = {project}-logs.clusterfuzz-external.appspot.com
CORPUS_BUCKET = {project}-corpus.clusterfuzz-external.appspot.com
QUARANTINE_BUCKET = {project}-quarantine.clusterfuzz-external.appspot.com
BACKUP_BUCKET = {project}-backup.clusterfuzz-external.appspot.com
AUTOMATIC_LABELS = Proj-{project},Engine-wycheproof
"""
print(job_definition)
if __name__ == '__main__':
main()
```
|
```java
package com.journaldev.hsqldb;
import java.sql.Connection;
import java.sql.DriverManager;
import java.sql.SQLException;
public class HSQLDBConnection {
public static Connection getConnection() {
Connection con = null;
try {
Class.forName("org.hsqldb.jdbc.JDBCDriver");
System.out.println("HSQLDB JDBCDriver Loaded");
con = DriverManager.getConnection(
"jdbc:hsqldb:hsql://localhost/Test", "SA", "");
System.out.println("HSQLDB Connection Created");
} catch (ClassNotFoundException e) {
e.printStackTrace();
} catch (SQLException e) {
e.printStackTrace();
}
return con;
}
}
```
|
```python
"""
Generic Resource Tag / Filters and Actions wrapper
These work for the whole family of resources associated
to ec2 (subnets, vpc, security-groups, volumes, instances,
snapshots) and resources that support Amazon's Resource Groups Tagging API
"""
from collections import Counter
from concurrent.futures import as_completed
from datetime import datetime, timedelta
from dateutil import tz as tzutil
from dateutil.parser import parse
import time
from c7n.manager import resources as aws_resources
from c7n.actions import BaseAction as Action, AutoTagUser
from c7n.exceptions import PolicyValidationError, PolicyExecutionError
from c7n.resources import load_resources
from c7n.filters import Filter, OPERATORS
from c7n.filters.offhours import Time
from c7n import deprecated, utils
DEFAULT_TAG = "maid_status"
def register_ec2_tags(filters, actions):
filters.register('marked-for-op', TagActionFilter)
filters.register('tag-count', TagCountFilter)
actions.register('auto-tag-user', AutoTagUser)
actions.register('mark-for-op', TagDelayedAction)
actions.register('tag-trim', TagTrim)
actions.register('mark', Tag)
actions.register('tag', Tag)
actions.register('unmark', RemoveTag)
actions.register('untag', RemoveTag)
actions.register('remove-tag', RemoveTag)
actions.register('rename-tag', RenameTag)
actions.register('normalize-tag', NormalizeTag)
def register_universal_tags(filters, actions, compatibility=True):
filters.register('marked-for-op', TagActionFilter)
if compatibility:
filters.register('tag-count', TagCountFilter)
actions.register('mark', UniversalTag)
actions.register('tag', UniversalTag)
actions.register('auto-tag-user', AutoTagUser)
actions.register('mark-for-op', UniversalTagDelayedAction)
if compatibility:
actions.register('unmark', UniversalUntag)
actions.register('untag', UniversalUntag)
actions.register('remove-tag', UniversalUntag)
actions.register('rename-tag', UniversalTagRename)
def universal_augment(self, resources):
# Resource Tagging API Support
# path_to_url
# Bail on empty set
if not resources:
return resources
region = utils.get_resource_tagging_region(self.resource_type, self.region)
self.log.debug("Using region %s for resource tagging" % region)
client = utils.local_session(
self.session_factory).client('resourcegroupstaggingapi', region_name=region)
# Lazy for non circular :-(
from c7n.query import RetryPageIterator
paginator = client.get_paginator('get_resources')
paginator.PAGE_ITERATOR_CLS = RetryPageIterator
rfetch = [r for r in resources if 'Tags' not in r]
for arn_resource_set in utils.chunks(
zip(self.get_arns(rfetch), rfetch), 100):
arn_resource_map = dict(arn_resource_set)
resource_tag_results = client.get_resources(
ResourceARNList=list(arn_resource_map.keys())).get(
'ResourceTagMappingList', ())
resource_tag_map = {
r['ResourceARN']: r['Tags'] for r in resource_tag_results}
for arn, r in arn_resource_map.items():
r['Tags'] = resource_tag_map.get(arn, [])
return resources
def _common_tag_processer(executor_factory, batch_size, concurrency, client,
process_resource_set, id_key, resources, tags,
log):
error = None
with executor_factory(max_workers=concurrency) as w:
futures = []
for resource_set in utils.chunks(resources, size=batch_size):
futures.append(
w.submit(process_resource_set, client, resource_set, tags))
for f in as_completed(futures):
if f.exception():
error = f.exception()
log.error(
"Exception with tags: %s %s", tags, f.exception())
if error:
raise error
class TagTrim(Action):
"""Automatically remove tags from an ec2 resource.
EC2 Resources have a limit of 50 tags, in order to make
additional tags space on a set of resources, this action can
be used to remove enough tags to make the desired amount of
space while preserving a given set of tags.
.. code-block :: yaml
policies:
- name: ec2-tag-trim
comment: |
Any instances with 48 or more tags get tags removed until
they match the target tag count, in this case 47 so we
that we free up a tag slot for another usage.
resource: ec2
filters:
# Filter down to resources which already have 8 tags
# as we need space for 3 more, this also ensures that
# metrics reporting is correct for the policy.
- type: value
key: "length(Tags)"
op: ge
value: 48
actions:
- type: tag-trim
space: 3
preserve:
- OwnerContact
- ASV
- CMDBEnvironment
- downtime
- custodian_status
"""
max_tag_count = 50
schema = utils.type_schema(
'tag-trim',
space={'type': 'integer'},
preserve={'type': 'array', 'items': {'type': 'string'}})
schema_alias = True
permissions = ('ec2:DeleteTags',)
def process(self, resources):
self.id_key = self.manager.get_model().id
self.preserve = set(self.data.get('preserve'))
self.space = self.data.get('space', 3)
client = utils.local_session(
self.manager.session_factory).client(self.manager.resource_type.service)
futures = {}
mid = self.manager.get_model().id
with self.executor_factory(max_workers=2) as w:
for r in resources:
futures[w.submit(self.process_resource, client, r)] = r
for f in as_completed(futures):
if f.exception():
self.log.warning(
"Error processing tag-trim on resource:%s",
futures[f][mid])
def process_resource(self, client, i):
# Can't really go in batch parallel without some heuristics
# without some more complex matching wrt to grouping resources
# by common tags populations.
tag_map = {
t['Key']: t['Value'] for t in i.get('Tags', [])
if not t['Key'].startswith('aws:')}
# Space == 0 means remove all but specified
if self.space and len(tag_map) + self.space <= self.max_tag_count:
return
keys = set(tag_map)
preserve = self.preserve.intersection(keys)
candidates = keys - self.preserve
if self.space:
# Free up slots to fit
remove = len(candidates) - (
self.max_tag_count - (self.space + len(preserve)))
candidates = list(sorted(candidates))[:remove]
if not candidates:
self.log.warning(
"Could not find any candidates to trim %s" % i[self.id_key])
return
self.process_tag_removal(i, candidates)
def process_tag_removal(self, client, resource, tags):
self.manager.retry(
client.delete_tags,
Tags=[{'Key': c} for c in tags],
Resources=[resource[self.id_key]],
DryRun=self.manager.config.dryrun)
class TagActionFilter(Filter):
"""Filter resources for tag specified future action
Filters resources by a 'maid_status' tag which specifies a future
date for an action.
The filter parses the tag values looking for an 'op@date'
string. The date is parsed and compared to do today's date, the
filter succeeds if today's date is gte to the target date.
The optional 'skew' parameter provides for incrementing today's
date a number of days into the future. An example use case might
be sending a final notice email a few days before terminating an
instance, or snapshotting a volume prior to deletion.
The optional 'skew_hours' parameter provides for incrementing the current
time a number of hours into the future.
Optionally, the 'tz' parameter can get used to specify the timezone
in which to interpret the clock (default value is 'utc')
.. code-block :: yaml
policies:
- name: ec2-stop-marked
resource: ec2
filters:
- type: marked-for-op
# The default tag used is maid_status
# but that is configurable
tag: custodian_status
op: stop
# Another optional tag is skew
tz: utc
actions:
- type: stop
"""
schema = utils.type_schema(
'marked-for-op',
tag={'type': 'string'},
tz={'type': 'string'},
skew={'type': 'number', 'minimum': 0},
skew_hours={'type': 'number', 'minimum': 0},
op={'type': 'string'})
schema_alias = True
def validate(self):
op = self.data.get('op')
if self.manager and op not in self.manager.action_registry.keys():
raise PolicyValidationError(
"Invalid marked-for-op op:%s in %s" % (op, self.manager.data))
tz = tzutil.gettz(Time.TZ_ALIASES.get(self.data.get('tz', 'utc')))
if not tz:
raise PolicyValidationError(
"Invalid timezone specified '%s' in %s" % (
self.data.get('tz'), self.manager.data))
return self
def __call__(self, i):
tag = self.data.get('tag', DEFAULT_TAG)
op = self.data.get('op', 'stop')
skew = self.data.get('skew', 0)
skew_hours = self.data.get('skew_hours', 0)
tz = tzutil.gettz(Time.TZ_ALIASES.get(self.data.get('tz', 'utc')))
v = None
for n in i.get('Tags', ()):
if n['Key'] == tag:
v = n['Value']
break
if v is None:
return False
if ':' not in v or '@' not in v:
return False
_, tgt = v.rsplit(':', 1)
action, action_date_str = tgt.strip().split('@', 1)
if action != op:
return False
try:
action_date = parse(action_date_str)
except Exception:
self.log.warning("could not parse tag:%s value:%s on %s" % (
tag, v, i['InstanceId']))
return False
if action_date.tzinfo:
# if action_date is timezone aware, set to timezone provided
action_date = action_date.astimezone(tz)
current_date = datetime.now(tz=tz)
else:
current_date = datetime.now()
return current_date >= (
action_date - timedelta(days=skew, hours=skew_hours))
class TagCountFilter(Filter):
"""Simplify tag counting..
ie. these two blocks are equivalent
.. code-block :: yaml
- filters:
- type: value
op: gte
count: 8
- filters:
- type: tag-count
count: 8
"""
schema = utils.type_schema(
'tag-count',
count={'type': 'integer', 'minimum': 0},
op={'enum': list(OPERATORS.keys())})
schema_alias = True
def __call__(self, i):
count = self.data.get('count', 10)
op_name = self.data.get('op', 'gte')
op = OPERATORS.get(op_name)
tag_count = len([
t['Key'] for t in i.get('Tags', [])
if not t['Key'].startswith('aws:')])
return op(tag_count, count)
class Tag(Action):
"""Tag an ec2 resource.
"""
batch_size = 25
concurrency = 2
deprecations = (
deprecated.alias('mark'),
)
schema = utils.type_schema(
'tag', aliases=('mark',),
tags={'type': 'object'},
key={'type': 'string'},
value={'type': 'string'},
tag={'type': 'string'},
)
schema_alias = True
permissions = ('ec2:CreateTags',)
id_key = None
def validate(self):
if self.data.get('key') and self.data.get('tag'):
raise PolicyValidationError(
"Can't specify both key and tag, choose one in %s" % (
self.manager.data,))
return self
def process(self, resources):
# Legacy
msg = self.data.get('msg')
msg = self.data.get('value') or msg
tag = self.data.get('tag', DEFAULT_TAG)
tag = self.data.get('key') or tag
# Support setting multiple tags in a single go with a mapping
tags = self.data.get('tags')
if tags is None:
tags = []
else:
tags = [{'Key': k, 'Value': v} for k, v in tags.items()]
if msg:
tags.append({'Key': tag, 'Value': msg})
self.interpolate_values(tags)
batch_size = self.data.get('batch_size', self.batch_size)
client = self.get_client()
_common_tag_processer(
self.executor_factory, batch_size, self.concurrency, client,
self.process_resource_set, self.id_key, resources, tags, self.log)
def process_resource_set(self, client, resource_set, tags):
mid = self.manager.get_model().id
self.manager.retry(
client.create_tags,
Resources=[v[mid] for v in resource_set],
Tags=tags,
DryRun=self.manager.config.dryrun)
def interpolate_single_value(self, tag):
"""Interpolate in a single tag value.
"""
params = {
'account_id': self.manager.config.account_id,
'now': utils.FormatDate.utcnow(),
'region': self.manager.config.region}
return str(tag).format(**params)
def interpolate_values(self, tags):
"""Interpolate in a list of tags - 'old' ec2 format
"""
for t in tags:
t['Value'] = self.interpolate_single_value(t['Value'])
def get_client(self):
return utils.local_session(self.manager.session_factory).client(
self.manager.resource_type.service)
class RemoveTag(Action):
"""Remove tags from ec2 resources.
"""
deprecations = (
deprecated.alias('unmark'),
deprecated.alias('untag'),
)
batch_size = 100
concurrency = 2
schema = utils.type_schema(
'remove-tag', aliases=('unmark', 'untag', 'remove-tag'),
tags={'type': 'array', 'items': {'type': 'string'}})
schema_alias = True
permissions = ('ec2:DeleteTags',)
def process(self, resources):
self.id_key = self.manager.get_model().id
tags = self.data.get('tags', [DEFAULT_TAG])
batch_size = self.data.get('batch_size', self.batch_size)
client = self.get_client()
_common_tag_processer(
self.executor_factory, batch_size, self.concurrency, client,
self.process_resource_set, self.id_key, resources, tags, self.log)
def process_resource_set(self, client, resource_set, tag_keys):
return self.manager.retry(
client.delete_tags,
Resources=[v[self.id_key] for v in resource_set],
Tags=[{'Key': k} for k in tag_keys],
DryRun=self.manager.config.dryrun)
def get_client(self):
return utils.local_session(self.manager.session_factory).client(
self.manager.resource_type.service)
class RenameTag(Action):
""" Create a new tag with identical value & remove old tag
"""
schema = utils.type_schema(
'rename-tag',
old_key={'type': 'string'},
new_key={'type': 'string'})
schema_alias = True
permissions = ('ec2:CreateTags', 'ec2:DeleteTags')
tag_count_max = 50
def delete_tag(self, client, ids, key, value):
client.delete_tags(
Resources=ids,
Tags=[{'Key': key, 'Value': value}])
def create_tag(self, client, ids, key, value):
client.create_tags(
Resources=ids,
Tags=[{'Key': key, 'Value': value}])
def process_rename(self, client, tag_value, resource_set):
"""
Move source tag value to destination tag value
- Collect value from old tag
- Delete old tag
- Create new tag & assign stored value
"""
self.log.info("Renaming tag on %s instances" % (len(resource_set)))
old_key = self.data.get('old_key')
new_key = self.data.get('new_key')
# We have a preference to creating the new tag when possible first
resource_ids = [r[self.id_key] for r in resource_set if len(
r.get('Tags', [])) < self.tag_count_max]
if resource_ids:
self.create_tag(client, resource_ids, new_key, tag_value)
self.delete_tag(
client, [r[self.id_key] for r in resource_set], old_key, tag_value)
# For resources with 50 tags, we need to delete first and then create.
resource_ids = [r[self.id_key] for r in resource_set if len(
r.get('Tags', [])) > self.tag_count_max - 1]
if resource_ids:
self.create_tag(client, resource_ids, new_key, tag_value)
def create_set(self, instances):
old_key = self.data.get('old_key', None)
resource_set = {}
for r in instances:
tags = {t['Key']: t['Value'] for t in r.get('Tags', [])}
if tags[old_key] not in resource_set:
resource_set[tags[old_key]] = []
resource_set[tags[old_key]].append(r)
return resource_set
def filter_resources(self, resources):
old_key = self.data.get('old_key', None)
filtered_resources = [
r for r in resources
if old_key in (t['Key'] for t in r.get('Tags', []))
]
return filtered_resources
def process(self, resources):
count = len(resources)
resources = self.filter_resources(resources)
self.log.info(
"Filtered from %s resources to %s" % (count, len(resources)))
self.id_key = self.manager.get_model().id
resource_set = self.create_set(resources)
client = self.get_client()
with self.executor_factory(max_workers=3) as w:
futures = []
for r in resource_set:
futures.append(
w.submit(self.process_rename, client, r, resource_set[r]))
for f in as_completed(futures):
if f.exception():
self.log.error(
"Exception renaming tag set \n %s" % (
f.exception()))
return resources
def get_client(self):
return utils.local_session(self.manager.session_factory).client(
self.manager.resource_type.service)
class TagDelayedAction(Action):
"""Tag resources for future action.
The optional 'tz' parameter can be used to adjust the clock to align
with a given timezone. The default value is 'utc'.
If neither 'days' nor 'hours' is specified, Cloud Custodian will default
to marking the resource for action 4 days in the future.
.. code-block :: yaml
policies:
- name: ec2-mark-for-stop-in-future
resource: ec2
filters:
- type: value
key: Name
value: instance-to-stop-in-four-days
actions:
- type: mark-for-op
op: stop
"""
deprecations = (
deprecated.optional_fields(('hours', 'days')),
)
schema = utils.type_schema(
'mark-for-op',
tag={'type': 'string'},
msg={'type': 'string'},
days={'type': 'number', 'minimum': 0},
hours={'type': 'number', 'minimum': 0},
tz={'type': 'string'},
op={'type': 'string'})
schema_alias = True
batch_size = 200
concurrency = 2
default_template = 'Resource does not meet policy: {op}@{action_date}'
def get_permissions(self):
return self.manager.action_registry['tag'].permissions
def validate(self):
op = self.data.get('op')
if self.manager and op not in self.manager.action_registry.keys():
raise PolicyValidationError(
"mark-for-op specifies invalid op:%s in %s" % (
op, self.manager.data))
self.tz = tzutil.gettz(
Time.TZ_ALIASES.get(self.data.get('tz', 'utc')))
if not self.tz:
raise PolicyValidationError(
"Invalid timezone specified %s in %s" % (
self.tz, self.manager.data))
return self
def generate_timestamp(self, days, hours):
n = datetime.now(tz=self.tz)
if days is None or hours is None:
# maintains default value of days being 4 if nothing is provided
days = 4
action_date = (n + timedelta(days=days, hours=hours))
if hours > 0:
action_date_string = action_date.strftime('%Y/%m/%d %H%M %Z')
else:
action_date_string = action_date.strftime('%Y/%m/%d')
return action_date_string
def get_config_values(self):
d = {
'op': self.data.get('op', 'stop'),
'tag': self.data.get('tag', DEFAULT_TAG),
'msg': self.data.get('msg', self.default_template),
'tz': self.data.get('tz', 'utc'),
'days': self.data.get('days', 0),
'hours': self.data.get('hours', 0)}
d['action_date'] = self.generate_timestamp(
d['days'], d['hours'])
return d
def process(self, resources):
cfg = self.get_config_values()
self.tz = tzutil.gettz(Time.TZ_ALIASES.get(cfg['tz']))
self.id_key = self.manager.get_model().id
msg = cfg['msg'].format(
op=cfg['op'], action_date=cfg['action_date'])
self.log.info("Tagging %d resources for %s on %s" % (
len(resources), cfg['op'], cfg['action_date']))
tags = [{'Key': cfg['tag'], 'Value': msg}]
# if the tag implementation has a specified batch size, it's typically
# due to some restraint on the api so we defer to that.
batch_size = getattr(
self.manager.action_registry.get('tag'), 'batch_size', self.batch_size)
client = self.get_client()
_common_tag_processer(
self.executor_factory, batch_size, self.concurrency, client,
self.process_resource_set, self.id_key, resources, tags, self.log)
def process_resource_set(self, client, resource_set, tags):
tagger = self.manager.action_registry['tag']({}, self.manager)
tagger.process_resource_set(client, resource_set, tags)
def get_client(self):
return utils.local_session(
self.manager.session_factory).client(
self.manager.resource_type.service)
class NormalizeTag(Action):
"""Transform the value of a tag.
Set the tag value to uppercase, title, lowercase, or strip text
from a tag key.
.. code-block :: yaml
policies:
- name: ec2-service-transform-lower
resource: ec2
comment: |
ec2-service-tag-value-to-lower
query:
- instance-state-name: running
filters:
- "tag:testing8882": present
actions:
- type: normalize-tag
key: lower_key
action: lower
- name: ec2-service-strip
resource: ec2
comment: |
ec2-service-tag-strip-blah
query:
- instance-state-name: running
filters:
- "tag:testing8882": present
actions:
- type: normalize-tag
key: strip_key
action: strip
value: blah
"""
schema_alias = True
schema = utils.type_schema(
'normalize-tag',
key={'type': 'string'},
action={'type': 'string',
'items': {
'enum': ['upper', 'lower', 'title' 'strip', 'replace']}},
value={'type': 'string'})
permissions = ('ec2:CreateTags',)
def create_tag(self, client, ids, key, value):
self.manager.retry(
client.create_tags,
Resources=ids,
Tags=[{'Key': key, 'Value': value}])
def process_transform(self, tag_value, resource_set):
"""
Transform tag value
- Collect value from tag
- Transform Tag value
- Assign new value for key
"""
self.log.info("Transforming tag value on %s instances" % (
len(resource_set)))
key = self.data.get('key')
c = utils.local_session(self.manager.session_factory).client('ec2')
self.create_tag(
c,
[r[self.id_key] for r in resource_set if len(
r.get('Tags', [])) < 50],
key, tag_value)
def create_set(self, instances):
key = self.data.get('key', None)
resource_set = {}
for r in instances:
tags = {t['Key']: t['Value'] for t in r.get('Tags', [])}
if tags[key] not in resource_set:
resource_set[tags[key]] = []
resource_set[tags[key]].append(r)
return resource_set
def filter_resources(self, resources):
key = self.data.get('key', None)
filtered_resources = [
r for r in resources
if key in (t['Key'] for t in r.get('Tags', []))
]
return filtered_resources
def process(self, resources):
count = len(resources)
resources = self.filter_resources(resources)
self.log.info(
"Filtered from %s resources to %s" % (count, len(resources)))
self.id_key = self.manager.get_model().id
resource_set = self.create_set(resources)
with self.executor_factory(max_workers=3) as w:
futures = []
for r in resource_set:
action = self.data.get('action')
value = self.data.get('value')
new_value = False
if action == 'lower' and not r.islower():
new_value = r.lower()
elif action == 'upper' and not r.isupper():
new_value = r.upper()
elif action == 'title' and not r.istitle():
new_value = r.title()
elif action == 'strip' and value and value in r:
new_value = r.strip(value)
if new_value:
futures.append(
w.submit(self.process_transform, new_value, resource_set[r]))
for f in as_completed(futures):
if f.exception():
self.log.error(
"Exception renaming tag set \n %s" % (
f.exception()))
return resources
class UniversalTag(Tag):
"""Applies one or more tags to the specified resources.
:example:
.. code-block :: yaml
policies:
- name: multiple-tags-example
comment: |
Tags any secrets missing either the Environment or ResourceOwner tag
resource: aws.secrets-manager
filters:
- or:
- "tag:Environment": absent
- "tag:ResourceOwner": absent
actions:
- type: tag
tags:
Environment: Staging
ResourceOwner: Avengers
"""
batch_size = 20
concurrency = 1
permissions = ('tag:TagResources',)
def process(self, resources):
self.id_key = self.manager.get_model().id
# Legacy
msg = self.data.get('msg')
msg = self.data.get('value') or msg
tag = self.data.get('tag', DEFAULT_TAG)
tag = self.data.get('key') or tag
# Support setting multiple tags in a single go with a mapping
tags = self.data.get('tags', {})
if msg:
tags[tag] = msg
self.interpolate_values(tags)
batch_size = self.data.get('batch_size', self.batch_size)
client = self.get_client()
_common_tag_processer(
self.executor_factory, batch_size, self.concurrency, client,
self.process_resource_set, self.id_key, resources, tags, self.log)
def process_resource_set(self, client, resource_set, tags):
arns = self.manager.get_arns(resource_set)
return universal_retry(
client.tag_resources, ResourceARNList=arns, Tags=tags)
def interpolate_values(self, tags):
"""Interpolate in a list of tags - 'new' resourcegroupstaggingapi format
"""
for key in list(tags.keys()):
tags[key] = self.interpolate_single_value(tags[key])
def get_client(self):
# For global resources, manage tags from us-east-1
region = (getattr(self.manager.resource_type, 'global_resource', None)
and 'us-east-1' or self.manager.region)
return utils.local_session(self.manager.session_factory).client(
'resourcegroupstaggingapi', region_name=region)
class UniversalUntag(RemoveTag):
"""Removes the specified tags from the specified resources.
"""
batch_size = 20
concurrency = 1
permissions = ('tag:UntagResources',)
def get_client(self):
# For global resources, manage tags from us-east-1
region = (getattr(self.manager.resource_type, 'global_resource', None)
and 'us-east-1' or self.manager.region)
return utils.local_session(self.manager.session_factory).client(
'resourcegroupstaggingapi', region_name=region)
def process_resource_set(self, client, resource_set, tag_keys):
arns = self.manager.get_arns(resource_set)
return universal_retry(
client.untag_resources, ResourceARNList=arns, TagKeys=tag_keys)
class UniversalTagRename(Action):
"""Rename an existing tag key to a new value.
:example:
rename Application, and Bap to App, if a resource has both of the old keys
then we'll use the value specified by Application, which is based on the
order of values of old_keys.
.. code-block :: yaml
policies:
- name: rename-tags-example
resource: aws.log-group
filters:
- or:
- "tag:Bap": present
- "tag:Application": present
actions:
- type: rename-tag
old_keys: [Application, Bap]
new_key: App
"""
schema = utils.type_schema(
'rename-tag',
old_keys={'type': 'array', 'items': {'type': 'string'}},
old_key={'type': 'string'},
new_key={'type': 'string'},
)
permissions = UniversalTag.permissions + UniversalUntag.permissions
def validate(self):
if 'old_keys' not in self.data and 'old_key' not in self.data:
raise PolicyValidationError(
f"{self.manager.ctx.policy.name}:{self.type} 'old_keys' or 'old_key' required")
def process(self, resources):
old_keys = set(self.data.get('old_keys', ()))
if 'old_key' in self.data:
old_keys.add(self.data['old_key'])
# Collect by distinct tag value, and old_key value to minimize api calls
# via bulk api usage on add and remove.
old_key_resources = {}
values_resources = {}
# sort tags using ordering of old_keys
def key_func(a):
if a['Key'] in old_keys:
return self.data['old_keys'].index(a['Key'])
return 50
for r in resources:
found = False
for t in sorted(r.get('Tags', ()), key=key_func):
if t['Key'] in old_keys:
old_key_resources.setdefault(t['Key'], []).append(r)
if not found:
values_resources.setdefault(t['Value'], []).append(r)
found = True
new_key = self.data['new_key']
for value, rpopulation in values_resources.items():
tagger = UniversalTag({'key': new_key, 'value': value}, self.manager)
tagger.process(rpopulation)
for old_key, rpopulation in old_key_resources.items():
cleaner = UniversalUntag({'tags': [old_key]}, self.manager)
cleaner.process(rpopulation)
class UniversalTagDelayedAction(TagDelayedAction):
"""Tag resources for future action.
:example:
.. code-block :: yaml
policies:
- name: ec2-mark-stop
resource: ec2
filters:
- type: image-age
op: ge
days: 90
actions:
- type: mark-for-op
tag: custodian_cleanup
op: terminate
days: 4
"""
batch_size = 20
concurrency = 1
def process(self, resources):
self.tz = tzutil.gettz(
Time.TZ_ALIASES.get(self.data.get('tz', 'utc')))
self.id_key = self.manager.get_model().id
# Move this to policy? / no resources bypasses actions?
if not len(resources):
return
msg_tmpl = self.data.get('msg', self.default_template)
op = self.data.get('op', 'stop')
tag = self.data.get('tag', DEFAULT_TAG)
days = self.data.get('days', 0)
hours = self.data.get('hours', 0)
action_date = self.generate_timestamp(days, hours)
msg = msg_tmpl.format(
op=op, action_date=action_date)
self.log.info("Tagging %d resources for %s on %s" % (
len(resources), op, action_date))
tags = {tag: msg}
batch_size = self.data.get('batch_size', self.batch_size)
client = self.get_client()
_common_tag_processer(
self.executor_factory, batch_size, self.concurrency, client,
self.process_resource_set, self.id_key, resources, tags, self.log)
def process_resource_set(self, client, resource_set, tags):
arns = self.manager.get_arns(resource_set)
return universal_retry(
client.tag_resources, ResourceARNList=arns, Tags=tags)
def get_client(self):
# For global resources, manage tags from us-east-1
region = (getattr(self.manager.resource_type, 'global_resource', None)
and 'us-east-1' or self.manager.region)
return utils.local_session(self.manager.session_factory).client(
'resourcegroupstaggingapi', region_name=region)
class CopyRelatedResourceTag(Tag):
"""
Copy a related resource tag to its associated resource
In some scenarios, resource tags from a related resource should be applied
to its child resource. For example, EBS Volume tags propogating to their
snapshots. To use this action, specify the resource type that contains the
tags that are to be copied, which can be found by using the
`custodian schema` command.
Then, specify the key on the resource that references the related resource.
In the case of ebs-snapshot, the VolumeId attribute would be the key that
identifies the related resource, ebs.
Finally, specify a list of tag keys to copy from the related resource onto
the original resource. The special character "*" can be used to signify that
all tags from the related resource should be copied to the original resource.
To raise an error when related resources cannot be found, use the
`skip_missing` option. By default, this is set to True.
:example:
.. code-block:: yaml
policies:
- name: copy-tags-from-ebs-volume-to-snapshot
resource: ebs-snapshot
actions:
- type: copy-related-tag
resource: ebs
skip_missing: True
key: VolumeId
tags: '*'
In the event that the resource type is not supported in Cloud Custodian but
is supported in the resources groups tagging api, use the resourcegroupstaggingapi
resource type to reference the resource. The value should be an ARN for the
related resource.
:example:
.. code-block:: yaml
policies:
- name: copy-tags-from-unsupported-resource
resource: ebs-snapshot
actions:
- type: copy-related-tag
resource: resourcegroupstaggingapi
key: tag:a-resource-tag
tags: '*'
"""
schema = utils.type_schema(
'copy-related-tag',
resource={'type': 'string'},
skip_missing={'type': 'boolean'},
key={'type': 'string'},
tags={'oneOf': [
{'enum': ['*']},
{'type': 'array'}
]},
required=['tags', 'key', 'resource']
)
schema_alias = True
def get_permissions(self):
return self.manager.action_registry.get('tag').permissions
def validate(self):
related_resource = self.data['resource']
if '.' in self.data['resource']:
related_resource = self.data['resource'].split('.')[-1]
load_resources((f'aws.{related_resource}', ))
if (
related_resource not in aws_resources.keys() and
related_resource != "resourcegroupstaggingapi"
):
raise PolicyValidationError(
"Error: Invalid resource type selected: %s" % related_resource
)
# ideally should never raise here since we shouldn't be applying this
# action to a resource if it doesn't have a tag action implemented
if self.manager.action_registry.get('tag') is None:
raise PolicyValidationError(
"Error: Tag action missing on resource"
)
return self
def process(self, resources):
related_resources = []
if self.data['key'].startswith('tag:'):
tag_key = self.data['key'].split(':', 1)[-1]
search_path = "[].[Tags[?Key=='%s'].Value | [0]]" % tag_key
else:
search_path = "[].[%s]" % self.data['key']
for rrid, r in zip(utils.jmespath_search(search_path, resources),
resources):
related_resources.append((rrid.pop(), r))
related_ids = {r[0] for r in related_resources}
missing = False
if None in related_ids:
missing = True
related_ids.discard(None)
related_tag_map = {}
if self.data['resource'] == 'resourcegroupstaggingapi':
related_tag_map = self.get_resource_tag_map_universal(related_ids)
else:
related_tag_map = self.get_resource_tag_map(self.data['resource'], related_ids)
missing_related_tags = related_ids.difference(related_tag_map.keys())
if not self.data.get('skip_missing', True) and (missing_related_tags or missing):
raise PolicyExecutionError(
"Unable to find all %d %s related resources tags %d missing" % (
len(related_ids), self.data['resource'],
len(missing_related_tags) + int(missing)))
# rely on resource manager tag action implementation as it can differ between resources
tag_action = self.manager.action_registry.get('tag')({}, self.manager)
tag_action.id_key = tag_action.manager.get_model().id
client = tag_action.get_client()
stats = Counter()
for related, r in related_resources:
if (related is None or
related in missing_related_tags or
not related_tag_map[related]):
stats['missing'] += 1
elif self.process_resource(
client, r, related_tag_map[related], self.data['tags'], tag_action):
stats['tagged'] += 1
else:
stats['unchanged'] += 1
self.log.info(
'Tagged %d resources from related, missing-skipped %d unchanged %d',
stats['tagged'], stats['missing'], stats['unchanged'])
def process_resource(self, client, r, related_tags, tag_keys, tag_action):
tags = {}
resource_tags = {
t['Key']: t['Value'] for t in r.get('Tags', []) if not t['Key'].startswith('aws:')}
if tag_keys == '*':
tags = {k: v for k, v in related_tags.items()
if resource_tags.get(k) != v and not k.startswith('aws:')}
else:
tags = {k: v for k, v in related_tags.items()
if k in tag_keys and resource_tags.get(k) != v}
if not tags:
return
if not isinstance(tag_action, UniversalTag):
tags = [{'Key': k, 'Value': v} for k, v in tags.items()]
tag_action.process_resource_set(client, [r], tags)
return True
def get_resource_tag_map(self, r_type, ids):
"""
Returns a mapping of {resource_id: {tagkey: tagvalue}}
"""
manager = self.manager.get_resource_manager(r_type)
r_id = manager.resource_type.id
return {
r[r_id]: {t['Key']: t['Value'] for t in r.get('Tags', [])}
for r in manager.get_resources(list(ids))
}
def get_resource_tag_map_universal(self, ids):
related_region = None
ids = list(ids)
if ids:
if ids[0].startswith('arn:aws:iam'):
related_region = 'us-east-1'
client = utils.local_session(
self.manager.session_factory).client(
'resourcegroupstaggingapi', region_name=related_region)
from c7n.query import RetryPageIterator
paginator = client.get_paginator('get_resources')
paginator.PAGE_ITERATOR_CLS = RetryPageIterator
resource_tag_results = client.get_resources(
ResourceARNList=list(ids))['ResourceTagMappingList']
resource_tag_map = {
r['ResourceARN']: {r['Key']: r['Value'] for r in r['Tags']}
for r in resource_tag_results}
return resource_tag_map
@classmethod
def register_resources(klass, registry, resource_class):
if not resource_class.action_registry.get('tag'):
return
resource_class.action_registry.register('copy-related-tag', klass)
aws_resources.subscribe(CopyRelatedResourceTag.register_resources)
def universal_retry(method, ResourceARNList, **kw):
"""Retry support for resourcegroup tagging apis.
The resource group tagging api typically returns a 200 status code
with embedded resource specific errors. To enable resource specific
retry on throttles, we extract those, perform backoff w/ jitter and
continue. Other errors are immediately raised.
We do not aggregate unified resource responses across retries, only the
last successful response is returned for a subset of the resources if
a retry is performed.
"""
max_attempts = 6
for idx, delay in enumerate(
utils.backoff_delays(1.5, 2 ** 8, jitter=True)):
response = method(ResourceARNList=ResourceARNList, **kw)
failures = response.get('FailedResourcesMap', {})
if not failures:
return response
errors = {}
throttles = set()
for f_arn in failures:
error_code = failures[f_arn]['ErrorCode']
if error_code == 'ThrottlingException':
throttles.add(f_arn)
elif error_code == 'ResourceNotFoundException':
continue
else:
errors[f_arn] = error_code
if errors:
raise Exception("Resource Tag Errors %s" % (errors))
if idx == max_attempts - 1:
raise Exception("Resource Tag Throttled %s" % (", ".join(throttles)))
time.sleep(delay)
ResourceARNList = list(throttles)
def coalesce_copy_user_tags(resource, copy_tags, user_tags):
"""
Returns a list of tags from resource and user supplied in
the format: [{'Key': 'key', 'Value': 'value'}]
Due to drift on implementation on copy-tags/tags used throughout
the code base, the following options are supported:
copy_tags (Tags to copy from the resource):
- list of str, e.g. ['key1', 'key2', '*']
- bool
user_tags (User supplied tags to apply):
- dict of key-value pairs, e.g. {Key: Value, Key2: Value}
- list of dict e.g. [{'Key': k, 'Value': v}]
In the case that there is a conflict in a user supplied tag
and an existing tag on the resource, the user supplied tags will
take priority.
Additionally, a value of '*' in copy_tags can be used to signify
to copy all tags from the resource.
"""
assert isinstance(copy_tags, bool) or isinstance(copy_tags, list)
assert isinstance(user_tags, dict) or isinstance(user_tags, list)
r_tags = resource.get('Tags', [])
if isinstance(copy_tags, list):
if '*' in copy_tags:
copy_keys = {t['Key'] for t in r_tags if not t['Key'].startswith('aws:')}
else:
copy_keys = set(copy_tags)
if isinstance(copy_tags, bool):
if copy_tags is True:
copy_keys = {t['Key'] for t in r_tags if not t['Key'].startswith('aws:')}
else:
copy_keys = set()
if isinstance(user_tags, dict):
user_tags = [{'Key': k, 'Value': v} for k, v in user_tags.items()]
user_keys = {t['Key'] for t in user_tags}
tags_diff = list(copy_keys.difference(user_keys))
resource_tags_to_copy = [t for t in r_tags if t['Key'] in tags_diff]
user_tags.extend(resource_tags_to_copy)
return user_tags
```
|
Diego José Erroz (born 21 September 1978) is a former Argentine association football midfielder and current coach.
Erroz was born in Berrotarán, Argentina, and currently works as coaching staff for Atlético Tucumán of the Primera B Nacional in Argentina.
Teams
Rosario Central 1996–2002
Tiro Federal 2003–2004
Almagro 2004–2005
Tiro Federal 2005–2007
Atlético Tucumán 2007–2011
Talleres 2011–2012
Tiro Federal 2012–2013
Titles
Atlético Tucumán 2007-2008 (Torneo Argentino A)
Atlético Tucumán 2008-2009 (Primera B Nacional)
References
1978 births
Living people
Argentine men's footballers
Argentine expatriate men's footballers
Rosario Central footballers
Atlético Tucumán footballers
Tiro Federal footballers
Club Almagro players
Men's association football midfielders
Atlético Tucumán managers
|
```c
/*********************************************************************/
/* */
/* Optimized BLAS libraries */
/* By Kazushige Goto <kgoto@tacc.utexas.edu> */
/* */
/* UNIVERSITY EXPRESSLY DISCLAIMS ANY AND ALL WARRANTIES CONCERNING */
/* THIS SOFTWARE AND DOCUMENTATION, INCLUDING ANY WARRANTIES OF */
/* MERCHANTABILITY, FITNESS FOR ANY PARTICULAR PURPOSE, */
/* NON-INFRINGEMENT AND WARRANTIES OF PERFORMANCE, AND ANY WARRANTY */
/* THAT MIGHT OTHERWISE ARISE FROM COURSE OF DEALING OR USAGE OF */
/* TRADE. NO WARRANTY IS EITHER EXPRESS OR IMPLIED WITH RESPECT TO */
/* THE USE OF THE SOFTWARE OR DOCUMENTATION. */
/* Under no circumstances shall University be liable for incidental, */
/* special, indirect, direct or consequential damages or loss of */
/* profits, interruption of business, or related expenses which may */
/* arise from use of Software or Documentation, including but not */
/* limited to those resulting from defects in Software and/or */
/* Documentation, or loss or inaccuracy of data of any kind. */
/*********************************************************************/
#include <stdio.h>
#include "common.h"
#ifndef UNIT
#define INV(a) (ONE / (a))
#else
#define INV(a) (ONE)
#endif
int CNAME(BLASLONG m, BLASLONG n, FLOAT *a, BLASLONG lda, BLASLONG offset, FLOAT *b){
BLASLONG i, ii, j, jj;
FLOAT data01, data02, data03, data04, data05, data06, data07, data08;
FLOAT data09, data10, data11, data12, data13, data14, data15, data16;
FLOAT *a1, *a2, *a3, *a4;
jj = offset;
j = (n >> 2);
while (j > 0){
a1 = a + 0 * lda;
a2 = a + 1 * lda;
a3 = a + 2 * lda;
a4 = a + 3 * lda;
i = (m >> 2);
ii = 0;
while (i > 0) {
if (ii == jj) {
#ifndef UNIT
data01 = *(a1 + 0);
#endif
data02 = *(a1 + 1);
data03 = *(a1 + 2);
data04 = *(a1 + 3);
#ifndef UNIT
data06 = *(a2 + 1);
#endif
data07 = *(a2 + 2);
data08 = *(a2 + 3);
#ifndef UNIT
data11 = *(a3 + 2);
#endif
data12 = *(a3 + 3);
#ifndef UNIT
data16 = *(a4 + 3);
#endif
*(b + 0) = INV(data01);
*(b + 4) = data02;
*(b + 5) = INV(data06);
*(b + 8) = data03;
*(b + 9) = data07;
*(b + 10) = INV(data11);
*(b + 12) = data04;
*(b + 13) = data08;
*(b + 14) = data12;
*(b + 15) = INV(data16);
}
if (ii > jj) {
data01 = *(a1 + 0);
data02 = *(a1 + 1);
data03 = *(a1 + 2);
data04 = *(a1 + 3);
data05 = *(a2 + 0);
data06 = *(a2 + 1);
data07 = *(a2 + 2);
data08 = *(a2 + 3);
data09 = *(a3 + 0);
data10 = *(a3 + 1);
data11 = *(a3 + 2);
data12 = *(a3 + 3);
data13 = *(a4 + 0);
data14 = *(a4 + 1);
data15 = *(a4 + 2);
data16 = *(a4 + 3);
*(b + 0) = data01;
*(b + 1) = data05;
*(b + 2) = data09;
*(b + 3) = data13;
*(b + 4) = data02;
*(b + 5) = data06;
*(b + 6) = data10;
*(b + 7) = data14;
*(b + 8) = data03;
*(b + 9) = data07;
*(b + 10) = data11;
*(b + 11) = data15;
*(b + 12) = data04;
*(b + 13) = data08;
*(b + 14) = data12;
*(b + 15) = data16;
}
a1 += 4;
a2 += 4;
a3 += 4;
a4 += 4;
b += 16;
i --;
ii += 4;
}
if ((m & 2) != 0) {
if (ii== jj) {
#ifndef UNIT
data01 = *(a1 + 0);
#endif
data02 = *(a1 + 1);
#ifndef UNIT
data06 = *(a2 + 1);
#endif
*(b + 0) = INV(data01);
*(b + 4) = data02;
*(b + 5) = INV(data06);
}
if (ii > jj) {
data01 = *(a1 + 0);
data02 = *(a1 + 1);
data03 = *(a2 + 0);
data04 = *(a2 + 1);
data05 = *(a3 + 0);
data06 = *(a3 + 1);
data07 = *(a4 + 0);
data08 = *(a4 + 1);
*(b + 0) = data01;
*(b + 1) = data03;
*(b + 2) = data05;
*(b + 3) = data07;
*(b + 4) = data02;
*(b + 5) = data04;
*(b + 6) = data06;
*(b + 7) = data08;
}
a1 += 2;
a2 += 2;
a3 += 2;
a4 += 2;
b += 8;
ii += 2;
}
if ((m & 1) != 0) {
if (ii== jj) {
#ifndef UNIT
data01 = *(a1 + 0);
#endif
*(b + 0) = INV(data01);
}
if (ii > jj) {
data01 = *(a1 + 0);
data02 = *(a2 + 0);
data03 = *(a3 + 0);
data04 = *(a4 + 0);
*(b + 0) = data01;
*(b + 1) = data02;
*(b + 2) = data03;
*(b + 3) = data04;
}
b += 4;
}
a += 4 * lda;
jj += 4;
j --;
}
if (n & 2) {
a1 = a + 0 * lda;
a2 = a + 1 * lda;
i = (m >> 1);
ii = 0;
while (i > 0) {
if (ii == jj) {
#ifndef UNIT
data01 = *(a1 + 0);
#endif
data02 = *(a1 + 1);
#ifndef UNIT
data04 = *(a2 + 1);
#endif
*(b + 0) = INV(data01);
*(b + 2) = data02;
*(b + 3) = INV(data04);
}
if (ii > jj) {
data01 = *(a1 + 0);
data02 = *(a1 + 1);
data03 = *(a2 + 0);
data04 = *(a2 + 1);
*(b + 0) = data01;
*(b + 1) = data03;
*(b + 2) = data02;
*(b + 3) = data04;
}
a1 += 2;
a2 += 2;
b += 4;
i --;
ii += 2;
}
if ((m & 1) != 0) {
if (ii== jj) {
#ifndef UNIT
data01 = *(a1 + 0);
#endif
*(b + 0) = INV(data01);
}
if (ii > jj) {
data01 = *(a1 + 0);
data02 = *(a2 + 0);
*(b + 0) = data01;
*(b + 1) = data02;
}
b += 2;
}
a += 2 * lda;
jj += 2;
}
if (n & 1) {
a1 = a + 0 * lda;
i = m;
ii = 0;
while (i > 0) {
if (ii == jj) {
#ifndef UNIT
data01 = *(a1 + 0);
#endif
*(b + 0) = INV(data01);
}
if (ii > jj) {
data01 = *(a1 + 0);
*(b + 0) = data01;
}
a1+= 1;
b += 1;
i --;
ii += 1;
}
}
return 0;
}
```
|
Cartavio belongs to the district of Santiago de Cao, Ascope Province, in the department of La Libertad in Peru. Its coastal location is north of Lima, at a latitude of 7°53'S and longitude of 79°13W and an altitude of 16m above sea level.
Sugar cane grows in the area and Cartavio has been home to the Cartavio Sugar Company since 1891. Once the site of rum production for Ron Cartavio (now produced in Perú), currently the sugar mill produces not only sugar but also up to 15 million litres of ethanol per year, which could be used by petroleum companies to replace the lead in petrol and thereby reducing the emissions of air pollutants.
External links
http://www.fallingrain.com/world/PE/13/Cartavio.html
https://web.archive.org/web/20070309060743/http://www.micartavio.com/contenido/principal.html
https://web.archive.org/web/20070509140519/http://www.micartavio.com/conociendo/geografia.html
http://archive.nacla.org/Summaries/V10I3P1-1.html
http://www.unep.org/cpi/briefs/Brief23Feb05.doc
https://web.archive.org/web/20070308110747/http://www.roncartavio.com/english/index_musica.html
http://www.iebenjaminfranklin.com
Populated places in La Libertad Region
|
Patrignone is a village in Marche, central Italy, administratively a frazione of the comune of Montalto delle Marche, province of Ascoli Piceno. At the time of the 2001 census its population was 130.
Patrignone is about 2 km from Montalto and 33 km from Ascoli Piceno.
References
Frazioni of the Province of Ascoli Piceno
|
Élan Recordings is an independent record label specializing in classical music.
History
Élan Recordings was established in 1985 by pianist Santiago Rodriguez and his wife, Natalia Rodriguez. The catalogue features numerous Spanish/Latin recordings. It also features a number of historic re-releases. Santiago Rodriguez records exclusively for Élan.
Artists
Santiago Rodriguez, pianist
Carmen Balthrop, soprano
Elias Barreiro, guitar
Bibiano Borrato, guitar
Rudolfo Brito, pianist
Hsuan-Ya Chen, pianist
Mark Clinton and Nicole Narboni, duo pianists
Cuarteto Latinoamericano, string quartet
Evelyn Garvey, fortepiano
Jaemi Kim, pianist
André Laplante, pianist
Noel Lester, pianist
Raymond Lewenthal, pianist
Donald Manildi, pianist
Elmar Oliveira, violinist
Reubén Pelåez, pianist
Nathaniel Rosen, cellist
Thomas Schumaker, pianist
Sofia Philharmonic Orchestra
Earl Wild, pianist
References
Sources
Ashby. "Guide to Records: Santiago Rodriguez." American Record Guide, Jul/Aug 1994, Vol. 57 Issue n. 4, pg. 155.
Cornelius, Stephen. "Pianist Searches For The Unexpected In The Music". Toledo Blade, September 27, 1996, p. 28
Gerber, L. "A Conversation with Santiago Rodriguez." Fanfare, 1992, Vol. 15 Issue n. 3, pp. 107–11.
Manildi, Donald. "Guide to Records: Santiago Rodriguez." American Record Guide, Jan/Feb 1995, Vol. 58 Issue n.1, p157.
March, Ivan; Greenfield, Edward; Layton, Robert. The Penguin Guide to Recorded Classical Music 2010. Penguin, 2009
McLellan, Joseph. "The Little Record Company That Could". Washington Post, April 1, 1990.
McLellan, Joseph. "Some Big Names Fit Well on Small Labels". Washington Post, Nov. 6, 1994.
McLellan, Joseph. "Santiago Rodriguez, Playing with Élan". Washington Post, June 7, 1998.
Phillip, Scott. "Ginastera: Danzas Argentinas, Piano Sonata No. 1..." Fanfare, July 1, 2010.
External links
elanrecordings.com
santiagorodriguez.net
Classical music record labels
American record labels
Record labels established in 1985
1985 establishments in the United States
|
```c++
/*****************************************************************************
This program is free software; you can redistribute it and/or modify it under
This program is distributed in the hope that it will be useful, but WITHOUT
ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS
this program; if not, write to the Free Software Foundation, Inc.,
51 Franklin Street, Suite 500, Boston, MA 02110-1335 USA
*****************************************************************************/
/**************************************************//**
@file fts/fts0sql.cc
Full Text Search functionality.
Created 2007-03-27 Sunny Bains
*******************************************************/
#include "que0que.h"
#include "trx0roll.h"
#include "pars0pars.h"
#include "dict0dict.h"
#include "fts0types.h"
#include "fts0priv.h"
#ifndef UNIV_NONINL
#include "fts0types.ic"
#include "fts0vlc.ic"
#endif
/** SQL statements for creating the ancillary FTS tables. %s must be replaced
with the indexed table's id. */
/** Preamble to all SQL statements. */
static const char* fts_sql_begin=
"PROCEDURE P() IS\n";
/** Postamble to non-committing SQL statements. */
static const char* fts_sql_end=
"\n"
"END;\n";
/******************************************************************//**
Get the table id.
@return number of bytes written */
UNIV_INTERN
int
fts_get_table_id(
/*=============*/
const fts_table_t*
fts_table, /*!< in: FTS Auxiliary table */
char* table_id) /*!< out: table id, must be at least
FTS_AUX_MIN_TABLE_ID_LENGTH bytes
long */
{
int len;
bool hex_name = DICT_TF2_FLAG_IS_SET(fts_table->table,
DICT_TF2_FTS_AUX_HEX_NAME);
ut_a(fts_table->table != NULL);
switch (fts_table->type) {
case FTS_COMMON_TABLE:
len = fts_write_object_id(fts_table->table_id, table_id,
hex_name);
break;
case FTS_INDEX_TABLE:
len = fts_write_object_id(fts_table->table_id, table_id,
hex_name);
table_id[len] = '_';
++len;
table_id += len;
len += fts_write_object_id(fts_table->index_id, table_id,
hex_name);
break;
default:
ut_error;
}
ut_a(len >= 16);
ut_a(len < FTS_AUX_MIN_TABLE_ID_LENGTH);
return(len);
}
/******************************************************************//**
Construct the prefix name of an FTS table.
@return own: table name, must be freed with mem_free() */
UNIV_INTERN
char*
fts_get_table_name_prefix(
/*======================*/
const fts_table_t*
fts_table) /*!< in: Auxiliary table type */
{
int len;
const char* slash;
char* prefix_name;
int dbname_len = 0;
int prefix_name_len;
char table_id[FTS_AUX_MIN_TABLE_ID_LENGTH];
slash = static_cast<const char*>(
memchr(fts_table->parent, '/', strlen(fts_table->parent)));
if (slash) {
/* Print up to and including the separator. */
dbname_len = static_cast<int>(slash - fts_table->parent) + 1;
}
len = fts_get_table_id(fts_table, table_id);
prefix_name_len = dbname_len + 4 + len + 1;
prefix_name = static_cast<char*>(mem_alloc(prefix_name_len));
len = sprintf(prefix_name, "%.*sFTS_%s",
dbname_len, fts_table->parent, table_id);
ut_a(len > 0);
ut_a(len == prefix_name_len - 1);
return(prefix_name);
}
/******************************************************************//**
Construct the name of an ancillary FTS table.
@return own: table name, must be freed with mem_free() */
UNIV_INTERN
char*
fts_get_table_name(
/*===============*/
const fts_table_t* fts_table)
/*!< in: Auxiliary table type */
{
int len;
char* name;
int name_len;
char* prefix_name;
prefix_name = fts_get_table_name_prefix(fts_table);
name_len = static_cast<int>(
strlen(prefix_name) + 1 + strlen(fts_table->suffix) + 1);
name = static_cast<char*>(mem_alloc(name_len));
len = sprintf(name, "%s_%s", prefix_name, fts_table->suffix);
ut_a(len > 0);
ut_a(len == name_len - 1);
mem_free(prefix_name);
return(name);
}
/******************************************************************//**
Parse an SQL string. %s is replaced with the table's id.
@return query graph */
UNIV_INTERN
que_t*
fts_parse_sql(
/*==========*/
fts_table_t* fts_table, /*!< in: FTS auxiliarry table info */
pars_info_t* info, /*!< in: info struct, or NULL */
const char* sql) /*!< in: SQL string to evaluate */
{
char* str;
que_t* graph;
char* str_tmp;
ibool dict_locked;
if (fts_table != NULL) {
char* table_name;
table_name = fts_get_table_name(fts_table);
str_tmp = ut_strreplace(sql, "%s", table_name);
mem_free(table_name);
} else {
ulint sql_len = strlen(sql) + 1;
str_tmp = static_cast<char*>(mem_alloc(sql_len));
strcpy(str_tmp, sql);
}
str = ut_str3cat(fts_sql_begin, str_tmp, fts_sql_end);
mem_free(str_tmp);
dict_locked = (fts_table && fts_table->table->fts
&& (fts_table->table->fts->fts_status
& TABLE_DICT_LOCKED));
if (!dict_locked) {
ut_ad(!mutex_own(&(dict_sys->mutex)));
/* The InnoDB SQL parser is not re-entrant. */
mutex_enter(&dict_sys->mutex);
}
graph = pars_sql(info, str);
ut_a(graph);
if (!dict_locked) {
mutex_exit(&dict_sys->mutex);
}
mem_free(str);
return(graph);
}
/******************************************************************//**
Parse an SQL string. %s is replaced with the table's id.
@return query graph */
UNIV_INTERN
que_t*
fts_parse_sql_no_dict_lock(
/*=======================*/
fts_table_t* fts_table, /*!< in: FTS aux table info */
pars_info_t* info, /*!< in: info struct, or NULL */
const char* sql) /*!< in: SQL string to evaluate */
{
char* str;
que_t* graph;
char* str_tmp = NULL;
#ifdef UNIV_DEBUG
ut_ad(mutex_own(&dict_sys->mutex));
#endif
if (fts_table != NULL) {
char* table_name;
table_name = fts_get_table_name(fts_table);
str_tmp = ut_strreplace(sql, "%s", table_name);
mem_free(table_name);
}
if (str_tmp != NULL) {
str = ut_str3cat(fts_sql_begin, str_tmp, fts_sql_end);
mem_free(str_tmp);
} else {
str = ut_str3cat(fts_sql_begin, sql, fts_sql_end);
}
//fprintf(stderr, "%s\n", str);
graph = pars_sql(info, str);
ut_a(graph);
mem_free(str);
return(graph);
}
/******************************************************************//**
Evaluate an SQL query graph.
@return DB_SUCCESS or error code */
UNIV_INTERN
dberr_t
fts_eval_sql(
/*=========*/
trx_t* trx, /*!< in: transaction */
que_t* graph) /*!< in: Query graph to evaluate */
{
que_thr_t* thr;
graph->trx = trx;
graph->fork_type = QUE_FORK_MYSQL_INTERFACE;
ut_a(thr = que_fork_start_command(graph));
que_run_threads(thr);
return(trx->error_state);
}
/******************************************************************//**
Construct the column specification part of the SQL string for selecting the
indexed FTS columns for the given table. Adds the necessary bound
ids to the given 'info' and returns the SQL string. Examples:
One indexed column named "text":
"$sel0",
info/ids: sel0 -> "text"
Two indexed columns named "subject" and "content":
"$sel0, $sel1",
info/ids: sel0 -> "subject", sel1 -> "content",
@return heap-allocated WHERE string */
UNIV_INTERN
const char*
fts_get_select_columns_str(
/*=======================*/
dict_index_t* index, /*!< in: index */
pars_info_t* info, /*!< in/out: parser info */
mem_heap_t* heap) /*!< in: memory heap */
{
ulint i;
const char* str = "";
for (i = 0; i < index->n_user_defined_cols; i++) {
char* sel_str;
dict_field_t* field = dict_index_get_nth_field(index, i);
sel_str = mem_heap_printf(heap, "sel%lu", (ulong) i);
/* Set copy_name to TRUE since it's dynamic. */
pars_info_bind_id(info, TRUE, sel_str, field->name);
str = mem_heap_printf(
heap, "%s%s$%s", str, (*str) ? ", " : "", sel_str);
}
return(str);
}
/******************************************************************//**
Commit a transaction.
@return DB_SUCCESS or error code */
UNIV_INTERN
dberr_t
fts_sql_commit(
/*===========*/
trx_t* trx) /*!< in: transaction */
{
dberr_t error;
error = trx_commit_for_mysql(trx);
/* Commit should always succeed */
ut_a(error == DB_SUCCESS);
return(DB_SUCCESS);
}
/******************************************************************//**
Rollback a transaction.
@return DB_SUCCESS or error code */
UNIV_INTERN
dberr_t
fts_sql_rollback(
/*=============*/
trx_t* trx) /*!< in: transaction */
{
return(trx_rollback_to_savepoint(trx, NULL));
}
```
|
```yaml
---
apiVersion: argoproj.io/v1alpha1
kind: Application
metadata:
name: kube-prometheus
namespace: argocd
annotations:
recipients.argocd-notifications.argoproj.io: "slack:jenkins"
spec:
destination:
namespace: monitoring
server: path_to_url
project: monitoring
source:
directory:
jsonnet:
libs:
- vendored
recurse: true
path: examples/continuous-delivery/argocd/kube-prometheus
repoURL: git@github.com:prometheus-operator/kube-prometheus.git
targetRevision: HEAD
syncPolicy:
automated: {}
---
```
|
```go
// Code generated by private/model/cli/gen-api/main.go. DO NOT EDIT.
package pinpoint
import (
"github.com/aws/aws-sdk-go/aws"
"github.com/aws/aws-sdk-go/aws/awsutil"
"github.com/aws/aws-sdk-go/aws/request"
)
const opCreateApp = "CreateApp"
// CreateAppRequest generates a "aws/request.Request" representing the
// client's request for the CreateApp operation. The "output" return
// value will be populated with the request's response once the request complets
// successfuly.
//
// Use "Send" method on the returned Request to send the API call to the service.
// the "output" return value is not valid until after Send returns without error.
//
// See CreateApp for more information on using the CreateApp
// API call, and error handling.
//
// This method is useful when you want to inject custom logic or configuration
// into the SDK's request lifecycle. Such as custom headers, or retry logic.
//
//
// // Example sending a request using the CreateAppRequest method.
// req, resp := client.CreateAppRequest(params)
//
// err := req.Send()
// if err == nil { // resp is now filled
// fmt.Println(resp)
// }
//
// See also, path_to_url
func (c *Pinpoint) CreateAppRequest(input *CreateAppInput) (req *request.Request, output *CreateAppOutput) {
op := &request.Operation{
Name: opCreateApp,
HTTPMethod: "POST",
HTTPPath: "/v1/apps",
}
if input == nil {
input = &CreateAppInput{}
}
output = &CreateAppOutput{}
req = c.newRequest(op, input, output)
return
}
// CreateApp API operation for Amazon Pinpoint.
//
// Creates or updates an app.
//
// Returns awserr.Error for service API and SDK errors. Use runtime type assertions
// with awserr.Error's Code and Message methods to get detailed information about
// the error.
//
// See the AWS API reference guide for Amazon Pinpoint's
// API operation CreateApp for usage and error information.
//
// Returned Error Codes:
// * ErrCodeBadRequestException "BadRequestException"
//
// * ErrCodeInternalServerErrorException "InternalServerErrorException"
//
// * ErrCodeForbiddenException "ForbiddenException"
//
// * ErrCodeNotFoundException "NotFoundException"
//
// * ErrCodeMethodNotAllowedException "MethodNotAllowedException"
//
// * ErrCodeTooManyRequestsException "TooManyRequestsException"
//
// See also, path_to_url
func (c *Pinpoint) CreateApp(input *CreateAppInput) (*CreateAppOutput, error) {
req, out := c.CreateAppRequest(input)
return out, req.Send()
}
// CreateAppWithContext is the same as CreateApp with the addition of
// the ability to pass a context and additional request options.
//
// See CreateApp for details on how to use this API operation.
//
// The context must be non-nil and will be used for request cancellation. If
// the context is nil a panic will occur. In the future the SDK may create
// sub-contexts for http.Requests. See path_to_url
// for more information on using Contexts.
func (c *Pinpoint) CreateAppWithContext(ctx aws.Context, input *CreateAppInput, opts ...request.Option) (*CreateAppOutput, error) {
req, out := c.CreateAppRequest(input)
req.SetContext(ctx)
req.ApplyOptions(opts...)
return out, req.Send()
}
const opCreateCampaign = "CreateCampaign"
// CreateCampaignRequest generates a "aws/request.Request" representing the
// client's request for the CreateCampaign operation. The "output" return
// value will be populated with the request's response once the request complets
// successfuly.
//
// Use "Send" method on the returned Request to send the API call to the service.
// the "output" return value is not valid until after Send returns without error.
//
// See CreateCampaign for more information on using the CreateCampaign
// API call, and error handling.
//
// This method is useful when you want to inject custom logic or configuration
// into the SDK's request lifecycle. Such as custom headers, or retry logic.
//
//
// // Example sending a request using the CreateCampaignRequest method.
// req, resp := client.CreateCampaignRequest(params)
//
// err := req.Send()
// if err == nil { // resp is now filled
// fmt.Println(resp)
// }
//
// See also, path_to_url
func (c *Pinpoint) CreateCampaignRequest(input *CreateCampaignInput) (req *request.Request, output *CreateCampaignOutput) {
op := &request.Operation{
Name: opCreateCampaign,
HTTPMethod: "POST",
HTTPPath: "/v1/apps/{application-id}/campaigns",
}
if input == nil {
input = &CreateCampaignInput{}
}
output = &CreateCampaignOutput{}
req = c.newRequest(op, input, output)
return
}
// CreateCampaign API operation for Amazon Pinpoint.
//
// Creates or updates a campaign.
//
// Returns awserr.Error for service API and SDK errors. Use runtime type assertions
// with awserr.Error's Code and Message methods to get detailed information about
// the error.
//
// See the AWS API reference guide for Amazon Pinpoint's
// API operation CreateCampaign for usage and error information.
//
// Returned Error Codes:
// * ErrCodeBadRequestException "BadRequestException"
//
// * ErrCodeInternalServerErrorException "InternalServerErrorException"
//
// * ErrCodeForbiddenException "ForbiddenException"
//
// * ErrCodeNotFoundException "NotFoundException"
//
// * ErrCodeMethodNotAllowedException "MethodNotAllowedException"
//
// * ErrCodeTooManyRequestsException "TooManyRequestsException"
//
// See also, path_to_url
func (c *Pinpoint) CreateCampaign(input *CreateCampaignInput) (*CreateCampaignOutput, error) {
req, out := c.CreateCampaignRequest(input)
return out, req.Send()
}
// CreateCampaignWithContext is the same as CreateCampaign with the addition of
// the ability to pass a context and additional request options.
//
// See CreateCampaign for details on how to use this API operation.
//
// The context must be non-nil and will be used for request cancellation. If
// the context is nil a panic will occur. In the future the SDK may create
// sub-contexts for http.Requests. See path_to_url
// for more information on using Contexts.
func (c *Pinpoint) CreateCampaignWithContext(ctx aws.Context, input *CreateCampaignInput, opts ...request.Option) (*CreateCampaignOutput, error) {
req, out := c.CreateCampaignRequest(input)
req.SetContext(ctx)
req.ApplyOptions(opts...)
return out, req.Send()
}
const opCreateImportJob = "CreateImportJob"
// CreateImportJobRequest generates a "aws/request.Request" representing the
// client's request for the CreateImportJob operation. The "output" return
// value will be populated with the request's response once the request complets
// successfuly.
//
// Use "Send" method on the returned Request to send the API call to the service.
// the "output" return value is not valid until after Send returns without error.
//
// See CreateImportJob for more information on using the CreateImportJob
// API call, and error handling.
//
// This method is useful when you want to inject custom logic or configuration
// into the SDK's request lifecycle. Such as custom headers, or retry logic.
//
//
// // Example sending a request using the CreateImportJobRequest method.
// req, resp := client.CreateImportJobRequest(params)
//
// err := req.Send()
// if err == nil { // resp is now filled
// fmt.Println(resp)
// }
//
// See also, path_to_url
func (c *Pinpoint) CreateImportJobRequest(input *CreateImportJobInput) (req *request.Request, output *CreateImportJobOutput) {
op := &request.Operation{
Name: opCreateImportJob,
HTTPMethod: "POST",
HTTPPath: "/v1/apps/{application-id}/jobs/import",
}
if input == nil {
input = &CreateImportJobInput{}
}
output = &CreateImportJobOutput{}
req = c.newRequest(op, input, output)
return
}
// CreateImportJob API operation for Amazon Pinpoint.
//
// Creates or updates an import job.
//
// Returns awserr.Error for service API and SDK errors. Use runtime type assertions
// with awserr.Error's Code and Message methods to get detailed information about
// the error.
//
// See the AWS API reference guide for Amazon Pinpoint's
// API operation CreateImportJob for usage and error information.
//
// Returned Error Codes:
// * ErrCodeBadRequestException "BadRequestException"
//
// * ErrCodeInternalServerErrorException "InternalServerErrorException"
//
// * ErrCodeForbiddenException "ForbiddenException"
//
// * ErrCodeNotFoundException "NotFoundException"
//
// * ErrCodeMethodNotAllowedException "MethodNotAllowedException"
//
// * ErrCodeTooManyRequestsException "TooManyRequestsException"
//
// See also, path_to_url
func (c *Pinpoint) CreateImportJob(input *CreateImportJobInput) (*CreateImportJobOutput, error) {
req, out := c.CreateImportJobRequest(input)
return out, req.Send()
}
// CreateImportJobWithContext is the same as CreateImportJob with the addition of
// the ability to pass a context and additional request options.
//
// See CreateImportJob for details on how to use this API operation.
//
// The context must be non-nil and will be used for request cancellation. If
// the context is nil a panic will occur. In the future the SDK may create
// sub-contexts for http.Requests. See path_to_url
// for more information on using Contexts.
func (c *Pinpoint) CreateImportJobWithContext(ctx aws.Context, input *CreateImportJobInput, opts ...request.Option) (*CreateImportJobOutput, error) {
req, out := c.CreateImportJobRequest(input)
req.SetContext(ctx)
req.ApplyOptions(opts...)
return out, req.Send()
}
const opCreateSegment = "CreateSegment"
// CreateSegmentRequest generates a "aws/request.Request" representing the
// client's request for the CreateSegment operation. The "output" return
// value will be populated with the request's response once the request complets
// successfuly.
//
// Use "Send" method on the returned Request to send the API call to the service.
// the "output" return value is not valid until after Send returns without error.
//
// See CreateSegment for more information on using the CreateSegment
// API call, and error handling.
//
// This method is useful when you want to inject custom logic or configuration
// into the SDK's request lifecycle. Such as custom headers, or retry logic.
//
//
// // Example sending a request using the CreateSegmentRequest method.
// req, resp := client.CreateSegmentRequest(params)
//
// err := req.Send()
// if err == nil { // resp is now filled
// fmt.Println(resp)
// }
//
// See also, path_to_url
func (c *Pinpoint) CreateSegmentRequest(input *CreateSegmentInput) (req *request.Request, output *CreateSegmentOutput) {
op := &request.Operation{
Name: opCreateSegment,
HTTPMethod: "POST",
HTTPPath: "/v1/apps/{application-id}/segments",
}
if input == nil {
input = &CreateSegmentInput{}
}
output = &CreateSegmentOutput{}
req = c.newRequest(op, input, output)
return
}
// CreateSegment API operation for Amazon Pinpoint.
//
// Used to create or update a segment.
//
// Returns awserr.Error for service API and SDK errors. Use runtime type assertions
// with awserr.Error's Code and Message methods to get detailed information about
// the error.
//
// See the AWS API reference guide for Amazon Pinpoint's
// API operation CreateSegment for usage and error information.
//
// Returned Error Codes:
// * ErrCodeBadRequestException "BadRequestException"
//
// * ErrCodeInternalServerErrorException "InternalServerErrorException"
//
// * ErrCodeForbiddenException "ForbiddenException"
//
// * ErrCodeNotFoundException "NotFoundException"
//
// * ErrCodeMethodNotAllowedException "MethodNotAllowedException"
//
// * ErrCodeTooManyRequestsException "TooManyRequestsException"
//
// See also, path_to_url
func (c *Pinpoint) CreateSegment(input *CreateSegmentInput) (*CreateSegmentOutput, error) {
req, out := c.CreateSegmentRequest(input)
return out, req.Send()
}
// CreateSegmentWithContext is the same as CreateSegment with the addition of
// the ability to pass a context and additional request options.
//
// See CreateSegment for details on how to use this API operation.
//
// The context must be non-nil and will be used for request cancellation. If
// the context is nil a panic will occur. In the future the SDK may create
// sub-contexts for http.Requests. See path_to_url
// for more information on using Contexts.
func (c *Pinpoint) CreateSegmentWithContext(ctx aws.Context, input *CreateSegmentInput, opts ...request.Option) (*CreateSegmentOutput, error) {
req, out := c.CreateSegmentRequest(input)
req.SetContext(ctx)
req.ApplyOptions(opts...)
return out, req.Send()
}
const opDeleteAdmChannel = "DeleteAdmChannel"
// DeleteAdmChannelRequest generates a "aws/request.Request" representing the
// client's request for the DeleteAdmChannel operation. The "output" return
// value will be populated with the request's response once the request complets
// successfuly.
//
// Use "Send" method on the returned Request to send the API call to the service.
// the "output" return value is not valid until after Send returns without error.
//
// See DeleteAdmChannel for more information on using the DeleteAdmChannel
// API call, and error handling.
//
// This method is useful when you want to inject custom logic or configuration
// into the SDK's request lifecycle. Such as custom headers, or retry logic.
//
//
// // Example sending a request using the DeleteAdmChannelRequest method.
// req, resp := client.DeleteAdmChannelRequest(params)
//
// err := req.Send()
// if err == nil { // resp is now filled
// fmt.Println(resp)
// }
//
// See also, path_to_url
func (c *Pinpoint) DeleteAdmChannelRequest(input *DeleteAdmChannelInput) (req *request.Request, output *DeleteAdmChannelOutput) {
op := &request.Operation{
Name: opDeleteAdmChannel,
HTTPMethod: "DELETE",
HTTPPath: "/v1/apps/{application-id}/channels/adm",
}
if input == nil {
input = &DeleteAdmChannelInput{}
}
output = &DeleteAdmChannelOutput{}
req = c.newRequest(op, input, output)
return
}
// DeleteAdmChannel API operation for Amazon Pinpoint.
//
// Delete an ADM channel
//
// Returns awserr.Error for service API and SDK errors. Use runtime type assertions
// with awserr.Error's Code and Message methods to get detailed information about
// the error.
//
// See the AWS API reference guide for Amazon Pinpoint's
// API operation DeleteAdmChannel for usage and error information.
//
// Returned Error Codes:
// * ErrCodeBadRequestException "BadRequestException"
//
// * ErrCodeInternalServerErrorException "InternalServerErrorException"
//
// * ErrCodeForbiddenException "ForbiddenException"
//
// * ErrCodeNotFoundException "NotFoundException"
//
// * ErrCodeMethodNotAllowedException "MethodNotAllowedException"
//
// * ErrCodeTooManyRequestsException "TooManyRequestsException"
//
// See also, path_to_url
func (c *Pinpoint) DeleteAdmChannel(input *DeleteAdmChannelInput) (*DeleteAdmChannelOutput, error) {
req, out := c.DeleteAdmChannelRequest(input)
return out, req.Send()
}
// DeleteAdmChannelWithContext is the same as DeleteAdmChannel with the addition of
// the ability to pass a context and additional request options.
//
// See DeleteAdmChannel for details on how to use this API operation.
//
// The context must be non-nil and will be used for request cancellation. If
// the context is nil a panic will occur. In the future the SDK may create
// sub-contexts for http.Requests. See path_to_url
// for more information on using Contexts.
func (c *Pinpoint) DeleteAdmChannelWithContext(ctx aws.Context, input *DeleteAdmChannelInput, opts ...request.Option) (*DeleteAdmChannelOutput, error) {
req, out := c.DeleteAdmChannelRequest(input)
req.SetContext(ctx)
req.ApplyOptions(opts...)
return out, req.Send()
}
const opDeleteApnsChannel = "DeleteApnsChannel"
// DeleteApnsChannelRequest generates a "aws/request.Request" representing the
// client's request for the DeleteApnsChannel operation. The "output" return
// value will be populated with the request's response once the request complets
// successfuly.
//
// Use "Send" method on the returned Request to send the API call to the service.
// the "output" return value is not valid until after Send returns without error.
//
// See DeleteApnsChannel for more information on using the DeleteApnsChannel
// API call, and error handling.
//
// This method is useful when you want to inject custom logic or configuration
// into the SDK's request lifecycle. Such as custom headers, or retry logic.
//
//
// // Example sending a request using the DeleteApnsChannelRequest method.
// req, resp := client.DeleteApnsChannelRequest(params)
//
// err := req.Send()
// if err == nil { // resp is now filled
// fmt.Println(resp)
// }
//
// See also, path_to_url
func (c *Pinpoint) DeleteApnsChannelRequest(input *DeleteApnsChannelInput) (req *request.Request, output *DeleteApnsChannelOutput) {
op := &request.Operation{
Name: opDeleteApnsChannel,
HTTPMethod: "DELETE",
HTTPPath: "/v1/apps/{application-id}/channels/apns",
}
if input == nil {
input = &DeleteApnsChannelInput{}
}
output = &DeleteApnsChannelOutput{}
req = c.newRequest(op, input, output)
return
}
// DeleteApnsChannel API operation for Amazon Pinpoint.
//
// Deletes the APNs channel for an app.
//
// Returns awserr.Error for service API and SDK errors. Use runtime type assertions
// with awserr.Error's Code and Message methods to get detailed information about
// the error.
//
// See the AWS API reference guide for Amazon Pinpoint's
// API operation DeleteApnsChannel for usage and error information.
//
// Returned Error Codes:
// * ErrCodeBadRequestException "BadRequestException"
//
// * ErrCodeInternalServerErrorException "InternalServerErrorException"
//
// * ErrCodeForbiddenException "ForbiddenException"
//
// * ErrCodeNotFoundException "NotFoundException"
//
// * ErrCodeMethodNotAllowedException "MethodNotAllowedException"
//
// * ErrCodeTooManyRequestsException "TooManyRequestsException"
//
// See also, path_to_url
func (c *Pinpoint) DeleteApnsChannel(input *DeleteApnsChannelInput) (*DeleteApnsChannelOutput, error) {
req, out := c.DeleteApnsChannelRequest(input)
return out, req.Send()
}
// DeleteApnsChannelWithContext is the same as DeleteApnsChannel with the addition of
// the ability to pass a context and additional request options.
//
// See DeleteApnsChannel for details on how to use this API operation.
//
// The context must be non-nil and will be used for request cancellation. If
// the context is nil a panic will occur. In the future the SDK may create
// sub-contexts for http.Requests. See path_to_url
// for more information on using Contexts.
func (c *Pinpoint) DeleteApnsChannelWithContext(ctx aws.Context, input *DeleteApnsChannelInput, opts ...request.Option) (*DeleteApnsChannelOutput, error) {
req, out := c.DeleteApnsChannelRequest(input)
req.SetContext(ctx)
req.ApplyOptions(opts...)
return out, req.Send()
}
const opDeleteApnsSandboxChannel = "DeleteApnsSandboxChannel"
// DeleteApnsSandboxChannelRequest generates a "aws/request.Request" representing the
// client's request for the DeleteApnsSandboxChannel operation. The "output" return
// value will be populated with the request's response once the request complets
// successfuly.
//
// Use "Send" method on the returned Request to send the API call to the service.
// the "output" return value is not valid until after Send returns without error.
//
// See DeleteApnsSandboxChannel for more information on using the DeleteApnsSandboxChannel
// API call, and error handling.
//
// This method is useful when you want to inject custom logic or configuration
// into the SDK's request lifecycle. Such as custom headers, or retry logic.
//
//
// // Example sending a request using the DeleteApnsSandboxChannelRequest method.
// req, resp := client.DeleteApnsSandboxChannelRequest(params)
//
// err := req.Send()
// if err == nil { // resp is now filled
// fmt.Println(resp)
// }
//
// See also, path_to_url
func (c *Pinpoint) DeleteApnsSandboxChannelRequest(input *DeleteApnsSandboxChannelInput) (req *request.Request, output *DeleteApnsSandboxChannelOutput) {
op := &request.Operation{
Name: opDeleteApnsSandboxChannel,
HTTPMethod: "DELETE",
HTTPPath: "/v1/apps/{application-id}/channels/apns_sandbox",
}
if input == nil {
input = &DeleteApnsSandboxChannelInput{}
}
output = &DeleteApnsSandboxChannelOutput{}
req = c.newRequest(op, input, output)
return
}
// DeleteApnsSandboxChannel API operation for Amazon Pinpoint.
//
// Delete an APNS sandbox channel
//
// Returns awserr.Error for service API and SDK errors. Use runtime type assertions
// with awserr.Error's Code and Message methods to get detailed information about
// the error.
//
// See the AWS API reference guide for Amazon Pinpoint's
// API operation DeleteApnsSandboxChannel for usage and error information.
//
// Returned Error Codes:
// * ErrCodeBadRequestException "BadRequestException"
//
// * ErrCodeInternalServerErrorException "InternalServerErrorException"
//
// * ErrCodeForbiddenException "ForbiddenException"
//
// * ErrCodeNotFoundException "NotFoundException"
//
// * ErrCodeMethodNotAllowedException "MethodNotAllowedException"
//
// * ErrCodeTooManyRequestsException "TooManyRequestsException"
//
// See also, path_to_url
func (c *Pinpoint) DeleteApnsSandboxChannel(input *DeleteApnsSandboxChannelInput) (*DeleteApnsSandboxChannelOutput, error) {
req, out := c.DeleteApnsSandboxChannelRequest(input)
return out, req.Send()
}
// DeleteApnsSandboxChannelWithContext is the same as DeleteApnsSandboxChannel with the addition of
// the ability to pass a context and additional request options.
//
// See DeleteApnsSandboxChannel for details on how to use this API operation.
//
// The context must be non-nil and will be used for request cancellation. If
// the context is nil a panic will occur. In the future the SDK may create
// sub-contexts for http.Requests. See path_to_url
// for more information on using Contexts.
func (c *Pinpoint) DeleteApnsSandboxChannelWithContext(ctx aws.Context, input *DeleteApnsSandboxChannelInput, opts ...request.Option) (*DeleteApnsSandboxChannelOutput, error) {
req, out := c.DeleteApnsSandboxChannelRequest(input)
req.SetContext(ctx)
req.ApplyOptions(opts...)
return out, req.Send()
}
const opDeleteApnsVoipChannel = "DeleteApnsVoipChannel"
// DeleteApnsVoipChannelRequest generates a "aws/request.Request" representing the
// client's request for the DeleteApnsVoipChannel operation. The "output" return
// value will be populated with the request's response once the request complets
// successfuly.
//
// Use "Send" method on the returned Request to send the API call to the service.
// the "output" return value is not valid until after Send returns without error.
//
// See DeleteApnsVoipChannel for more information on using the DeleteApnsVoipChannel
// API call, and error handling.
//
// This method is useful when you want to inject custom logic or configuration
// into the SDK's request lifecycle. Such as custom headers, or retry logic.
//
//
// // Example sending a request using the DeleteApnsVoipChannelRequest method.
// req, resp := client.DeleteApnsVoipChannelRequest(params)
//
// err := req.Send()
// if err == nil { // resp is now filled
// fmt.Println(resp)
// }
//
// See also, path_to_url
func (c *Pinpoint) DeleteApnsVoipChannelRequest(input *DeleteApnsVoipChannelInput) (req *request.Request, output *DeleteApnsVoipChannelOutput) {
op := &request.Operation{
Name: opDeleteApnsVoipChannel,
HTTPMethod: "DELETE",
HTTPPath: "/v1/apps/{application-id}/channels/apns_voip",
}
if input == nil {
input = &DeleteApnsVoipChannelInput{}
}
output = &DeleteApnsVoipChannelOutput{}
req = c.newRequest(op, input, output)
return
}
// DeleteApnsVoipChannel API operation for Amazon Pinpoint.
//
// Delete an APNS VOIP channel
//
// Returns awserr.Error for service API and SDK errors. Use runtime type assertions
// with awserr.Error's Code and Message methods to get detailed information about
// the error.
//
// See the AWS API reference guide for Amazon Pinpoint's
// API operation DeleteApnsVoipChannel for usage and error information.
//
// Returned Error Codes:
// * ErrCodeBadRequestException "BadRequestException"
//
// * ErrCodeInternalServerErrorException "InternalServerErrorException"
//
// * ErrCodeForbiddenException "ForbiddenException"
//
// * ErrCodeNotFoundException "NotFoundException"
//
// * ErrCodeMethodNotAllowedException "MethodNotAllowedException"
//
// * ErrCodeTooManyRequestsException "TooManyRequestsException"
//
// See also, path_to_url
func (c *Pinpoint) DeleteApnsVoipChannel(input *DeleteApnsVoipChannelInput) (*DeleteApnsVoipChannelOutput, error) {
req, out := c.DeleteApnsVoipChannelRequest(input)
return out, req.Send()
}
// DeleteApnsVoipChannelWithContext is the same as DeleteApnsVoipChannel with the addition of
// the ability to pass a context and additional request options.
//
// See DeleteApnsVoipChannel for details on how to use this API operation.
//
// The context must be non-nil and will be used for request cancellation. If
// the context is nil a panic will occur. In the future the SDK may create
// sub-contexts for http.Requests. See path_to_url
// for more information on using Contexts.
func (c *Pinpoint) DeleteApnsVoipChannelWithContext(ctx aws.Context, input *DeleteApnsVoipChannelInput, opts ...request.Option) (*DeleteApnsVoipChannelOutput, error) {
req, out := c.DeleteApnsVoipChannelRequest(input)
req.SetContext(ctx)
req.ApplyOptions(opts...)
return out, req.Send()
}
const opDeleteApnsVoipSandboxChannel = "DeleteApnsVoipSandboxChannel"
// DeleteApnsVoipSandboxChannelRequest generates a "aws/request.Request" representing the
// client's request for the DeleteApnsVoipSandboxChannel operation. The "output" return
// value will be populated with the request's response once the request complets
// successfuly.
//
// Use "Send" method on the returned Request to send the API call to the service.
// the "output" return value is not valid until after Send returns without error.
//
// See DeleteApnsVoipSandboxChannel for more information on using the DeleteApnsVoipSandboxChannel
// API call, and error handling.
//
// This method is useful when you want to inject custom logic or configuration
// into the SDK's request lifecycle. Such as custom headers, or retry logic.
//
//
// // Example sending a request using the DeleteApnsVoipSandboxChannelRequest method.
// req, resp := client.DeleteApnsVoipSandboxChannelRequest(params)
//
// err := req.Send()
// if err == nil { // resp is now filled
// fmt.Println(resp)
// }
//
// See also, path_to_url
func (c *Pinpoint) DeleteApnsVoipSandboxChannelRequest(input *DeleteApnsVoipSandboxChannelInput) (req *request.Request, output *DeleteApnsVoipSandboxChannelOutput) {
op := &request.Operation{
Name: opDeleteApnsVoipSandboxChannel,
HTTPMethod: "DELETE",
HTTPPath: "/v1/apps/{application-id}/channels/apns_voip_sandbox",
}
if input == nil {
input = &DeleteApnsVoipSandboxChannelInput{}
}
output = &DeleteApnsVoipSandboxChannelOutput{}
req = c.newRequest(op, input, output)
return
}
// DeleteApnsVoipSandboxChannel API operation for Amazon Pinpoint.
//
// Delete an APNS VOIP sandbox channel
//
// Returns awserr.Error for service API and SDK errors. Use runtime type assertions
// with awserr.Error's Code and Message methods to get detailed information about
// the error.
//
// See the AWS API reference guide for Amazon Pinpoint's
// API operation DeleteApnsVoipSandboxChannel for usage and error information.
//
// Returned Error Codes:
// * ErrCodeBadRequestException "BadRequestException"
//
// * ErrCodeInternalServerErrorException "InternalServerErrorException"
//
// * ErrCodeForbiddenException "ForbiddenException"
//
// * ErrCodeNotFoundException "NotFoundException"
//
// * ErrCodeMethodNotAllowedException "MethodNotAllowedException"
//
// * ErrCodeTooManyRequestsException "TooManyRequestsException"
//
// See also, path_to_url
func (c *Pinpoint) DeleteApnsVoipSandboxChannel(input *DeleteApnsVoipSandboxChannelInput) (*DeleteApnsVoipSandboxChannelOutput, error) {
req, out := c.DeleteApnsVoipSandboxChannelRequest(input)
return out, req.Send()
}
// DeleteApnsVoipSandboxChannelWithContext is the same as DeleteApnsVoipSandboxChannel with the addition of
// the ability to pass a context and additional request options.
//
// See DeleteApnsVoipSandboxChannel for details on how to use this API operation.
//
// The context must be non-nil and will be used for request cancellation. If
// the context is nil a panic will occur. In the future the SDK may create
// sub-contexts for http.Requests. See path_to_url
// for more information on using Contexts.
func (c *Pinpoint) DeleteApnsVoipSandboxChannelWithContext(ctx aws.Context, input *DeleteApnsVoipSandboxChannelInput, opts ...request.Option) (*DeleteApnsVoipSandboxChannelOutput, error) {
req, out := c.DeleteApnsVoipSandboxChannelRequest(input)
req.SetContext(ctx)
req.ApplyOptions(opts...)
return out, req.Send()
}
const opDeleteApp = "DeleteApp"
// DeleteAppRequest generates a "aws/request.Request" representing the
// client's request for the DeleteApp operation. The "output" return
// value will be populated with the request's response once the request complets
// successfuly.
//
// Use "Send" method on the returned Request to send the API call to the service.
// the "output" return value is not valid until after Send returns without error.
//
// See DeleteApp for more information on using the DeleteApp
// API call, and error handling.
//
// This method is useful when you want to inject custom logic or configuration
// into the SDK's request lifecycle. Such as custom headers, or retry logic.
//
//
// // Example sending a request using the DeleteAppRequest method.
// req, resp := client.DeleteAppRequest(params)
//
// err := req.Send()
// if err == nil { // resp is now filled
// fmt.Println(resp)
// }
//
// See also, path_to_url
func (c *Pinpoint) DeleteAppRequest(input *DeleteAppInput) (req *request.Request, output *DeleteAppOutput) {
op := &request.Operation{
Name: opDeleteApp,
HTTPMethod: "DELETE",
HTTPPath: "/v1/apps/{application-id}",
}
if input == nil {
input = &DeleteAppInput{}
}
output = &DeleteAppOutput{}
req = c.newRequest(op, input, output)
return
}
// DeleteApp API operation for Amazon Pinpoint.
//
// Deletes an app.
//
// Returns awserr.Error for service API and SDK errors. Use runtime type assertions
// with awserr.Error's Code and Message methods to get detailed information about
// the error.
//
// See the AWS API reference guide for Amazon Pinpoint's
// API operation DeleteApp for usage and error information.
//
// Returned Error Codes:
// * ErrCodeBadRequestException "BadRequestException"
//
// * ErrCodeInternalServerErrorException "InternalServerErrorException"
//
// * ErrCodeForbiddenException "ForbiddenException"
//
// * ErrCodeNotFoundException "NotFoundException"
//
// * ErrCodeMethodNotAllowedException "MethodNotAllowedException"
//
// * ErrCodeTooManyRequestsException "TooManyRequestsException"
//
// See also, path_to_url
func (c *Pinpoint) DeleteApp(input *DeleteAppInput) (*DeleteAppOutput, error) {
req, out := c.DeleteAppRequest(input)
return out, req.Send()
}
// DeleteAppWithContext is the same as DeleteApp with the addition of
// the ability to pass a context and additional request options.
//
// See DeleteApp for details on how to use this API operation.
//
// The context must be non-nil and will be used for request cancellation. If
// the context is nil a panic will occur. In the future the SDK may create
// sub-contexts for http.Requests. See path_to_url
// for more information on using Contexts.
func (c *Pinpoint) DeleteAppWithContext(ctx aws.Context, input *DeleteAppInput, opts ...request.Option) (*DeleteAppOutput, error) {
req, out := c.DeleteAppRequest(input)
req.SetContext(ctx)
req.ApplyOptions(opts...)
return out, req.Send()
}
const opDeleteBaiduChannel = "DeleteBaiduChannel"
// DeleteBaiduChannelRequest generates a "aws/request.Request" representing the
// client's request for the DeleteBaiduChannel operation. The "output" return
// value will be populated with the request's response once the request complets
// successfuly.
//
// Use "Send" method on the returned Request to send the API call to the service.
// the "output" return value is not valid until after Send returns without error.
//
// See DeleteBaiduChannel for more information on using the DeleteBaiduChannel
// API call, and error handling.
//
// This method is useful when you want to inject custom logic or configuration
// into the SDK's request lifecycle. Such as custom headers, or retry logic.
//
//
// // Example sending a request using the DeleteBaiduChannelRequest method.
// req, resp := client.DeleteBaiduChannelRequest(params)
//
// err := req.Send()
// if err == nil { // resp is now filled
// fmt.Println(resp)
// }
//
// See also, path_to_url
func (c *Pinpoint) DeleteBaiduChannelRequest(input *DeleteBaiduChannelInput) (req *request.Request, output *DeleteBaiduChannelOutput) {
op := &request.Operation{
Name: opDeleteBaiduChannel,
HTTPMethod: "DELETE",
HTTPPath: "/v1/apps/{application-id}/channels/baidu",
}
if input == nil {
input = &DeleteBaiduChannelInput{}
}
output = &DeleteBaiduChannelOutput{}
req = c.newRequest(op, input, output)
return
}
// DeleteBaiduChannel API operation for Amazon Pinpoint.
//
// Delete a BAIDU GCM channel
//
// Returns awserr.Error for service API and SDK errors. Use runtime type assertions
// with awserr.Error's Code and Message methods to get detailed information about
// the error.
//
// See the AWS API reference guide for Amazon Pinpoint's
// API operation DeleteBaiduChannel for usage and error information.
//
// Returned Error Codes:
// * ErrCodeBadRequestException "BadRequestException"
//
// * ErrCodeInternalServerErrorException "InternalServerErrorException"
//
// * ErrCodeForbiddenException "ForbiddenException"
//
// * ErrCodeNotFoundException "NotFoundException"
//
// * ErrCodeMethodNotAllowedException "MethodNotAllowedException"
//
// * ErrCodeTooManyRequestsException "TooManyRequestsException"
//
// See also, path_to_url
func (c *Pinpoint) DeleteBaiduChannel(input *DeleteBaiduChannelInput) (*DeleteBaiduChannelOutput, error) {
req, out := c.DeleteBaiduChannelRequest(input)
return out, req.Send()
}
// DeleteBaiduChannelWithContext is the same as DeleteBaiduChannel with the addition of
// the ability to pass a context and additional request options.
//
// See DeleteBaiduChannel for details on how to use this API operation.
//
// The context must be non-nil and will be used for request cancellation. If
// the context is nil a panic will occur. In the future the SDK may create
// sub-contexts for http.Requests. See path_to_url
// for more information on using Contexts.
func (c *Pinpoint) DeleteBaiduChannelWithContext(ctx aws.Context, input *DeleteBaiduChannelInput, opts ...request.Option) (*DeleteBaiduChannelOutput, error) {
req, out := c.DeleteBaiduChannelRequest(input)
req.SetContext(ctx)
req.ApplyOptions(opts...)
return out, req.Send()
}
const opDeleteCampaign = "DeleteCampaign"
// DeleteCampaignRequest generates a "aws/request.Request" representing the
// client's request for the DeleteCampaign operation. The "output" return
// value will be populated with the request's response once the request complets
// successfuly.
//
// Use "Send" method on the returned Request to send the API call to the service.
// the "output" return value is not valid until after Send returns without error.
//
// See DeleteCampaign for more information on using the DeleteCampaign
// API call, and error handling.
//
// This method is useful when you want to inject custom logic or configuration
// into the SDK's request lifecycle. Such as custom headers, or retry logic.
//
//
// // Example sending a request using the DeleteCampaignRequest method.
// req, resp := client.DeleteCampaignRequest(params)
//
// err := req.Send()
// if err == nil { // resp is now filled
// fmt.Println(resp)
// }
//
// See also, path_to_url
func (c *Pinpoint) DeleteCampaignRequest(input *DeleteCampaignInput) (req *request.Request, output *DeleteCampaignOutput) {
op := &request.Operation{
Name: opDeleteCampaign,
HTTPMethod: "DELETE",
HTTPPath: "/v1/apps/{application-id}/campaigns/{campaign-id}",
}
if input == nil {
input = &DeleteCampaignInput{}
}
output = &DeleteCampaignOutput{}
req = c.newRequest(op, input, output)
return
}
// DeleteCampaign API operation for Amazon Pinpoint.
//
// Deletes a campaign.
//
// Returns awserr.Error for service API and SDK errors. Use runtime type assertions
// with awserr.Error's Code and Message methods to get detailed information about
// the error.
//
// See the AWS API reference guide for Amazon Pinpoint's
// API operation DeleteCampaign for usage and error information.
//
// Returned Error Codes:
// * ErrCodeBadRequestException "BadRequestException"
//
// * ErrCodeInternalServerErrorException "InternalServerErrorException"
//
// * ErrCodeForbiddenException "ForbiddenException"
//
// * ErrCodeNotFoundException "NotFoundException"
//
// * ErrCodeMethodNotAllowedException "MethodNotAllowedException"
//
// * ErrCodeTooManyRequestsException "TooManyRequestsException"
//
// See also, path_to_url
func (c *Pinpoint) DeleteCampaign(input *DeleteCampaignInput) (*DeleteCampaignOutput, error) {
req, out := c.DeleteCampaignRequest(input)
return out, req.Send()
}
// DeleteCampaignWithContext is the same as DeleteCampaign with the addition of
// the ability to pass a context and additional request options.
//
// See DeleteCampaign for details on how to use this API operation.
//
// The context must be non-nil and will be used for request cancellation. If
// the context is nil a panic will occur. In the future the SDK may create
// sub-contexts for http.Requests. See path_to_url
// for more information on using Contexts.
func (c *Pinpoint) DeleteCampaignWithContext(ctx aws.Context, input *DeleteCampaignInput, opts ...request.Option) (*DeleteCampaignOutput, error) {
req, out := c.DeleteCampaignRequest(input)
req.SetContext(ctx)
req.ApplyOptions(opts...)
return out, req.Send()
}
const opDeleteEmailChannel = "DeleteEmailChannel"
// DeleteEmailChannelRequest generates a "aws/request.Request" representing the
// client's request for the DeleteEmailChannel operation. The "output" return
// value will be populated with the request's response once the request complets
// successfuly.
//
// Use "Send" method on the returned Request to send the API call to the service.
// the "output" return value is not valid until after Send returns without error.
//
// See DeleteEmailChannel for more information on using the DeleteEmailChannel
// API call, and error handling.
//
// This method is useful when you want to inject custom logic or configuration
// into the SDK's request lifecycle. Such as custom headers, or retry logic.
//
//
// // Example sending a request using the DeleteEmailChannelRequest method.
// req, resp := client.DeleteEmailChannelRequest(params)
//
// err := req.Send()
// if err == nil { // resp is now filled
// fmt.Println(resp)
// }
//
// See also, path_to_url
func (c *Pinpoint) DeleteEmailChannelRequest(input *DeleteEmailChannelInput) (req *request.Request, output *DeleteEmailChannelOutput) {
op := &request.Operation{
Name: opDeleteEmailChannel,
HTTPMethod: "DELETE",
HTTPPath: "/v1/apps/{application-id}/channels/email",
}
if input == nil {
input = &DeleteEmailChannelInput{}
}
output = &DeleteEmailChannelOutput{}
req = c.newRequest(op, input, output)
return
}
// DeleteEmailChannel API operation for Amazon Pinpoint.
//
// Delete an email channel
//
// Returns awserr.Error for service API and SDK errors. Use runtime type assertions
// with awserr.Error's Code and Message methods to get detailed information about
// the error.
//
// See the AWS API reference guide for Amazon Pinpoint's
// API operation DeleteEmailChannel for usage and error information.
//
// Returned Error Codes:
// * ErrCodeBadRequestException "BadRequestException"
//
// * ErrCodeInternalServerErrorException "InternalServerErrorException"
//
// * ErrCodeForbiddenException "ForbiddenException"
//
// * ErrCodeNotFoundException "NotFoundException"
//
// * ErrCodeMethodNotAllowedException "MethodNotAllowedException"
//
// * ErrCodeTooManyRequestsException "TooManyRequestsException"
//
// See also, path_to_url
func (c *Pinpoint) DeleteEmailChannel(input *DeleteEmailChannelInput) (*DeleteEmailChannelOutput, error) {
req, out := c.DeleteEmailChannelRequest(input)
return out, req.Send()
}
// DeleteEmailChannelWithContext is the same as DeleteEmailChannel with the addition of
// the ability to pass a context and additional request options.
//
// See DeleteEmailChannel for details on how to use this API operation.
//
// The context must be non-nil and will be used for request cancellation. If
// the context is nil a panic will occur. In the future the SDK may create
// sub-contexts for http.Requests. See path_to_url
// for more information on using Contexts.
func (c *Pinpoint) DeleteEmailChannelWithContext(ctx aws.Context, input *DeleteEmailChannelInput, opts ...request.Option) (*DeleteEmailChannelOutput, error) {
req, out := c.DeleteEmailChannelRequest(input)
req.SetContext(ctx)
req.ApplyOptions(opts...)
return out, req.Send()
}
const opDeleteEventStream = "DeleteEventStream"
// DeleteEventStreamRequest generates a "aws/request.Request" representing the
// client's request for the DeleteEventStream operation. The "output" return
// value will be populated with the request's response once the request complets
// successfuly.
//
// Use "Send" method on the returned Request to send the API call to the service.
// the "output" return value is not valid until after Send returns without error.
//
// See DeleteEventStream for more information on using the DeleteEventStream
// API call, and error handling.
//
// This method is useful when you want to inject custom logic or configuration
// into the SDK's request lifecycle. Such as custom headers, or retry logic.
//
//
// // Example sending a request using the DeleteEventStreamRequest method.
// req, resp := client.DeleteEventStreamRequest(params)
//
// err := req.Send()
// if err == nil { // resp is now filled
// fmt.Println(resp)
// }
//
// See also, path_to_url
func (c *Pinpoint) DeleteEventStreamRequest(input *DeleteEventStreamInput) (req *request.Request, output *DeleteEventStreamOutput) {
op := &request.Operation{
Name: opDeleteEventStream,
HTTPMethod: "DELETE",
HTTPPath: "/v1/apps/{application-id}/eventstream",
}
if input == nil {
input = &DeleteEventStreamInput{}
}
output = &DeleteEventStreamOutput{}
req = c.newRequest(op, input, output)
return
}
// DeleteEventStream API operation for Amazon Pinpoint.
//
// Deletes the event stream for an app.
//
// Returns awserr.Error for service API and SDK errors. Use runtime type assertions
// with awserr.Error's Code and Message methods to get detailed information about
// the error.
//
// See the AWS API reference guide for Amazon Pinpoint's
// API operation DeleteEventStream for usage and error information.
//
// Returned Error Codes:
// * ErrCodeBadRequestException "BadRequestException"
//
// * ErrCodeInternalServerErrorException "InternalServerErrorException"
//
// * ErrCodeForbiddenException "ForbiddenException"
//
// * ErrCodeNotFoundException "NotFoundException"
//
// * ErrCodeMethodNotAllowedException "MethodNotAllowedException"
//
// * ErrCodeTooManyRequestsException "TooManyRequestsException"
//
// See also, path_to_url
func (c *Pinpoint) DeleteEventStream(input *DeleteEventStreamInput) (*DeleteEventStreamOutput, error) {
req, out := c.DeleteEventStreamRequest(input)
return out, req.Send()
}
// DeleteEventStreamWithContext is the same as DeleteEventStream with the addition of
// the ability to pass a context and additional request options.
//
// See DeleteEventStream for details on how to use this API operation.
//
// The context must be non-nil and will be used for request cancellation. If
// the context is nil a panic will occur. In the future the SDK may create
// sub-contexts for http.Requests. See path_to_url
// for more information on using Contexts.
func (c *Pinpoint) DeleteEventStreamWithContext(ctx aws.Context, input *DeleteEventStreamInput, opts ...request.Option) (*DeleteEventStreamOutput, error) {
req, out := c.DeleteEventStreamRequest(input)
req.SetContext(ctx)
req.ApplyOptions(opts...)
return out, req.Send()
}
const opDeleteGcmChannel = "DeleteGcmChannel"
// DeleteGcmChannelRequest generates a "aws/request.Request" representing the
// client's request for the DeleteGcmChannel operation. The "output" return
// value will be populated with the request's response once the request complets
// successfuly.
//
// Use "Send" method on the returned Request to send the API call to the service.
// the "output" return value is not valid until after Send returns without error.
//
// See DeleteGcmChannel for more information on using the DeleteGcmChannel
// API call, and error handling.
//
// This method is useful when you want to inject custom logic or configuration
// into the SDK's request lifecycle. Such as custom headers, or retry logic.
//
//
// // Example sending a request using the DeleteGcmChannelRequest method.
// req, resp := client.DeleteGcmChannelRequest(params)
//
// err := req.Send()
// if err == nil { // resp is now filled
// fmt.Println(resp)
// }
//
// See also, path_to_url
func (c *Pinpoint) DeleteGcmChannelRequest(input *DeleteGcmChannelInput) (req *request.Request, output *DeleteGcmChannelOutput) {
op := &request.Operation{
Name: opDeleteGcmChannel,
HTTPMethod: "DELETE",
HTTPPath: "/v1/apps/{application-id}/channels/gcm",
}
if input == nil {
input = &DeleteGcmChannelInput{}
}
output = &DeleteGcmChannelOutput{}
req = c.newRequest(op, input, output)
return
}
// DeleteGcmChannel API operation for Amazon Pinpoint.
//
// Deletes the GCM channel for an app.
//
// Returns awserr.Error for service API and SDK errors. Use runtime type assertions
// with awserr.Error's Code and Message methods to get detailed information about
// the error.
//
// See the AWS API reference guide for Amazon Pinpoint's
// API operation DeleteGcmChannel for usage and error information.
//
// Returned Error Codes:
// * ErrCodeBadRequestException "BadRequestException"
//
// * ErrCodeInternalServerErrorException "InternalServerErrorException"
//
// * ErrCodeForbiddenException "ForbiddenException"
//
// * ErrCodeNotFoundException "NotFoundException"
//
// * ErrCodeMethodNotAllowedException "MethodNotAllowedException"
//
// * ErrCodeTooManyRequestsException "TooManyRequestsException"
//
// See also, path_to_url
func (c *Pinpoint) DeleteGcmChannel(input *DeleteGcmChannelInput) (*DeleteGcmChannelOutput, error) {
req, out := c.DeleteGcmChannelRequest(input)
return out, req.Send()
}
// DeleteGcmChannelWithContext is the same as DeleteGcmChannel with the addition of
// the ability to pass a context and additional request options.
//
// See DeleteGcmChannel for details on how to use this API operation.
//
// The context must be non-nil and will be used for request cancellation. If
// the context is nil a panic will occur. In the future the SDK may create
// sub-contexts for http.Requests. See path_to_url
// for more information on using Contexts.
func (c *Pinpoint) DeleteGcmChannelWithContext(ctx aws.Context, input *DeleteGcmChannelInput, opts ...request.Option) (*DeleteGcmChannelOutput, error) {
req, out := c.DeleteGcmChannelRequest(input)
req.SetContext(ctx)
req.ApplyOptions(opts...)
return out, req.Send()
}
const opDeleteSegment = "DeleteSegment"
// DeleteSegmentRequest generates a "aws/request.Request" representing the
// client's request for the DeleteSegment operation. The "output" return
// value will be populated with the request's response once the request complets
// successfuly.
//
// Use "Send" method on the returned Request to send the API call to the service.
// the "output" return value is not valid until after Send returns without error.
//
// See DeleteSegment for more information on using the DeleteSegment
// API call, and error handling.
//
// This method is useful when you want to inject custom logic or configuration
// into the SDK's request lifecycle. Such as custom headers, or retry logic.
//
//
// // Example sending a request using the DeleteSegmentRequest method.
// req, resp := client.DeleteSegmentRequest(params)
//
// err := req.Send()
// if err == nil { // resp is now filled
// fmt.Println(resp)
// }
//
// See also, path_to_url
func (c *Pinpoint) DeleteSegmentRequest(input *DeleteSegmentInput) (req *request.Request, output *DeleteSegmentOutput) {
op := &request.Operation{
Name: opDeleteSegment,
HTTPMethod: "DELETE",
HTTPPath: "/v1/apps/{application-id}/segments/{segment-id}",
}
if input == nil {
input = &DeleteSegmentInput{}
}
output = &DeleteSegmentOutput{}
req = c.newRequest(op, input, output)
return
}
// DeleteSegment API operation for Amazon Pinpoint.
//
// Deletes a segment.
//
// Returns awserr.Error for service API and SDK errors. Use runtime type assertions
// with awserr.Error's Code and Message methods to get detailed information about
// the error.
//
// See the AWS API reference guide for Amazon Pinpoint's
// API operation DeleteSegment for usage and error information.
//
// Returned Error Codes:
// * ErrCodeBadRequestException "BadRequestException"
//
// * ErrCodeInternalServerErrorException "InternalServerErrorException"
//
// * ErrCodeForbiddenException "ForbiddenException"
//
// * ErrCodeNotFoundException "NotFoundException"
//
// * ErrCodeMethodNotAllowedException "MethodNotAllowedException"
//
// * ErrCodeTooManyRequestsException "TooManyRequestsException"
//
// See also, path_to_url
func (c *Pinpoint) DeleteSegment(input *DeleteSegmentInput) (*DeleteSegmentOutput, error) {
req, out := c.DeleteSegmentRequest(input)
return out, req.Send()
}
// DeleteSegmentWithContext is the same as DeleteSegment with the addition of
// the ability to pass a context and additional request options.
//
// See DeleteSegment for details on how to use this API operation.
//
// The context must be non-nil and will be used for request cancellation. If
// the context is nil a panic will occur. In the future the SDK may create
// sub-contexts for http.Requests. See path_to_url
// for more information on using Contexts.
func (c *Pinpoint) DeleteSegmentWithContext(ctx aws.Context, input *DeleteSegmentInput, opts ...request.Option) (*DeleteSegmentOutput, error) {
req, out := c.DeleteSegmentRequest(input)
req.SetContext(ctx)
req.ApplyOptions(opts...)
return out, req.Send()
}
const opDeleteSmsChannel = "DeleteSmsChannel"
// DeleteSmsChannelRequest generates a "aws/request.Request" representing the
// client's request for the DeleteSmsChannel operation. The "output" return
// value will be populated with the request's response once the request complets
// successfuly.
//
// Use "Send" method on the returned Request to send the API call to the service.
// the "output" return value is not valid until after Send returns without error.
//
// See DeleteSmsChannel for more information on using the DeleteSmsChannel
// API call, and error handling.
//
// This method is useful when you want to inject custom logic or configuration
// into the SDK's request lifecycle. Such as custom headers, or retry logic.
//
//
// // Example sending a request using the DeleteSmsChannelRequest method.
// req, resp := client.DeleteSmsChannelRequest(params)
//
// err := req.Send()
// if err == nil { // resp is now filled
// fmt.Println(resp)
// }
//
// See also, path_to_url
func (c *Pinpoint) DeleteSmsChannelRequest(input *DeleteSmsChannelInput) (req *request.Request, output *DeleteSmsChannelOutput) {
op := &request.Operation{
Name: opDeleteSmsChannel,
HTTPMethod: "DELETE",
HTTPPath: "/v1/apps/{application-id}/channels/sms",
}
if input == nil {
input = &DeleteSmsChannelInput{}
}
output = &DeleteSmsChannelOutput{}
req = c.newRequest(op, input, output)
return
}
// DeleteSmsChannel API operation for Amazon Pinpoint.
//
// Delete an SMS channel
//
// Returns awserr.Error for service API and SDK errors. Use runtime type assertions
// with awserr.Error's Code and Message methods to get detailed information about
// the error.
//
// See the AWS API reference guide for Amazon Pinpoint's
// API operation DeleteSmsChannel for usage and error information.
//
// Returned Error Codes:
// * ErrCodeBadRequestException "BadRequestException"
//
// * ErrCodeInternalServerErrorException "InternalServerErrorException"
//
// * ErrCodeForbiddenException "ForbiddenException"
//
// * ErrCodeNotFoundException "NotFoundException"
//
// * ErrCodeMethodNotAllowedException "MethodNotAllowedException"
//
// * ErrCodeTooManyRequestsException "TooManyRequestsException"
//
// See also, path_to_url
func (c *Pinpoint) DeleteSmsChannel(input *DeleteSmsChannelInput) (*DeleteSmsChannelOutput, error) {
req, out := c.DeleteSmsChannelRequest(input)
return out, req.Send()
}
// DeleteSmsChannelWithContext is the same as DeleteSmsChannel with the addition of
// the ability to pass a context and additional request options.
//
// See DeleteSmsChannel for details on how to use this API operation.
//
// The context must be non-nil and will be used for request cancellation. If
// the context is nil a panic will occur. In the future the SDK may create
// sub-contexts for http.Requests. See path_to_url
// for more information on using Contexts.
func (c *Pinpoint) DeleteSmsChannelWithContext(ctx aws.Context, input *DeleteSmsChannelInput, opts ...request.Option) (*DeleteSmsChannelOutput, error) {
req, out := c.DeleteSmsChannelRequest(input)
req.SetContext(ctx)
req.ApplyOptions(opts...)
return out, req.Send()
}
const opGetAdmChannel = "GetAdmChannel"
// GetAdmChannelRequest generates a "aws/request.Request" representing the
// client's request for the GetAdmChannel operation. The "output" return
// value will be populated with the request's response once the request complets
// successfuly.
//
// Use "Send" method on the returned Request to send the API call to the service.
// the "output" return value is not valid until after Send returns without error.
//
// See GetAdmChannel for more information on using the GetAdmChannel
// API call, and error handling.
//
// This method is useful when you want to inject custom logic or configuration
// into the SDK's request lifecycle. Such as custom headers, or retry logic.
//
//
// // Example sending a request using the GetAdmChannelRequest method.
// req, resp := client.GetAdmChannelRequest(params)
//
// err := req.Send()
// if err == nil { // resp is now filled
// fmt.Println(resp)
// }
//
// See also, path_to_url
func (c *Pinpoint) GetAdmChannelRequest(input *GetAdmChannelInput) (req *request.Request, output *GetAdmChannelOutput) {
op := &request.Operation{
Name: opGetAdmChannel,
HTTPMethod: "GET",
HTTPPath: "/v1/apps/{application-id}/channels/adm",
}
if input == nil {
input = &GetAdmChannelInput{}
}
output = &GetAdmChannelOutput{}
req = c.newRequest(op, input, output)
return
}
// GetAdmChannel API operation for Amazon Pinpoint.
//
// Get an ADM channel
//
// Returns awserr.Error for service API and SDK errors. Use runtime type assertions
// with awserr.Error's Code and Message methods to get detailed information about
// the error.
//
// See the AWS API reference guide for Amazon Pinpoint's
// API operation GetAdmChannel for usage and error information.
//
// Returned Error Codes:
// * ErrCodeBadRequestException "BadRequestException"
//
// * ErrCodeInternalServerErrorException "InternalServerErrorException"
//
// * ErrCodeForbiddenException "ForbiddenException"
//
// * ErrCodeNotFoundException "NotFoundException"
//
// * ErrCodeMethodNotAllowedException "MethodNotAllowedException"
//
// * ErrCodeTooManyRequestsException "TooManyRequestsException"
//
// See also, path_to_url
func (c *Pinpoint) GetAdmChannel(input *GetAdmChannelInput) (*GetAdmChannelOutput, error) {
req, out := c.GetAdmChannelRequest(input)
return out, req.Send()
}
// GetAdmChannelWithContext is the same as GetAdmChannel with the addition of
// the ability to pass a context and additional request options.
//
// See GetAdmChannel for details on how to use this API operation.
//
// The context must be non-nil and will be used for request cancellation. If
// the context is nil a panic will occur. In the future the SDK may create
// sub-contexts for http.Requests. See path_to_url
// for more information on using Contexts.
func (c *Pinpoint) GetAdmChannelWithContext(ctx aws.Context, input *GetAdmChannelInput, opts ...request.Option) (*GetAdmChannelOutput, error) {
req, out := c.GetAdmChannelRequest(input)
req.SetContext(ctx)
req.ApplyOptions(opts...)
return out, req.Send()
}
const opGetApnsChannel = "GetApnsChannel"
// GetApnsChannelRequest generates a "aws/request.Request" representing the
// client's request for the GetApnsChannel operation. The "output" return
// value will be populated with the request's response once the request complets
// successfuly.
//
// Use "Send" method on the returned Request to send the API call to the service.
// the "output" return value is not valid until after Send returns without error.
//
// See GetApnsChannel for more information on using the GetApnsChannel
// API call, and error handling.
//
// This method is useful when you want to inject custom logic or configuration
// into the SDK's request lifecycle. Such as custom headers, or retry logic.
//
//
// // Example sending a request using the GetApnsChannelRequest method.
// req, resp := client.GetApnsChannelRequest(params)
//
// err := req.Send()
// if err == nil { // resp is now filled
// fmt.Println(resp)
// }
//
// See also, path_to_url
func (c *Pinpoint) GetApnsChannelRequest(input *GetApnsChannelInput) (req *request.Request, output *GetApnsChannelOutput) {
op := &request.Operation{
Name: opGetApnsChannel,
HTTPMethod: "GET",
HTTPPath: "/v1/apps/{application-id}/channels/apns",
}
if input == nil {
input = &GetApnsChannelInput{}
}
output = &GetApnsChannelOutput{}
req = c.newRequest(op, input, output)
return
}
// GetApnsChannel API operation for Amazon Pinpoint.
//
// Returns information about the APNs channel for an app.
//
// Returns awserr.Error for service API and SDK errors. Use runtime type assertions
// with awserr.Error's Code and Message methods to get detailed information about
// the error.
//
// See the AWS API reference guide for Amazon Pinpoint's
// API operation GetApnsChannel for usage and error information.
//
// Returned Error Codes:
// * ErrCodeBadRequestException "BadRequestException"
//
// * ErrCodeInternalServerErrorException "InternalServerErrorException"
//
// * ErrCodeForbiddenException "ForbiddenException"
//
// * ErrCodeNotFoundException "NotFoundException"
//
// * ErrCodeMethodNotAllowedException "MethodNotAllowedException"
//
// * ErrCodeTooManyRequestsException "TooManyRequestsException"
//
// See also, path_to_url
func (c *Pinpoint) GetApnsChannel(input *GetApnsChannelInput) (*GetApnsChannelOutput, error) {
req, out := c.GetApnsChannelRequest(input)
return out, req.Send()
}
// GetApnsChannelWithContext is the same as GetApnsChannel with the addition of
// the ability to pass a context and additional request options.
//
// See GetApnsChannel for details on how to use this API operation.
//
// The context must be non-nil and will be used for request cancellation. If
// the context is nil a panic will occur. In the future the SDK may create
// sub-contexts for http.Requests. See path_to_url
// for more information on using Contexts.
func (c *Pinpoint) GetApnsChannelWithContext(ctx aws.Context, input *GetApnsChannelInput, opts ...request.Option) (*GetApnsChannelOutput, error) {
req, out := c.GetApnsChannelRequest(input)
req.SetContext(ctx)
req.ApplyOptions(opts...)
return out, req.Send()
}
const opGetApnsSandboxChannel = "GetApnsSandboxChannel"
// GetApnsSandboxChannelRequest generates a "aws/request.Request" representing the
// client's request for the GetApnsSandboxChannel operation. The "output" return
// value will be populated with the request's response once the request complets
// successfuly.
//
// Use "Send" method on the returned Request to send the API call to the service.
// the "output" return value is not valid until after Send returns without error.
//
// See GetApnsSandboxChannel for more information on using the GetApnsSandboxChannel
// API call, and error handling.
//
// This method is useful when you want to inject custom logic or configuration
// into the SDK's request lifecycle. Such as custom headers, or retry logic.
//
//
// // Example sending a request using the GetApnsSandboxChannelRequest method.
// req, resp := client.GetApnsSandboxChannelRequest(params)
//
// err := req.Send()
// if err == nil { // resp is now filled
// fmt.Println(resp)
// }
//
// See also, path_to_url
func (c *Pinpoint) GetApnsSandboxChannelRequest(input *GetApnsSandboxChannelInput) (req *request.Request, output *GetApnsSandboxChannelOutput) {
op := &request.Operation{
Name: opGetApnsSandboxChannel,
HTTPMethod: "GET",
HTTPPath: "/v1/apps/{application-id}/channels/apns_sandbox",
}
if input == nil {
input = &GetApnsSandboxChannelInput{}
}
output = &GetApnsSandboxChannelOutput{}
req = c.newRequest(op, input, output)
return
}
// GetApnsSandboxChannel API operation for Amazon Pinpoint.
//
// Get an APNS sandbox channel
//
// Returns awserr.Error for service API and SDK errors. Use runtime type assertions
// with awserr.Error's Code and Message methods to get detailed information about
// the error.
//
// See the AWS API reference guide for Amazon Pinpoint's
// API operation GetApnsSandboxChannel for usage and error information.
//
// Returned Error Codes:
// * ErrCodeBadRequestException "BadRequestException"
//
// * ErrCodeInternalServerErrorException "InternalServerErrorException"
//
// * ErrCodeForbiddenException "ForbiddenException"
//
// * ErrCodeNotFoundException "NotFoundException"
//
// * ErrCodeMethodNotAllowedException "MethodNotAllowedException"
//
// * ErrCodeTooManyRequestsException "TooManyRequestsException"
//
// See also, path_to_url
func (c *Pinpoint) GetApnsSandboxChannel(input *GetApnsSandboxChannelInput) (*GetApnsSandboxChannelOutput, error) {
req, out := c.GetApnsSandboxChannelRequest(input)
return out, req.Send()
}
// GetApnsSandboxChannelWithContext is the same as GetApnsSandboxChannel with the addition of
// the ability to pass a context and additional request options.
//
// See GetApnsSandboxChannel for details on how to use this API operation.
//
// The context must be non-nil and will be used for request cancellation. If
// the context is nil a panic will occur. In the future the SDK may create
// sub-contexts for http.Requests. See path_to_url
// for more information on using Contexts.
func (c *Pinpoint) GetApnsSandboxChannelWithContext(ctx aws.Context, input *GetApnsSandboxChannelInput, opts ...request.Option) (*GetApnsSandboxChannelOutput, error) {
req, out := c.GetApnsSandboxChannelRequest(input)
req.SetContext(ctx)
req.ApplyOptions(opts...)
return out, req.Send()
}
const opGetApnsVoipChannel = "GetApnsVoipChannel"
// GetApnsVoipChannelRequest generates a "aws/request.Request" representing the
// client's request for the GetApnsVoipChannel operation. The "output" return
// value will be populated with the request's response once the request complets
// successfuly.
//
// Use "Send" method on the returned Request to send the API call to the service.
// the "output" return value is not valid until after Send returns without error.
//
// See GetApnsVoipChannel for more information on using the GetApnsVoipChannel
// API call, and error handling.
//
// This method is useful when you want to inject custom logic or configuration
// into the SDK's request lifecycle. Such as custom headers, or retry logic.
//
//
// // Example sending a request using the GetApnsVoipChannelRequest method.
// req, resp := client.GetApnsVoipChannelRequest(params)
//
// err := req.Send()
// if err == nil { // resp is now filled
// fmt.Println(resp)
// }
//
// See also, path_to_url
func (c *Pinpoint) GetApnsVoipChannelRequest(input *GetApnsVoipChannelInput) (req *request.Request, output *GetApnsVoipChannelOutput) {
op := &request.Operation{
Name: opGetApnsVoipChannel,
HTTPMethod: "GET",
HTTPPath: "/v1/apps/{application-id}/channels/apns_voip",
}
if input == nil {
input = &GetApnsVoipChannelInput{}
}
output = &GetApnsVoipChannelOutput{}
req = c.newRequest(op, input, output)
return
}
// GetApnsVoipChannel API operation for Amazon Pinpoint.
//
// Get an APNS Voip channel
//
// Returns awserr.Error for service API and SDK errors. Use runtime type assertions
// with awserr.Error's Code and Message methods to get detailed information about
// the error.
//
// See the AWS API reference guide for Amazon Pinpoint's
// API operation GetApnsVoipChannel for usage and error information.
//
// Returned Error Codes:
// * ErrCodeBadRequestException "BadRequestException"
//
// * ErrCodeInternalServerErrorException "InternalServerErrorException"
//
// * ErrCodeForbiddenException "ForbiddenException"
//
// * ErrCodeNotFoundException "NotFoundException"
//
// * ErrCodeMethodNotAllowedException "MethodNotAllowedException"
//
// * ErrCodeTooManyRequestsException "TooManyRequestsException"
//
// See also, path_to_url
func (c *Pinpoint) GetApnsVoipChannel(input *GetApnsVoipChannelInput) (*GetApnsVoipChannelOutput, error) {
req, out := c.GetApnsVoipChannelRequest(input)
return out, req.Send()
}
// GetApnsVoipChannelWithContext is the same as GetApnsVoipChannel with the addition of
// the ability to pass a context and additional request options.
//
// See GetApnsVoipChannel for details on how to use this API operation.
//
// The context must be non-nil and will be used for request cancellation. If
// the context is nil a panic will occur. In the future the SDK may create
// sub-contexts for http.Requests. See path_to_url
// for more information on using Contexts.
func (c *Pinpoint) GetApnsVoipChannelWithContext(ctx aws.Context, input *GetApnsVoipChannelInput, opts ...request.Option) (*GetApnsVoipChannelOutput, error) {
req, out := c.GetApnsVoipChannelRequest(input)
req.SetContext(ctx)
req.ApplyOptions(opts...)
return out, req.Send()
}
const opGetApnsVoipSandboxChannel = "GetApnsVoipSandboxChannel"
// GetApnsVoipSandboxChannelRequest generates a "aws/request.Request" representing the
// client's request for the GetApnsVoipSandboxChannel operation. The "output" return
// value will be populated with the request's response once the request complets
// successfuly.
//
// Use "Send" method on the returned Request to send the API call to the service.
// the "output" return value is not valid until after Send returns without error.
//
// See GetApnsVoipSandboxChannel for more information on using the GetApnsVoipSandboxChannel
// API call, and error handling.
//
// This method is useful when you want to inject custom logic or configuration
// into the SDK's request lifecycle. Such as custom headers, or retry logic.
//
//
// // Example sending a request using the GetApnsVoipSandboxChannelRequest method.
// req, resp := client.GetApnsVoipSandboxChannelRequest(params)
//
// err := req.Send()
// if err == nil { // resp is now filled
// fmt.Println(resp)
// }
//
// See also, path_to_url
func (c *Pinpoint) GetApnsVoipSandboxChannelRequest(input *GetApnsVoipSandboxChannelInput) (req *request.Request, output *GetApnsVoipSandboxChannelOutput) {
op := &request.Operation{
Name: opGetApnsVoipSandboxChannel,
HTTPMethod: "GET",
HTTPPath: "/v1/apps/{application-id}/channels/apns_voip_sandbox",
}
if input == nil {
input = &GetApnsVoipSandboxChannelInput{}
}
output = &GetApnsVoipSandboxChannelOutput{}
req = c.newRequest(op, input, output)
return
}
// GetApnsVoipSandboxChannel API operation for Amazon Pinpoint.
//
// Get an APNS VoipSandbox channel
//
// Returns awserr.Error for service API and SDK errors. Use runtime type assertions
// with awserr.Error's Code and Message methods to get detailed information about
// the error.
//
// See the AWS API reference guide for Amazon Pinpoint's
// API operation GetApnsVoipSandboxChannel for usage and error information.
//
// Returned Error Codes:
// * ErrCodeBadRequestException "BadRequestException"
//
// * ErrCodeInternalServerErrorException "InternalServerErrorException"
//
// * ErrCodeForbiddenException "ForbiddenException"
//
// * ErrCodeNotFoundException "NotFoundException"
//
// * ErrCodeMethodNotAllowedException "MethodNotAllowedException"
//
// * ErrCodeTooManyRequestsException "TooManyRequestsException"
//
// See also, path_to_url
func (c *Pinpoint) GetApnsVoipSandboxChannel(input *GetApnsVoipSandboxChannelInput) (*GetApnsVoipSandboxChannelOutput, error) {
req, out := c.GetApnsVoipSandboxChannelRequest(input)
return out, req.Send()
}
// GetApnsVoipSandboxChannelWithContext is the same as GetApnsVoipSandboxChannel with the addition of
// the ability to pass a context and additional request options.
//
// See GetApnsVoipSandboxChannel for details on how to use this API operation.
//
// The context must be non-nil and will be used for request cancellation. If
// the context is nil a panic will occur. In the future the SDK may create
// sub-contexts for http.Requests. See path_to_url
// for more information on using Contexts.
func (c *Pinpoint) GetApnsVoipSandboxChannelWithContext(ctx aws.Context, input *GetApnsVoipSandboxChannelInput, opts ...request.Option) (*GetApnsVoipSandboxChannelOutput, error) {
req, out := c.GetApnsVoipSandboxChannelRequest(input)
req.SetContext(ctx)
req.ApplyOptions(opts...)
return out, req.Send()
}
const opGetApp = "GetApp"
// GetAppRequest generates a "aws/request.Request" representing the
// client's request for the GetApp operation. The "output" return
// value will be populated with the request's response once the request complets
// successfuly.
//
// Use "Send" method on the returned Request to send the API call to the service.
// the "output" return value is not valid until after Send returns without error.
//
// See GetApp for more information on using the GetApp
// API call, and error handling.
//
// This method is useful when you want to inject custom logic or configuration
// into the SDK's request lifecycle. Such as custom headers, or retry logic.
//
//
// // Example sending a request using the GetAppRequest method.
// req, resp := client.GetAppRequest(params)
//
// err := req.Send()
// if err == nil { // resp is now filled
// fmt.Println(resp)
// }
//
// See also, path_to_url
func (c *Pinpoint) GetAppRequest(input *GetAppInput) (req *request.Request, output *GetAppOutput) {
op := &request.Operation{
Name: opGetApp,
HTTPMethod: "GET",
HTTPPath: "/v1/apps/{application-id}",
}
if input == nil {
input = &GetAppInput{}
}
output = &GetAppOutput{}
req = c.newRequest(op, input, output)
return
}
// GetApp API operation for Amazon Pinpoint.
//
// Returns information about an app.
//
// Returns awserr.Error for service API and SDK errors. Use runtime type assertions
// with awserr.Error's Code and Message methods to get detailed information about
// the error.
//
// See the AWS API reference guide for Amazon Pinpoint's
// API operation GetApp for usage and error information.
//
// Returned Error Codes:
// * ErrCodeBadRequestException "BadRequestException"
//
// * ErrCodeInternalServerErrorException "InternalServerErrorException"
//
// * ErrCodeForbiddenException "ForbiddenException"
//
// * ErrCodeNotFoundException "NotFoundException"
//
// * ErrCodeMethodNotAllowedException "MethodNotAllowedException"
//
// * ErrCodeTooManyRequestsException "TooManyRequestsException"
//
// See also, path_to_url
func (c *Pinpoint) GetApp(input *GetAppInput) (*GetAppOutput, error) {
req, out := c.GetAppRequest(input)
return out, req.Send()
}
// GetAppWithContext is the same as GetApp with the addition of
// the ability to pass a context and additional request options.
//
// See GetApp for details on how to use this API operation.
//
// The context must be non-nil and will be used for request cancellation. If
// the context is nil a panic will occur. In the future the SDK may create
// sub-contexts for http.Requests. See path_to_url
// for more information on using Contexts.
func (c *Pinpoint) GetAppWithContext(ctx aws.Context, input *GetAppInput, opts ...request.Option) (*GetAppOutput, error) {
req, out := c.GetAppRequest(input)
req.SetContext(ctx)
req.ApplyOptions(opts...)
return out, req.Send()
}
const opGetApplicationSettings = "GetApplicationSettings"
// GetApplicationSettingsRequest generates a "aws/request.Request" representing the
// client's request for the GetApplicationSettings operation. The "output" return
// value will be populated with the request's response once the request complets
// successfuly.
//
// Use "Send" method on the returned Request to send the API call to the service.
// the "output" return value is not valid until after Send returns without error.
//
// See GetApplicationSettings for more information on using the GetApplicationSettings
// API call, and error handling.
//
// This method is useful when you want to inject custom logic or configuration
// into the SDK's request lifecycle. Such as custom headers, or retry logic.
//
//
// // Example sending a request using the GetApplicationSettingsRequest method.
// req, resp := client.GetApplicationSettingsRequest(params)
//
// err := req.Send()
// if err == nil { // resp is now filled
// fmt.Println(resp)
// }
//
// See also, path_to_url
func (c *Pinpoint) GetApplicationSettingsRequest(input *GetApplicationSettingsInput) (req *request.Request, output *GetApplicationSettingsOutput) {
op := &request.Operation{
Name: opGetApplicationSettings,
HTTPMethod: "GET",
HTTPPath: "/v1/apps/{application-id}/settings",
}
if input == nil {
input = &GetApplicationSettingsInput{}
}
output = &GetApplicationSettingsOutput{}
req = c.newRequest(op, input, output)
return
}
// GetApplicationSettings API operation for Amazon Pinpoint.
//
// Used to request the settings for an app.
//
// Returns awserr.Error for service API and SDK errors. Use runtime type assertions
// with awserr.Error's Code and Message methods to get detailed information about
// the error.
//
// See the AWS API reference guide for Amazon Pinpoint's
// API operation GetApplicationSettings for usage and error information.
//
// Returned Error Codes:
// * ErrCodeBadRequestException "BadRequestException"
//
// * ErrCodeInternalServerErrorException "InternalServerErrorException"
//
// * ErrCodeForbiddenException "ForbiddenException"
//
// * ErrCodeNotFoundException "NotFoundException"
//
// * ErrCodeMethodNotAllowedException "MethodNotAllowedException"
//
// * ErrCodeTooManyRequestsException "TooManyRequestsException"
//
// See also, path_to_url
func (c *Pinpoint) GetApplicationSettings(input *GetApplicationSettingsInput) (*GetApplicationSettingsOutput, error) {
req, out := c.GetApplicationSettingsRequest(input)
return out, req.Send()
}
// GetApplicationSettingsWithContext is the same as GetApplicationSettings with the addition of
// the ability to pass a context and additional request options.
//
// See GetApplicationSettings for details on how to use this API operation.
//
// The context must be non-nil and will be used for request cancellation. If
// the context is nil a panic will occur. In the future the SDK may create
// sub-contexts for http.Requests. See path_to_url
// for more information on using Contexts.
func (c *Pinpoint) GetApplicationSettingsWithContext(ctx aws.Context, input *GetApplicationSettingsInput, opts ...request.Option) (*GetApplicationSettingsOutput, error) {
req, out := c.GetApplicationSettingsRequest(input)
req.SetContext(ctx)
req.ApplyOptions(opts...)
return out, req.Send()
}
const opGetApps = "GetApps"
// GetAppsRequest generates a "aws/request.Request" representing the
// client's request for the GetApps operation. The "output" return
// value will be populated with the request's response once the request complets
// successfuly.
//
// Use "Send" method on the returned Request to send the API call to the service.
// the "output" return value is not valid until after Send returns without error.
//
// See GetApps for more information on using the GetApps
// API call, and error handling.
//
// This method is useful when you want to inject custom logic or configuration
// into the SDK's request lifecycle. Such as custom headers, or retry logic.
//
//
// // Example sending a request using the GetAppsRequest method.
// req, resp := client.GetAppsRequest(params)
//
// err := req.Send()
// if err == nil { // resp is now filled
// fmt.Println(resp)
// }
//
// See also, path_to_url
func (c *Pinpoint) GetAppsRequest(input *GetAppsInput) (req *request.Request, output *GetAppsOutput) {
op := &request.Operation{
Name: opGetApps,
HTTPMethod: "GET",
HTTPPath: "/v1/apps",
}
if input == nil {
input = &GetAppsInput{}
}
output = &GetAppsOutput{}
req = c.newRequest(op, input, output)
return
}
// GetApps API operation for Amazon Pinpoint.
//
// Returns information about your apps.
//
// Returns awserr.Error for service API and SDK errors. Use runtime type assertions
// with awserr.Error's Code and Message methods to get detailed information about
// the error.
//
// See the AWS API reference guide for Amazon Pinpoint's
// API operation GetApps for usage and error information.
//
// Returned Error Codes:
// * ErrCodeBadRequestException "BadRequestException"
//
// * ErrCodeInternalServerErrorException "InternalServerErrorException"
//
// * ErrCodeForbiddenException "ForbiddenException"
//
// * ErrCodeNotFoundException "NotFoundException"
//
// * ErrCodeMethodNotAllowedException "MethodNotAllowedException"
//
// * ErrCodeTooManyRequestsException "TooManyRequestsException"
//
// See also, path_to_url
func (c *Pinpoint) GetApps(input *GetAppsInput) (*GetAppsOutput, error) {
req, out := c.GetAppsRequest(input)
return out, req.Send()
}
// GetAppsWithContext is the same as GetApps with the addition of
// the ability to pass a context and additional request options.
//
// See GetApps for details on how to use this API operation.
//
// The context must be non-nil and will be used for request cancellation. If
// the context is nil a panic will occur. In the future the SDK may create
// sub-contexts for http.Requests. See path_to_url
// for more information on using Contexts.
func (c *Pinpoint) GetAppsWithContext(ctx aws.Context, input *GetAppsInput, opts ...request.Option) (*GetAppsOutput, error) {
req, out := c.GetAppsRequest(input)
req.SetContext(ctx)
req.ApplyOptions(opts...)
return out, req.Send()
}
const opGetBaiduChannel = "GetBaiduChannel"
// GetBaiduChannelRequest generates a "aws/request.Request" representing the
// client's request for the GetBaiduChannel operation. The "output" return
// value will be populated with the request's response once the request complets
// successfuly.
//
// Use "Send" method on the returned Request to send the API call to the service.
// the "output" return value is not valid until after Send returns without error.
//
// See GetBaiduChannel for more information on using the GetBaiduChannel
// API call, and error handling.
//
// This method is useful when you want to inject custom logic or configuration
// into the SDK's request lifecycle. Such as custom headers, or retry logic.
//
//
// // Example sending a request using the GetBaiduChannelRequest method.
// req, resp := client.GetBaiduChannelRequest(params)
//
// err := req.Send()
// if err == nil { // resp is now filled
// fmt.Println(resp)
// }
//
// See also, path_to_url
func (c *Pinpoint) GetBaiduChannelRequest(input *GetBaiduChannelInput) (req *request.Request, output *GetBaiduChannelOutput) {
op := &request.Operation{
Name: opGetBaiduChannel,
HTTPMethod: "GET",
HTTPPath: "/v1/apps/{application-id}/channels/baidu",
}
if input == nil {
input = &GetBaiduChannelInput{}
}
output = &GetBaiduChannelOutput{}
req = c.newRequest(op, input, output)
return
}
// GetBaiduChannel API operation for Amazon Pinpoint.
//
// Get a BAIDU GCM channel
//
// Returns awserr.Error for service API and SDK errors. Use runtime type assertions
// with awserr.Error's Code and Message methods to get detailed information about
// the error.
//
// See the AWS API reference guide for Amazon Pinpoint's
// API operation GetBaiduChannel for usage and error information.
//
// Returned Error Codes:
// * ErrCodeBadRequestException "BadRequestException"
//
// * ErrCodeInternalServerErrorException "InternalServerErrorException"
//
// * ErrCodeForbiddenException "ForbiddenException"
//
// * ErrCodeNotFoundException "NotFoundException"
//
// * ErrCodeMethodNotAllowedException "MethodNotAllowedException"
//
// * ErrCodeTooManyRequestsException "TooManyRequestsException"
//
// See also, path_to_url
func (c *Pinpoint) GetBaiduChannel(input *GetBaiduChannelInput) (*GetBaiduChannelOutput, error) {
req, out := c.GetBaiduChannelRequest(input)
return out, req.Send()
}
// GetBaiduChannelWithContext is the same as GetBaiduChannel with the addition of
// the ability to pass a context and additional request options.
//
// See GetBaiduChannel for details on how to use this API operation.
//
// The context must be non-nil and will be used for request cancellation. If
// the context is nil a panic will occur. In the future the SDK may create
// sub-contexts for http.Requests. See path_to_url
// for more information on using Contexts.
func (c *Pinpoint) GetBaiduChannelWithContext(ctx aws.Context, input *GetBaiduChannelInput, opts ...request.Option) (*GetBaiduChannelOutput, error) {
req, out := c.GetBaiduChannelRequest(input)
req.SetContext(ctx)
req.ApplyOptions(opts...)
return out, req.Send()
}
const opGetCampaign = "GetCampaign"
// GetCampaignRequest generates a "aws/request.Request" representing the
// client's request for the GetCampaign operation. The "output" return
// value will be populated with the request's response once the request complets
// successfuly.
//
// Use "Send" method on the returned Request to send the API call to the service.
// the "output" return value is not valid until after Send returns without error.
//
// See GetCampaign for more information on using the GetCampaign
// API call, and error handling.
//
// This method is useful when you want to inject custom logic or configuration
// into the SDK's request lifecycle. Such as custom headers, or retry logic.
//
//
// // Example sending a request using the GetCampaignRequest method.
// req, resp := client.GetCampaignRequest(params)
//
// err := req.Send()
// if err == nil { // resp is now filled
// fmt.Println(resp)
// }
//
// See also, path_to_url
func (c *Pinpoint) GetCampaignRequest(input *GetCampaignInput) (req *request.Request, output *GetCampaignOutput) {
op := &request.Operation{
Name: opGetCampaign,
HTTPMethod: "GET",
HTTPPath: "/v1/apps/{application-id}/campaigns/{campaign-id}",
}
if input == nil {
input = &GetCampaignInput{}
}
output = &GetCampaignOutput{}
req = c.newRequest(op, input, output)
return
}
// GetCampaign API operation for Amazon Pinpoint.
//
// Returns information about a campaign.
//
// Returns awserr.Error for service API and SDK errors. Use runtime type assertions
// with awserr.Error's Code and Message methods to get detailed information about
// the error.
//
// See the AWS API reference guide for Amazon Pinpoint's
// API operation GetCampaign for usage and error information.
//
// Returned Error Codes:
// * ErrCodeBadRequestException "BadRequestException"
//
// * ErrCodeInternalServerErrorException "InternalServerErrorException"
//
// * ErrCodeForbiddenException "ForbiddenException"
//
// * ErrCodeNotFoundException "NotFoundException"
//
// * ErrCodeMethodNotAllowedException "MethodNotAllowedException"
//
// * ErrCodeTooManyRequestsException "TooManyRequestsException"
//
// See also, path_to_url
func (c *Pinpoint) GetCampaign(input *GetCampaignInput) (*GetCampaignOutput, error) {
req, out := c.GetCampaignRequest(input)
return out, req.Send()
}
// GetCampaignWithContext is the same as GetCampaign with the addition of
// the ability to pass a context and additional request options.
//
// See GetCampaign for details on how to use this API operation.
//
// The context must be non-nil and will be used for request cancellation. If
// the context is nil a panic will occur. In the future the SDK may create
// sub-contexts for http.Requests. See path_to_url
// for more information on using Contexts.
func (c *Pinpoint) GetCampaignWithContext(ctx aws.Context, input *GetCampaignInput, opts ...request.Option) (*GetCampaignOutput, error) {
req, out := c.GetCampaignRequest(input)
req.SetContext(ctx)
req.ApplyOptions(opts...)
return out, req.Send()
}
const opGetCampaignActivities = "GetCampaignActivities"
// GetCampaignActivitiesRequest generates a "aws/request.Request" representing the
// client's request for the GetCampaignActivities operation. The "output" return
// value will be populated with the request's response once the request complets
// successfuly.
//
// Use "Send" method on the returned Request to send the API call to the service.
// the "output" return value is not valid until after Send returns without error.
//
// See GetCampaignActivities for more information on using the GetCampaignActivities
// API call, and error handling.
//
// This method is useful when you want to inject custom logic or configuration
// into the SDK's request lifecycle. Such as custom headers, or retry logic.
//
//
// // Example sending a request using the GetCampaignActivitiesRequest method.
// req, resp := client.GetCampaignActivitiesRequest(params)
//
// err := req.Send()
// if err == nil { // resp is now filled
// fmt.Println(resp)
// }
//
// See also, path_to_url
func (c *Pinpoint) GetCampaignActivitiesRequest(input *GetCampaignActivitiesInput) (req *request.Request, output *GetCampaignActivitiesOutput) {
op := &request.Operation{
Name: opGetCampaignActivities,
HTTPMethod: "GET",
HTTPPath: "/v1/apps/{application-id}/campaigns/{campaign-id}/activities",
}
if input == nil {
input = &GetCampaignActivitiesInput{}
}
output = &GetCampaignActivitiesOutput{}
req = c.newRequest(op, input, output)
return
}
// GetCampaignActivities API operation for Amazon Pinpoint.
//
// Returns information about the activity performed by a campaign.
//
// Returns awserr.Error for service API and SDK errors. Use runtime type assertions
// with awserr.Error's Code and Message methods to get detailed information about
// the error.
//
// See the AWS API reference guide for Amazon Pinpoint's
// API operation GetCampaignActivities for usage and error information.
//
// Returned Error Codes:
// * ErrCodeBadRequestException "BadRequestException"
//
// * ErrCodeInternalServerErrorException "InternalServerErrorException"
//
// * ErrCodeForbiddenException "ForbiddenException"
//
// * ErrCodeNotFoundException "NotFoundException"
//
// * ErrCodeMethodNotAllowedException "MethodNotAllowedException"
//
// * ErrCodeTooManyRequestsException "TooManyRequestsException"
//
// See also, path_to_url
func (c *Pinpoint) GetCampaignActivities(input *GetCampaignActivitiesInput) (*GetCampaignActivitiesOutput, error) {
req, out := c.GetCampaignActivitiesRequest(input)
return out, req.Send()
}
// GetCampaignActivitiesWithContext is the same as GetCampaignActivities with the addition of
// the ability to pass a context and additional request options.
//
// See GetCampaignActivities for details on how to use this API operation.
//
// The context must be non-nil and will be used for request cancellation. If
// the context is nil a panic will occur. In the future the SDK may create
// sub-contexts for http.Requests. See path_to_url
// for more information on using Contexts.
func (c *Pinpoint) GetCampaignActivitiesWithContext(ctx aws.Context, input *GetCampaignActivitiesInput, opts ...request.Option) (*GetCampaignActivitiesOutput, error) {
req, out := c.GetCampaignActivitiesRequest(input)
req.SetContext(ctx)
req.ApplyOptions(opts...)
return out, req.Send()
}
const opGetCampaignVersion = "GetCampaignVersion"
// GetCampaignVersionRequest generates a "aws/request.Request" representing the
// client's request for the GetCampaignVersion operation. The "output" return
// value will be populated with the request's response once the request complets
// successfuly.
//
// Use "Send" method on the returned Request to send the API call to the service.
// the "output" return value is not valid until after Send returns without error.
//
// See GetCampaignVersion for more information on using the GetCampaignVersion
// API call, and error handling.
//
// This method is useful when you want to inject custom logic or configuration
// into the SDK's request lifecycle. Such as custom headers, or retry logic.
//
//
// // Example sending a request using the GetCampaignVersionRequest method.
// req, resp := client.GetCampaignVersionRequest(params)
//
// err := req.Send()
// if err == nil { // resp is now filled
// fmt.Println(resp)
// }
//
// See also, path_to_url
func (c *Pinpoint) GetCampaignVersionRequest(input *GetCampaignVersionInput) (req *request.Request, output *GetCampaignVersionOutput) {
op := &request.Operation{
Name: opGetCampaignVersion,
HTTPMethod: "GET",
HTTPPath: "/v1/apps/{application-id}/campaigns/{campaign-id}/versions/{version}",
}
if input == nil {
input = &GetCampaignVersionInput{}
}
output = &GetCampaignVersionOutput{}
req = c.newRequest(op, input, output)
return
}
// GetCampaignVersion API operation for Amazon Pinpoint.
//
// Returns information about a specific version of a campaign.
//
// Returns awserr.Error for service API and SDK errors. Use runtime type assertions
// with awserr.Error's Code and Message methods to get detailed information about
// the error.
//
// See the AWS API reference guide for Amazon Pinpoint's
// API operation GetCampaignVersion for usage and error information.
//
// Returned Error Codes:
// * ErrCodeBadRequestException "BadRequestException"
//
// * ErrCodeInternalServerErrorException "InternalServerErrorException"
//
// * ErrCodeForbiddenException "ForbiddenException"
//
// * ErrCodeNotFoundException "NotFoundException"
//
// * ErrCodeMethodNotAllowedException "MethodNotAllowedException"
//
// * ErrCodeTooManyRequestsException "TooManyRequestsException"
//
// See also, path_to_url
func (c *Pinpoint) GetCampaignVersion(input *GetCampaignVersionInput) (*GetCampaignVersionOutput, error) {
req, out := c.GetCampaignVersionRequest(input)
return out, req.Send()
}
// GetCampaignVersionWithContext is the same as GetCampaignVersion with the addition of
// the ability to pass a context and additional request options.
//
// See GetCampaignVersion for details on how to use this API operation.
//
// The context must be non-nil and will be used for request cancellation. If
// the context is nil a panic will occur. In the future the SDK may create
// sub-contexts for http.Requests. See path_to_url
// for more information on using Contexts.
func (c *Pinpoint) GetCampaignVersionWithContext(ctx aws.Context, input *GetCampaignVersionInput, opts ...request.Option) (*GetCampaignVersionOutput, error) {
req, out := c.GetCampaignVersionRequest(input)
req.SetContext(ctx)
req.ApplyOptions(opts...)
return out, req.Send()
}
const opGetCampaignVersions = "GetCampaignVersions"
// GetCampaignVersionsRequest generates a "aws/request.Request" representing the
// client's request for the GetCampaignVersions operation. The "output" return
// value will be populated with the request's response once the request complets
// successfuly.
//
// Use "Send" method on the returned Request to send the API call to the service.
// the "output" return value is not valid until after Send returns without error.
//
// See GetCampaignVersions for more information on using the GetCampaignVersions
// API call, and error handling.
//
// This method is useful when you want to inject custom logic or configuration
// into the SDK's request lifecycle. Such as custom headers, or retry logic.
//
//
// // Example sending a request using the GetCampaignVersionsRequest method.
// req, resp := client.GetCampaignVersionsRequest(params)
//
// err := req.Send()
// if err == nil { // resp is now filled
// fmt.Println(resp)
// }
//
// See also, path_to_url
func (c *Pinpoint) GetCampaignVersionsRequest(input *GetCampaignVersionsInput) (req *request.Request, output *GetCampaignVersionsOutput) {
op := &request.Operation{
Name: opGetCampaignVersions,
HTTPMethod: "GET",
HTTPPath: "/v1/apps/{application-id}/campaigns/{campaign-id}/versions",
}
if input == nil {
input = &GetCampaignVersionsInput{}
}
output = &GetCampaignVersionsOutput{}
req = c.newRequest(op, input, output)
return
}
// GetCampaignVersions API operation for Amazon Pinpoint.
//
// Returns information about your campaign versions.
//
// Returns awserr.Error for service API and SDK errors. Use runtime type assertions
// with awserr.Error's Code and Message methods to get detailed information about
// the error.
//
// See the AWS API reference guide for Amazon Pinpoint's
// API operation GetCampaignVersions for usage and error information.
//
// Returned Error Codes:
// * ErrCodeBadRequestException "BadRequestException"
//
// * ErrCodeInternalServerErrorException "InternalServerErrorException"
//
// * ErrCodeForbiddenException "ForbiddenException"
//
// * ErrCodeNotFoundException "NotFoundException"
//
// * ErrCodeMethodNotAllowedException "MethodNotAllowedException"
//
// * ErrCodeTooManyRequestsException "TooManyRequestsException"
//
// See also, path_to_url
func (c *Pinpoint) GetCampaignVersions(input *GetCampaignVersionsInput) (*GetCampaignVersionsOutput, error) {
req, out := c.GetCampaignVersionsRequest(input)
return out, req.Send()
}
// GetCampaignVersionsWithContext is the same as GetCampaignVersions with the addition of
// the ability to pass a context and additional request options.
//
// See GetCampaignVersions for details on how to use this API operation.
//
// The context must be non-nil and will be used for request cancellation. If
// the context is nil a panic will occur. In the future the SDK may create
// sub-contexts for http.Requests. See path_to_url
// for more information on using Contexts.
func (c *Pinpoint) GetCampaignVersionsWithContext(ctx aws.Context, input *GetCampaignVersionsInput, opts ...request.Option) (*GetCampaignVersionsOutput, error) {
req, out := c.GetCampaignVersionsRequest(input)
req.SetContext(ctx)
req.ApplyOptions(opts...)
return out, req.Send()
}
const opGetCampaigns = "GetCampaigns"
// GetCampaignsRequest generates a "aws/request.Request" representing the
// client's request for the GetCampaigns operation. The "output" return
// value will be populated with the request's response once the request complets
// successfuly.
//
// Use "Send" method on the returned Request to send the API call to the service.
// the "output" return value is not valid until after Send returns without error.
//
// See GetCampaigns for more information on using the GetCampaigns
// API call, and error handling.
//
// This method is useful when you want to inject custom logic or configuration
// into the SDK's request lifecycle. Such as custom headers, or retry logic.
//
//
// // Example sending a request using the GetCampaignsRequest method.
// req, resp := client.GetCampaignsRequest(params)
//
// err := req.Send()
// if err == nil { // resp is now filled
// fmt.Println(resp)
// }
//
// See also, path_to_url
func (c *Pinpoint) GetCampaignsRequest(input *GetCampaignsInput) (req *request.Request, output *GetCampaignsOutput) {
op := &request.Operation{
Name: opGetCampaigns,
HTTPMethod: "GET",
HTTPPath: "/v1/apps/{application-id}/campaigns",
}
if input == nil {
input = &GetCampaignsInput{}
}
output = &GetCampaignsOutput{}
req = c.newRequest(op, input, output)
return
}
// GetCampaigns API operation for Amazon Pinpoint.
//
// Returns information about your campaigns.
//
// Returns awserr.Error for service API and SDK errors. Use runtime type assertions
// with awserr.Error's Code and Message methods to get detailed information about
// the error.
//
// See the AWS API reference guide for Amazon Pinpoint's
// API operation GetCampaigns for usage and error information.
//
// Returned Error Codes:
// * ErrCodeBadRequestException "BadRequestException"
//
// * ErrCodeInternalServerErrorException "InternalServerErrorException"
//
// * ErrCodeForbiddenException "ForbiddenException"
//
// * ErrCodeNotFoundException "NotFoundException"
//
// * ErrCodeMethodNotAllowedException "MethodNotAllowedException"
//
// * ErrCodeTooManyRequestsException "TooManyRequestsException"
//
// See also, path_to_url
func (c *Pinpoint) GetCampaigns(input *GetCampaignsInput) (*GetCampaignsOutput, error) {
req, out := c.GetCampaignsRequest(input)
return out, req.Send()
}
// GetCampaignsWithContext is the same as GetCampaigns with the addition of
// the ability to pass a context and additional request options.
//
// See GetCampaigns for details on how to use this API operation.
//
// The context must be non-nil and will be used for request cancellation. If
// the context is nil a panic will occur. In the future the SDK may create
// sub-contexts for http.Requests. See path_to_url
// for more information on using Contexts.
func (c *Pinpoint) GetCampaignsWithContext(ctx aws.Context, input *GetCampaignsInput, opts ...request.Option) (*GetCampaignsOutput, error) {
req, out := c.GetCampaignsRequest(input)
req.SetContext(ctx)
req.ApplyOptions(opts...)
return out, req.Send()
}
const opGetEmailChannel = "GetEmailChannel"
// GetEmailChannelRequest generates a "aws/request.Request" representing the
// client's request for the GetEmailChannel operation. The "output" return
// value will be populated with the request's response once the request complets
// successfuly.
//
// Use "Send" method on the returned Request to send the API call to the service.
// the "output" return value is not valid until after Send returns without error.
//
// See GetEmailChannel for more information on using the GetEmailChannel
// API call, and error handling.
//
// This method is useful when you want to inject custom logic or configuration
// into the SDK's request lifecycle. Such as custom headers, or retry logic.
//
//
// // Example sending a request using the GetEmailChannelRequest method.
// req, resp := client.GetEmailChannelRequest(params)
//
// err := req.Send()
// if err == nil { // resp is now filled
// fmt.Println(resp)
// }
//
// See also, path_to_url
func (c *Pinpoint) GetEmailChannelRequest(input *GetEmailChannelInput) (req *request.Request, output *GetEmailChannelOutput) {
op := &request.Operation{
Name: opGetEmailChannel,
HTTPMethod: "GET",
HTTPPath: "/v1/apps/{application-id}/channels/email",
}
if input == nil {
input = &GetEmailChannelInput{}
}
output = &GetEmailChannelOutput{}
req = c.newRequest(op, input, output)
return
}
// GetEmailChannel API operation for Amazon Pinpoint.
//
// Get an email channel
//
// Returns awserr.Error for service API and SDK errors. Use runtime type assertions
// with awserr.Error's Code and Message methods to get detailed information about
// the error.
//
// See the AWS API reference guide for Amazon Pinpoint's
// API operation GetEmailChannel for usage and error information.
//
// Returned Error Codes:
// * ErrCodeBadRequestException "BadRequestException"
//
// * ErrCodeInternalServerErrorException "InternalServerErrorException"
//
// * ErrCodeForbiddenException "ForbiddenException"
//
// * ErrCodeNotFoundException "NotFoundException"
//
// * ErrCodeMethodNotAllowedException "MethodNotAllowedException"
//
// * ErrCodeTooManyRequestsException "TooManyRequestsException"
//
// See also, path_to_url
func (c *Pinpoint) GetEmailChannel(input *GetEmailChannelInput) (*GetEmailChannelOutput, error) {
req, out := c.GetEmailChannelRequest(input)
return out, req.Send()
}
// GetEmailChannelWithContext is the same as GetEmailChannel with the addition of
// the ability to pass a context and additional request options.
//
// See GetEmailChannel for details on how to use this API operation.
//
// The context must be non-nil and will be used for request cancellation. If
// the context is nil a panic will occur. In the future the SDK may create
// sub-contexts for http.Requests. See path_to_url
// for more information on using Contexts.
func (c *Pinpoint) GetEmailChannelWithContext(ctx aws.Context, input *GetEmailChannelInput, opts ...request.Option) (*GetEmailChannelOutput, error) {
req, out := c.GetEmailChannelRequest(input)
req.SetContext(ctx)
req.ApplyOptions(opts...)
return out, req.Send()
}
const opGetEndpoint = "GetEndpoint"
// GetEndpointRequest generates a "aws/request.Request" representing the
// client's request for the GetEndpoint operation. The "output" return
// value will be populated with the request's response once the request complets
// successfuly.
//
// Use "Send" method on the returned Request to send the API call to the service.
// the "output" return value is not valid until after Send returns without error.
//
// See GetEndpoint for more information on using the GetEndpoint
// API call, and error handling.
//
// This method is useful when you want to inject custom logic or configuration
// into the SDK's request lifecycle. Such as custom headers, or retry logic.
//
//
// // Example sending a request using the GetEndpointRequest method.
// req, resp := client.GetEndpointRequest(params)
//
// err := req.Send()
// if err == nil { // resp is now filled
// fmt.Println(resp)
// }
//
// See also, path_to_url
func (c *Pinpoint) GetEndpointRequest(input *GetEndpointInput) (req *request.Request, output *GetEndpointOutput) {
op := &request.Operation{
Name: opGetEndpoint,
HTTPMethod: "GET",
HTTPPath: "/v1/apps/{application-id}/endpoints/{endpoint-id}",
}
if input == nil {
input = &GetEndpointInput{}
}
output = &GetEndpointOutput{}
req = c.newRequest(op, input, output)
return
}
// GetEndpoint API operation for Amazon Pinpoint.
//
// Returns information about an endpoint.
//
// Returns awserr.Error for service API and SDK errors. Use runtime type assertions
// with awserr.Error's Code and Message methods to get detailed information about
// the error.
//
// See the AWS API reference guide for Amazon Pinpoint's
// API operation GetEndpoint for usage and error information.
//
// Returned Error Codes:
// * ErrCodeBadRequestException "BadRequestException"
//
// * ErrCodeInternalServerErrorException "InternalServerErrorException"
//
// * ErrCodeForbiddenException "ForbiddenException"
//
// * ErrCodeNotFoundException "NotFoundException"
//
// * ErrCodeMethodNotAllowedException "MethodNotAllowedException"
//
// * ErrCodeTooManyRequestsException "TooManyRequestsException"
//
// See also, path_to_url
func (c *Pinpoint) GetEndpoint(input *GetEndpointInput) (*GetEndpointOutput, error) {
req, out := c.GetEndpointRequest(input)
return out, req.Send()
}
// GetEndpointWithContext is the same as GetEndpoint with the addition of
// the ability to pass a context and additional request options.
//
// See GetEndpoint for details on how to use this API operation.
//
// The context must be non-nil and will be used for request cancellation. If
// the context is nil a panic will occur. In the future the SDK may create
// sub-contexts for http.Requests. See path_to_url
// for more information on using Contexts.
func (c *Pinpoint) GetEndpointWithContext(ctx aws.Context, input *GetEndpointInput, opts ...request.Option) (*GetEndpointOutput, error) {
req, out := c.GetEndpointRequest(input)
req.SetContext(ctx)
req.ApplyOptions(opts...)
return out, req.Send()
}
const opGetEventStream = "GetEventStream"
// GetEventStreamRequest generates a "aws/request.Request" representing the
// client's request for the GetEventStream operation. The "output" return
// value will be populated with the request's response once the request complets
// successfuly.
//
// Use "Send" method on the returned Request to send the API call to the service.
// the "output" return value is not valid until after Send returns without error.
//
// See GetEventStream for more information on using the GetEventStream
// API call, and error handling.
//
// This method is useful when you want to inject custom logic or configuration
// into the SDK's request lifecycle. Such as custom headers, or retry logic.
//
//
// // Example sending a request using the GetEventStreamRequest method.
// req, resp := client.GetEventStreamRequest(params)
//
// err := req.Send()
// if err == nil { // resp is now filled
// fmt.Println(resp)
// }
//
// See also, path_to_url
func (c *Pinpoint) GetEventStreamRequest(input *GetEventStreamInput) (req *request.Request, output *GetEventStreamOutput) {
op := &request.Operation{
Name: opGetEventStream,
HTTPMethod: "GET",
HTTPPath: "/v1/apps/{application-id}/eventstream",
}
if input == nil {
input = &GetEventStreamInput{}
}
output = &GetEventStreamOutput{}
req = c.newRequest(op, input, output)
return
}
// GetEventStream API operation for Amazon Pinpoint.
//
// Returns the event stream for an app.
//
// Returns awserr.Error for service API and SDK errors. Use runtime type assertions
// with awserr.Error's Code and Message methods to get detailed information about
// the error.
//
// See the AWS API reference guide for Amazon Pinpoint's
// API operation GetEventStream for usage and error information.
//
// Returned Error Codes:
// * ErrCodeBadRequestException "BadRequestException"
//
// * ErrCodeInternalServerErrorException "InternalServerErrorException"
//
// * ErrCodeForbiddenException "ForbiddenException"
//
// * ErrCodeNotFoundException "NotFoundException"
//
// * ErrCodeMethodNotAllowedException "MethodNotAllowedException"
//
// * ErrCodeTooManyRequestsException "TooManyRequestsException"
//
// See also, path_to_url
func (c *Pinpoint) GetEventStream(input *GetEventStreamInput) (*GetEventStreamOutput, error) {
req, out := c.GetEventStreamRequest(input)
return out, req.Send()
}
// GetEventStreamWithContext is the same as GetEventStream with the addition of
// the ability to pass a context and additional request options.
//
// See GetEventStream for details on how to use this API operation.
//
// The context must be non-nil and will be used for request cancellation. If
// the context is nil a panic will occur. In the future the SDK may create
// sub-contexts for http.Requests. See path_to_url
// for more information on using Contexts.
func (c *Pinpoint) GetEventStreamWithContext(ctx aws.Context, input *GetEventStreamInput, opts ...request.Option) (*GetEventStreamOutput, error) {
req, out := c.GetEventStreamRequest(input)
req.SetContext(ctx)
req.ApplyOptions(opts...)
return out, req.Send()
}
const opGetGcmChannel = "GetGcmChannel"
// GetGcmChannelRequest generates a "aws/request.Request" representing the
// client's request for the GetGcmChannel operation. The "output" return
// value will be populated with the request's response once the request complets
// successfuly.
//
// Use "Send" method on the returned Request to send the API call to the service.
// the "output" return value is not valid until after Send returns without error.
//
// See GetGcmChannel for more information on using the GetGcmChannel
// API call, and error handling.
//
// This method is useful when you want to inject custom logic or configuration
// into the SDK's request lifecycle. Such as custom headers, or retry logic.
//
//
// // Example sending a request using the GetGcmChannelRequest method.
// req, resp := client.GetGcmChannelRequest(params)
//
// err := req.Send()
// if err == nil { // resp is now filled
// fmt.Println(resp)
// }
//
// See also, path_to_url
func (c *Pinpoint) GetGcmChannelRequest(input *GetGcmChannelInput) (req *request.Request, output *GetGcmChannelOutput) {
op := &request.Operation{
Name: opGetGcmChannel,
HTTPMethod: "GET",
HTTPPath: "/v1/apps/{application-id}/channels/gcm",
}
if input == nil {
input = &GetGcmChannelInput{}
}
output = &GetGcmChannelOutput{}
req = c.newRequest(op, input, output)
return
}
// GetGcmChannel API operation for Amazon Pinpoint.
//
// Returns information about the GCM channel for an app.
//
// Returns awserr.Error for service API and SDK errors. Use runtime type assertions
// with awserr.Error's Code and Message methods to get detailed information about
// the error.
//
// See the AWS API reference guide for Amazon Pinpoint's
// API operation GetGcmChannel for usage and error information.
//
// Returned Error Codes:
// * ErrCodeBadRequestException "BadRequestException"
//
// * ErrCodeInternalServerErrorException "InternalServerErrorException"
//
// * ErrCodeForbiddenException "ForbiddenException"
//
// * ErrCodeNotFoundException "NotFoundException"
//
// * ErrCodeMethodNotAllowedException "MethodNotAllowedException"
//
// * ErrCodeTooManyRequestsException "TooManyRequestsException"
//
// See also, path_to_url
func (c *Pinpoint) GetGcmChannel(input *GetGcmChannelInput) (*GetGcmChannelOutput, error) {
req, out := c.GetGcmChannelRequest(input)
return out, req.Send()
}
// GetGcmChannelWithContext is the same as GetGcmChannel with the addition of
// the ability to pass a context and additional request options.
//
// See GetGcmChannel for details on how to use this API operation.
//
// The context must be non-nil and will be used for request cancellation. If
// the context is nil a panic will occur. In the future the SDK may create
// sub-contexts for http.Requests. See path_to_url
// for more information on using Contexts.
func (c *Pinpoint) GetGcmChannelWithContext(ctx aws.Context, input *GetGcmChannelInput, opts ...request.Option) (*GetGcmChannelOutput, error) {
req, out := c.GetGcmChannelRequest(input)
req.SetContext(ctx)
req.ApplyOptions(opts...)
return out, req.Send()
}
const opGetImportJob = "GetImportJob"
// GetImportJobRequest generates a "aws/request.Request" representing the
// client's request for the GetImportJob operation. The "output" return
// value will be populated with the request's response once the request complets
// successfuly.
//
// Use "Send" method on the returned Request to send the API call to the service.
// the "output" return value is not valid until after Send returns without error.
//
// See GetImportJob for more information on using the GetImportJob
// API call, and error handling.
//
// This method is useful when you want to inject custom logic or configuration
// into the SDK's request lifecycle. Such as custom headers, or retry logic.
//
//
// // Example sending a request using the GetImportJobRequest method.
// req, resp := client.GetImportJobRequest(params)
//
// err := req.Send()
// if err == nil { // resp is now filled
// fmt.Println(resp)
// }
//
// See also, path_to_url
func (c *Pinpoint) GetImportJobRequest(input *GetImportJobInput) (req *request.Request, output *GetImportJobOutput) {
op := &request.Operation{
Name: opGetImportJob,
HTTPMethod: "GET",
HTTPPath: "/v1/apps/{application-id}/jobs/import/{job-id}",
}
if input == nil {
input = &GetImportJobInput{}
}
output = &GetImportJobOutput{}
req = c.newRequest(op, input, output)
return
}
// GetImportJob API operation for Amazon Pinpoint.
//
// Returns information about an import job.
//
// Returns awserr.Error for service API and SDK errors. Use runtime type assertions
// with awserr.Error's Code and Message methods to get detailed information about
// the error.
//
// See the AWS API reference guide for Amazon Pinpoint's
// API operation GetImportJob for usage and error information.
//
// Returned Error Codes:
// * ErrCodeBadRequestException "BadRequestException"
//
// * ErrCodeInternalServerErrorException "InternalServerErrorException"
//
// * ErrCodeForbiddenException "ForbiddenException"
//
// * ErrCodeNotFoundException "NotFoundException"
//
// * ErrCodeMethodNotAllowedException "MethodNotAllowedException"
//
// * ErrCodeTooManyRequestsException "TooManyRequestsException"
//
// See also, path_to_url
func (c *Pinpoint) GetImportJob(input *GetImportJobInput) (*GetImportJobOutput, error) {
req, out := c.GetImportJobRequest(input)
return out, req.Send()
}
// GetImportJobWithContext is the same as GetImportJob with the addition of
// the ability to pass a context and additional request options.
//
// See GetImportJob for details on how to use this API operation.
//
// The context must be non-nil and will be used for request cancellation. If
// the context is nil a panic will occur. In the future the SDK may create
// sub-contexts for http.Requests. See path_to_url
// for more information on using Contexts.
func (c *Pinpoint) GetImportJobWithContext(ctx aws.Context, input *GetImportJobInput, opts ...request.Option) (*GetImportJobOutput, error) {
req, out := c.GetImportJobRequest(input)
req.SetContext(ctx)
req.ApplyOptions(opts...)
return out, req.Send()
}
const opGetImportJobs = "GetImportJobs"
// GetImportJobsRequest generates a "aws/request.Request" representing the
// client's request for the GetImportJobs operation. The "output" return
// value will be populated with the request's response once the request complets
// successfuly.
//
// Use "Send" method on the returned Request to send the API call to the service.
// the "output" return value is not valid until after Send returns without error.
//
// See GetImportJobs for more information on using the GetImportJobs
// API call, and error handling.
//
// This method is useful when you want to inject custom logic or configuration
// into the SDK's request lifecycle. Such as custom headers, or retry logic.
//
//
// // Example sending a request using the GetImportJobsRequest method.
// req, resp := client.GetImportJobsRequest(params)
//
// err := req.Send()
// if err == nil { // resp is now filled
// fmt.Println(resp)
// }
//
// See also, path_to_url
func (c *Pinpoint) GetImportJobsRequest(input *GetImportJobsInput) (req *request.Request, output *GetImportJobsOutput) {
op := &request.Operation{
Name: opGetImportJobs,
HTTPMethod: "GET",
HTTPPath: "/v1/apps/{application-id}/jobs/import",
}
if input == nil {
input = &GetImportJobsInput{}
}
output = &GetImportJobsOutput{}
req = c.newRequest(op, input, output)
return
}
// GetImportJobs API operation for Amazon Pinpoint.
//
// Returns information about your import jobs.
//
// Returns awserr.Error for service API and SDK errors. Use runtime type assertions
// with awserr.Error's Code and Message methods to get detailed information about
// the error.
//
// See the AWS API reference guide for Amazon Pinpoint's
// API operation GetImportJobs for usage and error information.
//
// Returned Error Codes:
// * ErrCodeBadRequestException "BadRequestException"
//
// * ErrCodeInternalServerErrorException "InternalServerErrorException"
//
// * ErrCodeForbiddenException "ForbiddenException"
//
// * ErrCodeNotFoundException "NotFoundException"
//
// * ErrCodeMethodNotAllowedException "MethodNotAllowedException"
//
// * ErrCodeTooManyRequestsException "TooManyRequestsException"
//
// See also, path_to_url
func (c *Pinpoint) GetImportJobs(input *GetImportJobsInput) (*GetImportJobsOutput, error) {
req, out := c.GetImportJobsRequest(input)
return out, req.Send()
}
// GetImportJobsWithContext is the same as GetImportJobs with the addition of
// the ability to pass a context and additional request options.
//
// See GetImportJobs for details on how to use this API operation.
//
// The context must be non-nil and will be used for request cancellation. If
// the context is nil a panic will occur. In the future the SDK may create
// sub-contexts for http.Requests. See path_to_url
// for more information on using Contexts.
func (c *Pinpoint) GetImportJobsWithContext(ctx aws.Context, input *GetImportJobsInput, opts ...request.Option) (*GetImportJobsOutput, error) {
req, out := c.GetImportJobsRequest(input)
req.SetContext(ctx)
req.ApplyOptions(opts...)
return out, req.Send()
}
const opGetSegment = "GetSegment"
// GetSegmentRequest generates a "aws/request.Request" representing the
// client's request for the GetSegment operation. The "output" return
// value will be populated with the request's response once the request complets
// successfuly.
//
// Use "Send" method on the returned Request to send the API call to the service.
// the "output" return value is not valid until after Send returns without error.
//
// See GetSegment for more information on using the GetSegment
// API call, and error handling.
//
// This method is useful when you want to inject custom logic or configuration
// into the SDK's request lifecycle. Such as custom headers, or retry logic.
//
//
// // Example sending a request using the GetSegmentRequest method.
// req, resp := client.GetSegmentRequest(params)
//
// err := req.Send()
// if err == nil { // resp is now filled
// fmt.Println(resp)
// }
//
// See also, path_to_url
func (c *Pinpoint) GetSegmentRequest(input *GetSegmentInput) (req *request.Request, output *GetSegmentOutput) {
op := &request.Operation{
Name: opGetSegment,
HTTPMethod: "GET",
HTTPPath: "/v1/apps/{application-id}/segments/{segment-id}",
}
if input == nil {
input = &GetSegmentInput{}
}
output = &GetSegmentOutput{}
req = c.newRequest(op, input, output)
return
}
// GetSegment API operation for Amazon Pinpoint.
//
// Returns information about a segment.
//
// Returns awserr.Error for service API and SDK errors. Use runtime type assertions
// with awserr.Error's Code and Message methods to get detailed information about
// the error.
//
// See the AWS API reference guide for Amazon Pinpoint's
// API operation GetSegment for usage and error information.
//
// Returned Error Codes:
// * ErrCodeBadRequestException "BadRequestException"
//
// * ErrCodeInternalServerErrorException "InternalServerErrorException"
//
// * ErrCodeForbiddenException "ForbiddenException"
//
// * ErrCodeNotFoundException "NotFoundException"
//
// * ErrCodeMethodNotAllowedException "MethodNotAllowedException"
//
// * ErrCodeTooManyRequestsException "TooManyRequestsException"
//
// See also, path_to_url
func (c *Pinpoint) GetSegment(input *GetSegmentInput) (*GetSegmentOutput, error) {
req, out := c.GetSegmentRequest(input)
return out, req.Send()
}
// GetSegmentWithContext is the same as GetSegment with the addition of
// the ability to pass a context and additional request options.
//
// See GetSegment for details on how to use this API operation.
//
// The context must be non-nil and will be used for request cancellation. If
// the context is nil a panic will occur. In the future the SDK may create
// sub-contexts for http.Requests. See path_to_url
// for more information on using Contexts.
func (c *Pinpoint) GetSegmentWithContext(ctx aws.Context, input *GetSegmentInput, opts ...request.Option) (*GetSegmentOutput, error) {
req, out := c.GetSegmentRequest(input)
req.SetContext(ctx)
req.ApplyOptions(opts...)
return out, req.Send()
}
const opGetSegmentImportJobs = "GetSegmentImportJobs"
// GetSegmentImportJobsRequest generates a "aws/request.Request" representing the
// client's request for the GetSegmentImportJobs operation. The "output" return
// value will be populated with the request's response once the request complets
// successfuly.
//
// Use "Send" method on the returned Request to send the API call to the service.
// the "output" return value is not valid until after Send returns without error.
//
// See GetSegmentImportJobs for more information on using the GetSegmentImportJobs
// API call, and error handling.
//
// This method is useful when you want to inject custom logic or configuration
// into the SDK's request lifecycle. Such as custom headers, or retry logic.
//
//
// // Example sending a request using the GetSegmentImportJobsRequest method.
// req, resp := client.GetSegmentImportJobsRequest(params)
//
// err := req.Send()
// if err == nil { // resp is now filled
// fmt.Println(resp)
// }
//
// See also, path_to_url
func (c *Pinpoint) GetSegmentImportJobsRequest(input *GetSegmentImportJobsInput) (req *request.Request, output *GetSegmentImportJobsOutput) {
op := &request.Operation{
Name: opGetSegmentImportJobs,
HTTPMethod: "GET",
HTTPPath: "/v1/apps/{application-id}/segments/{segment-id}/jobs/import",
}
if input == nil {
input = &GetSegmentImportJobsInput{}
}
output = &GetSegmentImportJobsOutput{}
req = c.newRequest(op, input, output)
return
}
// GetSegmentImportJobs API operation for Amazon Pinpoint.
//
// Returns a list of import jobs for a specific segment.
//
// Returns awserr.Error for service API and SDK errors. Use runtime type assertions
// with awserr.Error's Code and Message methods to get detailed information about
// the error.
//
// See the AWS API reference guide for Amazon Pinpoint's
// API operation GetSegmentImportJobs for usage and error information.
//
// Returned Error Codes:
// * ErrCodeBadRequestException "BadRequestException"
//
// * ErrCodeInternalServerErrorException "InternalServerErrorException"
//
// * ErrCodeForbiddenException "ForbiddenException"
//
// * ErrCodeNotFoundException "NotFoundException"
//
// * ErrCodeMethodNotAllowedException "MethodNotAllowedException"
//
// * ErrCodeTooManyRequestsException "TooManyRequestsException"
//
// See also, path_to_url
func (c *Pinpoint) GetSegmentImportJobs(input *GetSegmentImportJobsInput) (*GetSegmentImportJobsOutput, error) {
req, out := c.GetSegmentImportJobsRequest(input)
return out, req.Send()
}
// GetSegmentImportJobsWithContext is the same as GetSegmentImportJobs with the addition of
// the ability to pass a context and additional request options.
//
// See GetSegmentImportJobs for details on how to use this API operation.
//
// The context must be non-nil and will be used for request cancellation. If
// the context is nil a panic will occur. In the future the SDK may create
// sub-contexts for http.Requests. See path_to_url
// for more information on using Contexts.
func (c *Pinpoint) GetSegmentImportJobsWithContext(ctx aws.Context, input *GetSegmentImportJobsInput, opts ...request.Option) (*GetSegmentImportJobsOutput, error) {
req, out := c.GetSegmentImportJobsRequest(input)
req.SetContext(ctx)
req.ApplyOptions(opts...)
return out, req.Send()
}
const opGetSegmentVersion = "GetSegmentVersion"
// GetSegmentVersionRequest generates a "aws/request.Request" representing the
// client's request for the GetSegmentVersion operation. The "output" return
// value will be populated with the request's response once the request complets
// successfuly.
//
// Use "Send" method on the returned Request to send the API call to the service.
// the "output" return value is not valid until after Send returns without error.
//
// See GetSegmentVersion for more information on using the GetSegmentVersion
// API call, and error handling.
//
// This method is useful when you want to inject custom logic or configuration
// into the SDK's request lifecycle. Such as custom headers, or retry logic.
//
//
// // Example sending a request using the GetSegmentVersionRequest method.
// req, resp := client.GetSegmentVersionRequest(params)
//
// err := req.Send()
// if err == nil { // resp is now filled
// fmt.Println(resp)
// }
//
// See also, path_to_url
func (c *Pinpoint) GetSegmentVersionRequest(input *GetSegmentVersionInput) (req *request.Request, output *GetSegmentVersionOutput) {
op := &request.Operation{
Name: opGetSegmentVersion,
HTTPMethod: "GET",
HTTPPath: "/v1/apps/{application-id}/segments/{segment-id}/versions/{version}",
}
if input == nil {
input = &GetSegmentVersionInput{}
}
output = &GetSegmentVersionOutput{}
req = c.newRequest(op, input, output)
return
}
// GetSegmentVersion API operation for Amazon Pinpoint.
//
// Returns information about a segment version.
//
// Returns awserr.Error for service API and SDK errors. Use runtime type assertions
// with awserr.Error's Code and Message methods to get detailed information about
// the error.
//
// See the AWS API reference guide for Amazon Pinpoint's
// API operation GetSegmentVersion for usage and error information.
//
// Returned Error Codes:
// * ErrCodeBadRequestException "BadRequestException"
//
// * ErrCodeInternalServerErrorException "InternalServerErrorException"
//
// * ErrCodeForbiddenException "ForbiddenException"
//
// * ErrCodeNotFoundException "NotFoundException"
//
// * ErrCodeMethodNotAllowedException "MethodNotAllowedException"
//
// * ErrCodeTooManyRequestsException "TooManyRequestsException"
//
// See also, path_to_url
func (c *Pinpoint) GetSegmentVersion(input *GetSegmentVersionInput) (*GetSegmentVersionOutput, error) {
req, out := c.GetSegmentVersionRequest(input)
return out, req.Send()
}
// GetSegmentVersionWithContext is the same as GetSegmentVersion with the addition of
// the ability to pass a context and additional request options.
//
// See GetSegmentVersion for details on how to use this API operation.
//
// The context must be non-nil and will be used for request cancellation. If
// the context is nil a panic will occur. In the future the SDK may create
// sub-contexts for http.Requests. See path_to_url
// for more information on using Contexts.
func (c *Pinpoint) GetSegmentVersionWithContext(ctx aws.Context, input *GetSegmentVersionInput, opts ...request.Option) (*GetSegmentVersionOutput, error) {
req, out := c.GetSegmentVersionRequest(input)
req.SetContext(ctx)
req.ApplyOptions(opts...)
return out, req.Send()
}
const opGetSegmentVersions = "GetSegmentVersions"
// GetSegmentVersionsRequest generates a "aws/request.Request" representing the
// client's request for the GetSegmentVersions operation. The "output" return
// value will be populated with the request's response once the request complets
// successfuly.
//
// Use "Send" method on the returned Request to send the API call to the service.
// the "output" return value is not valid until after Send returns without error.
//
// See GetSegmentVersions for more information on using the GetSegmentVersions
// API call, and error handling.
//
// This method is useful when you want to inject custom logic or configuration
// into the SDK's request lifecycle. Such as custom headers, or retry logic.
//
//
// // Example sending a request using the GetSegmentVersionsRequest method.
// req, resp := client.GetSegmentVersionsRequest(params)
//
// err := req.Send()
// if err == nil { // resp is now filled
// fmt.Println(resp)
// }
//
// See also, path_to_url
func (c *Pinpoint) GetSegmentVersionsRequest(input *GetSegmentVersionsInput) (req *request.Request, output *GetSegmentVersionsOutput) {
op := &request.Operation{
Name: opGetSegmentVersions,
HTTPMethod: "GET",
HTTPPath: "/v1/apps/{application-id}/segments/{segment-id}/versions",
}
if input == nil {
input = &GetSegmentVersionsInput{}
}
output = &GetSegmentVersionsOutput{}
req = c.newRequest(op, input, output)
return
}
// GetSegmentVersions API operation for Amazon Pinpoint.
//
// Returns information about your segment versions.
//
// Returns awserr.Error for service API and SDK errors. Use runtime type assertions
// with awserr.Error's Code and Message methods to get detailed information about
// the error.
//
// See the AWS API reference guide for Amazon Pinpoint's
// API operation GetSegmentVersions for usage and error information.
//
// Returned Error Codes:
// * ErrCodeBadRequestException "BadRequestException"
//
// * ErrCodeInternalServerErrorException "InternalServerErrorException"
//
// * ErrCodeForbiddenException "ForbiddenException"
//
// * ErrCodeNotFoundException "NotFoundException"
//
// * ErrCodeMethodNotAllowedException "MethodNotAllowedException"
//
// * ErrCodeTooManyRequestsException "TooManyRequestsException"
//
// See also, path_to_url
func (c *Pinpoint) GetSegmentVersions(input *GetSegmentVersionsInput) (*GetSegmentVersionsOutput, error) {
req, out := c.GetSegmentVersionsRequest(input)
return out, req.Send()
}
// GetSegmentVersionsWithContext is the same as GetSegmentVersions with the addition of
// the ability to pass a context and additional request options.
//
// See GetSegmentVersions for details on how to use this API operation.
//
// The context must be non-nil and will be used for request cancellation. If
// the context is nil a panic will occur. In the future the SDK may create
// sub-contexts for http.Requests. See path_to_url
// for more information on using Contexts.
func (c *Pinpoint) GetSegmentVersionsWithContext(ctx aws.Context, input *GetSegmentVersionsInput, opts ...request.Option) (*GetSegmentVersionsOutput, error) {
req, out := c.GetSegmentVersionsRequest(input)
req.SetContext(ctx)
req.ApplyOptions(opts...)
return out, req.Send()
}
const opGetSegments = "GetSegments"
// GetSegmentsRequest generates a "aws/request.Request" representing the
// client's request for the GetSegments operation. The "output" return
// value will be populated with the request's response once the request complets
// successfuly.
//
// Use "Send" method on the returned Request to send the API call to the service.
// the "output" return value is not valid until after Send returns without error.
//
// See GetSegments for more information on using the GetSegments
// API call, and error handling.
//
// This method is useful when you want to inject custom logic or configuration
// into the SDK's request lifecycle. Such as custom headers, or retry logic.
//
//
// // Example sending a request using the GetSegmentsRequest method.
// req, resp := client.GetSegmentsRequest(params)
//
// err := req.Send()
// if err == nil { // resp is now filled
// fmt.Println(resp)
// }
//
// See also, path_to_url
func (c *Pinpoint) GetSegmentsRequest(input *GetSegmentsInput) (req *request.Request, output *GetSegmentsOutput) {
op := &request.Operation{
Name: opGetSegments,
HTTPMethod: "GET",
HTTPPath: "/v1/apps/{application-id}/segments",
}
if input == nil {
input = &GetSegmentsInput{}
}
output = &GetSegmentsOutput{}
req = c.newRequest(op, input, output)
return
}
// GetSegments API operation for Amazon Pinpoint.
//
// Used to get information about your segments.
//
// Returns awserr.Error for service API and SDK errors. Use runtime type assertions
// with awserr.Error's Code and Message methods to get detailed information about
// the error.
//
// See the AWS API reference guide for Amazon Pinpoint's
// API operation GetSegments for usage and error information.
//
// Returned Error Codes:
// * ErrCodeBadRequestException "BadRequestException"
//
// * ErrCodeInternalServerErrorException "InternalServerErrorException"
//
// * ErrCodeForbiddenException "ForbiddenException"
//
// * ErrCodeNotFoundException "NotFoundException"
//
// * ErrCodeMethodNotAllowedException "MethodNotAllowedException"
//
// * ErrCodeTooManyRequestsException "TooManyRequestsException"
//
// See also, path_to_url
func (c *Pinpoint) GetSegments(input *GetSegmentsInput) (*GetSegmentsOutput, error) {
req, out := c.GetSegmentsRequest(input)
return out, req.Send()
}
// GetSegmentsWithContext is the same as GetSegments with the addition of
// the ability to pass a context and additional request options.
//
// See GetSegments for details on how to use this API operation.
//
// The context must be non-nil and will be used for request cancellation. If
// the context is nil a panic will occur. In the future the SDK may create
// sub-contexts for http.Requests. See path_to_url
// for more information on using Contexts.
func (c *Pinpoint) GetSegmentsWithContext(ctx aws.Context, input *GetSegmentsInput, opts ...request.Option) (*GetSegmentsOutput, error) {
req, out := c.GetSegmentsRequest(input)
req.SetContext(ctx)
req.ApplyOptions(opts...)
return out, req.Send()
}
const opGetSmsChannel = "GetSmsChannel"
// GetSmsChannelRequest generates a "aws/request.Request" representing the
// client's request for the GetSmsChannel operation. The "output" return
// value will be populated with the request's response once the request complets
// successfuly.
//
// Use "Send" method on the returned Request to send the API call to the service.
// the "output" return value is not valid until after Send returns without error.
//
// See GetSmsChannel for more information on using the GetSmsChannel
// API call, and error handling.
//
// This method is useful when you want to inject custom logic or configuration
// into the SDK's request lifecycle. Such as custom headers, or retry logic.
//
//
// // Example sending a request using the GetSmsChannelRequest method.
// req, resp := client.GetSmsChannelRequest(params)
//
// err := req.Send()
// if err == nil { // resp is now filled
// fmt.Println(resp)
// }
//
// See also, path_to_url
func (c *Pinpoint) GetSmsChannelRequest(input *GetSmsChannelInput) (req *request.Request, output *GetSmsChannelOutput) {
op := &request.Operation{
Name: opGetSmsChannel,
HTTPMethod: "GET",
HTTPPath: "/v1/apps/{application-id}/channels/sms",
}
if input == nil {
input = &GetSmsChannelInput{}
}
output = &GetSmsChannelOutput{}
req = c.newRequest(op, input, output)
return
}
// GetSmsChannel API operation for Amazon Pinpoint.
//
// Get an SMS channel
//
// Returns awserr.Error for service API and SDK errors. Use runtime type assertions
// with awserr.Error's Code and Message methods to get detailed information about
// the error.
//
// See the AWS API reference guide for Amazon Pinpoint's
// API operation GetSmsChannel for usage and error information.
//
// Returned Error Codes:
// * ErrCodeBadRequestException "BadRequestException"
//
// * ErrCodeInternalServerErrorException "InternalServerErrorException"
//
// * ErrCodeForbiddenException "ForbiddenException"
//
// * ErrCodeNotFoundException "NotFoundException"
//
// * ErrCodeMethodNotAllowedException "MethodNotAllowedException"
//
// * ErrCodeTooManyRequestsException "TooManyRequestsException"
//
// See also, path_to_url
func (c *Pinpoint) GetSmsChannel(input *GetSmsChannelInput) (*GetSmsChannelOutput, error) {
req, out := c.GetSmsChannelRequest(input)
return out, req.Send()
}
// GetSmsChannelWithContext is the same as GetSmsChannel with the addition of
// the ability to pass a context and additional request options.
//
// See GetSmsChannel for details on how to use this API operation.
//
// The context must be non-nil and will be used for request cancellation. If
// the context is nil a panic will occur. In the future the SDK may create
// sub-contexts for http.Requests. See path_to_url
// for more information on using Contexts.
func (c *Pinpoint) GetSmsChannelWithContext(ctx aws.Context, input *GetSmsChannelInput, opts ...request.Option) (*GetSmsChannelOutput, error) {
req, out := c.GetSmsChannelRequest(input)
req.SetContext(ctx)
req.ApplyOptions(opts...)
return out, req.Send()
}
const opPutEventStream = "PutEventStream"
// PutEventStreamRequest generates a "aws/request.Request" representing the
// client's request for the PutEventStream operation. The "output" return
// value will be populated with the request's response once the request complets
// successfuly.
//
// Use "Send" method on the returned Request to send the API call to the service.
// the "output" return value is not valid until after Send returns without error.
//
// See PutEventStream for more information on using the PutEventStream
// API call, and error handling.
//
// This method is useful when you want to inject custom logic or configuration
// into the SDK's request lifecycle. Such as custom headers, or retry logic.
//
//
// // Example sending a request using the PutEventStreamRequest method.
// req, resp := client.PutEventStreamRequest(params)
//
// err := req.Send()
// if err == nil { // resp is now filled
// fmt.Println(resp)
// }
//
// See also, path_to_url
func (c *Pinpoint) PutEventStreamRequest(input *PutEventStreamInput) (req *request.Request, output *PutEventStreamOutput) {
op := &request.Operation{
Name: opPutEventStream,
HTTPMethod: "POST",
HTTPPath: "/v1/apps/{application-id}/eventstream",
}
if input == nil {
input = &PutEventStreamInput{}
}
output = &PutEventStreamOutput{}
req = c.newRequest(op, input, output)
return
}
// PutEventStream API operation for Amazon Pinpoint.
//
// Use to create or update the event stream for an app.
//
// Returns awserr.Error for service API and SDK errors. Use runtime type assertions
// with awserr.Error's Code and Message methods to get detailed information about
// the error.
//
// See the AWS API reference guide for Amazon Pinpoint's
// API operation PutEventStream for usage and error information.
//
// Returned Error Codes:
// * ErrCodeBadRequestException "BadRequestException"
//
// * ErrCodeInternalServerErrorException "InternalServerErrorException"
//
// * ErrCodeForbiddenException "ForbiddenException"
//
// * ErrCodeNotFoundException "NotFoundException"
//
// * ErrCodeMethodNotAllowedException "MethodNotAllowedException"
//
// * ErrCodeTooManyRequestsException "TooManyRequestsException"
//
// See also, path_to_url
func (c *Pinpoint) PutEventStream(input *PutEventStreamInput) (*PutEventStreamOutput, error) {
req, out := c.PutEventStreamRequest(input)
return out, req.Send()
}
// PutEventStreamWithContext is the same as PutEventStream with the addition of
// the ability to pass a context and additional request options.
//
// See PutEventStream for details on how to use this API operation.
//
// The context must be non-nil and will be used for request cancellation. If
// the context is nil a panic will occur. In the future the SDK may create
// sub-contexts for http.Requests. See path_to_url
// for more information on using Contexts.
func (c *Pinpoint) PutEventStreamWithContext(ctx aws.Context, input *PutEventStreamInput, opts ...request.Option) (*PutEventStreamOutput, error) {
req, out := c.PutEventStreamRequest(input)
req.SetContext(ctx)
req.ApplyOptions(opts...)
return out, req.Send()
}
const opSendMessages = "SendMessages"
// SendMessagesRequest generates a "aws/request.Request" representing the
// client's request for the SendMessages operation. The "output" return
// value will be populated with the request's response once the request complets
// successfuly.
//
// Use "Send" method on the returned Request to send the API call to the service.
// the "output" return value is not valid until after Send returns without error.
//
// See SendMessages for more information on using the SendMessages
// API call, and error handling.
//
// This method is useful when you want to inject custom logic or configuration
// into the SDK's request lifecycle. Such as custom headers, or retry logic.
//
//
// // Example sending a request using the SendMessagesRequest method.
// req, resp := client.SendMessagesRequest(params)
//
// err := req.Send()
// if err == nil { // resp is now filled
// fmt.Println(resp)
// }
//
// See also, path_to_url
func (c *Pinpoint) SendMessagesRequest(input *SendMessagesInput) (req *request.Request, output *SendMessagesOutput) {
op := &request.Operation{
Name: opSendMessages,
HTTPMethod: "POST",
HTTPPath: "/v1/apps/{application-id}/messages",
}
if input == nil {
input = &SendMessagesInput{}
}
output = &SendMessagesOutput{}
req = c.newRequest(op, input, output)
return
}
// SendMessages API operation for Amazon Pinpoint.
//
// Send a batch of messages
//
// Returns awserr.Error for service API and SDK errors. Use runtime type assertions
// with awserr.Error's Code and Message methods to get detailed information about
// the error.
//
// See the AWS API reference guide for Amazon Pinpoint's
// API operation SendMessages for usage and error information.
//
// Returned Error Codes:
// * ErrCodeBadRequestException "BadRequestException"
//
// * ErrCodeInternalServerErrorException "InternalServerErrorException"
//
// * ErrCodeForbiddenException "ForbiddenException"
//
// * ErrCodeNotFoundException "NotFoundException"
//
// * ErrCodeMethodNotAllowedException "MethodNotAllowedException"
//
// * ErrCodeTooManyRequestsException "TooManyRequestsException"
//
// See also, path_to_url
func (c *Pinpoint) SendMessages(input *SendMessagesInput) (*SendMessagesOutput, error) {
req, out := c.SendMessagesRequest(input)
return out, req.Send()
}
// SendMessagesWithContext is the same as SendMessages with the addition of
// the ability to pass a context and additional request options.
//
// See SendMessages for details on how to use this API operation.
//
// The context must be non-nil and will be used for request cancellation. If
// the context is nil a panic will occur. In the future the SDK may create
// sub-contexts for http.Requests. See path_to_url
// for more information on using Contexts.
func (c *Pinpoint) SendMessagesWithContext(ctx aws.Context, input *SendMessagesInput, opts ...request.Option) (*SendMessagesOutput, error) {
req, out := c.SendMessagesRequest(input)
req.SetContext(ctx)
req.ApplyOptions(opts...)
return out, req.Send()
}
const opSendUsersMessages = "SendUsersMessages"
// SendUsersMessagesRequest generates a "aws/request.Request" representing the
// client's request for the SendUsersMessages operation. The "output" return
// value will be populated with the request's response once the request complets
// successfuly.
//
// Use "Send" method on the returned Request to send the API call to the service.
// the "output" return value is not valid until after Send returns without error.
//
// See SendUsersMessages for more information on using the SendUsersMessages
// API call, and error handling.
//
// This method is useful when you want to inject custom logic or configuration
// into the SDK's request lifecycle. Such as custom headers, or retry logic.
//
//
// // Example sending a request using the SendUsersMessagesRequest method.
// req, resp := client.SendUsersMessagesRequest(params)
//
// err := req.Send()
// if err == nil { // resp is now filled
// fmt.Println(resp)
// }
//
// See also, path_to_url
func (c *Pinpoint) SendUsersMessagesRequest(input *SendUsersMessagesInput) (req *request.Request, output *SendUsersMessagesOutput) {
op := &request.Operation{
Name: opSendUsersMessages,
HTTPMethod: "POST",
HTTPPath: "/v1/apps/{application-id}/users-messages",
}
if input == nil {
input = &SendUsersMessagesInput{}
}
output = &SendUsersMessagesOutput{}
req = c.newRequest(op, input, output)
return
}
// SendUsersMessages API operation for Amazon Pinpoint.
//
// Send a batch of messages to users
//
// Returns awserr.Error for service API and SDK errors. Use runtime type assertions
// with awserr.Error's Code and Message methods to get detailed information about
// the error.
//
// See the AWS API reference guide for Amazon Pinpoint's
// API operation SendUsersMessages for usage and error information.
//
// Returned Error Codes:
// * ErrCodeBadRequestException "BadRequestException"
//
// * ErrCodeInternalServerErrorException "InternalServerErrorException"
//
// * ErrCodeForbiddenException "ForbiddenException"
//
// * ErrCodeNotFoundException "NotFoundException"
//
// * ErrCodeMethodNotAllowedException "MethodNotAllowedException"
//
// * ErrCodeTooManyRequestsException "TooManyRequestsException"
//
// See also, path_to_url
func (c *Pinpoint) SendUsersMessages(input *SendUsersMessagesInput) (*SendUsersMessagesOutput, error) {
req, out := c.SendUsersMessagesRequest(input)
return out, req.Send()
}
// SendUsersMessagesWithContext is the same as SendUsersMessages with the addition of
// the ability to pass a context and additional request options.
//
// See SendUsersMessages for details on how to use this API operation.
//
// The context must be non-nil and will be used for request cancellation. If
// the context is nil a panic will occur. In the future the SDK may create
// sub-contexts for http.Requests. See path_to_url
// for more information on using Contexts.
func (c *Pinpoint) SendUsersMessagesWithContext(ctx aws.Context, input *SendUsersMessagesInput, opts ...request.Option) (*SendUsersMessagesOutput, error) {
req, out := c.SendUsersMessagesRequest(input)
req.SetContext(ctx)
req.ApplyOptions(opts...)
return out, req.Send()
}
const opUpdateAdmChannel = "UpdateAdmChannel"
// UpdateAdmChannelRequest generates a "aws/request.Request" representing the
// client's request for the UpdateAdmChannel operation. The "output" return
// value will be populated with the request's response once the request complets
// successfuly.
//
// Use "Send" method on the returned Request to send the API call to the service.
// the "output" return value is not valid until after Send returns without error.
//
// See UpdateAdmChannel for more information on using the UpdateAdmChannel
// API call, and error handling.
//
// This method is useful when you want to inject custom logic or configuration
// into the SDK's request lifecycle. Such as custom headers, or retry logic.
//
//
// // Example sending a request using the UpdateAdmChannelRequest method.
// req, resp := client.UpdateAdmChannelRequest(params)
//
// err := req.Send()
// if err == nil { // resp is now filled
// fmt.Println(resp)
// }
//
// See also, path_to_url
func (c *Pinpoint) UpdateAdmChannelRequest(input *UpdateAdmChannelInput) (req *request.Request, output *UpdateAdmChannelOutput) {
op := &request.Operation{
Name: opUpdateAdmChannel,
HTTPMethod: "PUT",
HTTPPath: "/v1/apps/{application-id}/channels/adm",
}
if input == nil {
input = &UpdateAdmChannelInput{}
}
output = &UpdateAdmChannelOutput{}
req = c.newRequest(op, input, output)
return
}
// UpdateAdmChannel API operation for Amazon Pinpoint.
//
// Update an ADM channel
//
// Returns awserr.Error for service API and SDK errors. Use runtime type assertions
// with awserr.Error's Code and Message methods to get detailed information about
// the error.
//
// See the AWS API reference guide for Amazon Pinpoint's
// API operation UpdateAdmChannel for usage and error information.
//
// Returned Error Codes:
// * ErrCodeBadRequestException "BadRequestException"
//
// * ErrCodeInternalServerErrorException "InternalServerErrorException"
//
// * ErrCodeForbiddenException "ForbiddenException"
//
// * ErrCodeNotFoundException "NotFoundException"
//
// * ErrCodeMethodNotAllowedException "MethodNotAllowedException"
//
// * ErrCodeTooManyRequestsException "TooManyRequestsException"
//
// See also, path_to_url
func (c *Pinpoint) UpdateAdmChannel(input *UpdateAdmChannelInput) (*UpdateAdmChannelOutput, error) {
req, out := c.UpdateAdmChannelRequest(input)
return out, req.Send()
}
// UpdateAdmChannelWithContext is the same as UpdateAdmChannel with the addition of
// the ability to pass a context and additional request options.
//
// See UpdateAdmChannel for details on how to use this API operation.
//
// The context must be non-nil and will be used for request cancellation. If
// the context is nil a panic will occur. In the future the SDK may create
// sub-contexts for http.Requests. See path_to_url
// for more information on using Contexts.
func (c *Pinpoint) UpdateAdmChannelWithContext(ctx aws.Context, input *UpdateAdmChannelInput, opts ...request.Option) (*UpdateAdmChannelOutput, error) {
req, out := c.UpdateAdmChannelRequest(input)
req.SetContext(ctx)
req.ApplyOptions(opts...)
return out, req.Send()
}
const opUpdateApnsChannel = "UpdateApnsChannel"
// UpdateApnsChannelRequest generates a "aws/request.Request" representing the
// client's request for the UpdateApnsChannel operation. The "output" return
// value will be populated with the request's response once the request complets
// successfuly.
//
// Use "Send" method on the returned Request to send the API call to the service.
// the "output" return value is not valid until after Send returns without error.
//
// See UpdateApnsChannel for more information on using the UpdateApnsChannel
// API call, and error handling.
//
// This method is useful when you want to inject custom logic or configuration
// into the SDK's request lifecycle. Such as custom headers, or retry logic.
//
//
// // Example sending a request using the UpdateApnsChannelRequest method.
// req, resp := client.UpdateApnsChannelRequest(params)
//
// err := req.Send()
// if err == nil { // resp is now filled
// fmt.Println(resp)
// }
//
// See also, path_to_url
func (c *Pinpoint) UpdateApnsChannelRequest(input *UpdateApnsChannelInput) (req *request.Request, output *UpdateApnsChannelOutput) {
op := &request.Operation{
Name: opUpdateApnsChannel,
HTTPMethod: "PUT",
HTTPPath: "/v1/apps/{application-id}/channels/apns",
}
if input == nil {
input = &UpdateApnsChannelInput{}
}
output = &UpdateApnsChannelOutput{}
req = c.newRequest(op, input, output)
return
}
// UpdateApnsChannel API operation for Amazon Pinpoint.
//
// Use to update the APNs channel for an app.
//
// Returns awserr.Error for service API and SDK errors. Use runtime type assertions
// with awserr.Error's Code and Message methods to get detailed information about
// the error.
//
// See the AWS API reference guide for Amazon Pinpoint's
// API operation UpdateApnsChannel for usage and error information.
//
// Returned Error Codes:
// * ErrCodeBadRequestException "BadRequestException"
//
// * ErrCodeInternalServerErrorException "InternalServerErrorException"
//
// * ErrCodeForbiddenException "ForbiddenException"
//
// * ErrCodeNotFoundException "NotFoundException"
//
// * ErrCodeMethodNotAllowedException "MethodNotAllowedException"
//
// * ErrCodeTooManyRequestsException "TooManyRequestsException"
//
// See also, path_to_url
func (c *Pinpoint) UpdateApnsChannel(input *UpdateApnsChannelInput) (*UpdateApnsChannelOutput, error) {
req, out := c.UpdateApnsChannelRequest(input)
return out, req.Send()
}
// UpdateApnsChannelWithContext is the same as UpdateApnsChannel with the addition of
// the ability to pass a context and additional request options.
//
// See UpdateApnsChannel for details on how to use this API operation.
//
// The context must be non-nil and will be used for request cancellation. If
// the context is nil a panic will occur. In the future the SDK may create
// sub-contexts for http.Requests. See path_to_url
// for more information on using Contexts.
func (c *Pinpoint) UpdateApnsChannelWithContext(ctx aws.Context, input *UpdateApnsChannelInput, opts ...request.Option) (*UpdateApnsChannelOutput, error) {
req, out := c.UpdateApnsChannelRequest(input)
req.SetContext(ctx)
req.ApplyOptions(opts...)
return out, req.Send()
}
const opUpdateApnsSandboxChannel = "UpdateApnsSandboxChannel"
// UpdateApnsSandboxChannelRequest generates a "aws/request.Request" representing the
// client's request for the UpdateApnsSandboxChannel operation. The "output" return
// value will be populated with the request's response once the request complets
// successfuly.
//
// Use "Send" method on the returned Request to send the API call to the service.
// the "output" return value is not valid until after Send returns without error.
//
// See UpdateApnsSandboxChannel for more information on using the UpdateApnsSandboxChannel
// API call, and error handling.
//
// This method is useful when you want to inject custom logic or configuration
// into the SDK's request lifecycle. Such as custom headers, or retry logic.
//
//
// // Example sending a request using the UpdateApnsSandboxChannelRequest method.
// req, resp := client.UpdateApnsSandboxChannelRequest(params)
//
// err := req.Send()
// if err == nil { // resp is now filled
// fmt.Println(resp)
// }
//
// See also, path_to_url
func (c *Pinpoint) UpdateApnsSandboxChannelRequest(input *UpdateApnsSandboxChannelInput) (req *request.Request, output *UpdateApnsSandboxChannelOutput) {
op := &request.Operation{
Name: opUpdateApnsSandboxChannel,
HTTPMethod: "PUT",
HTTPPath: "/v1/apps/{application-id}/channels/apns_sandbox",
}
if input == nil {
input = &UpdateApnsSandboxChannelInput{}
}
output = &UpdateApnsSandboxChannelOutput{}
req = c.newRequest(op, input, output)
return
}
// UpdateApnsSandboxChannel API operation for Amazon Pinpoint.
//
// Update an APNS sandbox channel
//
// Returns awserr.Error for service API and SDK errors. Use runtime type assertions
// with awserr.Error's Code and Message methods to get detailed information about
// the error.
//
// See the AWS API reference guide for Amazon Pinpoint's
// API operation UpdateApnsSandboxChannel for usage and error information.
//
// Returned Error Codes:
// * ErrCodeBadRequestException "BadRequestException"
//
// * ErrCodeInternalServerErrorException "InternalServerErrorException"
//
// * ErrCodeForbiddenException "ForbiddenException"
//
// * ErrCodeNotFoundException "NotFoundException"
//
// * ErrCodeMethodNotAllowedException "MethodNotAllowedException"
//
// * ErrCodeTooManyRequestsException "TooManyRequestsException"
//
// See also, path_to_url
func (c *Pinpoint) UpdateApnsSandboxChannel(input *UpdateApnsSandboxChannelInput) (*UpdateApnsSandboxChannelOutput, error) {
req, out := c.UpdateApnsSandboxChannelRequest(input)
return out, req.Send()
}
// UpdateApnsSandboxChannelWithContext is the same as UpdateApnsSandboxChannel with the addition of
// the ability to pass a context and additional request options.
//
// See UpdateApnsSandboxChannel for details on how to use this API operation.
//
// The context must be non-nil and will be used for request cancellation. If
// the context is nil a panic will occur. In the future the SDK may create
// sub-contexts for http.Requests. See path_to_url
// for more information on using Contexts.
func (c *Pinpoint) UpdateApnsSandboxChannelWithContext(ctx aws.Context, input *UpdateApnsSandboxChannelInput, opts ...request.Option) (*UpdateApnsSandboxChannelOutput, error) {
req, out := c.UpdateApnsSandboxChannelRequest(input)
req.SetContext(ctx)
req.ApplyOptions(opts...)
return out, req.Send()
}
const opUpdateApnsVoipChannel = "UpdateApnsVoipChannel"
// UpdateApnsVoipChannelRequest generates a "aws/request.Request" representing the
// client's request for the UpdateApnsVoipChannel operation. The "output" return
// value will be populated with the request's response once the request complets
// successfuly.
//
// Use "Send" method on the returned Request to send the API call to the service.
// the "output" return value is not valid until after Send returns without error.
//
// See UpdateApnsVoipChannel for more information on using the UpdateApnsVoipChannel
// API call, and error handling.
//
// This method is useful when you want to inject custom logic or configuration
// into the SDK's request lifecycle. Such as custom headers, or retry logic.
//
//
// // Example sending a request using the UpdateApnsVoipChannelRequest method.
// req, resp := client.UpdateApnsVoipChannelRequest(params)
//
// err := req.Send()
// if err == nil { // resp is now filled
// fmt.Println(resp)
// }
//
// See also, path_to_url
func (c *Pinpoint) UpdateApnsVoipChannelRequest(input *UpdateApnsVoipChannelInput) (req *request.Request, output *UpdateApnsVoipChannelOutput) {
op := &request.Operation{
Name: opUpdateApnsVoipChannel,
HTTPMethod: "PUT",
HTTPPath: "/v1/apps/{application-id}/channels/apns_voip",
}
if input == nil {
input = &UpdateApnsVoipChannelInput{}
}
output = &UpdateApnsVoipChannelOutput{}
req = c.newRequest(op, input, output)
return
}
// UpdateApnsVoipChannel API operation for Amazon Pinpoint.
//
// Update an APNS VOIP channel
//
// Returns awserr.Error for service API and SDK errors. Use runtime type assertions
// with awserr.Error's Code and Message methods to get detailed information about
// the error.
//
// See the AWS API reference guide for Amazon Pinpoint's
// API operation UpdateApnsVoipChannel for usage and error information.
//
// Returned Error Codes:
// * ErrCodeBadRequestException "BadRequestException"
//
// * ErrCodeInternalServerErrorException "InternalServerErrorException"
//
// * ErrCodeForbiddenException "ForbiddenException"
//
// * ErrCodeNotFoundException "NotFoundException"
//
// * ErrCodeMethodNotAllowedException "MethodNotAllowedException"
//
// * ErrCodeTooManyRequestsException "TooManyRequestsException"
//
// See also, path_to_url
func (c *Pinpoint) UpdateApnsVoipChannel(input *UpdateApnsVoipChannelInput) (*UpdateApnsVoipChannelOutput, error) {
req, out := c.UpdateApnsVoipChannelRequest(input)
return out, req.Send()
}
// UpdateApnsVoipChannelWithContext is the same as UpdateApnsVoipChannel with the addition of
// the ability to pass a context and additional request options.
//
// See UpdateApnsVoipChannel for details on how to use this API operation.
//
// The context must be non-nil and will be used for request cancellation. If
// the context is nil a panic will occur. In the future the SDK may create
// sub-contexts for http.Requests. See path_to_url
// for more information on using Contexts.
func (c *Pinpoint) UpdateApnsVoipChannelWithContext(ctx aws.Context, input *UpdateApnsVoipChannelInput, opts ...request.Option) (*UpdateApnsVoipChannelOutput, error) {
req, out := c.UpdateApnsVoipChannelRequest(input)
req.SetContext(ctx)
req.ApplyOptions(opts...)
return out, req.Send()
}
const opUpdateApnsVoipSandboxChannel = "UpdateApnsVoipSandboxChannel"
// UpdateApnsVoipSandboxChannelRequest generates a "aws/request.Request" representing the
// client's request for the UpdateApnsVoipSandboxChannel operation. The "output" return
// value will be populated with the request's response once the request complets
// successfuly.
//
// Use "Send" method on the returned Request to send the API call to the service.
// the "output" return value is not valid until after Send returns without error.
//
// See UpdateApnsVoipSandboxChannel for more information on using the UpdateApnsVoipSandboxChannel
// API call, and error handling.
//
// This method is useful when you want to inject custom logic or configuration
// into the SDK's request lifecycle. Such as custom headers, or retry logic.
//
//
// // Example sending a request using the UpdateApnsVoipSandboxChannelRequest method.
// req, resp := client.UpdateApnsVoipSandboxChannelRequest(params)
//
// err := req.Send()
// if err == nil { // resp is now filled
// fmt.Println(resp)
// }
//
// See also, path_to_url
func (c *Pinpoint) UpdateApnsVoipSandboxChannelRequest(input *UpdateApnsVoipSandboxChannelInput) (req *request.Request, output *UpdateApnsVoipSandboxChannelOutput) {
op := &request.Operation{
Name: opUpdateApnsVoipSandboxChannel,
HTTPMethod: "PUT",
HTTPPath: "/v1/apps/{application-id}/channels/apns_voip_sandbox",
}
if input == nil {
input = &UpdateApnsVoipSandboxChannelInput{}
}
output = &UpdateApnsVoipSandboxChannelOutput{}
req = c.newRequest(op, input, output)
return
}
// UpdateApnsVoipSandboxChannel API operation for Amazon Pinpoint.
//
// Update an APNS VOIP sandbox channel
//
// Returns awserr.Error for service API and SDK errors. Use runtime type assertions
// with awserr.Error's Code and Message methods to get detailed information about
// the error.
//
// See the AWS API reference guide for Amazon Pinpoint's
// API operation UpdateApnsVoipSandboxChannel for usage and error information.
//
// Returned Error Codes:
// * ErrCodeBadRequestException "BadRequestException"
//
// * ErrCodeInternalServerErrorException "InternalServerErrorException"
//
// * ErrCodeForbiddenException "ForbiddenException"
//
// * ErrCodeNotFoundException "NotFoundException"
//
// * ErrCodeMethodNotAllowedException "MethodNotAllowedException"
//
// * ErrCodeTooManyRequestsException "TooManyRequestsException"
//
// See also, path_to_url
func (c *Pinpoint) UpdateApnsVoipSandboxChannel(input *UpdateApnsVoipSandboxChannelInput) (*UpdateApnsVoipSandboxChannelOutput, error) {
req, out := c.UpdateApnsVoipSandboxChannelRequest(input)
return out, req.Send()
}
// UpdateApnsVoipSandboxChannelWithContext is the same as UpdateApnsVoipSandboxChannel with the addition of
// the ability to pass a context and additional request options.
//
// See UpdateApnsVoipSandboxChannel for details on how to use this API operation.
//
// The context must be non-nil and will be used for request cancellation. If
// the context is nil a panic will occur. In the future the SDK may create
// sub-contexts for http.Requests. See path_to_url
// for more information on using Contexts.
func (c *Pinpoint) UpdateApnsVoipSandboxChannelWithContext(ctx aws.Context, input *UpdateApnsVoipSandboxChannelInput, opts ...request.Option) (*UpdateApnsVoipSandboxChannelOutput, error) {
req, out := c.UpdateApnsVoipSandboxChannelRequest(input)
req.SetContext(ctx)
req.ApplyOptions(opts...)
return out, req.Send()
}
const opUpdateApplicationSettings = "UpdateApplicationSettings"
// UpdateApplicationSettingsRequest generates a "aws/request.Request" representing the
// client's request for the UpdateApplicationSettings operation. The "output" return
// value will be populated with the request's response once the request complets
// successfuly.
//
// Use "Send" method on the returned Request to send the API call to the service.
// the "output" return value is not valid until after Send returns without error.
//
// See UpdateApplicationSettings for more information on using the UpdateApplicationSettings
// API call, and error handling.
//
// This method is useful when you want to inject custom logic or configuration
// into the SDK's request lifecycle. Such as custom headers, or retry logic.
//
//
// // Example sending a request using the UpdateApplicationSettingsRequest method.
// req, resp := client.UpdateApplicationSettingsRequest(params)
//
// err := req.Send()
// if err == nil { // resp is now filled
// fmt.Println(resp)
// }
//
// See also, path_to_url
func (c *Pinpoint) UpdateApplicationSettingsRequest(input *UpdateApplicationSettingsInput) (req *request.Request, output *UpdateApplicationSettingsOutput) {
op := &request.Operation{
Name: opUpdateApplicationSettings,
HTTPMethod: "PUT",
HTTPPath: "/v1/apps/{application-id}/settings",
}
if input == nil {
input = &UpdateApplicationSettingsInput{}
}
output = &UpdateApplicationSettingsOutput{}
req = c.newRequest(op, input, output)
return
}
// UpdateApplicationSettings API operation for Amazon Pinpoint.
//
// Used to update the settings for an app.
//
// Returns awserr.Error for service API and SDK errors. Use runtime type assertions
// with awserr.Error's Code and Message methods to get detailed information about
// the error.
//
// See the AWS API reference guide for Amazon Pinpoint's
// API operation UpdateApplicationSettings for usage and error information.
//
// Returned Error Codes:
// * ErrCodeBadRequestException "BadRequestException"
//
// * ErrCodeInternalServerErrorException "InternalServerErrorException"
//
// * ErrCodeForbiddenException "ForbiddenException"
//
// * ErrCodeNotFoundException "NotFoundException"
//
// * ErrCodeMethodNotAllowedException "MethodNotAllowedException"
//
// * ErrCodeTooManyRequestsException "TooManyRequestsException"
//
// See also, path_to_url
func (c *Pinpoint) UpdateApplicationSettings(input *UpdateApplicationSettingsInput) (*UpdateApplicationSettingsOutput, error) {
req, out := c.UpdateApplicationSettingsRequest(input)
return out, req.Send()
}
// UpdateApplicationSettingsWithContext is the same as UpdateApplicationSettings with the addition of
// the ability to pass a context and additional request options.
//
// See UpdateApplicationSettings for details on how to use this API operation.
//
// The context must be non-nil and will be used for request cancellation. If
// the context is nil a panic will occur. In the future the SDK may create
// sub-contexts for http.Requests. See path_to_url
// for more information on using Contexts.
func (c *Pinpoint) UpdateApplicationSettingsWithContext(ctx aws.Context, input *UpdateApplicationSettingsInput, opts ...request.Option) (*UpdateApplicationSettingsOutput, error) {
req, out := c.UpdateApplicationSettingsRequest(input)
req.SetContext(ctx)
req.ApplyOptions(opts...)
return out, req.Send()
}
const opUpdateBaiduChannel = "UpdateBaiduChannel"
// UpdateBaiduChannelRequest generates a "aws/request.Request" representing the
// client's request for the UpdateBaiduChannel operation. The "output" return
// value will be populated with the request's response once the request complets
// successfuly.
//
// Use "Send" method on the returned Request to send the API call to the service.
// the "output" return value is not valid until after Send returns without error.
//
// See UpdateBaiduChannel for more information on using the UpdateBaiduChannel
// API call, and error handling.
//
// This method is useful when you want to inject custom logic or configuration
// into the SDK's request lifecycle. Such as custom headers, or retry logic.
//
//
// // Example sending a request using the UpdateBaiduChannelRequest method.
// req, resp := client.UpdateBaiduChannelRequest(params)
//
// err := req.Send()
// if err == nil { // resp is now filled
// fmt.Println(resp)
// }
//
// See also, path_to_url
func (c *Pinpoint) UpdateBaiduChannelRequest(input *UpdateBaiduChannelInput) (req *request.Request, output *UpdateBaiduChannelOutput) {
op := &request.Operation{
Name: opUpdateBaiduChannel,
HTTPMethod: "PUT",
HTTPPath: "/v1/apps/{application-id}/channels/baidu",
}
if input == nil {
input = &UpdateBaiduChannelInput{}
}
output = &UpdateBaiduChannelOutput{}
req = c.newRequest(op, input, output)
return
}
// UpdateBaiduChannel API operation for Amazon Pinpoint.
//
// Update a BAIDU GCM channel
//
// Returns awserr.Error for service API and SDK errors. Use runtime type assertions
// with awserr.Error's Code and Message methods to get detailed information about
// the error.
//
// See the AWS API reference guide for Amazon Pinpoint's
// API operation UpdateBaiduChannel for usage and error information.
//
// Returned Error Codes:
// * ErrCodeBadRequestException "BadRequestException"
//
// * ErrCodeInternalServerErrorException "InternalServerErrorException"
//
// * ErrCodeForbiddenException "ForbiddenException"
//
// * ErrCodeNotFoundException "NotFoundException"
//
// * ErrCodeMethodNotAllowedException "MethodNotAllowedException"
//
// * ErrCodeTooManyRequestsException "TooManyRequestsException"
//
// See also, path_to_url
func (c *Pinpoint) UpdateBaiduChannel(input *UpdateBaiduChannelInput) (*UpdateBaiduChannelOutput, error) {
req, out := c.UpdateBaiduChannelRequest(input)
return out, req.Send()
}
// UpdateBaiduChannelWithContext is the same as UpdateBaiduChannel with the addition of
// the ability to pass a context and additional request options.
//
// See UpdateBaiduChannel for details on how to use this API operation.
//
// The context must be non-nil and will be used for request cancellation. If
// the context is nil a panic will occur. In the future the SDK may create
// sub-contexts for http.Requests. See path_to_url
// for more information on using Contexts.
func (c *Pinpoint) UpdateBaiduChannelWithContext(ctx aws.Context, input *UpdateBaiduChannelInput, opts ...request.Option) (*UpdateBaiduChannelOutput, error) {
req, out := c.UpdateBaiduChannelRequest(input)
req.SetContext(ctx)
req.ApplyOptions(opts...)
return out, req.Send()
}
const opUpdateCampaign = "UpdateCampaign"
// UpdateCampaignRequest generates a "aws/request.Request" representing the
// client's request for the UpdateCampaign operation. The "output" return
// value will be populated with the request's response once the request complets
// successfuly.
//
// Use "Send" method on the returned Request to send the API call to the service.
// the "output" return value is not valid until after Send returns without error.
//
// See UpdateCampaign for more information on using the UpdateCampaign
// API call, and error handling.
//
// This method is useful when you want to inject custom logic or configuration
// into the SDK's request lifecycle. Such as custom headers, or retry logic.
//
//
// // Example sending a request using the UpdateCampaignRequest method.
// req, resp := client.UpdateCampaignRequest(params)
//
// err := req.Send()
// if err == nil { // resp is now filled
// fmt.Println(resp)
// }
//
// See also, path_to_url
func (c *Pinpoint) UpdateCampaignRequest(input *UpdateCampaignInput) (req *request.Request, output *UpdateCampaignOutput) {
op := &request.Operation{
Name: opUpdateCampaign,
HTTPMethod: "PUT",
HTTPPath: "/v1/apps/{application-id}/campaigns/{campaign-id}",
}
if input == nil {
input = &UpdateCampaignInput{}
}
output = &UpdateCampaignOutput{}
req = c.newRequest(op, input, output)
return
}
// UpdateCampaign API operation for Amazon Pinpoint.
//
// Use to update a campaign.
//
// Returns awserr.Error for service API and SDK errors. Use runtime type assertions
// with awserr.Error's Code and Message methods to get detailed information about
// the error.
//
// See the AWS API reference guide for Amazon Pinpoint's
// API operation UpdateCampaign for usage and error information.
//
// Returned Error Codes:
// * ErrCodeBadRequestException "BadRequestException"
//
// * ErrCodeInternalServerErrorException "InternalServerErrorException"
//
// * ErrCodeForbiddenException "ForbiddenException"
//
// * ErrCodeNotFoundException "NotFoundException"
//
// * ErrCodeMethodNotAllowedException "MethodNotAllowedException"
//
// * ErrCodeTooManyRequestsException "TooManyRequestsException"
//
// See also, path_to_url
func (c *Pinpoint) UpdateCampaign(input *UpdateCampaignInput) (*UpdateCampaignOutput, error) {
req, out := c.UpdateCampaignRequest(input)
return out, req.Send()
}
// UpdateCampaignWithContext is the same as UpdateCampaign with the addition of
// the ability to pass a context and additional request options.
//
// See UpdateCampaign for details on how to use this API operation.
//
// The context must be non-nil and will be used for request cancellation. If
// the context is nil a panic will occur. In the future the SDK may create
// sub-contexts for http.Requests. See path_to_url
// for more information on using Contexts.
func (c *Pinpoint) UpdateCampaignWithContext(ctx aws.Context, input *UpdateCampaignInput, opts ...request.Option) (*UpdateCampaignOutput, error) {
req, out := c.UpdateCampaignRequest(input)
req.SetContext(ctx)
req.ApplyOptions(opts...)
return out, req.Send()
}
const opUpdateEmailChannel = "UpdateEmailChannel"
// UpdateEmailChannelRequest generates a "aws/request.Request" representing the
// client's request for the UpdateEmailChannel operation. The "output" return
// value will be populated with the request's response once the request complets
// successfuly.
//
// Use "Send" method on the returned Request to send the API call to the service.
// the "output" return value is not valid until after Send returns without error.
//
// See UpdateEmailChannel for more information on using the UpdateEmailChannel
// API call, and error handling.
//
// This method is useful when you want to inject custom logic or configuration
// into the SDK's request lifecycle. Such as custom headers, or retry logic.
//
//
// // Example sending a request using the UpdateEmailChannelRequest method.
// req, resp := client.UpdateEmailChannelRequest(params)
//
// err := req.Send()
// if err == nil { // resp is now filled
// fmt.Println(resp)
// }
//
// See also, path_to_url
func (c *Pinpoint) UpdateEmailChannelRequest(input *UpdateEmailChannelInput) (req *request.Request, output *UpdateEmailChannelOutput) {
op := &request.Operation{
Name: opUpdateEmailChannel,
HTTPMethod: "PUT",
HTTPPath: "/v1/apps/{application-id}/channels/email",
}
if input == nil {
input = &UpdateEmailChannelInput{}
}
output = &UpdateEmailChannelOutput{}
req = c.newRequest(op, input, output)
return
}
// UpdateEmailChannel API operation for Amazon Pinpoint.
//
// Update an email channel
//
// Returns awserr.Error for service API and SDK errors. Use runtime type assertions
// with awserr.Error's Code and Message methods to get detailed information about
// the error.
//
// See the AWS API reference guide for Amazon Pinpoint's
// API operation UpdateEmailChannel for usage and error information.
//
// Returned Error Codes:
// * ErrCodeBadRequestException "BadRequestException"
//
// * ErrCodeInternalServerErrorException "InternalServerErrorException"
//
// * ErrCodeForbiddenException "ForbiddenException"
//
// * ErrCodeNotFoundException "NotFoundException"
//
// * ErrCodeMethodNotAllowedException "MethodNotAllowedException"
//
// * ErrCodeTooManyRequestsException "TooManyRequestsException"
//
// See also, path_to_url
func (c *Pinpoint) UpdateEmailChannel(input *UpdateEmailChannelInput) (*UpdateEmailChannelOutput, error) {
req, out := c.UpdateEmailChannelRequest(input)
return out, req.Send()
}
// UpdateEmailChannelWithContext is the same as UpdateEmailChannel with the addition of
// the ability to pass a context and additional request options.
//
// See UpdateEmailChannel for details on how to use this API operation.
//
// The context must be non-nil and will be used for request cancellation. If
// the context is nil a panic will occur. In the future the SDK may create
// sub-contexts for http.Requests. See path_to_url
// for more information on using Contexts.
func (c *Pinpoint) UpdateEmailChannelWithContext(ctx aws.Context, input *UpdateEmailChannelInput, opts ...request.Option) (*UpdateEmailChannelOutput, error) {
req, out := c.UpdateEmailChannelRequest(input)
req.SetContext(ctx)
req.ApplyOptions(opts...)
return out, req.Send()
}
const opUpdateEndpoint = "UpdateEndpoint"
// UpdateEndpointRequest generates a "aws/request.Request" representing the
// client's request for the UpdateEndpoint operation. The "output" return
// value will be populated with the request's response once the request complets
// successfuly.
//
// Use "Send" method on the returned Request to send the API call to the service.
// the "output" return value is not valid until after Send returns without error.
//
// See UpdateEndpoint for more information on using the UpdateEndpoint
// API call, and error handling.
//
// This method is useful when you want to inject custom logic or configuration
// into the SDK's request lifecycle. Such as custom headers, or retry logic.
//
//
// // Example sending a request using the UpdateEndpointRequest method.
// req, resp := client.UpdateEndpointRequest(params)
//
// err := req.Send()
// if err == nil { // resp is now filled
// fmt.Println(resp)
// }
//
// See also, path_to_url
func (c *Pinpoint) UpdateEndpointRequest(input *UpdateEndpointInput) (req *request.Request, output *UpdateEndpointOutput) {
op := &request.Operation{
Name: opUpdateEndpoint,
HTTPMethod: "PUT",
HTTPPath: "/v1/apps/{application-id}/endpoints/{endpoint-id}",
}
if input == nil {
input = &UpdateEndpointInput{}
}
output = &UpdateEndpointOutput{}
req = c.newRequest(op, input, output)
return
}
// UpdateEndpoint API operation for Amazon Pinpoint.
//
// Use to update an endpoint.
//
// Returns awserr.Error for service API and SDK errors. Use runtime type assertions
// with awserr.Error's Code and Message methods to get detailed information about
// the error.
//
// See the AWS API reference guide for Amazon Pinpoint's
// API operation UpdateEndpoint for usage and error information.
//
// Returned Error Codes:
// * ErrCodeBadRequestException "BadRequestException"
//
// * ErrCodeInternalServerErrorException "InternalServerErrorException"
//
// * ErrCodeForbiddenException "ForbiddenException"
//
// * ErrCodeNotFoundException "NotFoundException"
//
// * ErrCodeMethodNotAllowedException "MethodNotAllowedException"
//
// * ErrCodeTooManyRequestsException "TooManyRequestsException"
//
// See also, path_to_url
func (c *Pinpoint) UpdateEndpoint(input *UpdateEndpointInput) (*UpdateEndpointOutput, error) {
req, out := c.UpdateEndpointRequest(input)
return out, req.Send()
}
// UpdateEndpointWithContext is the same as UpdateEndpoint with the addition of
// the ability to pass a context and additional request options.
//
// See UpdateEndpoint for details on how to use this API operation.
//
// The context must be non-nil and will be used for request cancellation. If
// the context is nil a panic will occur. In the future the SDK may create
// sub-contexts for http.Requests. See path_to_url
// for more information on using Contexts.
func (c *Pinpoint) UpdateEndpointWithContext(ctx aws.Context, input *UpdateEndpointInput, opts ...request.Option) (*UpdateEndpointOutput, error) {
req, out := c.UpdateEndpointRequest(input)
req.SetContext(ctx)
req.ApplyOptions(opts...)
return out, req.Send()
}
const opUpdateEndpointsBatch = "UpdateEndpointsBatch"
// UpdateEndpointsBatchRequest generates a "aws/request.Request" representing the
// client's request for the UpdateEndpointsBatch operation. The "output" return
// value will be populated with the request's response once the request complets
// successfuly.
//
// Use "Send" method on the returned Request to send the API call to the service.
// the "output" return value is not valid until after Send returns without error.
//
// See UpdateEndpointsBatch for more information on using the UpdateEndpointsBatch
// API call, and error handling.
//
// This method is useful when you want to inject custom logic or configuration
// into the SDK's request lifecycle. Such as custom headers, or retry logic.
//
//
// // Example sending a request using the UpdateEndpointsBatchRequest method.
// req, resp := client.UpdateEndpointsBatchRequest(params)
//
// err := req.Send()
// if err == nil { // resp is now filled
// fmt.Println(resp)
// }
//
// See also, path_to_url
func (c *Pinpoint) UpdateEndpointsBatchRequest(input *UpdateEndpointsBatchInput) (req *request.Request, output *UpdateEndpointsBatchOutput) {
op := &request.Operation{
Name: opUpdateEndpointsBatch,
HTTPMethod: "PUT",
HTTPPath: "/v1/apps/{application-id}/endpoints",
}
if input == nil {
input = &UpdateEndpointsBatchInput{}
}
output = &UpdateEndpointsBatchOutput{}
req = c.newRequest(op, input, output)
return
}
// UpdateEndpointsBatch API operation for Amazon Pinpoint.
//
// Use to update a batch of endpoints.
//
// Returns awserr.Error for service API and SDK errors. Use runtime type assertions
// with awserr.Error's Code and Message methods to get detailed information about
// the error.
//
// See the AWS API reference guide for Amazon Pinpoint's
// API operation UpdateEndpointsBatch for usage and error information.
//
// Returned Error Codes:
// * ErrCodeBadRequestException "BadRequestException"
//
// * ErrCodeInternalServerErrorException "InternalServerErrorException"
//
// * ErrCodeForbiddenException "ForbiddenException"
//
// * ErrCodeNotFoundException "NotFoundException"
//
// * ErrCodeMethodNotAllowedException "MethodNotAllowedException"
//
// * ErrCodeTooManyRequestsException "TooManyRequestsException"
//
// See also, path_to_url
func (c *Pinpoint) UpdateEndpointsBatch(input *UpdateEndpointsBatchInput) (*UpdateEndpointsBatchOutput, error) {
req, out := c.UpdateEndpointsBatchRequest(input)
return out, req.Send()
}
// UpdateEndpointsBatchWithContext is the same as UpdateEndpointsBatch with the addition of
// the ability to pass a context and additional request options.
//
// See UpdateEndpointsBatch for details on how to use this API operation.
//
// The context must be non-nil and will be used for request cancellation. If
// the context is nil a panic will occur. In the future the SDK may create
// sub-contexts for http.Requests. See path_to_url
// for more information on using Contexts.
func (c *Pinpoint) UpdateEndpointsBatchWithContext(ctx aws.Context, input *UpdateEndpointsBatchInput, opts ...request.Option) (*UpdateEndpointsBatchOutput, error) {
req, out := c.UpdateEndpointsBatchRequest(input)
req.SetContext(ctx)
req.ApplyOptions(opts...)
return out, req.Send()
}
const opUpdateGcmChannel = "UpdateGcmChannel"
// UpdateGcmChannelRequest generates a "aws/request.Request" representing the
// client's request for the UpdateGcmChannel operation. The "output" return
// value will be populated with the request's response once the request complets
// successfuly.
//
// Use "Send" method on the returned Request to send the API call to the service.
// the "output" return value is not valid until after Send returns without error.
//
// See UpdateGcmChannel for more information on using the UpdateGcmChannel
// API call, and error handling.
//
// This method is useful when you want to inject custom logic or configuration
// into the SDK's request lifecycle. Such as custom headers, or retry logic.
//
//
// // Example sending a request using the UpdateGcmChannelRequest method.
// req, resp := client.UpdateGcmChannelRequest(params)
//
// err := req.Send()
// if err == nil { // resp is now filled
// fmt.Println(resp)
// }
//
// See also, path_to_url
func (c *Pinpoint) UpdateGcmChannelRequest(input *UpdateGcmChannelInput) (req *request.Request, output *UpdateGcmChannelOutput) {
op := &request.Operation{
Name: opUpdateGcmChannel,
HTTPMethod: "PUT",
HTTPPath: "/v1/apps/{application-id}/channels/gcm",
}
if input == nil {
input = &UpdateGcmChannelInput{}
}
output = &UpdateGcmChannelOutput{}
req = c.newRequest(op, input, output)
return
}
// UpdateGcmChannel API operation for Amazon Pinpoint.
//
// Use to update the GCM channel for an app.
//
// Returns awserr.Error for service API and SDK errors. Use runtime type assertions
// with awserr.Error's Code and Message methods to get detailed information about
// the error.
//
// See the AWS API reference guide for Amazon Pinpoint's
// API operation UpdateGcmChannel for usage and error information.
//
// Returned Error Codes:
// * ErrCodeBadRequestException "BadRequestException"
//
// * ErrCodeInternalServerErrorException "InternalServerErrorException"
//
// * ErrCodeForbiddenException "ForbiddenException"
//
// * ErrCodeNotFoundException "NotFoundException"
//
// * ErrCodeMethodNotAllowedException "MethodNotAllowedException"
//
// * ErrCodeTooManyRequestsException "TooManyRequestsException"
//
// See also, path_to_url
func (c *Pinpoint) UpdateGcmChannel(input *UpdateGcmChannelInput) (*UpdateGcmChannelOutput, error) {
req, out := c.UpdateGcmChannelRequest(input)
return out, req.Send()
}
// UpdateGcmChannelWithContext is the same as UpdateGcmChannel with the addition of
// the ability to pass a context and additional request options.
//
// See UpdateGcmChannel for details on how to use this API operation.
//
// The context must be non-nil and will be used for request cancellation. If
// the context is nil a panic will occur. In the future the SDK may create
// sub-contexts for http.Requests. See path_to_url
// for more information on using Contexts.
func (c *Pinpoint) UpdateGcmChannelWithContext(ctx aws.Context, input *UpdateGcmChannelInput, opts ...request.Option) (*UpdateGcmChannelOutput, error) {
req, out := c.UpdateGcmChannelRequest(input)
req.SetContext(ctx)
req.ApplyOptions(opts...)
return out, req.Send()
}
const opUpdateSegment = "UpdateSegment"
// UpdateSegmentRequest generates a "aws/request.Request" representing the
// client's request for the UpdateSegment operation. The "output" return
// value will be populated with the request's response once the request complets
// successfuly.
//
// Use "Send" method on the returned Request to send the API call to the service.
// the "output" return value is not valid until after Send returns without error.
//
// See UpdateSegment for more information on using the UpdateSegment
// API call, and error handling.
//
// This method is useful when you want to inject custom logic or configuration
// into the SDK's request lifecycle. Such as custom headers, or retry logic.
//
//
// // Example sending a request using the UpdateSegmentRequest method.
// req, resp := client.UpdateSegmentRequest(params)
//
// err := req.Send()
// if err == nil { // resp is now filled
// fmt.Println(resp)
// }
//
// See also, path_to_url
func (c *Pinpoint) UpdateSegmentRequest(input *UpdateSegmentInput) (req *request.Request, output *UpdateSegmentOutput) {
op := &request.Operation{
Name: opUpdateSegment,
HTTPMethod: "PUT",
HTTPPath: "/v1/apps/{application-id}/segments/{segment-id}",
}
if input == nil {
input = &UpdateSegmentInput{}
}
output = &UpdateSegmentOutput{}
req = c.newRequest(op, input, output)
return
}
// UpdateSegment API operation for Amazon Pinpoint.
//
// Use to update a segment.
//
// Returns awserr.Error for service API and SDK errors. Use runtime type assertions
// with awserr.Error's Code and Message methods to get detailed information about
// the error.
//
// See the AWS API reference guide for Amazon Pinpoint's
// API operation UpdateSegment for usage and error information.
//
// Returned Error Codes:
// * ErrCodeBadRequestException "BadRequestException"
//
// * ErrCodeInternalServerErrorException "InternalServerErrorException"
//
// * ErrCodeForbiddenException "ForbiddenException"
//
// * ErrCodeNotFoundException "NotFoundException"
//
// * ErrCodeMethodNotAllowedException "MethodNotAllowedException"
//
// * ErrCodeTooManyRequestsException "TooManyRequestsException"
//
// See also, path_to_url
func (c *Pinpoint) UpdateSegment(input *UpdateSegmentInput) (*UpdateSegmentOutput, error) {
req, out := c.UpdateSegmentRequest(input)
return out, req.Send()
}
// UpdateSegmentWithContext is the same as UpdateSegment with the addition of
// the ability to pass a context and additional request options.
//
// See UpdateSegment for details on how to use this API operation.
//
// The context must be non-nil and will be used for request cancellation. If
// the context is nil a panic will occur. In the future the SDK may create
// sub-contexts for http.Requests. See path_to_url
// for more information on using Contexts.
func (c *Pinpoint) UpdateSegmentWithContext(ctx aws.Context, input *UpdateSegmentInput, opts ...request.Option) (*UpdateSegmentOutput, error) {
req, out := c.UpdateSegmentRequest(input)
req.SetContext(ctx)
req.ApplyOptions(opts...)
return out, req.Send()
}
const opUpdateSmsChannel = "UpdateSmsChannel"
// UpdateSmsChannelRequest generates a "aws/request.Request" representing the
// client's request for the UpdateSmsChannel operation. The "output" return
// value will be populated with the request's response once the request complets
// successfuly.
//
// Use "Send" method on the returned Request to send the API call to the service.
// the "output" return value is not valid until after Send returns without error.
//
// See UpdateSmsChannel for more information on using the UpdateSmsChannel
// API call, and error handling.
//
// This method is useful when you want to inject custom logic or configuration
// into the SDK's request lifecycle. Such as custom headers, or retry logic.
//
//
// // Example sending a request using the UpdateSmsChannelRequest method.
// req, resp := client.UpdateSmsChannelRequest(params)
//
// err := req.Send()
// if err == nil { // resp is now filled
// fmt.Println(resp)
// }
//
// See also, path_to_url
func (c *Pinpoint) UpdateSmsChannelRequest(input *UpdateSmsChannelInput) (req *request.Request, output *UpdateSmsChannelOutput) {
op := &request.Operation{
Name: opUpdateSmsChannel,
HTTPMethod: "PUT",
HTTPPath: "/v1/apps/{application-id}/channels/sms",
}
if input == nil {
input = &UpdateSmsChannelInput{}
}
output = &UpdateSmsChannelOutput{}
req = c.newRequest(op, input, output)
return
}
// UpdateSmsChannel API operation for Amazon Pinpoint.
//
// Update an SMS channel
//
// Returns awserr.Error for service API and SDK errors. Use runtime type assertions
// with awserr.Error's Code and Message methods to get detailed information about
// the error.
//
// See the AWS API reference guide for Amazon Pinpoint's
// API operation UpdateSmsChannel for usage and error information.
//
// Returned Error Codes:
// * ErrCodeBadRequestException "BadRequestException"
//
// * ErrCodeInternalServerErrorException "InternalServerErrorException"
//
// * ErrCodeForbiddenException "ForbiddenException"
//
// * ErrCodeNotFoundException "NotFoundException"
//
// * ErrCodeMethodNotAllowedException "MethodNotAllowedException"
//
// * ErrCodeTooManyRequestsException "TooManyRequestsException"
//
// See also, path_to_url
func (c *Pinpoint) UpdateSmsChannel(input *UpdateSmsChannelInput) (*UpdateSmsChannelOutput, error) {
req, out := c.UpdateSmsChannelRequest(input)
return out, req.Send()
}
// UpdateSmsChannelWithContext is the same as UpdateSmsChannel with the addition of
// the ability to pass a context and additional request options.
//
// See UpdateSmsChannel for details on how to use this API operation.
//
// The context must be non-nil and will be used for request cancellation. If
// the context is nil a panic will occur. In the future the SDK may create
// sub-contexts for http.Requests. See path_to_url
// for more information on using Contexts.
func (c *Pinpoint) UpdateSmsChannelWithContext(ctx aws.Context, input *UpdateSmsChannelInput, opts ...request.Option) (*UpdateSmsChannelOutput, error) {
req, out := c.UpdateSmsChannelRequest(input)
req.SetContext(ctx)
req.ApplyOptions(opts...)
return out, req.Send()
}
// Amazon Device Messaging channel definition.
// See also, path_to_url
type ADMChannelRequest struct {
_ struct{} `type:"structure"`
// Client ID as gotten from Amazon
ClientId *string `type:"string"`
// Client secret as gotten from Amazon
ClientSecret *string `type:"string"`
// If the channel is enabled for sending messages.
Enabled *bool `type:"boolean"`
}
// String returns the string representation
func (s ADMChannelRequest) String() string {
return awsutil.Prettify(s)
}
// GoString returns the string representation
func (s ADMChannelRequest) GoString() string {
return s.String()
}
// SetClientId sets the ClientId field's value.
func (s *ADMChannelRequest) SetClientId(v string) *ADMChannelRequest {
s.ClientId = &v
return s
}
// SetClientSecret sets the ClientSecret field's value.
func (s *ADMChannelRequest) SetClientSecret(v string) *ADMChannelRequest {
s.ClientSecret = &v
return s
}
// SetEnabled sets the Enabled field's value.
func (s *ADMChannelRequest) SetEnabled(v bool) *ADMChannelRequest {
s.Enabled = &v
return s
}
// Amazon Device Messaging channel definition.
// See also, path_to_url
type ADMChannelResponse struct {
_ struct{} `type:"structure"`
// Application id
ApplicationId *string `type:"string"`
// When was this segment created
CreationDate *string `type:"string"`
// If the channel is enabled for sending messages.
Enabled *bool `type:"boolean"`
// If the channel is registered with a credential for authentication.
HasCredential *bool `type:"boolean"`
// Channel ID. Not used, only for backwards compatibility.
Id *string `type:"string"`
// Is this channel archived
IsArchived *bool `type:"boolean"`
// Who last updated this entry
LastModifiedBy *string `type:"string"`
// Last date this was updated
LastModifiedDate *string `type:"string"`
// Platform type. Will be "ADM"
Platform *string `type:"string"`
// Version of channel
Version *int64 `type:"integer"`
}
// String returns the string representation
func (s ADMChannelResponse) String() string {
return awsutil.Prettify(s)
}
// GoString returns the string representation
func (s ADMChannelResponse) GoString() string {
return s.String()
}
// SetApplicationId sets the ApplicationId field's value.
func (s *ADMChannelResponse) SetApplicationId(v string) *ADMChannelResponse {
s.ApplicationId = &v
return s
}
// SetCreationDate sets the CreationDate field's value.
func (s *ADMChannelResponse) SetCreationDate(v string) *ADMChannelResponse {
s.CreationDate = &v
return s
}
// SetEnabled sets the Enabled field's value.
func (s *ADMChannelResponse) SetEnabled(v bool) *ADMChannelResponse {
s.Enabled = &v
return s
}
// SetHasCredential sets the HasCredential field's value.
func (s *ADMChannelResponse) SetHasCredential(v bool) *ADMChannelResponse {
s.HasCredential = &v
return s
}
// SetId sets the Id field's value.
func (s *ADMChannelResponse) SetId(v string) *ADMChannelResponse {
s.Id = &v
return s
}
// SetIsArchived sets the IsArchived field's value.
func (s *ADMChannelResponse) SetIsArchived(v bool) *ADMChannelResponse {
s.IsArchived = &v
return s
}
// SetLastModifiedBy sets the LastModifiedBy field's value.
func (s *ADMChannelResponse) SetLastModifiedBy(v string) *ADMChannelResponse {
s.LastModifiedBy = &v
return s
}
// SetLastModifiedDate sets the LastModifiedDate field's value.
func (s *ADMChannelResponse) SetLastModifiedDate(v string) *ADMChannelResponse {
s.LastModifiedDate = &v
return s
}
// SetPlatform sets the Platform field's value.
func (s *ADMChannelResponse) SetPlatform(v string) *ADMChannelResponse {
s.Platform = &v
return s
}
// SetVersion sets the Version field's value.
func (s *ADMChannelResponse) SetVersion(v int64) *ADMChannelResponse {
s.Version = &v
return s
}
// ADM Message.
// See also, path_to_url
type ADMMessage struct {
_ struct{} `type:"structure"`
// The action that occurs if the user taps a push notification delivered by
// the campaign: OPEN_APP - Your app launches, or it becomes the foreground
// app if it has been sent to the background. This is the default action. DEEP_LINK
// - Uses deep linking features in iOS and Android to open your app and display
// a designated user interface within the app. URL - The default mobile browser
// on the user's device launches and opens a web page at the URL you specify.
// Possible values include: OPEN_APP | DEEP_LINK | URL
Action *string `type:"string" enum:"Action"`
// The message body of the notification, the email body or the text message.
Body *string `type:"string"`
// Optional. Arbitrary string used to indicate multiple messages are logically
// the same and that ADM is allowed to drop previously enqueued messages in
// favor of this one.
ConsolidationKey *string `type:"string"`
Data map[string]*string `type:"map"`
// Optional. Number of seconds ADM should retain the message if the device is
// offline
ExpiresAfter *string `type:"string"`
// The icon image name of the asset saved in your application.
IconReference *string `type:"string"`
// The URL that points to an image used as the large icon to the notification
// content view.
ImageIconUrl *string `type:"string"`
// The URL that points to an image used in the push notification.
ImageUrl *string `type:"string"`
// Optional. Base-64-encoded MD5 checksum of the data parameter. Used to verify
// data integrity
MD5 *string `type:"string"`
// The Raw JSON formatted string to be used as the payload. This value overrides
// the message.
RawContent *string `type:"string"`
// Indicates if the message should display on the users device. Silent pushes
// can be used for Remote Configuration and Phone Home use cases.
SilentPush *bool `type:"boolean"`
// The URL that points to an image used as the small icon for the notification
// which will be used to represent the notification in the status bar and content
// view
SmallImageIconUrl *string `type:"string"`
// Indicates a sound to play when the device receives the notification. Supports
// default, or the filename of a sound resource bundled in the app. Android
// sound files must reside in /res/raw/
Sound *string `type:"string"`
Substitutions map[string][]*string `type:"map"`
// The message title that displays above the message on the user's device.
Title *string `type:"string"`
// The URL to open in the user's mobile browser. Used if the value for Action
// is URL.
Url *string `type:"string"`
}
// String returns the string representation
func (s ADMMessage) String() string {
return awsutil.Prettify(s)
}
// GoString returns the string representation
func (s ADMMessage) GoString() string {
return s.String()
}
// SetAction sets the Action field's value.
func (s *ADMMessage) SetAction(v string) *ADMMessage {
s.Action = &v
return s
}
// SetBody sets the Body field's value.
func (s *ADMMessage) SetBody(v string) *ADMMessage {
s.Body = &v
return s
}
// SetConsolidationKey sets the ConsolidationKey field's value.
func (s *ADMMessage) SetConsolidationKey(v string) *ADMMessage {
s.ConsolidationKey = &v
return s
}
// SetData sets the Data field's value.
func (s *ADMMessage) SetData(v map[string]*string) *ADMMessage {
s.Data = v
return s
}
// SetExpiresAfter sets the ExpiresAfter field's value.
func (s *ADMMessage) SetExpiresAfter(v string) *ADMMessage {
s.ExpiresAfter = &v
return s
}
// SetIconReference sets the IconReference field's value.
func (s *ADMMessage) SetIconReference(v string) *ADMMessage {
s.IconReference = &v
return s
}
// SetImageIconUrl sets the ImageIconUrl field's value.
func (s *ADMMessage) SetImageIconUrl(v string) *ADMMessage {
s.ImageIconUrl = &v
return s
}
// SetImageUrl sets the ImageUrl field's value.
func (s *ADMMessage) SetImageUrl(v string) *ADMMessage {
s.ImageUrl = &v
return s
}
// SetMD5 sets the MD5 field's value.
func (s *ADMMessage) SetMD5(v string) *ADMMessage {
s.MD5 = &v
return s
}
// SetRawContent sets the RawContent field's value.
func (s *ADMMessage) SetRawContent(v string) *ADMMessage {
s.RawContent = &v
return s
}
// SetSilentPush sets the SilentPush field's value.
func (s *ADMMessage) SetSilentPush(v bool) *ADMMessage {
s.SilentPush = &v
return s
}
// SetSmallImageIconUrl sets the SmallImageIconUrl field's value.
func (s *ADMMessage) SetSmallImageIconUrl(v string) *ADMMessage {
s.SmallImageIconUrl = &v
return s
}
// SetSound sets the Sound field's value.
func (s *ADMMessage) SetSound(v string) *ADMMessage {
s.Sound = &v
return s
}
// SetSubstitutions sets the Substitutions field's value.
func (s *ADMMessage) SetSubstitutions(v map[string][]*string) *ADMMessage {
s.Substitutions = v
return s
}
// SetTitle sets the Title field's value.
func (s *ADMMessage) SetTitle(v string) *ADMMessage {
s.Title = &v
return s
}
// SetUrl sets the Url field's value.
func (s *ADMMessage) SetUrl(v string) *ADMMessage {
s.Url = &v
return s
}
// Apple Push Notification Service channel definition.
// See also, path_to_url
type APNSChannelRequest struct {
_ struct{} `type:"structure"`
// The bundle id used for APNs Tokens.
BundleId *string `type:"string"`
// The distribution certificate from Apple.
Certificate *string `type:"string"`
// The default authentication method used for APNs.
DefaultAuthenticationMethod *string `type:"string"`
// If the channel is enabled for sending messages.
Enabled *bool `type:"boolean"`
// The certificate private key.
PrivateKey *string `type:"string"`
// The team id used for APNs Tokens.
TeamId *string `type:"string"`
// The token key used for APNs Tokens.
TokenKey *string `type:"string"`
// The token key used for APNs Tokens.
TokenKeyId *string `type:"string"`
}
// String returns the string representation
func (s APNSChannelRequest) String() string {
return awsutil.Prettify(s)
}
// GoString returns the string representation
func (s APNSChannelRequest) GoString() string {
return s.String()
}
// SetBundleId sets the BundleId field's value.
func (s *APNSChannelRequest) SetBundleId(v string) *APNSChannelRequest {
s.BundleId = &v
return s
}
// SetCertificate sets the Certificate field's value.
func (s *APNSChannelRequest) SetCertificate(v string) *APNSChannelRequest {
s.Certificate = &v
return s
}
// SetDefaultAuthenticationMethod sets the DefaultAuthenticationMethod field's value.
func (s *APNSChannelRequest) SetDefaultAuthenticationMethod(v string) *APNSChannelRequest {
s.DefaultAuthenticationMethod = &v
return s
}
// SetEnabled sets the Enabled field's value.
func (s *APNSChannelRequest) SetEnabled(v bool) *APNSChannelRequest {
s.Enabled = &v
return s
}
// SetPrivateKey sets the PrivateKey field's value.
func (s *APNSChannelRequest) SetPrivateKey(v string) *APNSChannelRequest {
s.PrivateKey = &v
return s
}
// SetTeamId sets the TeamId field's value.
func (s *APNSChannelRequest) SetTeamId(v string) *APNSChannelRequest {
s.TeamId = &v
return s
}
// SetTokenKey sets the TokenKey field's value.
func (s *APNSChannelRequest) SetTokenKey(v string) *APNSChannelRequest {
s.TokenKey = &v
return s
}
// SetTokenKeyId sets the TokenKeyId field's value.
func (s *APNSChannelRequest) SetTokenKeyId(v string) *APNSChannelRequest {
s.TokenKeyId = &v
return s
}
// Apple Distribution Push Notification Service channel definition.
// See also, path_to_url
type APNSChannelResponse struct {
_ struct{} `type:"structure"`
// The ID of the application to which the channel applies.
ApplicationId *string `type:"string"`
// When was this segment created
CreationDate *string `type:"string"`
// The default authentication method used for APNs.
DefaultAuthenticationMethod *string `type:"string"`
// If the channel is enabled for sending messages.
Enabled *bool `type:"boolean"`
// If the channel is registered with a credential for authentication.
HasCredential *bool `type:"boolean"`
// If the channel is registered with a token key for authentication.
HasTokenKey *bool `type:"boolean"`
// Channel ID. Not used. Present only for backwards compatibility.
Id *string `type:"string"`
// Is this channel archived
IsArchived *bool `type:"boolean"`
// Who last updated this entry
LastModifiedBy *string `type:"string"`
// Last date this was updated
LastModifiedDate *string `type:"string"`
// The platform type. Will be APNS.
Platform *string `type:"string"`
// Version of channel
Version *int64 `type:"integer"`
}
// String returns the string representation
func (s APNSChannelResponse) String() string {
return awsutil.Prettify(s)
}
// GoString returns the string representation
func (s APNSChannelResponse) GoString() string {
return s.String()
}
// SetApplicationId sets the ApplicationId field's value.
func (s *APNSChannelResponse) SetApplicationId(v string) *APNSChannelResponse {
s.ApplicationId = &v
return s
}
// SetCreationDate sets the CreationDate field's value.
func (s *APNSChannelResponse) SetCreationDate(v string) *APNSChannelResponse {
s.CreationDate = &v
return s
}
// SetDefaultAuthenticationMethod sets the DefaultAuthenticationMethod field's value.
func (s *APNSChannelResponse) SetDefaultAuthenticationMethod(v string) *APNSChannelResponse {
s.DefaultAuthenticationMethod = &v
return s
}
// SetEnabled sets the Enabled field's value.
func (s *APNSChannelResponse) SetEnabled(v bool) *APNSChannelResponse {
s.Enabled = &v
return s
}
// SetHasCredential sets the HasCredential field's value.
func (s *APNSChannelResponse) SetHasCredential(v bool) *APNSChannelResponse {
s.HasCredential = &v
return s
}
// SetHasTokenKey sets the HasTokenKey field's value.
func (s *APNSChannelResponse) SetHasTokenKey(v bool) *APNSChannelResponse {
s.HasTokenKey = &v
return s
}
// SetId sets the Id field's value.
func (s *APNSChannelResponse) SetId(v string) *APNSChannelResponse {
s.Id = &v
return s
}
// SetIsArchived sets the IsArchived field's value.
func (s *APNSChannelResponse) SetIsArchived(v bool) *APNSChannelResponse {
s.IsArchived = &v
return s
}
// SetLastModifiedBy sets the LastModifiedBy field's value.
func (s *APNSChannelResponse) SetLastModifiedBy(v string) *APNSChannelResponse {
s.LastModifiedBy = &v
return s
}
// SetLastModifiedDate sets the LastModifiedDate field's value.
func (s *APNSChannelResponse) SetLastModifiedDate(v string) *APNSChannelResponse {
s.LastModifiedDate = &v
return s
}
// SetPlatform sets the Platform field's value.
func (s *APNSChannelResponse) SetPlatform(v string) *APNSChannelResponse {
s.Platform = &v
return s
}
// SetVersion sets the Version field's value.
func (s *APNSChannelResponse) SetVersion(v int64) *APNSChannelResponse {
s.Version = &v
return s
}
// APNS Message.
// See also, path_to_url
type APNSMessage struct {
_ struct{} `type:"structure"`
// The action that occurs if the user taps a push notification delivered by
// the campaign: OPEN_APP - Your app launches, or it becomes the foreground
// app if it has been sent to the background. This is the default action. DEEP_LINK
// - Uses deep linking features in iOS and Android to open your app and display
// a designated user interface within the app. URL - The default mobile browser
// on the user's device launches and opens a web page at the URL you specify.
// Possible values include: OPEN_APP | DEEP_LINK | URL
Action *string `type:"string" enum:"Action"`
// Include this key when you want the system to modify the badge of your app
// icon. If this key is not included in the dictionary, the badge is not changed.
// To remove the badge, set the value of this key to 0.
Badge *int64 `type:"integer"`
// The message body of the notification, the email body or the text message.
Body *string `type:"string"`
// Provide this key with a string value that represents the notification's type.
// This value corresponds to the value in the identifier property of one of
// your app's registered categories.
Category *string `type:"string"`
// Multiple notifications with the same collapse identifier are displayed to
// the user as a single notification. The value of this key must not exceed
// 64 bytes.
CollapseId *string `type:"string"`
Data map[string]*string `type:"map"`
// The URL that points to a video used in the push notification.
MediaUrl *string `type:"string"`
// The preferred authentication method, either "CERTIFICATE" or "TOKEN"
PreferredAuthenticationMethod *string `type:"string"`
// Is this a transaction priority message or lower priority.
Priority *string `type:"string"`
// The Raw JSON formatted string to be used as the payload. This value overrides
// the message.
RawContent *string `type:"string"`
// Indicates if the message should display on the users device. Silent pushes
// can be used for Remote Configuration and Phone Home use cases.
SilentPush *bool `type:"boolean"`
// Include this key when you want the system to play a sound. The value of this
// key is the name of a sound file in your app's main bundle or in the Library/Sounds
// folder of your app's data container. If the sound file cannot be found, or
// if you specify defaultfor the value, the system plays the default alert sound.
Sound *string `type:"string"`
Substitutions map[string][]*string `type:"map"`
// Provide this key with a string value that represents the app-specific identifier
// for grouping notifications. If you provide a Notification Content app extension,
// you can use this value to group your notifications together.
ThreadId *string `type:"string"`
// This parameter specifies how long (in seconds) the message should be kept
// if APNS is unable to deliver the notification the first time. If the value
// is 0, APNS treats the notification as if it expires immediately and does
// not store the notification or attempt to redeliver it. This value is converted
// to the expiration field when sent to APNS
TimeToLive *int64 `type:"integer"`
// The message title that displays above the message on the user's device.
Title *string `type:"string"`
// The URL to open in the user's mobile browser. Used if the value for Action
// is URL.
Url *string `type:"string"`
}
// String returns the string representation
func (s APNSMessage) String() string {
return awsutil.Prettify(s)
}
// GoString returns the string representation
func (s APNSMessage) GoString() string {
return s.String()
}
// SetAction sets the Action field's value.
func (s *APNSMessage) SetAction(v string) *APNSMessage {
s.Action = &v
return s
}
// SetBadge sets the Badge field's value.
func (s *APNSMessage) SetBadge(v int64) *APNSMessage {
s.Badge = &v
return s
}
// SetBody sets the Body field's value.
func (s *APNSMessage) SetBody(v string) *APNSMessage {
s.Body = &v
return s
}
// SetCategory sets the Category field's value.
func (s *APNSMessage) SetCategory(v string) *APNSMessage {
s.Category = &v
return s
}
// SetCollapseId sets the CollapseId field's value.
func (s *APNSMessage) SetCollapseId(v string) *APNSMessage {
s.CollapseId = &v
return s
}
// SetData sets the Data field's value.
func (s *APNSMessage) SetData(v map[string]*string) *APNSMessage {
s.Data = v
return s
}
// SetMediaUrl sets the MediaUrl field's value.
func (s *APNSMessage) SetMediaUrl(v string) *APNSMessage {
s.MediaUrl = &v
return s
}
// SetPreferredAuthenticationMethod sets the PreferredAuthenticationMethod field's value.
func (s *APNSMessage) SetPreferredAuthenticationMethod(v string) *APNSMessage {
s.PreferredAuthenticationMethod = &v
return s
}
// SetPriority sets the Priority field's value.
func (s *APNSMessage) SetPriority(v string) *APNSMessage {
s.Priority = &v
return s
}
// SetRawContent sets the RawContent field's value.
func (s *APNSMessage) SetRawContent(v string) *APNSMessage {
s.RawContent = &v
return s
}
// SetSilentPush sets the SilentPush field's value.
func (s *APNSMessage) SetSilentPush(v bool) *APNSMessage {
s.SilentPush = &v
return s
}
// SetSound sets the Sound field's value.
func (s *APNSMessage) SetSound(v string) *APNSMessage {
s.Sound = &v
return s
}
// SetSubstitutions sets the Substitutions field's value.
func (s *APNSMessage) SetSubstitutions(v map[string][]*string) *APNSMessage {
s.Substitutions = v
return s
}
// SetThreadId sets the ThreadId field's value.
func (s *APNSMessage) SetThreadId(v string) *APNSMessage {
s.ThreadId = &v
return s
}
// SetTimeToLive sets the TimeToLive field's value.
func (s *APNSMessage) SetTimeToLive(v int64) *APNSMessage {
s.TimeToLive = &v
return s
}
// SetTitle sets the Title field's value.
func (s *APNSMessage) SetTitle(v string) *APNSMessage {
s.Title = &v
return s
}
// SetUrl sets the Url field's value.
func (s *APNSMessage) SetUrl(v string) *APNSMessage {
s.Url = &v
return s
}
// Apple Development Push Notification Service channel definition.
// See also, path_to_url
type APNSSandboxChannelRequest struct {
_ struct{} `type:"structure"`
// The bundle id used for APNs Tokens.
BundleId *string `type:"string"`
// The distribution certificate from Apple.
Certificate *string `type:"string"`
// The default authentication method used for APNs.
DefaultAuthenticationMethod *string `type:"string"`
// If the channel is enabled for sending messages.
Enabled *bool `type:"boolean"`
// The certificate private key.
PrivateKey *string `type:"string"`
// The team id used for APNs Tokens.
TeamId *string `type:"string"`
// The token key used for APNs Tokens.
TokenKey *string `type:"string"`
// The token key used for APNs Tokens.
TokenKeyId *string `type:"string"`
}
// String returns the string representation
func (s APNSSandboxChannelRequest) String() string {
return awsutil.Prettify(s)
}
// GoString returns the string representation
func (s APNSSandboxChannelRequest) GoString() string {
return s.String()
}
// SetBundleId sets the BundleId field's value.
func (s *APNSSandboxChannelRequest) SetBundleId(v string) *APNSSandboxChannelRequest {
s.BundleId = &v
return s
}
// SetCertificate sets the Certificate field's value.
func (s *APNSSandboxChannelRequest) SetCertificate(v string) *APNSSandboxChannelRequest {
s.Certificate = &v
return s
}
// SetDefaultAuthenticationMethod sets the DefaultAuthenticationMethod field's value.
func (s *APNSSandboxChannelRequest) SetDefaultAuthenticationMethod(v string) *APNSSandboxChannelRequest {
s.DefaultAuthenticationMethod = &v
return s
}
// SetEnabled sets the Enabled field's value.
func (s *APNSSandboxChannelRequest) SetEnabled(v bool) *APNSSandboxChannelRequest {
s.Enabled = &v
return s
}
// SetPrivateKey sets the PrivateKey field's value.
func (s *APNSSandboxChannelRequest) SetPrivateKey(v string) *APNSSandboxChannelRequest {
s.PrivateKey = &v
return s
}
// SetTeamId sets the TeamId field's value.
func (s *APNSSandboxChannelRequest) SetTeamId(v string) *APNSSandboxChannelRequest {
s.TeamId = &v
return s
}
// SetTokenKey sets the TokenKey field's value.
func (s *APNSSandboxChannelRequest) SetTokenKey(v string) *APNSSandboxChannelRequest {
s.TokenKey = &v
return s
}
// SetTokenKeyId sets the TokenKeyId field's value.
func (s *APNSSandboxChannelRequest) SetTokenKeyId(v string) *APNSSandboxChannelRequest {
s.TokenKeyId = &v
return s
}
// Apple Development Push Notification Service channel definition.
// See also, path_to_url
type APNSSandboxChannelResponse struct {
_ struct{} `type:"structure"`
// Application id
ApplicationId *string `type:"string"`
// When was this segment created
CreationDate *string `type:"string"`
// The default authentication method used for APNs.
DefaultAuthenticationMethod *string `type:"string"`
// If the channel is enabled for sending messages.
Enabled *bool `type:"boolean"`
// If the channel is registered with a credential for authentication.
HasCredential *bool `type:"boolean"`
// If the channel is registered with a token key for authentication.
HasTokenKey *bool `type:"boolean"`
// Channel ID. Not used, only for backwards compatibility.
Id *string `type:"string"`
// Is this channel archived
IsArchived *bool `type:"boolean"`
// Who last updated this entry
LastModifiedBy *string `type:"string"`
// Last date this was updated
LastModifiedDate *string `type:"string"`
// The platform type. Will be APNS_SANDBOX.
Platform *string `type:"string"`
// Version of channel
Version *int64 `type:"integer"`
}
// String returns the string representation
func (s APNSSandboxChannelResponse) String() string {
return awsutil.Prettify(s)
}
// GoString returns the string representation
func (s APNSSandboxChannelResponse) GoString() string {
return s.String()
}
// SetApplicationId sets the ApplicationId field's value.
func (s *APNSSandboxChannelResponse) SetApplicationId(v string) *APNSSandboxChannelResponse {
s.ApplicationId = &v
return s
}
// SetCreationDate sets the CreationDate field's value.
func (s *APNSSandboxChannelResponse) SetCreationDate(v string) *APNSSandboxChannelResponse {
s.CreationDate = &v
return s
}
// SetDefaultAuthenticationMethod sets the DefaultAuthenticationMethod field's value.
func (s *APNSSandboxChannelResponse) SetDefaultAuthenticationMethod(v string) *APNSSandboxChannelResponse {
s.DefaultAuthenticationMethod = &v
return s
}
// SetEnabled sets the Enabled field's value.
func (s *APNSSandboxChannelResponse) SetEnabled(v bool) *APNSSandboxChannelResponse {
s.Enabled = &v
return s
}
// SetHasCredential sets the HasCredential field's value.
func (s *APNSSandboxChannelResponse) SetHasCredential(v bool) *APNSSandboxChannelResponse {
s.HasCredential = &v
return s
}
// SetHasTokenKey sets the HasTokenKey field's value.
func (s *APNSSandboxChannelResponse) SetHasTokenKey(v bool) *APNSSandboxChannelResponse {
s.HasTokenKey = &v
return s
}
// SetId sets the Id field's value.
func (s *APNSSandboxChannelResponse) SetId(v string) *APNSSandboxChannelResponse {
s.Id = &v
return s
}
// SetIsArchived sets the IsArchived field's value.
func (s *APNSSandboxChannelResponse) SetIsArchived(v bool) *APNSSandboxChannelResponse {
s.IsArchived = &v
return s
}
// SetLastModifiedBy sets the LastModifiedBy field's value.
func (s *APNSSandboxChannelResponse) SetLastModifiedBy(v string) *APNSSandboxChannelResponse {
s.LastModifiedBy = &v
return s
}
// SetLastModifiedDate sets the LastModifiedDate field's value.
func (s *APNSSandboxChannelResponse) SetLastModifiedDate(v string) *APNSSandboxChannelResponse {
s.LastModifiedDate = &v
return s
}
// SetPlatform sets the Platform field's value.
func (s *APNSSandboxChannelResponse) SetPlatform(v string) *APNSSandboxChannelResponse {
s.Platform = &v
return s
}
// SetVersion sets the Version field's value.
func (s *APNSSandboxChannelResponse) SetVersion(v int64) *APNSSandboxChannelResponse {
s.Version = &v
return s
}
// Apple VOIP Push Notification Service channel definition.
// See also, path_to_url
type APNSVoipChannelRequest struct {
_ struct{} `type:"structure"`
// The bundle id used for APNs Tokens.
BundleId *string `type:"string"`
// The distribution certificate from Apple.
Certificate *string `type:"string"`
// The default authentication method used for APNs.
DefaultAuthenticationMethod *string `type:"string"`
// If the channel is enabled for sending messages.
Enabled *bool `type:"boolean"`
// The certificate private key.
PrivateKey *string `type:"string"`
// The team id used for APNs Tokens.
TeamId *string `type:"string"`
// The token key used for APNs Tokens.
TokenKey *string `type:"string"`
// The token key used for APNs Tokens.
TokenKeyId *string `type:"string"`
}
// String returns the string representation
func (s APNSVoipChannelRequest) String() string {
return awsutil.Prettify(s)
}
// GoString returns the string representation
func (s APNSVoipChannelRequest) GoString() string {
return s.String()
}
// SetBundleId sets the BundleId field's value.
func (s *APNSVoipChannelRequest) SetBundleId(v string) *APNSVoipChannelRequest {
s.BundleId = &v
return s
}
// SetCertificate sets the Certificate field's value.
func (s *APNSVoipChannelRequest) SetCertificate(v string) *APNSVoipChannelRequest {
s.Certificate = &v
return s
}
// SetDefaultAuthenticationMethod sets the DefaultAuthenticationMethod field's value.
func (s *APNSVoipChannelRequest) SetDefaultAuthenticationMethod(v string) *APNSVoipChannelRequest {
s.DefaultAuthenticationMethod = &v
return s
}
// SetEnabled sets the Enabled field's value.
func (s *APNSVoipChannelRequest) SetEnabled(v bool) *APNSVoipChannelRequest {
s.Enabled = &v
return s
}
// SetPrivateKey sets the PrivateKey field's value.
func (s *APNSVoipChannelRequest) SetPrivateKey(v string) *APNSVoipChannelRequest {
s.PrivateKey = &v
return s
}
// SetTeamId sets the TeamId field's value.
func (s *APNSVoipChannelRequest) SetTeamId(v string) *APNSVoipChannelRequest {
s.TeamId = &v
return s
}
// SetTokenKey sets the TokenKey field's value.
func (s *APNSVoipChannelRequest) SetTokenKey(v string) *APNSVoipChannelRequest {
s.TokenKey = &v
return s
}
// SetTokenKeyId sets the TokenKeyId field's value.
func (s *APNSVoipChannelRequest) SetTokenKeyId(v string) *APNSVoipChannelRequest {
s.TokenKeyId = &v
return s
}
// Apple VOIP Push Notification Service channel definition.
// See also, path_to_url
type APNSVoipChannelResponse struct {
_ struct{} `type:"structure"`
// Application id
ApplicationId *string `type:"string"`
// When was this segment created
CreationDate *string `type:"string"`
// The default authentication method used for APNs.
DefaultAuthenticationMethod *string `type:"string"`
// If the channel is enabled for sending messages.
Enabled *bool `type:"boolean"`
// If the channel is registered with a credential for authentication.
HasCredential *bool `type:"boolean"`
// If the channel is registered with a token key for authentication.
HasTokenKey *bool `type:"boolean"`
// Channel ID. Not used, only for backwards compatibility.
Id *string `type:"string"`
// Is this channel archived
IsArchived *bool `type:"boolean"`
// Who made the last change
LastModifiedBy *string `type:"string"`
// Last date this was updated
LastModifiedDate *string `type:"string"`
// The platform type. Will be APNS.
Platform *string `type:"string"`
// Version of channel
Version *int64 `type:"integer"`
}
// String returns the string representation
func (s APNSVoipChannelResponse) String() string {
return awsutil.Prettify(s)
}
// GoString returns the string representation
func (s APNSVoipChannelResponse) GoString() string {
return s.String()
}
// SetApplicationId sets the ApplicationId field's value.
func (s *APNSVoipChannelResponse) SetApplicationId(v string) *APNSVoipChannelResponse {
s.ApplicationId = &v
return s
}
// SetCreationDate sets the CreationDate field's value.
func (s *APNSVoipChannelResponse) SetCreationDate(v string) *APNSVoipChannelResponse {
s.CreationDate = &v
return s
}
// SetDefaultAuthenticationMethod sets the DefaultAuthenticationMethod field's value.
func (s *APNSVoipChannelResponse) SetDefaultAuthenticationMethod(v string) *APNSVoipChannelResponse {
s.DefaultAuthenticationMethod = &v
return s
}
// SetEnabled sets the Enabled field's value.
func (s *APNSVoipChannelResponse) SetEnabled(v bool) *APNSVoipChannelResponse {
s.Enabled = &v
return s
}
// SetHasCredential sets the HasCredential field's value.
func (s *APNSVoipChannelResponse) SetHasCredential(v bool) *APNSVoipChannelResponse {
s.HasCredential = &v
return s
}
// SetHasTokenKey sets the HasTokenKey field's value.
func (s *APNSVoipChannelResponse) SetHasTokenKey(v bool) *APNSVoipChannelResponse {
s.HasTokenKey = &v
return s
}
// SetId sets the Id field's value.
func (s *APNSVoipChannelResponse) SetId(v string) *APNSVoipChannelResponse {
s.Id = &v
return s
}
// SetIsArchived sets the IsArchived field's value.
func (s *APNSVoipChannelResponse) SetIsArchived(v bool) *APNSVoipChannelResponse {
s.IsArchived = &v
return s
}
// SetLastModifiedBy sets the LastModifiedBy field's value.
func (s *APNSVoipChannelResponse) SetLastModifiedBy(v string) *APNSVoipChannelResponse {
s.LastModifiedBy = &v
return s
}
// SetLastModifiedDate sets the LastModifiedDate field's value.
func (s *APNSVoipChannelResponse) SetLastModifiedDate(v string) *APNSVoipChannelResponse {
s.LastModifiedDate = &v
return s
}
// SetPlatform sets the Platform field's value.
func (s *APNSVoipChannelResponse) SetPlatform(v string) *APNSVoipChannelResponse {
s.Platform = &v
return s
}
// SetVersion sets the Version field's value.
func (s *APNSVoipChannelResponse) SetVersion(v int64) *APNSVoipChannelResponse {
s.Version = &v
return s
}
// Apple VOIP Developer Push Notification Service channel definition.
// See also, path_to_url
type APNSVoipSandboxChannelRequest struct {
_ struct{} `type:"structure"`
// The bundle id used for APNs Tokens.
BundleId *string `type:"string"`
// The distribution certificate from Apple.
Certificate *string `type:"string"`
// The default authentication method used for APNs.
DefaultAuthenticationMethod *string `type:"string"`
// If the channel is enabled for sending messages.
Enabled *bool `type:"boolean"`
// The certificate private key.
PrivateKey *string `type:"string"`
// The team id used for APNs Tokens.
TeamId *string `type:"string"`
// The token key used for APNs Tokens.
TokenKey *string `type:"string"`
// The token key used for APNs Tokens.
TokenKeyId *string `type:"string"`
}
// String returns the string representation
func (s APNSVoipSandboxChannelRequest) String() string {
return awsutil.Prettify(s)
}
// GoString returns the string representation
func (s APNSVoipSandboxChannelRequest) GoString() string {
return s.String()
}
// SetBundleId sets the BundleId field's value.
func (s *APNSVoipSandboxChannelRequest) SetBundleId(v string) *APNSVoipSandboxChannelRequest {
s.BundleId = &v
return s
}
// SetCertificate sets the Certificate field's value.
func (s *APNSVoipSandboxChannelRequest) SetCertificate(v string) *APNSVoipSandboxChannelRequest {
s.Certificate = &v
return s
}
// SetDefaultAuthenticationMethod sets the DefaultAuthenticationMethod field's value.
func (s *APNSVoipSandboxChannelRequest) SetDefaultAuthenticationMethod(v string) *APNSVoipSandboxChannelRequest {
s.DefaultAuthenticationMethod = &v
return s
}
// SetEnabled sets the Enabled field's value.
func (s *APNSVoipSandboxChannelRequest) SetEnabled(v bool) *APNSVoipSandboxChannelRequest {
s.Enabled = &v
return s
}
// SetPrivateKey sets the PrivateKey field's value.
func (s *APNSVoipSandboxChannelRequest) SetPrivateKey(v string) *APNSVoipSandboxChannelRequest {
s.PrivateKey = &v
return s
}
// SetTeamId sets the TeamId field's value.
func (s *APNSVoipSandboxChannelRequest) SetTeamId(v string) *APNSVoipSandboxChannelRequest {
s.TeamId = &v
return s
}
// SetTokenKey sets the TokenKey field's value.
func (s *APNSVoipSandboxChannelRequest) SetTokenKey(v string) *APNSVoipSandboxChannelRequest {
s.TokenKey = &v
return s
}
// SetTokenKeyId sets the TokenKeyId field's value.
func (s *APNSVoipSandboxChannelRequest) SetTokenKeyId(v string) *APNSVoipSandboxChannelRequest {
s.TokenKeyId = &v
return s
}
// Apple VOIP Developer Push Notification Service channel definition.
// See also, path_to_url
type APNSVoipSandboxChannelResponse struct {
_ struct{} `type:"structure"`
// Application id
ApplicationId *string `type:"string"`
// When was this segment created
CreationDate *string `type:"string"`
// The default authentication method used for APNs.
DefaultAuthenticationMethod *string `type:"string"`
// If the channel is enabled for sending messages.
Enabled *bool `type:"boolean"`
// If the channel is registered with a credential for authentication.
HasCredential *bool `type:"boolean"`
// If the channel is registered with a token key for authentication.
HasTokenKey *bool `type:"boolean"`
// Channel ID. Not used, only for backwards compatibility.
Id *string `type:"string"`
// Is this channel archived
IsArchived *bool `type:"boolean"`
// Who made the last change
LastModifiedBy *string `type:"string"`
// Last date this was updated
LastModifiedDate *string `type:"string"`
// The platform type. Will be APNS.
Platform *string `type:"string"`
// Version of channel
Version *int64 `type:"integer"`
}
// String returns the string representation
func (s APNSVoipSandboxChannelResponse) String() string {
return awsutil.Prettify(s)
}
// GoString returns the string representation
func (s APNSVoipSandboxChannelResponse) GoString() string {
return s.String()
}
// SetApplicationId sets the ApplicationId field's value.
func (s *APNSVoipSandboxChannelResponse) SetApplicationId(v string) *APNSVoipSandboxChannelResponse {
s.ApplicationId = &v
return s
}
// SetCreationDate sets the CreationDate field's value.
func (s *APNSVoipSandboxChannelResponse) SetCreationDate(v string) *APNSVoipSandboxChannelResponse {
s.CreationDate = &v
return s
}
// SetDefaultAuthenticationMethod sets the DefaultAuthenticationMethod field's value.
func (s *APNSVoipSandboxChannelResponse) SetDefaultAuthenticationMethod(v string) *APNSVoipSandboxChannelResponse {
s.DefaultAuthenticationMethod = &v
return s
}
// SetEnabled sets the Enabled field's value.
func (s *APNSVoipSandboxChannelResponse) SetEnabled(v bool) *APNSVoipSandboxChannelResponse {
s.Enabled = &v
return s
}
// SetHasCredential sets the HasCredential field's value.
func (s *APNSVoipSandboxChannelResponse) SetHasCredential(v bool) *APNSVoipSandboxChannelResponse {
s.HasCredential = &v
return s
}
// SetHasTokenKey sets the HasTokenKey field's value.
func (s *APNSVoipSandboxChannelResponse) SetHasTokenKey(v bool) *APNSVoipSandboxChannelResponse {
s.HasTokenKey = &v
return s
}
// SetId sets the Id field's value.
func (s *APNSVoipSandboxChannelResponse) SetId(v string) *APNSVoipSandboxChannelResponse {
s.Id = &v
return s
}
// SetIsArchived sets the IsArchived field's value.
func (s *APNSVoipSandboxChannelResponse) SetIsArchived(v bool) *APNSVoipSandboxChannelResponse {
s.IsArchived = &v
return s
}
// SetLastModifiedBy sets the LastModifiedBy field's value.
func (s *APNSVoipSandboxChannelResponse) SetLastModifiedBy(v string) *APNSVoipSandboxChannelResponse {
s.LastModifiedBy = &v
return s
}
// SetLastModifiedDate sets the LastModifiedDate field's value.
func (s *APNSVoipSandboxChannelResponse) SetLastModifiedDate(v string) *APNSVoipSandboxChannelResponse {
s.LastModifiedDate = &v
return s
}
// SetPlatform sets the Platform field's value.
func (s *APNSVoipSandboxChannelResponse) SetPlatform(v string) *APNSVoipSandboxChannelResponse {
s.Platform = &v
return s
}
// SetVersion sets the Version field's value.
func (s *APNSVoipSandboxChannelResponse) SetVersion(v int64) *APNSVoipSandboxChannelResponse {
s.Version = &v
return s
}
// Activities for campaign.
// See also, path_to_url
type ActivitiesResponse struct {
_ struct{} `type:"structure"`
// List of campaign activities
Item []*ActivityResponse `type:"list"`
}
// String returns the string representation
func (s ActivitiesResponse) String() string {
return awsutil.Prettify(s)
}
// GoString returns the string representation
func (s ActivitiesResponse) GoString() string {
return s.String()
}
// SetItem sets the Item field's value.
func (s *ActivitiesResponse) SetItem(v []*ActivityResponse) *ActivitiesResponse {
s.Item = v
return s
}
// Activity definition
// See also, path_to_url
type ActivityResponse struct {
_ struct{} `type:"structure"`
// The ID of the application to which the campaign applies.
ApplicationId *string `type:"string"`
// The ID of the campaign to which the activity applies.
CampaignId *string `type:"string"`
// The actual time the activity was marked CANCELLED or COMPLETED. Provided
// in ISO 8601 format.
End *string `type:"string"`
// The unique activity ID.
Id *string `type:"string"`
// Indicates whether the activity succeeded.Valid values: SUCCESS, FAIL
Result *string `type:"string"`
// The scheduled start time for the activity in ISO 8601 format.
ScheduledStart *string `type:"string"`
// The actual start time of the activity in ISO 8601 format.
Start *string `type:"string"`
// The state of the activity.Valid values: PENDING, INITIALIZING, RUNNING, PAUSED,
// CANCELLED, COMPLETED
State *string `type:"string"`
// The total number of endpoints to which the campaign successfully delivered
// messages.
SuccessfulEndpointCount *int64 `type:"integer"`
// The total number of timezones completed.
TimezonesCompletedCount *int64 `type:"integer"`
// The total number of unique timezones present in the segment.
TimezonesTotalCount *int64 `type:"integer"`
// The total number of endpoints to which the campaign attempts to deliver messages.
TotalEndpointCount *int64 `type:"integer"`
// The ID of a variation of the campaign used for A/B testing.
TreatmentId *string `type:"string"`
}
// String returns the string representation
func (s ActivityResponse) String() string {
return awsutil.Prettify(s)
}
// GoString returns the string representation
func (s ActivityResponse) GoString() string {
return s.String()
}
// SetApplicationId sets the ApplicationId field's value.
func (s *ActivityResponse) SetApplicationId(v string) *ActivityResponse {
s.ApplicationId = &v
return s
}
// SetCampaignId sets the CampaignId field's value.
func (s *ActivityResponse) SetCampaignId(v string) *ActivityResponse {
s.CampaignId = &v
return s
}
// SetEnd sets the End field's value.
func (s *ActivityResponse) SetEnd(v string) *ActivityResponse {
s.End = &v
return s
}
// SetId sets the Id field's value.
func (s *ActivityResponse) SetId(v string) *ActivityResponse {
s.Id = &v
return s
}
// SetResult sets the Result field's value.
func (s *ActivityResponse) SetResult(v string) *ActivityResponse {
s.Result = &v
return s
}
// SetScheduledStart sets the ScheduledStart field's value.
func (s *ActivityResponse) SetScheduledStart(v string) *ActivityResponse {
s.ScheduledStart = &v
return s
}
// SetStart sets the Start field's value.
func (s *ActivityResponse) SetStart(v string) *ActivityResponse {
s.Start = &v
return s
}
// SetState sets the State field's value.
func (s *ActivityResponse) SetState(v string) *ActivityResponse {
s.State = &v
return s
}
// SetSuccessfulEndpointCount sets the SuccessfulEndpointCount field's value.
func (s *ActivityResponse) SetSuccessfulEndpointCount(v int64) *ActivityResponse {
s.SuccessfulEndpointCount = &v
return s
}
// SetTimezonesCompletedCount sets the TimezonesCompletedCount field's value.
func (s *ActivityResponse) SetTimezonesCompletedCount(v int64) *ActivityResponse {
s.TimezonesCompletedCount = &v
return s
}
// SetTimezonesTotalCount sets the TimezonesTotalCount field's value.
func (s *ActivityResponse) SetTimezonesTotalCount(v int64) *ActivityResponse {
s.TimezonesTotalCount = &v
return s
}
// SetTotalEndpointCount sets the TotalEndpointCount field's value.
func (s *ActivityResponse) SetTotalEndpointCount(v int64) *ActivityResponse {
s.TotalEndpointCount = &v
return s
}
// SetTreatmentId sets the TreatmentId field's value.
func (s *ActivityResponse) SetTreatmentId(v string) *ActivityResponse {
s.TreatmentId = &v
return s
}
// Address configuration.
// See also, path_to_url
type AddressConfiguration struct {
_ struct{} `type:"structure"`
// Body override. If specified will override default body.
BodyOverride *string `type:"string"`
// The channel type.Valid values: GCM | APNS | SMS | EMAIL
ChannelType *string `type:"string" enum:"ChannelType"`
Context map[string]*string `type:"map"`
// The Raw JSON formatted string to be used as the payload. This value overrides
// the message.
RawContent *string `type:"string"`
Substitutions map[string][]*string `type:"map"`
// Title override. If specified will override default title if applicable.
TitleOverride *string `type:"string"`
}
// String returns the string representation
func (s AddressConfiguration) String() string {
return awsutil.Prettify(s)
}
// GoString returns the string representation
func (s AddressConfiguration) GoString() string {
return s.String()
}
// SetBodyOverride sets the BodyOverride field's value.
func (s *AddressConfiguration) SetBodyOverride(v string) *AddressConfiguration {
s.BodyOverride = &v
return s
}
// SetChannelType sets the ChannelType field's value.
func (s *AddressConfiguration) SetChannelType(v string) *AddressConfiguration {
s.ChannelType = &v
return s
}
// SetContext sets the Context field's value.
func (s *AddressConfiguration) SetContext(v map[string]*string) *AddressConfiguration {
s.Context = v
return s
}
// SetRawContent sets the RawContent field's value.
func (s *AddressConfiguration) SetRawContent(v string) *AddressConfiguration {
s.RawContent = &v
return s
}
// SetSubstitutions sets the Substitutions field's value.
func (s *AddressConfiguration) SetSubstitutions(v map[string][]*string) *AddressConfiguration {
s.Substitutions = v
return s
}
// SetTitleOverride sets the TitleOverride field's value.
func (s *AddressConfiguration) SetTitleOverride(v string) *AddressConfiguration {
s.TitleOverride = &v
return s
}
// Application Response.
// See also, path_to_url
type ApplicationResponse struct {
_ struct{} `type:"structure"`
// The unique application ID.
Id *string `type:"string"`
// The display name of the application.
Name *string `type:"string"`
}
// String returns the string representation
func (s ApplicationResponse) String() string {
return awsutil.Prettify(s)
}
// GoString returns the string representation
func (s ApplicationResponse) GoString() string {
return s.String()
}
// SetId sets the Id field's value.
func (s *ApplicationResponse) SetId(v string) *ApplicationResponse {
s.Id = &v
return s
}
// SetName sets the Name field's value.
func (s *ApplicationResponse) SetName(v string) *ApplicationResponse {
s.Name = &v
return s
}
// Application settings.
// See also, path_to_url
type ApplicationSettingsResource struct {
_ struct{} `type:"structure"`
// The unique ID for the application.
ApplicationId *string `type:"string"`
// The date that the settings were last updated in ISO 8601 format.
LastModifiedDate *string `type:"string"`
// The default campaign limits for the app. These limits apply to each campaign
// for the app, unless the campaign overrides the default with limits of its
// own.
Limits *CampaignLimits `type:"structure"`
// The default quiet time for the app. Each campaign for this app sends no messages
// during this time unless the campaign overrides the default with a quiet time
// of its own.
QuietTime *QuietTime `type:"structure"`
}
// String returns the string representation
func (s ApplicationSettingsResource) String() string {
return awsutil.Prettify(s)
}
// GoString returns the string representation
func (s ApplicationSettingsResource) GoString() string {
return s.String()
}
// SetApplicationId sets the ApplicationId field's value.
func (s *ApplicationSettingsResource) SetApplicationId(v string) *ApplicationSettingsResource {
s.ApplicationId = &v
return s
}
// SetLastModifiedDate sets the LastModifiedDate field's value.
func (s *ApplicationSettingsResource) SetLastModifiedDate(v string) *ApplicationSettingsResource {
s.LastModifiedDate = &v
return s
}
// SetLimits sets the Limits field's value.
func (s *ApplicationSettingsResource) SetLimits(v *CampaignLimits) *ApplicationSettingsResource {
s.Limits = v
return s
}
// SetQuietTime sets the QuietTime field's value.
func (s *ApplicationSettingsResource) SetQuietTime(v *QuietTime) *ApplicationSettingsResource {
s.QuietTime = v
return s
}
// Get Applications Result.
// See also, path_to_url
type ApplicationsResponse struct {
_ struct{} `type:"structure"`
// List of applications returned in this page.
Item []*ApplicationResponse `type:"list"`
// The string that you use in a subsequent request to get the next page of results
// in a paginated response.
NextToken *string `type:"string"`
}
// String returns the string representation
func (s ApplicationsResponse) String() string {
return awsutil.Prettify(s)
}
// GoString returns the string representation
func (s ApplicationsResponse) GoString() string {
return s.String()
}
// SetItem sets the Item field's value.
func (s *ApplicationsResponse) SetItem(v []*ApplicationResponse) *ApplicationsResponse {
s.Item = v
return s
}
// SetNextToken sets the NextToken field's value.
func (s *ApplicationsResponse) SetNextToken(v string) *ApplicationsResponse {
s.NextToken = &v
return s
}
// Custom attibute dimension
// See also, path_to_url
type AttributeDimension struct {
_ struct{} `type:"structure"`
// The type of dimension:INCLUSIVE - Endpoints that match the criteria are included
// in the segment.EXCLUSIVE - Endpoints that match the criteria are excluded
// from the segment.
AttributeType *string `type:"string" enum:"AttributeType"`
Values []*string `type:"list"`
}
// String returns the string representation
func (s AttributeDimension) String() string {
return awsutil.Prettify(s)
}
// GoString returns the string representation
func (s AttributeDimension) GoString() string {
return s.String()
}
// SetAttributeType sets the AttributeType field's value.
func (s *AttributeDimension) SetAttributeType(v string) *AttributeDimension {
s.AttributeType = &v
return s
}
// SetValues sets the Values field's value.
func (s *AttributeDimension) SetValues(v []*string) *AttributeDimension {
s.Values = v
return s
}
// Baidu Cloud Push credentials
// See also, path_to_url
type BaiduChannelRequest struct {
_ struct{} `type:"structure"`
// Platform credential API key from Baidu.
ApiKey *string `type:"string"`
// If the channel is enabled for sending messages.
Enabled *bool `type:"boolean"`
// Platform credential Secret key from Baidu.
SecretKey *string `type:"string"`
}
// String returns the string representation
func (s BaiduChannelRequest) String() string {
return awsutil.Prettify(s)
}
// GoString returns the string representation
func (s BaiduChannelRequest) GoString() string {
return s.String()
}
// SetApiKey sets the ApiKey field's value.
func (s *BaiduChannelRequest) SetApiKey(v string) *BaiduChannelRequest {
s.ApiKey = &v
return s
}
// SetEnabled sets the Enabled field's value.
func (s *BaiduChannelRequest) SetEnabled(v bool) *BaiduChannelRequest {
s.Enabled = &v
return s
}
// SetSecretKey sets the SecretKey field's value.
func (s *BaiduChannelRequest) SetSecretKey(v string) *BaiduChannelRequest {
s.SecretKey = &v
return s
}
// Baidu Cloud Messaging channel definition
// See also, path_to_url
type BaiduChannelResponse struct {
_ struct{} `type:"structure"`
// Application id
ApplicationId *string `type:"string"`
// When was this segment created
CreationDate *string `type:"string"`
// The Baidu API key from Baidu.
Credential *string `type:"string"`
// If the channel is enabled for sending messages.
Enabled *bool `type:"boolean"`
// If the channel is registered with a credential for authentication.
HasCredential *bool `type:"boolean"`
// Channel ID. Not used, only for backwards compatibility.
Id *string `type:"string"`
// Is this channel archived
IsArchived *bool `type:"boolean"`
// Who made the last change
LastModifiedBy *string `type:"string"`
// Last date this was updated
LastModifiedDate *string `type:"string"`
// The platform type. Will be BAIDU
Platform *string `type:"string"`
// Version of channel
Version *int64 `type:"integer"`
}
// String returns the string representation
func (s BaiduChannelResponse) String() string {
return awsutil.Prettify(s)
}
// GoString returns the string representation
func (s BaiduChannelResponse) GoString() string {
return s.String()
}
// SetApplicationId sets the ApplicationId field's value.
func (s *BaiduChannelResponse) SetApplicationId(v string) *BaiduChannelResponse {
s.ApplicationId = &v
return s
}
// SetCreationDate sets the CreationDate field's value.
func (s *BaiduChannelResponse) SetCreationDate(v string) *BaiduChannelResponse {
s.CreationDate = &v
return s
}
// SetCredential sets the Credential field's value.
func (s *BaiduChannelResponse) SetCredential(v string) *BaiduChannelResponse {
s.Credential = &v
return s
}
// SetEnabled sets the Enabled field's value.
func (s *BaiduChannelResponse) SetEnabled(v bool) *BaiduChannelResponse {
s.Enabled = &v
return s
}
// SetHasCredential sets the HasCredential field's value.
func (s *BaiduChannelResponse) SetHasCredential(v bool) *BaiduChannelResponse {
s.HasCredential = &v
return s
}
// SetId sets the Id field's value.
func (s *BaiduChannelResponse) SetId(v string) *BaiduChannelResponse {
s.Id = &v
return s
}
// SetIsArchived sets the IsArchived field's value.
func (s *BaiduChannelResponse) SetIsArchived(v bool) *BaiduChannelResponse {
s.IsArchived = &v
return s
}
// SetLastModifiedBy sets the LastModifiedBy field's value.
func (s *BaiduChannelResponse) SetLastModifiedBy(v string) *BaiduChannelResponse {
s.LastModifiedBy = &v
return s
}
// SetLastModifiedDate sets the LastModifiedDate field's value.
func (s *BaiduChannelResponse) SetLastModifiedDate(v string) *BaiduChannelResponse {
s.LastModifiedDate = &v
return s
}
// SetPlatform sets the Platform field's value.
func (s *BaiduChannelResponse) SetPlatform(v string) *BaiduChannelResponse {
s.Platform = &v
return s
}
// SetVersion sets the Version field's value.
func (s *BaiduChannelResponse) SetVersion(v int64) *BaiduChannelResponse {
s.Version = &v
return s
}
// Baidu Message.
// See also, path_to_url
type BaiduMessage struct {
_ struct{} `type:"structure"`
// The action that occurs if the user taps a push notification delivered by
// the campaign: OPEN_APP - Your app launches, or it becomes the foreground
// app if it has been sent to the background. This is the default action. DEEP_LINK
// - Uses deep linking features in iOS and Android to open your app and display
// a designated user interface within the app. URL - The default mobile browser
// on the user's device launches and opens a web page at the URL you specify.
// Possible values include: OPEN_APP | DEEP_LINK | URL
Action *string `type:"string" enum:"Action"`
// The message body of the notification, the email body or the text message.
Body *string `type:"string"`
Data map[string]*string `type:"map"`
// The icon image name of the asset saved in your application.
IconReference *string `type:"string"`
// The URL that points to an image used as the large icon to the notification
// content view.
ImageIconUrl *string `type:"string"`
// The URL that points to an image used in the push notification.
ImageUrl *string `type:"string"`
// The Raw JSON formatted string to be used as the payload. This value overrides
// the message.
RawContent *string `type:"string"`
// Indicates if the message should display on the users device. Silent pushes
// can be used for Remote Configuration and Phone Home use cases.
SilentPush *bool `type:"boolean"`
// The URL that points to an image used as the small icon for the notification
// which will be used to represent the notification in the status bar and content
// view
SmallImageIconUrl *string `type:"string"`
// Indicates a sound to play when the device receives the notification. Supports
// default, or the filename of a sound resource bundled in the app. Android
// sound files must reside in /res/raw/
Sound *string `type:"string"`
Substitutions map[string][]*string `type:"map"`
// The message title that displays above the message on the user's device.
Title *string `type:"string"`
// The URL to open in the user's mobile browser. Used if the value for Action
// is URL.
Url *string `type:"string"`
}
// String returns the string representation
func (s BaiduMessage) String() string {
return awsutil.Prettify(s)
}
// GoString returns the string representation
func (s BaiduMessage) GoString() string {
return s.String()
}
// SetAction sets the Action field's value.
func (s *BaiduMessage) SetAction(v string) *BaiduMessage {
s.Action = &v
return s
}
// SetBody sets the Body field's value.
func (s *BaiduMessage) SetBody(v string) *BaiduMessage {
s.Body = &v
return s
}
// SetData sets the Data field's value.
func (s *BaiduMessage) SetData(v map[string]*string) *BaiduMessage {
s.Data = v
return s
}
// SetIconReference sets the IconReference field's value.
func (s *BaiduMessage) SetIconReference(v string) *BaiduMessage {
s.IconReference = &v
return s
}
// SetImageIconUrl sets the ImageIconUrl field's value.
func (s *BaiduMessage) SetImageIconUrl(v string) *BaiduMessage {
s.ImageIconUrl = &v
return s
}
// SetImageUrl sets the ImageUrl field's value.
func (s *BaiduMessage) SetImageUrl(v string) *BaiduMessage {
s.ImageUrl = &v
return s
}
// SetRawContent sets the RawContent field's value.
func (s *BaiduMessage) SetRawContent(v string) *BaiduMessage {
s.RawContent = &v
return s
}
// SetSilentPush sets the SilentPush field's value.
func (s *BaiduMessage) SetSilentPush(v bool) *BaiduMessage {
s.SilentPush = &v
return s
}
// SetSmallImageIconUrl sets the SmallImageIconUrl field's value.
func (s *BaiduMessage) SetSmallImageIconUrl(v string) *BaiduMessage {
s.SmallImageIconUrl = &v
return s
}
// SetSound sets the Sound field's value.
func (s *BaiduMessage) SetSound(v string) *BaiduMessage {
s.Sound = &v
return s
}
// SetSubstitutions sets the Substitutions field's value.
func (s *BaiduMessage) SetSubstitutions(v map[string][]*string) *BaiduMessage {
s.Substitutions = v
return s
}
// SetTitle sets the Title field's value.
func (s *BaiduMessage) SetTitle(v string) *BaiduMessage {
s.Title = &v
return s
}
// SetUrl sets the Url field's value.
func (s *BaiduMessage) SetUrl(v string) *BaiduMessage {
s.Url = &v
return s
}
// The email message configuration.
// See also, path_to_url
type CampaignEmailMessage struct {
_ struct{} `type:"structure"`
// The email text body.
Body *string `type:"string"`
// The email address used to send the email from. Defaults to use FromAddress
// specified in the Email Channel.
FromAddress *string `type:"string"`
// The email html body.
HtmlBody *string `type:"string"`
// The email title (Or subject).
Title *string `type:"string"`
}
// String returns the string representation
func (s CampaignEmailMessage) String() string {
return awsutil.Prettify(s)
}
// GoString returns the string representation
func (s CampaignEmailMessage) GoString() string {
return s.String()
}
// SetBody sets the Body field's value.
func (s *CampaignEmailMessage) SetBody(v string) *CampaignEmailMessage {
s.Body = &v
return s
}
// SetFromAddress sets the FromAddress field's value.
func (s *CampaignEmailMessage) SetFromAddress(v string) *CampaignEmailMessage {
s.FromAddress = &v
return s
}
// SetHtmlBody sets the HtmlBody field's value.
func (s *CampaignEmailMessage) SetHtmlBody(v string) *CampaignEmailMessage {
s.HtmlBody = &v
return s
}
// SetTitle sets the Title field's value.
func (s *CampaignEmailMessage) SetTitle(v string) *CampaignEmailMessage {
s.Title = &v
return s
}
// Campaign Limits are used to limit the number of messages that can be sent
// to a user.
// See also, path_to_url
type CampaignLimits struct {
_ struct{} `type:"structure"`
// The maximum number of messages that the campaign can send daily.
Daily *int64 `type:"integer"`
// The maximum duration of a campaign from the scheduled start. Must be a minimum
// of 60 seconds.
MaximumDuration *int64 `type:"integer"`
// The maximum number of messages per second that the campaign will send. This
// is a best effort maximum cap and can go as high as 20000 and as low as 50
MessagesPerSecond *int64 `type:"integer"`
// The maximum total number of messages that the campaign can send.
Total *int64 `type:"integer"`
}
// String returns the string representation
func (s CampaignLimits) String() string {
return awsutil.Prettify(s)
}
// GoString returns the string representation
func (s CampaignLimits) GoString() string {
return s.String()
}
// SetDaily sets the Daily field's value.
func (s *CampaignLimits) SetDaily(v int64) *CampaignLimits {
s.Daily = &v
return s
}
// SetMaximumDuration sets the MaximumDuration field's value.
func (s *CampaignLimits) SetMaximumDuration(v int64) *CampaignLimits {
s.MaximumDuration = &v
return s
}
// SetMessagesPerSecond sets the MessagesPerSecond field's value.
func (s *CampaignLimits) SetMessagesPerSecond(v int64) *CampaignLimits {
s.MessagesPerSecond = &v
return s
}
// SetTotal sets the Total field's value.
func (s *CampaignLimits) SetTotal(v int64) *CampaignLimits {
s.Total = &v
return s
}
// Campaign definition
// See also, path_to_url
type CampaignResponse struct {
_ struct{} `type:"structure"`
// Treatments that are defined in addition to the default treatment.
AdditionalTreatments []*TreatmentResource `type:"list"`
// The ID of the application to which the campaign applies.
ApplicationId *string `type:"string"`
// The date the campaign was created in ISO 8601 format.
CreationDate *string `type:"string"`
// The status of the campaign's default treatment. Only present for A/B test
// campaigns.
DefaultState *CampaignState `type:"structure"`
// A description of the campaign.
Description *string `type:"string"`
// The allocated percentage of end users who will not receive messages from
// this campaign.
HoldoutPercent *int64 `type:"integer"`
// The unique campaign ID.
Id *string `type:"string"`
// Indicates whether the campaign is paused. A paused campaign does not send
// messages unless you resume it by setting IsPaused to false.
IsPaused *bool `type:"boolean"`
// The date the campaign was last updated in ISO 8601 format.
LastModifiedDate *string `type:"string"`
// The campaign limits settings.
Limits *CampaignLimits `type:"structure"`
// The message configuration settings.
MessageConfiguration *MessageConfiguration `type:"structure"`
// The custom name of the campaign.
Name *string `type:"string"`
// The campaign schedule.
Schedule *Schedule `type:"structure"`
// The ID of the segment to which the campaign sends messages.
SegmentId *string `type:"string"`
// The version of the segment to which the campaign sends messages.
SegmentVersion *int64 `type:"integer"`
// The campaign status.An A/B test campaign will have a status of COMPLETED
// only when all treatments have a status of COMPLETED.
State *CampaignState `type:"structure"`
// A custom description for the treatment.
TreatmentDescription *string `type:"string"`
// The custom name of a variation of the campaign used for A/B testing.
TreatmentName *string `type:"string"`
// The campaign version number.
Version *int64 `type:"integer"`
}
// String returns the string representation
func (s CampaignResponse) String() string {
return awsutil.Prettify(s)
}
// GoString returns the string representation
func (s CampaignResponse) GoString() string {
return s.String()
}
// SetAdditionalTreatments sets the AdditionalTreatments field's value.
func (s *CampaignResponse) SetAdditionalTreatments(v []*TreatmentResource) *CampaignResponse {
s.AdditionalTreatments = v
return s
}
// SetApplicationId sets the ApplicationId field's value.
func (s *CampaignResponse) SetApplicationId(v string) *CampaignResponse {
s.ApplicationId = &v
return s
}
// SetCreationDate sets the CreationDate field's value.
func (s *CampaignResponse) SetCreationDate(v string) *CampaignResponse {
s.CreationDate = &v
return s
}
// SetDefaultState sets the DefaultState field's value.
func (s *CampaignResponse) SetDefaultState(v *CampaignState) *CampaignResponse {
s.DefaultState = v
return s
}
// SetDescription sets the Description field's value.
func (s *CampaignResponse) SetDescription(v string) *CampaignResponse {
s.Description = &v
return s
}
// SetHoldoutPercent sets the HoldoutPercent field's value.
func (s *CampaignResponse) SetHoldoutPercent(v int64) *CampaignResponse {
s.HoldoutPercent = &v
return s
}
// SetId sets the Id field's value.
func (s *CampaignResponse) SetId(v string) *CampaignResponse {
s.Id = &v
return s
}
// SetIsPaused sets the IsPaused field's value.
func (s *CampaignResponse) SetIsPaused(v bool) *CampaignResponse {
s.IsPaused = &v
return s
}
// SetLastModifiedDate sets the LastModifiedDate field's value.
func (s *CampaignResponse) SetLastModifiedDate(v string) *CampaignResponse {
s.LastModifiedDate = &v
return s
}
// SetLimits sets the Limits field's value.
func (s *CampaignResponse) SetLimits(v *CampaignLimits) *CampaignResponse {
s.Limits = v
return s
}
// SetMessageConfiguration sets the MessageConfiguration field's value.
func (s *CampaignResponse) SetMessageConfiguration(v *MessageConfiguration) *CampaignResponse {
s.MessageConfiguration = v
return s
}
// SetName sets the Name field's value.
func (s *CampaignResponse) SetName(v string) *CampaignResponse {
s.Name = &v
return s
}
// SetSchedule sets the Schedule field's value.
func (s *CampaignResponse) SetSchedule(v *Schedule) *CampaignResponse {
s.Schedule = v
return s
}
// SetSegmentId sets the SegmentId field's value.
func (s *CampaignResponse) SetSegmentId(v string) *CampaignResponse {
s.SegmentId = &v
return s
}
// SetSegmentVersion sets the SegmentVersion field's value.
func (s *CampaignResponse) SetSegmentVersion(v int64) *CampaignResponse {
s.SegmentVersion = &v
return s
}
// SetState sets the State field's value.
func (s *CampaignResponse) SetState(v *CampaignState) *CampaignResponse {
s.State = v
return s
}
// SetTreatmentDescription sets the TreatmentDescription field's value.
func (s *CampaignResponse) SetTreatmentDescription(v string) *CampaignResponse {
s.TreatmentDescription = &v
return s
}
// SetTreatmentName sets the TreatmentName field's value.
func (s *CampaignResponse) SetTreatmentName(v string) *CampaignResponse {
s.TreatmentName = &v
return s
}
// SetVersion sets the Version field's value.
func (s *CampaignResponse) SetVersion(v int64) *CampaignResponse {
s.Version = &v
return s
}
// SMS message configuration.
// See also, path_to_url
type CampaignSmsMessage struct {
_ struct{} `type:"structure"`
// The SMS text body.
Body *string `type:"string"`
// Is this is a transactional SMS message, otherwise a promotional message.
MessageType *string `type:"string" enum:"MessageType"`
// Sender ID of sent message.
SenderId *string `type:"string"`
}
// String returns the string representation
func (s CampaignSmsMessage) String() string {
return awsutil.Prettify(s)
}
// GoString returns the string representation
func (s CampaignSmsMessage) GoString() string {
return s.String()
}
// SetBody sets the Body field's value.
func (s *CampaignSmsMessage) SetBody(v string) *CampaignSmsMessage {
s.Body = &v
return s
}
// SetMessageType sets the MessageType field's value.
func (s *CampaignSmsMessage) SetMessageType(v string) *CampaignSmsMessage {
s.MessageType = &v
return s
}
// SetSenderId sets the SenderId field's value.
func (s *CampaignSmsMessage) SetSenderId(v string) *CampaignSmsMessage {
s.SenderId = &v
return s
}
// State of the Campaign
// See also, path_to_url
type CampaignState struct {
_ struct{} `type:"structure"`
// The status of the campaign, or the status of a treatment that belongs to
// an A/B test campaign.Valid values: SCHEDULED, EXECUTING, PENDING_NEXT_RUN,
// COMPLETED, PAUSED
CampaignStatus *string `type:"string" enum:"CampaignStatus"`
}
// String returns the string representation
func (s CampaignState) String() string {
return awsutil.Prettify(s)
}
// GoString returns the string representation
func (s CampaignState) GoString() string {
return s.String()
}
// SetCampaignStatus sets the CampaignStatus field's value.
func (s *CampaignState) SetCampaignStatus(v string) *CampaignState {
s.CampaignStatus = &v
return s
}
// List of available campaigns.
// See also, path_to_url
type CampaignsResponse struct {
_ struct{} `type:"structure"`
// A list of campaigns.
Item []*CampaignResponse `type:"list"`
// The string that you use in a subsequent request to get the next page of results
// in a paginated response.
NextToken *string `type:"string"`
}
// String returns the string representation
func (s CampaignsResponse) String() string {
return awsutil.Prettify(s)
}
// GoString returns the string representation
func (s CampaignsResponse) GoString() string {
return s.String()
}
// SetItem sets the Item field's value.
func (s *CampaignsResponse) SetItem(v []*CampaignResponse) *CampaignsResponse {
s.Item = v
return s
}
// SetNextToken sets the NextToken field's value.
func (s *CampaignsResponse) SetNextToken(v string) *CampaignsResponse {
s.NextToken = &v
return s
}
// See also, path_to_url
type CreateAppInput struct {
_ struct{} `type:"structure" payload:"CreateApplicationRequest"`
// Application Request.
//
// CreateApplicationRequest is a required field
CreateApplicationRequest *CreateApplicationRequest `type:"structure" required:"true"`
}
// String returns the string representation
func (s CreateAppInput) String() string {
return awsutil.Prettify(s)
}
// GoString returns the string representation
func (s CreateAppInput) GoString() string {
return s.String()
}
// Validate inspects the fields of the type to determine if they are valid.
func (s *CreateAppInput) Validate() error {
invalidParams := request.ErrInvalidParams{Context: "CreateAppInput"}
if s.CreateApplicationRequest == nil {
invalidParams.Add(request.NewErrParamRequired("CreateApplicationRequest"))
}
if invalidParams.Len() > 0 {
return invalidParams
}
return nil
}
// SetCreateApplicationRequest sets the CreateApplicationRequest field's value.
func (s *CreateAppInput) SetCreateApplicationRequest(v *CreateApplicationRequest) *CreateAppInput {
s.CreateApplicationRequest = v
return s
}
// See also, path_to_url
type CreateAppOutput struct {
_ struct{} `type:"structure" payload:"ApplicationResponse"`
// Application Response.
//
// ApplicationResponse is a required field
ApplicationResponse *ApplicationResponse `type:"structure" required:"true"`
}
// String returns the string representation
func (s CreateAppOutput) String() string {
return awsutil.Prettify(s)
}
// GoString returns the string representation
func (s CreateAppOutput) GoString() string {
return s.String()
}
// SetApplicationResponse sets the ApplicationResponse field's value.
func (s *CreateAppOutput) SetApplicationResponse(v *ApplicationResponse) *CreateAppOutput {
s.ApplicationResponse = v
return s
}
// Application Request.
// See also, path_to_url
type CreateApplicationRequest struct {
_ struct{} `type:"structure"`
// The display name of the application. Used in the Amazon Pinpoint console.
Name *string `type:"string"`
}
// String returns the string representation
func (s CreateApplicationRequest) String() string {
return awsutil.Prettify(s)
}
// GoString returns the string representation
func (s CreateApplicationRequest) GoString() string {
return s.String()
}
// SetName sets the Name field's value.
func (s *CreateApplicationRequest) SetName(v string) *CreateApplicationRequest {
s.Name = &v
return s
}
// See also, path_to_url
type CreateCampaignInput struct {
_ struct{} `type:"structure" payload:"WriteCampaignRequest"`
// ApplicationId is a required field
ApplicationId *string `location:"uri" locationName:"application-id" type:"string" required:"true"`
// Used to create a campaign.
//
// WriteCampaignRequest is a required field
WriteCampaignRequest *WriteCampaignRequest `type:"structure" required:"true"`
}
// String returns the string representation
func (s CreateCampaignInput) String() string {
return awsutil.Prettify(s)
}
// GoString returns the string representation
func (s CreateCampaignInput) GoString() string {
return s.String()
}
// Validate inspects the fields of the type to determine if they are valid.
func (s *CreateCampaignInput) Validate() error {
invalidParams := request.ErrInvalidParams{Context: "CreateCampaignInput"}
if s.ApplicationId == nil {
invalidParams.Add(request.NewErrParamRequired("ApplicationId"))
}
if s.WriteCampaignRequest == nil {
invalidParams.Add(request.NewErrParamRequired("WriteCampaignRequest"))
}
if invalidParams.Len() > 0 {
return invalidParams
}
return nil
}
// SetApplicationId sets the ApplicationId field's value.
func (s *CreateCampaignInput) SetApplicationId(v string) *CreateCampaignInput {
s.ApplicationId = &v
return s
}
// SetWriteCampaignRequest sets the WriteCampaignRequest field's value.
func (s *CreateCampaignInput) SetWriteCampaignRequest(v *WriteCampaignRequest) *CreateCampaignInput {
s.WriteCampaignRequest = v
return s
}
// See also, path_to_url
type CreateCampaignOutput struct {
_ struct{} `type:"structure" payload:"CampaignResponse"`
// Campaign definition
//
// CampaignResponse is a required field
CampaignResponse *CampaignResponse `type:"structure" required:"true"`
}
// String returns the string representation
func (s CreateCampaignOutput) String() string {
return awsutil.Prettify(s)
}
// GoString returns the string representation
func (s CreateCampaignOutput) GoString() string {
return s.String()
}
// SetCampaignResponse sets the CampaignResponse field's value.
func (s *CreateCampaignOutput) SetCampaignResponse(v *CampaignResponse) *CreateCampaignOutput {
s.CampaignResponse = v
return s
}
// See also, path_to_url
type CreateImportJobInput struct {
_ struct{} `type:"structure" payload:"ImportJobRequest"`
// ApplicationId is a required field
ApplicationId *string `location:"uri" locationName:"application-id" type:"string" required:"true"`
// ImportJobRequest is a required field
ImportJobRequest *ImportJobRequest `type:"structure" required:"true"`
}
// String returns the string representation
func (s CreateImportJobInput) String() string {
return awsutil.Prettify(s)
}
// GoString returns the string representation
func (s CreateImportJobInput) GoString() string {
return s.String()
}
// Validate inspects the fields of the type to determine if they are valid.
func (s *CreateImportJobInput) Validate() error {
invalidParams := request.ErrInvalidParams{Context: "CreateImportJobInput"}
if s.ApplicationId == nil {
invalidParams.Add(request.NewErrParamRequired("ApplicationId"))
}
if s.ImportJobRequest == nil {
invalidParams.Add(request.NewErrParamRequired("ImportJobRequest"))
}
if invalidParams.Len() > 0 {
return invalidParams
}
return nil
}
// SetApplicationId sets the ApplicationId field's value.
func (s *CreateImportJobInput) SetApplicationId(v string) *CreateImportJobInput {
s.ApplicationId = &v
return s
}
// SetImportJobRequest sets the ImportJobRequest field's value.
func (s *CreateImportJobInput) SetImportJobRequest(v *ImportJobRequest) *CreateImportJobInput {
s.ImportJobRequest = v
return s
}
// See also, path_to_url
type CreateImportJobOutput struct {
_ struct{} `type:"structure" payload:"ImportJobResponse"`
// ImportJobResponse is a required field
ImportJobResponse *ImportJobResponse `type:"structure" required:"true"`
}
// String returns the string representation
func (s CreateImportJobOutput) String() string {
return awsutil.Prettify(s)
}
// GoString returns the string representation
func (s CreateImportJobOutput) GoString() string {
return s.String()
}
// SetImportJobResponse sets the ImportJobResponse field's value.
func (s *CreateImportJobOutput) SetImportJobResponse(v *ImportJobResponse) *CreateImportJobOutput {
s.ImportJobResponse = v
return s
}
// See also, path_to_url
type CreateSegmentInput struct {
_ struct{} `type:"structure" payload:"WriteSegmentRequest"`
// ApplicationId is a required field
ApplicationId *string `location:"uri" locationName:"application-id" type:"string" required:"true"`
// Segment definition.
//
// WriteSegmentRequest is a required field
WriteSegmentRequest *WriteSegmentRequest `type:"structure" required:"true"`
}
// String returns the string representation
func (s CreateSegmentInput) String() string {
return awsutil.Prettify(s)
}
// GoString returns the string representation
func (s CreateSegmentInput) GoString() string {
return s.String()
}
// Validate inspects the fields of the type to determine if they are valid.
func (s *CreateSegmentInput) Validate() error {
invalidParams := request.ErrInvalidParams{Context: "CreateSegmentInput"}
if s.ApplicationId == nil {
invalidParams.Add(request.NewErrParamRequired("ApplicationId"))
}
if s.WriteSegmentRequest == nil {
invalidParams.Add(request.NewErrParamRequired("WriteSegmentRequest"))
}
if invalidParams.Len() > 0 {
return invalidParams
}
return nil
}
// SetApplicationId sets the ApplicationId field's value.
func (s *CreateSegmentInput) SetApplicationId(v string) *CreateSegmentInput {
s.ApplicationId = &v
return s
}
// SetWriteSegmentRequest sets the WriteSegmentRequest field's value.
func (s *CreateSegmentInput) SetWriteSegmentRequest(v *WriteSegmentRequest) *CreateSegmentInput {
s.WriteSegmentRequest = v
return s
}
// See also, path_to_url
type CreateSegmentOutput struct {
_ struct{} `type:"structure" payload:"SegmentResponse"`
// Segment definition.
//
// SegmentResponse is a required field
SegmentResponse *SegmentResponse `type:"structure" required:"true"`
}
// String returns the string representation
func (s CreateSegmentOutput) String() string {
return awsutil.Prettify(s)
}
// GoString returns the string representation
func (s CreateSegmentOutput) GoString() string {
return s.String()
}
// SetSegmentResponse sets the SegmentResponse field's value.
func (s *CreateSegmentOutput) SetSegmentResponse(v *SegmentResponse) *CreateSegmentOutput {
s.SegmentResponse = v
return s
}
// Default Message across push notification, email, and sms.
// See also, path_to_url
type DefaultMessage struct {
_ struct{} `type:"structure"`
// The message body of the notification, the email body or the text message.
Body *string `type:"string"`
Substitutions map[string][]*string `type:"map"`
}
// String returns the string representation
func (s DefaultMessage) String() string {
return awsutil.Prettify(s)
}
// GoString returns the string representation
func (s DefaultMessage) GoString() string {
return s.String()
}
// SetBody sets the Body field's value.
func (s *DefaultMessage) SetBody(v string) *DefaultMessage {
s.Body = &v
return s
}
// SetSubstitutions sets the Substitutions field's value.
func (s *DefaultMessage) SetSubstitutions(v map[string][]*string) *DefaultMessage {
s.Substitutions = v
return s
}
// Default Push Notification Message.
// See also, path_to_url
type DefaultPushNotificationMessage struct {
_ struct{} `type:"structure"`
// The action that occurs if the user taps a push notification delivered by
// the campaign: OPEN_APP - Your app launches, or it becomes the foreground
// app if it has been sent to the background. This is the default action. DEEP_LINK
// - Uses deep linking features in iOS and Android to open your app and display
// a designated user interface within the app. URL - The default mobile browser
// on the user's device launches and opens a web page at the URL you specify.
// Possible values include: OPEN_APP | DEEP_LINK | URL
Action *string `type:"string" enum:"Action"`
// The message body of the notification, the email body or the text message.
Body *string `type:"string"`
Data map[string]*string `type:"map"`
// Indicates if the message should display on the users device. Silent pushes
// can be used for Remote Configuration and Phone Home use cases.
SilentPush *bool `type:"boolean"`
Substitutions map[string][]*string `type:"map"`
// The message title that displays above the message on the user's device.
Title *string `type:"string"`
// The URL to open in the user's mobile browser. Used if the value for Action
// is URL.
Url *string `type:"string"`
}
// String returns the string representation
func (s DefaultPushNotificationMessage) String() string {
return awsutil.Prettify(s)
}
// GoString returns the string representation
func (s DefaultPushNotificationMessage) GoString() string {
return s.String()
}
// SetAction sets the Action field's value.
func (s *DefaultPushNotificationMessage) SetAction(v string) *DefaultPushNotificationMessage {
s.Action = &v
return s
}
// SetBody sets the Body field's value.
func (s *DefaultPushNotificationMessage) SetBody(v string) *DefaultPushNotificationMessage {
s.Body = &v
return s
}
// SetData sets the Data field's value.
func (s *DefaultPushNotificationMessage) SetData(v map[string]*string) *DefaultPushNotificationMessage {
s.Data = v
return s
}
// SetSilentPush sets the SilentPush field's value.
func (s *DefaultPushNotificationMessage) SetSilentPush(v bool) *DefaultPushNotificationMessage {
s.SilentPush = &v
return s
}
// SetSubstitutions sets the Substitutions field's value.
func (s *DefaultPushNotificationMessage) SetSubstitutions(v map[string][]*string) *DefaultPushNotificationMessage {
s.Substitutions = v
return s
}
// SetTitle sets the Title field's value.
func (s *DefaultPushNotificationMessage) SetTitle(v string) *DefaultPushNotificationMessage {
s.Title = &v
return s
}
// SetUrl sets the Url field's value.
func (s *DefaultPushNotificationMessage) SetUrl(v string) *DefaultPushNotificationMessage {
s.Url = &v
return s
}
// See also, path_to_url
type DeleteAdmChannelInput struct {
_ struct{} `type:"structure"`
// ApplicationId is a required field
ApplicationId *string `location:"uri" locationName:"application-id" type:"string" required:"true"`
}
// String returns the string representation
func (s DeleteAdmChannelInput) String() string {
return awsutil.Prettify(s)
}
// GoString returns the string representation
func (s DeleteAdmChannelInput) GoString() string {
return s.String()
}
// Validate inspects the fields of the type to determine if they are valid.
func (s *DeleteAdmChannelInput) Validate() error {
invalidParams := request.ErrInvalidParams{Context: "DeleteAdmChannelInput"}
if s.ApplicationId == nil {
invalidParams.Add(request.NewErrParamRequired("ApplicationId"))
}
if invalidParams.Len() > 0 {
return invalidParams
}
return nil
}
// SetApplicationId sets the ApplicationId field's value.
func (s *DeleteAdmChannelInput) SetApplicationId(v string) *DeleteAdmChannelInput {
s.ApplicationId = &v
return s
}
// See also, path_to_url
type DeleteAdmChannelOutput struct {
_ struct{} `type:"structure" payload:"ADMChannelResponse"`
// Amazon Device Messaging channel definition.
//
// ADMChannelResponse is a required field
ADMChannelResponse *ADMChannelResponse `type:"structure" required:"true"`
}
// String returns the string representation
func (s DeleteAdmChannelOutput) String() string {
return awsutil.Prettify(s)
}
// GoString returns the string representation
func (s DeleteAdmChannelOutput) GoString() string {
return s.String()
}
// SetADMChannelResponse sets the ADMChannelResponse field's value.
func (s *DeleteAdmChannelOutput) SetADMChannelResponse(v *ADMChannelResponse) *DeleteAdmChannelOutput {
s.ADMChannelResponse = v
return s
}
// See also, path_to_url
type DeleteApnsChannelInput struct {
_ struct{} `type:"structure"`
// ApplicationId is a required field
ApplicationId *string `location:"uri" locationName:"application-id" type:"string" required:"true"`
}
// String returns the string representation
func (s DeleteApnsChannelInput) String() string {
return awsutil.Prettify(s)
}
// GoString returns the string representation
func (s DeleteApnsChannelInput) GoString() string {
return s.String()
}
// Validate inspects the fields of the type to determine if they are valid.
func (s *DeleteApnsChannelInput) Validate() error {
invalidParams := request.ErrInvalidParams{Context: "DeleteApnsChannelInput"}
if s.ApplicationId == nil {
invalidParams.Add(request.NewErrParamRequired("ApplicationId"))
}
if invalidParams.Len() > 0 {
return invalidParams
}
return nil
}
// SetApplicationId sets the ApplicationId field's value.
func (s *DeleteApnsChannelInput) SetApplicationId(v string) *DeleteApnsChannelInput {
s.ApplicationId = &v
return s
}
// See also, path_to_url
type DeleteApnsChannelOutput struct {
_ struct{} `type:"structure" payload:"APNSChannelResponse"`
// Apple Distribution Push Notification Service channel definition.
//
// APNSChannelResponse is a required field
APNSChannelResponse *APNSChannelResponse `type:"structure" required:"true"`
}
// String returns the string representation
func (s DeleteApnsChannelOutput) String() string {
return awsutil.Prettify(s)
}
// GoString returns the string representation
func (s DeleteApnsChannelOutput) GoString() string {
return s.String()
}
// SetAPNSChannelResponse sets the APNSChannelResponse field's value.
func (s *DeleteApnsChannelOutput) SetAPNSChannelResponse(v *APNSChannelResponse) *DeleteApnsChannelOutput {
s.APNSChannelResponse = v
return s
}
// See also, path_to_url
type DeleteApnsSandboxChannelInput struct {
_ struct{} `type:"structure"`
// ApplicationId is a required field
ApplicationId *string `location:"uri" locationName:"application-id" type:"string" required:"true"`
}
// String returns the string representation
func (s DeleteApnsSandboxChannelInput) String() string {
return awsutil.Prettify(s)
}
// GoString returns the string representation
func (s DeleteApnsSandboxChannelInput) GoString() string {
return s.String()
}
// Validate inspects the fields of the type to determine if they are valid.
func (s *DeleteApnsSandboxChannelInput) Validate() error {
invalidParams := request.ErrInvalidParams{Context: "DeleteApnsSandboxChannelInput"}
if s.ApplicationId == nil {
invalidParams.Add(request.NewErrParamRequired("ApplicationId"))
}
if invalidParams.Len() > 0 {
return invalidParams
}
return nil
}
// SetApplicationId sets the ApplicationId field's value.
func (s *DeleteApnsSandboxChannelInput) SetApplicationId(v string) *DeleteApnsSandboxChannelInput {
s.ApplicationId = &v
return s
}
// See also, path_to_url
type DeleteApnsSandboxChannelOutput struct {
_ struct{} `type:"structure" payload:"APNSSandboxChannelResponse"`
// Apple Development Push Notification Service channel definition.
//
// APNSSandboxChannelResponse is a required field
APNSSandboxChannelResponse *APNSSandboxChannelResponse `type:"structure" required:"true"`
}
// String returns the string representation
func (s DeleteApnsSandboxChannelOutput) String() string {
return awsutil.Prettify(s)
}
// GoString returns the string representation
func (s DeleteApnsSandboxChannelOutput) GoString() string {
return s.String()
}
// SetAPNSSandboxChannelResponse sets the APNSSandboxChannelResponse field's value.
func (s *DeleteApnsSandboxChannelOutput) SetAPNSSandboxChannelResponse(v *APNSSandboxChannelResponse) *DeleteApnsSandboxChannelOutput {
s.APNSSandboxChannelResponse = v
return s
}
// See also, path_to_url
type DeleteApnsVoipChannelInput struct {
_ struct{} `type:"structure"`
// ApplicationId is a required field
ApplicationId *string `location:"uri" locationName:"application-id" type:"string" required:"true"`
}
// String returns the string representation
func (s DeleteApnsVoipChannelInput) String() string {
return awsutil.Prettify(s)
}
// GoString returns the string representation
func (s DeleteApnsVoipChannelInput) GoString() string {
return s.String()
}
// Validate inspects the fields of the type to determine if they are valid.
func (s *DeleteApnsVoipChannelInput) Validate() error {
invalidParams := request.ErrInvalidParams{Context: "DeleteApnsVoipChannelInput"}
if s.ApplicationId == nil {
invalidParams.Add(request.NewErrParamRequired("ApplicationId"))
}
if invalidParams.Len() > 0 {
return invalidParams
}
return nil
}
// SetApplicationId sets the ApplicationId field's value.
func (s *DeleteApnsVoipChannelInput) SetApplicationId(v string) *DeleteApnsVoipChannelInput {
s.ApplicationId = &v
return s
}
// See also, path_to_url
type DeleteApnsVoipChannelOutput struct {
_ struct{} `type:"structure" payload:"APNSVoipChannelResponse"`
// Apple VOIP Push Notification Service channel definition.
//
// APNSVoipChannelResponse is a required field
APNSVoipChannelResponse *APNSVoipChannelResponse `type:"structure" required:"true"`
}
// String returns the string representation
func (s DeleteApnsVoipChannelOutput) String() string {
return awsutil.Prettify(s)
}
// GoString returns the string representation
func (s DeleteApnsVoipChannelOutput) GoString() string {
return s.String()
}
// SetAPNSVoipChannelResponse sets the APNSVoipChannelResponse field's value.
func (s *DeleteApnsVoipChannelOutput) SetAPNSVoipChannelResponse(v *APNSVoipChannelResponse) *DeleteApnsVoipChannelOutput {
s.APNSVoipChannelResponse = v
return s
}
// See also, path_to_url
type DeleteApnsVoipSandboxChannelInput struct {
_ struct{} `type:"structure"`
// ApplicationId is a required field
ApplicationId *string `location:"uri" locationName:"application-id" type:"string" required:"true"`
}
// String returns the string representation
func (s DeleteApnsVoipSandboxChannelInput) String() string {
return awsutil.Prettify(s)
}
// GoString returns the string representation
func (s DeleteApnsVoipSandboxChannelInput) GoString() string {
return s.String()
}
// Validate inspects the fields of the type to determine if they are valid.
func (s *DeleteApnsVoipSandboxChannelInput) Validate() error {
invalidParams := request.ErrInvalidParams{Context: "DeleteApnsVoipSandboxChannelInput"}
if s.ApplicationId == nil {
invalidParams.Add(request.NewErrParamRequired("ApplicationId"))
}
if invalidParams.Len() > 0 {
return invalidParams
}
return nil
}
// SetApplicationId sets the ApplicationId field's value.
func (s *DeleteApnsVoipSandboxChannelInput) SetApplicationId(v string) *DeleteApnsVoipSandboxChannelInput {
s.ApplicationId = &v
return s
}
// See also, path_to_url
type DeleteApnsVoipSandboxChannelOutput struct {
_ struct{} `type:"structure" payload:"APNSVoipSandboxChannelResponse"`
// Apple VOIP Developer Push Notification Service channel definition.
//
// APNSVoipSandboxChannelResponse is a required field
APNSVoipSandboxChannelResponse *APNSVoipSandboxChannelResponse `type:"structure" required:"true"`
}
// String returns the string representation
func (s DeleteApnsVoipSandboxChannelOutput) String() string {
return awsutil.Prettify(s)
}
// GoString returns the string representation
func (s DeleteApnsVoipSandboxChannelOutput) GoString() string {
return s.String()
}
// SetAPNSVoipSandboxChannelResponse sets the APNSVoipSandboxChannelResponse field's value.
func (s *DeleteApnsVoipSandboxChannelOutput) SetAPNSVoipSandboxChannelResponse(v *APNSVoipSandboxChannelResponse) *DeleteApnsVoipSandboxChannelOutput {
s.APNSVoipSandboxChannelResponse = v
return s
}
// See also, path_to_url
type DeleteAppInput struct {
_ struct{} `type:"structure"`
// ApplicationId is a required field
ApplicationId *string `location:"uri" locationName:"application-id" type:"string" required:"true"`
}
// String returns the string representation
func (s DeleteAppInput) String() string {
return awsutil.Prettify(s)
}
// GoString returns the string representation
func (s DeleteAppInput) GoString() string {
return s.String()
}
// Validate inspects the fields of the type to determine if they are valid.
func (s *DeleteAppInput) Validate() error {
invalidParams := request.ErrInvalidParams{Context: "DeleteAppInput"}
if s.ApplicationId == nil {
invalidParams.Add(request.NewErrParamRequired("ApplicationId"))
}
if invalidParams.Len() > 0 {
return invalidParams
}
return nil
}
// SetApplicationId sets the ApplicationId field's value.
func (s *DeleteAppInput) SetApplicationId(v string) *DeleteAppInput {
s.ApplicationId = &v
return s
}
// See also, path_to_url
type DeleteAppOutput struct {
_ struct{} `type:"structure" payload:"ApplicationResponse"`
// Application Response.
//
// ApplicationResponse is a required field
ApplicationResponse *ApplicationResponse `type:"structure" required:"true"`
}
// String returns the string representation
func (s DeleteAppOutput) String() string {
return awsutil.Prettify(s)
}
// GoString returns the string representation
func (s DeleteAppOutput) GoString() string {
return s.String()
}
// SetApplicationResponse sets the ApplicationResponse field's value.
func (s *DeleteAppOutput) SetApplicationResponse(v *ApplicationResponse) *DeleteAppOutput {
s.ApplicationResponse = v
return s
}
// See also, path_to_url
type DeleteBaiduChannelInput struct {
_ struct{} `type:"structure"`
// ApplicationId is a required field
ApplicationId *string `location:"uri" locationName:"application-id" type:"string" required:"true"`
}
// String returns the string representation
func (s DeleteBaiduChannelInput) String() string {
return awsutil.Prettify(s)
}
// GoString returns the string representation
func (s DeleteBaiduChannelInput) GoString() string {
return s.String()
}
// Validate inspects the fields of the type to determine if they are valid.
func (s *DeleteBaiduChannelInput) Validate() error {
invalidParams := request.ErrInvalidParams{Context: "DeleteBaiduChannelInput"}
if s.ApplicationId == nil {
invalidParams.Add(request.NewErrParamRequired("ApplicationId"))
}
if invalidParams.Len() > 0 {
return invalidParams
}
return nil
}
// SetApplicationId sets the ApplicationId field's value.
func (s *DeleteBaiduChannelInput) SetApplicationId(v string) *DeleteBaiduChannelInput {
s.ApplicationId = &v
return s
}
// See also, path_to_url
type DeleteBaiduChannelOutput struct {
_ struct{} `type:"structure" payload:"BaiduChannelResponse"`
// Baidu Cloud Messaging channel definition
//
// BaiduChannelResponse is a required field
BaiduChannelResponse *BaiduChannelResponse `type:"structure" required:"true"`
}
// String returns the string representation
func (s DeleteBaiduChannelOutput) String() string {
return awsutil.Prettify(s)
}
// GoString returns the string representation
func (s DeleteBaiduChannelOutput) GoString() string {
return s.String()
}
// SetBaiduChannelResponse sets the BaiduChannelResponse field's value.
func (s *DeleteBaiduChannelOutput) SetBaiduChannelResponse(v *BaiduChannelResponse) *DeleteBaiduChannelOutput {
s.BaiduChannelResponse = v
return s
}
// See also, path_to_url
type DeleteCampaignInput struct {
_ struct{} `type:"structure"`
// ApplicationId is a required field
ApplicationId *string `location:"uri" locationName:"application-id" type:"string" required:"true"`
// CampaignId is a required field
CampaignId *string `location:"uri" locationName:"campaign-id" type:"string" required:"true"`
}
// String returns the string representation
func (s DeleteCampaignInput) String() string {
return awsutil.Prettify(s)
}
// GoString returns the string representation
func (s DeleteCampaignInput) GoString() string {
return s.String()
}
// Validate inspects the fields of the type to determine if they are valid.
func (s *DeleteCampaignInput) Validate() error {
invalidParams := request.ErrInvalidParams{Context: "DeleteCampaignInput"}
if s.ApplicationId == nil {
invalidParams.Add(request.NewErrParamRequired("ApplicationId"))
}
if s.CampaignId == nil {
invalidParams.Add(request.NewErrParamRequired("CampaignId"))
}
if invalidParams.Len() > 0 {
return invalidParams
}
return nil
}
// SetApplicationId sets the ApplicationId field's value.
func (s *DeleteCampaignInput) SetApplicationId(v string) *DeleteCampaignInput {
s.ApplicationId = &v
return s
}
// SetCampaignId sets the CampaignId field's value.
func (s *DeleteCampaignInput) SetCampaignId(v string) *DeleteCampaignInput {
s.CampaignId = &v
return s
}
// See also, path_to_url
type DeleteCampaignOutput struct {
_ struct{} `type:"structure" payload:"CampaignResponse"`
// Campaign definition
//
// CampaignResponse is a required field
CampaignResponse *CampaignResponse `type:"structure" required:"true"`
}
// String returns the string representation
func (s DeleteCampaignOutput) String() string {
return awsutil.Prettify(s)
}
// GoString returns the string representation
func (s DeleteCampaignOutput) GoString() string {
return s.String()
}
// SetCampaignResponse sets the CampaignResponse field's value.
func (s *DeleteCampaignOutput) SetCampaignResponse(v *CampaignResponse) *DeleteCampaignOutput {
s.CampaignResponse = v
return s
}
// See also, path_to_url
type DeleteEmailChannelInput struct {
_ struct{} `type:"structure"`
// ApplicationId is a required field
ApplicationId *string `location:"uri" locationName:"application-id" type:"string" required:"true"`
}
// String returns the string representation
func (s DeleteEmailChannelInput) String() string {
return awsutil.Prettify(s)
}
// GoString returns the string representation
func (s DeleteEmailChannelInput) GoString() string {
return s.String()
}
// Validate inspects the fields of the type to determine if they are valid.
func (s *DeleteEmailChannelInput) Validate() error {
invalidParams := request.ErrInvalidParams{Context: "DeleteEmailChannelInput"}
if s.ApplicationId == nil {
invalidParams.Add(request.NewErrParamRequired("ApplicationId"))
}
if invalidParams.Len() > 0 {
return invalidParams
}
return nil
}
// SetApplicationId sets the ApplicationId field's value.
func (s *DeleteEmailChannelInput) SetApplicationId(v string) *DeleteEmailChannelInput {
s.ApplicationId = &v
return s
}
// See also, path_to_url
type DeleteEmailChannelOutput struct {
_ struct{} `type:"structure" payload:"EmailChannelResponse"`
// Email Channel Response.
//
// EmailChannelResponse is a required field
EmailChannelResponse *EmailChannelResponse `type:"structure" required:"true"`
}
// String returns the string representation
func (s DeleteEmailChannelOutput) String() string {
return awsutil.Prettify(s)
}
// GoString returns the string representation
func (s DeleteEmailChannelOutput) GoString() string {
return s.String()
}
// SetEmailChannelResponse sets the EmailChannelResponse field's value.
func (s *DeleteEmailChannelOutput) SetEmailChannelResponse(v *EmailChannelResponse) *DeleteEmailChannelOutput {
s.EmailChannelResponse = v
return s
}
// See also, path_to_url
type DeleteEventStreamInput struct {
_ struct{} `type:"structure"`
// Application Id.
//
// ApplicationId is a required field
ApplicationId *string `location:"uri" locationName:"application-id" type:"string" required:"true"`
}
// String returns the string representation
func (s DeleteEventStreamInput) String() string {
return awsutil.Prettify(s)
}
// GoString returns the string representation
func (s DeleteEventStreamInput) GoString() string {
return s.String()
}
// Validate inspects the fields of the type to determine if they are valid.
func (s *DeleteEventStreamInput) Validate() error {
invalidParams := request.ErrInvalidParams{Context: "DeleteEventStreamInput"}
if s.ApplicationId == nil {
invalidParams.Add(request.NewErrParamRequired("ApplicationId"))
}
if invalidParams.Len() > 0 {
return invalidParams
}
return nil
}
// SetApplicationId sets the ApplicationId field's value.
func (s *DeleteEventStreamInput) SetApplicationId(v string) *DeleteEventStreamInput {
s.ApplicationId = &v
return s
}
// See also, path_to_url
type DeleteEventStreamOutput struct {
_ struct{} `type:"structure" payload:"EventStream"`
// Model for an event publishing subscription export.
//
// EventStream is a required field
EventStream *EventStream `type:"structure" required:"true"`
}
// String returns the string representation
func (s DeleteEventStreamOutput) String() string {
return awsutil.Prettify(s)
}
// GoString returns the string representation
func (s DeleteEventStreamOutput) GoString() string {
return s.String()
}
// SetEventStream sets the EventStream field's value.
func (s *DeleteEventStreamOutput) SetEventStream(v *EventStream) *DeleteEventStreamOutput {
s.EventStream = v
return s
}
// See also, path_to_url
type DeleteGcmChannelInput struct {
_ struct{} `type:"structure"`
// ApplicationId is a required field
ApplicationId *string `location:"uri" locationName:"application-id" type:"string" required:"true"`
}
// String returns the string representation
func (s DeleteGcmChannelInput) String() string {
return awsutil.Prettify(s)
}
// GoString returns the string representation
func (s DeleteGcmChannelInput) GoString() string {
return s.String()
}
// Validate inspects the fields of the type to determine if they are valid.
func (s *DeleteGcmChannelInput) Validate() error {
invalidParams := request.ErrInvalidParams{Context: "DeleteGcmChannelInput"}
if s.ApplicationId == nil {
invalidParams.Add(request.NewErrParamRequired("ApplicationId"))
}
if invalidParams.Len() > 0 {
return invalidParams
}
return nil
}
// SetApplicationId sets the ApplicationId field's value.
func (s *DeleteGcmChannelInput) SetApplicationId(v string) *DeleteGcmChannelInput {
s.ApplicationId = &v
return s
}
// See also, path_to_url
type DeleteGcmChannelOutput struct {
_ struct{} `type:"structure" payload:"GCMChannelResponse"`
// Google Cloud Messaging channel definition
//
// GCMChannelResponse is a required field
GCMChannelResponse *GCMChannelResponse `type:"structure" required:"true"`
}
// String returns the string representation
func (s DeleteGcmChannelOutput) String() string {
return awsutil.Prettify(s)
}
// GoString returns the string representation
func (s DeleteGcmChannelOutput) GoString() string {
return s.String()
}
// SetGCMChannelResponse sets the GCMChannelResponse field's value.
func (s *DeleteGcmChannelOutput) SetGCMChannelResponse(v *GCMChannelResponse) *DeleteGcmChannelOutput {
s.GCMChannelResponse = v
return s
}
// See also, path_to_url
type DeleteSegmentInput struct {
_ struct{} `type:"structure"`
// ApplicationId is a required field
ApplicationId *string `location:"uri" locationName:"application-id" type:"string" required:"true"`
// SegmentId is a required field
SegmentId *string `location:"uri" locationName:"segment-id" type:"string" required:"true"`
}
// String returns the string representation
func (s DeleteSegmentInput) String() string {
return awsutil.Prettify(s)
}
// GoString returns the string representation
func (s DeleteSegmentInput) GoString() string {
return s.String()
}
// Validate inspects the fields of the type to determine if they are valid.
func (s *DeleteSegmentInput) Validate() error {
invalidParams := request.ErrInvalidParams{Context: "DeleteSegmentInput"}
if s.ApplicationId == nil {
invalidParams.Add(request.NewErrParamRequired("ApplicationId"))
}
if s.SegmentId == nil {
invalidParams.Add(request.NewErrParamRequired("SegmentId"))
}
if invalidParams.Len() > 0 {
return invalidParams
}
return nil
}
// SetApplicationId sets the ApplicationId field's value.
func (s *DeleteSegmentInput) SetApplicationId(v string) *DeleteSegmentInput {
s.ApplicationId = &v
return s
}
// SetSegmentId sets the SegmentId field's value.
func (s *DeleteSegmentInput) SetSegmentId(v string) *DeleteSegmentInput {
s.SegmentId = &v
return s
}
// See also, path_to_url
type DeleteSegmentOutput struct {
_ struct{} `type:"structure" payload:"SegmentResponse"`
// Segment definition.
//
// SegmentResponse is a required field
SegmentResponse *SegmentResponse `type:"structure" required:"true"`
}
// String returns the string representation
func (s DeleteSegmentOutput) String() string {
return awsutil.Prettify(s)
}
// GoString returns the string representation
func (s DeleteSegmentOutput) GoString() string {
return s.String()
}
// SetSegmentResponse sets the SegmentResponse field's value.
func (s *DeleteSegmentOutput) SetSegmentResponse(v *SegmentResponse) *DeleteSegmentOutput {
s.SegmentResponse = v
return s
}
// See also, path_to_url
type DeleteSmsChannelInput struct {
_ struct{} `type:"structure"`
// ApplicationId is a required field
ApplicationId *string `location:"uri" locationName:"application-id" type:"string" required:"true"`
}
// String returns the string representation
func (s DeleteSmsChannelInput) String() string {
return awsutil.Prettify(s)
}
// GoString returns the string representation
func (s DeleteSmsChannelInput) GoString() string {
return s.String()
}
// Validate inspects the fields of the type to determine if they are valid.
func (s *DeleteSmsChannelInput) Validate() error {
invalidParams := request.ErrInvalidParams{Context: "DeleteSmsChannelInput"}
if s.ApplicationId == nil {
invalidParams.Add(request.NewErrParamRequired("ApplicationId"))
}
if invalidParams.Len() > 0 {
return invalidParams
}
return nil
}
// SetApplicationId sets the ApplicationId field's value.
func (s *DeleteSmsChannelInput) SetApplicationId(v string) *DeleteSmsChannelInput {
s.ApplicationId = &v
return s
}
// See also, path_to_url
type DeleteSmsChannelOutput struct {
_ struct{} `type:"structure" payload:"SMSChannelResponse"`
// SMS Channel Response.
//
// SMSChannelResponse is a required field
SMSChannelResponse *SMSChannelResponse `type:"structure" required:"true"`
}
// String returns the string representation
func (s DeleteSmsChannelOutput) String() string {
return awsutil.Prettify(s)
}
// GoString returns the string representation
func (s DeleteSmsChannelOutput) GoString() string {
return s.String()
}
// SetSMSChannelResponse sets the SMSChannelResponse field's value.
func (s *DeleteSmsChannelOutput) SetSMSChannelResponse(v *SMSChannelResponse) *DeleteSmsChannelOutput {
s.SMSChannelResponse = v
return s
}
// The message configuration.
// See also, path_to_url
type DirectMessageConfiguration struct {
_ struct{} `type:"structure"`
// The message to ADM channels. Overrides the default push notification message.
ADMMessage *ADMMessage `type:"structure"`
// The message to APNS channels. Overrides the default push notification message.
APNSMessage *APNSMessage `type:"structure"`
// The message to Baidu GCM channels. Overrides the default push notification
// message.
BaiduMessage *BaiduMessage `type:"structure"`
// The default message for all channels.
DefaultMessage *DefaultMessage `type:"structure"`
// The default push notification message for all push channels.
DefaultPushNotificationMessage *DefaultPushNotificationMessage `type:"structure"`
// The message to GCM channels. Overrides the default push notification message.
GCMMessage *GCMMessage `type:"structure"`
// The message to SMS channels. Overrides the default message.
SMSMessage *SMSMessage `type:"structure"`
}
// String returns the string representation
func (s DirectMessageConfiguration) String() string {
return awsutil.Prettify(s)
}
// GoString returns the string representation
func (s DirectMessageConfiguration) GoString() string {
return s.String()
}
// SetADMMessage sets the ADMMessage field's value.
func (s *DirectMessageConfiguration) SetADMMessage(v *ADMMessage) *DirectMessageConfiguration {
s.ADMMessage = v
return s
}
// SetAPNSMessage sets the APNSMessage field's value.
func (s *DirectMessageConfiguration) SetAPNSMessage(v *APNSMessage) *DirectMessageConfiguration {
s.APNSMessage = v
return s
}
// SetBaiduMessage sets the BaiduMessage field's value.
func (s *DirectMessageConfiguration) SetBaiduMessage(v *BaiduMessage) *DirectMessageConfiguration {
s.BaiduMessage = v
return s
}
// SetDefaultMessage sets the DefaultMessage field's value.
func (s *DirectMessageConfiguration) SetDefaultMessage(v *DefaultMessage) *DirectMessageConfiguration {
s.DefaultMessage = v
return s
}
// SetDefaultPushNotificationMessage sets the DefaultPushNotificationMessage field's value.
func (s *DirectMessageConfiguration) SetDefaultPushNotificationMessage(v *DefaultPushNotificationMessage) *DirectMessageConfiguration {
s.DefaultPushNotificationMessage = v
return s
}
// SetGCMMessage sets the GCMMessage field's value.
func (s *DirectMessageConfiguration) SetGCMMessage(v *GCMMessage) *DirectMessageConfiguration {
s.GCMMessage = v
return s
}
// SetSMSMessage sets the SMSMessage field's value.
func (s *DirectMessageConfiguration) SetSMSMessage(v *SMSMessage) *DirectMessageConfiguration {
s.SMSMessage = v
return s
}
// Email Channel Request
// See also, path_to_url
type EmailChannelRequest struct {
_ struct{} `type:"structure"`
// If the channel is enabled for sending messages.
Enabled *bool `type:"boolean"`
// The email address used to send emails from.
FromAddress *string `type:"string"`
// The ARN of an identity verified with SES.
Identity *string `type:"string"`
// The ARN of an IAM Role used to submit events to Mobile Analytics' event ingestion
// service
RoleArn *string `type:"string"`
}
// String returns the string representation
func (s EmailChannelRequest) String() string {
return awsutil.Prettify(s)
}
// GoString returns the string representation
func (s EmailChannelRequest) GoString() string {
return s.String()
}
// SetEnabled sets the Enabled field's value.
func (s *EmailChannelRequest) SetEnabled(v bool) *EmailChannelRequest {
s.Enabled = &v
return s
}
// SetFromAddress sets the FromAddress field's value.
func (s *EmailChannelRequest) SetFromAddress(v string) *EmailChannelRequest {
s.FromAddress = &v
return s
}
// SetIdentity sets the Identity field's value.
func (s *EmailChannelRequest) SetIdentity(v string) *EmailChannelRequest {
s.Identity = &v
return s
}
// SetRoleArn sets the RoleArn field's value.
func (s *EmailChannelRequest) SetRoleArn(v string) *EmailChannelRequest {
s.RoleArn = &v
return s
}
// Email Channel Response.
// See also, path_to_url
type EmailChannelResponse struct {
_ struct{} `type:"structure"`
// The unique ID of the application to which the email channel belongs.
ApplicationId *string `type:"string"`
// The date that the settings were last updated in ISO 8601 format.
CreationDate *string `type:"string"`
// If the channel is enabled for sending messages.
Enabled *bool `type:"boolean"`
// The email address used to send emails from.
FromAddress *string `type:"string"`
// If the channel is registered with a credential for authentication.
HasCredential *bool `type:"boolean"`
// Channel ID. Not used, only for backwards compatibility.
Id *string `type:"string"`
// The ARN of an identity verified with SES.
Identity *string `type:"string"`
// Is this channel archived
IsArchived *bool `type:"boolean"`
// Who last updated this entry
LastModifiedBy *string `type:"string"`
// Last date this was updated
LastModifiedDate *string `type:"string"`
// Platform type. Will be "EMAIL"
Platform *string `type:"string"`
// The ARN of an IAM Role used to submit events to Mobile Analytics' event ingestion
// service
RoleArn *string `type:"string"`
// Version of channel
Version *int64 `type:"integer"`
}
// String returns the string representation
func (s EmailChannelResponse) String() string {
return awsutil.Prettify(s)
}
// GoString returns the string representation
func (s EmailChannelResponse) GoString() string {
return s.String()
}
// SetApplicationId sets the ApplicationId field's value.
func (s *EmailChannelResponse) SetApplicationId(v string) *EmailChannelResponse {
s.ApplicationId = &v
return s
}
// SetCreationDate sets the CreationDate field's value.
func (s *EmailChannelResponse) SetCreationDate(v string) *EmailChannelResponse {
s.CreationDate = &v
return s
}
// SetEnabled sets the Enabled field's value.
func (s *EmailChannelResponse) SetEnabled(v bool) *EmailChannelResponse {
s.Enabled = &v
return s
}
// SetFromAddress sets the FromAddress field's value.
func (s *EmailChannelResponse) SetFromAddress(v string) *EmailChannelResponse {
s.FromAddress = &v
return s
}
// SetHasCredential sets the HasCredential field's value.
func (s *EmailChannelResponse) SetHasCredential(v bool) *EmailChannelResponse {
s.HasCredential = &v
return s
}
// SetId sets the Id field's value.
func (s *EmailChannelResponse) SetId(v string) *EmailChannelResponse {
s.Id = &v
return s
}
// SetIdentity sets the Identity field's value.
func (s *EmailChannelResponse) SetIdentity(v string) *EmailChannelResponse {
s.Identity = &v
return s
}
// SetIsArchived sets the IsArchived field's value.
func (s *EmailChannelResponse) SetIsArchived(v bool) *EmailChannelResponse {
s.IsArchived = &v
return s
}
// SetLastModifiedBy sets the LastModifiedBy field's value.
func (s *EmailChannelResponse) SetLastModifiedBy(v string) *EmailChannelResponse {
s.LastModifiedBy = &v
return s
}
// SetLastModifiedDate sets the LastModifiedDate field's value.
func (s *EmailChannelResponse) SetLastModifiedDate(v string) *EmailChannelResponse {
s.LastModifiedDate = &v
return s
}
// SetPlatform sets the Platform field's value.
func (s *EmailChannelResponse) SetPlatform(v string) *EmailChannelResponse {
s.Platform = &v
return s
}
// SetRoleArn sets the RoleArn field's value.
func (s *EmailChannelResponse) SetRoleArn(v string) *EmailChannelResponse {
s.RoleArn = &v
return s
}
// SetVersion sets the Version field's value.
func (s *EmailChannelResponse) SetVersion(v int64) *EmailChannelResponse {
s.Version = &v
return s
}
// Endpoint update request
// See also, path_to_url
type EndpointBatchItem struct {
_ struct{} `type:"structure"`
// The address or token of the endpoint as provided by your push provider (e.g.
// DeviceToken or RegistrationId).
Address *string `type:"string"`
Attributes map[string][]*string `type:"map"`
// The channel type.Valid values: GCM | APNS | SMS | EMAIL
ChannelType *string `type:"string" enum:"ChannelType"`
// The endpoint demographic attributes.
Demographic *EndpointDemographic `type:"structure"`
// The last time the endpoint was updated. Provided in ISO 8601 format.
EffectiveDate *string `type:"string"`
// The endpoint status. Can be either ACTIVE or INACTIVE. Will be set to INACTIVE
// if a delivery fails. Will be set to ACTIVE if the address is updated.
EndpointStatus *string `type:"string"`
// The unique Id for the Endpoint in the batch.
Id *string `type:"string"`
// The endpoint location attributes.
Location *EndpointLocation `type:"structure"`
Metrics map[string]*float64 `type:"map"`
// Indicates whether a user has opted out of receiving messages with one of
// the following values:ALL - User has opted out of all messages.NONE - Users
// has not opted out and receives all messages.
OptOut *string `type:"string"`
// The unique ID for the most recent request to update the endpoint.
RequestId *string `type:"string"`
// Custom user-specific attributes that your app reports to Amazon Pinpoint.
User *EndpointUser `type:"structure"`
}
// String returns the string representation
func (s EndpointBatchItem) String() string {
return awsutil.Prettify(s)
}
// GoString returns the string representation
func (s EndpointBatchItem) GoString() string {
return s.String()
}
// SetAddress sets the Address field's value.
func (s *EndpointBatchItem) SetAddress(v string) *EndpointBatchItem {
s.Address = &v
return s
}
// SetAttributes sets the Attributes field's value.
func (s *EndpointBatchItem) SetAttributes(v map[string][]*string) *EndpointBatchItem {
s.Attributes = v
return s
}
// SetChannelType sets the ChannelType field's value.
func (s *EndpointBatchItem) SetChannelType(v string) *EndpointBatchItem {
s.ChannelType = &v
return s
}
// SetDemographic sets the Demographic field's value.
func (s *EndpointBatchItem) SetDemographic(v *EndpointDemographic) *EndpointBatchItem {
s.Demographic = v
return s
}
// SetEffectiveDate sets the EffectiveDate field's value.
func (s *EndpointBatchItem) SetEffectiveDate(v string) *EndpointBatchItem {
s.EffectiveDate = &v
return s
}
// SetEndpointStatus sets the EndpointStatus field's value.
func (s *EndpointBatchItem) SetEndpointStatus(v string) *EndpointBatchItem {
s.EndpointStatus = &v
return s
}
// SetId sets the Id field's value.
func (s *EndpointBatchItem) SetId(v string) *EndpointBatchItem {
s.Id = &v
return s
}
// SetLocation sets the Location field's value.
func (s *EndpointBatchItem) SetLocation(v *EndpointLocation) *EndpointBatchItem {
s.Location = v
return s
}
// SetMetrics sets the Metrics field's value.
func (s *EndpointBatchItem) SetMetrics(v map[string]*float64) *EndpointBatchItem {
s.Metrics = v
return s
}
// SetOptOut sets the OptOut field's value.
func (s *EndpointBatchItem) SetOptOut(v string) *EndpointBatchItem {
s.OptOut = &v
return s
}
// SetRequestId sets the RequestId field's value.
func (s *EndpointBatchItem) SetRequestId(v string) *EndpointBatchItem {
s.RequestId = &v
return s
}
// SetUser sets the User field's value.
func (s *EndpointBatchItem) SetUser(v *EndpointUser) *EndpointBatchItem {
s.User = v
return s
}
// Endpoint batch update request.
// See also, path_to_url
type EndpointBatchRequest struct {
_ struct{} `type:"structure"`
// List of items to update. Maximum 100 items
Item []*EndpointBatchItem `type:"list"`
}
// String returns the string representation
func (s EndpointBatchRequest) String() string {
return awsutil.Prettify(s)
}
// GoString returns the string representation
func (s EndpointBatchRequest) GoString() string {
return s.String()
}
// SetItem sets the Item field's value.
func (s *EndpointBatchRequest) SetItem(v []*EndpointBatchItem) *EndpointBatchRequest {
s.Item = v
return s
}
// Endpoint demographic data
// See also, path_to_url
type EndpointDemographic struct {
_ struct{} `type:"structure"`
// The version of the application associated with the endpoint.
AppVersion *string `type:"string"`
// The endpoint locale in the following format: The ISO 639-1 alpha-2 code,
// followed by an underscore, followed by an ISO 3166-1 alpha-2 value.
Locale *string `type:"string"`
// The endpoint make, such as such as Apple or Samsung.
Make *string `type:"string"`
// The endpoint model, such as iPhone.
Model *string `type:"string"`
// The endpoint model version.
ModelVersion *string `type:"string"`
// The endpoint platform, such as ios or android.
Platform *string `type:"string"`
// The endpoint platform version.
PlatformVersion *string `type:"string"`
// The timezone of the endpoint. Specified as a tz database value, such as Americas/Los_Angeles.
Timezone *string `type:"string"`
}
// String returns the string representation
func (s EndpointDemographic) String() string {
return awsutil.Prettify(s)
}
// GoString returns the string representation
func (s EndpointDemographic) GoString() string {
return s.String()
}
// SetAppVersion sets the AppVersion field's value.
func (s *EndpointDemographic) SetAppVersion(v string) *EndpointDemographic {
s.AppVersion = &v
return s
}
// SetLocale sets the Locale field's value.
func (s *EndpointDemographic) SetLocale(v string) *EndpointDemographic {
s.Locale = &v
return s
}
// SetMake sets the Make field's value.
func (s *EndpointDemographic) SetMake(v string) *EndpointDemographic {
s.Make = &v
return s
}
// SetModel sets the Model field's value.
func (s *EndpointDemographic) SetModel(v string) *EndpointDemographic {
s.Model = &v
return s
}
// SetModelVersion sets the ModelVersion field's value.
func (s *EndpointDemographic) SetModelVersion(v string) *EndpointDemographic {
s.ModelVersion = &v
return s
}
// SetPlatform sets the Platform field's value.
func (s *EndpointDemographic) SetPlatform(v string) *EndpointDemographic {
s.Platform = &v
return s
}
// SetPlatformVersion sets the PlatformVersion field's value.
func (s *EndpointDemographic) SetPlatformVersion(v string) *EndpointDemographic {
s.PlatformVersion = &v
return s
}
// SetTimezone sets the Timezone field's value.
func (s *EndpointDemographic) SetTimezone(v string) *EndpointDemographic {
s.Timezone = &v
return s
}
// Endpoint location data
// See also, path_to_url
type EndpointLocation struct {
_ struct{} `type:"structure"`
// The city where the endpoint is located.
City *string `type:"string"`
// Country according to ISO 3166-1 Alpha-2 codes. For example, US.
Country *string `type:"string"`
// The latitude of the endpoint location. Rounded to one decimal (Roughly corresponding
// to a mile).
Latitude *float64 `type:"double"`
// The longitude of the endpoint location. Rounded to one decimal (Roughly corresponding
// to a mile).
Longitude *float64 `type:"double"`
// The postal code or zip code of the endpoint.
PostalCode *string `type:"string"`
// The region of the endpoint location. For example, corresponds to a state
// in US.
Region *string `type:"string"`
}
// String returns the string representation
func (s EndpointLocation) String() string {
return awsutil.Prettify(s)
}
// GoString returns the string representation
func (s EndpointLocation) GoString() string {
return s.String()
}
// SetCity sets the City field's value.
func (s *EndpointLocation) SetCity(v string) *EndpointLocation {
s.City = &v
return s
}
// SetCountry sets the Country field's value.
func (s *EndpointLocation) SetCountry(v string) *EndpointLocation {
s.Country = &v
return s
}
// SetLatitude sets the Latitude field's value.
func (s *EndpointLocation) SetLatitude(v float64) *EndpointLocation {
s.Latitude = &v
return s
}
// SetLongitude sets the Longitude field's value.
func (s *EndpointLocation) SetLongitude(v float64) *EndpointLocation {
s.Longitude = &v
return s
}
// SetPostalCode sets the PostalCode field's value.
func (s *EndpointLocation) SetPostalCode(v string) *EndpointLocation {
s.PostalCode = &v
return s
}
// SetRegion sets the Region field's value.
func (s *EndpointLocation) SetRegion(v string) *EndpointLocation {
s.Region = &v
return s
}
// The result from sending a message to an endpoint.
// See also, path_to_url
type EndpointMessageResult struct {
_ struct{} `type:"structure"`
// Address that endpoint message was delivered to.
Address *string `type:"string"`
// Delivery status of message.
DeliveryStatus *string `type:"string" enum:"DeliveryStatus"`
// Downstream service status code.
StatusCode *int64 `type:"integer"`
// Status message for message delivery.
StatusMessage *string `type:"string"`
// If token was updated as part of delivery. (This is GCM Specific)
UpdatedToken *string `type:"string"`
}
// String returns the string representation
func (s EndpointMessageResult) String() string {
return awsutil.Prettify(s)
}
// GoString returns the string representation
func (s EndpointMessageResult) GoString() string {
return s.String()
}
// SetAddress sets the Address field's value.
func (s *EndpointMessageResult) SetAddress(v string) *EndpointMessageResult {
s.Address = &v
return s
}
// SetDeliveryStatus sets the DeliveryStatus field's value.
func (s *EndpointMessageResult) SetDeliveryStatus(v string) *EndpointMessageResult {
s.DeliveryStatus = &v
return s
}
// SetStatusCode sets the StatusCode field's value.
func (s *EndpointMessageResult) SetStatusCode(v int64) *EndpointMessageResult {
s.StatusCode = &v
return s
}
// SetStatusMessage sets the StatusMessage field's value.
func (s *EndpointMessageResult) SetStatusMessage(v string) *EndpointMessageResult {
s.StatusMessage = &v
return s
}
// SetUpdatedToken sets the UpdatedToken field's value.
func (s *EndpointMessageResult) SetUpdatedToken(v string) *EndpointMessageResult {
s.UpdatedToken = &v
return s
}
// Endpoint update request
// See also, path_to_url
type EndpointRequest struct {
_ struct{} `type:"structure"`
// The address or token of the endpoint as provided by your push provider (e.g.
// DeviceToken or RegistrationId).
Address *string `type:"string"`
Attributes map[string][]*string `type:"map"`
// The channel type.Valid values: GCM | APNS | SMS | EMAIL
ChannelType *string `type:"string" enum:"ChannelType"`
// The endpoint demographic attributes.
Demographic *EndpointDemographic `type:"structure"`
// The last time the endpoint was updated. Provided in ISO 8601 format.
EffectiveDate *string `type:"string"`
// The endpoint status. Can be either ACTIVE or INACTIVE. Will be set to INACTIVE
// if a delivery fails. Will be set to ACTIVE if the address is updated.
EndpointStatus *string `type:"string"`
// The endpoint location attributes.
Location *EndpointLocation `type:"structure"`
Metrics map[string]*float64 `type:"map"`
// Indicates whether a user has opted out of receiving messages with one of
// the following values:ALL - User has opted out of all messages.NONE - Users
// has not opted out and receives all messages.
OptOut *string `type:"string"`
// The unique ID for the most recent request to update the endpoint.
RequestId *string `type:"string"`
// Custom user-specific attributes that your app reports to Amazon Pinpoint.
User *EndpointUser `type:"structure"`
}
// String returns the string representation
func (s EndpointRequest) String() string {
return awsutil.Prettify(s)
}
// GoString returns the string representation
func (s EndpointRequest) GoString() string {
return s.String()
}
// SetAddress sets the Address field's value.
func (s *EndpointRequest) SetAddress(v string) *EndpointRequest {
s.Address = &v
return s
}
// SetAttributes sets the Attributes field's value.
func (s *EndpointRequest) SetAttributes(v map[string][]*string) *EndpointRequest {
s.Attributes = v
return s
}
// SetChannelType sets the ChannelType field's value.
func (s *EndpointRequest) SetChannelType(v string) *EndpointRequest {
s.ChannelType = &v
return s
}
// SetDemographic sets the Demographic field's value.
func (s *EndpointRequest) SetDemographic(v *EndpointDemographic) *EndpointRequest {
s.Demographic = v
return s
}
// SetEffectiveDate sets the EffectiveDate field's value.
func (s *EndpointRequest) SetEffectiveDate(v string) *EndpointRequest {
s.EffectiveDate = &v
return s
}
// SetEndpointStatus sets the EndpointStatus field's value.
func (s *EndpointRequest) SetEndpointStatus(v string) *EndpointRequest {
s.EndpointStatus = &v
return s
}
// SetLocation sets the Location field's value.
func (s *EndpointRequest) SetLocation(v *EndpointLocation) *EndpointRequest {
s.Location = v
return s
}
// SetMetrics sets the Metrics field's value.
func (s *EndpointRequest) SetMetrics(v map[string]*float64) *EndpointRequest {
s.Metrics = v
return s
}
// SetOptOut sets the OptOut field's value.
func (s *EndpointRequest) SetOptOut(v string) *EndpointRequest {
s.OptOut = &v
return s
}
// SetRequestId sets the RequestId field's value.
func (s *EndpointRequest) SetRequestId(v string) *EndpointRequest {
s.RequestId = &v
return s
}
// SetUser sets the User field's value.
func (s *EndpointRequest) SetUser(v *EndpointUser) *EndpointRequest {
s.User = v
return s
}
// Endpoint response
// See also, path_to_url
type EndpointResponse struct {
_ struct{} `type:"structure"`
// The address or token of the endpoint as provided by your push provider (e.g.
// DeviceToken or RegistrationId).
Address *string `type:"string"`
// The ID of the application associated with the endpoint.
ApplicationId *string `type:"string"`
Attributes map[string][]*string `type:"map"`
// The channel type.Valid values: GCM | APNS | SMS | EMAIL
ChannelType *string `type:"string" enum:"ChannelType"`
// A number from 0 - 99 that represents the cohort the endpoint is assigned
// to. Endpoints are grouped into cohorts randomly, and each cohort contains
// approximately 1 percent of the endpoints for an app. Amazon Pinpoint assigns
// cohorts to the holdout or treatment allocations for a campaign.
CohortId *string `type:"string"`
// The last time the endpoint was created. Provided in ISO 8601 format.
CreationDate *string `type:"string"`
// The endpoint demographic attributes.
Demographic *EndpointDemographic `type:"structure"`
// The last time the endpoint was updated. Provided in ISO 8601 format.
EffectiveDate *string `type:"string"`
// The endpoint status. Can be either ACTIVE or INACTIVE. Will be set to INACTIVE
// if a delivery fails. Will be set to ACTIVE if the address is updated.
EndpointStatus *string `type:"string"`
// The unique ID that you assigned to the endpoint. The ID should be a globally
// unique identifier (GUID) to ensure that it is unique compared to all other
// endpoints for the application.
Id *string `type:"string"`
// The endpoint location attributes.
Location *EndpointLocation `type:"structure"`
Metrics map[string]*float64 `type:"map"`
// Indicates whether a user has opted out of receiving messages with one of
// the following values:ALL - User has opted out of all messages.NONE - Users
// has not opted out and receives all messages.
OptOut *string `type:"string"`
// The unique ID for the most recent request to update the endpoint.
RequestId *string `type:"string"`
// Custom user-specific attributes that your app reports to Amazon Pinpoint.
User *EndpointUser `type:"structure"`
}
// String returns the string representation
func (s EndpointResponse) String() string {
return awsutil.Prettify(s)
}
// GoString returns the string representation
func (s EndpointResponse) GoString() string {
return s.String()
}
// SetAddress sets the Address field's value.
func (s *EndpointResponse) SetAddress(v string) *EndpointResponse {
s.Address = &v
return s
}
// SetApplicationId sets the ApplicationId field's value.
func (s *EndpointResponse) SetApplicationId(v string) *EndpointResponse {
s.ApplicationId = &v
return s
}
// SetAttributes sets the Attributes field's value.
func (s *EndpointResponse) SetAttributes(v map[string][]*string) *EndpointResponse {
s.Attributes = v
return s
}
// SetChannelType sets the ChannelType field's value.
func (s *EndpointResponse) SetChannelType(v string) *EndpointResponse {
s.ChannelType = &v
return s
}
// SetCohortId sets the CohortId field's value.
func (s *EndpointResponse) SetCohortId(v string) *EndpointResponse {
s.CohortId = &v
return s
}
// SetCreationDate sets the CreationDate field's value.
func (s *EndpointResponse) SetCreationDate(v string) *EndpointResponse {
s.CreationDate = &v
return s
}
// SetDemographic sets the Demographic field's value.
func (s *EndpointResponse) SetDemographic(v *EndpointDemographic) *EndpointResponse {
s.Demographic = v
return s
}
// SetEffectiveDate sets the EffectiveDate field's value.
func (s *EndpointResponse) SetEffectiveDate(v string) *EndpointResponse {
s.EffectiveDate = &v
return s
}
// SetEndpointStatus sets the EndpointStatus field's value.
func (s *EndpointResponse) SetEndpointStatus(v string) *EndpointResponse {
s.EndpointStatus = &v
return s
}
// SetId sets the Id field's value.
func (s *EndpointResponse) SetId(v string) *EndpointResponse {
s.Id = &v
return s
}
// SetLocation sets the Location field's value.
func (s *EndpointResponse) SetLocation(v *EndpointLocation) *EndpointResponse {
s.Location = v
return s
}
// SetMetrics sets the Metrics field's value.
func (s *EndpointResponse) SetMetrics(v map[string]*float64) *EndpointResponse {
s.Metrics = v
return s
}
// SetOptOut sets the OptOut field's value.
func (s *EndpointResponse) SetOptOut(v string) *EndpointResponse {
s.OptOut = &v
return s
}
// SetRequestId sets the RequestId field's value.
func (s *EndpointResponse) SetRequestId(v string) *EndpointResponse {
s.RequestId = &v
return s
}
// SetUser sets the User field's value.
func (s *EndpointResponse) SetUser(v *EndpointUser) *EndpointResponse {
s.User = v
return s
}
// Endpoint send configuration.
// See also, path_to_url
type EndpointSendConfiguration struct {
_ struct{} `type:"structure"`
// Body override. If specified will override default body.
BodyOverride *string `type:"string"`
Context map[string]*string `type:"map"`
// The Raw JSON formatted string to be used as the payload. This value overrides
// the message.
RawContent *string `type:"string"`
Substitutions map[string][]*string `type:"map"`
// Title override. If specified will override default title if applicable.
TitleOverride *string `type:"string"`
}
// String returns the string representation
func (s EndpointSendConfiguration) String() string {
return awsutil.Prettify(s)
}
// GoString returns the string representation
func (s EndpointSendConfiguration) GoString() string {
return s.String()
}
// SetBodyOverride sets the BodyOverride field's value.
func (s *EndpointSendConfiguration) SetBodyOverride(v string) *EndpointSendConfiguration {
s.BodyOverride = &v
return s
}
// SetContext sets the Context field's value.
func (s *EndpointSendConfiguration) SetContext(v map[string]*string) *EndpointSendConfiguration {
s.Context = v
return s
}
// SetRawContent sets the RawContent field's value.
func (s *EndpointSendConfiguration) SetRawContent(v string) *EndpointSendConfiguration {
s.RawContent = &v
return s
}
// SetSubstitutions sets the Substitutions field's value.
func (s *EndpointSendConfiguration) SetSubstitutions(v map[string][]*string) *EndpointSendConfiguration {
s.Substitutions = v
return s
}
// SetTitleOverride sets the TitleOverride field's value.
func (s *EndpointSendConfiguration) SetTitleOverride(v string) *EndpointSendConfiguration {
s.TitleOverride = &v
return s
}
// Endpoint user specific custom userAttributes
// See also, path_to_url
type EndpointUser struct {
_ struct{} `type:"structure"`
UserAttributes map[string][]*string `type:"map"`
// The unique ID of the user.
UserId *string `type:"string"`
}
// String returns the string representation
func (s EndpointUser) String() string {
return awsutil.Prettify(s)
}
// GoString returns the string representation
func (s EndpointUser) GoString() string {
return s.String()
}
// SetUserAttributes sets the UserAttributes field's value.
func (s *EndpointUser) SetUserAttributes(v map[string][]*string) *EndpointUser {
s.UserAttributes = v
return s
}
// SetUserId sets the UserId field's value.
func (s *EndpointUser) SetUserId(v string) *EndpointUser {
s.UserId = &v
return s
}
// Model for an event publishing subscription export.
// See also, path_to_url
type EventStream struct {
_ struct{} `type:"structure"`
// The ID of the application from which events should be published.
ApplicationId *string `type:"string"`
// The Amazon Resource Name (ARN) of the Amazon Kinesis stream or Firehose delivery
// stream to which you want to publish events. Firehose ARN: arn:aws:firehose:REGION:ACCOUNT_ID:deliverystream/STREAM_NAME
// Kinesis ARN: arn:aws:kinesis:REGION:ACCOUNT_ID:stream/STREAM_NAME
DestinationStreamArn *string `type:"string"`
// The external ID assigned the IAM role that authorizes Amazon Pinpoint to
// publish to the stream.
ExternalId *string `type:"string"`
// The date the event stream was last updated in ISO 8601 format.
LastModifiedDate *string `type:"string"`
// The IAM user who last modified the event stream.
LastUpdatedBy *string `type:"string"`
// The IAM role that authorizes Amazon Pinpoint to publish events to the stream
// in your account.
RoleArn *string `type:"string"`
}
// String returns the string representation
func (s EventStream) String() string {
return awsutil.Prettify(s)
}
// GoString returns the string representation
func (s EventStream) GoString() string {
return s.String()
}
// SetApplicationId sets the ApplicationId field's value.
func (s *EventStream) SetApplicationId(v string) *EventStream {
s.ApplicationId = &v
return s
}
// SetDestinationStreamArn sets the DestinationStreamArn field's value.
func (s *EventStream) SetDestinationStreamArn(v string) *EventStream {
s.DestinationStreamArn = &v
return s
}
// SetExternalId sets the ExternalId field's value.
func (s *EventStream) SetExternalId(v string) *EventStream {
s.ExternalId = &v
return s
}
// SetLastModifiedDate sets the LastModifiedDate field's value.
func (s *EventStream) SetLastModifiedDate(v string) *EventStream {
s.LastModifiedDate = &v
return s
}
// SetLastUpdatedBy sets the LastUpdatedBy field's value.
func (s *EventStream) SetLastUpdatedBy(v string) *EventStream {
s.LastUpdatedBy = &v
return s
}
// SetRoleArn sets the RoleArn field's value.
func (s *EventStream) SetRoleArn(v string) *EventStream {
s.RoleArn = &v
return s
}
// Google Cloud Messaging credentials
// See also, path_to_url
type GCMChannelRequest struct {
_ struct{} `type:"structure"`
// Platform credential API key from Google.
ApiKey *string `type:"string"`
// If the channel is enabled for sending messages.
Enabled *bool `type:"boolean"`
}
// String returns the string representation
func (s GCMChannelRequest) String() string {
return awsutil.Prettify(s)
}
// GoString returns the string representation
func (s GCMChannelRequest) GoString() string {
return s.String()
}
// SetApiKey sets the ApiKey field's value.
func (s *GCMChannelRequest) SetApiKey(v string) *GCMChannelRequest {
s.ApiKey = &v
return s
}
// SetEnabled sets the Enabled field's value.
func (s *GCMChannelRequest) SetEnabled(v bool) *GCMChannelRequest {
s.Enabled = &v
return s
}
// Google Cloud Messaging channel definition
// See also, path_to_url
type GCMChannelResponse struct {
_ struct{} `type:"structure"`
// The ID of the application to which the channel applies.
ApplicationId *string `type:"string"`
// When was this segment created
CreationDate *string `type:"string"`
// The GCM API key from Google.
Credential *string `type:"string"`
// If the channel is enabled for sending messages.
Enabled *bool `type:"boolean"`
// If the channel is registered with a credential for authentication.
HasCredential *bool `type:"boolean"`
// Channel ID. Not used. Present only for backwards compatibility.
Id *string `type:"string"`
// Is this channel archived
IsArchived *bool `type:"boolean"`
// Who last updated this entry
LastModifiedBy *string `type:"string"`
// Last date this was updated
LastModifiedDate *string `type:"string"`
// The platform type. Will be GCM
Platform *string `type:"string"`
// Version of channel
Version *int64 `type:"integer"`
}
// String returns the string representation
func (s GCMChannelResponse) String() string {
return awsutil.Prettify(s)
}
// GoString returns the string representation
func (s GCMChannelResponse) GoString() string {
return s.String()
}
// SetApplicationId sets the ApplicationId field's value.
func (s *GCMChannelResponse) SetApplicationId(v string) *GCMChannelResponse {
s.ApplicationId = &v
return s
}
// SetCreationDate sets the CreationDate field's value.
func (s *GCMChannelResponse) SetCreationDate(v string) *GCMChannelResponse {
s.CreationDate = &v
return s
}
// SetCredential sets the Credential field's value.
func (s *GCMChannelResponse) SetCredential(v string) *GCMChannelResponse {
s.Credential = &v
return s
}
// SetEnabled sets the Enabled field's value.
func (s *GCMChannelResponse) SetEnabled(v bool) *GCMChannelResponse {
s.Enabled = &v
return s
}
// SetHasCredential sets the HasCredential field's value.
func (s *GCMChannelResponse) SetHasCredential(v bool) *GCMChannelResponse {
s.HasCredential = &v
return s
}
// SetId sets the Id field's value.
func (s *GCMChannelResponse) SetId(v string) *GCMChannelResponse {
s.Id = &v
return s
}
// SetIsArchived sets the IsArchived field's value.
func (s *GCMChannelResponse) SetIsArchived(v bool) *GCMChannelResponse {
s.IsArchived = &v
return s
}
// SetLastModifiedBy sets the LastModifiedBy field's value.
func (s *GCMChannelResponse) SetLastModifiedBy(v string) *GCMChannelResponse {
s.LastModifiedBy = &v
return s
}
// SetLastModifiedDate sets the LastModifiedDate field's value.
func (s *GCMChannelResponse) SetLastModifiedDate(v string) *GCMChannelResponse {
s.LastModifiedDate = &v
return s
}
// SetPlatform sets the Platform field's value.
func (s *GCMChannelResponse) SetPlatform(v string) *GCMChannelResponse {
s.Platform = &v
return s
}
// SetVersion sets the Version field's value.
func (s *GCMChannelResponse) SetVersion(v int64) *GCMChannelResponse {
s.Version = &v
return s
}
// GCM Message.
// See also, path_to_url
type GCMMessage struct {
_ struct{} `type:"structure"`
// The action that occurs if the user taps a push notification delivered by
// the campaign: OPEN_APP - Your app launches, or it becomes the foreground
// app if it has been sent to the background. This is the default action. DEEP_LINK
// - Uses deep linking features in iOS and Android to open your app and display
// a designated user interface within the app. URL - The default mobile browser
// on the user's device launches and opens a web page at the URL you specify.
// Possible values include: OPEN_APP | DEEP_LINK | URL
Action *string `type:"string" enum:"Action"`
// The message body of the notification, the email body or the text message.
Body *string `type:"string"`
// This parameter identifies a group of messages (e.g., with collapse_key: "Updates
// Available") that can be collapsed, so that only the last message gets sent
// when delivery can be resumed. This is intended to avoid sending too many
// of the same messages when the device comes back online or becomes active.
CollapseKey *string `type:"string"`
Data map[string]*string `type:"map"`
// The icon image name of the asset saved in your application.
IconReference *string `type:"string"`
// The URL that points to an image used as the large icon to the notification
// content view.
ImageIconUrl *string `type:"string"`
// The URL that points to an image used in the push notification.
ImageUrl *string `type:"string"`
// Is this a transaction priority message or lower priority.
Priority *string `type:"string"`
// The Raw JSON formatted string to be used as the payload. This value overrides
// the message.
RawContent *string `type:"string"`
// This parameter specifies the package name of the application where the registration
// tokens must match in order to receive the message.
RestrictedPackageName *string `type:"string"`
// Indicates if the message should display on the users device. Silent pushes
// can be used for Remote Configuration and Phone Home use cases.
SilentPush *bool `type:"boolean"`
// The URL that points to an image used as the small icon for the notification
// which will be used to represent the notification in the status bar and content
// view
SmallImageIconUrl *string `type:"string"`
// Indicates a sound to play when the device receives the notification. Supports
// default, or the filename of a sound resource bundled in the app. Android
// sound files must reside in /res/raw/
Sound *string `type:"string"`
Substitutions map[string][]*string `type:"map"`
// This parameter specifies how long (in seconds) the message should be kept
// in GCM storage if the device is offline. The maximum time to live supported
// is 4 weeks, and the default value is 4 weeks.
TimeToLive *int64 `type:"integer"`
// The message title that displays above the message on the user's device.
Title *string `type:"string"`
// The URL to open in the user's mobile browser. Used if the value for Action
// is URL.
Url *string `type:"string"`
}
// String returns the string representation
func (s GCMMessage) String() string {
return awsutil.Prettify(s)
}
// GoString returns the string representation
func (s GCMMessage) GoString() string {
return s.String()
}
// SetAction sets the Action field's value.
func (s *GCMMessage) SetAction(v string) *GCMMessage {
s.Action = &v
return s
}
// SetBody sets the Body field's value.
func (s *GCMMessage) SetBody(v string) *GCMMessage {
s.Body = &v
return s
}
// SetCollapseKey sets the CollapseKey field's value.
func (s *GCMMessage) SetCollapseKey(v string) *GCMMessage {
s.CollapseKey = &v
return s
}
// SetData sets the Data field's value.
func (s *GCMMessage) SetData(v map[string]*string) *GCMMessage {
s.Data = v
return s
}
// SetIconReference sets the IconReference field's value.
func (s *GCMMessage) SetIconReference(v string) *GCMMessage {
s.IconReference = &v
return s
}
// SetImageIconUrl sets the ImageIconUrl field's value.
func (s *GCMMessage) SetImageIconUrl(v string) *GCMMessage {
s.ImageIconUrl = &v
return s
}
// SetImageUrl sets the ImageUrl field's value.
func (s *GCMMessage) SetImageUrl(v string) *GCMMessage {
s.ImageUrl = &v
return s
}
// SetPriority sets the Priority field's value.
func (s *GCMMessage) SetPriority(v string) *GCMMessage {
s.Priority = &v
return s
}
// SetRawContent sets the RawContent field's value.
func (s *GCMMessage) SetRawContent(v string) *GCMMessage {
s.RawContent = &v
return s
}
// SetRestrictedPackageName sets the RestrictedPackageName field's value.
func (s *GCMMessage) SetRestrictedPackageName(v string) *GCMMessage {
s.RestrictedPackageName = &v
return s
}
// SetSilentPush sets the SilentPush field's value.
func (s *GCMMessage) SetSilentPush(v bool) *GCMMessage {
s.SilentPush = &v
return s
}
// SetSmallImageIconUrl sets the SmallImageIconUrl field's value.
func (s *GCMMessage) SetSmallImageIconUrl(v string) *GCMMessage {
s.SmallImageIconUrl = &v
return s
}
// SetSound sets the Sound field's value.
func (s *GCMMessage) SetSound(v string) *GCMMessage {
s.Sound = &v
return s
}
// SetSubstitutions sets the Substitutions field's value.
func (s *GCMMessage) SetSubstitutions(v map[string][]*string) *GCMMessage {
s.Substitutions = v
return s
}
// SetTimeToLive sets the TimeToLive field's value.
func (s *GCMMessage) SetTimeToLive(v int64) *GCMMessage {
s.TimeToLive = &v
return s
}
// SetTitle sets the Title field's value.
func (s *GCMMessage) SetTitle(v string) *GCMMessage {
s.Title = &v
return s
}
// SetUrl sets the Url field's value.
func (s *GCMMessage) SetUrl(v string) *GCMMessage {
s.Url = &v
return s
}
// See also, path_to_url
type GetAdmChannelInput struct {
_ struct{} `type:"structure"`
// ApplicationId is a required field
ApplicationId *string `location:"uri" locationName:"application-id" type:"string" required:"true"`
}
// String returns the string representation
func (s GetAdmChannelInput) String() string {
return awsutil.Prettify(s)
}
// GoString returns the string representation
func (s GetAdmChannelInput) GoString() string {
return s.String()
}
// Validate inspects the fields of the type to determine if they are valid.
func (s *GetAdmChannelInput) Validate() error {
invalidParams := request.ErrInvalidParams{Context: "GetAdmChannelInput"}
if s.ApplicationId == nil {
invalidParams.Add(request.NewErrParamRequired("ApplicationId"))
}
if invalidParams.Len() > 0 {
return invalidParams
}
return nil
}
// SetApplicationId sets the ApplicationId field's value.
func (s *GetAdmChannelInput) SetApplicationId(v string) *GetAdmChannelInput {
s.ApplicationId = &v
return s
}
// See also, path_to_url
type GetAdmChannelOutput struct {
_ struct{} `type:"structure" payload:"ADMChannelResponse"`
// Amazon Device Messaging channel definition.
//
// ADMChannelResponse is a required field
ADMChannelResponse *ADMChannelResponse `type:"structure" required:"true"`
}
// String returns the string representation
func (s GetAdmChannelOutput) String() string {
return awsutil.Prettify(s)
}
// GoString returns the string representation
func (s GetAdmChannelOutput) GoString() string {
return s.String()
}
// SetADMChannelResponse sets the ADMChannelResponse field's value.
func (s *GetAdmChannelOutput) SetADMChannelResponse(v *ADMChannelResponse) *GetAdmChannelOutput {
s.ADMChannelResponse = v
return s
}
// See also, path_to_url
type GetApnsChannelInput struct {
_ struct{} `type:"structure"`
// ApplicationId is a required field
ApplicationId *string `location:"uri" locationName:"application-id" type:"string" required:"true"`
}
// String returns the string representation
func (s GetApnsChannelInput) String() string {
return awsutil.Prettify(s)
}
// GoString returns the string representation
func (s GetApnsChannelInput) GoString() string {
return s.String()
}
// Validate inspects the fields of the type to determine if they are valid.
func (s *GetApnsChannelInput) Validate() error {
invalidParams := request.ErrInvalidParams{Context: "GetApnsChannelInput"}
if s.ApplicationId == nil {
invalidParams.Add(request.NewErrParamRequired("ApplicationId"))
}
if invalidParams.Len() > 0 {
return invalidParams
}
return nil
}
// SetApplicationId sets the ApplicationId field's value.
func (s *GetApnsChannelInput) SetApplicationId(v string) *GetApnsChannelInput {
s.ApplicationId = &v
return s
}
// See also, path_to_url
type GetApnsChannelOutput struct {
_ struct{} `type:"structure" payload:"APNSChannelResponse"`
// Apple Distribution Push Notification Service channel definition.
//
// APNSChannelResponse is a required field
APNSChannelResponse *APNSChannelResponse `type:"structure" required:"true"`
}
// String returns the string representation
func (s GetApnsChannelOutput) String() string {
return awsutil.Prettify(s)
}
// GoString returns the string representation
func (s GetApnsChannelOutput) GoString() string {
return s.String()
}
// SetAPNSChannelResponse sets the APNSChannelResponse field's value.
func (s *GetApnsChannelOutput) SetAPNSChannelResponse(v *APNSChannelResponse) *GetApnsChannelOutput {
s.APNSChannelResponse = v
return s
}
// See also, path_to_url
type GetApnsSandboxChannelInput struct {
_ struct{} `type:"structure"`
// ApplicationId is a required field
ApplicationId *string `location:"uri" locationName:"application-id" type:"string" required:"true"`
}
// String returns the string representation
func (s GetApnsSandboxChannelInput) String() string {
return awsutil.Prettify(s)
}
// GoString returns the string representation
func (s GetApnsSandboxChannelInput) GoString() string {
return s.String()
}
// Validate inspects the fields of the type to determine if they are valid.
func (s *GetApnsSandboxChannelInput) Validate() error {
invalidParams := request.ErrInvalidParams{Context: "GetApnsSandboxChannelInput"}
if s.ApplicationId == nil {
invalidParams.Add(request.NewErrParamRequired("ApplicationId"))
}
if invalidParams.Len() > 0 {
return invalidParams
}
return nil
}
// SetApplicationId sets the ApplicationId field's value.
func (s *GetApnsSandboxChannelInput) SetApplicationId(v string) *GetApnsSandboxChannelInput {
s.ApplicationId = &v
return s
}
// See also, path_to_url
type GetApnsSandboxChannelOutput struct {
_ struct{} `type:"structure" payload:"APNSSandboxChannelResponse"`
// Apple Development Push Notification Service channel definition.
//
// APNSSandboxChannelResponse is a required field
APNSSandboxChannelResponse *APNSSandboxChannelResponse `type:"structure" required:"true"`
}
// String returns the string representation
func (s GetApnsSandboxChannelOutput) String() string {
return awsutil.Prettify(s)
}
// GoString returns the string representation
func (s GetApnsSandboxChannelOutput) GoString() string {
return s.String()
}
// SetAPNSSandboxChannelResponse sets the APNSSandboxChannelResponse field's value.
func (s *GetApnsSandboxChannelOutput) SetAPNSSandboxChannelResponse(v *APNSSandboxChannelResponse) *GetApnsSandboxChannelOutput {
s.APNSSandboxChannelResponse = v
return s
}
// See also, path_to_url
type GetApnsVoipChannelInput struct {
_ struct{} `type:"structure"`
// ApplicationId is a required field
ApplicationId *string `location:"uri" locationName:"application-id" type:"string" required:"true"`
}
// String returns the string representation
func (s GetApnsVoipChannelInput) String() string {
return awsutil.Prettify(s)
}
// GoString returns the string representation
func (s GetApnsVoipChannelInput) GoString() string {
return s.String()
}
// Validate inspects the fields of the type to determine if they are valid.
func (s *GetApnsVoipChannelInput) Validate() error {
invalidParams := request.ErrInvalidParams{Context: "GetApnsVoipChannelInput"}
if s.ApplicationId == nil {
invalidParams.Add(request.NewErrParamRequired("ApplicationId"))
}
if invalidParams.Len() > 0 {
return invalidParams
}
return nil
}
// SetApplicationId sets the ApplicationId field's value.
func (s *GetApnsVoipChannelInput) SetApplicationId(v string) *GetApnsVoipChannelInput {
s.ApplicationId = &v
return s
}
// See also, path_to_url
type GetApnsVoipChannelOutput struct {
_ struct{} `type:"structure" payload:"APNSVoipChannelResponse"`
// Apple VOIP Push Notification Service channel definition.
//
// APNSVoipChannelResponse is a required field
APNSVoipChannelResponse *APNSVoipChannelResponse `type:"structure" required:"true"`
}
// String returns the string representation
func (s GetApnsVoipChannelOutput) String() string {
return awsutil.Prettify(s)
}
// GoString returns the string representation
func (s GetApnsVoipChannelOutput) GoString() string {
return s.String()
}
// SetAPNSVoipChannelResponse sets the APNSVoipChannelResponse field's value.
func (s *GetApnsVoipChannelOutput) SetAPNSVoipChannelResponse(v *APNSVoipChannelResponse) *GetApnsVoipChannelOutput {
s.APNSVoipChannelResponse = v
return s
}
// See also, path_to_url
type GetApnsVoipSandboxChannelInput struct {
_ struct{} `type:"structure"`
// ApplicationId is a required field
ApplicationId *string `location:"uri" locationName:"application-id" type:"string" required:"true"`
}
// String returns the string representation
func (s GetApnsVoipSandboxChannelInput) String() string {
return awsutil.Prettify(s)
}
// GoString returns the string representation
func (s GetApnsVoipSandboxChannelInput) GoString() string {
return s.String()
}
// Validate inspects the fields of the type to determine if they are valid.
func (s *GetApnsVoipSandboxChannelInput) Validate() error {
invalidParams := request.ErrInvalidParams{Context: "GetApnsVoipSandboxChannelInput"}
if s.ApplicationId == nil {
invalidParams.Add(request.NewErrParamRequired("ApplicationId"))
}
if invalidParams.Len() > 0 {
return invalidParams
}
return nil
}
// SetApplicationId sets the ApplicationId field's value.
func (s *GetApnsVoipSandboxChannelInput) SetApplicationId(v string) *GetApnsVoipSandboxChannelInput {
s.ApplicationId = &v
return s
}
// See also, path_to_url
type GetApnsVoipSandboxChannelOutput struct {
_ struct{} `type:"structure" payload:"APNSVoipSandboxChannelResponse"`
// Apple VOIP Developer Push Notification Service channel definition.
//
// APNSVoipSandboxChannelResponse is a required field
APNSVoipSandboxChannelResponse *APNSVoipSandboxChannelResponse `type:"structure" required:"true"`
}
// String returns the string representation
func (s GetApnsVoipSandboxChannelOutput) String() string {
return awsutil.Prettify(s)
}
// GoString returns the string representation
func (s GetApnsVoipSandboxChannelOutput) GoString() string {
return s.String()
}
// SetAPNSVoipSandboxChannelResponse sets the APNSVoipSandboxChannelResponse field's value.
func (s *GetApnsVoipSandboxChannelOutput) SetAPNSVoipSandboxChannelResponse(v *APNSVoipSandboxChannelResponse) *GetApnsVoipSandboxChannelOutput {
s.APNSVoipSandboxChannelResponse = v
return s
}
// See also, path_to_url
type GetAppInput struct {
_ struct{} `type:"structure"`
// ApplicationId is a required field
ApplicationId *string `location:"uri" locationName:"application-id" type:"string" required:"true"`
}
// String returns the string representation
func (s GetAppInput) String() string {
return awsutil.Prettify(s)
}
// GoString returns the string representation
func (s GetAppInput) GoString() string {
return s.String()
}
// Validate inspects the fields of the type to determine if they are valid.
func (s *GetAppInput) Validate() error {
invalidParams := request.ErrInvalidParams{Context: "GetAppInput"}
if s.ApplicationId == nil {
invalidParams.Add(request.NewErrParamRequired("ApplicationId"))
}
if invalidParams.Len() > 0 {
return invalidParams
}
return nil
}
// SetApplicationId sets the ApplicationId field's value.
func (s *GetAppInput) SetApplicationId(v string) *GetAppInput {
s.ApplicationId = &v
return s
}
// See also, path_to_url
type GetAppOutput struct {
_ struct{} `type:"structure" payload:"ApplicationResponse"`
// Application Response.
//
// ApplicationResponse is a required field
ApplicationResponse *ApplicationResponse `type:"structure" required:"true"`
}
// String returns the string representation
func (s GetAppOutput) String() string {
return awsutil.Prettify(s)
}
// GoString returns the string representation
func (s GetAppOutput) GoString() string {
return s.String()
}
// SetApplicationResponse sets the ApplicationResponse field's value.
func (s *GetAppOutput) SetApplicationResponse(v *ApplicationResponse) *GetAppOutput {
s.ApplicationResponse = v
return s
}
// See also, path_to_url
type GetApplicationSettingsInput struct {
_ struct{} `type:"structure"`
// ApplicationId is a required field
ApplicationId *string `location:"uri" locationName:"application-id" type:"string" required:"true"`
}
// String returns the string representation
func (s GetApplicationSettingsInput) String() string {
return awsutil.Prettify(s)
}
// GoString returns the string representation
func (s GetApplicationSettingsInput) GoString() string {
return s.String()
}
// Validate inspects the fields of the type to determine if they are valid.
func (s *GetApplicationSettingsInput) Validate() error {
invalidParams := request.ErrInvalidParams{Context: "GetApplicationSettingsInput"}
if s.ApplicationId == nil {
invalidParams.Add(request.NewErrParamRequired("ApplicationId"))
}
if invalidParams.Len() > 0 {
return invalidParams
}
return nil
}
// SetApplicationId sets the ApplicationId field's value.
func (s *GetApplicationSettingsInput) SetApplicationId(v string) *GetApplicationSettingsInput {
s.ApplicationId = &v
return s
}
// See also, path_to_url
type GetApplicationSettingsOutput struct {
_ struct{} `type:"structure" payload:"ApplicationSettingsResource"`
// Application settings.
//
// ApplicationSettingsResource is a required field
ApplicationSettingsResource *ApplicationSettingsResource `type:"structure" required:"true"`
}
// String returns the string representation
func (s GetApplicationSettingsOutput) String() string {
return awsutil.Prettify(s)
}
// GoString returns the string representation
func (s GetApplicationSettingsOutput) GoString() string {
return s.String()
}
// SetApplicationSettingsResource sets the ApplicationSettingsResource field's value.
func (s *GetApplicationSettingsOutput) SetApplicationSettingsResource(v *ApplicationSettingsResource) *GetApplicationSettingsOutput {
s.ApplicationSettingsResource = v
return s
}
// See also, path_to_url
type GetAppsInput struct {
_ struct{} `type:"structure"`
PageSize *string `location:"querystring" locationName:"page-size" type:"string"`
Token *string `location:"querystring" locationName:"token" type:"string"`
}
// String returns the string representation
func (s GetAppsInput) String() string {
return awsutil.Prettify(s)
}
// GoString returns the string representation
func (s GetAppsInput) GoString() string {
return s.String()
}
// SetPageSize sets the PageSize field's value.
func (s *GetAppsInput) SetPageSize(v string) *GetAppsInput {
s.PageSize = &v
return s
}
// SetToken sets the Token field's value.
func (s *GetAppsInput) SetToken(v string) *GetAppsInput {
s.Token = &v
return s
}
// See also, path_to_url
type GetAppsOutput struct {
_ struct{} `type:"structure" payload:"ApplicationsResponse"`
// Get Applications Result.
//
// ApplicationsResponse is a required field
ApplicationsResponse *ApplicationsResponse `type:"structure" required:"true"`
}
// String returns the string representation
func (s GetAppsOutput) String() string {
return awsutil.Prettify(s)
}
// GoString returns the string representation
func (s GetAppsOutput) GoString() string {
return s.String()
}
// SetApplicationsResponse sets the ApplicationsResponse field's value.
func (s *GetAppsOutput) SetApplicationsResponse(v *ApplicationsResponse) *GetAppsOutput {
s.ApplicationsResponse = v
return s
}
// See also, path_to_url
type GetBaiduChannelInput struct {
_ struct{} `type:"structure"`
// ApplicationId is a required field
ApplicationId *string `location:"uri" locationName:"application-id" type:"string" required:"true"`
}
// String returns the string representation
func (s GetBaiduChannelInput) String() string {
return awsutil.Prettify(s)
}
// GoString returns the string representation
func (s GetBaiduChannelInput) GoString() string {
return s.String()
}
// Validate inspects the fields of the type to determine if they are valid.
func (s *GetBaiduChannelInput) Validate() error {
invalidParams := request.ErrInvalidParams{Context: "GetBaiduChannelInput"}
if s.ApplicationId == nil {
invalidParams.Add(request.NewErrParamRequired("ApplicationId"))
}
if invalidParams.Len() > 0 {
return invalidParams
}
return nil
}
// SetApplicationId sets the ApplicationId field's value.
func (s *GetBaiduChannelInput) SetApplicationId(v string) *GetBaiduChannelInput {
s.ApplicationId = &v
return s
}
// See also, path_to_url
type GetBaiduChannelOutput struct {
_ struct{} `type:"structure" payload:"BaiduChannelResponse"`
// Baidu Cloud Messaging channel definition
//
// BaiduChannelResponse is a required field
BaiduChannelResponse *BaiduChannelResponse `type:"structure" required:"true"`
}
// String returns the string representation
func (s GetBaiduChannelOutput) String() string {
return awsutil.Prettify(s)
}
// GoString returns the string representation
func (s GetBaiduChannelOutput) GoString() string {
return s.String()
}
// SetBaiduChannelResponse sets the BaiduChannelResponse field's value.
func (s *GetBaiduChannelOutput) SetBaiduChannelResponse(v *BaiduChannelResponse) *GetBaiduChannelOutput {
s.BaiduChannelResponse = v
return s
}
// See also, path_to_url
type GetCampaignActivitiesInput struct {
_ struct{} `type:"structure"`
// ApplicationId is a required field
ApplicationId *string `location:"uri" locationName:"application-id" type:"string" required:"true"`
// CampaignId is a required field
CampaignId *string `location:"uri" locationName:"campaign-id" type:"string" required:"true"`
PageSize *string `location:"querystring" locationName:"page-size" type:"string"`
Token *string `location:"querystring" locationName:"token" type:"string"`
}
// String returns the string representation
func (s GetCampaignActivitiesInput) String() string {
return awsutil.Prettify(s)
}
// GoString returns the string representation
func (s GetCampaignActivitiesInput) GoString() string {
return s.String()
}
// Validate inspects the fields of the type to determine if they are valid.
func (s *GetCampaignActivitiesInput) Validate() error {
invalidParams := request.ErrInvalidParams{Context: "GetCampaignActivitiesInput"}
if s.ApplicationId == nil {
invalidParams.Add(request.NewErrParamRequired("ApplicationId"))
}
if s.CampaignId == nil {
invalidParams.Add(request.NewErrParamRequired("CampaignId"))
}
if invalidParams.Len() > 0 {
return invalidParams
}
return nil
}
// SetApplicationId sets the ApplicationId field's value.
func (s *GetCampaignActivitiesInput) SetApplicationId(v string) *GetCampaignActivitiesInput {
s.ApplicationId = &v
return s
}
// SetCampaignId sets the CampaignId field's value.
func (s *GetCampaignActivitiesInput) SetCampaignId(v string) *GetCampaignActivitiesInput {
s.CampaignId = &v
return s
}
// SetPageSize sets the PageSize field's value.
func (s *GetCampaignActivitiesInput) SetPageSize(v string) *GetCampaignActivitiesInput {
s.PageSize = &v
return s
}
// SetToken sets the Token field's value.
func (s *GetCampaignActivitiesInput) SetToken(v string) *GetCampaignActivitiesInput {
s.Token = &v
return s
}
// See also, path_to_url
type GetCampaignActivitiesOutput struct {
_ struct{} `type:"structure" payload:"ActivitiesResponse"`
// Activities for campaign.
//
// ActivitiesResponse is a required field
ActivitiesResponse *ActivitiesResponse `type:"structure" required:"true"`
}
// String returns the string representation
func (s GetCampaignActivitiesOutput) String() string {
return awsutil.Prettify(s)
}
// GoString returns the string representation
func (s GetCampaignActivitiesOutput) GoString() string {
return s.String()
}
// SetActivitiesResponse sets the ActivitiesResponse field's value.
func (s *GetCampaignActivitiesOutput) SetActivitiesResponse(v *ActivitiesResponse) *GetCampaignActivitiesOutput {
s.ActivitiesResponse = v
return s
}
// See also, path_to_url
type GetCampaignInput struct {
_ struct{} `type:"structure"`
// ApplicationId is a required field
ApplicationId *string `location:"uri" locationName:"application-id" type:"string" required:"true"`
// CampaignId is a required field
CampaignId *string `location:"uri" locationName:"campaign-id" type:"string" required:"true"`
}
// String returns the string representation
func (s GetCampaignInput) String() string {
return awsutil.Prettify(s)
}
// GoString returns the string representation
func (s GetCampaignInput) GoString() string {
return s.String()
}
// Validate inspects the fields of the type to determine if they are valid.
func (s *GetCampaignInput) Validate() error {
invalidParams := request.ErrInvalidParams{Context: "GetCampaignInput"}
if s.ApplicationId == nil {
invalidParams.Add(request.NewErrParamRequired("ApplicationId"))
}
if s.CampaignId == nil {
invalidParams.Add(request.NewErrParamRequired("CampaignId"))
}
if invalidParams.Len() > 0 {
return invalidParams
}
return nil
}
// SetApplicationId sets the ApplicationId field's value.
func (s *GetCampaignInput) SetApplicationId(v string) *GetCampaignInput {
s.ApplicationId = &v
return s
}
// SetCampaignId sets the CampaignId field's value.
func (s *GetCampaignInput) SetCampaignId(v string) *GetCampaignInput {
s.CampaignId = &v
return s
}
// See also, path_to_url
type GetCampaignOutput struct {
_ struct{} `type:"structure" payload:"CampaignResponse"`
// Campaign definition
//
// CampaignResponse is a required field
CampaignResponse *CampaignResponse `type:"structure" required:"true"`
}
// String returns the string representation
func (s GetCampaignOutput) String() string {
return awsutil.Prettify(s)
}
// GoString returns the string representation
func (s GetCampaignOutput) GoString() string {
return s.String()
}
// SetCampaignResponse sets the CampaignResponse field's value.
func (s *GetCampaignOutput) SetCampaignResponse(v *CampaignResponse) *GetCampaignOutput {
s.CampaignResponse = v
return s
}
// See also, path_to_url
type GetCampaignVersionInput struct {
_ struct{} `type:"structure"`
// ApplicationId is a required field
ApplicationId *string `location:"uri" locationName:"application-id" type:"string" required:"true"`
// CampaignId is a required field
CampaignId *string `location:"uri" locationName:"campaign-id" type:"string" required:"true"`
// Version is a required field
Version *string `location:"uri" locationName:"version" type:"string" required:"true"`
}
// String returns the string representation
func (s GetCampaignVersionInput) String() string {
return awsutil.Prettify(s)
}
// GoString returns the string representation
func (s GetCampaignVersionInput) GoString() string {
return s.String()
}
// Validate inspects the fields of the type to determine if they are valid.
func (s *GetCampaignVersionInput) Validate() error {
invalidParams := request.ErrInvalidParams{Context: "GetCampaignVersionInput"}
if s.ApplicationId == nil {
invalidParams.Add(request.NewErrParamRequired("ApplicationId"))
}
if s.CampaignId == nil {
invalidParams.Add(request.NewErrParamRequired("CampaignId"))
}
if s.Version == nil {
invalidParams.Add(request.NewErrParamRequired("Version"))
}
if invalidParams.Len() > 0 {
return invalidParams
}
return nil
}
// SetApplicationId sets the ApplicationId field's value.
func (s *GetCampaignVersionInput) SetApplicationId(v string) *GetCampaignVersionInput {
s.ApplicationId = &v
return s
}
// SetCampaignId sets the CampaignId field's value.
func (s *GetCampaignVersionInput) SetCampaignId(v string) *GetCampaignVersionInput {
s.CampaignId = &v
return s
}
// SetVersion sets the Version field's value.
func (s *GetCampaignVersionInput) SetVersion(v string) *GetCampaignVersionInput {
s.Version = &v
return s
}
// See also, path_to_url
type GetCampaignVersionOutput struct {
_ struct{} `type:"structure" payload:"CampaignResponse"`
// Campaign definition
//
// CampaignResponse is a required field
CampaignResponse *CampaignResponse `type:"structure" required:"true"`
}
// String returns the string representation
func (s GetCampaignVersionOutput) String() string {
return awsutil.Prettify(s)
}
// GoString returns the string representation
func (s GetCampaignVersionOutput) GoString() string {
return s.String()
}
// SetCampaignResponse sets the CampaignResponse field's value.
func (s *GetCampaignVersionOutput) SetCampaignResponse(v *CampaignResponse) *GetCampaignVersionOutput {
s.CampaignResponse = v
return s
}
// See also, path_to_url
type GetCampaignVersionsInput struct {
_ struct{} `type:"structure"`
// ApplicationId is a required field
ApplicationId *string `location:"uri" locationName:"application-id" type:"string" required:"true"`
// CampaignId is a required field
CampaignId *string `location:"uri" locationName:"campaign-id" type:"string" required:"true"`
PageSize *string `location:"querystring" locationName:"page-size" type:"string"`
Token *string `location:"querystring" locationName:"token" type:"string"`
}
// String returns the string representation
func (s GetCampaignVersionsInput) String() string {
return awsutil.Prettify(s)
}
// GoString returns the string representation
func (s GetCampaignVersionsInput) GoString() string {
return s.String()
}
// Validate inspects the fields of the type to determine if they are valid.
func (s *GetCampaignVersionsInput) Validate() error {
invalidParams := request.ErrInvalidParams{Context: "GetCampaignVersionsInput"}
if s.ApplicationId == nil {
invalidParams.Add(request.NewErrParamRequired("ApplicationId"))
}
if s.CampaignId == nil {
invalidParams.Add(request.NewErrParamRequired("CampaignId"))
}
if invalidParams.Len() > 0 {
return invalidParams
}
return nil
}
// SetApplicationId sets the ApplicationId field's value.
func (s *GetCampaignVersionsInput) SetApplicationId(v string) *GetCampaignVersionsInput {
s.ApplicationId = &v
return s
}
// SetCampaignId sets the CampaignId field's value.
func (s *GetCampaignVersionsInput) SetCampaignId(v string) *GetCampaignVersionsInput {
s.CampaignId = &v
return s
}
// SetPageSize sets the PageSize field's value.
func (s *GetCampaignVersionsInput) SetPageSize(v string) *GetCampaignVersionsInput {
s.PageSize = &v
return s
}
// SetToken sets the Token field's value.
func (s *GetCampaignVersionsInput) SetToken(v string) *GetCampaignVersionsInput {
s.Token = &v
return s
}
// See also, path_to_url
type GetCampaignVersionsOutput struct {
_ struct{} `type:"structure" payload:"CampaignsResponse"`
// List of available campaigns.
//
// CampaignsResponse is a required field
CampaignsResponse *CampaignsResponse `type:"structure" required:"true"`
}
// String returns the string representation
func (s GetCampaignVersionsOutput) String() string {
return awsutil.Prettify(s)
}
// GoString returns the string representation
func (s GetCampaignVersionsOutput) GoString() string {
return s.String()
}
// SetCampaignsResponse sets the CampaignsResponse field's value.
func (s *GetCampaignVersionsOutput) SetCampaignsResponse(v *CampaignsResponse) *GetCampaignVersionsOutput {
s.CampaignsResponse = v
return s
}
// See also, path_to_url
type GetCampaignsInput struct {
_ struct{} `type:"structure"`
// ApplicationId is a required field
ApplicationId *string `location:"uri" locationName:"application-id" type:"string" required:"true"`
PageSize *string `location:"querystring" locationName:"page-size" type:"string"`
Token *string `location:"querystring" locationName:"token" type:"string"`
}
// String returns the string representation
func (s GetCampaignsInput) String() string {
return awsutil.Prettify(s)
}
// GoString returns the string representation
func (s GetCampaignsInput) GoString() string {
return s.String()
}
// Validate inspects the fields of the type to determine if they are valid.
func (s *GetCampaignsInput) Validate() error {
invalidParams := request.ErrInvalidParams{Context: "GetCampaignsInput"}
if s.ApplicationId == nil {
invalidParams.Add(request.NewErrParamRequired("ApplicationId"))
}
if invalidParams.Len() > 0 {
return invalidParams
}
return nil
}
// SetApplicationId sets the ApplicationId field's value.
func (s *GetCampaignsInput) SetApplicationId(v string) *GetCampaignsInput {
s.ApplicationId = &v
return s
}
// SetPageSize sets the PageSize field's value.
func (s *GetCampaignsInput) SetPageSize(v string) *GetCampaignsInput {
s.PageSize = &v
return s
}
// SetToken sets the Token field's value.
func (s *GetCampaignsInput) SetToken(v string) *GetCampaignsInput {
s.Token = &v
return s
}
// See also, path_to_url
type GetCampaignsOutput struct {
_ struct{} `type:"structure" payload:"CampaignsResponse"`
// List of available campaigns.
//
// CampaignsResponse is a required field
CampaignsResponse *CampaignsResponse `type:"structure" required:"true"`
}
// String returns the string representation
func (s GetCampaignsOutput) String() string {
return awsutil.Prettify(s)
}
// GoString returns the string representation
func (s GetCampaignsOutput) GoString() string {
return s.String()
}
// SetCampaignsResponse sets the CampaignsResponse field's value.
func (s *GetCampaignsOutput) SetCampaignsResponse(v *CampaignsResponse) *GetCampaignsOutput {
s.CampaignsResponse = v
return s
}
// See also, path_to_url
type GetEmailChannelInput struct {
_ struct{} `type:"structure"`
// ApplicationId is a required field
ApplicationId *string `location:"uri" locationName:"application-id" type:"string" required:"true"`
}
// String returns the string representation
func (s GetEmailChannelInput) String() string {
return awsutil.Prettify(s)
}
// GoString returns the string representation
func (s GetEmailChannelInput) GoString() string {
return s.String()
}
// Validate inspects the fields of the type to determine if they are valid.
func (s *GetEmailChannelInput) Validate() error {
invalidParams := request.ErrInvalidParams{Context: "GetEmailChannelInput"}
if s.ApplicationId == nil {
invalidParams.Add(request.NewErrParamRequired("ApplicationId"))
}
if invalidParams.Len() > 0 {
return invalidParams
}
return nil
}
// SetApplicationId sets the ApplicationId field's value.
func (s *GetEmailChannelInput) SetApplicationId(v string) *GetEmailChannelInput {
s.ApplicationId = &v
return s
}
// See also, path_to_url
type GetEmailChannelOutput struct {
_ struct{} `type:"structure" payload:"EmailChannelResponse"`
// Email Channel Response.
//
// EmailChannelResponse is a required field
EmailChannelResponse *EmailChannelResponse `type:"structure" required:"true"`
}
// String returns the string representation
func (s GetEmailChannelOutput) String() string {
return awsutil.Prettify(s)
}
// GoString returns the string representation
func (s GetEmailChannelOutput) GoString() string {
return s.String()
}
// SetEmailChannelResponse sets the EmailChannelResponse field's value.
func (s *GetEmailChannelOutput) SetEmailChannelResponse(v *EmailChannelResponse) *GetEmailChannelOutput {
s.EmailChannelResponse = v
return s
}
// See also, path_to_url
type GetEndpointInput struct {
_ struct{} `type:"structure"`
// ApplicationId is a required field
ApplicationId *string `location:"uri" locationName:"application-id" type:"string" required:"true"`
// EndpointId is a required field
EndpointId *string `location:"uri" locationName:"endpoint-id" type:"string" required:"true"`
}
// String returns the string representation
func (s GetEndpointInput) String() string {
return awsutil.Prettify(s)
}
// GoString returns the string representation
func (s GetEndpointInput) GoString() string {
return s.String()
}
// Validate inspects the fields of the type to determine if they are valid.
func (s *GetEndpointInput) Validate() error {
invalidParams := request.ErrInvalidParams{Context: "GetEndpointInput"}
if s.ApplicationId == nil {
invalidParams.Add(request.NewErrParamRequired("ApplicationId"))
}
if s.EndpointId == nil {
invalidParams.Add(request.NewErrParamRequired("EndpointId"))
}
if invalidParams.Len() > 0 {
return invalidParams
}
return nil
}
// SetApplicationId sets the ApplicationId field's value.
func (s *GetEndpointInput) SetApplicationId(v string) *GetEndpointInput {
s.ApplicationId = &v
return s
}
// SetEndpointId sets the EndpointId field's value.
func (s *GetEndpointInput) SetEndpointId(v string) *GetEndpointInput {
s.EndpointId = &v
return s
}
// See also, path_to_url
type GetEndpointOutput struct {
_ struct{} `type:"structure" payload:"EndpointResponse"`
// Endpoint response
//
// EndpointResponse is a required field
EndpointResponse *EndpointResponse `type:"structure" required:"true"`
}
// String returns the string representation
func (s GetEndpointOutput) String() string {
return awsutil.Prettify(s)
}
// GoString returns the string representation
func (s GetEndpointOutput) GoString() string {
return s.String()
}
// SetEndpointResponse sets the EndpointResponse field's value.
func (s *GetEndpointOutput) SetEndpointResponse(v *EndpointResponse) *GetEndpointOutput {
s.EndpointResponse = v
return s
}
// See also, path_to_url
type GetEventStreamInput struct {
_ struct{} `type:"structure"`
// Application Id.
//
// ApplicationId is a required field
ApplicationId *string `location:"uri" locationName:"application-id" type:"string" required:"true"`
}
// String returns the string representation
func (s GetEventStreamInput) String() string {
return awsutil.Prettify(s)
}
// GoString returns the string representation
func (s GetEventStreamInput) GoString() string {
return s.String()
}
// Validate inspects the fields of the type to determine if they are valid.
func (s *GetEventStreamInput) Validate() error {
invalidParams := request.ErrInvalidParams{Context: "GetEventStreamInput"}
if s.ApplicationId == nil {
invalidParams.Add(request.NewErrParamRequired("ApplicationId"))
}
if invalidParams.Len() > 0 {
return invalidParams
}
return nil
}
// SetApplicationId sets the ApplicationId field's value.
func (s *GetEventStreamInput) SetApplicationId(v string) *GetEventStreamInput {
s.ApplicationId = &v
return s
}
// See also, path_to_url
type GetEventStreamOutput struct {
_ struct{} `type:"structure" payload:"EventStream"`
// Model for an event publishing subscription export.
//
// EventStream is a required field
EventStream *EventStream `type:"structure" required:"true"`
}
// String returns the string representation
func (s GetEventStreamOutput) String() string {
return awsutil.Prettify(s)
}
// GoString returns the string representation
func (s GetEventStreamOutput) GoString() string {
return s.String()
}
// SetEventStream sets the EventStream field's value.
func (s *GetEventStreamOutput) SetEventStream(v *EventStream) *GetEventStreamOutput {
s.EventStream = v
return s
}
// See also, path_to_url
type GetGcmChannelInput struct {
_ struct{} `type:"structure"`
// ApplicationId is a required field
ApplicationId *string `location:"uri" locationName:"application-id" type:"string" required:"true"`
}
// String returns the string representation
func (s GetGcmChannelInput) String() string {
return awsutil.Prettify(s)
}
// GoString returns the string representation
func (s GetGcmChannelInput) GoString() string {
return s.String()
}
// Validate inspects the fields of the type to determine if they are valid.
func (s *GetGcmChannelInput) Validate() error {
invalidParams := request.ErrInvalidParams{Context: "GetGcmChannelInput"}
if s.ApplicationId == nil {
invalidParams.Add(request.NewErrParamRequired("ApplicationId"))
}
if invalidParams.Len() > 0 {
return invalidParams
}
return nil
}
// SetApplicationId sets the ApplicationId field's value.
func (s *GetGcmChannelInput) SetApplicationId(v string) *GetGcmChannelInput {
s.ApplicationId = &v
return s
}
// See also, path_to_url
type GetGcmChannelOutput struct {
_ struct{} `type:"structure" payload:"GCMChannelResponse"`
// Google Cloud Messaging channel definition
//
// GCMChannelResponse is a required field
GCMChannelResponse *GCMChannelResponse `type:"structure" required:"true"`
}
// String returns the string representation
func (s GetGcmChannelOutput) String() string {
return awsutil.Prettify(s)
}
// GoString returns the string representation
func (s GetGcmChannelOutput) GoString() string {
return s.String()
}
// SetGCMChannelResponse sets the GCMChannelResponse field's value.
func (s *GetGcmChannelOutput) SetGCMChannelResponse(v *GCMChannelResponse) *GetGcmChannelOutput {
s.GCMChannelResponse = v
return s
}
// See also, path_to_url
type GetImportJobInput struct {
_ struct{} `type:"structure"`
// ApplicationId is a required field
ApplicationId *string `location:"uri" locationName:"application-id" type:"string" required:"true"`
// JobId is a required field
JobId *string `location:"uri" locationName:"job-id" type:"string" required:"true"`
}
// String returns the string representation
func (s GetImportJobInput) String() string {
return awsutil.Prettify(s)
}
// GoString returns the string representation
func (s GetImportJobInput) GoString() string {
return s.String()
}
// Validate inspects the fields of the type to determine if they are valid.
func (s *GetImportJobInput) Validate() error {
invalidParams := request.ErrInvalidParams{Context: "GetImportJobInput"}
if s.ApplicationId == nil {
invalidParams.Add(request.NewErrParamRequired("ApplicationId"))
}
if s.JobId == nil {
invalidParams.Add(request.NewErrParamRequired("JobId"))
}
if invalidParams.Len() > 0 {
return invalidParams
}
return nil
}
// SetApplicationId sets the ApplicationId field's value.
func (s *GetImportJobInput) SetApplicationId(v string) *GetImportJobInput {
s.ApplicationId = &v
return s
}
// SetJobId sets the JobId field's value.
func (s *GetImportJobInput) SetJobId(v string) *GetImportJobInput {
s.JobId = &v
return s
}
// See also, path_to_url
type GetImportJobOutput struct {
_ struct{} `type:"structure" payload:"ImportJobResponse"`
// ImportJobResponse is a required field
ImportJobResponse *ImportJobResponse `type:"structure" required:"true"`
}
// String returns the string representation
func (s GetImportJobOutput) String() string {
return awsutil.Prettify(s)
}
// GoString returns the string representation
func (s GetImportJobOutput) GoString() string {
return s.String()
}
// SetImportJobResponse sets the ImportJobResponse field's value.
func (s *GetImportJobOutput) SetImportJobResponse(v *ImportJobResponse) *GetImportJobOutput {
s.ImportJobResponse = v
return s
}
// See also, path_to_url
type GetImportJobsInput struct {
_ struct{} `type:"structure"`
// ApplicationId is a required field
ApplicationId *string `location:"uri" locationName:"application-id" type:"string" required:"true"`
PageSize *string `location:"querystring" locationName:"page-size" type:"string"`
Token *string `location:"querystring" locationName:"token" type:"string"`
}
// String returns the string representation
func (s GetImportJobsInput) String() string {
return awsutil.Prettify(s)
}
// GoString returns the string representation
func (s GetImportJobsInput) GoString() string {
return s.String()
}
// Validate inspects the fields of the type to determine if they are valid.
func (s *GetImportJobsInput) Validate() error {
invalidParams := request.ErrInvalidParams{Context: "GetImportJobsInput"}
if s.ApplicationId == nil {
invalidParams.Add(request.NewErrParamRequired("ApplicationId"))
}
if invalidParams.Len() > 0 {
return invalidParams
}
return nil
}
// SetApplicationId sets the ApplicationId field's value.
func (s *GetImportJobsInput) SetApplicationId(v string) *GetImportJobsInput {
s.ApplicationId = &v
return s
}
// SetPageSize sets the PageSize field's value.
func (s *GetImportJobsInput) SetPageSize(v string) *GetImportJobsInput {
s.PageSize = &v
return s
}
// SetToken sets the Token field's value.
func (s *GetImportJobsInput) SetToken(v string) *GetImportJobsInput {
s.Token = &v
return s
}
// See also, path_to_url
type GetImportJobsOutput struct {
_ struct{} `type:"structure" payload:"ImportJobsResponse"`
// Import job list.
//
// ImportJobsResponse is a required field
ImportJobsResponse *ImportJobsResponse `type:"structure" required:"true"`
}
// String returns the string representation
func (s GetImportJobsOutput) String() string {
return awsutil.Prettify(s)
}
// GoString returns the string representation
func (s GetImportJobsOutput) GoString() string {
return s.String()
}
// SetImportJobsResponse sets the ImportJobsResponse field's value.
func (s *GetImportJobsOutput) SetImportJobsResponse(v *ImportJobsResponse) *GetImportJobsOutput {
s.ImportJobsResponse = v
return s
}
// See also, path_to_url
type GetSegmentImportJobsInput struct {
_ struct{} `type:"structure"`
// ApplicationId is a required field
ApplicationId *string `location:"uri" locationName:"application-id" type:"string" required:"true"`
PageSize *string `location:"querystring" locationName:"page-size" type:"string"`
// SegmentId is a required field
SegmentId *string `location:"uri" locationName:"segment-id" type:"string" required:"true"`
Token *string `location:"querystring" locationName:"token" type:"string"`
}
// String returns the string representation
func (s GetSegmentImportJobsInput) String() string {
return awsutil.Prettify(s)
}
// GoString returns the string representation
func (s GetSegmentImportJobsInput) GoString() string {
return s.String()
}
// Validate inspects the fields of the type to determine if they are valid.
func (s *GetSegmentImportJobsInput) Validate() error {
invalidParams := request.ErrInvalidParams{Context: "GetSegmentImportJobsInput"}
if s.ApplicationId == nil {
invalidParams.Add(request.NewErrParamRequired("ApplicationId"))
}
if s.SegmentId == nil {
invalidParams.Add(request.NewErrParamRequired("SegmentId"))
}
if invalidParams.Len() > 0 {
return invalidParams
}
return nil
}
// SetApplicationId sets the ApplicationId field's value.
func (s *GetSegmentImportJobsInput) SetApplicationId(v string) *GetSegmentImportJobsInput {
s.ApplicationId = &v
return s
}
// SetPageSize sets the PageSize field's value.
func (s *GetSegmentImportJobsInput) SetPageSize(v string) *GetSegmentImportJobsInput {
s.PageSize = &v
return s
}
// SetSegmentId sets the SegmentId field's value.
func (s *GetSegmentImportJobsInput) SetSegmentId(v string) *GetSegmentImportJobsInput {
s.SegmentId = &v
return s
}
// SetToken sets the Token field's value.
func (s *GetSegmentImportJobsInput) SetToken(v string) *GetSegmentImportJobsInput {
s.Token = &v
return s
}
// See also, path_to_url
type GetSegmentImportJobsOutput struct {
_ struct{} `type:"structure" payload:"ImportJobsResponse"`
// Import job list.
//
// ImportJobsResponse is a required field
ImportJobsResponse *ImportJobsResponse `type:"structure" required:"true"`
}
// String returns the string representation
func (s GetSegmentImportJobsOutput) String() string {
return awsutil.Prettify(s)
}
// GoString returns the string representation
func (s GetSegmentImportJobsOutput) GoString() string {
return s.String()
}
// SetImportJobsResponse sets the ImportJobsResponse field's value.
func (s *GetSegmentImportJobsOutput) SetImportJobsResponse(v *ImportJobsResponse) *GetSegmentImportJobsOutput {
s.ImportJobsResponse = v
return s
}
// See also, path_to_url
type GetSegmentInput struct {
_ struct{} `type:"structure"`
// ApplicationId is a required field
ApplicationId *string `location:"uri" locationName:"application-id" type:"string" required:"true"`
// SegmentId is a required field
SegmentId *string `location:"uri" locationName:"segment-id" type:"string" required:"true"`
}
// String returns the string representation
func (s GetSegmentInput) String() string {
return awsutil.Prettify(s)
}
// GoString returns the string representation
func (s GetSegmentInput) GoString() string {
return s.String()
}
// Validate inspects the fields of the type to determine if they are valid.
func (s *GetSegmentInput) Validate() error {
invalidParams := request.ErrInvalidParams{Context: "GetSegmentInput"}
if s.ApplicationId == nil {
invalidParams.Add(request.NewErrParamRequired("ApplicationId"))
}
if s.SegmentId == nil {
invalidParams.Add(request.NewErrParamRequired("SegmentId"))
}
if invalidParams.Len() > 0 {
return invalidParams
}
return nil
}
// SetApplicationId sets the ApplicationId field's value.
func (s *GetSegmentInput) SetApplicationId(v string) *GetSegmentInput {
s.ApplicationId = &v
return s
}
// SetSegmentId sets the SegmentId field's value.
func (s *GetSegmentInput) SetSegmentId(v string) *GetSegmentInput {
s.SegmentId = &v
return s
}
// See also, path_to_url
type GetSegmentOutput struct {
_ struct{} `type:"structure" payload:"SegmentResponse"`
// Segment definition.
//
// SegmentResponse is a required field
SegmentResponse *SegmentResponse `type:"structure" required:"true"`
}
// String returns the string representation
func (s GetSegmentOutput) String() string {
return awsutil.Prettify(s)
}
// GoString returns the string representation
func (s GetSegmentOutput) GoString() string {
return s.String()
}
// SetSegmentResponse sets the SegmentResponse field's value.
func (s *GetSegmentOutput) SetSegmentResponse(v *SegmentResponse) *GetSegmentOutput {
s.SegmentResponse = v
return s
}
// See also, path_to_url
type GetSegmentVersionInput struct {
_ struct{} `type:"structure"`
// ApplicationId is a required field
ApplicationId *string `location:"uri" locationName:"application-id" type:"string" required:"true"`
// SegmentId is a required field
SegmentId *string `location:"uri" locationName:"segment-id" type:"string" required:"true"`
// Version is a required field
Version *string `location:"uri" locationName:"version" type:"string" required:"true"`
}
// String returns the string representation
func (s GetSegmentVersionInput) String() string {
return awsutil.Prettify(s)
}
// GoString returns the string representation
func (s GetSegmentVersionInput) GoString() string {
return s.String()
}
// Validate inspects the fields of the type to determine if they are valid.
func (s *GetSegmentVersionInput) Validate() error {
invalidParams := request.ErrInvalidParams{Context: "GetSegmentVersionInput"}
if s.ApplicationId == nil {
invalidParams.Add(request.NewErrParamRequired("ApplicationId"))
}
if s.SegmentId == nil {
invalidParams.Add(request.NewErrParamRequired("SegmentId"))
}
if s.Version == nil {
invalidParams.Add(request.NewErrParamRequired("Version"))
}
if invalidParams.Len() > 0 {
return invalidParams
}
return nil
}
// SetApplicationId sets the ApplicationId field's value.
func (s *GetSegmentVersionInput) SetApplicationId(v string) *GetSegmentVersionInput {
s.ApplicationId = &v
return s
}
// SetSegmentId sets the SegmentId field's value.
func (s *GetSegmentVersionInput) SetSegmentId(v string) *GetSegmentVersionInput {
s.SegmentId = &v
return s
}
// SetVersion sets the Version field's value.
func (s *GetSegmentVersionInput) SetVersion(v string) *GetSegmentVersionInput {
s.Version = &v
return s
}
// See also, path_to_url
type GetSegmentVersionOutput struct {
_ struct{} `type:"structure" payload:"SegmentResponse"`
// Segment definition.
//
// SegmentResponse is a required field
SegmentResponse *SegmentResponse `type:"structure" required:"true"`
}
// String returns the string representation
func (s GetSegmentVersionOutput) String() string {
return awsutil.Prettify(s)
}
// GoString returns the string representation
func (s GetSegmentVersionOutput) GoString() string {
return s.String()
}
// SetSegmentResponse sets the SegmentResponse field's value.
func (s *GetSegmentVersionOutput) SetSegmentResponse(v *SegmentResponse) *GetSegmentVersionOutput {
s.SegmentResponse = v
return s
}
// See also, path_to_url
type GetSegmentVersionsInput struct {
_ struct{} `type:"structure"`
// ApplicationId is a required field
ApplicationId *string `location:"uri" locationName:"application-id" type:"string" required:"true"`
PageSize *string `location:"querystring" locationName:"page-size" type:"string"`
// SegmentId is a required field
SegmentId *string `location:"uri" locationName:"segment-id" type:"string" required:"true"`
Token *string `location:"querystring" locationName:"token" type:"string"`
}
// String returns the string representation
func (s GetSegmentVersionsInput) String() string {
return awsutil.Prettify(s)
}
// GoString returns the string representation
func (s GetSegmentVersionsInput) GoString() string {
return s.String()
}
// Validate inspects the fields of the type to determine if they are valid.
func (s *GetSegmentVersionsInput) Validate() error {
invalidParams := request.ErrInvalidParams{Context: "GetSegmentVersionsInput"}
if s.ApplicationId == nil {
invalidParams.Add(request.NewErrParamRequired("ApplicationId"))
}
if s.SegmentId == nil {
invalidParams.Add(request.NewErrParamRequired("SegmentId"))
}
if invalidParams.Len() > 0 {
return invalidParams
}
return nil
}
// SetApplicationId sets the ApplicationId field's value.
func (s *GetSegmentVersionsInput) SetApplicationId(v string) *GetSegmentVersionsInput {
s.ApplicationId = &v
return s
}
// SetPageSize sets the PageSize field's value.
func (s *GetSegmentVersionsInput) SetPageSize(v string) *GetSegmentVersionsInput {
s.PageSize = &v
return s
}
// SetSegmentId sets the SegmentId field's value.
func (s *GetSegmentVersionsInput) SetSegmentId(v string) *GetSegmentVersionsInput {
s.SegmentId = &v
return s
}
// SetToken sets the Token field's value.
func (s *GetSegmentVersionsInput) SetToken(v string) *GetSegmentVersionsInput {
s.Token = &v
return s
}
// See also, path_to_url
type GetSegmentVersionsOutput struct {
_ struct{} `type:"structure" payload:"SegmentsResponse"`
// Segments in your account.
//
// SegmentsResponse is a required field
SegmentsResponse *SegmentsResponse `type:"structure" required:"true"`
}
// String returns the string representation
func (s GetSegmentVersionsOutput) String() string {
return awsutil.Prettify(s)
}
// GoString returns the string representation
func (s GetSegmentVersionsOutput) GoString() string {
return s.String()
}
// SetSegmentsResponse sets the SegmentsResponse field's value.
func (s *GetSegmentVersionsOutput) SetSegmentsResponse(v *SegmentsResponse) *GetSegmentVersionsOutput {
s.SegmentsResponse = v
return s
}
// See also, path_to_url
type GetSegmentsInput struct {
_ struct{} `type:"structure"`
// ApplicationId is a required field
ApplicationId *string `location:"uri" locationName:"application-id" type:"string" required:"true"`
PageSize *string `location:"querystring" locationName:"page-size" type:"string"`
Token *string `location:"querystring" locationName:"token" type:"string"`
}
// String returns the string representation
func (s GetSegmentsInput) String() string {
return awsutil.Prettify(s)
}
// GoString returns the string representation
func (s GetSegmentsInput) GoString() string {
return s.String()
}
// Validate inspects the fields of the type to determine if they are valid.
func (s *GetSegmentsInput) Validate() error {
invalidParams := request.ErrInvalidParams{Context: "GetSegmentsInput"}
if s.ApplicationId == nil {
invalidParams.Add(request.NewErrParamRequired("ApplicationId"))
}
if invalidParams.Len() > 0 {
return invalidParams
}
return nil
}
// SetApplicationId sets the ApplicationId field's value.
func (s *GetSegmentsInput) SetApplicationId(v string) *GetSegmentsInput {
s.ApplicationId = &v
return s
}
// SetPageSize sets the PageSize field's value.
func (s *GetSegmentsInput) SetPageSize(v string) *GetSegmentsInput {
s.PageSize = &v
return s
}
// SetToken sets the Token field's value.
func (s *GetSegmentsInput) SetToken(v string) *GetSegmentsInput {
s.Token = &v
return s
}
// See also, path_to_url
type GetSegmentsOutput struct {
_ struct{} `type:"structure" payload:"SegmentsResponse"`
// Segments in your account.
//
// SegmentsResponse is a required field
SegmentsResponse *SegmentsResponse `type:"structure" required:"true"`
}
// String returns the string representation
func (s GetSegmentsOutput) String() string {
return awsutil.Prettify(s)
}
// GoString returns the string representation
func (s GetSegmentsOutput) GoString() string {
return s.String()
}
// SetSegmentsResponse sets the SegmentsResponse field's value.
func (s *GetSegmentsOutput) SetSegmentsResponse(v *SegmentsResponse) *GetSegmentsOutput {
s.SegmentsResponse = v
return s
}
// See also, path_to_url
type GetSmsChannelInput struct {
_ struct{} `type:"structure"`
// ApplicationId is a required field
ApplicationId *string `location:"uri" locationName:"application-id" type:"string" required:"true"`
}
// String returns the string representation
func (s GetSmsChannelInput) String() string {
return awsutil.Prettify(s)
}
// GoString returns the string representation
func (s GetSmsChannelInput) GoString() string {
return s.String()
}
// Validate inspects the fields of the type to determine if they are valid.
func (s *GetSmsChannelInput) Validate() error {
invalidParams := request.ErrInvalidParams{Context: "GetSmsChannelInput"}
if s.ApplicationId == nil {
invalidParams.Add(request.NewErrParamRequired("ApplicationId"))
}
if invalidParams.Len() > 0 {
return invalidParams
}
return nil
}
// SetApplicationId sets the ApplicationId field's value.
func (s *GetSmsChannelInput) SetApplicationId(v string) *GetSmsChannelInput {
s.ApplicationId = &v
return s
}
// See also, path_to_url
type GetSmsChannelOutput struct {
_ struct{} `type:"structure" payload:"SMSChannelResponse"`
// SMS Channel Response.
//
// SMSChannelResponse is a required field
SMSChannelResponse *SMSChannelResponse `type:"structure" required:"true"`
}
// String returns the string representation
func (s GetSmsChannelOutput) String() string {
return awsutil.Prettify(s)
}
// GoString returns the string representation
func (s GetSmsChannelOutput) GoString() string {
return s.String()
}
// SetSMSChannelResponse sets the SMSChannelResponse field's value.
func (s *GetSmsChannelOutput) SetSMSChannelResponse(v *SMSChannelResponse) *GetSmsChannelOutput {
s.SMSChannelResponse = v
return s
}
// See also, path_to_url
type ImportJobRequest struct {
_ struct{} `type:"structure"`
// Sets whether the endpoints create a segment when they are imported.
DefineSegment *bool `type:"boolean"`
// A unique, custom ID assigned to the IAM role that restricts who can assume
// the role.
ExternalId *string `type:"string"`
// The format of the files that contain the endpoint definitions.Valid values:
// CSV, JSON
Format *string `type:"string" enum:"Format"`
// Sets whether the endpoints are registered with Amazon Pinpoint when they
// are imported.
RegisterEndpoints *bool `type:"boolean"`
// The Amazon Resource Name (ARN) of an IAM role that grants Amazon Pinpoint
// access to the Amazon S3 location that contains the endpoints to import.
RoleArn *string `type:"string"`
// A URL that points to the location within an Amazon S3 bucket that contains
// the endpoints to import. The location can be a folder or a single file.The
// URL should follow this format: s3://bucket-name/folder-name/file-nameAmazon
// Pinpoint will import endpoints from this location and any subfolders it contains.
S3Url *string `type:"string"`
// The ID of the segment to update if the import job is meant to update an existing
// segment.
SegmentId *string `type:"string"`
// A custom name for the segment created by the import job. Use if DefineSegment
// is true.
SegmentName *string `type:"string"`
}
// String returns the string representation
func (s ImportJobRequest) String() string {
return awsutil.Prettify(s)
}
// GoString returns the string representation
func (s ImportJobRequest) GoString() string {
return s.String()
}
// SetDefineSegment sets the DefineSegment field's value.
func (s *ImportJobRequest) SetDefineSegment(v bool) *ImportJobRequest {
s.DefineSegment = &v
return s
}
// SetExternalId sets the ExternalId field's value.
func (s *ImportJobRequest) SetExternalId(v string) *ImportJobRequest {
s.ExternalId = &v
return s
}
// SetFormat sets the Format field's value.
func (s *ImportJobRequest) SetFormat(v string) *ImportJobRequest {
s.Format = &v
return s
}
// SetRegisterEndpoints sets the RegisterEndpoints field's value.
func (s *ImportJobRequest) SetRegisterEndpoints(v bool) *ImportJobRequest {
s.RegisterEndpoints = &v
return s
}
// SetRoleArn sets the RoleArn field's value.
func (s *ImportJobRequest) SetRoleArn(v string) *ImportJobRequest {
s.RoleArn = &v
return s
}
// SetS3Url sets the S3Url field's value.
func (s *ImportJobRequest) SetS3Url(v string) *ImportJobRequest {
s.S3Url = &v
return s
}
// SetSegmentId sets the SegmentId field's value.
func (s *ImportJobRequest) SetSegmentId(v string) *ImportJobRequest {
s.SegmentId = &v
return s
}
// SetSegmentName sets the SegmentName field's value.
func (s *ImportJobRequest) SetSegmentName(v string) *ImportJobRequest {
s.SegmentName = &v
return s
}
// See also, path_to_url
type ImportJobResource struct {
_ struct{} `type:"structure"`
// Sets whether the endpoints create a segment when they are imported.
DefineSegment *bool `type:"boolean"`
// A unique, custom ID assigned to the IAM role that restricts who can assume
// the role.
ExternalId *string `type:"string"`
// The format of the files that contain the endpoint definitions.Valid values:
// CSV, JSON
Format *string `type:"string" enum:"Format"`
// Sets whether the endpoints are registered with Amazon Pinpoint when they
// are imported.
RegisterEndpoints *bool `type:"boolean"`
// The Amazon Resource Name (ARN) of an IAM role that grants Amazon Pinpoint
// access to the Amazon S3 location that contains the endpoints to import.
RoleArn *string `type:"string"`
// A URL that points to the location within an Amazon S3 bucket that contains
// the endpoints to import. The location can be a folder or a single file.The
// URL should follow this format: s3://bucket-name/folder-name/file-nameAmazon
// Pinpoint will import endpoints from this location and any subfolders it contains.
S3Url *string `type:"string"`
// The ID of the segment to update if the import job is meant to update an existing
// segment.
SegmentId *string `type:"string"`
// A custom name for the segment created by the import job. Use if DefineSegment
// is true.
SegmentName *string `type:"string"`
}
// String returns the string representation
func (s ImportJobResource) String() string {
return awsutil.Prettify(s)
}
// GoString returns the string representation
func (s ImportJobResource) GoString() string {
return s.String()
}
// SetDefineSegment sets the DefineSegment field's value.
func (s *ImportJobResource) SetDefineSegment(v bool) *ImportJobResource {
s.DefineSegment = &v
return s
}
// SetExternalId sets the ExternalId field's value.
func (s *ImportJobResource) SetExternalId(v string) *ImportJobResource {
s.ExternalId = &v
return s
}
// SetFormat sets the Format field's value.
func (s *ImportJobResource) SetFormat(v string) *ImportJobResource {
s.Format = &v
return s
}
// SetRegisterEndpoints sets the RegisterEndpoints field's value.
func (s *ImportJobResource) SetRegisterEndpoints(v bool) *ImportJobResource {
s.RegisterEndpoints = &v
return s
}
// SetRoleArn sets the RoleArn field's value.
func (s *ImportJobResource) SetRoleArn(v string) *ImportJobResource {
s.RoleArn = &v
return s
}
// SetS3Url sets the S3Url field's value.
func (s *ImportJobResource) SetS3Url(v string) *ImportJobResource {
s.S3Url = &v
return s
}
// SetSegmentId sets the SegmentId field's value.
func (s *ImportJobResource) SetSegmentId(v string) *ImportJobResource {
s.SegmentId = &v
return s
}
// SetSegmentName sets the SegmentName field's value.
func (s *ImportJobResource) SetSegmentName(v string) *ImportJobResource {
s.SegmentName = &v
return s
}
// See also, path_to_url
type ImportJobResponse struct {
_ struct{} `type:"structure"`
// The unique ID of the application to which the import job applies.
ApplicationId *string `type:"string"`
// The number of pieces that have successfully imported as of the time of the
// request.
CompletedPieces *int64 `type:"integer"`
// The date the import job completed in ISO 8601 format.
CompletionDate *string `type:"string"`
// The date the import job was created in ISO 8601 format.
CreationDate *string `type:"string"`
// The import job settings.
Definition *ImportJobResource `type:"structure"`
// The number of pieces that have failed to import as of the time of the request.
FailedPieces *int64 `type:"integer"`
Failures []*string `type:"list"`
// The unique ID of the import job.
Id *string `type:"string"`
// The status of the import job.Valid values: CREATED, INITIALIZING, PROCESSING,
// COMPLETING, COMPLETED, FAILING, FAILEDThe job status is FAILED if one or
// more pieces failed to import.
JobStatus *string `type:"string" enum:"JobStatus"`
// The number of endpoints that failed to import; for example, because of syntax
// errors.
TotalFailures *int64 `type:"integer"`
// The total number of pieces that must be imported to finish the job. Each
// piece is an approximately equal portion of the endpoints to import.
TotalPieces *int64 `type:"integer"`
// The number of endpoints that were processed by the import job.
TotalProcessed *int64 `type:"integer"`
// The job type. Will be Import.
Type *string `type:"string"`
}
// String returns the string representation
func (s ImportJobResponse) String() string {
return awsutil.Prettify(s)
}
// GoString returns the string representation
func (s ImportJobResponse) GoString() string {
return s.String()
}
// SetApplicationId sets the ApplicationId field's value.
func (s *ImportJobResponse) SetApplicationId(v string) *ImportJobResponse {
s.ApplicationId = &v
return s
}
// SetCompletedPieces sets the CompletedPieces field's value.
func (s *ImportJobResponse) SetCompletedPieces(v int64) *ImportJobResponse {
s.CompletedPieces = &v
return s
}
// SetCompletionDate sets the CompletionDate field's value.
func (s *ImportJobResponse) SetCompletionDate(v string) *ImportJobResponse {
s.CompletionDate = &v
return s
}
// SetCreationDate sets the CreationDate field's value.
func (s *ImportJobResponse) SetCreationDate(v string) *ImportJobResponse {
s.CreationDate = &v
return s
}
// SetDefinition sets the Definition field's value.
func (s *ImportJobResponse) SetDefinition(v *ImportJobResource) *ImportJobResponse {
s.Definition = v
return s
}
// SetFailedPieces sets the FailedPieces field's value.
func (s *ImportJobResponse) SetFailedPieces(v int64) *ImportJobResponse {
s.FailedPieces = &v
return s
}
// SetFailures sets the Failures field's value.
func (s *ImportJobResponse) SetFailures(v []*string) *ImportJobResponse {
s.Failures = v
return s
}
// SetId sets the Id field's value.
func (s *ImportJobResponse) SetId(v string) *ImportJobResponse {
s.Id = &v
return s
}
// SetJobStatus sets the JobStatus field's value.
func (s *ImportJobResponse) SetJobStatus(v string) *ImportJobResponse {
s.JobStatus = &v
return s
}
// SetTotalFailures sets the TotalFailures field's value.
func (s *ImportJobResponse) SetTotalFailures(v int64) *ImportJobResponse {
s.TotalFailures = &v
return s
}
// SetTotalPieces sets the TotalPieces field's value.
func (s *ImportJobResponse) SetTotalPieces(v int64) *ImportJobResponse {
s.TotalPieces = &v
return s
}
// SetTotalProcessed sets the TotalProcessed field's value.
func (s *ImportJobResponse) SetTotalProcessed(v int64) *ImportJobResponse {
s.TotalProcessed = &v
return s
}
// SetType sets the Type field's value.
func (s *ImportJobResponse) SetType(v string) *ImportJobResponse {
s.Type = &v
return s
}
// Import job list.
// See also, path_to_url
type ImportJobsResponse struct {
_ struct{} `type:"structure"`
// A list of import jobs for the application.
Item []*ImportJobResponse `type:"list"`
// The string that you use in a subsequent request to get the next page of results
// in a paginated response.
NextToken *string `type:"string"`
}
// String returns the string representation
func (s ImportJobsResponse) String() string {
return awsutil.Prettify(s)
}
// GoString returns the string representation
func (s ImportJobsResponse) GoString() string {
return s.String()
}
// SetItem sets the Item field's value.
func (s *ImportJobsResponse) SetItem(v []*ImportJobResponse) *ImportJobsResponse {
s.Item = v
return s
}
// SetNextToken sets the NextToken field's value.
func (s *ImportJobsResponse) SetNextToken(v string) *ImportJobsResponse {
s.NextToken = &v
return s
}
// See also, path_to_url
type Message struct {
_ struct{} `type:"structure"`
// The action that occurs if the user taps a push notification delivered by
// the campaign:OPEN_APP - Your app launches, or it becomes the foreground app
// if it has been sent to the background. This is the default action.DEEP_LINK
// - Uses deep linking features in iOS and Android to open your app and display
// a designated user interface within the app.URL - The default mobile browser
// on the user's device launches and opens a web page at the URL you specify.
Action *string `type:"string" enum:"Action"`
// The message body. Can include up to 140 characters.
Body *string `type:"string"`
// The URL that points to the icon image for the push notification icon, for
// example, the app icon.
ImageIconUrl *string `type:"string"`
// The URL that points to the small icon image for the push notification icon,
// for example, the app icon.
ImageSmallIconUrl *string `type:"string"`
// The URL that points to an image used in the push notification.
ImageUrl *string `type:"string"`
// The JSON payload used for a silent push.
JsonBody *string `type:"string"`
// The URL that points to the media resource, for example a .mp4 or .gif file.
MediaUrl *string `type:"string"`
// The Raw JSON formatted string to be used as the payload. This value overrides
// the message.
RawContent *string `type:"string"`
// Indicates if the message should display on the users device.Silent pushes
// can be used for Remote Configuration and Phone Home use cases.
SilentPush *bool `type:"boolean"`
// The message title that displays above the message on the user's device.
Title *string `type:"string"`
// The URL to open in the user's mobile browser. Used if the value for Action
// is URL.
Url *string `type:"string"`
}
// String returns the string representation
func (s Message) String() string {
return awsutil.Prettify(s)
}
// GoString returns the string representation
func (s Message) GoString() string {
return s.String()
}
// SetAction sets the Action field's value.
func (s *Message) SetAction(v string) *Message {
s.Action = &v
return s
}
// SetBody sets the Body field's value.
func (s *Message) SetBody(v string) *Message {
s.Body = &v
return s
}
// SetImageIconUrl sets the ImageIconUrl field's value.
func (s *Message) SetImageIconUrl(v string) *Message {
s.ImageIconUrl = &v
return s
}
// SetImageSmallIconUrl sets the ImageSmallIconUrl field's value.
func (s *Message) SetImageSmallIconUrl(v string) *Message {
s.ImageSmallIconUrl = &v
return s
}
// SetImageUrl sets the ImageUrl field's value.
func (s *Message) SetImageUrl(v string) *Message {
s.ImageUrl = &v
return s
}
// SetJsonBody sets the JsonBody field's value.
func (s *Message) SetJsonBody(v string) *Message {
s.JsonBody = &v
return s
}
// SetMediaUrl sets the MediaUrl field's value.
func (s *Message) SetMediaUrl(v string) *Message {
s.MediaUrl = &v
return s
}
// SetRawContent sets the RawContent field's value.
func (s *Message) SetRawContent(v string) *Message {
s.RawContent = &v
return s
}
// SetSilentPush sets the SilentPush field's value.
func (s *Message) SetSilentPush(v bool) *Message {
s.SilentPush = &v
return s
}
// SetTitle sets the Title field's value.
func (s *Message) SetTitle(v string) *Message {
s.Title = &v
return s
}
// SetUrl sets the Url field's value.
func (s *Message) SetUrl(v string) *Message {
s.Url = &v
return s
}
// Simple message object.
// See also, path_to_url
type MessageBody struct {
_ struct{} `type:"structure"`
// The error message returned from the API.
Message *string `type:"string"`
// The unique message body ID.
RequestID *string `type:"string"`
}
// String returns the string representation
func (s MessageBody) String() string {
return awsutil.Prettify(s)
}
// GoString returns the string representation
func (s MessageBody) GoString() string {
return s.String()
}
// SetMessage sets the Message field's value.
func (s *MessageBody) SetMessage(v string) *MessageBody {
s.Message = &v
return s
}
// SetRequestID sets the RequestID field's value.
func (s *MessageBody) SetRequestID(v string) *MessageBody {
s.RequestID = &v
return s
}
// Message configuration for a campaign.
// See also, path_to_url
type MessageConfiguration struct {
_ struct{} `type:"structure"`
// The message that the campaign delivers to ADM channels. Overrides the default
// message.
ADMMessage *Message `type:"structure"`
// The message that the campaign delivers to APNS channels. Overrides the default
// message.
APNSMessage *Message `type:"structure"`
// The message that the campaign delivers to Baidu channels. Overrides the default
// message.
BaiduMessage *Message `type:"structure"`
// The default message for all channels.
DefaultMessage *Message `type:"structure"`
// The email message configuration.
EmailMessage *CampaignEmailMessage `type:"structure"`
// The message that the campaign delivers to GCM channels. Overrides the default
// message.
GCMMessage *Message `type:"structure"`
// The SMS message configuration.
SMSMessage *CampaignSmsMessage `type:"structure"`
}
// String returns the string representation
func (s MessageConfiguration) String() string {
return awsutil.Prettify(s)
}
// GoString returns the string representation
func (s MessageConfiguration) GoString() string {
return s.String()
}
// SetADMMessage sets the ADMMessage field's value.
func (s *MessageConfiguration) SetADMMessage(v *Message) *MessageConfiguration {
s.ADMMessage = v
return s
}
// SetAPNSMessage sets the APNSMessage field's value.
func (s *MessageConfiguration) SetAPNSMessage(v *Message) *MessageConfiguration {
s.APNSMessage = v
return s
}
// SetBaiduMessage sets the BaiduMessage field's value.
func (s *MessageConfiguration) SetBaiduMessage(v *Message) *MessageConfiguration {
s.BaiduMessage = v
return s
}
// SetDefaultMessage sets the DefaultMessage field's value.
func (s *MessageConfiguration) SetDefaultMessage(v *Message) *MessageConfiguration {
s.DefaultMessage = v
return s
}
// SetEmailMessage sets the EmailMessage field's value.
func (s *MessageConfiguration) SetEmailMessage(v *CampaignEmailMessage) *MessageConfiguration {
s.EmailMessage = v
return s
}
// SetGCMMessage sets the GCMMessage field's value.
func (s *MessageConfiguration) SetGCMMessage(v *Message) *MessageConfiguration {
s.GCMMessage = v
return s
}
// SetSMSMessage sets the SMSMessage field's value.
func (s *MessageConfiguration) SetSMSMessage(v *CampaignSmsMessage) *MessageConfiguration {
s.SMSMessage = v
return s
}
// Send message request.
// See also, path_to_url
type MessageRequest struct {
_ struct{} `type:"structure"`
// A map of destination addresses, with the address as the key(Email address,
// phone number or push token) and the Address Configuration as the value.
Addresses map[string]*AddressConfiguration `type:"map"`
Context map[string]*string `type:"map"`
// A map of destination addresses, with the address as the key(Email address,
// phone number or push token) and the Address Configuration as the value.
Endpoints map[string]*EndpointSendConfiguration `type:"map"`
// Message configuration.
MessageConfiguration *DirectMessageConfiguration `type:"structure"`
}
// String returns the string representation
func (s MessageRequest) String() string {
return awsutil.Prettify(s)
}
// GoString returns the string representation
func (s MessageRequest) GoString() string {
return s.String()
}
// SetAddresses sets the Addresses field's value.
func (s *MessageRequest) SetAddresses(v map[string]*AddressConfiguration) *MessageRequest {
s.Addresses = v
return s
}
// SetContext sets the Context field's value.
func (s *MessageRequest) SetContext(v map[string]*string) *MessageRequest {
s.Context = v
return s
}
// SetEndpoints sets the Endpoints field's value.
func (s *MessageRequest) SetEndpoints(v map[string]*EndpointSendConfiguration) *MessageRequest {
s.Endpoints = v
return s
}
// SetMessageConfiguration sets the MessageConfiguration field's value.
func (s *MessageRequest) SetMessageConfiguration(v *DirectMessageConfiguration) *MessageRequest {
s.MessageConfiguration = v
return s
}
// Send message response.
// See also, path_to_url
type MessageResponse struct {
_ struct{} `type:"structure"`
// Application id of the message.
ApplicationId *string `type:"string"`
// A map containing a multi part response for each address, with the endpointId
// as the key and the result as the value.
EndpointResult map[string]*EndpointMessageResult `type:"map"`
// Original request Id for which this message was delivered.
RequestId *string `type:"string"`
// A map containing a multi part response for each address, with the address
// as the key(Email address, phone number or push token) and the result as the
// value.
Result map[string]*MessageResult `type:"map"`
}
// String returns the string representation
func (s MessageResponse) String() string {
return awsutil.Prettify(s)
}
// GoString returns the string representation
func (s MessageResponse) GoString() string {
return s.String()
}
// SetApplicationId sets the ApplicationId field's value.
func (s *MessageResponse) SetApplicationId(v string) *MessageResponse {
s.ApplicationId = &v
return s
}
// SetEndpointResult sets the EndpointResult field's value.
func (s *MessageResponse) SetEndpointResult(v map[string]*EndpointMessageResult) *MessageResponse {
s.EndpointResult = v
return s
}
// SetRequestId sets the RequestId field's value.
func (s *MessageResponse) SetRequestId(v string) *MessageResponse {
s.RequestId = &v
return s
}
// SetResult sets the Result field's value.
func (s *MessageResponse) SetResult(v map[string]*MessageResult) *MessageResponse {
s.Result = v
return s
}
// The result from sending a message to an address.
// See also, path_to_url
type MessageResult struct {
_ struct{} `type:"structure"`
// Delivery status of message.
DeliveryStatus *string `type:"string" enum:"DeliveryStatus"`
// Downstream service status code.
StatusCode *int64 `type:"integer"`
// Status message for message delivery.
StatusMessage *string `type:"string"`
// If token was updated as part of delivery. (This is GCM Specific)
UpdatedToken *string `type:"string"`
}
// String returns the string representation
func (s MessageResult) String() string {
return awsutil.Prettify(s)
}
// GoString returns the string representation
func (s MessageResult) GoString() string {
return s.String()
}
// SetDeliveryStatus sets the DeliveryStatus field's value.
func (s *MessageResult) SetDeliveryStatus(v string) *MessageResult {
s.DeliveryStatus = &v
return s
}
// SetStatusCode sets the StatusCode field's value.
func (s *MessageResult) SetStatusCode(v int64) *MessageResult {
s.StatusCode = &v
return s
}
// SetStatusMessage sets the StatusMessage field's value.
func (s *MessageResult) SetStatusMessage(v string) *MessageResult {
s.StatusMessage = &v
return s
}
// SetUpdatedToken sets the UpdatedToken field's value.
func (s *MessageResult) SetUpdatedToken(v string) *MessageResult {
s.UpdatedToken = &v
return s
}
// See also, path_to_url
type PutEventStreamInput struct {
_ struct{} `type:"structure" payload:"WriteEventStream"`
// Application Id.
//
// ApplicationId is a required field
ApplicationId *string `location:"uri" locationName:"application-id" type:"string" required:"true"`
// Write event stream wrapper.
//
// WriteEventStream is a required field
WriteEventStream *WriteEventStream `type:"structure" required:"true"`
}
// String returns the string representation
func (s PutEventStreamInput) String() string {
return awsutil.Prettify(s)
}
// GoString returns the string representation
func (s PutEventStreamInput) GoString() string {
return s.String()
}
// Validate inspects the fields of the type to determine if they are valid.
func (s *PutEventStreamInput) Validate() error {
invalidParams := request.ErrInvalidParams{Context: "PutEventStreamInput"}
if s.ApplicationId == nil {
invalidParams.Add(request.NewErrParamRequired("ApplicationId"))
}
if s.WriteEventStream == nil {
invalidParams.Add(request.NewErrParamRequired("WriteEventStream"))
}
if invalidParams.Len() > 0 {
return invalidParams
}
return nil
}
// SetApplicationId sets the ApplicationId field's value.
func (s *PutEventStreamInput) SetApplicationId(v string) *PutEventStreamInput {
s.ApplicationId = &v
return s
}
// SetWriteEventStream sets the WriteEventStream field's value.
func (s *PutEventStreamInput) SetWriteEventStream(v *WriteEventStream) *PutEventStreamInput {
s.WriteEventStream = v
return s
}
// See also, path_to_url
type PutEventStreamOutput struct {
_ struct{} `type:"structure" payload:"EventStream"`
// Model for an event publishing subscription export.
//
// EventStream is a required field
EventStream *EventStream `type:"structure" required:"true"`
}
// String returns the string representation
func (s PutEventStreamOutput) String() string {
return awsutil.Prettify(s)
}
// GoString returns the string representation
func (s PutEventStreamOutput) GoString() string {
return s.String()
}
// SetEventStream sets the EventStream field's value.
func (s *PutEventStreamOutput) SetEventStream(v *EventStream) *PutEventStreamOutput {
s.EventStream = v
return s
}
// Quiet Time
// See also, path_to_url
type QuietTime struct {
_ struct{} `type:"structure"`
// The default end time for quiet time in ISO 8601 format.
End *string `type:"string"`
// The default start time for quiet time in ISO 8601 format.
Start *string `type:"string"`
}
// String returns the string representation
func (s QuietTime) String() string {
return awsutil.Prettify(s)
}
// GoString returns the string representation
func (s QuietTime) GoString() string {
return s.String()
}
// SetEnd sets the End field's value.
func (s *QuietTime) SetEnd(v string) *QuietTime {
s.End = &v
return s
}
// SetStart sets the Start field's value.
func (s *QuietTime) SetStart(v string) *QuietTime {
s.Start = &v
return s
}
// Define how a segment based on recency of use.
// See also, path_to_url
type RecencyDimension struct {
_ struct{} `type:"structure"`
// The length of time during which users have been active or inactive with your
// app.Valid values: HR_24, DAY_7, DAY_14, DAY_30
Duration *string `type:"string" enum:"Duration"`
// The recency dimension type:ACTIVE - Users who have used your app within the
// specified duration are included in the segment.INACTIVE - Users who have
// not used your app within the specified duration are included in the segment.
RecencyType *string `type:"string" enum:"RecencyType"`
}
// String returns the string representation
func (s RecencyDimension) String() string {
return awsutil.Prettify(s)
}
// GoString returns the string representation
func (s RecencyDimension) GoString() string {
return s.String()
}
// SetDuration sets the Duration field's value.
func (s *RecencyDimension) SetDuration(v string) *RecencyDimension {
s.Duration = &v
return s
}
// SetRecencyType sets the RecencyType field's value.
func (s *RecencyDimension) SetRecencyType(v string) *RecencyDimension {
s.RecencyType = &v
return s
}
// SMS Channel Request
// See also, path_to_url
type SMSChannelRequest struct {
_ struct{} `type:"structure"`
// If the channel is enabled for sending messages.
Enabled *bool `type:"boolean"`
// Sender identifier of your messages.
SenderId *string `type:"string"`
// ShortCode registered with phone provider.
ShortCode *string `type:"string"`
}
// String returns the string representation
func (s SMSChannelRequest) String() string {
return awsutil.Prettify(s)
}
// GoString returns the string representation
func (s SMSChannelRequest) GoString() string {
return s.String()
}
// SetEnabled sets the Enabled field's value.
func (s *SMSChannelRequest) SetEnabled(v bool) *SMSChannelRequest {
s.Enabled = &v
return s
}
// SetSenderId sets the SenderId field's value.
func (s *SMSChannelRequest) SetSenderId(v string) *SMSChannelRequest {
s.SenderId = &v
return s
}
// SetShortCode sets the ShortCode field's value.
func (s *SMSChannelRequest) SetShortCode(v string) *SMSChannelRequest {
s.ShortCode = &v
return s
}
// SMS Channel Response.
// See also, path_to_url
type SMSChannelResponse struct {
_ struct{} `type:"structure"`
// The unique ID of the application to which the SMS channel belongs.
ApplicationId *string `type:"string"`
// The date that the settings were last updated in ISO 8601 format.
CreationDate *string `type:"string"`
// If the channel is enabled for sending messages.
Enabled *bool `type:"boolean"`
// If the channel is registered with a credential for authentication.
HasCredential *bool `type:"boolean"`
// Channel ID. Not used, only for backwards compatibility.
Id *string `type:"string"`
// Is this channel archived
IsArchived *bool `type:"boolean"`
// Who last updated this entry
LastModifiedBy *string `type:"string"`
// Last date this was updated
LastModifiedDate *string `type:"string"`
// Platform type. Will be "SMS"
Platform *string `type:"string"`
// Sender identifier of your messages.
SenderId *string `type:"string"`
// The short code registered with the phone provider.
ShortCode *string `type:"string"`
// Version of channel
Version *int64 `type:"integer"`
}
// String returns the string representation
func (s SMSChannelResponse) String() string {
return awsutil.Prettify(s)
}
// GoString returns the string representation
func (s SMSChannelResponse) GoString() string {
return s.String()
}
// SetApplicationId sets the ApplicationId field's value.
func (s *SMSChannelResponse) SetApplicationId(v string) *SMSChannelResponse {
s.ApplicationId = &v
return s
}
// SetCreationDate sets the CreationDate field's value.
func (s *SMSChannelResponse) SetCreationDate(v string) *SMSChannelResponse {
s.CreationDate = &v
return s
}
// SetEnabled sets the Enabled field's value.
func (s *SMSChannelResponse) SetEnabled(v bool) *SMSChannelResponse {
s.Enabled = &v
return s
}
// SetHasCredential sets the HasCredential field's value.
func (s *SMSChannelResponse) SetHasCredential(v bool) *SMSChannelResponse {
s.HasCredential = &v
return s
}
// SetId sets the Id field's value.
func (s *SMSChannelResponse) SetId(v string) *SMSChannelResponse {
s.Id = &v
return s
}
// SetIsArchived sets the IsArchived field's value.
func (s *SMSChannelResponse) SetIsArchived(v bool) *SMSChannelResponse {
s.IsArchived = &v
return s
}
// SetLastModifiedBy sets the LastModifiedBy field's value.
func (s *SMSChannelResponse) SetLastModifiedBy(v string) *SMSChannelResponse {
s.LastModifiedBy = &v
return s
}
// SetLastModifiedDate sets the LastModifiedDate field's value.
func (s *SMSChannelResponse) SetLastModifiedDate(v string) *SMSChannelResponse {
s.LastModifiedDate = &v
return s
}
// SetPlatform sets the Platform field's value.
func (s *SMSChannelResponse) SetPlatform(v string) *SMSChannelResponse {
s.Platform = &v
return s
}
// SetSenderId sets the SenderId field's value.
func (s *SMSChannelResponse) SetSenderId(v string) *SMSChannelResponse {
s.SenderId = &v
return s
}
// SetShortCode sets the ShortCode field's value.
func (s *SMSChannelResponse) SetShortCode(v string) *SMSChannelResponse {
s.ShortCode = &v
return s
}
// SetVersion sets the Version field's value.
func (s *SMSChannelResponse) SetVersion(v int64) *SMSChannelResponse {
s.Version = &v
return s
}
// SMS Message.
// See also, path_to_url
type SMSMessage struct {
_ struct{} `type:"structure"`
// The message body of the notification, the email body or the text message.
Body *string `type:"string"`
// Is this a transaction priority message or lower priority.
MessageType *string `type:"string" enum:"MessageType"`
// Sender ID of sent message.
SenderId *string `type:"string"`
Substitutions map[string][]*string `type:"map"`
}
// String returns the string representation
func (s SMSMessage) String() string {
return awsutil.Prettify(s)
}
// GoString returns the string representation
func (s SMSMessage) GoString() string {
return s.String()
}
// SetBody sets the Body field's value.
func (s *SMSMessage) SetBody(v string) *SMSMessage {
s.Body = &v
return s
}
// SetMessageType sets the MessageType field's value.
func (s *SMSMessage) SetMessageType(v string) *SMSMessage {
s.MessageType = &v
return s
}
// SetSenderId sets the SenderId field's value.
func (s *SMSMessage) SetSenderId(v string) *SMSMessage {
s.SenderId = &v
return s
}
// SetSubstitutions sets the Substitutions field's value.
func (s *SMSMessage) SetSubstitutions(v map[string][]*string) *SMSMessage {
s.Substitutions = v
return s
}
// Shcedule that defines when a campaign is run.
// See also, path_to_url
type Schedule struct {
_ struct{} `type:"structure"`
// The scheduled time that the campaign ends in ISO 8601 format.
EndTime *string `type:"string"`
// How often the campaign delivers messages.Valid values: ONCE, HOURLY, DAILY,
// WEEKLY, MONTHLY
Frequency *string `type:"string" enum:"Frequency"`
// Indicates whether the campaign schedule takes effect according to each user's
// local time.
IsLocalTime *bool `type:"boolean"`
// The time during which the campaign sends no messages.
QuietTime *QuietTime `type:"structure"`
// The scheduled time that the campaign begins in ISO 8601 format.
StartTime *string `type:"string"`
// The starting UTC offset for the schedule if the value for isLocalTime is
// trueValid values: UTCUTC+01UTC+02UTC+03UTC+03:30UTC+04UTC+04:30UTC+05UTC+05:30UTC+05:45UTC+06UTC+06:30UTC+07UTC+08UTC+09UTC+09:30UTC+10UTC+10:30UTC+11UTC+12UTC+13UTC-02UTC-03UTC-04UTC-05UTC-06UTC-07UTC-08UTC-09UTC-10UTC-11
Timezone *string `type:"string"`
}
// String returns the string representation
func (s Schedule) String() string {
return awsutil.Prettify(s)
}
// GoString returns the string representation
func (s Schedule) GoString() string {
return s.String()
}
// SetEndTime sets the EndTime field's value.
func (s *Schedule) SetEndTime(v string) *Schedule {
s.EndTime = &v
return s
}
// SetFrequency sets the Frequency field's value.
func (s *Schedule) SetFrequency(v string) *Schedule {
s.Frequency = &v
return s
}
// SetIsLocalTime sets the IsLocalTime field's value.
func (s *Schedule) SetIsLocalTime(v bool) *Schedule {
s.IsLocalTime = &v
return s
}
// SetQuietTime sets the QuietTime field's value.
func (s *Schedule) SetQuietTime(v *QuietTime) *Schedule {
s.QuietTime = v
return s
}
// SetStartTime sets the StartTime field's value.
func (s *Schedule) SetStartTime(v string) *Schedule {
s.StartTime = &v
return s
}
// SetTimezone sets the Timezone field's value.
func (s *Schedule) SetTimezone(v string) *Schedule {
s.Timezone = &v
return s
}
// Segment behavior dimensions
// See also, path_to_url
type SegmentBehaviors struct {
_ struct{} `type:"structure"`
// The recency of use.
Recency *RecencyDimension `type:"structure"`
}
// String returns the string representation
func (s SegmentBehaviors) String() string {
return awsutil.Prettify(s)
}
// GoString returns the string representation
func (s SegmentBehaviors) GoString() string {
return s.String()
}
// SetRecency sets the Recency field's value.
func (s *SegmentBehaviors) SetRecency(v *RecencyDimension) *SegmentBehaviors {
s.Recency = v
return s
}
// Segment demographic dimensions
// See also, path_to_url
type SegmentDemographics struct {
_ struct{} `type:"structure"`
// The app version criteria for the segment.
AppVersion *SetDimension `type:"structure"`
// The channel criteria for the segment.
Channel *SetDimension `type:"structure"`
// The device type criteria for the segment.
DeviceType *SetDimension `type:"structure"`
// The device make criteria for the segment.
Make *SetDimension `type:"structure"`
// The device model criteria for the segment.
Model *SetDimension `type:"structure"`
// The device platform criteria for the segment.
Platform *SetDimension `type:"structure"`
}
// String returns the string representation
func (s SegmentDemographics) String() string {
return awsutil.Prettify(s)
}
// GoString returns the string representation
func (s SegmentDemographics) GoString() string {
return s.String()
}
// SetAppVersion sets the AppVersion field's value.
func (s *SegmentDemographics) SetAppVersion(v *SetDimension) *SegmentDemographics {
s.AppVersion = v
return s
}
// SetChannel sets the Channel field's value.
func (s *SegmentDemographics) SetChannel(v *SetDimension) *SegmentDemographics {
s.Channel = v
return s
}
// SetDeviceType sets the DeviceType field's value.
func (s *SegmentDemographics) SetDeviceType(v *SetDimension) *SegmentDemographics {
s.DeviceType = v
return s
}
// SetMake sets the Make field's value.
func (s *SegmentDemographics) SetMake(v *SetDimension) *SegmentDemographics {
s.Make = v
return s
}
// SetModel sets the Model field's value.
func (s *SegmentDemographics) SetModel(v *SetDimension) *SegmentDemographics {
s.Model = v
return s
}
// SetPlatform sets the Platform field's value.
func (s *SegmentDemographics) SetPlatform(v *SetDimension) *SegmentDemographics {
s.Platform = v
return s
}
// Segment dimensions
// See also, path_to_url
type SegmentDimensions struct {
_ struct{} `type:"structure"`
// Custom segment attributes.
Attributes map[string]*AttributeDimension `type:"map"`
// The segment behaviors attributes.
Behavior *SegmentBehaviors `type:"structure"`
// The segment demographics attributes.
Demographic *SegmentDemographics `type:"structure"`
// The segment location attributes.
Location *SegmentLocation `type:"structure"`
// Custom segment user attributes.
UserAttributes map[string]*AttributeDimension `type:"map"`
}
// String returns the string representation
func (s SegmentDimensions) String() string {
return awsutil.Prettify(s)
}
// GoString returns the string representation
func (s SegmentDimensions) GoString() string {
return s.String()
}
// SetAttributes sets the Attributes field's value.
func (s *SegmentDimensions) SetAttributes(v map[string]*AttributeDimension) *SegmentDimensions {
s.Attributes = v
return s
}
// SetBehavior sets the Behavior field's value.
func (s *SegmentDimensions) SetBehavior(v *SegmentBehaviors) *SegmentDimensions {
s.Behavior = v
return s
}
// SetDemographic sets the Demographic field's value.
func (s *SegmentDimensions) SetDemographic(v *SegmentDemographics) *SegmentDimensions {
s.Demographic = v
return s
}
// SetLocation sets the Location field's value.
func (s *SegmentDimensions) SetLocation(v *SegmentLocation) *SegmentDimensions {
s.Location = v
return s
}
// SetUserAttributes sets the UserAttributes field's value.
func (s *SegmentDimensions) SetUserAttributes(v map[string]*AttributeDimension) *SegmentDimensions {
s.UserAttributes = v
return s
}
// Segment import definition.
// See also, path_to_url
type SegmentImportResource struct {
_ struct{} `type:"structure"`
ChannelCounts map[string]*int64 `type:"map"`
// A unique, custom ID assigned to the IAM role that restricts who can assume
// the role.
ExternalId *string `type:"string"`
// The format of the endpoint files that were imported to create this segment.Valid
// values: CSV, JSON
Format *string `type:"string" enum:"Format"`
// The Amazon Resource Name (ARN) of an IAM role that grants Amazon Pinpoint
// access to the endpoints in Amazon S3.
RoleArn *string `type:"string"`
// A URL that points to the Amazon S3 location from which the endpoints for
// this segment were imported.
S3Url *string `type:"string"`
// The number of endpoints that were successfully imported to create this segment.
Size *int64 `type:"integer"`
}
// String returns the string representation
func (s SegmentImportResource) String() string {
return awsutil.Prettify(s)
}
// GoString returns the string representation
func (s SegmentImportResource) GoString() string {
return s.String()
}
// SetChannelCounts sets the ChannelCounts field's value.
func (s *SegmentImportResource) SetChannelCounts(v map[string]*int64) *SegmentImportResource {
s.ChannelCounts = v
return s
}
// SetExternalId sets the ExternalId field's value.
func (s *SegmentImportResource) SetExternalId(v string) *SegmentImportResource {
s.ExternalId = &v
return s
}
// SetFormat sets the Format field's value.
func (s *SegmentImportResource) SetFormat(v string) *SegmentImportResource {
s.Format = &v
return s
}
// SetRoleArn sets the RoleArn field's value.
func (s *SegmentImportResource) SetRoleArn(v string) *SegmentImportResource {
s.RoleArn = &v
return s
}
// SetS3Url sets the S3Url field's value.
func (s *SegmentImportResource) SetS3Url(v string) *SegmentImportResource {
s.S3Url = &v
return s
}
// SetSize sets the Size field's value.
func (s *SegmentImportResource) SetSize(v int64) *SegmentImportResource {
s.Size = &v
return s
}
// Segment location dimensions
// See also, path_to_url
type SegmentLocation struct {
_ struct{} `type:"structure"`
// The country filter according to ISO 3166-1 Alpha-2 codes.
Country *SetDimension `type:"structure"`
}
// String returns the string representation
func (s SegmentLocation) String() string {
return awsutil.Prettify(s)
}
// GoString returns the string representation
func (s SegmentLocation) GoString() string {
return s.String()
}
// SetCountry sets the Country field's value.
func (s *SegmentLocation) SetCountry(v *SetDimension) *SegmentLocation {
s.Country = v
return s
}
// Segment definition.
// See also, path_to_url
type SegmentResponse struct {
_ struct{} `type:"structure"`
// The ID of the application to which the segment applies.
ApplicationId *string `type:"string"`
// The date the segment was created in ISO 8601 format.
CreationDate *string `type:"string"`
// The segment dimensions attributes.
Dimensions *SegmentDimensions `type:"structure"`
// The unique segment ID.
Id *string `type:"string"`
// The import job settings.
ImportDefinition *SegmentImportResource `type:"structure"`
// The date the segment was last updated in ISO 8601 format.
LastModifiedDate *string `type:"string"`
// The name of segment
Name *string `type:"string"`
// The segment type:DIMENSIONAL - A dynamic segment built from selection criteria
// based on endpoint data reported by your app. You create this type of segment
// by using the segment builder in the Amazon Pinpoint console or by making
// a POST request to the segments resource.IMPORT - A static segment built from
// an imported set of endpoint definitions. You create this type of segment
// by importing a segment in the Amazon Pinpoint console or by making a POST
// request to the jobs/import resource.
SegmentType *string `type:"string" enum:"SegmentType"`
// The segment version number.
Version *int64 `type:"integer"`
}
// String returns the string representation
func (s SegmentResponse) String() string {
return awsutil.Prettify(s)
}
// GoString returns the string representation
func (s SegmentResponse) GoString() string {
return s.String()
}
// SetApplicationId sets the ApplicationId field's value.
func (s *SegmentResponse) SetApplicationId(v string) *SegmentResponse {
s.ApplicationId = &v
return s
}
// SetCreationDate sets the CreationDate field's value.
func (s *SegmentResponse) SetCreationDate(v string) *SegmentResponse {
s.CreationDate = &v
return s
}
// SetDimensions sets the Dimensions field's value.
func (s *SegmentResponse) SetDimensions(v *SegmentDimensions) *SegmentResponse {
s.Dimensions = v
return s
}
// SetId sets the Id field's value.
func (s *SegmentResponse) SetId(v string) *SegmentResponse {
s.Id = &v
return s
}
// SetImportDefinition sets the ImportDefinition field's value.
func (s *SegmentResponse) SetImportDefinition(v *SegmentImportResource) *SegmentResponse {
s.ImportDefinition = v
return s
}
// SetLastModifiedDate sets the LastModifiedDate field's value.
func (s *SegmentResponse) SetLastModifiedDate(v string) *SegmentResponse {
s.LastModifiedDate = &v
return s
}
// SetName sets the Name field's value.
func (s *SegmentResponse) SetName(v string) *SegmentResponse {
s.Name = &v
return s
}
// SetSegmentType sets the SegmentType field's value.
func (s *SegmentResponse) SetSegmentType(v string) *SegmentResponse {
s.SegmentType = &v
return s
}
// SetVersion sets the Version field's value.
func (s *SegmentResponse) SetVersion(v int64) *SegmentResponse {
s.Version = &v
return s
}
// Segments in your account.
// See also, path_to_url
type SegmentsResponse struct {
_ struct{} `type:"structure"`
// The list of segments.
Item []*SegmentResponse `type:"list"`
// An identifier used to retrieve the next page of results. The token is null
// if no additional pages exist.
NextToken *string `type:"string"`
}
// String returns the string representation
func (s SegmentsResponse) String() string {
return awsutil.Prettify(s)
}
// GoString returns the string representation
func (s SegmentsResponse) GoString() string {
return s.String()
}
// SetItem sets the Item field's value.
func (s *SegmentsResponse) SetItem(v []*SegmentResponse) *SegmentsResponse {
s.Item = v
return s
}
// SetNextToken sets the NextToken field's value.
func (s *SegmentsResponse) SetNextToken(v string) *SegmentsResponse {
s.NextToken = &v
return s
}
// See also, path_to_url
type SendMessagesInput struct {
_ struct{} `type:"structure" payload:"MessageRequest"`
// ApplicationId is a required field
ApplicationId *string `location:"uri" locationName:"application-id" type:"string" required:"true"`
// Send message request.
//
// MessageRequest is a required field
MessageRequest *MessageRequest `type:"structure" required:"true"`
}
// String returns the string representation
func (s SendMessagesInput) String() string {
return awsutil.Prettify(s)
}
// GoString returns the string representation
func (s SendMessagesInput) GoString() string {
return s.String()
}
// Validate inspects the fields of the type to determine if they are valid.
func (s *SendMessagesInput) Validate() error {
invalidParams := request.ErrInvalidParams{Context: "SendMessagesInput"}
if s.ApplicationId == nil {
invalidParams.Add(request.NewErrParamRequired("ApplicationId"))
}
if s.MessageRequest == nil {
invalidParams.Add(request.NewErrParamRequired("MessageRequest"))
}
if invalidParams.Len() > 0 {
return invalidParams
}
return nil
}
// SetApplicationId sets the ApplicationId field's value.
func (s *SendMessagesInput) SetApplicationId(v string) *SendMessagesInput {
s.ApplicationId = &v
return s
}
// SetMessageRequest sets the MessageRequest field's value.
func (s *SendMessagesInput) SetMessageRequest(v *MessageRequest) *SendMessagesInput {
s.MessageRequest = v
return s
}
// See also, path_to_url
type SendMessagesOutput struct {
_ struct{} `type:"structure" payload:"MessageResponse"`
// Send message response.
//
// MessageResponse is a required field
MessageResponse *MessageResponse `type:"structure" required:"true"`
}
// String returns the string representation
func (s SendMessagesOutput) String() string {
return awsutil.Prettify(s)
}
// GoString returns the string representation
func (s SendMessagesOutput) GoString() string {
return s.String()
}
// SetMessageResponse sets the MessageResponse field's value.
func (s *SendMessagesOutput) SetMessageResponse(v *MessageResponse) *SendMessagesOutput {
s.MessageResponse = v
return s
}
// Send message request.
// See also, path_to_url
type SendUsersMessageRequest struct {
_ struct{} `type:"structure"`
Context map[string]*string `type:"map"`
// Message configuration.
MessageConfiguration *DirectMessageConfiguration `type:"structure"`
// A map of destination endpoints, with the EndpointId as the key Endpoint Message
// Configuration as the value.
Users map[string]*EndpointSendConfiguration `type:"map"`
}
// String returns the string representation
func (s SendUsersMessageRequest) String() string {
return awsutil.Prettify(s)
}
// GoString returns the string representation
func (s SendUsersMessageRequest) GoString() string {
return s.String()
}
// SetContext sets the Context field's value.
func (s *SendUsersMessageRequest) SetContext(v map[string]*string) *SendUsersMessageRequest {
s.Context = v
return s
}
// SetMessageConfiguration sets the MessageConfiguration field's value.
func (s *SendUsersMessageRequest) SetMessageConfiguration(v *DirectMessageConfiguration) *SendUsersMessageRequest {
s.MessageConfiguration = v
return s
}
// SetUsers sets the Users field's value.
func (s *SendUsersMessageRequest) SetUsers(v map[string]*EndpointSendConfiguration) *SendUsersMessageRequest {
s.Users = v
return s
}
// User send message response.
// See also, path_to_url
type SendUsersMessageResponse struct {
_ struct{} `type:"structure"`
// Application id of the message.
ApplicationId *string `type:"string"`
// Original request Id for which this message was delivered.
RequestId *string `type:"string"`
// A map containing of UserId to Map of EndpointId to Endpoint Message Result.
Result map[string]map[string]*EndpointMessageResult `type:"map"`
}
// String returns the string representation
func (s SendUsersMessageResponse) String() string {
return awsutil.Prettify(s)
}
// GoString returns the string representation
func (s SendUsersMessageResponse) GoString() string {
return s.String()
}
// SetApplicationId sets the ApplicationId field's value.
func (s *SendUsersMessageResponse) SetApplicationId(v string) *SendUsersMessageResponse {
s.ApplicationId = &v
return s
}
// SetRequestId sets the RequestId field's value.
func (s *SendUsersMessageResponse) SetRequestId(v string) *SendUsersMessageResponse {
s.RequestId = &v
return s
}
// SetResult sets the Result field's value.
func (s *SendUsersMessageResponse) SetResult(v map[string]map[string]*EndpointMessageResult) *SendUsersMessageResponse {
s.Result = v
return s
}
// See also, path_to_url
type SendUsersMessagesInput struct {
_ struct{} `type:"structure" payload:"SendUsersMessageRequest"`
// ApplicationId is a required field
ApplicationId *string `location:"uri" locationName:"application-id" type:"string" required:"true"`
// Send message request.
//
// SendUsersMessageRequest is a required field
SendUsersMessageRequest *SendUsersMessageRequest `type:"structure" required:"true"`
}
// String returns the string representation
func (s SendUsersMessagesInput) String() string {
return awsutil.Prettify(s)
}
// GoString returns the string representation
func (s SendUsersMessagesInput) GoString() string {
return s.String()
}
// Validate inspects the fields of the type to determine if they are valid.
func (s *SendUsersMessagesInput) Validate() error {
invalidParams := request.ErrInvalidParams{Context: "SendUsersMessagesInput"}
if s.ApplicationId == nil {
invalidParams.Add(request.NewErrParamRequired("ApplicationId"))
}
if s.SendUsersMessageRequest == nil {
invalidParams.Add(request.NewErrParamRequired("SendUsersMessageRequest"))
}
if invalidParams.Len() > 0 {
return invalidParams
}
return nil
}
// SetApplicationId sets the ApplicationId field's value.
func (s *SendUsersMessagesInput) SetApplicationId(v string) *SendUsersMessagesInput {
s.ApplicationId = &v
return s
}
// SetSendUsersMessageRequest sets the SendUsersMessageRequest field's value.
func (s *SendUsersMessagesInput) SetSendUsersMessageRequest(v *SendUsersMessageRequest) *SendUsersMessagesInput {
s.SendUsersMessageRequest = v
return s
}
// See also, path_to_url
type SendUsersMessagesOutput struct {
_ struct{} `type:"structure" payload:"SendUsersMessageResponse"`
// User send message response.
//
// SendUsersMessageResponse is a required field
SendUsersMessageResponse *SendUsersMessageResponse `type:"structure" required:"true"`
}
// String returns the string representation
func (s SendUsersMessagesOutput) String() string {
return awsutil.Prettify(s)
}
// GoString returns the string representation
func (s SendUsersMessagesOutput) GoString() string {
return s.String()
}
// SetSendUsersMessageResponse sets the SendUsersMessageResponse field's value.
func (s *SendUsersMessagesOutput) SetSendUsersMessageResponse(v *SendUsersMessageResponse) *SendUsersMessagesOutput {
s.SendUsersMessageResponse = v
return s
}
// Dimension specification of a segment.
// See also, path_to_url
type SetDimension struct {
_ struct{} `type:"structure"`
// The type of dimension:INCLUSIVE - Endpoints that match the criteria are included
// in the segment.EXCLUSIVE - Endpoints that match the criteria are excluded
// from the segment.
DimensionType *string `type:"string" enum:"DimensionType"`
Values []*string `type:"list"`
}
// String returns the string representation
func (s SetDimension) String() string {
return awsutil.Prettify(s)
}
// GoString returns the string representation
func (s SetDimension) GoString() string {
return s.String()
}
// SetDimensionType sets the DimensionType field's value.
func (s *SetDimension) SetDimensionType(v string) *SetDimension {
s.DimensionType = &v
return s
}
// SetValues sets the Values field's value.
func (s *SetDimension) SetValues(v []*string) *SetDimension {
s.Values = v
return s
}
// Treatment resource
// See also, path_to_url
type TreatmentResource struct {
_ struct{} `type:"structure"`
// The unique treatment ID.
Id *string `type:"string"`
// The message configuration settings.
MessageConfiguration *MessageConfiguration `type:"structure"`
// The campaign schedule.
Schedule *Schedule `type:"structure"`
// The allocated percentage of users for this treatment.
SizePercent *int64 `type:"integer"`
// The treatment status.
State *CampaignState `type:"structure"`
// A custom description for the treatment.
TreatmentDescription *string `type:"string"`
// The custom name of a variation of the campaign used for A/B testing.
TreatmentName *string `type:"string"`
}
// String returns the string representation
func (s TreatmentResource) String() string {
return awsutil.Prettify(s)
}
// GoString returns the string representation
func (s TreatmentResource) GoString() string {
return s.String()
}
// SetId sets the Id field's value.
func (s *TreatmentResource) SetId(v string) *TreatmentResource {
s.Id = &v
return s
}
// SetMessageConfiguration sets the MessageConfiguration field's value.
func (s *TreatmentResource) SetMessageConfiguration(v *MessageConfiguration) *TreatmentResource {
s.MessageConfiguration = v
return s
}
// SetSchedule sets the Schedule field's value.
func (s *TreatmentResource) SetSchedule(v *Schedule) *TreatmentResource {
s.Schedule = v
return s
}
// SetSizePercent sets the SizePercent field's value.
func (s *TreatmentResource) SetSizePercent(v int64) *TreatmentResource {
s.SizePercent = &v
return s
}
// SetState sets the State field's value.
func (s *TreatmentResource) SetState(v *CampaignState) *TreatmentResource {
s.State = v
return s
}
// SetTreatmentDescription sets the TreatmentDescription field's value.
func (s *TreatmentResource) SetTreatmentDescription(v string) *TreatmentResource {
s.TreatmentDescription = &v
return s
}
// SetTreatmentName sets the TreatmentName field's value.
func (s *TreatmentResource) SetTreatmentName(v string) *TreatmentResource {
s.TreatmentName = &v
return s
}
// See also, path_to_url
type UpdateAdmChannelInput struct {
_ struct{} `type:"structure" payload:"ADMChannelRequest"`
// Amazon Device Messaging channel definition.
//
// ADMChannelRequest is a required field
ADMChannelRequest *ADMChannelRequest `type:"structure" required:"true"`
// ApplicationId is a required field
ApplicationId *string `location:"uri" locationName:"application-id" type:"string" required:"true"`
}
// String returns the string representation
func (s UpdateAdmChannelInput) String() string {
return awsutil.Prettify(s)
}
// GoString returns the string representation
func (s UpdateAdmChannelInput) GoString() string {
return s.String()
}
// Validate inspects the fields of the type to determine if they are valid.
func (s *UpdateAdmChannelInput) Validate() error {
invalidParams := request.ErrInvalidParams{Context: "UpdateAdmChannelInput"}
if s.ADMChannelRequest == nil {
invalidParams.Add(request.NewErrParamRequired("ADMChannelRequest"))
}
if s.ApplicationId == nil {
invalidParams.Add(request.NewErrParamRequired("ApplicationId"))
}
if invalidParams.Len() > 0 {
return invalidParams
}
return nil
}
// SetADMChannelRequest sets the ADMChannelRequest field's value.
func (s *UpdateAdmChannelInput) SetADMChannelRequest(v *ADMChannelRequest) *UpdateAdmChannelInput {
s.ADMChannelRequest = v
return s
}
// SetApplicationId sets the ApplicationId field's value.
func (s *UpdateAdmChannelInput) SetApplicationId(v string) *UpdateAdmChannelInput {
s.ApplicationId = &v
return s
}
// See also, path_to_url
type UpdateAdmChannelOutput struct {
_ struct{} `type:"structure" payload:"ADMChannelResponse"`
// Amazon Device Messaging channel definition.
//
// ADMChannelResponse is a required field
ADMChannelResponse *ADMChannelResponse `type:"structure" required:"true"`
}
// String returns the string representation
func (s UpdateAdmChannelOutput) String() string {
return awsutil.Prettify(s)
}
// GoString returns the string representation
func (s UpdateAdmChannelOutput) GoString() string {
return s.String()
}
// SetADMChannelResponse sets the ADMChannelResponse field's value.
func (s *UpdateAdmChannelOutput) SetADMChannelResponse(v *ADMChannelResponse) *UpdateAdmChannelOutput {
s.ADMChannelResponse = v
return s
}
// See also, path_to_url
type UpdateApnsChannelInput struct {
_ struct{} `type:"structure" payload:"APNSChannelRequest"`
// Apple Push Notification Service channel definition.
//
// APNSChannelRequest is a required field
APNSChannelRequest *APNSChannelRequest `type:"structure" required:"true"`
// ApplicationId is a required field
ApplicationId *string `location:"uri" locationName:"application-id" type:"string" required:"true"`
}
// String returns the string representation
func (s UpdateApnsChannelInput) String() string {
return awsutil.Prettify(s)
}
// GoString returns the string representation
func (s UpdateApnsChannelInput) GoString() string {
return s.String()
}
// Validate inspects the fields of the type to determine if they are valid.
func (s *UpdateApnsChannelInput) Validate() error {
invalidParams := request.ErrInvalidParams{Context: "UpdateApnsChannelInput"}
if s.APNSChannelRequest == nil {
invalidParams.Add(request.NewErrParamRequired("APNSChannelRequest"))
}
if s.ApplicationId == nil {
invalidParams.Add(request.NewErrParamRequired("ApplicationId"))
}
if invalidParams.Len() > 0 {
return invalidParams
}
return nil
}
// SetAPNSChannelRequest sets the APNSChannelRequest field's value.
func (s *UpdateApnsChannelInput) SetAPNSChannelRequest(v *APNSChannelRequest) *UpdateApnsChannelInput {
s.APNSChannelRequest = v
return s
}
// SetApplicationId sets the ApplicationId field's value.
func (s *UpdateApnsChannelInput) SetApplicationId(v string) *UpdateApnsChannelInput {
s.ApplicationId = &v
return s
}
// See also, path_to_url
type UpdateApnsChannelOutput struct {
_ struct{} `type:"structure" payload:"APNSChannelResponse"`
// Apple Distribution Push Notification Service channel definition.
//
// APNSChannelResponse is a required field
APNSChannelResponse *APNSChannelResponse `type:"structure" required:"true"`
}
// String returns the string representation
func (s UpdateApnsChannelOutput) String() string {
return awsutil.Prettify(s)
}
// GoString returns the string representation
func (s UpdateApnsChannelOutput) GoString() string {
return s.String()
}
// SetAPNSChannelResponse sets the APNSChannelResponse field's value.
func (s *UpdateApnsChannelOutput) SetAPNSChannelResponse(v *APNSChannelResponse) *UpdateApnsChannelOutput {
s.APNSChannelResponse = v
return s
}
// See also, path_to_url
type UpdateApnsSandboxChannelInput struct {
_ struct{} `type:"structure" payload:"APNSSandboxChannelRequest"`
// Apple Development Push Notification Service channel definition.
//
// APNSSandboxChannelRequest is a required field
APNSSandboxChannelRequest *APNSSandboxChannelRequest `type:"structure" required:"true"`
// ApplicationId is a required field
ApplicationId *string `location:"uri" locationName:"application-id" type:"string" required:"true"`
}
// String returns the string representation
func (s UpdateApnsSandboxChannelInput) String() string {
return awsutil.Prettify(s)
}
// GoString returns the string representation
func (s UpdateApnsSandboxChannelInput) GoString() string {
return s.String()
}
// Validate inspects the fields of the type to determine if they are valid.
func (s *UpdateApnsSandboxChannelInput) Validate() error {
invalidParams := request.ErrInvalidParams{Context: "UpdateApnsSandboxChannelInput"}
if s.APNSSandboxChannelRequest == nil {
invalidParams.Add(request.NewErrParamRequired("APNSSandboxChannelRequest"))
}
if s.ApplicationId == nil {
invalidParams.Add(request.NewErrParamRequired("ApplicationId"))
}
if invalidParams.Len() > 0 {
return invalidParams
}
return nil
}
// SetAPNSSandboxChannelRequest sets the APNSSandboxChannelRequest field's value.
func (s *UpdateApnsSandboxChannelInput) SetAPNSSandboxChannelRequest(v *APNSSandboxChannelRequest) *UpdateApnsSandboxChannelInput {
s.APNSSandboxChannelRequest = v
return s
}
// SetApplicationId sets the ApplicationId field's value.
func (s *UpdateApnsSandboxChannelInput) SetApplicationId(v string) *UpdateApnsSandboxChannelInput {
s.ApplicationId = &v
return s
}
// See also, path_to_url
type UpdateApnsSandboxChannelOutput struct {
_ struct{} `type:"structure" payload:"APNSSandboxChannelResponse"`
// Apple Development Push Notification Service channel definition.
//
// APNSSandboxChannelResponse is a required field
APNSSandboxChannelResponse *APNSSandboxChannelResponse `type:"structure" required:"true"`
}
// String returns the string representation
func (s UpdateApnsSandboxChannelOutput) String() string {
return awsutil.Prettify(s)
}
// GoString returns the string representation
func (s UpdateApnsSandboxChannelOutput) GoString() string {
return s.String()
}
// SetAPNSSandboxChannelResponse sets the APNSSandboxChannelResponse field's value.
func (s *UpdateApnsSandboxChannelOutput) SetAPNSSandboxChannelResponse(v *APNSSandboxChannelResponse) *UpdateApnsSandboxChannelOutput {
s.APNSSandboxChannelResponse = v
return s
}
// See also, path_to_url
type UpdateApnsVoipChannelInput struct {
_ struct{} `type:"structure" payload:"APNSVoipChannelRequest"`
// Apple VOIP Push Notification Service channel definition.
//
// APNSVoipChannelRequest is a required field
APNSVoipChannelRequest *APNSVoipChannelRequest `type:"structure" required:"true"`
// ApplicationId is a required field
ApplicationId *string `location:"uri" locationName:"application-id" type:"string" required:"true"`
}
// String returns the string representation
func (s UpdateApnsVoipChannelInput) String() string {
return awsutil.Prettify(s)
}
// GoString returns the string representation
func (s UpdateApnsVoipChannelInput) GoString() string {
return s.String()
}
// Validate inspects the fields of the type to determine if they are valid.
func (s *UpdateApnsVoipChannelInput) Validate() error {
invalidParams := request.ErrInvalidParams{Context: "UpdateApnsVoipChannelInput"}
if s.APNSVoipChannelRequest == nil {
invalidParams.Add(request.NewErrParamRequired("APNSVoipChannelRequest"))
}
if s.ApplicationId == nil {
invalidParams.Add(request.NewErrParamRequired("ApplicationId"))
}
if invalidParams.Len() > 0 {
return invalidParams
}
return nil
}
// SetAPNSVoipChannelRequest sets the APNSVoipChannelRequest field's value.
func (s *UpdateApnsVoipChannelInput) SetAPNSVoipChannelRequest(v *APNSVoipChannelRequest) *UpdateApnsVoipChannelInput {
s.APNSVoipChannelRequest = v
return s
}
// SetApplicationId sets the ApplicationId field's value.
func (s *UpdateApnsVoipChannelInput) SetApplicationId(v string) *UpdateApnsVoipChannelInput {
s.ApplicationId = &v
return s
}
// See also, path_to_url
type UpdateApnsVoipChannelOutput struct {
_ struct{} `type:"structure" payload:"APNSVoipChannelResponse"`
// Apple VOIP Push Notification Service channel definition.
//
// APNSVoipChannelResponse is a required field
APNSVoipChannelResponse *APNSVoipChannelResponse `type:"structure" required:"true"`
}
// String returns the string representation
func (s UpdateApnsVoipChannelOutput) String() string {
return awsutil.Prettify(s)
}
// GoString returns the string representation
func (s UpdateApnsVoipChannelOutput) GoString() string {
return s.String()
}
// SetAPNSVoipChannelResponse sets the APNSVoipChannelResponse field's value.
func (s *UpdateApnsVoipChannelOutput) SetAPNSVoipChannelResponse(v *APNSVoipChannelResponse) *UpdateApnsVoipChannelOutput {
s.APNSVoipChannelResponse = v
return s
}
// See also, path_to_url
type UpdateApnsVoipSandboxChannelInput struct {
_ struct{} `type:"structure" payload:"APNSVoipSandboxChannelRequest"`
// Apple VOIP Developer Push Notification Service channel definition.
//
// APNSVoipSandboxChannelRequest is a required field
APNSVoipSandboxChannelRequest *APNSVoipSandboxChannelRequest `type:"structure" required:"true"`
// ApplicationId is a required field
ApplicationId *string `location:"uri" locationName:"application-id" type:"string" required:"true"`
}
// String returns the string representation
func (s UpdateApnsVoipSandboxChannelInput) String() string {
return awsutil.Prettify(s)
}
// GoString returns the string representation
func (s UpdateApnsVoipSandboxChannelInput) GoString() string {
return s.String()
}
// Validate inspects the fields of the type to determine if they are valid.
func (s *UpdateApnsVoipSandboxChannelInput) Validate() error {
invalidParams := request.ErrInvalidParams{Context: "UpdateApnsVoipSandboxChannelInput"}
if s.APNSVoipSandboxChannelRequest == nil {
invalidParams.Add(request.NewErrParamRequired("APNSVoipSandboxChannelRequest"))
}
if s.ApplicationId == nil {
invalidParams.Add(request.NewErrParamRequired("ApplicationId"))
}
if invalidParams.Len() > 0 {
return invalidParams
}
return nil
}
// SetAPNSVoipSandboxChannelRequest sets the APNSVoipSandboxChannelRequest field's value.
func (s *UpdateApnsVoipSandboxChannelInput) SetAPNSVoipSandboxChannelRequest(v *APNSVoipSandboxChannelRequest) *UpdateApnsVoipSandboxChannelInput {
s.APNSVoipSandboxChannelRequest = v
return s
}
// SetApplicationId sets the ApplicationId field's value.
func (s *UpdateApnsVoipSandboxChannelInput) SetApplicationId(v string) *UpdateApnsVoipSandboxChannelInput {
s.ApplicationId = &v
return s
}
// See also, path_to_url
type UpdateApnsVoipSandboxChannelOutput struct {
_ struct{} `type:"structure" payload:"APNSVoipSandboxChannelResponse"`
// Apple VOIP Developer Push Notification Service channel definition.
//
// APNSVoipSandboxChannelResponse is a required field
APNSVoipSandboxChannelResponse *APNSVoipSandboxChannelResponse `type:"structure" required:"true"`
}
// String returns the string representation
func (s UpdateApnsVoipSandboxChannelOutput) String() string {
return awsutil.Prettify(s)
}
// GoString returns the string representation
func (s UpdateApnsVoipSandboxChannelOutput) GoString() string {
return s.String()
}
// SetAPNSVoipSandboxChannelResponse sets the APNSVoipSandboxChannelResponse field's value.
func (s *UpdateApnsVoipSandboxChannelOutput) SetAPNSVoipSandboxChannelResponse(v *APNSVoipSandboxChannelResponse) *UpdateApnsVoipSandboxChannelOutput {
s.APNSVoipSandboxChannelResponse = v
return s
}
// See also, path_to_url
type UpdateApplicationSettingsInput struct {
_ struct{} `type:"structure" payload:"WriteApplicationSettingsRequest"`
// ApplicationId is a required field
ApplicationId *string `location:"uri" locationName:"application-id" type:"string" required:"true"`
// Creating application setting request
//
// WriteApplicationSettingsRequest is a required field
WriteApplicationSettingsRequest *WriteApplicationSettingsRequest `type:"structure" required:"true"`
}
// String returns the string representation
func (s UpdateApplicationSettingsInput) String() string {
return awsutil.Prettify(s)
}
// GoString returns the string representation
func (s UpdateApplicationSettingsInput) GoString() string {
return s.String()
}
// Validate inspects the fields of the type to determine if they are valid.
func (s *UpdateApplicationSettingsInput) Validate() error {
invalidParams := request.ErrInvalidParams{Context: "UpdateApplicationSettingsInput"}
if s.ApplicationId == nil {
invalidParams.Add(request.NewErrParamRequired("ApplicationId"))
}
if s.WriteApplicationSettingsRequest == nil {
invalidParams.Add(request.NewErrParamRequired("WriteApplicationSettingsRequest"))
}
if invalidParams.Len() > 0 {
return invalidParams
}
return nil
}
// SetApplicationId sets the ApplicationId field's value.
func (s *UpdateApplicationSettingsInput) SetApplicationId(v string) *UpdateApplicationSettingsInput {
s.ApplicationId = &v
return s
}
// SetWriteApplicationSettingsRequest sets the WriteApplicationSettingsRequest field's value.
func (s *UpdateApplicationSettingsInput) SetWriteApplicationSettingsRequest(v *WriteApplicationSettingsRequest) *UpdateApplicationSettingsInput {
s.WriteApplicationSettingsRequest = v
return s
}
// See also, path_to_url
type UpdateApplicationSettingsOutput struct {
_ struct{} `type:"structure" payload:"ApplicationSettingsResource"`
// Application settings.
//
// ApplicationSettingsResource is a required field
ApplicationSettingsResource *ApplicationSettingsResource `type:"structure" required:"true"`
}
// String returns the string representation
func (s UpdateApplicationSettingsOutput) String() string {
return awsutil.Prettify(s)
}
// GoString returns the string representation
func (s UpdateApplicationSettingsOutput) GoString() string {
return s.String()
}
// SetApplicationSettingsResource sets the ApplicationSettingsResource field's value.
func (s *UpdateApplicationSettingsOutput) SetApplicationSettingsResource(v *ApplicationSettingsResource) *UpdateApplicationSettingsOutput {
s.ApplicationSettingsResource = v
return s
}
// See also, path_to_url
type UpdateBaiduChannelInput struct {
_ struct{} `type:"structure" payload:"BaiduChannelRequest"`
// ApplicationId is a required field
ApplicationId *string `location:"uri" locationName:"application-id" type:"string" required:"true"`
// Baidu Cloud Push credentials
//
// BaiduChannelRequest is a required field
BaiduChannelRequest *BaiduChannelRequest `type:"structure" required:"true"`
}
// String returns the string representation
func (s UpdateBaiduChannelInput) String() string {
return awsutil.Prettify(s)
}
// GoString returns the string representation
func (s UpdateBaiduChannelInput) GoString() string {
return s.String()
}
// Validate inspects the fields of the type to determine if they are valid.
func (s *UpdateBaiduChannelInput) Validate() error {
invalidParams := request.ErrInvalidParams{Context: "UpdateBaiduChannelInput"}
if s.ApplicationId == nil {
invalidParams.Add(request.NewErrParamRequired("ApplicationId"))
}
if s.BaiduChannelRequest == nil {
invalidParams.Add(request.NewErrParamRequired("BaiduChannelRequest"))
}
if invalidParams.Len() > 0 {
return invalidParams
}
return nil
}
// SetApplicationId sets the ApplicationId field's value.
func (s *UpdateBaiduChannelInput) SetApplicationId(v string) *UpdateBaiduChannelInput {
s.ApplicationId = &v
return s
}
// SetBaiduChannelRequest sets the BaiduChannelRequest field's value.
func (s *UpdateBaiduChannelInput) SetBaiduChannelRequest(v *BaiduChannelRequest) *UpdateBaiduChannelInput {
s.BaiduChannelRequest = v
return s
}
// See also, path_to_url
type UpdateBaiduChannelOutput struct {
_ struct{} `type:"structure" payload:"BaiduChannelResponse"`
// Baidu Cloud Messaging channel definition
//
// BaiduChannelResponse is a required field
BaiduChannelResponse *BaiduChannelResponse `type:"structure" required:"true"`
}
// String returns the string representation
func (s UpdateBaiduChannelOutput) String() string {
return awsutil.Prettify(s)
}
// GoString returns the string representation
func (s UpdateBaiduChannelOutput) GoString() string {
return s.String()
}
// SetBaiduChannelResponse sets the BaiduChannelResponse field's value.
func (s *UpdateBaiduChannelOutput) SetBaiduChannelResponse(v *BaiduChannelResponse) *UpdateBaiduChannelOutput {
s.BaiduChannelResponse = v
return s
}
// See also, path_to_url
type UpdateCampaignInput struct {
_ struct{} `type:"structure" payload:"WriteCampaignRequest"`
// ApplicationId is a required field
ApplicationId *string `location:"uri" locationName:"application-id" type:"string" required:"true"`
// CampaignId is a required field
CampaignId *string `location:"uri" locationName:"campaign-id" type:"string" required:"true"`
// Used to create a campaign.
//
// WriteCampaignRequest is a required field
WriteCampaignRequest *WriteCampaignRequest `type:"structure" required:"true"`
}
// String returns the string representation
func (s UpdateCampaignInput) String() string {
return awsutil.Prettify(s)
}
// GoString returns the string representation
func (s UpdateCampaignInput) GoString() string {
return s.String()
}
// Validate inspects the fields of the type to determine if they are valid.
func (s *UpdateCampaignInput) Validate() error {
invalidParams := request.ErrInvalidParams{Context: "UpdateCampaignInput"}
if s.ApplicationId == nil {
invalidParams.Add(request.NewErrParamRequired("ApplicationId"))
}
if s.CampaignId == nil {
invalidParams.Add(request.NewErrParamRequired("CampaignId"))
}
if s.WriteCampaignRequest == nil {
invalidParams.Add(request.NewErrParamRequired("WriteCampaignRequest"))
}
if invalidParams.Len() > 0 {
return invalidParams
}
return nil
}
// SetApplicationId sets the ApplicationId field's value.
func (s *UpdateCampaignInput) SetApplicationId(v string) *UpdateCampaignInput {
s.ApplicationId = &v
return s
}
// SetCampaignId sets the CampaignId field's value.
func (s *UpdateCampaignInput) SetCampaignId(v string) *UpdateCampaignInput {
s.CampaignId = &v
return s
}
// SetWriteCampaignRequest sets the WriteCampaignRequest field's value.
func (s *UpdateCampaignInput) SetWriteCampaignRequest(v *WriteCampaignRequest) *UpdateCampaignInput {
s.WriteCampaignRequest = v
return s
}
// See also, path_to_url
type UpdateCampaignOutput struct {
_ struct{} `type:"structure" payload:"CampaignResponse"`
// Campaign definition
//
// CampaignResponse is a required field
CampaignResponse *CampaignResponse `type:"structure" required:"true"`
}
// String returns the string representation
func (s UpdateCampaignOutput) String() string {
return awsutil.Prettify(s)
}
// GoString returns the string representation
func (s UpdateCampaignOutput) GoString() string {
return s.String()
}
// SetCampaignResponse sets the CampaignResponse field's value.
func (s *UpdateCampaignOutput) SetCampaignResponse(v *CampaignResponse) *UpdateCampaignOutput {
s.CampaignResponse = v
return s
}
// See also, path_to_url
type UpdateEmailChannelInput struct {
_ struct{} `type:"structure" payload:"EmailChannelRequest"`
// ApplicationId is a required field
ApplicationId *string `location:"uri" locationName:"application-id" type:"string" required:"true"`
// Email Channel Request
//
// EmailChannelRequest is a required field
EmailChannelRequest *EmailChannelRequest `type:"structure" required:"true"`
}
// String returns the string representation
func (s UpdateEmailChannelInput) String() string {
return awsutil.Prettify(s)
}
// GoString returns the string representation
func (s UpdateEmailChannelInput) GoString() string {
return s.String()
}
// Validate inspects the fields of the type to determine if they are valid.
func (s *UpdateEmailChannelInput) Validate() error {
invalidParams := request.ErrInvalidParams{Context: "UpdateEmailChannelInput"}
if s.ApplicationId == nil {
invalidParams.Add(request.NewErrParamRequired("ApplicationId"))
}
if s.EmailChannelRequest == nil {
invalidParams.Add(request.NewErrParamRequired("EmailChannelRequest"))
}
if invalidParams.Len() > 0 {
return invalidParams
}
return nil
}
// SetApplicationId sets the ApplicationId field's value.
func (s *UpdateEmailChannelInput) SetApplicationId(v string) *UpdateEmailChannelInput {
s.ApplicationId = &v
return s
}
// SetEmailChannelRequest sets the EmailChannelRequest field's value.
func (s *UpdateEmailChannelInput) SetEmailChannelRequest(v *EmailChannelRequest) *UpdateEmailChannelInput {
s.EmailChannelRequest = v
return s
}
// See also, path_to_url
type UpdateEmailChannelOutput struct {
_ struct{} `type:"structure" payload:"EmailChannelResponse"`
// Email Channel Response.
//
// EmailChannelResponse is a required field
EmailChannelResponse *EmailChannelResponse `type:"structure" required:"true"`
}
// String returns the string representation
func (s UpdateEmailChannelOutput) String() string {
return awsutil.Prettify(s)
}
// GoString returns the string representation
func (s UpdateEmailChannelOutput) GoString() string {
return s.String()
}
// SetEmailChannelResponse sets the EmailChannelResponse field's value.
func (s *UpdateEmailChannelOutput) SetEmailChannelResponse(v *EmailChannelResponse) *UpdateEmailChannelOutput {
s.EmailChannelResponse = v
return s
}
// See also, path_to_url
type UpdateEndpointInput struct {
_ struct{} `type:"structure" payload:"EndpointRequest"`
// ApplicationId is a required field
ApplicationId *string `location:"uri" locationName:"application-id" type:"string" required:"true"`
// EndpointId is a required field
EndpointId *string `location:"uri" locationName:"endpoint-id" type:"string" required:"true"`
// Endpoint update request
//
// EndpointRequest is a required field
EndpointRequest *EndpointRequest `type:"structure" required:"true"`
}
// String returns the string representation
func (s UpdateEndpointInput) String() string {
return awsutil.Prettify(s)
}
// GoString returns the string representation
func (s UpdateEndpointInput) GoString() string {
return s.String()
}
// Validate inspects the fields of the type to determine if they are valid.
func (s *UpdateEndpointInput) Validate() error {
invalidParams := request.ErrInvalidParams{Context: "UpdateEndpointInput"}
if s.ApplicationId == nil {
invalidParams.Add(request.NewErrParamRequired("ApplicationId"))
}
if s.EndpointId == nil {
invalidParams.Add(request.NewErrParamRequired("EndpointId"))
}
if s.EndpointRequest == nil {
invalidParams.Add(request.NewErrParamRequired("EndpointRequest"))
}
if invalidParams.Len() > 0 {
return invalidParams
}
return nil
}
// SetApplicationId sets the ApplicationId field's value.
func (s *UpdateEndpointInput) SetApplicationId(v string) *UpdateEndpointInput {
s.ApplicationId = &v
return s
}
// SetEndpointId sets the EndpointId field's value.
func (s *UpdateEndpointInput) SetEndpointId(v string) *UpdateEndpointInput {
s.EndpointId = &v
return s
}
// SetEndpointRequest sets the EndpointRequest field's value.
func (s *UpdateEndpointInput) SetEndpointRequest(v *EndpointRequest) *UpdateEndpointInput {
s.EndpointRequest = v
return s
}
// See also, path_to_url
type UpdateEndpointOutput struct {
_ struct{} `type:"structure" payload:"MessageBody"`
// Simple message object.
//
// MessageBody is a required field
MessageBody *MessageBody `type:"structure" required:"true"`
}
// String returns the string representation
func (s UpdateEndpointOutput) String() string {
return awsutil.Prettify(s)
}
// GoString returns the string representation
func (s UpdateEndpointOutput) GoString() string {
return s.String()
}
// SetMessageBody sets the MessageBody field's value.
func (s *UpdateEndpointOutput) SetMessageBody(v *MessageBody) *UpdateEndpointOutput {
s.MessageBody = v
return s
}
// See also, path_to_url
type UpdateEndpointsBatchInput struct {
_ struct{} `type:"structure" payload:"EndpointBatchRequest"`
// ApplicationId is a required field
ApplicationId *string `location:"uri" locationName:"application-id" type:"string" required:"true"`
// Endpoint batch update request.
//
// EndpointBatchRequest is a required field
EndpointBatchRequest *EndpointBatchRequest `type:"structure" required:"true"`
}
// String returns the string representation
func (s UpdateEndpointsBatchInput) String() string {
return awsutil.Prettify(s)
}
// GoString returns the string representation
func (s UpdateEndpointsBatchInput) GoString() string {
return s.String()
}
// Validate inspects the fields of the type to determine if they are valid.
func (s *UpdateEndpointsBatchInput) Validate() error {
invalidParams := request.ErrInvalidParams{Context: "UpdateEndpointsBatchInput"}
if s.ApplicationId == nil {
invalidParams.Add(request.NewErrParamRequired("ApplicationId"))
}
if s.EndpointBatchRequest == nil {
invalidParams.Add(request.NewErrParamRequired("EndpointBatchRequest"))
}
if invalidParams.Len() > 0 {
return invalidParams
}
return nil
}
// SetApplicationId sets the ApplicationId field's value.
func (s *UpdateEndpointsBatchInput) SetApplicationId(v string) *UpdateEndpointsBatchInput {
s.ApplicationId = &v
return s
}
// SetEndpointBatchRequest sets the EndpointBatchRequest field's value.
func (s *UpdateEndpointsBatchInput) SetEndpointBatchRequest(v *EndpointBatchRequest) *UpdateEndpointsBatchInput {
s.EndpointBatchRequest = v
return s
}
// See also, path_to_url
type UpdateEndpointsBatchOutput struct {
_ struct{} `type:"structure" payload:"MessageBody"`
// Simple message object.
//
// MessageBody is a required field
MessageBody *MessageBody `type:"structure" required:"true"`
}
// String returns the string representation
func (s UpdateEndpointsBatchOutput) String() string {
return awsutil.Prettify(s)
}
// GoString returns the string representation
func (s UpdateEndpointsBatchOutput) GoString() string {
return s.String()
}
// SetMessageBody sets the MessageBody field's value.
func (s *UpdateEndpointsBatchOutput) SetMessageBody(v *MessageBody) *UpdateEndpointsBatchOutput {
s.MessageBody = v
return s
}
// See also, path_to_url
type UpdateGcmChannelInput struct {
_ struct{} `type:"structure" payload:"GCMChannelRequest"`
// ApplicationId is a required field
ApplicationId *string `location:"uri" locationName:"application-id" type:"string" required:"true"`
// Google Cloud Messaging credentials
//
// GCMChannelRequest is a required field
GCMChannelRequest *GCMChannelRequest `type:"structure" required:"true"`
}
// String returns the string representation
func (s UpdateGcmChannelInput) String() string {
return awsutil.Prettify(s)
}
// GoString returns the string representation
func (s UpdateGcmChannelInput) GoString() string {
return s.String()
}
// Validate inspects the fields of the type to determine if they are valid.
func (s *UpdateGcmChannelInput) Validate() error {
invalidParams := request.ErrInvalidParams{Context: "UpdateGcmChannelInput"}
if s.ApplicationId == nil {
invalidParams.Add(request.NewErrParamRequired("ApplicationId"))
}
if s.GCMChannelRequest == nil {
invalidParams.Add(request.NewErrParamRequired("GCMChannelRequest"))
}
if invalidParams.Len() > 0 {
return invalidParams
}
return nil
}
// SetApplicationId sets the ApplicationId field's value.
func (s *UpdateGcmChannelInput) SetApplicationId(v string) *UpdateGcmChannelInput {
s.ApplicationId = &v
return s
}
// SetGCMChannelRequest sets the GCMChannelRequest field's value.
func (s *UpdateGcmChannelInput) SetGCMChannelRequest(v *GCMChannelRequest) *UpdateGcmChannelInput {
s.GCMChannelRequest = v
return s
}
// See also, path_to_url
type UpdateGcmChannelOutput struct {
_ struct{} `type:"structure" payload:"GCMChannelResponse"`
// Google Cloud Messaging channel definition
//
// GCMChannelResponse is a required field
GCMChannelResponse *GCMChannelResponse `type:"structure" required:"true"`
}
// String returns the string representation
func (s UpdateGcmChannelOutput) String() string {
return awsutil.Prettify(s)
}
// GoString returns the string representation
func (s UpdateGcmChannelOutput) GoString() string {
return s.String()
}
// SetGCMChannelResponse sets the GCMChannelResponse field's value.
func (s *UpdateGcmChannelOutput) SetGCMChannelResponse(v *GCMChannelResponse) *UpdateGcmChannelOutput {
s.GCMChannelResponse = v
return s
}
// See also, path_to_url
type UpdateSegmentInput struct {
_ struct{} `type:"structure" payload:"WriteSegmentRequest"`
// ApplicationId is a required field
ApplicationId *string `location:"uri" locationName:"application-id" type:"string" required:"true"`
// SegmentId is a required field
SegmentId *string `location:"uri" locationName:"segment-id" type:"string" required:"true"`
// Segment definition.
//
// WriteSegmentRequest is a required field
WriteSegmentRequest *WriteSegmentRequest `type:"structure" required:"true"`
}
// String returns the string representation
func (s UpdateSegmentInput) String() string {
return awsutil.Prettify(s)
}
// GoString returns the string representation
func (s UpdateSegmentInput) GoString() string {
return s.String()
}
// Validate inspects the fields of the type to determine if they are valid.
func (s *UpdateSegmentInput) Validate() error {
invalidParams := request.ErrInvalidParams{Context: "UpdateSegmentInput"}
if s.ApplicationId == nil {
invalidParams.Add(request.NewErrParamRequired("ApplicationId"))
}
if s.SegmentId == nil {
invalidParams.Add(request.NewErrParamRequired("SegmentId"))
}
if s.WriteSegmentRequest == nil {
invalidParams.Add(request.NewErrParamRequired("WriteSegmentRequest"))
}
if invalidParams.Len() > 0 {
return invalidParams
}
return nil
}
// SetApplicationId sets the ApplicationId field's value.
func (s *UpdateSegmentInput) SetApplicationId(v string) *UpdateSegmentInput {
s.ApplicationId = &v
return s
}
// SetSegmentId sets the SegmentId field's value.
func (s *UpdateSegmentInput) SetSegmentId(v string) *UpdateSegmentInput {
s.SegmentId = &v
return s
}
// SetWriteSegmentRequest sets the WriteSegmentRequest field's value.
func (s *UpdateSegmentInput) SetWriteSegmentRequest(v *WriteSegmentRequest) *UpdateSegmentInput {
s.WriteSegmentRequest = v
return s
}
// See also, path_to_url
type UpdateSegmentOutput struct {
_ struct{} `type:"structure" payload:"SegmentResponse"`
// Segment definition.
//
// SegmentResponse is a required field
SegmentResponse *SegmentResponse `type:"structure" required:"true"`
}
// String returns the string representation
func (s UpdateSegmentOutput) String() string {
return awsutil.Prettify(s)
}
// GoString returns the string representation
func (s UpdateSegmentOutput) GoString() string {
return s.String()
}
// SetSegmentResponse sets the SegmentResponse field's value.
func (s *UpdateSegmentOutput) SetSegmentResponse(v *SegmentResponse) *UpdateSegmentOutput {
s.SegmentResponse = v
return s
}
// See also, path_to_url
type UpdateSmsChannelInput struct {
_ struct{} `type:"structure" payload:"SMSChannelRequest"`
// ApplicationId is a required field
ApplicationId *string `location:"uri" locationName:"application-id" type:"string" required:"true"`
// SMS Channel Request
//
// SMSChannelRequest is a required field
SMSChannelRequest *SMSChannelRequest `type:"structure" required:"true"`
}
// String returns the string representation
func (s UpdateSmsChannelInput) String() string {
return awsutil.Prettify(s)
}
// GoString returns the string representation
func (s UpdateSmsChannelInput) GoString() string {
return s.String()
}
// Validate inspects the fields of the type to determine if they are valid.
func (s *UpdateSmsChannelInput) Validate() error {
invalidParams := request.ErrInvalidParams{Context: "UpdateSmsChannelInput"}
if s.ApplicationId == nil {
invalidParams.Add(request.NewErrParamRequired("ApplicationId"))
}
if s.SMSChannelRequest == nil {
invalidParams.Add(request.NewErrParamRequired("SMSChannelRequest"))
}
if invalidParams.Len() > 0 {
return invalidParams
}
return nil
}
// SetApplicationId sets the ApplicationId field's value.
func (s *UpdateSmsChannelInput) SetApplicationId(v string) *UpdateSmsChannelInput {
s.ApplicationId = &v
return s
}
// SetSMSChannelRequest sets the SMSChannelRequest field's value.
func (s *UpdateSmsChannelInput) SetSMSChannelRequest(v *SMSChannelRequest) *UpdateSmsChannelInput {
s.SMSChannelRequest = v
return s
}
// See also, path_to_url
type UpdateSmsChannelOutput struct {
_ struct{} `type:"structure" payload:"SMSChannelResponse"`
// SMS Channel Response.
//
// SMSChannelResponse is a required field
SMSChannelResponse *SMSChannelResponse `type:"structure" required:"true"`
}
// String returns the string representation
func (s UpdateSmsChannelOutput) String() string {
return awsutil.Prettify(s)
}
// GoString returns the string representation
func (s UpdateSmsChannelOutput) GoString() string {
return s.String()
}
// SetSMSChannelResponse sets the SMSChannelResponse field's value.
func (s *UpdateSmsChannelOutput) SetSMSChannelResponse(v *SMSChannelResponse) *UpdateSmsChannelOutput {
s.SMSChannelResponse = v
return s
}
// Creating application setting request
// See also, path_to_url
type WriteApplicationSettingsRequest struct {
_ struct{} `type:"structure"`
// The default campaign limits for the app. These limits apply to each campaign
// for the app, unless the campaign overrides the default with limits of its
// own.
Limits *CampaignLimits `type:"structure"`
// The default quiet time for the app. Each campaign for this app sends no messages
// during this time unless the campaign overrides the default with a quiet time
// of its own.
QuietTime *QuietTime `type:"structure"`
}
// String returns the string representation
func (s WriteApplicationSettingsRequest) String() string {
return awsutil.Prettify(s)
}
// GoString returns the string representation
func (s WriteApplicationSettingsRequest) GoString() string {
return s.String()
}
// SetLimits sets the Limits field's value.
func (s *WriteApplicationSettingsRequest) SetLimits(v *CampaignLimits) *WriteApplicationSettingsRequest {
s.Limits = v
return s
}
// SetQuietTime sets the QuietTime field's value.
func (s *WriteApplicationSettingsRequest) SetQuietTime(v *QuietTime) *WriteApplicationSettingsRequest {
s.QuietTime = v
return s
}
// Used to create a campaign.
// See also, path_to_url
type WriteCampaignRequest struct {
_ struct{} `type:"structure"`
// Treatments that are defined in addition to the default treatment.
AdditionalTreatments []*WriteTreatmentResource `type:"list"`
// A description of the campaign.
Description *string `type:"string"`
// The allocated percentage of end users who will not receive messages from
// this campaign.
HoldoutPercent *int64 `type:"integer"`
// Indicates whether the campaign is paused. A paused campaign does not send
// messages unless you resume it by setting IsPaused to false.
IsPaused *bool `type:"boolean"`
// The campaign limits settings.
Limits *CampaignLimits `type:"structure"`
// The message configuration settings.
MessageConfiguration *MessageConfiguration `type:"structure"`
// The custom name of the campaign.
Name *string `type:"string"`
// The campaign schedule.
Schedule *Schedule `type:"structure"`
// The ID of the segment to which the campaign sends messages.
SegmentId *string `type:"string"`
// The version of the segment to which the campaign sends messages.
SegmentVersion *int64 `type:"integer"`
// A custom description for the treatment.
TreatmentDescription *string `type:"string"`
// The custom name of a variation of the campaign used for A/B testing.
TreatmentName *string `type:"string"`
}
// String returns the string representation
func (s WriteCampaignRequest) String() string {
return awsutil.Prettify(s)
}
// GoString returns the string representation
func (s WriteCampaignRequest) GoString() string {
return s.String()
}
// SetAdditionalTreatments sets the AdditionalTreatments field's value.
func (s *WriteCampaignRequest) SetAdditionalTreatments(v []*WriteTreatmentResource) *WriteCampaignRequest {
s.AdditionalTreatments = v
return s
}
// SetDescription sets the Description field's value.
func (s *WriteCampaignRequest) SetDescription(v string) *WriteCampaignRequest {
s.Description = &v
return s
}
// SetHoldoutPercent sets the HoldoutPercent field's value.
func (s *WriteCampaignRequest) SetHoldoutPercent(v int64) *WriteCampaignRequest {
s.HoldoutPercent = &v
return s
}
// SetIsPaused sets the IsPaused field's value.
func (s *WriteCampaignRequest) SetIsPaused(v bool) *WriteCampaignRequest {
s.IsPaused = &v
return s
}
// SetLimits sets the Limits field's value.
func (s *WriteCampaignRequest) SetLimits(v *CampaignLimits) *WriteCampaignRequest {
s.Limits = v
return s
}
// SetMessageConfiguration sets the MessageConfiguration field's value.
func (s *WriteCampaignRequest) SetMessageConfiguration(v *MessageConfiguration) *WriteCampaignRequest {
s.MessageConfiguration = v
return s
}
// SetName sets the Name field's value.
func (s *WriteCampaignRequest) SetName(v string) *WriteCampaignRequest {
s.Name = &v
return s
}
// SetSchedule sets the Schedule field's value.
func (s *WriteCampaignRequest) SetSchedule(v *Schedule) *WriteCampaignRequest {
s.Schedule = v
return s
}
// SetSegmentId sets the SegmentId field's value.
func (s *WriteCampaignRequest) SetSegmentId(v string) *WriteCampaignRequest {
s.SegmentId = &v
return s
}
// SetSegmentVersion sets the SegmentVersion field's value.
func (s *WriteCampaignRequest) SetSegmentVersion(v int64) *WriteCampaignRequest {
s.SegmentVersion = &v
return s
}
// SetTreatmentDescription sets the TreatmentDescription field's value.
func (s *WriteCampaignRequest) SetTreatmentDescription(v string) *WriteCampaignRequest {
s.TreatmentDescription = &v
return s
}
// SetTreatmentName sets the TreatmentName field's value.
func (s *WriteCampaignRequest) SetTreatmentName(v string) *WriteCampaignRequest {
s.TreatmentName = &v
return s
}
// Request to save an EventStream.
// See also, path_to_url
type WriteEventStream struct {
_ struct{} `type:"structure"`
// The Amazon Resource Name (ARN) of the Amazon Kinesis stream or Firehose delivery
// stream to which you want to publish events. Firehose ARN: arn:aws:firehose:REGION:ACCOUNT_ID:deliverystream/STREAM_NAME
// Kinesis ARN: arn:aws:kinesis:REGION:ACCOUNT_ID:stream/STREAM_NAME
DestinationStreamArn *string `type:"string"`
// The IAM role that authorizes Amazon Pinpoint to publish events to the stream
// in your account.
RoleArn *string `type:"string"`
}
// String returns the string representation
func (s WriteEventStream) String() string {
return awsutil.Prettify(s)
}
// GoString returns the string representation
func (s WriteEventStream) GoString() string {
return s.String()
}
// SetDestinationStreamArn sets the DestinationStreamArn field's value.
func (s *WriteEventStream) SetDestinationStreamArn(v string) *WriteEventStream {
s.DestinationStreamArn = &v
return s
}
// SetRoleArn sets the RoleArn field's value.
func (s *WriteEventStream) SetRoleArn(v string) *WriteEventStream {
s.RoleArn = &v
return s
}
// Segment definition.
// See also, path_to_url
type WriteSegmentRequest struct {
_ struct{} `type:"structure"`
// The segment dimensions attributes.
Dimensions *SegmentDimensions `type:"structure"`
// The name of segment
Name *string `type:"string"`
}
// String returns the string representation
func (s WriteSegmentRequest) String() string {
return awsutil.Prettify(s)
}
// GoString returns the string representation
func (s WriteSegmentRequest) GoString() string {
return s.String()
}
// SetDimensions sets the Dimensions field's value.
func (s *WriteSegmentRequest) SetDimensions(v *SegmentDimensions) *WriteSegmentRequest {
s.Dimensions = v
return s
}
// SetName sets the Name field's value.
func (s *WriteSegmentRequest) SetName(v string) *WriteSegmentRequest {
s.Name = &v
return s
}
// Used to create a campaign treatment.
// See also, path_to_url
type WriteTreatmentResource struct {
_ struct{} `type:"structure"`
// The message configuration settings.
MessageConfiguration *MessageConfiguration `type:"structure"`
// The campaign schedule.
Schedule *Schedule `type:"structure"`
// The allocated percentage of users for this treatment.
SizePercent *int64 `type:"integer"`
// A custom description for the treatment.
TreatmentDescription *string `type:"string"`
// The custom name of a variation of the campaign used for A/B testing.
TreatmentName *string `type:"string"`
}
// String returns the string representation
func (s WriteTreatmentResource) String() string {
return awsutil.Prettify(s)
}
// GoString returns the string representation
func (s WriteTreatmentResource) GoString() string {
return s.String()
}
// SetMessageConfiguration sets the MessageConfiguration field's value.
func (s *WriteTreatmentResource) SetMessageConfiguration(v *MessageConfiguration) *WriteTreatmentResource {
s.MessageConfiguration = v
return s
}
// SetSchedule sets the Schedule field's value.
func (s *WriteTreatmentResource) SetSchedule(v *Schedule) *WriteTreatmentResource {
s.Schedule = v
return s
}
// SetSizePercent sets the SizePercent field's value.
func (s *WriteTreatmentResource) SetSizePercent(v int64) *WriteTreatmentResource {
s.SizePercent = &v
return s
}
// SetTreatmentDescription sets the TreatmentDescription field's value.
func (s *WriteTreatmentResource) SetTreatmentDescription(v string) *WriteTreatmentResource {
s.TreatmentDescription = &v
return s
}
// SetTreatmentName sets the TreatmentName field's value.
func (s *WriteTreatmentResource) SetTreatmentName(v string) *WriteTreatmentResource {
s.TreatmentName = &v
return s
}
const (
// ActionOpenApp is a Action enum value
ActionOpenApp = "OPEN_APP"
// ActionDeepLink is a Action enum value
ActionDeepLink = "DEEP_LINK"
// ActionUrl is a Action enum value
ActionUrl = "URL"
)
const (
// AttributeTypeInclusive is a AttributeType enum value
AttributeTypeInclusive = "INCLUSIVE"
// AttributeTypeExclusive is a AttributeType enum value
AttributeTypeExclusive = "EXCLUSIVE"
)
const (
// CampaignStatusScheduled is a CampaignStatus enum value
CampaignStatusScheduled = "SCHEDULED"
// CampaignStatusExecuting is a CampaignStatus enum value
CampaignStatusExecuting = "EXECUTING"
// CampaignStatusPendingNextRun is a CampaignStatus enum value
CampaignStatusPendingNextRun = "PENDING_NEXT_RUN"
// CampaignStatusCompleted is a CampaignStatus enum value
CampaignStatusCompleted = "COMPLETED"
// CampaignStatusPaused is a CampaignStatus enum value
CampaignStatusPaused = "PAUSED"
)
const (
// ChannelTypeGcm is a ChannelType enum value
ChannelTypeGcm = "GCM"
// ChannelTypeApns is a ChannelType enum value
ChannelTypeApns = "APNS"
// ChannelTypeApnsSandbox is a ChannelType enum value
ChannelTypeApnsSandbox = "APNS_SANDBOX"
// ChannelTypeApnsVoip is a ChannelType enum value
ChannelTypeApnsVoip = "APNS_VOIP"
// ChannelTypeApnsVoipSandbox is a ChannelType enum value
ChannelTypeApnsVoipSandbox = "APNS_VOIP_SANDBOX"
// ChannelTypeAdm is a ChannelType enum value
ChannelTypeAdm = "ADM"
// ChannelTypeSms is a ChannelType enum value
ChannelTypeSms = "SMS"
// ChannelTypeEmail is a ChannelType enum value
ChannelTypeEmail = "EMAIL"
// ChannelTypeBaidu is a ChannelType enum value
ChannelTypeBaidu = "BAIDU"
)
const (
// DeliveryStatusSuccessful is a DeliveryStatus enum value
DeliveryStatusSuccessful = "SUCCESSFUL"
// DeliveryStatusThrottled is a DeliveryStatus enum value
DeliveryStatusThrottled = "THROTTLED"
// DeliveryStatusTemporaryFailure is a DeliveryStatus enum value
DeliveryStatusTemporaryFailure = "TEMPORARY_FAILURE"
// DeliveryStatusPermanentFailure is a DeliveryStatus enum value
DeliveryStatusPermanentFailure = "PERMANENT_FAILURE"
// DeliveryStatusUnknownFailure is a DeliveryStatus enum value
DeliveryStatusUnknownFailure = "UNKNOWN_FAILURE"
// DeliveryStatusOptOut is a DeliveryStatus enum value
DeliveryStatusOptOut = "OPT_OUT"
// DeliveryStatusDuplicate is a DeliveryStatus enum value
DeliveryStatusDuplicate = "DUPLICATE"
)
const (
// DimensionTypeInclusive is a DimensionType enum value
DimensionTypeInclusive = "INCLUSIVE"
// DimensionTypeExclusive is a DimensionType enum value
DimensionTypeExclusive = "EXCLUSIVE"
)
const (
// DurationHr24 is a Duration enum value
DurationHr24 = "HR_24"
// DurationDay7 is a Duration enum value
DurationDay7 = "DAY_7"
// DurationDay14 is a Duration enum value
DurationDay14 = "DAY_14"
// DurationDay30 is a Duration enum value
DurationDay30 = "DAY_30"
)
const (
// FormatCsv is a Format enum value
FormatCsv = "CSV"
// FormatJson is a Format enum value
FormatJson = "JSON"
)
const (
// FrequencyOnce is a Frequency enum value
FrequencyOnce = "ONCE"
// FrequencyHourly is a Frequency enum value
FrequencyHourly = "HOURLY"
// FrequencyDaily is a Frequency enum value
FrequencyDaily = "DAILY"
// FrequencyWeekly is a Frequency enum value
FrequencyWeekly = "WEEKLY"
// FrequencyMonthly is a Frequency enum value
FrequencyMonthly = "MONTHLY"
)
const (
// JobStatusCreated is a JobStatus enum value
JobStatusCreated = "CREATED"
// JobStatusInitializing is a JobStatus enum value
JobStatusInitializing = "INITIALIZING"
// JobStatusProcessing is a JobStatus enum value
JobStatusProcessing = "PROCESSING"
// JobStatusCompleting is a JobStatus enum value
JobStatusCompleting = "COMPLETING"
// JobStatusCompleted is a JobStatus enum value
JobStatusCompleted = "COMPLETED"
// JobStatusFailing is a JobStatus enum value
JobStatusFailing = "FAILING"
// JobStatusFailed is a JobStatus enum value
JobStatusFailed = "FAILED"
)
const (
// MessageTypeTransactional is a MessageType enum value
MessageTypeTransactional = "TRANSACTIONAL"
// MessageTypePromotional is a MessageType enum value
MessageTypePromotional = "PROMOTIONAL"
)
const (
// RecencyTypeActive is a RecencyType enum value
RecencyTypeActive = "ACTIVE"
// RecencyTypeInactive is a RecencyType enum value
RecencyTypeInactive = "INACTIVE"
)
const (
// SegmentTypeDimensional is a SegmentType enum value
SegmentTypeDimensional = "DIMENSIONAL"
// SegmentTypeImport is a SegmentType enum value
SegmentTypeImport = "IMPORT"
)
```
|
Showtime Greats (previously Encore) was an Australian cable and satellite television channel which was available on the Foxtel, Austar and Optus Television subscription television platforms.
Showtime Greats broadcast films dating from the 1960s to the early 2000s. These films were older films which had previously premiered on sister channel Showtime premiere. Prior to March 2004, the channel was known as Encore and aired much older films.
The channel was closed on 15 November 2009 and was replaced by three themed channels.
See also
Showtime movie channels
Showcase
References
Movie channels in Australia
Defunct television channels in Australia
Television channels and stations established in 1995
Television channels and stations disestablished in 2009
|
Hjärnkontoret ("Think Tank") is a Swedish children's science programme broadcast by SVT since 10 January 1995 (then hosted by Fredrik Berling). Today, it's hosted by Benjamin "Beppe" Singer and its earlier hosts include DJ Webster, Frida Nilsson, Henry Chu, Victoria Dyring and Fredrik Berling.
Awards
2002 – Kunskapspriset
2006 – Kristallen
2011 – Årets folkbildare
References/sources
External links
Hjärnkontoret's website (http://svt.se/hjarnkontoret)
Hjärnkontoret on Swedish Media Database
Swedish children's television series
Sveriges Television original programming
1990s Swedish television series
2000s Swedish television series
2010s Swedish television series
1995 Swedish television series debuts
|
```php
<?php
/*
* ABOUT THIS PHP SAMPLE => This sample is part of the SDK for PHP Developer Guide topic at
* path_to_url
*
*/
// snippet-start:[ses.php.add_domain.complete]
// snippet-start:[ses.php.add_domain.import]
require 'vendor/autoload.php';
use Aws\Exception\AwsException;
// snippet-end:[ses.php.add_domain.import]
//Create a SESClient
// snippet-start:[ses.php.add_domain.main]
$SesClient = new Aws\Ses\SesClient([
'profile' => 'default',
'version' => '2010-12-01',
'region' => 'us-east-2'
]);
$domain = 'domain.name';
try {
$result = $SesClient->verifyDomainIdentity([
'Domain' => $domain,
]);
var_dump($result);
} catch (AwsException $e) {
// output error message if fails
echo $e->getMessage();
echo "\n";
}
// snippet-end:[ses.php.add_domain.main]
// snippet-end:[ses.php.add_domain.complete]
```
|
McKay House may refer to:
McKay House (Owenton, Kentucky), listed on the NRHP in Owen County, Kentucky
Ellas-McKay House, Clarendon, Arkansas, listed on the NRHP in Monroe County, Arkansas
McKay-Thornberry House, Owensboro, Kentucky, listed on the NRHP in Daviess County, Kentucky
Donald McKay House, Boston, Massachusetts, listed on the NRHP in Boston, Massachusetts
Strawberry Patch-McKay House, Madison, Mississippi, listed on the NRHP in Madison County, Mississippi
Claude McKay Residence, New York, New York, listed on the NRHP in New York City
John A. McKay House and Manufacturing Company, Dunn, North Carolina, listed on the NRHP in Harnett County, North Carolina
Summer Villa and the McKay-Salmon House, Lillington, North Carolina, listed on the NRHP in Harnett County, North Carolina
Moses McKay House, Waynesville, Ohio, listed on the NRHP in Warren County, Ohio
|
Scandalpedia was a political website launched September 9, 2008, by the Liberal Party of Canada in response to the 2008 Canadian federal election in particular as a counter to an attack website launched by the Conservative Party of Canada. It contains "Wikipedia style" articles on controversial actions and ethical concerns raised since the Conservative Party of Canada has taken power in 2006. It features articles, quotes, and biographies of Conservative party members involved in the various controversies.
The site uses the MediaWiki monobook theme but is not editable by the public and does not appear to be based on MediaWiki software.
References
Scandalpdia
|
The Asian Film Awards are presented annually by the Asian Film Awards Academy to recognise the excellence of the film professionals in the film industries of Asian cinema.
History
On January 29, 2007, Wilfred Wong, the Chairman of Hong Kong International Film Festival Society, announced the launch of the Asian Film Awards (AFA). The 1st Asian Film Awards occurred on March 20, 2007, on the opening night of the 31st Hong Kong International Film Festival (HKIFF) in Hong Kong Convention and Exhibition Centre. It honoured the best film achievements of the Asian cinema in the year 2006. It was attended by about 4000 guests from around the world.
The AFA Presentation Ceremony takes place as part of the Entertainment Expo Hong Kong Opening Gala. Eminent filmmakers and superstars from around the world are invited to bestow awards upon the winner(s) of each category, making the ceremony a dazzling extravaganza as well as an influential cultural event.
Throughout its history and since its inauguration in 2007, Chinese-language films and professionals from China, Taiwan, and Hong Kong have dominated the awards.
The trophy
On February 13, 2007, the Hong Kong Trade Development Council hosted a celebration of Park Chan-wook's I'm a Cyborg, But That's OK announcement of being the opening film for the 31st Hong Kong International Film Festival at a reception in Berlin. At the same event the AFA trophy, designed by award-winning production designer, William Chang, was also unveiled.
According to William Chang, his inspiration behind the artwork was his admiration to a combination of architectural drawings and his own collection of antique statues. Measuring 36 cm (14 in), the trophy symbolises the joy and the accomplishment of all the award winners.
The current trophy is gold as a whole but had changed significantly before. The first trophies that were handed in 2007 has its trophy in black with a white base. In the 2nd AFA, the current gold colour was used as whole but in 2009 for its 3rd AFA instead of a gold base, it has a black base. Then in 2010, the whole gold trophy had returned and now used nowadays.
Eligibility, nominations and voting
To be eligible, films must be feature length (more than 60 minutes); be in 35mm or 70mm film format or digital format suitable for exhibition in cinemas; and be fiction films from Asia. This encompasses all the cinemas of Asia: East Asia, Central Asia, South Asia, Southeast Asia and West Asia. Additionally, the films must have English subtitles.
The films must have been released between January 1 and December 31 of the year preceding the awards ceremony, and have been exhibited through a domestic theatrical release and distribution to at least one other country; been premiered at an international film festival; or received national film awards.
The Hong Kong International Film Festival Society compile the preliminary nomination list with the participation of the two parties who can submit films for the consideration to be included in the nomination list which are:
the Asian Film Awards Official Submission Organisations are composed of recognised film organizations from different Asian territories. Each Official Submission Organisation can submit up to three films to represent their territory.
the Asian Film Awards Jury is composed of film professionals from around the world. Each Jury Member can recommend up to two additional nominations in each Category.
After the Society finalised the nomination list, the Jury and the Voting Members (composed of previous winners from past AFA) would then vote in an Online Balloting System where it would be counted, tallied and kept confidential until the day of the AFA by a reputable firm of certified public accountants.
Award categories
Best Film
Best Director
Best Actor
Best Actress
Best Supporting Actor: since 2008
Best Supporting Actress: since 2008
Best New Director: since 2018
Best Newcomer: since 2009
Best Screenwriter
Best Cinematographer
Best Production Designer
Best Composer
Best Editor
Best Visual Effects
Best Costume Designer : since 2010
Special Awards
These special awards are not always presented on a consistent annual basis. The Society chooses the special awards to be given for a certain year.
Asian Film Award for Excellence in Scholarship in Asian Cinema
Asian Film Award for Outstanding Contribution to Asian Cinema
Nielsen Box Office Star of Asia Award
Lifetime Achievement Award: since 2008
The Edward Yang New Talent Award: since 2008
The Asian Film Award for Top-Grossing Film Director: since 2009
The Asian Film Award for Top-Grossing Asian Film: since 2011
Award for the Promotion of Asian Cinema: since 2011
Excellence in Asian Cinema Award: since 2013
The Next Generation Award: since 2016
People's Choice Awards
People's Choice for the Best Asian Film: 2009 (defunct)
People's Choice for Best Actor : since 2010
People's Choice for Best Actress : since 2010
The asterisk indicates the awards that were renamed for a certain Asian Film Awards Presentation Ceremony. Their first and original names are used in this list.
Major award winners
Presentation Ceremonies
2021: The 15th edition of the awards presentation hosted by actress Kim Gyu-ri and broadcaster Lee Seung-guk was held on October 8, 2021 in Busan at Haeundae. 36 films from 8 Asian regions competed for 16 awards. Director Kiyoshi Kurosawa's Wife of a Spy (2020) won the best picture award at the ceremony streamed live on YouTube and Naver.
2023: The 16th edition of the awards presentation hosted by Hong Kong-born Canadian actress Grace Chan and actor Sammy Leung was held on March 12, 2023 at Hong Kong Jockey Club Auditorium in Hong Kong Palace Museum. 30 films from 22 regions and countries have been shortlisted for 81 nominations. Drive My Car by Ryusuke Hamaguchi won the best film award and best direction was awarded to Hirokazu Kore-eda for Broker, whereas Tang Wei's performance in Decision to Leave got her the best actress award. Tony Leung Chiu-wai, a Hong Kong actor and singer, was presented with Asian Film Contribution Award for his contribution to the Asian cinema and the best actor award for his performance in Where the Wind Blows.
See also
Hong Kong International Film Festival
16th Asian Film Awards
References
External links
Asian Film Awards at IMDb
Awards established in 2007
2007 establishments in Hong Kong
Annual events in Hong Kong
2021 disestablishments in Hong Kong
Awards disestablished in 2021
|
```python
Immutable sets with `frozenset`
`set` operations
How to count
A thread-safe `Queue`
Prioritize your `queue`
```
|
```ruby
require_relative 'avg/job'
require_relative 'avg/benchmark_suite'
module Benchmark
module Avg
def avg
benchmark_suite = BenchmarkSuite.new
yield benchmark_suite
benchmark_suite.run
end
end
extend Benchmark::Avg
end
```
|
```php
<?php
namespace Illuminate\Database\Events;
use Illuminate\Contracts\Database\Events\MigrationEvent as MigrationEventContract;
abstract class MigrationsEvent implements MigrationEventContract
{
/**
* The migration method that was invoked.
*
* @var string
*/
public $method;
/**
* Create a new event instance.
*
* @param string $method
* @return void
*/
public function __construct($method)
{
$this->method = $method;
}
}
```
|
Merlimont () is a commune in the Pas-de-Calais department in the Hauts-de-France region of France.
Geography
Merlimont lies on the coast of France, facing northwards to the English Channel. Long, wide sandy beaches and huge sand-dunes are the most obvious features.
Population
Places of interest
Bagatelle, a theme park, was opened in 1955.
See also
Communes of the Pas-de-Calais department
References
External links
Merlimont’s own website
Bagatelle theme park in English
Communes of Pas-de-Calais
Populated coastal places in France
|
```java
/*
* or more contributor license agreements. See the NOTICE file
* distributed with this work for additional information
* regarding copyright ownership. The ASF licenses this file
*
* path_to_url
*
* Unless required by applicable law or agreed to in writing,
* "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
* specific language governing permissions and limitations
*/
package org.apache.pulsar.common.policies.data;
import java.util.List;
import org.apache.pulsar.client.admin.utils.ReflectionUtils;
public interface NamespaceIsolationData {
List<String> getNamespaces();
List<String> getPrimary();
List<String> getSecondary();
AutoFailoverPolicyData getAutoFailoverPolicy();
void validate();
interface Builder {
Builder namespaces(List<String> namespaces);
Builder primary(List<String> primary);
Builder secondary(List<String> secondary);
Builder autoFailoverPolicy(AutoFailoverPolicyData autoFailoverPolicyData);
NamespaceIsolationData build();
}
static Builder builder() {
return ReflectionUtils.newBuilder("org.apache.pulsar.common.policies.data.NamespaceIsolationDataImpl");
}
}
```
|
"As I Am" is a song by Canadian singer Justin Bieber featuring American singer-songwriter Khalid. It was released through Def Jam Recordings on March 19, 2021, as the third track from Bieber's sixth studio album, Justice. The song was written alongside Scott Harris, Aldae, producers The Monsters & Strangerz, German (of TM&S), & Josh Gudwin, and co-producer Ido Zmishlany.
Background and composition
"As I Am" is a pop ballad set in the key of B major and has a moderate tempo of 100 beats per minute. The song marks the first collaboration between Justin Bieber and Khalid. The "soulful and hopeful" song serves as "a sweet reminder of being grateful for the people who love you even when you are not perfect". The "high-pitched synth and intense percussion" develop into the "upbeat, catchy chorus".
On March 19, 2021, in an interview with Vogue, Bieber spoke on the nature of the song and revealed that it was about the promises that he made to his wife Hailey Baldwin: I love this song because it has a really hopeful message. A lot of us, including me at times, have felt unworthy of love and so [the hook] is saying, 'Take me as I am and I'll do the best that I can.' It's that commitment that I personally made to my wife. I'm here through thick and thin—this is me, take it or leave it.
Critical reception
Billboards Jason Lipshutz ranked "As I Am" as the twelfth-best song on Justice, opining that the pairing of Bieber and Khalid "plays out just as fans would have hoped" and that it "should be the first of several team-ups between the two". Craig Jenkins from Vulture wrote that the collaboration "fools you into thinking it's another muted ballad before knocking you over the head with a massive drop". Jennifer McClellan of USA Today thought that Khalid's vocals on the track were a "genius addition". Similarly, Chris Willman of Variety believed Khalid was one of several guest artists on Justice "who actually feel like they complement Bieber somehow". By contrast, Ali Shutler of The Daily Telegraph turned down Khalid's guest appearance on the song as unexciting. Uproxx's Bianca Gracie felt that the song was "a formulaic recreation of Believes poppier moments".
Credits and personnel
Credits adapted from Tidal.
Justin Bieber – lead vocals, songwriting
Khalid – featured vocals, songwriting
The Monsters & Strangerz – production, songwriting, drums, programming
Jordan K. Johnson – production, songwriting, drums, programming
Stefan Johnson – production, vocal production, songwriting, drums, programming
German – production, songwriting, bass, programming
Josh Gudwin – production, songwriting, mixing, recording, vocal engineering, studio personnel
Ido Zmishlany – co-production, songwriting, piano
Scott Harris – songwriting
Aldae – songwriting, background vocals
Pierre-Luc Rioux – guitar
Colin Leonard – mastering
Denis Kosiak – recording
Heidi Wang – recording, assistant mixing
James Keeley – assistant recording
Charts
Certifications
References
2020s ballads
2021 songs
Justin Bieber songs
Khalid (singer) songs
Pop ballads
Song recordings produced by the Monsters & Strangerz
Songs written by Justin Bieber
Songs written by Khalid (singer)
Songs written by Jordan Johnson (songwriter)
Songs written by Stefan Johnson
Songs written by Scott Harris (songwriter)
Songs written by Gregory Hein
|
```java
package com.lzy.ninegridview.model.evaluation.bean;
import java.io.Serializable;
import java.util.ArrayList;
/** */
public class Evaluation implements Serializable{
public int totalCount; //
public int pageNo; //
public int pageCount;
public int goodCount;
public int badCount;
public int middleCount;
public String goodPD; //
public ArrayList<EvaluationItem> evaluataions;
public int getTotalCount() {
return totalCount;
}
public void setTotalCount(int totalCount) {
this.totalCount = totalCount;
}
public int getPageNo() {
return pageNo;
}
public void setPageNo(int pageNo) {
this.pageNo = pageNo;
}
public int getPageCount() {
return pageCount;
}
public void setPageCount(int pageCount) {
this.pageCount = pageCount;
}
public int getGoodCount() {
return goodCount;
}
public void setGoodCount(int goodCount) {
this.goodCount = goodCount;
}
public int getBadCount() {
return badCount;
}
public void setBadCount(int badCount) {
this.badCount = badCount;
}
public int getMiddleCount() {
return middleCount;
}
public void setMiddleCount(int middleCount) {
this.middleCount = middleCount;
}
public String getGoodPD() {
return goodPD;
}
public void setGoodPD(String goodPD) {
this.goodPD = goodPD;
}
public ArrayList<EvaluationItem> getEvaluataions() {
return evaluataions;
}
public void setEvaluataions(ArrayList<EvaluationItem> evaluataions) {
this.evaluataions = evaluataions;
}
@Override
public String toString() {
return "Evaluation{" +
"totalCount=" + totalCount +
", pageNo=" + pageNo +
", pageCount=" + pageCount +
", goodCount=" + goodCount +
", badCount=" + badCount +
", middleCount=" + middleCount +
", goodPD='" + goodPD + '\'' +
", evaluataions=" + evaluataions +
'}';
}
}
```
|
Abu Sayeed Al Mahmood Swapon is a Bangladesh Awami League politician and the incumbent Member of Parliament from Joypurhat-2.
Early life
Swapon was born on 21 September 1969. He has B.A. and M.B.A. degrees.
Career
Swapon was elected to Parliament on 5 January 2014 from Joypurhat-2 as a Bangladesh Awami League candidate. From 23 to 26 April 2018, he was the acting General Secretary of Bangladesh Awami League after Obaidul Quader left for a three-day trip to India.
References
Awami League politicians
Living people
1969 births
10th Jatiya Sangsad members
11th Jatiya Sangsad members
|
Sir Francis Cockburn (; 10 November 1780 – 24 August 1868) served in the British Army, played an important role in the early settlement of eastern Canada and was a colonial administrator.
Cockburn was born in England in 1780. He was the fifth and last son of Sir James Cockburn, 8th Baronet (1729–1804) and his second wife Augusta Anne Ayscough. His maternal grandfather was Francis Ayscough, Dean of Bristol and Royal tutor.
On 19 November 1804, at Harbledown, Kent, England, he married Alicia Arabella (1782-1854), daughter of Richard Sandys, a descendant of Archbishop Sandys.
Military career
He had first joined the 7th Dragoon Guards at the age of 19 and served in South America and the Iberian Peninsula. Following his marriage, he was sent to Canada in 1811 as a captain in the Canadian Fencibles and fought in the War of 1812 against the United States. He served with the Quartermaster-General for Upper Canada at York and Kingston. In 1815, he became assistant quartermaster-general for Upper Canada and assisted in settling immigrants near Perth in the Bathurst District.
In 1818, he became deputy quartermaster-general for Upper and Lower Canada. He helped establish military settlements at Perth, Richmond, Lanark, the Bay of Quinte, Glengarry County and on the Saint-François River in Lower Canada. He also founded a village at Franktown, Ontario. In 1819, he accompanied the Duke of Richmond on the tour of Perth and Richmond which led to the Duke's death.
He returned to England in 1823. During his time there, he helped establish the price of lands for properties in Upper Canada and provided advice on the best locations for settlement in the region.
He served as superintendent of British Honduras from 1830 to 1837 and Governor of the Bahamas from 1837 to 1844. Cockburn Town, the largest settlement on San Salvador Island in the Bahamas, was named after him, as was Cockburn Island in Ontario.
Cockburn was knighted by Letters Patent on 8 Sept 1841. He was promoted to the rank of Lieutenant-General in 1860.
He was buried at Harbledown, Kent, where he had married, on 29 August 1868.
References
External links
Biography at the Dictionary of Canadian Biography Online
1780 births
1868 deaths
British Army lieutenant generals
Upper Canada people
British people of the War of 1812
British colonial governors and administrators in the Americas
7th Dragoon Guards officers
British governors of the Bahamas
Francis
Younger sons of baronets
Lower Canada people
Governors of British Honduras
|
Sandy Point Island (more commonly referred to as Sandy Point) is a island in Little Narragansett Bay, lying mostly in Westerly, Rhode Island and partly in Stonington, Connecticut. Once an extension of Napatree Point, Sandy Point is now a island that serves as an important nature preserve and recreation site. Sandy Point is the westernmost piece of land in the state of Rhode Island.
History
Before the Great September Gale of 1815, Sandy Point was the farthest extension of Napatree Point, forming a small, sickle-shaped peninsula on the western edge of Watch Hill, Rhode Island. Following the storm, virtually all of the trees on the once-forested peninsula were destroyed, allowing the coastal vegetation to occupy the landscape.
Even during the period when it was connected to the mainland, Sandy Point was never built upon. Fort Mansfield, situated at the elbow of the peninsula, marked the end of the developed portion of the land. In 1926, following the closure of the fort, the federal government put Fort Mansfield and all the land beyond it (that is, Sandy Point) up for sale. A New York developer proposed Sandy Point be subdivided into 674 lots and in response a syndicate of Watch Hill residents purchased the land to prevent the construction of the "cheap little houses" that might change the exclusive character of their village.
Prior to the 1938 Hurricane making landfall on the Northeastern United States, Napatree and Sandy Points formed a single peninsula. When the hurricane struck the coast, it destroyed all the houses on Napatree Point and cut several channels into the peninsula. Only one of those channels proved to be permanent; that breach separated Sandy Point from Napatree Point just beyond the site of the former fort. To this day Sandy Point remains an island, leaving Napatree Point as the westernmost point on mainland Rhode Island.
In 1940, Sandy Point was deeded to Alfred Gildersleeve of Stonington, Connecticut. The Gildersleeve family gave Sandy Point to the Avalonia Land Conservancy in 1982 to be protected and used as a nature preserve.
Geography and geology
The present, shifting geography of the island is the result of the 1938 Hurricane and the process of longshore drift. Sandy Point Island is a slender, barrier beach in Little Narragansett Bay, an estuary of the Pawcatuck River in Fishers Island Sound. It lies about one mile north of Napatree Point, with very shallow waters in the area where the two were once connected.
The island is low-lying and geologically similar to Napatree Point. The northern and southern ends provide a dune habitat covered in beachgrass, shrubs, and a few trees. The middle of the island is a sandy washover area, with sparse (yet locally-rare) sand plain vegetation. Tidal flats extend into Little Narragansett Bay on both the bay and ocean sides of the island.
Aside from a few tiny dunes, the topography of the island is generally flat. Since its separation from Napatree Point, Sandy Point Island has been migrating in a northwestern direction; the northernmost five acres now lie within the boundaries of Connecticut, with the remaining thirty acres still in Rhode Island.
Sandy Point Nature Preserve
Following the Avalonia Land Conservancy's acquisition of the island in 1982, Sandy Point has served an important ecological role for wildlife in the region. It mainly serves as a place of refuge and a breeding ground for shoreline birds such as the piping plover, American oystercatcher, least tern, and several species of gulls. A large number of horseshoe crabs also come to the island to breed.
The Avalonia Land Conservancy sought assistance from the U.S. Fish & Wildlife Service in 2009 to more effectively manage the preserve for the endangered shorebirds which nest there. In 2015, the Fish and Wildlife Service began its partnership with the Avalonia Land Conservancy in earnest, with the intention of incorporating Sandy Point into the refuge boundary of the Stewart B. McKinney National Wildlife Refuge. The property is currently managed by the Rhode Island National Wildlife Refuge Complex through the Partners for Fish and Wildlife program, which allows the Avalonia Land Conservancy to maintain ownership of the island and benefit from the management expertise of the USFWS.
Public Access
Sandy Point Island has been a popular recreation site for boaters and beachgoers who enjoy its soft sand and shallow waters. Striking a balance between conservation and public use of the property has been a primary focus of the Avalonia Land Conservancy and the USFWS over the last several years. Currently, the public is permitted to access those portions of the island on which birds are not nesting. Each year, once the birds have chosen sites for their nests, nesting areas are roped off during the breeding season (typically the northern and southern tips of the island, as well as a portion of the sandy middle). The remainder of the island is left open to the public, with the purchase of a permit to visit the site required from Memorial Day to Labor Day.
Despite some initial opposition, increased educational outreach has led most Sandy Point visitors to accept the island's dual-purpose vocation and respect the boundaries established each year for nesting shorebirds. The Fish & Wildlife Service has installed informational kiosks on the northern and southern ends of the island, and rangers often walk the island to monitor the wildlife and engage the public.
As an island with no dock, Sandy Point can be somewhat difficult to access. The island is most easily reached by kayak or by a boat with a shallow draft. Larger boats can also be taken to the island, but boaters must drop anchor offshore and then row or swim to the beach.
See also
Napatree Point
Little Narragansett Bay
1938 New England Hurricane
U.S. Fish & Wildlife Service
References
External links
The Avalonia Land Conservancy, the organization that owns Sandy Point
U.S. Fish and Wildlife Service PDF brochure for Sandy Point
Rhode Island National Wildlife Refuge Complex, the organization which sells visitor passes to Sandy Point
"Landowners protect the beach and the birds of Sandy Point Island"
Islands of Rhode Island
Nature reserves in Rhode Island
Islands of Washington County, Rhode Island
Westerly, Rhode Island
Stonington, Connecticut
Protected areas of Washington County, Rhode Island
Coastal islands of Rhode Island
|
```smalltalk
namespace Volo.Abp.AspNetCore.Mvc.UI.Bundling;
public enum BundlingMode
{
/// <summary>
/// No bundling or minification.
/// </summary>
None,
/// <summary>
/// Automatically determine the mode.
/// - Uses <see cref="None"/> for development time.
/// - Uses <see cref="BundleAndMinify"/> for other environments.
/// </summary>
Auto,
/// <summary>
/// Bundled but not minified.
/// </summary>
Bundle,
/// <summary>
/// Bundled and minified.
/// </summary>
BundleAndMinify
}
```
|
Flight 191 is an airline flight number that has had multiple accidents and incidents. It may refer to:
Aeroflot Flight 191 (1963), crashed on final approach to Ashgabat International Airport, killing 12 people
X-15 Flight 191 (1967), or X-15 Flight 3-65-97, experimental test plane, broke apart in flight, killing its test pilot
Prinair Flight 191 (1972), crashed at Mercedita Airport in Ponce, Puerto Rico, killing five people
American Airlines Flight 191 (1979), crashed shortly after takeoff from Chicago O'Hare Airport, killing 273
Delta Air Lines Flight 191 (1985), crashed while on final approach to Dallas-Fort Worth, killing 137
Comair Flight 191 (2006), crashed on take-off from the wrong runway at Lexington, Kentucky, killing 49; in all ATC communications the call sign was "Comair 191"
JetBlue Flight 191 (2012), a flight from New York John F. Kennedy airport to Las Vegas, Nevada; diverted to Amarillo, Texas due to erratic pilot behavior
See also
Flight 901 (disambiguation)
Flight 1 / 001 (disambiguation)
Flight 101 (disambiguation)
0191
|
```objective-c
// Use of this source code is governed by a BSD-style license that can be
// found in the LICENSE file.
#ifndef RootFrameViewport_h
#define RootFrameViewport_h
#include "core/CoreExport.h"
#include "platform/scroll/ScrollableArea.h"
namespace blink {
class LayoutRect;
// ScrollableArea for the root frame's viewport. This class ties together the
// concepts of layout and visual viewports, used in pinch-to-zoom. This class
// takes two ScrollableAreas, one for the visual viewport and one for the
// layout viewport, and delegates and composes the ScrollableArea API as needed
// between them. For most scrolling APIs, this class will split the scroll up
// between the two viewports in accord with the pinch-zoom semantics. For other
// APIs that don't make sense on the combined viewport, the call is delegated to
// the layout viewport. Thus, we could say this class is a decorator on the
// FrameView scrollable area that adds pinch-zoom semantics to scrolling.
class CORE_EXPORT RootFrameViewport final : public NoBaseWillBeGarbageCollectedFinalized<RootFrameViewport>, public ScrollableArea {
WILL_BE_USING_GARBAGE_COLLECTED_MIXIN(RootFrameViewport);
public:
static PassOwnPtrWillBeRawPtr<RootFrameViewport> create(ScrollableArea& visualViewport, ScrollableArea& layoutViewport)
{
return adoptPtrWillBeNoop(new RootFrameViewport(visualViewport, layoutViewport));
}
DECLARE_VIRTUAL_TRACE();
// ScrollableArea Implementation
void setScrollPosition(const DoublePoint&, ScrollType, ScrollBehavior = ScrollBehaviorInstant) override;
LayoutRect scrollIntoView(
const LayoutRect& rectInContent,
const ScrollAlignment& alignX,
const ScrollAlignment& alignY) override;
DoubleRect visibleContentRectDouble(IncludeScrollbarsInRect = ExcludeScrollbars) const override;
IntRect visibleContentRect(IncludeScrollbarsInRect = ExcludeScrollbars) const override;
bool shouldUseIntegerScrollOffset() const override;
bool isActive() const override;
int scrollSize(ScrollbarOrientation) const override;
bool isScrollCornerVisible() const override;
IntRect scrollCornerRect() const override;
void setScrollOffset(const IntPoint&, ScrollType) override;
void setScrollOffset(const DoublePoint&, ScrollType) override;
IntPoint scrollPosition() const override;
DoublePoint scrollPositionDouble() const override;
IntPoint minimumScrollPosition() const override;
IntPoint maximumScrollPosition() const override;
DoublePoint maximumScrollPositionDouble() const override;
IntSize contentsSize() const override;
bool scrollbarsCanBeActive() const override;
IntRect scrollableAreaBoundingBox() const override;
bool userInputScrollable(ScrollbarOrientation) const override;
bool shouldPlaceVerticalScrollbarOnLeft() const override;
void invalidateScrollbarRect(Scrollbar*, const IntRect&) override;
void invalidateScrollCornerRect(const IntRect&) override;
GraphicsLayer* layerForContainer() const override;
GraphicsLayer* layerForScrolling() const override;
GraphicsLayer* layerForHorizontalScrollbar() const override;
GraphicsLayer* layerForVerticalScrollbar() const override;
ScrollResultOneDimensional userScroll(ScrollDirectionPhysical, ScrollGranularity, float delta = 1) override;
bool scrollAnimatorEnabled() const override;
HostWindow* hostWindow() const override;
void serviceScrollAnimations(double) override;
void updateCompositorScrollAnimations() override;
virtual ScrollBehavior scrollBehaviorStyle() const override;
// TODO(bokan): This method should be removed. It should be replaced by
// making EventHandler::handleWheelEvent unpack the WheelEvent and make a
// call to this class' scroll method.
ScrollResult handleWheel(const PlatformWheelEvent&) override;
private:
RootFrameViewport(ScrollableArea& visualViewport, ScrollableArea& layoutViewport);
DoublePoint scrollOffsetFromScrollAnimators() const;
// If either of the layout or visual viewports are scrolled explicitly (i.e. not
// through this class), their updated offset will not be reflected in this class'
// animator so use this method to pull updated values when necessary.
void updateScrollAnimator();
ScrollableArea& visualViewport() const { ASSERT(m_visualViewport); return *m_visualViewport; }
ScrollableArea& layoutViewport() const { ASSERT(m_layoutViewport); return *m_layoutViewport; }
RawPtrWillBeMember<ScrollableArea> m_visualViewport;
RawPtrWillBeMember<ScrollableArea> m_layoutViewport;
};
} // namespace blink
#endif // RootFrameViewport_h
```
|
```c++
path_to_url
Unless required by applicable law or agreed to in writing, software
WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
#include <string>
#include <vector>
#include "paddle/fluid/framework/infershape_utils.h"
#include "paddle/fluid/framework/op_registry.h"
#include "paddle/phi/infermeta/multiary.h"
namespace paddle {
namespace operators {
/**
* Organize the classes into a binary tree. At each node, a sigmoid function
* is used to calculate the probability of belonging to the right branch.
* This idea is from "F. Morin, Y. Bengio (AISTATS 05):
* Hierarchical Probabilistic Neural Network Language Model."
*
* Here we uses a simple way of making the binary tree.
* Assuming the number of classes C = 6,
* The classes are organized as a binary tree in the following way:
*
* @code{.py}
* *-*-*- 2
* | | |- 3
* | |
* | |-*- 4
* | |- 5
* |
* |-*- 0
* |- 1
* @endcode
*
* where * indicates an internal node, and each leaf node represents a class.
* - Node 0 ... C-2 are internal nodes.
* - Node C-1 ... 2C-2 are leaf nodes.
* - Class c is represented by leaf node \f$c+C-1\f$.
*
* We assign an id for each node:
* - the id of root be 0.
* - the left child of a node i is 2*i+1.
* - the right child of a node i is 2*i+2.
*
* It's easy to see that:
* - the parent of node i is \f$\left\lfloor(i-1)/2\right\rfloor\f$.
* - the j-th level ancestor of node i is
* \f$\left\lfloor(i+1)/2^{j+1}\right\rfloor - 1\f$.
* - A node i is a left child of its parent if \f$(i-1)\%2==0\f$.
*
*/
class HierarchicalSigmoidOp : public framework::OperatorWithKernel {
public:
using framework::OperatorWithKernel::OperatorWithKernel;
protected:
phi::KernelKey GetExpectedKernelType(
const framework::ExecutionContext& ctx) const override {
return phi::KernelKey(OperatorWithKernel::IndicateVarDataType(ctx, "X"),
ctx.GetPlace());
}
};
/*
* Inputs: X, W, Label, PathTable, PathCode, Bias
* Outputs: Out, PreOut, W_out
*/
template <typename AttrType>
class HierarchicalSigmoidOpMaker : public framework::OpProtoAndCheckerMaker {
public:
void Make() override {
AddInput("X",
"(phi::DenseTensor, required) The input tensor with shape [N, D], "
"where N is the size of mini-batch, and D is the feature size.");
AddInput("W",
"(phi::DenseTensor, required), The parameters of hierarchical "
"sigmoid operator, each of them is a 2-D tensor, the shape is"
"[K, D]. Which K is the num of non-leaf node in Path Tree");
AddInput("Label",
"(phi::DenseTensor, required), The labels of training data. It's a"
"tensor with shape [N, 1].");
AddInput(
"PathTable",
"(phi::DenseTensor, optional), The Path Table from root to current word"
"it should have shape like [N, L], L is the length of the Path")
.AsDispensable();
AddInput("PathCode",
"(phi::DenseTensor, optional), The Code on each Node of the Path "
"from root "
"to current word"
"it should have shape like [N, L], L is the length of the Path")
.AsDispensable();
AddInput("Bias",
"(phi::DenseTensor, optional), The bias is a tensor with shape or "
"[num_classes, 1]"
"[num_classes - 1, 1].")
.AsDispensable();
AddOutput("Out",
"(phi::DenseTensor, required) The output of hierarchical sigmoid "
"operator."
"The shape is [N, 1].");
AddOutput("PreOut",
"(phi::DenseTensor, required) A intermedia 2-D tensor with shape "
"[batch_size, code_length], where code_length represents the "
"maximum path length from root to leaf nodes.")
.AsIntermediate();
AddOutput("W_Out",
"(phi::DenseTensor, optional) using input 'W' as Output to make "
"it mutable"
"When we are using prefetch")
.AsIntermediate();
AddAttr<AttrType>("num_classes", "(int, optional), The number of classes")
.SetDefault(2);
// for parameter prefetch
AddAttr<int>("trainer_id", "trainer id from 0 ~ worker_num.").SetDefault(0);
AddAttr<std::vector<int64_t>>("height_sections",
"Height for each output SelectedRows.")
.SetDefault(std::vector<int64_t>({}));
AddAttr<std::vector<std::string>>(
"epmap",
"(string vector, default 127.0.0.1:6164)"
"Server endpoints in the order of input variables for mapping")
.SetDefault({});
AddAttr<std::vector<std::string>>(
"table_names",
"(string vector, the split table names that will be fetched from "
"parameter server)"
"in the order of input variables for mapping")
.SetDefault({});
AddComment(R"DOC(
The hierarchical sigmoid operator organize the classes into a binary tree.
At each node, a sigmoid function is used to calculate the probability of
belonging to the right branch. This idea is from
"F. Morin, Y. Bengio (AISTATS 05):
Hierarchical Probabilistic Neural Network Language Model."
)DOC");
AddAttr<bool>("is_sparse",
"(boolean, default false) "
"Sparse update.")
.SetDefault(false);
}
};
/*
* Inputs: X, W, Label, PathTable, PathCode, PreOut, Out@GRAD
* Outputs: X@GRAD, W@GRAD, Bias@GRAD
*/
template <typename T>
class HierarchicalSigmoidGradMaker : public framework::SingleGradOpMaker<T> {
public:
using framework::SingleGradOpMaker<T>::SingleGradOpMaker;
void Apply(GradOpPtr<T> op) const override {
op->SetType(this->ForwardOpType() + "_grad");
// Inputs: X, W, Label, PathTable, PathCode, PreOut, Out@GRAD
op->SetInput("X", this->Input("X"));
op->SetInput("W", this->Input("W"));
op->SetInput("Bias", this->Input("Bias"));
op->SetInput("Label", this->Input("Label"));
op->SetInput("PathTable", this->Input("PathTable"));
op->SetInput("PathCode", this->Input("PathCode"));
op->SetInput("PreOut", this->Output("PreOut"));
op->SetInput(framework::GradVarName("Out"), this->OutputGrad("Out"));
// Outputs: X@GRAD, W@GRAD, Bias@GRAD
op->SetOutput(framework::GradVarName("X"), this->InputGrad("X"));
op->SetOutput(framework::GradVarName("W"), this->InputGrad("W"));
op->SetOutput(framework::GradVarName("Bias"), this->InputGrad("Bias"));
op->SetAttrMap(this->Attrs());
}
};
class HierarchicalSigmoidGradOp : public framework::OperatorWithKernel {
public:
using framework::OperatorWithKernel::OperatorWithKernel;
void InferShape(framework::InferShapeContext* ctx) const override {
OP_INOUT_CHECK(ctx->HasInput("W"), "Input", "W", "hsigmoid_grad");
OP_INOUT_CHECK(ctx->HasInput("Label"), "Input", "Label", "hsigmoid_grad");
OP_INOUT_CHECK(ctx->HasInput(framework::GradVarName("Out")),
"Input",
"Out@Grad",
"hsigmoid_grad");
OP_INOUT_CHECK(ctx->HasInput("PreOut"), "Input", "PreOut", "hsigmoid_grad");
OP_INOUT_CHECK(ctx->HasOutput(framework::GradVarName("W")),
"Output",
"W@Grad",
"hsigmoid_grad");
OP_INOUT_CHECK(ctx->HasOutput(framework::GradVarName("X")),
"Output",
"X@Grad",
"hsigmoid_grad");
if (ctx->HasOutput(framework::GradVarName("Bias"))) {
ctx->SetOutputDim(framework::GradVarName("Bias"),
ctx->GetInputDim("Bias"));
}
ctx->SetOutputDim(framework::GradVarName("W"), ctx->GetInputDim("W"));
ctx->SetOutputDim(framework::GradVarName("X"), ctx->GetInputDim("X"));
ctx->ShareLoD("X", /*->*/ framework::GradVarName("X"));
}
protected:
phi::KernelKey GetExpectedKernelType(
const framework::ExecutionContext& ctx) const override {
return phi::KernelKey(OperatorWithKernel::IndicateVarDataType(ctx, "X"),
ctx.GetPlace());
}
};
class HierarchicalSigmoidGradOpGradVarTypeInference
: public framework::VarTypeInference {
public:
void operator()(framework::InferVarTypeContext* ctx) const override {
auto w_grad_var_name = framework::GradVarName("W");
auto bias_grad_var_name = framework::GradVarName("Bias");
if (ctx->HasOutput(bias_grad_var_name)) {
VLOG(3) << "hierarchical_sigmoid_grad op "
<< framework::GradVarName("Bias")
<< " is set to phi::DenseTensor";
ctx->SetOutputType(bias_grad_var_name,
framework::proto::VarType::LOD_TENSOR);
}
auto attr = ctx->GetAttr("is_sparse");
bool is_sparse = PADDLE_GET(bool, attr);
if (is_sparse) {
VLOG(3) << "hierarchical_sigmoid_grad op " << framework::GradVarName("W")
<< " is set to SelectedRows";
ctx->SetOutputType(w_grad_var_name,
framework::proto::VarType::SELECTED_ROWS);
} else {
VLOG(3) << "hierarchical_sigmoid_grad op " << framework::GradVarName("W")
<< " is set to phi::DenseTensor";
ctx->SetOutputType(w_grad_var_name,
framework::proto::VarType::LOD_TENSOR);
}
ctx->SetOutputDataType(w_grad_var_name, ctx->GetInputDataType("W"));
}
};
DECLARE_NO_NEED_BUFFER_VARS_INFERER(
HierarchicalSigmoidGradOpNoNeedBufferVarInferer, "Bias");
} // namespace operators
} // namespace paddle
namespace ops = paddle::operators;
DECLARE_INFER_SHAPE_FUNCTOR(hierarchical_sigmoid,
HierarchicalSigmoidInferShapeFunctor,
PD_INFER_META(phi::HSigmoidLossInferMeta));
REGISTER_OPERATOR(hierarchical_sigmoid,
ops::HierarchicalSigmoidOp,
ops::HierarchicalSigmoidOpMaker<int>,
ops::HierarchicalSigmoidGradMaker<paddle::framework::OpDesc>,
ops::HierarchicalSigmoidGradMaker<paddle::imperative::OpBase>,
HierarchicalSigmoidInferShapeFunctor);
REGISTER_OPERATOR(hierarchical_sigmoid_grad,
ops::HierarchicalSigmoidGradOp,
ops::HierarchicalSigmoidGradOpGradVarTypeInference,
ops::HierarchicalSigmoidGradOpNoNeedBufferVarInferer);
```
|
```xml
import { graphql } from "react-relay";
import { Environment } from "relay-runtime";
import {
commitMutationPromiseNormalized,
createMutation,
MutationInput,
} from "coral-framework/lib/relay";
import { DemoteModeratorMutation as MutationTypes } from "coral-admin/__generated__/DemoteModeratorMutation.graphql";
let clientMutationId = 0;
const DemoteModeratorMutation = createMutation(
"demoteModerator",
(environment: Environment, input: MutationInput<MutationTypes>) =>
commitMutationPromiseNormalized<MutationTypes>(environment, {
mutation: graphql`
mutation DemoteModeratorMutation($input: DemoteModeratorInput!) {
demoteModerator(input: $input) {
user {
id
role
moderationScopes {
scoped
sites {
id
name
}
}
}
clientMutationId
}
}
`,
variables: {
input: {
...input,
clientMutationId: (clientMutationId++).toString(),
},
},
})
);
export default DemoteModeratorMutation;
```
|
```javascript
/**
* @license Apache-2.0
*
*
*
* path_to_url
*
* Unless required by applicable law or agreed to in writing, software
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
*/
'use strict';
// MODULES //
var tape = require( 'tape' );
var isRegExp = require( '@stdlib/assert/is-regexp' );
var reDurationString = require( './../lib' );
// TESTS //
tape( 'main export is a function', function test( t ) {
t.ok( true, __filename );
t.strictEqual( typeof reDurationString, 'function', 'main export is a function' );
t.end();
});
tape( 'attached to the main export is a regular expression', function test( t ) {
t.equal( isRegExp( reDurationString.REGEXP ), true, 'exports a regular expression' );
t.end();
});
```
|
Bruised Music, Volume 1 is a compilation album by Appleton, Wisconsin rock group Tenement, released by Grave Mistake Records and Toxic Pop Records. It is composed of singles and rarities from the band's first four years. The album was ranked #1170 by The Village Voice on their 2015 Pazz & Jop critics poll.
Reception
Punknews: "Sounding like a darker, more depressed Midwestern version of the Descendents, Tenement’s brand of pop punk is heavier, harder and better than most of their ilk."
Rock Freaks: "...Given the compilation nature of the album, the quality of song varies quite significantly from the more anonymous tracks to the quality songs that make Tenement worth following and checking out especially live. Those on the second half of the record are arguably catchier than on the first half, but it's still mostly a fan release and probably not suitable as the starting point to the band."
Ahead of Bruised Music, Volume 1 's release, Stereogum wrote, "Though the album cover's stark binary palette and vampire-like outstretched claws might bring to mind a Bauhaus coldness, the music owes more to Black Flag than anything remotely post-punk," calling the song Spaghetti Midwestern "a riotous portrait of suburban disillusionment, the American Dream gone awry" and Morning Mouth "a spiraling two and a half minutes of theatrical frustration".
Track listing
All compositions by Amos Pitsch except where noted.
"Sitcom Moms"
"Spaghetti Midwestern"
"The Fire Is Out"
"Summer Street, Parts 1 and 2"
"Best And Worst Of Times" (Hart Miller/Amos Pitsch)
"Pauline"
"Icepick"
"Goodnight, Rosendale"
"Morning Mouth"
"Do You Think About Him?"
References
External links
Bruised Music, Volume 1 at Bandcamp
2015 compilation albums
Tenement (band) albums
|
```go
package totest
/*
* or more contributor license agreements. See the NOTICE file
* distributed with this work for additional information
* regarding copyright ownership. The ASF licenses this file
*
* path_to_url
*
* Unless required by applicable law or agreed to in writing,
* "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
* specific language governing permissions and limitations
*/
import (
"strconv"
"testing"
"github.com/apache/trafficcontrol/v8/lib/go-util/assert"
toclient "github.com/apache/trafficcontrol/v8/traffic_ops/v5-client"
)
func CreateTestProfiles(t *testing.T, cl *toclient.Session, td TrafficControl) {
for _, profile := range td.Profiles {
resp, _, err := cl.CreateProfile(profile, toclient.RequestOptions{})
assert.RequireNoError(t, err, "Could not create Profile '%s': %v - alerts: %+v", profile.Name, err, resp.Alerts)
}
}
func DeleteTestProfiles(t *testing.T, cl *toclient.Session) {
profiles, _, err := cl.GetProfiles(toclient.RequestOptions{})
assert.NoError(t, err, "Cannot get Profiles: %v - alerts: %+v", err, profiles.Alerts)
for _, profile := range profiles.Response {
alerts, _, err := cl.DeleteProfile(profile.ID, toclient.RequestOptions{})
assert.NoError(t, err, "Cannot delete Profile: %v - alerts: %+v", err, alerts.Alerts)
// Retrieve the Profile to see if it got deleted
opts := toclient.NewRequestOptions()
opts.QueryParameters.Set("id", strconv.Itoa(profile.ID))
getProfiles, _, err := cl.GetProfiles(opts)
assert.NoError(t, err, "Error getting Profile '%s' after deletion: %v - alerts: %+v", profile.Name, err, getProfiles.Alerts)
assert.Equal(t, 0, len(getProfiles.Response), "Expected Profile '%s' to be deleted, but it was found in Traffic Ops", profile.Name)
}
}
func GetProfileID(t *testing.T, cl *toclient.Session, profileName string) func() int {
return func() int {
opts := toclient.NewRequestOptions()
opts.QueryParameters.Set("name", profileName)
resp, _, err := cl.GetProfiles(opts)
assert.RequireNoError(t, err, "Get Profiles Request failed with error: %v", err)
assert.RequireEqual(t, 1, len(resp.Response), "Expected response object length 1, but got %d", len(resp.Response))
return resp.Response[0].ID
}
}
```
|
```objective-c
// ConsoleClose.h
#ifndef __CONSOLE_CLOSE_H
#define __CONSOLE_CLOSE_H
namespace NConsoleClose {
class CCtrlBreakException {};
#ifdef UNDER_CE
inline bool TestBreakSignal() { return false; }
struct CCtrlHandlerSetter {};
#else
extern unsigned g_BreakCounter;
inline bool TestBreakSignal()
{
return (g_BreakCounter != 0);
}
class CCtrlHandlerSetter
{
#ifndef _WIN32
void (*memo_sig_int)(int);
void (*memo_sig_term)(int);
#endif
public:
CCtrlHandlerSetter();
virtual ~CCtrlHandlerSetter();
};
#endif
}
#endif
```
|
```java
*
* path_to_url
*
* Unless required by applicable law or agreed to in writing, software
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
*/
package org.flowable.app.rest.service.api.repository;
import org.flowable.app.api.AppRepositoryService;
import org.flowable.app.api.repository.AppDefinition;
import org.flowable.app.rest.AppRestApiInterceptor;
import org.flowable.app.rest.AppRestResponseFactory;
import org.flowable.common.engine.api.FlowableIllegalArgumentException;
import org.flowable.common.engine.api.FlowableObjectNotFoundException;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.web.bind.annotation.GetMapping;
import org.springframework.web.bind.annotation.PathVariable;
import org.springframework.web.bind.annotation.PutMapping;
import org.springframework.web.bind.annotation.RequestBody;
import org.springframework.web.bind.annotation.RestController;
import io.swagger.annotations.Api;
import io.swagger.annotations.ApiOperation;
import io.swagger.annotations.ApiParam;
import io.swagger.annotations.ApiResponse;
import io.swagger.annotations.ApiResponses;
import io.swagger.annotations.Authorization;
/**
* @author Tijs Rademakers
*/
@RestController
@Api(tags = { "App Definitions" }, description = "Manage App Definitions", authorizations = { @Authorization(value = "basicAuth") })
public class AppDefinitionResource {
@Autowired
protected AppRestResponseFactory appRestResponseFactory;
@Autowired
protected AppRepositoryService appRepositoryService;
@Autowired(required=false)
protected AppRestApiInterceptor restApiInterceptor;
@ApiOperation(value = "Get a app definition", tags = { "App Definitions" })
@ApiResponses(value = {
@ApiResponse(code = 200, message = "Indicates the app definition was found returned."),
@ApiResponse(code = 404, message = "Indicates the app definition was not found.")
})
@GetMapping(value = "/app-repository/app-definitions/{appDefinitionId}", produces = "application/json")
public AppDefinitionResponse getAppDefinition(@ApiParam(name = "appDefinitionId") @PathVariable String appDefinitionId) {
AppDefinition appDefinition = appRepositoryService.getAppDefinition(appDefinitionId);
if (appDefinition == null) {
throw new FlowableObjectNotFoundException("Could not find an app definition with id '" + appDefinitionId);
}
if (restApiInterceptor != null) {
restApiInterceptor.accessAppDefinitionInfoById(appDefinition);
}
return appRestResponseFactory.createAppDefinitionResponse(appDefinition);
}
@ApiOperation(value = "Execute actions for an app definition", tags = { "App Definitions" },
notes = "Execute actions for an app definition (Update category)")
@ApiResponses(value = {
@ApiResponse(code = 200, message = "Indicates action has been executed for the specified app definition. (category altered)"),
@ApiResponse(code = 400, message = "Indicates no category was defined in the request body."),
@ApiResponse(code = 404, message = "Indicates the requested app definition was not found.")
})
@PutMapping(value = "/app-repository/app-definitions/{appDefinitionId}", produces = "application/json")
public AppDefinitionResponse executeAppDefinitionAction(
@ApiParam(name = "appDefinitionId") @PathVariable String appDefinitionId,
@ApiParam(required = true) @RequestBody AppDefinitionActionRequest actionRequest) {
if (actionRequest == null) {
throw new FlowableIllegalArgumentException("No action found in request body.");
}
AppDefinition appDefinition = appRepositoryService.getAppDefinition(appDefinitionId);
if (appDefinition == null) {
throw new FlowableObjectNotFoundException("Could not find an app definition with id '" + appDefinitionId + "'.", AppDefinition.class);
}
if (restApiInterceptor != null) {
restApiInterceptor.accessAppDefinitionInfoById(appDefinition);
}
if (actionRequest.getCategory() != null) {
// Update of category required
appRepositoryService.setAppDefinitionCategory(appDefinition.getId(), actionRequest.getCategory());
// No need to re-fetch the AppDefinition entity, just update category in response
AppDefinitionResponse response = appRestResponseFactory.createAppDefinitionResponse(appDefinition);
response.setCategory(actionRequest.getCategory());
return response;
}
throw new FlowableIllegalArgumentException("Invalid action: '" + actionRequest.getAction() + "'.");
}
}
```
|
Ealing Hockey Club is a field hockey club based at Perivale Lane in Greenford and at St.Augustine’s Prior School, W5, Middlesex
The original club was formed in 1884 and gained notable success in the 1980s when the women's team won three successive National Clubs Competitions during the 1986–87 England Hockey League season, 1987–88 England Hockey League season and 1988–89 England Hockey League season. Former internationals include Sheila Harding-Cornwallis, Katie Dodd, Mandy Nicholson-Langridge and Joan Lewis.
The club was re-formed by TotalHockey (a coaching agency of England Hockey) in 2012 and runs a ladies team who play in the Middlesex League. The club principally concentrated on the development of junior teams but is now growing an adult section.
2019 the club was handed to its members as a member owned not for profit community amateur sports club.
The club had to be reformed because in 2000 it went out of existence after a merger with Hounslow to form the Hounslow and Ealing Hockey Club which itself then merged with the Barnes Hockey Club.
In the 2018/19 Ealing Hockey Club fielded a second Ladies team. Having both Ladies Team gained promotion Total Hockey gifted the club to its members as a member-owned / member-run amateur sports club. The 2019/20 season the club will field 3 ladies' teams and 1 men's team with the Ladies 2s being promoted to Division 1. The Junior section is now fielding 370 juniors with many going on to represent the county and the adult section.
References
External links
Ealing Hockey Club
Field hockey clubs in England
|
Garabogaz () is a city subordinate to Turkmenbashy District, Balkan province, Turkmenistan, on the shore of the Caspian Sea. Until 2002, the municipality had the status of a town and was named Bekdaş .
Etymology
The city takes its name from the nearby Garabogaz gulf. Atanyyazow explains that the name originally applied to the narrow strait which connects the gulf to the Caspian Sea. Because water in the strait, termed a "throat" (), was darker than the water on either side, it was termed "dark" or "black" (), hence garabogaz. Over time the name was applied to the gulf itself and ultimately to the city. The original name, Bekdash () is taken from the name of a small hill nearby, on which a television antenna has been installed. The origin of bek is obscure; daş means "stone, rock" and Atanyyazov suggests it refers to the pebbles found in the area.
Overview
The settlement occupies the northern tapering of a ridge before it becomes a narrow spit. These together divide the Garabogazköl lagoon from the Caspian Sea, with a small inlet channel to the south of the town. It has abundant and varied mineral resources from the highly saline lagoon. It is one of few places in the world where naturally deposited sodium sulfate exists in commercially exploitable quantities.
Economy
Garabogaz is the site of one of Turkmenistan's three urea (carbamide) plants. The $1.3 billion Garabogaz plant, built by Mitsubishi Heavy Industries and GAP İnşaat (a subsidiary of Çalık Holding), was inaugurated on September 18, 2018, with a design capacity of 1.16 million tonnes of urea per year. Between January and October 2019, the Garabogaz plant produced approximately 392,000 tonnes of urea, of which 261,000 tonnes was exported. The plant operates a loading terminal for shipping urea via the Caspian.
A mineral salt extraction plant dating to the Soviet period is located 15 km northeast of the city. It was constructed over a period of ten years, between 1963 and 1973. It produces sodium sulfate as well as epsomite and Glauber's salt. It has a reported capacity to produce 400,000 tonnes of sodium sulfate per year, but in 1998 produced an estimated 55,000 tonnes, and in 2018, 26,000 tonnes.
Transport
The city lies on the P-18 highway connecting the city of Turkmenbashy with the border of Kazakhstan at Temir Baba. This road is planned for an upgrade or replacement according to press reports, since the section of highway between Garabogaz and the border is mostly unpaved. Garabogaz is served by a freight rail line. Plans were announced in 2018 to renovate the small municipal airport, which does not offer regular passenger service.
Garabogaz offers the only gasoline station between Turkmenbashy and the border with Kazakhstan.
Exile village
It serves as a spot of supervised exile in Turkmen law. Gulgeldy Annaniyazov is one person held there, since 2019.
History
Prior to 1932 the town lay in what is now Kazakhstan.
References
Populated places in Balkan Region
|
```c++
//
// Aspia Project
//
// This program is free software: you can redistribute it and/or modify
// (at your option) any later version.
//
// This program is distributed in the hope that it will be useful,
// but WITHOUT ANY WARRANTY; without even the implied warranty of
// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
//
// along with this program. If not, see <path_to_url
//
#include "host/task_manager.h"
#include "base/logging.h"
#include "base/strings/unicode.h"
#include "base/win/service_enumerator.h"
#include "base/win/service_controller.h"
#include "base/win/session_enumerator.h"
#include "base/win/session_info.h"
#include "host/process_monitor.h"
namespace host {
//your_sha256_hash----------------------------------
TaskManager::TaskManager(Delegate* delegate)
: process_monitor_(std::make_unique<ProcessMonitor>()),
delegate_(delegate)
{
LOG(LS_INFO) << "Ctor";
DCHECK(delegate_);
}
//your_sha256_hash----------------------------------
TaskManager::~TaskManager()
{
LOG(LS_INFO) << "Dtor";
}
//your_sha256_hash----------------------------------
void TaskManager::readMessage(const proto::task_manager::ClientToHost& message)
{
if (message.has_process_list_request())
{
sendProcessList(message.process_list_request().flags());
}
else if (message.has_end_process_request())
{
if (process_monitor_)
{
process_monitor_->endProcess(
static_cast<ProcessMonitor::ProcessId>(message.end_process_request().pid()));
}
}
else if (message.has_service_list_request())
{
sendServiceList();
}
else if (message.has_service_request())
{
if (message.service_request().name().empty())
{
LOG(LS_ERROR) << "Service name not specified";
return;
}
switch (message.service_request().command())
{
case proto::task_manager::ServiceRequest::COMMAND_START:
{
base::win::ServiceController controller = base::win::ServiceController::open(
base::utf16FromUtf8(message.service_request().name()));
if (!controller.isValid())
{
LOG(LS_ERROR) << "Unable to open service: " << message.service_request().name();
return;
}
if (!controller.start())
{
LOG(LS_ERROR) << "Unable to start service: " << message.service_request().name();
return;
}
sendServiceList();
}
break;
case proto::task_manager::ServiceRequest::COMMAND_STOP:
{
base::win::ServiceController controller = base::win::ServiceController::open(
base::utf16FromUtf8(message.service_request().name()));
if (!controller.isValid())
{
LOG(LS_ERROR) << "Unable to open service: " << message.service_request().name();
return;
}
if (!controller.stop())
{
LOG(LS_ERROR) << "Unable to stop service: " << message.service_request().name();
return;
}
sendServiceList();
}
break;
default:
{
LOG(LS_ERROR) << "Unknown command for service request: "
<< message.service_request().command();
}
break;
}
}
else if (message.has_user_list_request())
{
sendUserList();
}
else if (message.has_user_request())
{
if (message.user_request().session_id() == base::kInvalidSessionId)
{
LOG(LS_ERROR) << "Invalid session id";
return;
}
switch (message.user_request().command())
{
case proto::task_manager::UserRequest::COMMAND_DISCONNECT:
{
if (!WTSDisconnectSession(WTS_CURRENT_SERVER_HANDLE, message.user_request().session_id(), FALSE))
{
PLOG(LS_ERROR) << "WTSLogoffSession failed";
return;
}
}
break;
case proto::task_manager::UserRequest::COMMAND_LOGOFF:
{
if (!WTSLogoffSession(WTS_CURRENT_SERVER_HANDLE, message.user_request().session_id(), FALSE))
{
PLOG(LS_ERROR) << "WTSLogoffSession failed";
return;
}
}
break;
default:
{
LOG(LS_ERROR) << "Unknown command for user request: "
<< message.user_request().command();
}
break;
}
}
else
{
LOG(LS_ERROR) << "Unhandled task manager request";
}
}
//your_sha256_hash----------------------------------
void TaskManager::sendProcessList(uint32_t flags)
{
proto::task_manager::HostToClient message;
bool reset_cache = false;
if (flags & proto::task_manager::ProcessListRequest::RESET_CACHE)
reset_cache = true;
proto::task_manager::ProcessList* process_list = message.mutable_process_list();
process_list->set_cpu_usage(process_monitor_->calcCpuUsage());
process_list->set_memory_usage(process_monitor_->calcMemoryUsage());
const ProcessMonitor::ProcessMap& processes = process_monitor_->processes(reset_cache);
for (const auto& process : processes)
{
proto::task_manager::Process* item = process_list->add_process();
ProcessMonitor::ProcessId process_id = process.first;
const ProcessMonitor::ProcessEntry& process_info = process.second;
if (process_info.process_name_changed)
item->set_process_name(process_info.process_name);
if (process_info.user_name_changed)
item->set_user_name(process_info.user_name);
if (process_info.file_path_changed)
item->set_file_path(process_info.file_path);
item->set_session_id(process_info.session_id);
item->set_process_id(process_id);
item->set_session_id(process_info.session_id);
item->set_cpu_usage(process_info.cpu_ratio);
item->set_mem_private_working_set(process_info.mem_private_working_set);
item->set_mem_working_set(process_info.mem_working_set);
item->set_mem_peak_working_set(process_info.mem_peak_working_set);
item->set_mem_working_set_delta(process_info.mem_working_set_delta);
item->set_thread_count(process_info.thread_count);
}
delegate_->onTaskManagerMessage(message);
}
//your_sha256_hash----------------------------------
void TaskManager::sendServiceList()
{
proto::task_manager::HostToClient message;
proto::task_manager::ServiceList* service_list = message.mutable_service_list();
for (base::win::ServiceEnumerator enumerator(base::win::ServiceEnumerator::Type::SERVICES);
!enumerator.isAtEnd(); enumerator.advance())
{
proto::task_manager::Service* item = service_list->add_service();
item->set_name(enumerator.name());
item->set_display_name(enumerator.displayName());
item->set_description(enumerator.description());
switch (enumerator.startupType())
{
case base::win::ServiceEnumerator::StartupType::AUTO_START:
item->set_startup_type(proto::task_manager::Service::STARTUP_TYPE_AUTO_START);
break;
case base::win::ServiceEnumerator::StartupType::DEMAND_START:
item->set_startup_type(proto::task_manager::Service::STARTUP_TYPE_DEMAND_START);
break;
case base::win::ServiceEnumerator::StartupType::DISABLED:
item->set_startup_type(proto::task_manager::Service::STARTUP_TYPE_DISABLED);
break;
case base::win::ServiceEnumerator::StartupType::BOOT_START:
item->set_startup_type(proto::task_manager::Service::STARTUP_TYPE_BOOT_START);
break;
case base::win::ServiceEnumerator::StartupType::SYSTEM_START:
item->set_startup_type(proto::task_manager::Service::STARTUP_TYPE_SYSTEM_START);
break;
default:
item->set_startup_type(proto::task_manager::Service::STARTUP_TYPE_UNKNOWN);
break;
}
switch (enumerator.status())
{
case base::win::ServiceEnumerator::Status::CONTINUE_PENDING:
item->set_status(proto::task_manager::Service::STATUS_CONTINUE_PENDING);
break;
case base::win::ServiceEnumerator::Status::PAUSE_PENDING:
item->set_status(proto::task_manager::Service::STATUS_PAUSE_PENDING);
break;
case base::win::ServiceEnumerator::Status::PAUSED:
item->set_status(proto::task_manager::Service::STATUS_PAUSED);
break;
case base::win::ServiceEnumerator::Status::RUNNING:
item->set_status(proto::task_manager::Service::STATUS_RUNNING);
break;
case base::win::ServiceEnumerator::Status::START_PENDING:
item->set_status(proto::task_manager::Service::STATUS_START_PENDING);
break;
case base::win::ServiceEnumerator::Status::STOP_PENDING:
item->set_status(proto::task_manager::Service::STATUS_STOP_PENDING);
break;
case base::win::ServiceEnumerator::Status::STOPPED:
item->set_status(proto::task_manager::Service::STATUS_STOPPED);
break;
default:
item->set_status(proto::task_manager::Service::STATUS_UNKNOWN);
break;
}
}
delegate_->onTaskManagerMessage(message);
}
//your_sha256_hash----------------------------------
void TaskManager::sendUserList()
{
proto::task_manager::HostToClient message;
proto::task_manager::UserList* user_list = message.mutable_user_list();
for (base::win::SessionEnumerator enumerator; !enumerator.isAtEnd(); enumerator.advance())
{
// Skip services.
if (enumerator.sessionId() == 0)
continue;
base::win::SessionInfo session_info(enumerator.sessionId());
if (!session_info.isValid())
continue;
proto::task_manager::User* item = user_list->add_user();
item->set_user_name(enumerator.userName());
item->set_session_id(enumerator.sessionId());
item->set_session_name(enumerator.sessionName());
item->set_client_name(session_info.clientName());
switch (session_info.connectState())
{
case base::win::SessionInfo::ConnectState::ACTIVE:
item->set_connect_state(proto::task_manager::User::CONNECT_STATE_ACTIVE);
break;
case base::win::SessionInfo::ConnectState::CONNECTED:
item->set_connect_state(proto::task_manager::User::CONNECT_STATE_CONNECTED);
break;
case base::win::SessionInfo::ConnectState::CONNECT_QUERY:
item->set_connect_state(proto::task_manager::User::CONNECT_STATE_CONNECT_QUERY);
break;
case base::win::SessionInfo::ConnectState::SHADOW:
item->set_connect_state(proto::task_manager::User::CONNECT_STATE_SHADOW);
break;
case base::win::SessionInfo::ConnectState::DISCONNECTED:
item->set_connect_state(proto::task_manager::User::CONNECT_STATE_DISCONNECTED);
break;
case base::win::SessionInfo::ConnectState::IDLE:
item->set_connect_state(proto::task_manager::User::CONNECT_STATE_IDLE);
break;
case base::win::SessionInfo::ConnectState::LISTEN:
item->set_connect_state(proto::task_manager::User::CONNECT_STATE_LISTEN);
break;
case base::win::SessionInfo::ConnectState::RESET:
item->set_connect_state(proto::task_manager::User::CONNECT_STATE_RESET);
break;
case base::win::SessionInfo::ConnectState::DOWN:
item->set_connect_state(proto::task_manager::User::CONNECT_STATE_DOWN);
break;
case base::win::SessionInfo::ConnectState::INIT:
item->set_connect_state(proto::task_manager::User::CONNECT_STATE_INIT);
break;
default:
item->set_connect_state(proto::task_manager::User::CONNECT_STATE_UNKNOWN);
break;
}
}
delegate_->onTaskManagerMessage(message);
}
} // namespace host
```
|
```objective-c
#define HAVE_ISSETUGID 1
#define HAVE_STRLCAT 1
#define HAVE_STRLCPY 1
#define HAVE_CLOCK_GETTIME 1
#define HAVE_SOCK_CLOEXEC 1
```
|
```xml
import { Component, OnInit } from '@angular/core';
import { MenuItem, MessageService } from 'primeng/api';
import { Code } from '@domain/code';
@Component({
selector: 'mask-doc',
template: `
<app-docsectiontext>
<p>Adding <i>mask</i> property displays a modal layer behind the popup items.</p>
</app-docsectiontext>
<div class="card">
<div style="height: 350px; position: relative;" class="speeddial-mask-demo">
<p-toast />
<p-speedDial [model]="items" direction="up" [mask]="true" />
</div>
</div>
<app-code [code]="code" selector="speed-dial-mask-demo"></app-code>
`,
providers: [MessageService]
})
export class MaskDoc implements OnInit {
items: MenuItem[] | undefined;
constructor(private messageService: MessageService) {}
ngOnInit() {
this.items = [
{
icon: 'pi pi-pencil',
command: () => {
this.messageService.add({ severity: 'info', summary: 'Add', detail: 'Data Added' });
}
},
{
icon: 'pi pi-refresh',
command: () => {
this.messageService.add({ severity: 'success', summary: 'Update', detail: 'Data Updated' });
}
},
{
icon: 'pi pi-trash',
command: () => {
this.messageService.add({ severity: 'error', summary: 'Delete', detail: 'Data Deleted' });
}
},
{
icon: 'pi pi-upload',
routerLink: ['/fileupload']
},
{
icon: 'pi pi-external-link',
target: '_blank',
url: 'path_to_url
}
];
}
code: Code = {
basic: `<p-speedDial
[model]="items"
direction="up"
[mask]="true" />`,
html: `<div class="card">
<div style="height: 350px; position: relative;" class="speeddial-mask-demo">
<p-toast />
<p-speedDial
[model]="items"
direction="up"
[mask]="true" />
</div>
</div>`,
typescript: `import { Component, OnInit } from '@angular/core';
import { MenuItem, MessageService } from 'primeng/api';
import { SpeedDialModule } from 'primeng/speeddial';
import { ToastModule } from 'primeng/toast';
@Component({
selector: 'speed-dial-mask-demo',
templateUrl: './speed-dial-mask-demo.html',
styles: [
\`:host ::ng-deep {
.speeddial-mask-demo {
.p-speeddial-direction-up {
right: 0;
bottom: 0;
}
}
}\`
],
standalone: true,
imports: [SpeedDialModule, ToastModule],
providers: [MessageService]
})
export class SpeedDialMaskDemo implements OnInit {
items: MenuItem[] | undefined;
constructor(private messageService: MessageService) {}
ngOnInit() {
this.items = [
{
icon: 'pi pi-pencil',
command: () => {
this.messageService.add({ severity: 'info', summary: 'Add', detail: 'Data Added' });
}
},
{
icon: 'pi pi-refresh',
command: () => {
this.messageService.add({ severity: 'success', summary: 'Update', detail: 'Data Updated' });
}
},
{
icon: 'pi pi-trash',
command: () => {
this.messageService.add({ severity: 'error', summary: 'Delete', detail: 'Data Deleted' });
}
},
{
icon: 'pi pi-upload',
routerLink: ['/fileupload']
},
{
icon: 'pi pi-external-link',
target: '_blank',
url: 'path_to_url
}
];
}
}`,
scss: `:host ::ng-deep {
.speeddial-mask-demo {
.p-speeddial-direction-up {
right: 0;
bottom: 0;
}
}
}`
};
}
```
|
Batán Grande is a national park 40 km north east of Chiclayo, in Pitipo District, Ferreñafe Province, of Lambayeque Region of Peru. Primarily the park protects the ancient city of Poma founded by the Lambayeque culture around 800 C.E. This archaeological site was extensively looted throughout the 20th century. The park was established on 16 October 1991 and has a surface area of 134 km2.
The Sican Culture developed between 700 and 1350 on the north coast of Peru. The Lambayeque were a subdivision of the Sican, and appear first in the Batán Grande area.
Before the discovery of the city of Poma, Batán Grande was a farm raising sugar cane.
Reserved zones of Peru
Geography of Lambayeque Region
|
The stratosphere is a region of Earth's upper atmosphere.
Stratosphere may also refer to:
Stratosphere: Conquest of the Skies, a 1998 computer game
"Stratosphere gun", nickname for the U.S. Army 120 mm M1 gun
Stratosphere Las Vegas, a casino hotel in Las Vegas, Nevada
Suzuki Stratosphere, a concept motorcycle
Music
Stratosphere Sound, a recording studio in New York City
Stratosfear, a 1976 album by Tangerine Dream
Stratosphere (Duster album), 1998
Stratosphere (Matt Sorum album), 2014
"Stratosphere", a song by Stratovarius
|
The is a river located in central Yamaguchi Prefecture, in the San'yō region of western Honshū in Japan. It is also written as "鯖川".
Overview
The Saba River is long and has a watershed of . It rises from Mikamine in the Suō Mountains located on the border of Shimane Prefecture, flows further south through Lake Ohara (Sabagawa Dam), crosses the Chūgoku Expressway, turns to the southwest, crosses the northwestern part of Hōfu city, and then flows into the Suō Sea of the Seto Inland Sea. Local governments in the watershed are Hōfu City, Yamaguchi City, and Shūnan City.
Origin of the name
During the early Kamakura period, the Kamakura shogunate earmarked the revenues of Suō Province for use in rebuilding the great national temple of Tōdai-ji in Nara, which had been destroyed during the Genpei War. Tōdai-ji dispatched the noted monk Chōgen in 1186 to raise funds and to procure the necessary timber and other raw materials from the mountains of Saba District in Suō.According to legend, when Chōgen overhear some of the workers complaining that they had not eaten any fish since they left Yamato, he wrote a magical pray on a piece of scrap wood, which turned into a mackerel ("saba") when he tossed it in the river.
Sabagawa Sekimizu
Since ancient times, the Saba River was prone to flooding. Chōgen is recorded to have constructed 118 weirs along its course to control flooding and to facilitate the transport of lumber. All have been destroyed over time through neglect, flooding and typhoon damage, and only the ruins of the first and second weirs located at the Tukuji Funaji neighborhood of Yamaguchi City remain. This weir raised the water level via a shallow dam, and had an opening with a width of approximately 5.4 meters to create a long and narrow waterway for timber flow, with flat stones on the bottom of the river to enable the logs to slide easier. It was designated a National Historic Site of Japan in 1937 as the .
Notani Stone Bath
Another physical remnant of Chōgen's time along this river is the , located about 1.8 kilometers north of the Sabagawa Sekimizu in the Tokuji neighborhood of the city of Yamaguchi, Yamaguchi Prefecture. An ishiburo is a steam bath in which water is poured over heated stones to create a sauna. Chōgen constructed a number of these facilities in order to treat sicknesses and injuries of people engaged in work such as logging and transporting lumber. The Notani facility is the one of many which were once located along the Saba River at the time, and is situated on the south bank of the Shikotani River, a tributary of the Saba River. It consists of a cliff in which a rectangular area 0.9 meters high and 0.6 meter wide and two meters deep has been carved out. It was designated a National Historic Site of Japan in 1935.
See also
List of Historic Sites of Japan (Yamaguchi)
References
External links
Cultural properties of Yamaguchi Prefecture for Sabagawa Sekimizu
Yamaguchi city official site for Notani Stone Bath
Yamaguchi Tourism official site for Notani Stone Bath
Notes
Rivers of Yamaguchi Prefecture
Yamaguchi (city)
Shūnan, Yamaguchi
Hōfu, Yamaguchi
Historic Sites of Japan
Suō Province
History of Yamaguchi Prefecture
Rivers of Japan
|
```javascript
Setting the length of an array
Performing a function at timed intervals
`String.replace`
Infix operators are left-associative
JavaScript compilation
```
|
```smalltalk
namespace Microsoft.MixedReality.Toolkit
{
/// <summary>
/// Generic interface for all optional Mixed Reality systems, components, or features that can be added to the <see cref="MixedRealityServiceConfiguration"/>
/// </summary>
public interface IMixedRealityExtensionService : IMixedRealityService
{
// Empty for now, but it is used to filter out the valid class types in the inspector dropdown.
}
}
```
|
Leif Torvald Halse (7 July 1896 – 8 February 1984) was a Norwegian teacher, novelist, short story writer, children's writer, comics writer and local historian, particularly known for the comics series Vangsgutane.
Biography
He was born in Halsa and grew up in Todal, Surnadal. He was employed at Levanger Teacher School ( Levanger lærerhøgskole) from 1914-17, later working at Hommelvik, where he was a teacher and local historian.
Halse made his literary debut in 1920 with the story collection UIv. He later wrote novels, children's books and local history books. He edited the anthologies Trønderkveld (1943) and I trønder-lag (1944). The comics series Vangsgutane was started in 1940, initiated by the editor of the weekly magazine Nynorsk Vekeblad, Hans Aarnes. Halse wrote the text for the series, which was illustrated by Jens R. Nilssen from 1941 to 1957, and eventually by other illustrators. Halse issued a collection of Vangsgutane almost every year from 1941 to 1982 (except in 1944, 1946 and 1963).
Halse was awarded the King's Medal of Merit in gold (Kongens fortjenstmedalje).
A statue of "Vangsgutane", sculptured by Annasif Døhlen and with a relief of Halse, was unveiled in Todal in 1997.
References
1896 births
1984 deaths
People from Surnadal
Norwegian comics writers
Nynorsk-language writers
Norwegian male novelists
Norwegian children's writers
Norwegian male short story writers
20th-century Norwegian novelists
20th-century Norwegian male writers
Recipients of the King's Medal of Merit in gold
|
Matthew Jeffrey Salganik (born 1976) is an American sociologist and professor of sociology at Princeton University with a special interest on social networks and computational social science.
Career
Salganik received his bachelor's degree in mathematics at Emory University in 1998. He proceeded to get his master's degree in sociology at Cornell University in 2003, where he also lived in the Telluride House. He finished his Ph.D. in sociology (with distinction) at Columbia University in 2007. Salganik was hired by Princeton in 2007 as an assistant professor and was promoted to full professor in 2013. Alongside this, he also currently serves as the Director of the Center for Information Technology Policy. Salganik is affiliated with interdisciplinary research centers at Princeton, such as the Office for Population Research, the Center for Information Technology Policy, the Center for Health and Wellbeing, and the Center for Statistics and Machine Learning. In 2017, he and Chris Bail co-founded Summer Institute in Computational Social Science (SICSS), an annual program that provides learning and research opportunities for students, faculty, and researchers across the world within the realm of data science and social science.
His research has been previously funded by the National Science Foundation, National Institutes of Health, Joint United Nations Programs for HIV/AIDS, Russell Sage Foundation, Sloan Foundation, Facebook, and Google.
Publications
Salganik published his first book Bit by Bit, on December 5, 2017, in which he explores the birth and spread of social media and other digital advancements and how this has ultimately changed the way social scientists and data scientists can conduct research to collect and process data on human behavior.
Other publications include articles in Science, PNAS, Sociological Methodology, and Journal of the American Statistical Association. His work has appeared in The New York Times, Wall Street Journal, Journal Economist, and The New Yorker.
Awards
Salganik won the Outstanding Article Award from the Mathematical Sociology Section of the American Sociological Association in 2005. He won the Outstanding Statistical Application Award from the American Statistical Association in 2008.
Outstanding Article Award (2005)
Outstanding Statistical Application Award (2008)
Google Faculty Research Award (2011)
Leo Goodman Early Career Award (2015).
References
1976 births
Living people
Princeton University faculty
American sociologists
Columbia Graduate School of Arts and Sciences alumni
|
The Journal of Adolescent and Young Adult Oncology is a bimonthly peer-reviewed medical journal covering oncology as it relates to adolescents and young adults. It was established in April 2011 and is published by Mary Ann Liebert, Inc. on behalf of the Society for Adolescent and Young Adult Oncology, of which it is the official journal. Since the journal first launched, its editor-in-chief has been Leonard Sender (Children's Hospital of Orange County). According to the Journal Citation Reports, the journal has a 2016 impact factor of 1.431.
References
External links
Academic journals established in 2011
Oncology journals
Mary Ann Liebert academic journals
English-language journals
Pediatrics journals
Bimonthly journals
|
Insurify is an American insurance comparison shopping website headquartered in Cambridge, Massachusetts. Partnering with insurance companies like Nationwide, Farmers, and Liberty Mutual, Insurify is licensed and operating in all 50 states. The platform has collected more than 100,000 reviews from customers.
History
Insurify was founded in 2013 by Snejina Zacharia, MIT Sloan fellow and Giorgos Zacharia, President of Kayak.com metasearch engine and Tod Kiryazov, CPO, MBA.
In January 2015, the company secured $2M of funding in a seed round led by Rationalwave Capital Partners and other angel investors. The funding was used to officially launch its marketplace website.
Insurify started offering its online insurance quote comparison marketplace publicly in July 2015 in Texas, California, and Florida. The company established relationships with auto insurance carriers and auto insurance brokers that allowed them to provide personalized insurance quotes based on a user's profile, vehicle, and driving history. By January 2016, Insurify had expanded coverage to 30 states. The website lets users type in their zip code, answer questions about their car(s) and driving record and compare auto insurance quotes from major insurance carriers including Liberty Mutual, Metlife, The Travelers Companies, Safeco, The General and Nationwide Mutual Insurance Company. Insurify is officially accredited and operates in all 50 states.
In October 2016, Insurify raised $4.6M of funding in a seed round, led by MassMutual Ventures and Nationwide Ventures and also launched a Facebook Messenger chat bot, which allows users to compare and buy insurance directly from Facebook Messenger.
In January 2020, Insurify announced it raised $23M in Series A funding, led by MTech Capital and Viola FinTech, with support from Hearst Ventures, MassMutual Ventures, and Nationwide.
Operations
Insurify is an auto and home insurance comparison insurance website that uses predictive modeling in order to make shopping for car insurance easier. Insurify is the operator of Evia (Expert Virtual Insurance Agent), which allows users to search for car insurance by texting a photo of their license plate. The company invented RateRank, a proprietary software that matches each driver's profile and risk levels to the best insurance carrier and coverage.
References
Financial services companies of the United States
Financial services companies established in 2013
Internet properties established in 2013
Comparison shopping websites
Companies based in Cambridge, Massachusetts
|
```scss
@import "foobar";
body { color: red; }
```
|
The Officers Quarters are fifteen residences located in eight historic buildings in the Washington Navy Yard. Each individual residence is labelled with a single letter such as Quarters A or Quarters B. They were built at different times but continue to serve as housing for senior officers of the United States Navy.
Quarters A
This house, also known as Tingey House was built around 1804 and was the home of the Commandant of the Navy Yard. It was named after the first Commandant, Captain Thomas Tingey. It is possible that the 2-story brick building was designed by Lovering and Dyer. Unlike most government buildings, it was not seriously damaged during the 1814 Burning of Washington. In 1977, it became the official home of the Chief of Naval Operations.
Quarters B
The first of the quarters to be built in 1801, this housed the second in command of the Yard. As with Quarters A, it was looted but not damaged during the 1814 Burning of Washington.
Quarters C and D
Built in 1878 on top of the former reservoir, these two residences in a three-story brick building housed the Naval Constructor and the Civil Engineer.
Quarters E, F and G
Built around 1837, this building housed the Master of the Yard, the Surgeon, and a Lieutenant. It was smaller than normal for officers of this rank.
Quarters H
Built sometime before 1824, the Gunner quarters were built against the wall separating the Yard from M street. The building was expanded and repaired throughout the late 1800s.
Quarters K, L and M
An octagon building originally built for muster calls, it was modified to house three residences in 1889.
Quarters N, O
Originally a paint shop built in 1865, which also served as a museum, this building was remodeled into two residences in 1891.
Quarters P, Q
Standing next to the Latrobe Gate and the Marine barracks, this building housed the ranking Marine officer in charge of the guard. The building was added to and repaired throughout the late 1800s.
References
External links
United States Navy
Military facilities on the National Register of Historic Places in Washington, D.C.
Federal architecture in Washington, D.C.
Government buildings completed in 1801
Government buildings completed in 1804
|
```xml
import type { JSONSchema7 } from 'json-schema';
import { expect } from 'chai';
import { deepFreeze } from '@stryker-mutator/util';
import { testInjector } from '@stryker-mutator/test-helpers';
import { MetaSchemaBuilder } from '../../../src/config/index.js';
import { coreTokens } from '../../../src/di/index.js';
describe(MetaSchemaBuilder.name, () => {
it('should merge `properties`', () => {
const input: JSONSchema7 = deepFreeze({ properties: { foo: { type: 'string' } } });
const additionalSchema: JSONSchema7 = deepFreeze({ properties: { bar: { type: 'string' } } });
const additionalSchema2: JSONSchema7 = deepFreeze({ properties: { baz: { type: 'number' } } });
const sut = testInjector.injector.provideValue(coreTokens.validationSchema, input).injectClass(MetaSchemaBuilder);
const actual = sut.buildMetaSchema([additionalSchema, additionalSchema2] as Array<Record<string, unknown>>);
expect(actual).deep.eq({ definitions: {}, properties: { ...input.properties, ...additionalSchema.properties, ...additionalSchema2.properties } });
});
it('should merge `definitions`', () => {
const input: JSONSchema7 = deepFreeze({ definitions: { foo: { type: 'string' } } });
const additionalSchema: JSONSchema7 = deepFreeze({ definitions: { bar: { type: 'string' } } });
const additionalSchema2: JSONSchema7 = deepFreeze({ definitions: { baz: { type: 'number' } } });
const sut = testInjector.injector.provideValue(coreTokens.validationSchema, input).injectClass(MetaSchemaBuilder);
const actual = sut.buildMetaSchema([additionalSchema, additionalSchema2] as Array<Record<string, unknown>>);
expect(actual).deep.eq({
properties: {},
definitions: { ...input.definitions, ...additionalSchema.definitions, ...additionalSchema2.definitions },
});
});
});
```
|
Gobitrichinotus is a genus of sand darters, with one species from rivers in Madagascar and another from coastal waters (salt, brackish and fresh) of the western Pacific Ocean.
Species
There are currently two recognized species in this genus:
Gobitrichinotus arnoulti Kiener, 1963
Gobitrichinotus radiocularis Fowler, 1943
References
Kraemeriidae
Gobiidae
Taxonomy articles created by Polbot
|
```javascript
CKEDITOR.plugins.setLang("find","fr-ca",{find:"Rechercher",findOptions:"Options de recherche",findWhat:"Rechercher:",matchCase:"Respecter la casse",matchCyclic:"Recherche cyclique",matchWord:"Mot entier",notFoundMsg:"Le texte indiqu est introuvable.",replace:"Remplacer",replaceAll:"Tout remplacer",replaceSuccessMsg:"%1 remplacements.",replaceWith:"Remplacer par:",title:"Rechercher et remplacer"});
```
|
The remains of the old castle of Kingencleugh or Kingenclough lies close to east of the town of Mauchline, East Ayrshire, in the old Barony of Mauchline off the A76. The castle is Category B listed.
The history of Kingencleugh Castle
From the remains, this appears to have been built as a dwelling with defence as a secondary consideration. John Knox is said to have visited it in 1556. Kingencleugh was built as one of several castles built as border markers for the Campbell feus in the area. Kingencleugh latterly became part of the Ballochmyle estate. The present castle was built around 1620 to replace the older fortification that Knox would have known. The castle was abandoned once the new house was built. The Campbells held the property until the end of the 18th century.
Kingencleugh was the residence successively of Hugh and Robert Campbell, both ardent reformers. George Wishart and John Knox were entertained here and Knox also preached at this castle when he visited Mauchline in 1556. On his death bed it was to Robert Campbell that Knox said: "I rely on you becoming to them (his wife and children) as a husband and a father in my room."
Dobie records that John Knox was conducted by Lochhart of Bar and Campbell of Kineancleugh to Kyle, the ancient receptacle of the Scottish Lollards, where there were a number of adherents to the reformed doctrine. He preached in the houses of Bar, Kineancleugh, Carnell, Ochiltree, and Gadgirth, and in the town of Ayr. In several of these places he also dispensed the Sacrament of Our Lord's Supper.
The castle ruins
The remains lie above the Kingen Cleugh Glen and burn and are those of a four-storey L-shaped residence of ashlar-ended rubble masonry. The remaining walls are 0.8m thick; the two lower floors have slit windows only. The north-west wall, forming the end of the western arm of the 'L', stands to its full height of around 7.0 m, and is surmounted by a crow-stepped gable. The lower part of a corbelled turret remains in the re-entrant angle, in the western arm of which is the entrance. The main ground-floor apartment appears to have been barrel-vaulted. The house is in a fairly defensible situation, overlooking ground sloping to the south. A 'Cleugh' is a narrow gorge or chasm with high rocky sides in Scots. Jerviston House is of a very similar design.
Kingencleugh overlooks the Lily or Kingen Cleugh Glen and the burn that runs into the nearby River Ayr. Local tradition states that a subterranean passage or ley tunnel runs between Mauchline Castle and Kingencleugh.
The Lily Glen and Robert Burns
The Lily Glen or Kingen Cleugh Glen contains a small rivulet that runs down to the River Ayr. The lilies usually refer to daffodils in Scots, however lily can also be a general term for wild garlic or bluebells. The glen is rich in old woodland indicator plants such as woodruff, wood sorrel, bluebell, woodrush, cow wheat, enchanter's nightshade, creeping jenny, wood millet, dog's mercury, etc.
Local tradition maintains that Robert Burns used to visit the glen to enjoy a dip in the Kingencleugh Burn when he lived at Mossgiel Farm near Mauchline. An old stone bath or cistern still exists with moss covered steps running down to it. Locals would point out this site as being his bathing place and a vague memory of a Lady Sophia is also associated with this site. Burns is known to have frequented the area and he praised these 'Braes of Ballochmyle' in his poem to The Lass of Ballochmyle who he observed in the half-twilight near the site of the old 'Fog House.'
The OS maps show a stone bath or cistern at the bottom of the Kingen Cleugh Glen where all the burn waters were diverted into it, leaving via a tunnel cut through the rock and then running down the Haugh hamlet, situated about two and a half miles downstream from Catrine, on the north bank of the River Ayr. In 1837 there was a woollen mill, and a corn and saw mill, drawing water from the aforementioned cistern, about a quarter of a mile upstream. The lade was tunnelled through the soft red sandstone of the river gorge, and the tunnel mouths can both be seen, as can two stone arched footbridges over the lade, and an overflow sluice. No trace traces of the woollen mill, which in 1837 employed thirty persons Spinning yarn for a Kilmarnock carpet factory, have survived.
Kingencleugh House
The present day manor house was erected around 1765 and later rebuilt to plans by Mervyn Noad as a dower house to Ballochmyle in 1957. An elephant was the family crest and this appears over the door.
Cartographic evidence
Robert Gordon's map of 1636–52 shows Kinzancleuch (sic). Kinzankcleug is recorded on the Timothy Pont map of circa 1602. Moll records a Monfod. Roy's map of 1747 shows the castle as 'Kings Cleugh'. Armstrong's map of 1775 shows the old castle ruins as 'Kingincleugh' with the house nearby. Thomson's map of 1832 shows 'Kingscleugh'.
Associated families
The Campbells
The Campbells, cadets of the Campbells of Cessnock and Loudoun, are the first recorded lairds in the fifteenth century. Hugh Campbell may have been the son of Sir George Campbell of Loudoun and his mentioned by John Knox in connection with George Wishart being refused entry to preach in the kirk of Mauchline by those opposing reform. Robert Campbell of Kingencleugh (d. 1574) stood surety for a friend who was implicated in the plot that led to the murder of David Rizzio and was a good friend of John Knox as previously stated, and attended him during his final illness. He had a daughter, Elizabeth, and married Elizabeth Campbell. This daughter inherited the lands and castle in 1586 and had a son, John, however the name of her husband is not recorded.
The "Memorial" to the couple by John Davidson reads :
John Campbell of Kingencleugh became heir to his mother in 1627 and to his grandfather in 1636; he may have had a brother in joint possession as a Charles Campbell of Kingencleugh is recorded in 1625. John Craufurd of Craufurdland's daughter Agnes married John Campbell of Kingencleugh, son of the previous John, and the couple had two sons, Hugh and George, and a daughter. Hugh inherited and married Elizabeith, the daughter of Sir Hugh Campbell of Cessnock. His son John inherited and married Elizabeth Adair, daughter of the minister of Ayr. His heir was another John, a zealous elder of the kirk, who married Anna Kennedy of Daljarroch. He died circa 1752 and their daughter married a Mr. McGill; the couple had no offspring.
In 1781 John Howie of Lochgoin records, as stated, that Hugh Campbell of Kinzeancleuch, younger son of Sir George Campbell of Loudoun, was a strong supporter of the Reformation and entertained fellow adherents at his residence. Circa 1539 the Sheriff of Ayr sent troops to Mauchline church so as to prevent the reformist George Wishart from preaching and Hugh Campbell and others had intended to force entry however Wishart declined the offer and preached instead on Mauchline Muir close to the old loch.
The Campbells of Kingancleuch (sic) are frequently mention in the records occur until the late 18th century.
The Alexanders
On the death of the last Campbell of Kingencleugh, Mrs McGill, Mr. Alexander of Ballochmyle purchased the property. Alexander, later Hagart-Alexander Baronetcy, of Ballochmyle is a title created in 1886 for Major-General Claud Alexander, who served in the Crimean War. Sir Claud Hagart-Alexander, 4th Baronet (b. 1963), now lives at Kingencleugh House, the family having long left Ballochmyle House which they had acquired in 1785.
A Legend of Kingcleugh Castle
In 1253 Sir Percy Seton fell in love with Mona, the daughter of the 'rude and almost savage' Cormac of the Cleugh, Laird of Kingcleugh, known as 'King of the Cleugh' or the 'Hunter King'. Cormac refused to allow Sir Percy to marry his daughter. Cormac was obsessed with the sport of hunting wild boar in the woods to the west of Kingcleugh. The skins and heads of his many kills over the years were kept at trophies within one the vaults in the castle. One day, whilst hunting boar in the forest of Kolium, some miles to the west of his castle, near the River Ayr, he chanced upon the deep and secluded lair of an exceptional boar.
This ferocious creature however killed all his boar-hounds. The laird attempted to force his head huntsman to enter the animal's den and upon refusal he hit him with his boar-spear, knocking him off balance, resulting in the retainers terrible death at the 'tusks' of the creature after falling into the boars lair. The laird was superstitious and believed that the dead man's spirit and the ghost of the boar haunted the vault of his castle. Sir Percy hit upon the plan of using the ley tunnel that ran between the castle of Mauchline and that of Kingcleugh to enter the vault, and Mona, having been informed of the plot, ensured that her forced wedding to a man chosen by her father, was close to the vault. At the critical point in the ceremony the bloodied ghost of the dead huntsman appeared to burst forth from the sealed vault. The apparition seized the bride and then secretly carried her away to Mauchline Castle, via the tunnel, in the arms of her beloved.
Micro-history
Lady Cecilia Brabazon, aunt of Mr Alexander of Ballochmyle, lived for many years in a cottage (Kingencleugh House?) near the old castle tower of Kingencleugh.
Miss Wilhelmina Alexander of Ballochmyle is Robert Burns' Bonnie Lass of Ballochmyle who he observed in the half-twilight near Ballochmyle House in the Braes of Ballochmyle. The old 'Fog House' was said to mark the site of his sighting of her. Wilhelmina never married and kept the poet's letter and manuscript all of her life.
The lands of Over and Nether Haugh became known as Kinzeancleuche or Kingencleugh.
A prisoner of war camp was located at Kingencleugh.
Robert Burns' father in law is said to have been involved in the building of the old 1750 Howford Bridge that lies below the site of Catrine House.
The famous Ballochmyle cup and ring marks are located on the estate.
See also
List of castles in East Ayrshire
List of listed buildings in Mauchline, East Ayrshire
References
Notes
Sources
Bonar, Rev Andrew A. (1879). The Scots Worthies according to Howie's Second Edition, 1781. Glasgow : McGready, Thomson & Dunedin.
Campbell, Thorbjørn (2003). Ayrshire. A Historical Guide. Edinburgh : Birlinn. .
Coventry, Martin (2010). Castles of the Clans. Musselburgh : Goblinshead. .
Cuthbertson, D. C. Autumn in Kyle and the Charm of Cunninghame. London : Herbert Jenkins.
Dobie, James D. (ed Dobie, J.S.) (1876). Cunninghame, Topographized by Timothy Pont 1604–1608, with continuations and illustrative notices. Glasgow: John Tweed.
Ingram, John (1844). The Spectre Huntsman. The Ayrshire Wreath MDCCCXLIV.
Love, Dane (2003). Ayrshire : Discovering a County. Ayr : Fort Publishing. .
Love, Dane (2010). The River Ayr Way. Auchinleck : Carn. .
Paterson, James (1866). History of the Counties of Ayrs and Wigton. Vol. IV. Cuninghame. Parts 1 & 2. Edinburgh : James Stillie.
Robertson, George (1823). A Genealogical Account of the Principal Families in Ayrshire, more particularly in Cunninghame. Irvine.
Salter, Mike (2006). The Castles of South-West Scotland. Malvern : Folly. .
External links
Kingencleugh Glen & castle
Castles in East Ayrshire
Archaeological sites in East Ayrshire
Demolished buildings and structures in Scotland
1620s establishments in Scotland
Mauchline
Category B listed buildings in East Ayrshire
|
```javascript
export default function camelCaseSplit(str) {
function isUpperCase(str) {
return str.toUpperCase() === str;
}
const words = [];
let word = '';
for (let i = 0; i < str.length; i++) {
const c = str.charAt(i);
if (c === '_' || c === '-') {
continue;
}
const dot = c === '.';
if ((dot || isUpperCase(c)) && word.length !== 0) {
words.push(word);
word = '';
}
if (!dot) word += c;
}
if (word.length !== 0){
words.push(word);
}
return words;
}
export function camelCaseSplitToStr(str) {
const words = camelCaseSplit(str);
if (words.length !== 0) {
return words.map(w => w.toLowerCase()).join(' ');
}
return str;
}
```
|
```smalltalk
using Chloe.DbExpressions;
namespace Chloe.RDBMS.MethodHandlers
{
public class TrimEnd_HandlerBase : MethodHandlerBase
{
public override bool CanProcess(DbMethodCallExpression exp)
{
if (exp.Method != PublicConstants.MethodInfo_String_TrimEnd)
return false;
return true;
}
}
}
```
|
```javascript
tinymce.addI18n('pl',{
"Redo": "Pon\u00f3w",
"Undo": "Cofnij",
"Cut": "Wytnij",
"Copy": "Kopiuj",
"Paste": "Wklej",
"Select all": "Zaznacz wszystko",
"New document": "Nowy dokument",
"Ok": "Ok",
"Cancel": "Anuluj",
"Visual aids": "Pomoce wizualne",
"Bold": "Pogrubienie",
"Italic": "Kursywa",
"Underline": "Podkre\u015blenie",
"Strikethrough": "Przekre\u015blenie",
"Superscript": "Indeks g\u00f3rny",
"Subscript": "Indeks dolny",
"Clear formatting": "Wyczy\u015b\u0107 formatowanie",
"Align left": "Wyr\u00f3wnaj do lewej",
"Align center": "Wyr\u00f3wnaj do \u015brodka",
"Align right": "Wyr\u00f3wnaj do prawej",
"Justify": "Do lewej i prawej",
"Bullet list": "Lista wypunktowana",
"Numbered list": "Lista numerowana",
"Decrease indent": "Zmniejsz wci\u0119cie",
"Increase indent": "Zwi\u0119ksz wci\u0119cie",
"Close": "Zamknij",
"Formats": "Formaty",
"Your browser doesn't support direct access to the clipboard. Please use the Ctrl+X\/C\/V keyboard shortcuts instead.": "Twoja przegl\u0105darka nie obs\u0142uguje bezpo\u015bredniego dost\u0119pu do schowka. U\u017cyj zamiast tego kombinacji klawiszy Ctrl+X\/C\/V.",
"Headers": "Nag\u0142\u00f3wki",
"Header 1": "Nag\u0142\u00f3wek 1",
"Header 2": "Nag\u0142\u00f3wek 2",
"Header 3": "Nag\u0142\u00f3wek 3",
"Header 4": "Nag\u0142\u00f3wek 4",
"Header 5": "Nag\u0142\u00f3wek 5",
"Header 6": "Nag\u0142\u00f3wek 6",
"Headings": "Nag\u0142\u00f3wki",
"Heading 1": "Nag\u0142\u00f3wek 1",
"Heading 2": "Nag\u0142\u00f3wek 2",
"Heading 3": "Nag\u0142\u00f3wek 3",
"Heading 4": "Nag\u0142\u00f3wek 4",
"Heading 5": "Nag\u0142\u00f3wek 5",
"Heading 6": "Nag\u0142\u00f3wek 6",
"Div": "Div",
"Pre": "Sformatowany tekst",
"Code": "Kod \u017ar\u00f3d\u0142owy",
"Paragraph": "Akapit",
"Blockquote": "Blok cytatu",
"Inline": "W tek\u015bcie",
"Blocks": "Bloki",
"Paste is now in plain text mode. Contents will now be pasted as plain text until you toggle this option off.": "Wklejanie jest w trybie tekstowym. Zawarto\u015b\u0107 zostanie wklejona jako zwyk\u0142y tekst dop\u00f3ki nie wy\u0142\u0105czysz tej opcji.",
"Font Family": "Kr\u00f3j fontu",
"Font Sizes": "Rozmiar fontu",
"Class": "Klasa",
"Browse for an image": "Przegl\u0105daj za zdj\u0119ciem",
"OR": "OR",
"Drop an image here": "Upu\u015b\u0107 obraz tutaj",
"Upload": "Prze\u015blij",
"Block": "Zablokuj",
"Align": "Wyr\u00f3wnaj",
"Default": "Domy\u015blne",
"Circle": "K\u00f3\u0142ko",
"Disc": "Dysk",
"Square": "Kwadrat",
"Lower Alpha": "Ma\u0142e litery",
"Lower Greek": "Ma\u0142e greckie",
"Lower Roman": "Ma\u0142e rzymskie",
"Upper Alpha": "Wielkie litery",
"Upper Roman": "Wielkie rzymskie",
"Anchor": "Kotwica",
"Name": "Nazwa",
"Id": "Identyfikator",
"Id should start with a letter, followed only by letters, numbers, dashes, dots, colons or underscores.": "Identyfikator powinien zaczyna\u0107 si\u0119 liter\u0105, dozwolone s\u0105 tylko litery, numery, uko\u015bniki, kropki, dwukropki i podkre\u015blniki - tzw. pod\u0142ogi",
"You have unsaved changes are you sure you want to navigate away?": "Masz niezapisane zmiany. Czy na pewno chcesz opu\u015bci\u0107 stron\u0119?",
"Restore last draft": "Przywr\u00f3\u0107 ostatni szkic",
"Special character": "Znak specjalny",
"Source code": "Kod \u017ar\u00f3d\u0142owy",
"Insert\/Edit code sample": "Dodaj\/Edytuj przyk\u0142adowy kod",
"Language": "J\u0119zyk",
"Code sample": "Przyk\u0142ad kodu \u017ar\u00f3d\u0142owego",
"Color": "Kolor",
"R": "R",
"G": "G",
"B": "B",
"Left to right": "Od lewej do prawej",
"Right to left": "Od prawej do lewej",
"Emoticons": "Ikony emocji",
"Document properties": "W\u0142a\u015bciwo\u015bci dokumentu",
"Title": "Tytu\u0142",
"Keywords": "S\u0142owa kluczowe",
"Description": "Opis",
"Robots": "Roboty",
"Author": "Autor",
"Encoding": "Kodowanie",
"Fullscreen": "Pe\u0142ny ekran",
"Action": "Akcja",
"Shortcut": "Skr\u00f3t",
"Help": "Pomoc",
"Address": "Adres",
"Focus to menubar": "Skup si\u0119 na pasku menu",
"Focus to toolbar": "Skupi\u0107 si\u0119 na pasku",
"Focus to element path": "Skup si\u0119 na \u015bcie\u017cce elementu",
"Focus to contextual toolbar": "Skupi\u0107 si\u0119 na pasku narz\u0119dzi kontekstowych",
"Insert link (if link plugin activated)": "Wstaw \u0142\u0105cze (je\u015bli w\u0142\u0105czysz wtyczk\u0119 link\u00f3w)",
"Save (if save plugin activated)": "Zapisz (je\u015bli aktywowana jest wtyczka do zapisu)",
"Find (if searchreplace plugin activated)": "Znajd\u017a (je\u015bli w\u0142\u0105czysz wtyczk\u0119 do wyszukiwania)",
"Plugins installed ({0}):": "Zainstalowane wtyczki ({0}):",
"Premium plugins:": "Wtyczki Premium:",
"Learn more...": "Dowiedz si\u0119 wi\u0119cej...",
"You are using {0}": "U\u017cywasz {0}",
"Plugins": "Pluginy",
"Handy Shortcuts": "Przydatne skr\u00f3ty",
"Horizontal line": "Pozioma linia",
"Insert\/edit image": "Wstaw\/edytuj obrazek",
"Image description": "Opis obrazka",
"Source": "\u0179r\u00f3d\u0142o",
"Dimensions": "Wymiary",
"Constrain proportions": "Zachowaj proporcje",
"General": "Og\u00f3lne",
"Advanced": "Zaawansowane",
"Style": "Styl",
"Vertical space": "Odst\u0119p pionowy",
"Horizontal space": "Odst\u0119p poziomy",
"Border": "Ramka",
"Insert image": "Wstaw obrazek",
"Image": "Obraz",
"Image list": "Lista obrazk\u00f3w",
"Rotate counterclockwise": "Obr\u00f3\u0107 w lewo",
"Rotate clockwise": "Obr\u00f3\u0107 w prawo",
"Flip vertically": "Przerzu\u0107 w pionie",
"Flip horizontally": "Przerzu\u0107 w poziomie",
"Edit image": "Edytuj obrazek",
"Image options": "Opcje obrazu",
"Zoom in": "Powi\u0119ksz",
"Zoom out": "Pomniejsz",
"Crop": "Przytnij",
"Resize": "Zmiana rozmiaru",
"Orientation": "Orientacja",
"Brightness": "Jasno\u015b\u0107",
"Sharpen": "Wyostrz",
"Contrast": "Kontrast",
"Color levels": "Poziom koloru",
"Gamma": "Gamma",
"Invert": "Odwr\u00f3\u0107",
"Apply": "Zaakceptuj",
"Back": "Cofnij",
"Insert date\/time": "Wstaw dat\u0119\/czas",
"Date\/time": "Data\/Czas",
"Insert link": "Wstaw \u0142\u0105cze",
"Insert\/edit link": "Wstaw\/edytuj \u0142\u0105cze",
"Text to display": "Tekst do wy\u015bwietlenia",
"Url": "URL",
"Target": "Cel",
"None": "\u017baden",
"New window": "Nowe okno",
"Remove link": "Usu\u0144 \u0142\u0105cze",
"Anchors": "Kotwice",
"Link": "Adres \u0142\u0105cza",
"Paste or type a link": "Wklej lub wpisz adres \u0142\u0105cza",
"The URL you entered seems to be an email address. Do you want to add the required mailto: prefix?": "URL, kt\u00f3ry wprowadzi\u0142e\u015b wygl\u0105da na adres e-mail. Czy chcesz doda\u0107 mailto: jako prefiks?",
"The URL you entered seems to be an external link. Do you want to add the required http:\/\/ prefix?": "URL, kt\u00f3ry wprowadzi\u0142e\u015b wygl\u0105da na link zewn\u0119trzny. Czy chcesz doda\u0107 http:\/\/ jako prefiks?",
"Link list": "Lista link\u00f3w",
"Insert video": "Wstaw wideo",
"Insert\/edit video": "Wstaw\/edytuj wideo",
"Insert\/edit media": "Wstaw\/Edytuj media",
"Alternative source": "Alternatywne \u017ar\u00f3d\u0142o",
"Poster": "Plakat",
"Paste your embed code below:": "Wklej tutaj kod do osadzenia:",
"Embed": "Osad\u017a",
"Media": "Media",
"Nonbreaking space": "Nie\u0142amliwa spacja",
"Page break": "Podzia\u0142 strony",
"Paste as text": "Wklej jako zwyk\u0142y tekst",
"Preview": "Podgl\u0105d",
"Print": "Drukuj",
"Save": "Zapisz",
"Find": "Znajd\u017a",
"Replace with": "Zamie\u0144 na",
"Replace": "Zamie\u0144",
"Replace all": "Zamie\u0144 wszystko",
"Prev": "Poprz.",
"Next": "Nast.",
"Find and replace": "Znajd\u017a i zamie\u0144",
"Could not find the specified string.": "Nie znaleziono szukanego tekstu.",
"Match case": "Dopasuj wielko\u015b\u0107 liter",
"Whole words": "Ca\u0142e s\u0142owa",
"Spellcheck": "Sprawdzanie pisowni",
"Ignore": "Ignoruj",
"Ignore all": "Ignoruj wszystko",
"Finish": "Zako\u0144cz",
"Add to Dictionary": "Dodaj do s\u0142ownika",
"Insert table": "Wstaw tabel\u0119",
"Table properties": "W\u0142a\u015bciwo\u015bci tabeli",
"Delete table": "Usu\u0144 tabel\u0119",
"Cell": "Kom\u00f3rka",
"Row": "Wiersz",
"Column": "Kolumna",
"Cell properties": "W\u0142a\u015bciwo\u015bci kom\u00f3rki",
"Merge cells": "\u0141\u0105cz kom\u00f3rki",
"Split cell": "Podziel kom\u00f3rk\u0119",
"Insert row before": "Wstaw wiersz przed",
"Insert row after": "Wstaw wiersz po",
"Delete row": "Usu\u0144 wiersz",
"Row properties": "W\u0142a\u015bciwo\u015bci wiersza",
"Cut row": "Wytnij wiersz",
"Copy row": "Kopiuj wiersz",
"Paste row before": "Wklej wiersz przed",
"Paste row after": "Wklej wiersz po",
"Insert column before": "Wstaw kolumn\u0119 przed",
"Insert column after": "Wstaw kolumn\u0119 po",
"Delete column": "Usu\u0144 kolumn\u0119",
"Cols": "Kol.",
"Rows": "Wiersz.",
"Width": "Szeroko\u015b\u0107",
"Height": "Wysoko\u015b\u0107",
"Cell spacing": "Odst\u0119py kom\u00f3rek",
"Cell padding": "Dope\u0142nienie kom\u00f3rki",
"Caption": "Tytu\u0142",
"Left": "Lewo",
"Center": "\u015arodek",
"Right": "Prawo",
"Cell type": "Typ kom\u00f3rki",
"Scope": "Kontekst",
"Alignment": "Wyr\u00f3wnanie",
"H Align": "Wyr\u00f3wnanie w pionie",
"V Align": "Wyr\u00f3wnanie w poziomie",
"Top": "G\u00f3ra",
"Middle": "\u015arodek",
"Bottom": "D\u00f3\u0142",
"Header cell": "Kom\u00f3rka nag\u0142\u00f3wka",
"Row group": "Grupa wierszy",
"Column group": "Grupa kolumn",
"Row type": "Typ wiersza",
"Header": "Nag\u0142\u00f3wek",
"Body": "Tre\u015b\u0107",
"Footer": "Stopka",
"Border color": "Kolor ramki",
"Insert template": "Wstaw szablon",
"Templates": "Szablony",
"Template": "Szablon",
"Text color": "Kolor tekstu",
"Background color": "Kolor t\u0142a",
"Custom...": "Niestandardowy...",
"Custom color": "Kolor niestandardowy",
"No color": "Bez koloru",
"Table of Contents": "Spis tre\u015bci",
"Show blocks": "Poka\u017c bloki",
"Show invisible characters": "Poka\u017c niewidoczne znaki",
"Words: {0}": "S\u0142\u00f3w: {0}",
"{0} words": "{0} s\u0142\u00f3w",
"File": "Plik",
"Edit": "Edycja",
"Insert": "Wstaw",
"View": "Widok",
"Format": "Format",
"Table": "Tabela",
"Tools": "Narz\u0119dzia",
"Powered by {0}": "Powered by {0}",
"Rich Text Area. Press ALT-F9 for menu. Press ALT-F10 for toolbar. Press ALT-0 for help": "Obszar Edycji. ALT-F9 - menu. ALT-F10 - pasek narz\u0119dzi. ALT-0 - pomoc"
});
```
|
```javascript
require('./angular');
module.exports = angular;
```
|
```go
//
//
// path_to_url
//
// Unless required by applicable law or agreed to in writing, software
// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
// Package client implements a client for the Pulumi Service HTTP/REST API.
// Important note: This client is not versioned, and not intended for external use at this time.
package client
```
|
```makefile
PKG_NAME="vfs.sftp"
PKG_VERSION="20.2.0-Nexus"
PKG_SHA256=your_sha256_hash
PKG_REV="5"
PKG_ARCH="any"
PKG_LICENSE="GPLv2"
PKG_SITE="path_to_url"
PKG_URL="path_to_url{PKG_VERSION}.tar.gz"
PKG_DEPENDS_TARGET="toolchain kodi-platform libssh"
PKG_SECTION=""
PKG_SHORTDESC="vfs.sftp"
PKG_LONGDESC="vfs.sftp"
PKG_IS_ADDON="yes"
PKG_ADDON_TYPE="kodi.vfs"
```
|
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.