@aws-sdk/client-database-migration-service 3.34.0 → 3.35.0

package/src/endpoints.ts

@@ -0,0 +1,63 @@
+import { getRegionInfo, PartitionHash, RegionHash } from "@aws-sdk/config-resolver";
+import { RegionInfoProvider } from "@aws-sdk/types";
+
+const regionHash: RegionHash = {
+  "dms-fips": {
+    hostname: "dms.us-gov-west-1.amazonaws.com",
+    signingRegion: "us-gov-west-1",
+  },
+};
+
+const partitionHash: PartitionHash = {
+  aws: {
+    regions: [
+      "af-south-1",
+      "ap-east-1",
+      "ap-northeast-1",
+      "ap-northeast-2",
+      "ap-northeast-3",
+      "ap-south-1",
+      "ap-southeast-1",
+      "ap-southeast-2",
+      "ca-central-1",
+      "dms-fips",
+      "eu-central-1",
+      "eu-north-1",
+      "eu-south-1",
+      "eu-west-1",
+      "eu-west-2",
+      "eu-west-3",
+      "me-south-1",
+      "sa-east-1",
+      "us-east-1",
+      "us-east-2",
+      "us-west-1",
+      "us-west-2",
+    ],
+    hostname: "dms.{region}.amazonaws.com",
+  },
+  "aws-cn": {
+    regions: ["cn-north-1", "cn-northwest-1"],
+    hostname: "dms.{region}.amazonaws.com.cn",
+  },
+  "aws-iso": {
+    regions: ["dms-fips", "us-iso-east-1"],
+    hostname: "dms.{region}.c2s.ic.gov",
+  },
+  "aws-iso-b": {
+    regions: ["dms-fips", "us-isob-east-1"],
+    hostname: "dms.{region}.sc2s.sgov.gov",
+  },
+  "aws-us-gov": {
+    regions: ["dms-fips", "us-gov-east-1", "us-gov-west-1"],
+    hostname: "dms.{region}.amazonaws.com",
+  },
+};
+
+export const defaultRegionInfoProvider: RegionInfoProvider = async (region: string, options?: any) =>
+  getRegionInfo(region, {
+    ...options,
+    signingService: "dms",
+    regionHash,
+    partitionHash,
+  });

package/src/pagination/DescribeApplicableIndividualAssessmentsPaginator.ts

@@ -0,0 +1,59 @@
+import { Paginator } from "@aws-sdk/types";
+
+import {
+  DescribeApplicableIndividualAssessmentsCommand,
+  DescribeApplicableIndividualAssessmentsCommandInput,
+  DescribeApplicableIndividualAssessmentsCommandOutput,
+} from "../commands/DescribeApplicableIndividualAssessmentsCommand";
+import { DatabaseMigrationService } from "../DatabaseMigrationService";
+import { DatabaseMigrationServiceClient } from "../DatabaseMigrationServiceClient";
+import { DatabaseMigrationServicePaginationConfiguration } from "./Interfaces";
+
+/**
+ * @private
+ */
+const makePagedClientRequest = async (
+  client: DatabaseMigrationServiceClient,
+  input: DescribeApplicableIndividualAssessmentsCommandInput,
+  ...args: any
+): Promise<DescribeApplicableIndividualAssessmentsCommandOutput> => {
+  // @ts-ignore
+  return await client.send(new DescribeApplicableIndividualAssessmentsCommand(input), ...args);
+};
+/**
+ * @private
+ */
+const makePagedRequest = async (
+  client: DatabaseMigrationService,
+  input: DescribeApplicableIndividualAssessmentsCommandInput,
+  ...args: any
+): Promise<DescribeApplicableIndividualAssessmentsCommandOutput> => {
+  // @ts-ignore
+  return await client.describeApplicableIndividualAssessments(input, ...args);
+};
+export async function* paginateDescribeApplicableIndividualAssessments(
+  config: DatabaseMigrationServicePaginationConfiguration,
+  input: DescribeApplicableIndividualAssessmentsCommandInput,
+  ...additionalArguments: any
+): Paginator<DescribeApplicableIndividualAssessmentsCommandOutput> {
+  // ToDo: replace with actual type instead of typeof input.Marker
+  let token: typeof input.Marker | undefined = config.startingToken || undefined;
+  let hasNext = true;
+  let page: DescribeApplicableIndividualAssessmentsCommandOutput;
+  while (hasNext) {
+    input.Marker = token;
+    input["MaxRecords"] = config.pageSize;
+    if (config.client instanceof DatabaseMigrationService) {
+      page = await makePagedRequest(config.client, input, ...additionalArguments);
+    } else if (config.client instanceof DatabaseMigrationServiceClient) {
+      page = await makePagedClientRequest(config.client, input, ...additionalArguments);
+    } else {
+      throw new Error("Invalid client, expected DatabaseMigrationService | DatabaseMigrationServiceClient");
+    }
+    yield page;
+    token = page.Marker;
+    hasNext = !!token;
+  }
+  // @ts-ignore
+  return undefined;
+}

package/src/pagination/DescribeCertificatesPaginator.ts

@@ -0,0 +1,59 @@
+import { Paginator } from "@aws-sdk/types";
+
+import {
+  DescribeCertificatesCommand,
+  DescribeCertificatesCommandInput,
+  DescribeCertificatesCommandOutput,
+} from "../commands/DescribeCertificatesCommand";
+import { DatabaseMigrationService } from "../DatabaseMigrationService";
+import { DatabaseMigrationServiceClient } from "../DatabaseMigrationServiceClient";
+import { DatabaseMigrationServicePaginationConfiguration } from "./Interfaces";
+
+/**
+ * @private
+ */
+const makePagedClientRequest = async (
+  client: DatabaseMigrationServiceClient,
+  input: DescribeCertificatesCommandInput,
+  ...args: any
+): Promise<DescribeCertificatesCommandOutput> => {
+  // @ts-ignore
+  return await client.send(new DescribeCertificatesCommand(input), ...args);
+};
+/**
+ * @private
+ */
+const makePagedRequest = async (
+  client: DatabaseMigrationService,
+  input: DescribeCertificatesCommandInput,
+  ...args: any
+): Promise<DescribeCertificatesCommandOutput> => {
+  // @ts-ignore
+  return await client.describeCertificates(input, ...args);
+};
+export async function* paginateDescribeCertificates(
+  config: DatabaseMigrationServicePaginationConfiguration,
+  input: DescribeCertificatesCommandInput,
+  ...additionalArguments: any
+): Paginator<DescribeCertificatesCommandOutput> {
+  // ToDo: replace with actual type instead of typeof input.Marker
+  let token: typeof input.Marker | undefined = config.startingToken || undefined;
+  let hasNext = true;
+  let page: DescribeCertificatesCommandOutput;
+  while (hasNext) {
+    input.Marker = token;
+    input["MaxRecords"] = config.pageSize;
+    if (config.client instanceof DatabaseMigrationService) {
+      page = await makePagedRequest(config.client, input, ...additionalArguments);
+    } else if (config.client instanceof DatabaseMigrationServiceClient) {
+      page = await makePagedClientRequest(config.client, input, ...additionalArguments);
+    } else {
+      throw new Error("Invalid client, expected DatabaseMigrationService | DatabaseMigrationServiceClient");
+    }
+    yield page;
+    token = page.Marker;
+    hasNext = !!token;
+  }
+  // @ts-ignore
+  return undefined;
+}

package/src/pagination/DescribeConnectionsPaginator.ts

@@ -0,0 +1,59 @@
+import { Paginator } from "@aws-sdk/types";
+
+import {
+  DescribeConnectionsCommand,
+  DescribeConnectionsCommandInput,
+  DescribeConnectionsCommandOutput,
+} from "../commands/DescribeConnectionsCommand";
+import { DatabaseMigrationService } from "../DatabaseMigrationService";
+import { DatabaseMigrationServiceClient } from "../DatabaseMigrationServiceClient";
+import { DatabaseMigrationServicePaginationConfiguration } from "./Interfaces";
+
+/**
+ * @private
+ */
+const makePagedClientRequest = async (
+  client: DatabaseMigrationServiceClient,
+  input: DescribeConnectionsCommandInput,
+  ...args: any
+): Promise<DescribeConnectionsCommandOutput> => {
+  // @ts-ignore
+  return await client.send(new DescribeConnectionsCommand(input), ...args);
+};
+/**
+ * @private
+ */
+const makePagedRequest = async (
+  client: DatabaseMigrationService,
+  input: DescribeConnectionsCommandInput,
+  ...args: any
+): Promise<DescribeConnectionsCommandOutput> => {
+  // @ts-ignore
+  return await client.describeConnections(input, ...args);
+};
+export async function* paginateDescribeConnections(
+  config: DatabaseMigrationServicePaginationConfiguration,
+  input: DescribeConnectionsCommandInput,
+  ...additionalArguments: any
+): Paginator<DescribeConnectionsCommandOutput> {
+  // ToDo: replace with actual type instead of typeof input.Marker
+  let token: typeof input.Marker | undefined = config.startingToken || undefined;
+  let hasNext = true;
+  let page: DescribeConnectionsCommandOutput;
+  while (hasNext) {
+    input.Marker = token;
+    input["MaxRecords"] = config.pageSize;
+    if (config.client instanceof DatabaseMigrationService) {
+      page = await makePagedRequest(config.client, input, ...additionalArguments);
+    } else if (config.client instanceof DatabaseMigrationServiceClient) {
+      page = await makePagedClientRequest(config.client, input, ...additionalArguments);
+    } else {
+      throw new Error("Invalid client, expected DatabaseMigrationService | DatabaseMigrationServiceClient");
+    }
+    yield page;
+    token = page.Marker;
+    hasNext = !!token;
+  }
+  // @ts-ignore
+  return undefined;
+}

package/src/pagination/DescribeEndpointSettingsPaginator.ts

@@ -0,0 +1,59 @@
+import { Paginator } from "@aws-sdk/types";
+
+import {
+  DescribeEndpointSettingsCommand,
+  DescribeEndpointSettingsCommandInput,
+  DescribeEndpointSettingsCommandOutput,
+} from "../commands/DescribeEndpointSettingsCommand";
+import { DatabaseMigrationService } from "../DatabaseMigrationService";
+import { DatabaseMigrationServiceClient } from "../DatabaseMigrationServiceClient";
+import { DatabaseMigrationServicePaginationConfiguration } from "./Interfaces";
+
+/**
+ * @private
+ */
+const makePagedClientRequest = async (
+  client: DatabaseMigrationServiceClient,
+  input: DescribeEndpointSettingsCommandInput,
+  ...args: any
+): Promise<DescribeEndpointSettingsCommandOutput> => {
+  // @ts-ignore
+  return await client.send(new DescribeEndpointSettingsCommand(input), ...args);
+};
+/**
+ * @private
+ */
+const makePagedRequest = async (
+  client: DatabaseMigrationService,
+  input: DescribeEndpointSettingsCommandInput,
+  ...args: any
+): Promise<DescribeEndpointSettingsCommandOutput> => {
+  // @ts-ignore
+  return await client.describeEndpointSettings(input, ...args);
+};
+export async function* paginateDescribeEndpointSettings(
+  config: DatabaseMigrationServicePaginationConfiguration,
+  input: DescribeEndpointSettingsCommandInput,
+  ...additionalArguments: any
+): Paginator<DescribeEndpointSettingsCommandOutput> {
+  // ToDo: replace with actual type instead of typeof input.Marker
+  let token: typeof input.Marker | undefined = config.startingToken || undefined;
+  let hasNext = true;
+  let page: DescribeEndpointSettingsCommandOutput;
+  while (hasNext) {
+    input.Marker = token;
+    input["MaxRecords"] = config.pageSize;
+    if (config.client instanceof DatabaseMigrationService) {
+      page = await makePagedRequest(config.client, input, ...additionalArguments);
+    } else if (config.client instanceof DatabaseMigrationServiceClient) {
+      page = await makePagedClientRequest(config.client, input, ...additionalArguments);
+    } else {
+      throw new Error("Invalid client, expected DatabaseMigrationService | DatabaseMigrationServiceClient");
+    }
+    yield page;
+    token = page.Marker;
+    hasNext = !!token;
+  }
+  // @ts-ignore
+  return undefined;
+}

package/src/pagination/DescribeEndpointTypesPaginator.ts

@@ -0,0 +1,59 @@
+import { Paginator } from "@aws-sdk/types";
+
+import {
+  DescribeEndpointTypesCommand,
+  DescribeEndpointTypesCommandInput,
+  DescribeEndpointTypesCommandOutput,
+} from "../commands/DescribeEndpointTypesCommand";
+import { DatabaseMigrationService } from "../DatabaseMigrationService";
+import { DatabaseMigrationServiceClient } from "../DatabaseMigrationServiceClient";
+import { DatabaseMigrationServicePaginationConfiguration } from "./Interfaces";
+
+/**
+ * @private
+ */
+const makePagedClientRequest = async (
+  client: DatabaseMigrationServiceClient,
+  input: DescribeEndpointTypesCommandInput,
+  ...args: any
+): Promise<DescribeEndpointTypesCommandOutput> => {
+  // @ts-ignore
+  return await client.send(new DescribeEndpointTypesCommand(input), ...args);
+};
+/**
+ * @private
+ */
+const makePagedRequest = async (
+  client: DatabaseMigrationService,
+  input: DescribeEndpointTypesCommandInput,
+  ...args: any
+): Promise<DescribeEndpointTypesCommandOutput> => {
+  // @ts-ignore
+  return await client.describeEndpointTypes(input, ...args);
+};
+export async function* paginateDescribeEndpointTypes(
+  config: DatabaseMigrationServicePaginationConfiguration,
+  input: DescribeEndpointTypesCommandInput,
+  ...additionalArguments: any
+): Paginator<DescribeEndpointTypesCommandOutput> {
+  // ToDo: replace with actual type instead of typeof input.Marker
+  let token: typeof input.Marker | undefined = config.startingToken || undefined;
+  let hasNext = true;
+  let page: DescribeEndpointTypesCommandOutput;
+  while (hasNext) {
+    input.Marker = token;
+    input["MaxRecords"] = config.pageSize;
+    if (config.client instanceof DatabaseMigrationService) {
+      page = await makePagedRequest(config.client, input, ...additionalArguments);
+    } else if (config.client instanceof DatabaseMigrationServiceClient) {
+      page = await makePagedClientRequest(config.client, input, ...additionalArguments);
+    } else {
+      throw new Error("Invalid client, expected DatabaseMigrationService | DatabaseMigrationServiceClient");
+    }
+    yield page;
+    token = page.Marker;
+    hasNext = !!token;
+  }
+  // @ts-ignore
+  return undefined;
+}

package/src/pagination/DescribeEndpointsPaginator.ts

@@ -0,0 +1,59 @@
+import { Paginator } from "@aws-sdk/types";
+
+import {
+  DescribeEndpointsCommand,
+  DescribeEndpointsCommandInput,
+  DescribeEndpointsCommandOutput,
+} from "../commands/DescribeEndpointsCommand";
+import { DatabaseMigrationService } from "../DatabaseMigrationService";
+import { DatabaseMigrationServiceClient } from "../DatabaseMigrationServiceClient";
+import { DatabaseMigrationServicePaginationConfiguration } from "./Interfaces";
+
+/**
+ * @private
+ */
+const makePagedClientRequest = async (
+  client: DatabaseMigrationServiceClient,
+  input: DescribeEndpointsCommandInput,
+  ...args: any
+): Promise<DescribeEndpointsCommandOutput> => {
+  // @ts-ignore
+  return await client.send(new DescribeEndpointsCommand(input), ...args);
+};
+/**
+ * @private
+ */
+const makePagedRequest = async (
+  client: DatabaseMigrationService,
+  input: DescribeEndpointsCommandInput,
+  ...args: any
+): Promise<DescribeEndpointsCommandOutput> => {
+  // @ts-ignore
+  return await client.describeEndpoints(input, ...args);
+};
+export async function* paginateDescribeEndpoints(
+  config: DatabaseMigrationServicePaginationConfiguration,
+  input: DescribeEndpointsCommandInput,
+  ...additionalArguments: any
+): Paginator<DescribeEndpointsCommandOutput> {
+  // ToDo: replace with actual type instead of typeof input.Marker
+  let token: typeof input.Marker | undefined = config.startingToken || undefined;
+  let hasNext = true;
+  let page: DescribeEndpointsCommandOutput;
+  while (hasNext) {
+    input.Marker = token;
+    input["MaxRecords"] = config.pageSize;
+    if (config.client instanceof DatabaseMigrationService) {
+      page = await makePagedRequest(config.client, input, ...additionalArguments);
+    } else if (config.client instanceof DatabaseMigrationServiceClient) {
+      page = await makePagedClientRequest(config.client, input, ...additionalArguments);
+    } else {
+      throw new Error("Invalid client, expected DatabaseMigrationService | DatabaseMigrationServiceClient");
+    }
+    yield page;
+    token = page.Marker;
+    hasNext = !!token;
+  }
+  // @ts-ignore
+  return undefined;
+}

package/src/pagination/DescribeEventSubscriptionsPaginator.ts

@@ -0,0 +1,59 @@
+import { Paginator } from "@aws-sdk/types";
+
+import {
+  DescribeEventSubscriptionsCommand,
+  DescribeEventSubscriptionsCommandInput,
+  DescribeEventSubscriptionsCommandOutput,
+} from "../commands/DescribeEventSubscriptionsCommand";
+import { DatabaseMigrationService } from "../DatabaseMigrationService";
+import { DatabaseMigrationServiceClient } from "../DatabaseMigrationServiceClient";
+import { DatabaseMigrationServicePaginationConfiguration } from "./Interfaces";
+
+/**
+ * @private
+ */
+const makePagedClientRequest = async (
+  client: DatabaseMigrationServiceClient,
+  input: DescribeEventSubscriptionsCommandInput,
+  ...args: any
+): Promise<DescribeEventSubscriptionsCommandOutput> => {
+  // @ts-ignore
+  return await client.send(new DescribeEventSubscriptionsCommand(input), ...args);
+};
+/**
+ * @private
+ */
+const makePagedRequest = async (
+  client: DatabaseMigrationService,
+  input: DescribeEventSubscriptionsCommandInput,
+  ...args: any
+): Promise<DescribeEventSubscriptionsCommandOutput> => {
+  // @ts-ignore
+  return await client.describeEventSubscriptions(input, ...args);
+};
+export async function* paginateDescribeEventSubscriptions(
+  config: DatabaseMigrationServicePaginationConfiguration,
+  input: DescribeEventSubscriptionsCommandInput,
+  ...additionalArguments: any
+): Paginator<DescribeEventSubscriptionsCommandOutput> {
+  // ToDo: replace with actual type instead of typeof input.Marker
+  let token: typeof input.Marker | undefined = config.startingToken || undefined;
+  let hasNext = true;
+  let page: DescribeEventSubscriptionsCommandOutput;
+  while (hasNext) {
+    input.Marker = token;
+    input["MaxRecords"] = config.pageSize;
+    if (config.client instanceof DatabaseMigrationService) {
+      page = await makePagedRequest(config.client, input, ...additionalArguments);
+    } else if (config.client instanceof DatabaseMigrationServiceClient) {
+      page = await makePagedClientRequest(config.client, input, ...additionalArguments);
+    } else {
+      throw new Error("Invalid client, expected DatabaseMigrationService | DatabaseMigrationServiceClient");
+    }
+    yield page;
+    token = page.Marker;
+    hasNext = !!token;
+  }
+  // @ts-ignore
+  return undefined;
+}

package/src/pagination/DescribeEventsPaginator.ts

@@ -0,0 +1,59 @@
+import { Paginator } from "@aws-sdk/types";
+
+import {
+  DescribeEventsCommand,
+  DescribeEventsCommandInput,
+  DescribeEventsCommandOutput,
+} from "../commands/DescribeEventsCommand";
+import { DatabaseMigrationService } from "../DatabaseMigrationService";
+import { DatabaseMigrationServiceClient } from "../DatabaseMigrationServiceClient";
+import { DatabaseMigrationServicePaginationConfiguration } from "./Interfaces";
+
+/**
+ * @private
+ */
+const makePagedClientRequest = async (
+  client: DatabaseMigrationServiceClient,
+  input: DescribeEventsCommandInput,
+  ...args: any
+): Promise<DescribeEventsCommandOutput> => {
+  // @ts-ignore
+  return await client.send(new DescribeEventsCommand(input), ...args);
+};
+/**
+ * @private
+ */
+const makePagedRequest = async (
+  client: DatabaseMigrationService,
+  input: DescribeEventsCommandInput,
+  ...args: any
+): Promise<DescribeEventsCommandOutput> => {
+  // @ts-ignore
+  return await client.describeEvents(input, ...args);
+};
+export async function* paginateDescribeEvents(
+  config: DatabaseMigrationServicePaginationConfiguration,
+  input: DescribeEventsCommandInput,
+  ...additionalArguments: any
+): Paginator<DescribeEventsCommandOutput> {
+  // ToDo: replace with actual type instead of typeof input.Marker
+  let token: typeof input.Marker | undefined = config.startingToken || undefined;
+  let hasNext = true;
+  let page: DescribeEventsCommandOutput;
+  while (hasNext) {
+    input.Marker = token;
+    input["MaxRecords"] = config.pageSize;
+    if (config.client instanceof DatabaseMigrationService) {
+      page = await makePagedRequest(config.client, input, ...additionalArguments);
+    } else if (config.client instanceof DatabaseMigrationServiceClient) {
+      page = await makePagedClientRequest(config.client, input, ...additionalArguments);
+    } else {
+      throw new Error("Invalid client, expected DatabaseMigrationService | DatabaseMigrationServiceClient");
+    }
+    yield page;
+    token = page.Marker;
+    hasNext = !!token;
+  }
+  // @ts-ignore
+  return undefined;
+}

package/src/pagination/DescribeOrderableReplicationInstancesPaginator.ts

@@ -0,0 +1,59 @@
+import { Paginator } from "@aws-sdk/types";
+
+import {
+  DescribeOrderableReplicationInstancesCommand,
+  DescribeOrderableReplicationInstancesCommandInput,
+  DescribeOrderableReplicationInstancesCommandOutput,
+} from "../commands/DescribeOrderableReplicationInstancesCommand";
+import { DatabaseMigrationService } from "../DatabaseMigrationService";
+import { DatabaseMigrationServiceClient } from "../DatabaseMigrationServiceClient";
+import { DatabaseMigrationServicePaginationConfiguration } from "./Interfaces";
+
+/**
+ * @private
+ */
+const makePagedClientRequest = async (
+  client: DatabaseMigrationServiceClient,
+  input: DescribeOrderableReplicationInstancesCommandInput,
+  ...args: any
+): Promise<DescribeOrderableReplicationInstancesCommandOutput> => {
+  // @ts-ignore
+  return await client.send(new DescribeOrderableReplicationInstancesCommand(input), ...args);
+};
+/**
+ * @private
+ */
+const makePagedRequest = async (
+  client: DatabaseMigrationService,
+  input: DescribeOrderableReplicationInstancesCommandInput,
+  ...args: any
+): Promise<DescribeOrderableReplicationInstancesCommandOutput> => {
+  // @ts-ignore
+  return await client.describeOrderableReplicationInstances(input, ...args);
+};
+export async function* paginateDescribeOrderableReplicationInstances(
+  config: DatabaseMigrationServicePaginationConfiguration,
+  input: DescribeOrderableReplicationInstancesCommandInput,
+  ...additionalArguments: any
+): Paginator<DescribeOrderableReplicationInstancesCommandOutput> {
+  // ToDo: replace with actual type instead of typeof input.Marker
+  let token: typeof input.Marker | undefined = config.startingToken || undefined;
+  let hasNext = true;
+  let page: DescribeOrderableReplicationInstancesCommandOutput;
+  while (hasNext) {
+    input.Marker = token;
+    input["MaxRecords"] = config.pageSize;
+    if (config.client instanceof DatabaseMigrationService) {
+      page = await makePagedRequest(config.client, input, ...additionalArguments);
+    } else if (config.client instanceof DatabaseMigrationServiceClient) {
+      page = await makePagedClientRequest(config.client, input, ...additionalArguments);
+    } else {
+      throw new Error("Invalid client, expected DatabaseMigrationService | DatabaseMigrationServiceClient");
+    }
+    yield page;
+    token = page.Marker;
+    hasNext = !!token;
+  }
+  // @ts-ignore
+  return undefined;
+}

package/src/pagination/DescribePendingMaintenanceActionsPaginator.ts

@@ -0,0 +1,59 @@
+import { Paginator } from "@aws-sdk/types";
+
+import {
+  DescribePendingMaintenanceActionsCommand,
+  DescribePendingMaintenanceActionsCommandInput,
+  DescribePendingMaintenanceActionsCommandOutput,
+} from "../commands/DescribePendingMaintenanceActionsCommand";
+import { DatabaseMigrationService } from "../DatabaseMigrationService";
+import { DatabaseMigrationServiceClient } from "../DatabaseMigrationServiceClient";
+import { DatabaseMigrationServicePaginationConfiguration } from "./Interfaces";
+
+/**
+ * @private
+ */
+const makePagedClientRequest = async (
+  client: DatabaseMigrationServiceClient,
+  input: DescribePendingMaintenanceActionsCommandInput,
+  ...args: any
+): Promise<DescribePendingMaintenanceActionsCommandOutput> => {
+  // @ts-ignore
+  return await client.send(new DescribePendingMaintenanceActionsCommand(input), ...args);
+};
+/**
+ * @private
+ */
+const makePagedRequest = async (
+  client: DatabaseMigrationService,
+  input: DescribePendingMaintenanceActionsCommandInput,
+  ...args: any
+): Promise<DescribePendingMaintenanceActionsCommandOutput> => {
+  // @ts-ignore
+  return await client.describePendingMaintenanceActions(input, ...args);
+};
+export async function* paginateDescribePendingMaintenanceActions(
+  config: DatabaseMigrationServicePaginationConfiguration,
+  input: DescribePendingMaintenanceActionsCommandInput,
+  ...additionalArguments: any
+): Paginator<DescribePendingMaintenanceActionsCommandOutput> {
+  // ToDo: replace with actual type instead of typeof input.Marker
+  let token: typeof input.Marker | undefined = config.startingToken || undefined;
+  let hasNext = true;
+  let page: DescribePendingMaintenanceActionsCommandOutput;
+  while (hasNext) {
+    input.Marker = token;
+    input["MaxRecords"] = config.pageSize;
+    if (config.client instanceof DatabaseMigrationService) {
+      page = await makePagedRequest(config.client, input, ...additionalArguments);
+    } else if (config.client instanceof DatabaseMigrationServiceClient) {
+      page = await makePagedClientRequest(config.client, input, ...additionalArguments);
+    } else {
+      throw new Error("Invalid client, expected DatabaseMigrationService | DatabaseMigrationServiceClient");
+    }
+    yield page;
+    token = page.Marker;
+    hasNext = !!token;
+  }
+  // @ts-ignore
+  return undefined;
+}