@aws-sdk/client-pinpoint 3.34.0 → 3.35.0

package/dist-types/commands/GetBaiduChannelCommand.d.ts

@@ -0,0 +1,35 @@
+import { Command as $Command } from "@aws-sdk/smithy-client";
+import { Handler, HttpHandlerOptions as __HttpHandlerOptions, MetadataBearer as __MetadataBearer, MiddlewareStack } from "@aws-sdk/types";
+import { GetBaiduChannelRequest, GetBaiduChannelResponse } from "../models/models_0";
+import { PinpointClientResolvedConfig, ServiceInputTypes, ServiceOutputTypes } from "../PinpointClient";
+export interface GetBaiduChannelCommandInput extends GetBaiduChannelRequest {
+}
+export interface GetBaiduChannelCommandOutput extends GetBaiduChannelResponse, __MetadataBearer {
+}
+/**
+ * <p>Retrieves information about the status and settings of the Baidu channel for an application.</p>
+ * @example
+ * Use a bare-bones client and the command you need to make an API call.
+ * ```javascript
+ * import { PinpointClient, GetBaiduChannelCommand } from "@aws-sdk/client-pinpoint"; // ES Modules import
+ * // const { PinpointClient, GetBaiduChannelCommand } = require("@aws-sdk/client-pinpoint"); // CommonJS import
+ * const client = new PinpointClient(config);
+ * const command = new GetBaiduChannelCommand(input);
+ * const response = await client.send(command);
+ * ```
+ *
+ * @see {@link GetBaiduChannelCommandInput} for command's `input` shape.
+ * @see {@link GetBaiduChannelCommandOutput} for command's `response` shape.
+ * @see {@link PinpointClientResolvedConfig | config} for command's `input` shape.
+ *
+ */
+export declare class GetBaiduChannelCommand extends $Command<GetBaiduChannelCommandInput, GetBaiduChannelCommandOutput, PinpointClientResolvedConfig> {
+    readonly input: GetBaiduChannelCommandInput;
+    constructor(input: GetBaiduChannelCommandInput);
+    /**
+     * @internal
+     */
+    resolveMiddleware(clientStack: MiddlewareStack<ServiceInputTypes, ServiceOutputTypes>, configuration: PinpointClientResolvedConfig, options?: __HttpHandlerOptions): Handler<GetBaiduChannelCommandInput, GetBaiduChannelCommandOutput>;
+    private serialize;
+    private deserialize;
+}

package/dist-types/commands/GetCampaignActivitiesCommand.d.ts

@@ -0,0 +1,35 @@
+import { Command as $Command } from "@aws-sdk/smithy-client";
+import { Handler, HttpHandlerOptions as __HttpHandlerOptions, MetadataBearer as __MetadataBearer, MiddlewareStack } from "@aws-sdk/types";
+import { GetCampaignActivitiesRequest, GetCampaignActivitiesResponse } from "../models/models_0";
+import { PinpointClientResolvedConfig, ServiceInputTypes, ServiceOutputTypes } from "../PinpointClient";
+export interface GetCampaignActivitiesCommandInput extends GetCampaignActivitiesRequest {
+}
+export interface GetCampaignActivitiesCommandOutput extends GetCampaignActivitiesResponse, __MetadataBearer {
+}
+/**
+ * <p>Retrieves information about all the activities for a campaign.</p>
+ * @example
+ * Use a bare-bones client and the command you need to make an API call.
+ * ```javascript
+ * import { PinpointClient, GetCampaignActivitiesCommand } from "@aws-sdk/client-pinpoint"; // ES Modules import
+ * // const { PinpointClient, GetCampaignActivitiesCommand } = require("@aws-sdk/client-pinpoint"); // CommonJS import
+ * const client = new PinpointClient(config);
+ * const command = new GetCampaignActivitiesCommand(input);
+ * const response = await client.send(command);
+ * ```
+ *
+ * @see {@link GetCampaignActivitiesCommandInput} for command's `input` shape.
+ * @see {@link GetCampaignActivitiesCommandOutput} for command's `response` shape.
+ * @see {@link PinpointClientResolvedConfig | config} for command's `input` shape.
+ *
+ */
+export declare class GetCampaignActivitiesCommand extends $Command<GetCampaignActivitiesCommandInput, GetCampaignActivitiesCommandOutput, PinpointClientResolvedConfig> {
+    readonly input: GetCampaignActivitiesCommandInput;
+    constructor(input: GetCampaignActivitiesCommandInput);
+    /**
+     * @internal
+     */
+    resolveMiddleware(clientStack: MiddlewareStack<ServiceInputTypes, ServiceOutputTypes>, configuration: PinpointClientResolvedConfig, options?: __HttpHandlerOptions): Handler<GetCampaignActivitiesCommandInput, GetCampaignActivitiesCommandOutput>;
+    private serialize;
+    private deserialize;
+}

package/dist-types/commands/GetCampaignCommand.d.ts

@@ -0,0 +1,35 @@
+import { Command as $Command } from "@aws-sdk/smithy-client";
+import { Handler, HttpHandlerOptions as __HttpHandlerOptions, MetadataBearer as __MetadataBearer, MiddlewareStack } from "@aws-sdk/types";
+import { GetCampaignRequest, GetCampaignResponse } from "../models/models_0";
+import { PinpointClientResolvedConfig, ServiceInputTypes, ServiceOutputTypes } from "../PinpointClient";
+export interface GetCampaignCommandInput extends GetCampaignRequest {
+}
+export interface GetCampaignCommandOutput extends GetCampaignResponse, __MetadataBearer {
+}
+/**
+ * <p>Retrieves information about the status, configuration, and other settings for a campaign.</p>
+ * @example
+ * Use a bare-bones client and the command you need to make an API call.
+ * ```javascript
+ * import { PinpointClient, GetCampaignCommand } from "@aws-sdk/client-pinpoint"; // ES Modules import
+ * // const { PinpointClient, GetCampaignCommand } = require("@aws-sdk/client-pinpoint"); // CommonJS import
+ * const client = new PinpointClient(config);
+ * const command = new GetCampaignCommand(input);
+ * const response = await client.send(command);
+ * ```
+ *
+ * @see {@link GetCampaignCommandInput} for command's `input` shape.
+ * @see {@link GetCampaignCommandOutput} for command's `response` shape.
+ * @see {@link PinpointClientResolvedConfig | config} for command's `input` shape.
+ *
+ */
+export declare class GetCampaignCommand extends $Command<GetCampaignCommandInput, GetCampaignCommandOutput, PinpointClientResolvedConfig> {
+    readonly input: GetCampaignCommandInput;
+    constructor(input: GetCampaignCommandInput);
+    /**
+     * @internal
+     */
+    resolveMiddleware(clientStack: MiddlewareStack<ServiceInputTypes, ServiceOutputTypes>, configuration: PinpointClientResolvedConfig, options?: __HttpHandlerOptions): Handler<GetCampaignCommandInput, GetCampaignCommandOutput>;
+    private serialize;
+    private deserialize;
+}

package/dist-types/commands/GetCampaignDateRangeKpiCommand.d.ts

@@ -0,0 +1,35 @@
+import { Command as $Command } from "@aws-sdk/smithy-client";
+import { Handler, HttpHandlerOptions as __HttpHandlerOptions, MetadataBearer as __MetadataBearer, MiddlewareStack } from "@aws-sdk/types";
+import { GetCampaignDateRangeKpiRequest, GetCampaignDateRangeKpiResponse } from "../models/models_0";
+import { PinpointClientResolvedConfig, ServiceInputTypes, ServiceOutputTypes } from "../PinpointClient";
+export interface GetCampaignDateRangeKpiCommandInput extends GetCampaignDateRangeKpiRequest {
+}
+export interface GetCampaignDateRangeKpiCommandOutput extends GetCampaignDateRangeKpiResponse, __MetadataBearer {
+}
+/**
+ * <p>Retrieves (queries) pre-aggregated data for a standard metric that applies to a campaign.</p>
+ * @example
+ * Use a bare-bones client and the command you need to make an API call.
+ * ```javascript
+ * import { PinpointClient, GetCampaignDateRangeKpiCommand } from "@aws-sdk/client-pinpoint"; // ES Modules import
+ * // const { PinpointClient, GetCampaignDateRangeKpiCommand } = require("@aws-sdk/client-pinpoint"); // CommonJS import
+ * const client = new PinpointClient(config);
+ * const command = new GetCampaignDateRangeKpiCommand(input);
+ * const response = await client.send(command);
+ * ```
+ *
+ * @see {@link GetCampaignDateRangeKpiCommandInput} for command's `input` shape.
+ * @see {@link GetCampaignDateRangeKpiCommandOutput} for command's `response` shape.
+ * @see {@link PinpointClientResolvedConfig | config} for command's `input` shape.
+ *
+ */
+export declare class GetCampaignDateRangeKpiCommand extends $Command<GetCampaignDateRangeKpiCommandInput, GetCampaignDateRangeKpiCommandOutput, PinpointClientResolvedConfig> {
+    readonly input: GetCampaignDateRangeKpiCommandInput;
+    constructor(input: GetCampaignDateRangeKpiCommandInput);
+    /**
+     * @internal
+     */
+    resolveMiddleware(clientStack: MiddlewareStack<ServiceInputTypes, ServiceOutputTypes>, configuration: PinpointClientResolvedConfig, options?: __HttpHandlerOptions): Handler<GetCampaignDateRangeKpiCommandInput, GetCampaignDateRangeKpiCommandOutput>;
+    private serialize;
+    private deserialize;
+}

package/dist-types/commands/GetCampaignVersionCommand.d.ts

@@ -0,0 +1,35 @@
+import { Command as $Command } from "@aws-sdk/smithy-client";
+import { Handler, HttpHandlerOptions as __HttpHandlerOptions, MetadataBearer as __MetadataBearer, MiddlewareStack } from "@aws-sdk/types";
+import { GetCampaignVersionRequest, GetCampaignVersionResponse } from "../models/models_0";
+import { PinpointClientResolvedConfig, ServiceInputTypes, ServiceOutputTypes } from "../PinpointClient";
+export interface GetCampaignVersionCommandInput extends GetCampaignVersionRequest {
+}
+export interface GetCampaignVersionCommandOutput extends GetCampaignVersionResponse, __MetadataBearer {
+}
+/**
+ * <p>Retrieves information about the status, configuration, and other settings for a specific version of a campaign.</p>
+ * @example
+ * Use a bare-bones client and the command you need to make an API call.
+ * ```javascript
+ * import { PinpointClient, GetCampaignVersionCommand } from "@aws-sdk/client-pinpoint"; // ES Modules import
+ * // const { PinpointClient, GetCampaignVersionCommand } = require("@aws-sdk/client-pinpoint"); // CommonJS import
+ * const client = new PinpointClient(config);
+ * const command = new GetCampaignVersionCommand(input);
+ * const response = await client.send(command);
+ * ```
+ *
+ * @see {@link GetCampaignVersionCommandInput} for command's `input` shape.
+ * @see {@link GetCampaignVersionCommandOutput} for command's `response` shape.
+ * @see {@link PinpointClientResolvedConfig | config} for command's `input` shape.
+ *
+ */
+export declare class GetCampaignVersionCommand extends $Command<GetCampaignVersionCommandInput, GetCampaignVersionCommandOutput, PinpointClientResolvedConfig> {
+    readonly input: GetCampaignVersionCommandInput;
+    constructor(input: GetCampaignVersionCommandInput);
+    /**
+     * @internal
+     */
+    resolveMiddleware(clientStack: MiddlewareStack<ServiceInputTypes, ServiceOutputTypes>, configuration: PinpointClientResolvedConfig, options?: __HttpHandlerOptions): Handler<GetCampaignVersionCommandInput, GetCampaignVersionCommandOutput>;
+    private serialize;
+    private deserialize;
+}

package/dist-types/commands/GetCampaignVersionsCommand.d.ts

@@ -0,0 +1,35 @@
+import { Command as $Command } from "@aws-sdk/smithy-client";
+import { Handler, HttpHandlerOptions as __HttpHandlerOptions, MetadataBearer as __MetadataBearer, MiddlewareStack } from "@aws-sdk/types";
+import { GetCampaignVersionsRequest, GetCampaignVersionsResponse } from "../models/models_0";
+import { PinpointClientResolvedConfig, ServiceInputTypes, ServiceOutputTypes } from "../PinpointClient";
+export interface GetCampaignVersionsCommandInput extends GetCampaignVersionsRequest {
+}
+export interface GetCampaignVersionsCommandOutput extends GetCampaignVersionsResponse, __MetadataBearer {
+}
+/**
+ * <p>Retrieves information about the status, configuration, and other settings for all versions of a campaign.</p>
+ * @example
+ * Use a bare-bones client and the command you need to make an API call.
+ * ```javascript
+ * import { PinpointClient, GetCampaignVersionsCommand } from "@aws-sdk/client-pinpoint"; // ES Modules import
+ * // const { PinpointClient, GetCampaignVersionsCommand } = require("@aws-sdk/client-pinpoint"); // CommonJS import
+ * const client = new PinpointClient(config);
+ * const command = new GetCampaignVersionsCommand(input);
+ * const response = await client.send(command);
+ * ```
+ *
+ * @see {@link GetCampaignVersionsCommandInput} for command's `input` shape.
+ * @see {@link GetCampaignVersionsCommandOutput} for command's `response` shape.
+ * @see {@link PinpointClientResolvedConfig | config} for command's `input` shape.
+ *
+ */
+export declare class GetCampaignVersionsCommand extends $Command<GetCampaignVersionsCommandInput, GetCampaignVersionsCommandOutput, PinpointClientResolvedConfig> {
+    readonly input: GetCampaignVersionsCommandInput;
+    constructor(input: GetCampaignVersionsCommandInput);
+    /**
+     * @internal
+     */
+    resolveMiddleware(clientStack: MiddlewareStack<ServiceInputTypes, ServiceOutputTypes>, configuration: PinpointClientResolvedConfig, options?: __HttpHandlerOptions): Handler<GetCampaignVersionsCommandInput, GetCampaignVersionsCommandOutput>;
+    private serialize;
+    private deserialize;
+}

package/dist-types/commands/GetCampaignsCommand.d.ts

@@ -0,0 +1,35 @@
+import { Command as $Command } from "@aws-sdk/smithy-client";
+import { Handler, HttpHandlerOptions as __HttpHandlerOptions, MetadataBearer as __MetadataBearer, MiddlewareStack } from "@aws-sdk/types";
+import { GetCampaignsRequest, GetCampaignsResponse } from "../models/models_0";
+import { PinpointClientResolvedConfig, ServiceInputTypes, ServiceOutputTypes } from "../PinpointClient";
+export interface GetCampaignsCommandInput extends GetCampaignsRequest {
+}
+export interface GetCampaignsCommandOutput extends GetCampaignsResponse, __MetadataBearer {
+}
+/**
+ * <p>Retrieves information about the status, configuration, and other settings for all the campaigns that are associated with an application.</p>
+ * @example
+ * Use a bare-bones client and the command you need to make an API call.
+ * ```javascript
+ * import { PinpointClient, GetCampaignsCommand } from "@aws-sdk/client-pinpoint"; // ES Modules import
+ * // const { PinpointClient, GetCampaignsCommand } = require("@aws-sdk/client-pinpoint"); // CommonJS import
+ * const client = new PinpointClient(config);
+ * const command = new GetCampaignsCommand(input);
+ * const response = await client.send(command);
+ * ```
+ *
+ * @see {@link GetCampaignsCommandInput} for command's `input` shape.
+ * @see {@link GetCampaignsCommandOutput} for command's `response` shape.
+ * @see {@link PinpointClientResolvedConfig | config} for command's `input` shape.
+ *
+ */
+export declare class GetCampaignsCommand extends $Command<GetCampaignsCommandInput, GetCampaignsCommandOutput, PinpointClientResolvedConfig> {
+    readonly input: GetCampaignsCommandInput;
+    constructor(input: GetCampaignsCommandInput);
+    /**
+     * @internal
+     */
+    resolveMiddleware(clientStack: MiddlewareStack<ServiceInputTypes, ServiceOutputTypes>, configuration: PinpointClientResolvedConfig, options?: __HttpHandlerOptions): Handler<GetCampaignsCommandInput, GetCampaignsCommandOutput>;
+    private serialize;
+    private deserialize;
+}

package/dist-types/commands/GetChannelsCommand.d.ts

@@ -0,0 +1,35 @@
+import { Command as $Command } from "@aws-sdk/smithy-client";
+import { Handler, HttpHandlerOptions as __HttpHandlerOptions, MetadataBearer as __MetadataBearer, MiddlewareStack } from "@aws-sdk/types";
+import { GetChannelsRequest, GetChannelsResponse } from "../models/models_0";
+import { PinpointClientResolvedConfig, ServiceInputTypes, ServiceOutputTypes } from "../PinpointClient";
+export interface GetChannelsCommandInput extends GetChannelsRequest {
+}
+export interface GetChannelsCommandOutput extends GetChannelsResponse, __MetadataBearer {
+}
+/**
+ * <p>Retrieves information about the history and status of each channel for an application.</p>
+ * @example
+ * Use a bare-bones client and the command you need to make an API call.
+ * ```javascript
+ * import { PinpointClient, GetChannelsCommand } from "@aws-sdk/client-pinpoint"; // ES Modules import
+ * // const { PinpointClient, GetChannelsCommand } = require("@aws-sdk/client-pinpoint"); // CommonJS import
+ * const client = new PinpointClient(config);
+ * const command = new GetChannelsCommand(input);
+ * const response = await client.send(command);
+ * ```
+ *
+ * @see {@link GetChannelsCommandInput} for command's `input` shape.
+ * @see {@link GetChannelsCommandOutput} for command's `response` shape.
+ * @see {@link PinpointClientResolvedConfig | config} for command's `input` shape.
+ *
+ */
+export declare class GetChannelsCommand extends $Command<GetChannelsCommandInput, GetChannelsCommandOutput, PinpointClientResolvedConfig> {
+    readonly input: GetChannelsCommandInput;
+    constructor(input: GetChannelsCommandInput);
+    /**
+     * @internal
+     */
+    resolveMiddleware(clientStack: MiddlewareStack<ServiceInputTypes, ServiceOutputTypes>, configuration: PinpointClientResolvedConfig, options?: __HttpHandlerOptions): Handler<GetChannelsCommandInput, GetChannelsCommandOutput>;
+    private serialize;
+    private deserialize;
+}

package/dist-types/commands/GetEmailChannelCommand.d.ts

@@ -0,0 +1,35 @@
+import { Command as $Command } from "@aws-sdk/smithy-client";
+import { Handler, HttpHandlerOptions as __HttpHandlerOptions, MetadataBearer as __MetadataBearer, MiddlewareStack } from "@aws-sdk/types";
+import { GetEmailChannelRequest, GetEmailChannelResponse } from "../models/models_0";
+import { PinpointClientResolvedConfig, ServiceInputTypes, ServiceOutputTypes } from "../PinpointClient";
+export interface GetEmailChannelCommandInput extends GetEmailChannelRequest {
+}
+export interface GetEmailChannelCommandOutput extends GetEmailChannelResponse, __MetadataBearer {
+}
+/**
+ * <p>Retrieves information about the status and settings of the email channel for an application.</p>
+ * @example
+ * Use a bare-bones client and the command you need to make an API call.
+ * ```javascript
+ * import { PinpointClient, GetEmailChannelCommand } from "@aws-sdk/client-pinpoint"; // ES Modules import
+ * // const { PinpointClient, GetEmailChannelCommand } = require("@aws-sdk/client-pinpoint"); // CommonJS import
+ * const client = new PinpointClient(config);
+ * const command = new GetEmailChannelCommand(input);
+ * const response = await client.send(command);
+ * ```
+ *
+ * @see {@link GetEmailChannelCommandInput} for command's `input` shape.
+ * @see {@link GetEmailChannelCommandOutput} for command's `response` shape.
+ * @see {@link PinpointClientResolvedConfig | config} for command's `input` shape.
+ *
+ */
+export declare class GetEmailChannelCommand extends $Command<GetEmailChannelCommandInput, GetEmailChannelCommandOutput, PinpointClientResolvedConfig> {
+    readonly input: GetEmailChannelCommandInput;
+    constructor(input: GetEmailChannelCommandInput);
+    /**
+     * @internal
+     */
+    resolveMiddleware(clientStack: MiddlewareStack<ServiceInputTypes, ServiceOutputTypes>, configuration: PinpointClientResolvedConfig, options?: __HttpHandlerOptions): Handler<GetEmailChannelCommandInput, GetEmailChannelCommandOutput>;
+    private serialize;
+    private deserialize;
+}

package/dist-types/commands/GetEmailTemplateCommand.d.ts

@@ -0,0 +1,36 @@
+import { Command as $Command } from "@aws-sdk/smithy-client";
+import { Handler, HttpHandlerOptions as __HttpHandlerOptions, MetadataBearer as __MetadataBearer, MiddlewareStack } from "@aws-sdk/types";
+import { GetEmailTemplateRequest } from "../models/models_0";
+import { GetEmailTemplateResponse } from "../models/models_1";
+import { PinpointClientResolvedConfig, ServiceInputTypes, ServiceOutputTypes } from "../PinpointClient";
+export interface GetEmailTemplateCommandInput extends GetEmailTemplateRequest {
+}
+export interface GetEmailTemplateCommandOutput extends GetEmailTemplateResponse, __MetadataBearer {
+}
+/**
+ * <p>Retrieves the content and settings of a message template for messages that are sent through the email channel.</p>
+ * @example
+ * Use a bare-bones client and the command you need to make an API call.
+ * ```javascript
+ * import { PinpointClient, GetEmailTemplateCommand } from "@aws-sdk/client-pinpoint"; // ES Modules import
+ * // const { PinpointClient, GetEmailTemplateCommand } = require("@aws-sdk/client-pinpoint"); // CommonJS import
+ * const client = new PinpointClient(config);
+ * const command = new GetEmailTemplateCommand(input);
+ * const response = await client.send(command);
+ * ```
+ *
+ * @see {@link GetEmailTemplateCommandInput} for command's `input` shape.
+ * @see {@link GetEmailTemplateCommandOutput} for command's `response` shape.
+ * @see {@link PinpointClientResolvedConfig | config} for command's `input` shape.
+ *
+ */
+export declare class GetEmailTemplateCommand extends $Command<GetEmailTemplateCommandInput, GetEmailTemplateCommandOutput, PinpointClientResolvedConfig> {
+    readonly input: GetEmailTemplateCommandInput;
+    constructor(input: GetEmailTemplateCommandInput);
+    /**
+     * @internal
+     */
+    resolveMiddleware(clientStack: MiddlewareStack<ServiceInputTypes, ServiceOutputTypes>, configuration: PinpointClientResolvedConfig, options?: __HttpHandlerOptions): Handler<GetEmailTemplateCommandInput, GetEmailTemplateCommandOutput>;
+    private serialize;
+    private deserialize;
+}

package/dist-types/commands/GetEndpointCommand.d.ts

@@ -0,0 +1,35 @@
+import { Command as $Command } from "@aws-sdk/smithy-client";
+import { Handler, HttpHandlerOptions as __HttpHandlerOptions, MetadataBearer as __MetadataBearer, MiddlewareStack } from "@aws-sdk/types";
+import { GetEndpointRequest, GetEndpointResponse } from "../models/models_1";
+import { PinpointClientResolvedConfig, ServiceInputTypes, ServiceOutputTypes } from "../PinpointClient";
+export interface GetEndpointCommandInput extends GetEndpointRequest {
+}
+export interface GetEndpointCommandOutput extends GetEndpointResponse, __MetadataBearer {
+}
+/**
+ * <p>Retrieves information about the settings and attributes of a specific endpoint for an application.</p>
+ * @example
+ * Use a bare-bones client and the command you need to make an API call.
+ * ```javascript
+ * import { PinpointClient, GetEndpointCommand } from "@aws-sdk/client-pinpoint"; // ES Modules import
+ * // const { PinpointClient, GetEndpointCommand } = require("@aws-sdk/client-pinpoint"); // CommonJS import
+ * const client = new PinpointClient(config);
+ * const command = new GetEndpointCommand(input);
+ * const response = await client.send(command);
+ * ```
+ *
+ * @see {@link GetEndpointCommandInput} for command's `input` shape.
+ * @see {@link GetEndpointCommandOutput} for command's `response` shape.
+ * @see {@link PinpointClientResolvedConfig | config} for command's `input` shape.
+ *
+ */
+export declare class GetEndpointCommand extends $Command<GetEndpointCommandInput, GetEndpointCommandOutput, PinpointClientResolvedConfig> {
+    readonly input: GetEndpointCommandInput;
+    constructor(input: GetEndpointCommandInput);
+    /**
+     * @internal
+     */
+    resolveMiddleware(clientStack: MiddlewareStack<ServiceInputTypes, ServiceOutputTypes>, configuration: PinpointClientResolvedConfig, options?: __HttpHandlerOptions): Handler<GetEndpointCommandInput, GetEndpointCommandOutput>;
+    private serialize;
+    private deserialize;
+}

package/dist-types/commands/GetEventStreamCommand.d.ts

@@ -0,0 +1,35 @@
+import { Command as $Command } from "@aws-sdk/smithy-client";
+import { Handler, HttpHandlerOptions as __HttpHandlerOptions, MetadataBearer as __MetadataBearer, MiddlewareStack } from "@aws-sdk/types";
+import { GetEventStreamRequest, GetEventStreamResponse } from "../models/models_1";
+import { PinpointClientResolvedConfig, ServiceInputTypes, ServiceOutputTypes } from "../PinpointClient";
+export interface GetEventStreamCommandInput extends GetEventStreamRequest {
+}
+export interface GetEventStreamCommandOutput extends GetEventStreamResponse, __MetadataBearer {
+}
+/**
+ * <p>Retrieves information about the event stream settings for an application.</p>
+ * @example
+ * Use a bare-bones client and the command you need to make an API call.
+ * ```javascript
+ * import { PinpointClient, GetEventStreamCommand } from "@aws-sdk/client-pinpoint"; // ES Modules import
+ * // const { PinpointClient, GetEventStreamCommand } = require("@aws-sdk/client-pinpoint"); // CommonJS import
+ * const client = new PinpointClient(config);
+ * const command = new GetEventStreamCommand(input);
+ * const response = await client.send(command);
+ * ```
+ *
+ * @see {@link GetEventStreamCommandInput} for command's `input` shape.
+ * @see {@link GetEventStreamCommandOutput} for command's `response` shape.
+ * @see {@link PinpointClientResolvedConfig | config} for command's `input` shape.
+ *
+ */
+export declare class GetEventStreamCommand extends $Command<GetEventStreamCommandInput, GetEventStreamCommandOutput, PinpointClientResolvedConfig> {
+    readonly input: GetEventStreamCommandInput;
+    constructor(input: GetEventStreamCommandInput);
+    /**
+     * @internal
+     */
+    resolveMiddleware(clientStack: MiddlewareStack<ServiceInputTypes, ServiceOutputTypes>, configuration: PinpointClientResolvedConfig, options?: __HttpHandlerOptions): Handler<GetEventStreamCommandInput, GetEventStreamCommandOutput>;
+    private serialize;
+    private deserialize;
+}

package/dist-types/commands/GetExportJobCommand.d.ts

@@ -0,0 +1,35 @@
+import { Command as $Command } from "@aws-sdk/smithy-client";
+import { Handler, HttpHandlerOptions as __HttpHandlerOptions, MetadataBearer as __MetadataBearer, MiddlewareStack } from "@aws-sdk/types";
+import { GetExportJobRequest, GetExportJobResponse } from "../models/models_1";
+import { PinpointClientResolvedConfig, ServiceInputTypes, ServiceOutputTypes } from "../PinpointClient";
+export interface GetExportJobCommandInput extends GetExportJobRequest {
+}
+export interface GetExportJobCommandOutput extends GetExportJobResponse, __MetadataBearer {
+}
+/**
+ * <p>Retrieves information about the status and settings of a specific export job for an application.</p>
+ * @example
+ * Use a bare-bones client and the command you need to make an API call.
+ * ```javascript
+ * import { PinpointClient, GetExportJobCommand } from "@aws-sdk/client-pinpoint"; // ES Modules import
+ * // const { PinpointClient, GetExportJobCommand } = require("@aws-sdk/client-pinpoint"); // CommonJS import
+ * const client = new PinpointClient(config);
+ * const command = new GetExportJobCommand(input);
+ * const response = await client.send(command);
+ * ```
+ *
+ * @see {@link GetExportJobCommandInput} for command's `input` shape.
+ * @see {@link GetExportJobCommandOutput} for command's `response` shape.
+ * @see {@link PinpointClientResolvedConfig | config} for command's `input` shape.
+ *
+ */
+export declare class GetExportJobCommand extends $Command<GetExportJobCommandInput, GetExportJobCommandOutput, PinpointClientResolvedConfig> {
+    readonly input: GetExportJobCommandInput;
+    constructor(input: GetExportJobCommandInput);
+    /**
+     * @internal
+     */
+    resolveMiddleware(clientStack: MiddlewareStack<ServiceInputTypes, ServiceOutputTypes>, configuration: PinpointClientResolvedConfig, options?: __HttpHandlerOptions): Handler<GetExportJobCommandInput, GetExportJobCommandOutput>;
+    private serialize;
+    private deserialize;
+}

package/dist-types/commands/GetExportJobsCommand.d.ts

@@ -0,0 +1,35 @@
+import { Command as $Command } from "@aws-sdk/smithy-client";
+import { Handler, HttpHandlerOptions as __HttpHandlerOptions, MetadataBearer as __MetadataBearer, MiddlewareStack } from "@aws-sdk/types";
+import { GetExportJobsRequest, GetExportJobsResponse } from "../models/models_1";
+import { PinpointClientResolvedConfig, ServiceInputTypes, ServiceOutputTypes } from "../PinpointClient";
+export interface GetExportJobsCommandInput extends GetExportJobsRequest {
+}
+export interface GetExportJobsCommandOutput extends GetExportJobsResponse, __MetadataBearer {
+}
+/**
+ * <p>Retrieves information about the status and settings of all the export jobs for an application.</p>
+ * @example
+ * Use a bare-bones client and the command you need to make an API call.
+ * ```javascript
+ * import { PinpointClient, GetExportJobsCommand } from "@aws-sdk/client-pinpoint"; // ES Modules import
+ * // const { PinpointClient, GetExportJobsCommand } = require("@aws-sdk/client-pinpoint"); // CommonJS import
+ * const client = new PinpointClient(config);
+ * const command = new GetExportJobsCommand(input);
+ * const response = await client.send(command);
+ * ```
+ *
+ * @see {@link GetExportJobsCommandInput} for command's `input` shape.
+ * @see {@link GetExportJobsCommandOutput} for command's `response` shape.
+ * @see {@link PinpointClientResolvedConfig | config} for command's `input` shape.
+ *
+ */
+export declare class GetExportJobsCommand extends $Command<GetExportJobsCommandInput, GetExportJobsCommandOutput, PinpointClientResolvedConfig> {
+    readonly input: GetExportJobsCommandInput;
+    constructor(input: GetExportJobsCommandInput);
+    /**
+     * @internal
+     */
+    resolveMiddleware(clientStack: MiddlewareStack<ServiceInputTypes, ServiceOutputTypes>, configuration: PinpointClientResolvedConfig, options?: __HttpHandlerOptions): Handler<GetExportJobsCommandInput, GetExportJobsCommandOutput>;
+    private serialize;
+    private deserialize;
+}

package/dist-types/commands/GetGcmChannelCommand.d.ts

@@ -0,0 +1,35 @@
+import { Command as $Command } from "@aws-sdk/smithy-client";
+import { Handler, HttpHandlerOptions as __HttpHandlerOptions, MetadataBearer as __MetadataBearer, MiddlewareStack } from "@aws-sdk/types";
+import { GetGcmChannelRequest, GetGcmChannelResponse } from "../models/models_1";
+import { PinpointClientResolvedConfig, ServiceInputTypes, ServiceOutputTypes } from "../PinpointClient";
+export interface GetGcmChannelCommandInput extends GetGcmChannelRequest {
+}
+export interface GetGcmChannelCommandOutput extends GetGcmChannelResponse, __MetadataBearer {
+}
+/**
+ * <p>Retrieves information about the status and settings of the GCM channel for an application.</p>
+ * @example
+ * Use a bare-bones client and the command you need to make an API call.
+ * ```javascript
+ * import { PinpointClient, GetGcmChannelCommand } from "@aws-sdk/client-pinpoint"; // ES Modules import
+ * // const { PinpointClient, GetGcmChannelCommand } = require("@aws-sdk/client-pinpoint"); // CommonJS import
+ * const client = new PinpointClient(config);
+ * const command = new GetGcmChannelCommand(input);
+ * const response = await client.send(command);
+ * ```
+ *
+ * @see {@link GetGcmChannelCommandInput} for command's `input` shape.
+ * @see {@link GetGcmChannelCommandOutput} for command's `response` shape.
+ * @see {@link PinpointClientResolvedConfig | config} for command's `input` shape.
+ *
+ */
+export declare class GetGcmChannelCommand extends $Command<GetGcmChannelCommandInput, GetGcmChannelCommandOutput, PinpointClientResolvedConfig> {
+    readonly input: GetGcmChannelCommandInput;
+    constructor(input: GetGcmChannelCommandInput);
+    /**
+     * @internal
+     */
+    resolveMiddleware(clientStack: MiddlewareStack<ServiceInputTypes, ServiceOutputTypes>, configuration: PinpointClientResolvedConfig, options?: __HttpHandlerOptions): Handler<GetGcmChannelCommandInput, GetGcmChannelCommandOutput>;
+    private serialize;
+    private deserialize;
+}

package/dist-types/commands/GetImportJobCommand.d.ts

@@ -0,0 +1,35 @@
+import { Command as $Command } from "@aws-sdk/smithy-client";
+import { Handler, HttpHandlerOptions as __HttpHandlerOptions, MetadataBearer as __MetadataBearer, MiddlewareStack } from "@aws-sdk/types";
+import { GetImportJobRequest, GetImportJobResponse } from "../models/models_1";
+import { PinpointClientResolvedConfig, ServiceInputTypes, ServiceOutputTypes } from "../PinpointClient";
+export interface GetImportJobCommandInput extends GetImportJobRequest {
+}
+export interface GetImportJobCommandOutput extends GetImportJobResponse, __MetadataBearer {
+}
+/**
+ * <p>Retrieves information about the status and settings of a specific import job for an application.</p>
+ * @example
+ * Use a bare-bones client and the command you need to make an API call.
+ * ```javascript
+ * import { PinpointClient, GetImportJobCommand } from "@aws-sdk/client-pinpoint"; // ES Modules import
+ * // const { PinpointClient, GetImportJobCommand } = require("@aws-sdk/client-pinpoint"); // CommonJS import
+ * const client = new PinpointClient(config);
+ * const command = new GetImportJobCommand(input);
+ * const response = await client.send(command);
+ * ```
+ *
+ * @see {@link GetImportJobCommandInput} for command's `input` shape.
+ * @see {@link GetImportJobCommandOutput} for command's `response` shape.
+ * @see {@link PinpointClientResolvedConfig | config} for command's `input` shape.
+ *
+ */
+export declare class GetImportJobCommand extends $Command<GetImportJobCommandInput, GetImportJobCommandOutput, PinpointClientResolvedConfig> {
+    readonly input: GetImportJobCommandInput;
+    constructor(input: GetImportJobCommandInput);
+    /**
+     * @internal
+     */
+    resolveMiddleware(clientStack: MiddlewareStack<ServiceInputTypes, ServiceOutputTypes>, configuration: PinpointClientResolvedConfig, options?: __HttpHandlerOptions): Handler<GetImportJobCommandInput, GetImportJobCommandOutput>;
+    private serialize;
+    private deserialize;
+}

package/dist-types/commands/GetImportJobsCommand.d.ts

@@ -0,0 +1,35 @@
+import { Command as $Command } from "@aws-sdk/smithy-client";
+import { Handler, HttpHandlerOptions as __HttpHandlerOptions, MetadataBearer as __MetadataBearer, MiddlewareStack } from "@aws-sdk/types";
+import { GetImportJobsRequest, GetImportJobsResponse } from "../models/models_1";
+import { PinpointClientResolvedConfig, ServiceInputTypes, ServiceOutputTypes } from "../PinpointClient";
+export interface GetImportJobsCommandInput extends GetImportJobsRequest {
+}
+export interface GetImportJobsCommandOutput extends GetImportJobsResponse, __MetadataBearer {
+}
+/**
+ * <p>Retrieves information about the status and settings of all the import jobs for an application.</p>
+ * @example
+ * Use a bare-bones client and the command you need to make an API call.
+ * ```javascript
+ * import { PinpointClient, GetImportJobsCommand } from "@aws-sdk/client-pinpoint"; // ES Modules import
+ * // const { PinpointClient, GetImportJobsCommand } = require("@aws-sdk/client-pinpoint"); // CommonJS import
+ * const client = new PinpointClient(config);
+ * const command = new GetImportJobsCommand(input);
+ * const response = await client.send(command);
+ * ```
+ *
+ * @see {@link GetImportJobsCommandInput} for command's `input` shape.
+ * @see {@link GetImportJobsCommandOutput} for command's `response` shape.
+ * @see {@link PinpointClientResolvedConfig | config} for command's `input` shape.
+ *
+ */
+export declare class GetImportJobsCommand extends $Command<GetImportJobsCommandInput, GetImportJobsCommandOutput, PinpointClientResolvedConfig> {
+    readonly input: GetImportJobsCommandInput;
+    constructor(input: GetImportJobsCommandInput);
+    /**
+     * @internal
+     */
+    resolveMiddleware(clientStack: MiddlewareStack<ServiceInputTypes, ServiceOutputTypes>, configuration: PinpointClientResolvedConfig, options?: __HttpHandlerOptions): Handler<GetImportJobsCommandInput, GetImportJobsCommandOutput>;
+    private serialize;
+    private deserialize;
+}