@aws-sdk/client-datazone 3.425.0

package/dist-es/models/models_1.js

@@ -0,0 +1,244 @@
+import { SENSITIVE_STRING } from "@smithy/smithy-client";
+import { AssetItemFilterSensitiveLog, AssetListingItemFilterSensitiveLog, AssetTypeItemFilterSensitiveLog, CustomParameterFilterSensitiveLog, DataProductSummaryFilterSensitiveLog, ImportFilterSensitiveLog, SubscribedListingFilterSensitiveLog, SubscribedPrincipalFilterSensitiveLog, UserProfileDetailsFilterSensitiveLog, } from "./models_0";
+export const RejectRuleBehavior = {
+    ALL: "ALL",
+    NONE: "NONE",
+};
+export const SearchOutputAdditionalAttribute = {
+    FORMS: "FORMS",
+};
+export const InventorySearchScope = {
+    ASSET: "ASSET",
+    GLOSSARY: "GLOSSARY",
+    GLOSSARY_TERM: "GLOSSARY_TERM",
+};
+export var SearchInventoryResultItem;
+(function (SearchInventoryResultItem) {
+    SearchInventoryResultItem.visit = (value, visitor) => {
+        if (value.glossaryItem !== undefined)
+            return visitor.glossaryItem(value.glossaryItem);
+        if (value.glossaryTermItem !== undefined)
+            return visitor.glossaryTermItem(value.glossaryTermItem);
+        if (value.assetItem !== undefined)
+            return visitor.assetItem(value.assetItem);
+        if (value.dataProductItem !== undefined)
+            return visitor.dataProductItem(value.dataProductItem);
+        return visitor._(value.$unknown[0], value.$unknown[1]);
+    };
+})(SearchInventoryResultItem || (SearchInventoryResultItem = {}));
+export const GroupSearchType = {
+    DATAZONE_SSO_GROUP: "DATAZONE_SSO_GROUP",
+    SSO_GROUP: "SSO_GROUP",
+};
+export var SearchResultItem;
+(function (SearchResultItem) {
+    SearchResultItem.visit = (value, visitor) => {
+        if (value.assetListing !== undefined)
+            return visitor.assetListing(value.assetListing);
+        return visitor._(value.$unknown[0], value.$unknown[1]);
+    };
+})(SearchResultItem || (SearchResultItem = {}));
+export const TypesSearchScope = {
+    ASSET_TYPE: "ASSET_TYPE",
+    FORM_TYPE: "FORM_TYPE",
+};
+export var SearchTypesResultItem;
+(function (SearchTypesResultItem) {
+    SearchTypesResultItem.visit = (value, visitor) => {
+        if (value.assetTypeItem !== undefined)
+            return visitor.assetTypeItem(value.assetTypeItem);
+        if (value.formTypeItem !== undefined)
+            return visitor.formTypeItem(value.formTypeItem);
+        return visitor._(value.$unknown[0], value.$unknown[1]);
+    };
+})(SearchTypesResultItem || (SearchTypesResultItem = {}));
+export const UserSearchType = {
+    DATAZONE_IAM_USER: "DATAZONE_IAM_USER",
+    DATAZONE_SSO_USER: "DATAZONE_SSO_USER",
+    DATAZONE_USER: "DATAZONE_USER",
+    SSO_USER: "SSO_USER",
+};
+export var FilterClause;
+(function (FilterClause) {
+    FilterClause.visit = (value, visitor) => {
+        if (value.filter !== undefined)
+            return visitor.filter(value.filter);
+        if (value.and !== undefined)
+            return visitor.and(value.and);
+        if (value.or !== undefined)
+            return visitor.or(value.or);
+        return visitor._(value.$unknown[0], value.$unknown[1]);
+    };
+})(FilterClause || (FilterClause = {}));
+export const SubscriptionTargetSummaryFilterSensitiveLog = (obj) => ({
+    ...obj,
+    ...(obj.name && { name: SENSITIVE_STRING }),
+});
+export const ListSubscriptionTargetsOutputFilterSensitiveLog = (obj) => ({
+    ...obj,
+    ...(obj.items && { items: obj.items.map((item) => SubscriptionTargetSummaryFilterSensitiveLog(item)) }),
+});
+export const RejectSubscriptionRequestInputFilterSensitiveLog = (obj) => ({
+    ...obj,
+    ...(obj.decisionComment && { decisionComment: SENSITIVE_STRING }),
+});
+export const RejectSubscriptionRequestOutputFilterSensitiveLog = (obj) => ({
+    ...obj,
+    ...(obj.requestReason && { requestReason: SENSITIVE_STRING }),
+    ...(obj.subscribedPrincipals && {
+        subscribedPrincipals: obj.subscribedPrincipals.map((item) => SubscribedPrincipalFilterSensitiveLog(item)),
+    }),
+    ...(obj.subscribedListings && {
+        subscribedListings: obj.subscribedListings.map((item) => SubscribedListingFilterSensitiveLog(item)),
+    }),
+    ...(obj.decisionComment && { decisionComment: SENSITIVE_STRING }),
+});
+export const RevokeSubscriptionOutputFilterSensitiveLog = (obj) => ({
+    ...obj,
+    ...(obj.subscribedPrincipal && {
+        subscribedPrincipal: SubscribedPrincipalFilterSensitiveLog(obj.subscribedPrincipal),
+    }),
+    ...(obj.subscribedListing && { subscribedListing: SubscribedListingFilterSensitiveLog(obj.subscribedListing) }),
+});
+export const GlossaryItemFilterSensitiveLog = (obj) => ({
+    ...obj,
+    ...(obj.name && { name: SENSITIVE_STRING }),
+    ...(obj.description && { description: SENSITIVE_STRING }),
+});
+export const GlossaryTermItemFilterSensitiveLog = (obj) => ({
+    ...obj,
+    ...(obj.name && { name: SENSITIVE_STRING }),
+    ...(obj.shortDescription && { shortDescription: SENSITIVE_STRING }),
+    ...(obj.longDescription && { longDescription: SENSITIVE_STRING }),
+});
+export const SearchInventoryResultItemFilterSensitiveLog = (obj) => {
+    if (obj.glossaryItem !== undefined)
+        return { glossaryItem: GlossaryItemFilterSensitiveLog(obj.glossaryItem) };
+    if (obj.glossaryTermItem !== undefined)
+        return { glossaryTermItem: GlossaryTermItemFilterSensitiveLog(obj.glossaryTermItem) };
+    if (obj.assetItem !== undefined)
+        return { assetItem: AssetItemFilterSensitiveLog(obj.assetItem) };
+    if (obj.dataProductItem !== undefined)
+        return { dataProductItem: DataProductSummaryFilterSensitiveLog(obj.dataProductItem) };
+    if (obj.$unknown !== undefined)
+        return { [obj.$unknown[0]]: "UNKNOWN" };
+};
+export const SearchOutputFilterSensitiveLog = (obj) => ({
+    ...obj,
+    ...(obj.items && { items: obj.items.map((item) => SearchInventoryResultItemFilterSensitiveLog(item)) }),
+});
+export const SearchGroupProfilesInputFilterSensitiveLog = (obj) => ({
+    ...obj,
+    ...(obj.searchText && { searchText: SENSITIVE_STRING }),
+});
+export const GroupProfileSummaryFilterSensitiveLog = (obj) => ({
+    ...obj,
+    ...(obj.groupName && { groupName: SENSITIVE_STRING }),
+});
+export const SearchGroupProfilesOutputFilterSensitiveLog = (obj) => ({
+    ...obj,
+    ...(obj.items && { items: obj.items.map((item) => GroupProfileSummaryFilterSensitiveLog(item)) }),
+});
+export const SearchResultItemFilterSensitiveLog = (obj) => {
+    if (obj.assetListing !== undefined)
+        return { assetListing: AssetListingItemFilterSensitiveLog(obj.assetListing) };
+    if (obj.$unknown !== undefined)
+        return { [obj.$unknown[0]]: "UNKNOWN" };
+};
+export const SearchListingsOutputFilterSensitiveLog = (obj) => ({
+    ...obj,
+    ...(obj.items && { items: obj.items.map((item) => SearchResultItemFilterSensitiveLog(item)) }),
+});
+export const FormTypeDataFilterSensitiveLog = (obj) => ({
+    ...obj,
+    ...(obj.name && { name: SENSITIVE_STRING }),
+    ...(obj.model && { model: SENSITIVE_STRING }),
+    ...(obj.description && { description: SENSITIVE_STRING }),
+    ...(obj.imports && { imports: obj.imports.map((item) => ImportFilterSensitiveLog(item)) }),
+});
+export const SearchTypesResultItemFilterSensitiveLog = (obj) => {
+    if (obj.assetTypeItem !== undefined)
+        return { assetTypeItem: AssetTypeItemFilterSensitiveLog(obj.assetTypeItem) };
+    if (obj.formTypeItem !== undefined)
+        return { formTypeItem: FormTypeDataFilterSensitiveLog(obj.formTypeItem) };
+    if (obj.$unknown !== undefined)
+        return { [obj.$unknown[0]]: "UNKNOWN" };
+};
+export const SearchTypesOutputFilterSensitiveLog = (obj) => ({
+    ...obj,
+    ...(obj.items && { items: obj.items.map((item) => SearchTypesResultItemFilterSensitiveLog(item)) }),
+});
+export const SearchUserProfilesInputFilterSensitiveLog = (obj) => ({
+    ...obj,
+    ...(obj.searchText && { searchText: SENSITIVE_STRING }),
+});
+export const UserProfileSummaryFilterSensitiveLog = (obj) => ({
+    ...obj,
+    ...(obj.details && { details: UserProfileDetailsFilterSensitiveLog(obj.details) }),
+});
+export const SearchUserProfilesOutputFilterSensitiveLog = (obj) => ({
+    ...obj,
+    ...(obj.items && { items: obj.items.map((item) => UserProfileSummaryFilterSensitiveLog(item)) }),
+});
+export const UpdateEnvironmentOutputFilterSensitiveLog = (obj) => ({
+    ...obj,
+    ...(obj.name && { name: SENSITIVE_STRING }),
+    ...(obj.description && { description: SENSITIVE_STRING }),
+    ...(obj.userParameters && {
+        userParameters: obj.userParameters.map((item) => CustomParameterFilterSensitiveLog(item)),
+    }),
+    ...(obj.provisioningProperties && { provisioningProperties: obj.provisioningProperties }),
+});
+export const UpdateEnvironmentProfileInputFilterSensitiveLog = (obj) => ({
+    ...obj,
+    ...(obj.name && { name: SENSITIVE_STRING }),
+});
+export const UpdateEnvironmentProfileOutputFilterSensitiveLog = (obj) => ({
+    ...obj,
+    ...(obj.name && { name: SENSITIVE_STRING }),
+    ...(obj.description && { description: SENSITIVE_STRING }),
+    ...(obj.userParameters && {
+        userParameters: obj.userParameters.map((item) => CustomParameterFilterSensitiveLog(item)),
+    }),
+});
+export const UpdateGroupProfileOutputFilterSensitiveLog = (obj) => ({
+    ...obj,
+    ...(obj.groupName && { groupName: SENSITIVE_STRING }),
+});
+export const UpdateProjectInputFilterSensitiveLog = (obj) => ({
+    ...obj,
+    ...(obj.name && { name: SENSITIVE_STRING }),
+    ...(obj.description && { description: SENSITIVE_STRING }),
+});
+export const UpdateProjectOutputFilterSensitiveLog = (obj) => ({
+    ...obj,
+    ...(obj.name && { name: SENSITIVE_STRING }),
+    ...(obj.description && { description: SENSITIVE_STRING }),
+});
+export const UpdateSubscriptionRequestInputFilterSensitiveLog = (obj) => ({
+    ...obj,
+    ...(obj.requestReason && { requestReason: SENSITIVE_STRING }),
+});
+export const UpdateSubscriptionRequestOutputFilterSensitiveLog = (obj) => ({
+    ...obj,
+    ...(obj.requestReason && { requestReason: SENSITIVE_STRING }),
+    ...(obj.subscribedPrincipals && {
+        subscribedPrincipals: obj.subscribedPrincipals.map((item) => SubscribedPrincipalFilterSensitiveLog(item)),
+    }),
+    ...(obj.subscribedListings && {
+        subscribedListings: obj.subscribedListings.map((item) => SubscribedListingFilterSensitiveLog(item)),
+    }),
+    ...(obj.decisionComment && { decisionComment: SENSITIVE_STRING }),
+});
+export const UpdateSubscriptionTargetInputFilterSensitiveLog = (obj) => ({
+    ...obj,
+    ...(obj.name && { name: SENSITIVE_STRING }),
+});
+export const UpdateSubscriptionTargetOutputFilterSensitiveLog = (obj) => ({
+    ...obj,
+    ...(obj.name && { name: SENSITIVE_STRING }),
+});
+export const UpdateUserProfileOutputFilterSensitiveLog = (obj) => ({
+    ...obj,
+    ...(obj.details && { details: UserProfileDetailsFilterSensitiveLog(obj.details) }),
+});

package/dist-es/pagination/Interfaces.js

@@ -0,0 +1 @@
+export {};

package/dist-es/pagination/ListAssetRevisionsPaginator.js

@@ -0,0 +1,25 @@
+import { ListAssetRevisionsCommand, } from "../commands/ListAssetRevisionsCommand";
+import { DataZoneClient } from "../DataZoneClient";
+const makePagedClientRequest = async (client, input, ...args) => {
+    return await client.send(new ListAssetRevisionsCommand(input), ...args);
+};
+export async function* paginateListAssetRevisions(config, input, ...additionalArguments) {
+    let token = config.startingToken || undefined;
+    let hasNext = true;
+    let page;
+    while (hasNext) {
+        input.nextToken = token;
+        input["maxResults"] = config.pageSize;
+        if (config.client instanceof DataZoneClient) {
+            page = await makePagedClientRequest(config.client, input, ...additionalArguments);
+        }
+        else {
+            throw new Error("Invalid client, expected DataZone | DataZoneClient");
+        }
+        yield page;
+        const prevToken = token;
+        token = page.nextToken;
+        hasNext = !!(token && (!config.stopOnSameToken || token !== prevToken));
+    }
+    return undefined;
+}

package/dist-es/pagination/ListDataSourceRunActivitiesPaginator.js

@@ -0,0 +1,25 @@
+import { ListDataSourceRunActivitiesCommand, } from "../commands/ListDataSourceRunActivitiesCommand";
+import { DataZoneClient } from "../DataZoneClient";
+const makePagedClientRequest = async (client, input, ...args) => {
+    return await client.send(new ListDataSourceRunActivitiesCommand(input), ...args);
+};
+export async function* paginateListDataSourceRunActivities(config, input, ...additionalArguments) {
+    let token = config.startingToken || undefined;
+    let hasNext = true;
+    let page;
+    while (hasNext) {
+        input.nextToken = token;
+        input["maxResults"] = config.pageSize;
+        if (config.client instanceof DataZoneClient) {
+            page = await makePagedClientRequest(config.client, input, ...additionalArguments);
+        }
+        else {
+            throw new Error("Invalid client, expected DataZone | DataZoneClient");
+        }
+        yield page;
+        const prevToken = token;
+        token = page.nextToken;
+        hasNext = !!(token && (!config.stopOnSameToken || token !== prevToken));
+    }
+    return undefined;
+}

package/dist-es/pagination/ListDataSourceRunsPaginator.js

@@ -0,0 +1,25 @@
+import { ListDataSourceRunsCommand, } from "../commands/ListDataSourceRunsCommand";
+import { DataZoneClient } from "../DataZoneClient";
+const makePagedClientRequest = async (client, input, ...args) => {
+    return await client.send(new ListDataSourceRunsCommand(input), ...args);
+};
+export async function* paginateListDataSourceRuns(config, input, ...additionalArguments) {
+    let token = config.startingToken || undefined;
+    let hasNext = true;
+    let page;
+    while (hasNext) {
+        input.nextToken = token;
+        input["maxResults"] = config.pageSize;
+        if (config.client instanceof DataZoneClient) {
+            page = await makePagedClientRequest(config.client, input, ...additionalArguments);
+        }
+        else {
+            throw new Error("Invalid client, expected DataZone | DataZoneClient");
+        }
+        yield page;
+        const prevToken = token;
+        token = page.nextToken;
+        hasNext = !!(token && (!config.stopOnSameToken || token !== prevToken));
+    }
+    return undefined;
+}

package/dist-es/pagination/ListDataSourcesPaginator.js

@@ -0,0 +1,25 @@
+import { ListDataSourcesCommand, } from "../commands/ListDataSourcesCommand";
+import { DataZoneClient } from "../DataZoneClient";
+const makePagedClientRequest = async (client, input, ...args) => {
+    return await client.send(new ListDataSourcesCommand(input), ...args);
+};
+export async function* paginateListDataSources(config, input, ...additionalArguments) {
+    let token = config.startingToken || undefined;
+    let hasNext = true;
+    let page;
+    while (hasNext) {
+        input.nextToken = token;
+        input["maxResults"] = config.pageSize;
+        if (config.client instanceof DataZoneClient) {
+            page = await makePagedClientRequest(config.client, input, ...additionalArguments);
+        }
+        else {
+            throw new Error("Invalid client, expected DataZone | DataZoneClient");
+        }
+        yield page;
+        const prevToken = token;
+        token = page.nextToken;
+        hasNext = !!(token && (!config.stopOnSameToken || token !== prevToken));
+    }
+    return undefined;
+}

package/dist-es/pagination/ListDomainsPaginator.js

@@ -0,0 +1,25 @@
+import { ListDomainsCommand } from "../commands/ListDomainsCommand";
+import { DataZoneClient } from "../DataZoneClient";
+const makePagedClientRequest = async (client, input, ...args) => {
+    return await client.send(new ListDomainsCommand(input), ...args);
+};
+export async function* paginateListDomains(config, input, ...additionalArguments) {
+    let token = config.startingToken || undefined;
+    let hasNext = true;
+    let page;
+    while (hasNext) {
+        input.nextToken = token;
+        input["maxResults"] = config.pageSize;
+        if (config.client instanceof DataZoneClient) {
+            page = await makePagedClientRequest(config.client, input, ...additionalArguments);
+        }
+        else {
+            throw new Error("Invalid client, expected DataZone | DataZoneClient");
+        }
+        yield page;
+        const prevToken = token;
+        token = page.nextToken;
+        hasNext = !!(token && (!config.stopOnSameToken || token !== prevToken));
+    }
+    return undefined;
+}

package/dist-es/pagination/ListEnvironmentBlueprintConfigurationsPaginator.js

@@ -0,0 +1,25 @@
+import { ListEnvironmentBlueprintConfigurationsCommand, } from "../commands/ListEnvironmentBlueprintConfigurationsCommand";
+import { DataZoneClient } from "../DataZoneClient";
+const makePagedClientRequest = async (client, input, ...args) => {
+    return await client.send(new ListEnvironmentBlueprintConfigurationsCommand(input), ...args);
+};
+export async function* paginateListEnvironmentBlueprintConfigurations(config, input, ...additionalArguments) {
+    let token = config.startingToken || undefined;
+    let hasNext = true;
+    let page;
+    while (hasNext) {
+        input.nextToken = token;
+        input["maxResults"] = config.pageSize;
+        if (config.client instanceof DataZoneClient) {
+            page = await makePagedClientRequest(config.client, input, ...additionalArguments);
+        }
+        else {
+            throw new Error("Invalid client, expected DataZone | DataZoneClient");
+        }
+        yield page;
+        const prevToken = token;
+        token = page.nextToken;
+        hasNext = !!(token && (!config.stopOnSameToken || token !== prevToken));
+    }
+    return undefined;
+}

package/dist-es/pagination/ListEnvironmentBlueprintsPaginator.js

@@ -0,0 +1,25 @@
+import { ListEnvironmentBlueprintsCommand, } from "../commands/ListEnvironmentBlueprintsCommand";
+import { DataZoneClient } from "../DataZoneClient";
+const makePagedClientRequest = async (client, input, ...args) => {
+    return await client.send(new ListEnvironmentBlueprintsCommand(input), ...args);
+};
+export async function* paginateListEnvironmentBlueprints(config, input, ...additionalArguments) {
+    let token = config.startingToken || undefined;
+    let hasNext = true;
+    let page;
+    while (hasNext) {
+        input.nextToken = token;
+        input["maxResults"] = config.pageSize;
+        if (config.client instanceof DataZoneClient) {
+            page = await makePagedClientRequest(config.client, input, ...additionalArguments);
+        }
+        else {
+            throw new Error("Invalid client, expected DataZone | DataZoneClient");
+        }
+        yield page;
+        const prevToken = token;
+        token = page.nextToken;
+        hasNext = !!(token && (!config.stopOnSameToken || token !== prevToken));
+    }
+    return undefined;
+}

package/dist-es/pagination/ListEnvironmentProfilesPaginator.js

@@ -0,0 +1,25 @@
+import { ListEnvironmentProfilesCommand, } from "../commands/ListEnvironmentProfilesCommand";
+import { DataZoneClient } from "../DataZoneClient";
+const makePagedClientRequest = async (client, input, ...args) => {
+    return await client.send(new ListEnvironmentProfilesCommand(input), ...args);
+};
+export async function* paginateListEnvironmentProfiles(config, input, ...additionalArguments) {
+    let token = config.startingToken || undefined;
+    let hasNext = true;
+    let page;
+    while (hasNext) {
+        input.nextToken = token;
+        input["maxResults"] = config.pageSize;
+        if (config.client instanceof DataZoneClient) {
+            page = await makePagedClientRequest(config.client, input, ...additionalArguments);
+        }
+        else {
+            throw new Error("Invalid client, expected DataZone | DataZoneClient");
+        }
+        yield page;
+        const prevToken = token;
+        token = page.nextToken;
+        hasNext = !!(token && (!config.stopOnSameToken || token !== prevToken));
+    }
+    return undefined;
+}

package/dist-es/pagination/ListEnvironmentsPaginator.js

@@ -0,0 +1,25 @@
+import { ListEnvironmentsCommand, } from "../commands/ListEnvironmentsCommand";
+import { DataZoneClient } from "../DataZoneClient";
+const makePagedClientRequest = async (client, input, ...args) => {
+    return await client.send(new ListEnvironmentsCommand(input), ...args);
+};
+export async function* paginateListEnvironments(config, input, ...additionalArguments) {
+    let token = config.startingToken || undefined;
+    let hasNext = true;
+    let page;
+    while (hasNext) {
+        input.nextToken = token;
+        input["maxResults"] = config.pageSize;
+        if (config.client instanceof DataZoneClient) {
+            page = await makePagedClientRequest(config.client, input, ...additionalArguments);
+        }
+        else {
+            throw new Error("Invalid client, expected DataZone | DataZoneClient");
+        }
+        yield page;
+        const prevToken = token;
+        token = page.nextToken;
+        hasNext = !!(token && (!config.stopOnSameToken || token !== prevToken));
+    }
+    return undefined;
+}

package/dist-es/pagination/ListNotificationsPaginator.js

@@ -0,0 +1,25 @@
+import { ListNotificationsCommand, } from "../commands/ListNotificationsCommand";
+import { DataZoneClient } from "../DataZoneClient";
+const makePagedClientRequest = async (client, input, ...args) => {
+    return await client.send(new ListNotificationsCommand(input), ...args);
+};
+export async function* paginateListNotifications(config, input, ...additionalArguments) {
+    let token = config.startingToken || undefined;
+    let hasNext = true;
+    let page;
+    while (hasNext) {
+        input.nextToken = token;
+        input["maxResults"] = config.pageSize;
+        if (config.client instanceof DataZoneClient) {
+            page = await makePagedClientRequest(config.client, input, ...additionalArguments);
+        }
+        else {
+            throw new Error("Invalid client, expected DataZone | DataZoneClient");
+        }
+        yield page;
+        const prevToken = token;
+        token = page.nextToken;
+        hasNext = !!(token && (!config.stopOnSameToken || token !== prevToken));
+    }
+    return undefined;
+}

package/dist-es/pagination/ListProjectMembershipsPaginator.js

@@ -0,0 +1,25 @@
+import { ListProjectMembershipsCommand, } from "../commands/ListProjectMembershipsCommand";
+import { DataZoneClient } from "../DataZoneClient";
+const makePagedClientRequest = async (client, input, ...args) => {
+    return await client.send(new ListProjectMembershipsCommand(input), ...args);
+};
+export async function* paginateListProjectMemberships(config, input, ...additionalArguments) {
+    let token = config.startingToken || undefined;
+    let hasNext = true;
+    let page;
+    while (hasNext) {
+        input.nextToken = token;
+        input["maxResults"] = config.pageSize;
+        if (config.client instanceof DataZoneClient) {
+            page = await makePagedClientRequest(config.client, input, ...additionalArguments);
+        }
+        else {
+            throw new Error("Invalid client, expected DataZone | DataZoneClient");
+        }
+        yield page;
+        const prevToken = token;
+        token = page.nextToken;
+        hasNext = !!(token && (!config.stopOnSameToken || token !== prevToken));
+    }
+    return undefined;
+}

package/dist-es/pagination/ListProjectsPaginator.js

@@ -0,0 +1,25 @@
+import { ListProjectsCommand, } from "../commands/ListProjectsCommand";
+import { DataZoneClient } from "../DataZoneClient";
+const makePagedClientRequest = async (client, input, ...args) => {
+    return await client.send(new ListProjectsCommand(input), ...args);
+};
+export async function* paginateListProjects(config, input, ...additionalArguments) {
+    let token = config.startingToken || undefined;
+    let hasNext = true;
+    let page;
+    while (hasNext) {
+        input.nextToken = token;
+        input["maxResults"] = config.pageSize;
+        if (config.client instanceof DataZoneClient) {
+            page = await makePagedClientRequest(config.client, input, ...additionalArguments);
+        }
+        else {
+            throw new Error("Invalid client, expected DataZone | DataZoneClient");
+        }
+        yield page;
+        const prevToken = token;
+        token = page.nextToken;
+        hasNext = !!(token && (!config.stopOnSameToken || token !== prevToken));
+    }
+    return undefined;
+}

package/dist-es/pagination/ListSubscriptionGrantsPaginator.js

@@ -0,0 +1,25 @@
+import { ListSubscriptionGrantsCommand, } from "../commands/ListSubscriptionGrantsCommand";
+import { DataZoneClient } from "../DataZoneClient";
+const makePagedClientRequest = async (client, input, ...args) => {
+    return await client.send(new ListSubscriptionGrantsCommand(input), ...args);
+};
+export async function* paginateListSubscriptionGrants(config, input, ...additionalArguments) {
+    let token = config.startingToken || undefined;
+    let hasNext = true;
+    let page;
+    while (hasNext) {
+        input.nextToken = token;
+        input["maxResults"] = config.pageSize;
+        if (config.client instanceof DataZoneClient) {
+            page = await makePagedClientRequest(config.client, input, ...additionalArguments);
+        }
+        else {
+            throw new Error("Invalid client, expected DataZone | DataZoneClient");
+        }
+        yield page;
+        const prevToken = token;
+        token = page.nextToken;
+        hasNext = !!(token && (!config.stopOnSameToken || token !== prevToken));
+    }
+    return undefined;
+}

package/dist-es/pagination/ListSubscriptionRequestsPaginator.js

@@ -0,0 +1,25 @@
+import { ListSubscriptionRequestsCommand, } from "../commands/ListSubscriptionRequestsCommand";
+import { DataZoneClient } from "../DataZoneClient";
+const makePagedClientRequest = async (client, input, ...args) => {
+    return await client.send(new ListSubscriptionRequestsCommand(input), ...args);
+};
+export async function* paginateListSubscriptionRequests(config, input, ...additionalArguments) {
+    let token = config.startingToken || undefined;
+    let hasNext = true;
+    let page;
+    while (hasNext) {
+        input.nextToken = token;
+        input["maxResults"] = config.pageSize;
+        if (config.client instanceof DataZoneClient) {
+            page = await makePagedClientRequest(config.client, input, ...additionalArguments);
+        }
+        else {
+            throw new Error("Invalid client, expected DataZone | DataZoneClient");
+        }
+        yield page;
+        const prevToken = token;
+        token = page.nextToken;
+        hasNext = !!(token && (!config.stopOnSameToken || token !== prevToken));
+    }
+    return undefined;
+}

package/dist-es/pagination/ListSubscriptionTargetsPaginator.js

@@ -0,0 +1,25 @@
+import { ListSubscriptionTargetsCommand, } from "../commands/ListSubscriptionTargetsCommand";
+import { DataZoneClient } from "../DataZoneClient";
+const makePagedClientRequest = async (client, input, ...args) => {
+    return await client.send(new ListSubscriptionTargetsCommand(input), ...args);
+};
+export async function* paginateListSubscriptionTargets(config, input, ...additionalArguments) {
+    let token = config.startingToken || undefined;
+    let hasNext = true;
+    let page;
+    while (hasNext) {
+        input.nextToken = token;
+        input["maxResults"] = config.pageSize;
+        if (config.client instanceof DataZoneClient) {
+            page = await makePagedClientRequest(config.client, input, ...additionalArguments);
+        }
+        else {
+            throw new Error("Invalid client, expected DataZone | DataZoneClient");
+        }
+        yield page;
+        const prevToken = token;
+        token = page.nextToken;
+        hasNext = !!(token && (!config.stopOnSameToken || token !== prevToken));
+    }
+    return undefined;
+}

package/dist-es/pagination/ListSubscriptionsPaginator.js

@@ -0,0 +1,25 @@
+import { ListSubscriptionsCommand, } from "../commands/ListSubscriptionsCommand";
+import { DataZoneClient } from "../DataZoneClient";
+const makePagedClientRequest = async (client, input, ...args) => {
+    return await client.send(new ListSubscriptionsCommand(input), ...args);
+};
+export async function* paginateListSubscriptions(config, input, ...additionalArguments) {
+    let token = config.startingToken || undefined;
+    let hasNext = true;
+    let page;
+    while (hasNext) {
+        input.nextToken = token;
+        input["maxResults"] = config.pageSize;
+        if (config.client instanceof DataZoneClient) {
+            page = await makePagedClientRequest(config.client, input, ...additionalArguments);
+        }
+        else {
+            throw new Error("Invalid client, expected DataZone | DataZoneClient");
+        }
+        yield page;
+        const prevToken = token;
+        token = page.nextToken;
+        hasNext = !!(token && (!config.stopOnSameToken || token !== prevToken));
+    }
+    return undefined;
+}