pulumi-ns1 3.3.0a1719035723__py3-none-any.whl → 3.3.1__py3-none-any.whl

pulumi_ns1/__init__.py

@@ -22,6 +22,8 @@ from .notify_list import *
 from .provider import *
 from .pulsar_job import *
 from .record import *
+from .redirect import *
+from .redirect_certificate import *
 from .subnet import *
 from .team import *
 from .tsigkey import *
@@ -128,6 +130,22 @@ _utilities.register(
    "ns1:index/record:Record": "Record"
   }
  },
+ {
+  "pkg": "ns1",
+  "mod": "index/redirect",
+  "fqn": "pulumi_ns1",
+  "classes": {
+   "ns1:index/redirect:Redirect": "Redirect"
+  }
+ },
+ {
+  "pkg": "ns1",
+  "mod": "index/redirectCertificate",
+  "fqn": "pulumi_ns1",
+  "classes": {
+   "ns1:index/redirectCertificate:RedirectCertificate": "RedirectCertificate"
+  }
+ },
  {
   "pkg": "ns1",
   "mod": "index/subnet",

pulumi_ns1/_utilities.py

@@ -4,6 +4,7 @@
 
 
 import asyncio
+import functools
 import importlib.metadata
 import importlib.util
 import inspect
@@ -11,6 +12,7 @@ import json
 import os
 import sys
 import typing
+import warnings
 
 import pulumi
 import pulumi.runtime
@@ -19,6 +21,8 @@ from pulumi.runtime.sync_await import _sync_await
 from semver import VersionInfo as SemverVersion
 from parver import Version as PEP440Version
 
+C = typing.TypeVar("C", bound=typing.Callable)
+
 
 def get_env(*args):
     for v in args:
@@ -287,5 +291,36 @@ async def _await_output(o: pulumi.Output[typing.Any]) -> typing.Tuple[object, bo
         await o._resources,
     )
 
+
+# This is included to provide an upgrade path for users who are using a version
+# of the Pulumi SDK (<3.121.0) that does not include the `deprecated` decorator.
+def deprecated(message: str) -> typing.Callable[[C], C]:
+    """
+    Decorator to indicate a function is deprecated.
+
+    As well as inserting appropriate statements to indicate that the function is
+    deprecated, this decorator also tags the function with a special attribute
+    so that Pulumi code can detect that it is deprecated and react appropriately
+    in certain situations.
+
+    message is the deprecation message that should be printed if the function is called.
+    """
+
+    def decorator(fn: C) -> C:
+        if not callable(fn):
+            raise TypeError("Expected fn to be callable")
+
+        @functools.wraps(fn)
+        def deprecated_fn(*args, **kwargs):
+            warnings.warn(message)
+            pulumi.warn(f"{fn.__name__} is deprecated: {message}")
+
+            return fn(*args, **kwargs)
+
+        deprecated_fn.__dict__["_pulumi_deprecated_callable"] = fn
+        return typing.cast(C, deprecated_fn)
+
+    return decorator
+
 def get_plugin_download_url():
 	return None

pulumi_ns1/api_key.py

@@ -206,13 +206,11 @@ class APIKeyArgs:
 
     @property
     @pulumi.getter(name="accountManagePlan")
+    @_utilities.deprecated("""obsolete, should no longer be used""")
     def account_manage_plan(self) -> Optional[pulumi.Input[bool]]:
         """
         No longer in use.
         """
-        warnings.warn("""obsolete, should no longer be used""", DeprecationWarning)
-        pulumi.log.warn("""account_manage_plan is deprecated: obsolete, should no longer be used""")
-
         return pulumi.get(self, "account_manage_plan")
 
     @account_manage_plan.setter
@@ -746,13 +744,11 @@ class _APIKeyState:
 
     @property
     @pulumi.getter(name="accountManagePlan")
+    @_utilities.deprecated("""obsolete, should no longer be used""")
     def account_manage_plan(self) -> Optional[pulumi.Input[bool]]:
         """
         No longer in use.
         """
-        warnings.warn("""obsolete, should no longer be used""", DeprecationWarning)
-        pulumi.log.warn("""account_manage_plan is deprecated: obsolete, should no longer be used""")
-
         return pulumi.get(self, "account_manage_plan")
 
     @account_manage_plan.setter
@@ -1538,13 +1534,11 @@ class APIKey(pulumi.CustomResource):
 
     @property
     @pulumi.getter(name="accountManagePlan")
+    @_utilities.deprecated("""obsolete, should no longer be used""")
     def account_manage_plan(self) -> pulumi.Output[Optional[bool]]:
         """
         No longer in use.
         """
-        warnings.warn("""obsolete, should no longer be used""", DeprecationWarning)
-        pulumi.log.warn("""account_manage_plan is deprecated: obsolete, should no longer be used""")
-
         return pulumi.get(self, "account_manage_plan")
 
     @property

pulumi_ns1/pulumi-plugin.json

@@ -1,5 +1,5 @@
 {
   "resource": true,
   "name": "ns1",
-  "version": "3.3.0-alpha.1719035723"
+  "version": "3.3.1"
 }

pulumi_ns1/record.py

@@ -204,10 +204,8 @@ class RecordArgs:
 
     @property
     @pulumi.getter(name="shortAnswers")
+    @_utilities.deprecated("""short_answers will be deprecated in a future release. It is suggested to migrate to a regular \"answers\" block.""")
     def short_answers(self) -> Optional[pulumi.Input[Sequence[pulumi.Input[str]]]]:
-        warnings.warn("""short_answers will be deprecated in a future release. It is suggested to migrate to a regular \"answers\" block.""", DeprecationWarning)
-        pulumi.log.warn("""short_answers is deprecated: short_answers will be deprecated in a future release. It is suggested to migrate to a regular \"answers\" block.""")
-
         return pulumi.get(self, "short_answers")
 
     @short_answers.setter
@@ -423,10 +421,8 @@ class _RecordState:
 
     @property
     @pulumi.getter(name="shortAnswers")
+    @_utilities.deprecated("""short_answers will be deprecated in a future release. It is suggested to migrate to a regular \"answers\" block.""")
     def short_answers(self) -> Optional[pulumi.Input[Sequence[pulumi.Input[str]]]]:
-        warnings.warn("""short_answers will be deprecated in a future release. It is suggested to migrate to a regular \"answers\" block.""", DeprecationWarning)
-        pulumi.log.warn("""short_answers is deprecated: short_answers will be deprecated in a future release. It is suggested to migrate to a regular \"answers\" block.""")
-
         return pulumi.get(self, "short_answers")
 
     @short_answers.setter
@@ -1001,10 +997,8 @@ class Record(pulumi.CustomResource):
 
     @property
     @pulumi.getter(name="shortAnswers")
+    @_utilities.deprecated("""short_answers will be deprecated in a future release. It is suggested to migrate to a regular \"answers\" block.""")
     def short_answers(self) -> pulumi.Output[Optional[Sequence[str]]]:
-        warnings.warn("""short_answers will be deprecated in a future release. It is suggested to migrate to a regular \"answers\" block.""", DeprecationWarning)
-        pulumi.log.warn("""short_answers is deprecated: short_answers will be deprecated in a future release. It is suggested to migrate to a regular \"answers\" block.""")
-
         return pulumi.get(self, "short_answers")
 
     @property

pulumi_ns1/redirect.py

@@ -0,0 +1,723 @@
+# coding=utf-8
+# *** WARNING: this file was generated by the Pulumi Terraform Bridge (tfgen) Tool. ***
+# *** Do not edit by hand unless you're certain you know what you are doing! ***
+
+import copy
+import warnings
+import pulumi
+import pulumi.runtime
+from typing import Any, Mapping, Optional, Sequence, Union, overload
+from . import _utilities
+
+__all__ = ['RedirectArgs', 'Redirect']
+
+@pulumi.input_type
+class RedirectArgs:
+    def __init__(__self__, *,
+                 domain: pulumi.Input[str],
+                 path: pulumi.Input[str],
+                 target: pulumi.Input[str],
+                 certificate_id: Optional[pulumi.Input[str]] = None,
+                 forwarding_mode: Optional[pulumi.Input[str]] = None,
+                 forwarding_type: Optional[pulumi.Input[str]] = None,
+                 https_forced: Optional[pulumi.Input[bool]] = None,
+                 query_forwarding: Optional[pulumi.Input[bool]] = None,
+                 tags: Optional[pulumi.Input[Sequence[pulumi.Input[str]]]] = None):
+        """
+        The set of arguments for constructing a Redirect resource.
+        :param pulumi.Input[str] domain: The domain the redirect refers to.
+        :param pulumi.Input[str] path: The path on the domain to redirect from.
+        :param pulumi.Input[str] target: The URL to redirect to.
+        :param pulumi.Input[str] certificate_id: The certificate redirect id.
+        :param pulumi.Input[str] forwarding_mode: How the target is interpreted:
+               * __all__       appends the entire incoming path to the target destination;
+               * __capture__   appends only the part of the incoming path corresponding to the wildcard (*);
+               * __none__      does not append any part of the incoming path.
+        :param pulumi.Input[str] forwarding_type: How the redirect is executed:
+               * __permanent__ (HTTP 301) indicates to search engines that they should remove the old page from
+               their database and replace it with the new target page (this is recommended for SEO);
+               * __temporary__ (HTTP 302) less common, indicates that search engines should keep the old domain or
+               page indexed as the redirect is only temporary (while both pages might appear in the
+               search results, a temporary redirect suggests to the search engine that it should
+               prefer the new target page);
+               * __masking__   preserves the redirected domain in the browser's address bar (this lets users see the
+               address they entered, even though the displayed content comes from a different web page).
+        :param pulumi.Input[bool] https_forced: Forces redirect for users that try to visit HTTP domain to HTTPS instead.
+        :param pulumi.Input[bool] query_forwarding: Enables the query string of a URL to be applied directly to the new target URL.
+        :param pulumi.Input[Sequence[pulumi.Input[str]]] tags: Tags associated with the configuration.
+        """
+        pulumi.set(__self__, "domain", domain)
+        pulumi.set(__self__, "path", path)
+        pulumi.set(__self__, "target", target)
+        if certificate_id is not None:
+            pulumi.set(__self__, "certificate_id", certificate_id)
+        if forwarding_mode is not None:
+            pulumi.set(__self__, "forwarding_mode", forwarding_mode)
+        if forwarding_type is not None:
+            pulumi.set(__self__, "forwarding_type", forwarding_type)
+        if https_forced is not None:
+            pulumi.set(__self__, "https_forced", https_forced)
+        if query_forwarding is not None:
+            pulumi.set(__self__, "query_forwarding", query_forwarding)
+        if tags is not None:
+            pulumi.set(__self__, "tags", tags)
+
+    @property
+    @pulumi.getter
+    def domain(self) -> pulumi.Input[str]:
+        """
+        The domain the redirect refers to.
+        """
+        return pulumi.get(self, "domain")
+
+    @domain.setter
+    def domain(self, value: pulumi.Input[str]):
+        pulumi.set(self, "domain", value)
+
+    @property
+    @pulumi.getter
+    def path(self) -> pulumi.Input[str]:
+        """
+        The path on the domain to redirect from.
+        """
+        return pulumi.get(self, "path")
+
+    @path.setter
+    def path(self, value: pulumi.Input[str]):
+        pulumi.set(self, "path", value)
+
+    @property
+    @pulumi.getter
+    def target(self) -> pulumi.Input[str]:
+        """
+        The URL to redirect to.
+        """
+        return pulumi.get(self, "target")
+
+    @target.setter
+    def target(self, value: pulumi.Input[str]):
+        pulumi.set(self, "target", value)
+
+    @property
+    @pulumi.getter(name="certificateId")
+    def certificate_id(self) -> Optional[pulumi.Input[str]]:
+        """
+        The certificate redirect id.
+        """
+        return pulumi.get(self, "certificate_id")
+
+    @certificate_id.setter
+    def certificate_id(self, value: Optional[pulumi.Input[str]]):
+        pulumi.set(self, "certificate_id", value)
+
+    @property
+    @pulumi.getter(name="forwardingMode")
+    def forwarding_mode(self) -> Optional[pulumi.Input[str]]:
+        """
+        How the target is interpreted:
+        * __all__       appends the entire incoming path to the target destination;
+        * __capture__   appends only the part of the incoming path corresponding to the wildcard (*);
+        * __none__      does not append any part of the incoming path.
+        """
+        return pulumi.get(self, "forwarding_mode")
+
+    @forwarding_mode.setter
+    def forwarding_mode(self, value: Optional[pulumi.Input[str]]):
+        pulumi.set(self, "forwarding_mode", value)
+
+    @property
+    @pulumi.getter(name="forwardingType")
+    def forwarding_type(self) -> Optional[pulumi.Input[str]]:
+        """
+        How the redirect is executed:
+        * __permanent__ (HTTP 301) indicates to search engines that they should remove the old page from
+        their database and replace it with the new target page (this is recommended for SEO);
+        * __temporary__ (HTTP 302) less common, indicates that search engines should keep the old domain or
+        page indexed as the redirect is only temporary (while both pages might appear in the
+        search results, a temporary redirect suggests to the search engine that it should
+        prefer the new target page);
+        * __masking__   preserves the redirected domain in the browser's address bar (this lets users see the
+        address they entered, even though the displayed content comes from a different web page).
+        """
+        return pulumi.get(self, "forwarding_type")
+
+    @forwarding_type.setter
+    def forwarding_type(self, value: Optional[pulumi.Input[str]]):
+        pulumi.set(self, "forwarding_type", value)
+
+    @property
+    @pulumi.getter(name="httpsForced")
+    def https_forced(self) -> Optional[pulumi.Input[bool]]:
+        """
+        Forces redirect for users that try to visit HTTP domain to HTTPS instead.
+        """
+        return pulumi.get(self, "https_forced")
+
+    @https_forced.setter
+    def https_forced(self, value: Optional[pulumi.Input[bool]]):
+        pulumi.set(self, "https_forced", value)
+
+    @property
+    @pulumi.getter(name="queryForwarding")
+    def query_forwarding(self) -> Optional[pulumi.Input[bool]]:
+        """
+        Enables the query string of a URL to be applied directly to the new target URL.
+        """
+        return pulumi.get(self, "query_forwarding")
+
+    @query_forwarding.setter
+    def query_forwarding(self, value: Optional[pulumi.Input[bool]]):
+        pulumi.set(self, "query_forwarding", value)
+
+    @property
+    @pulumi.getter
+    def tags(self) -> Optional[pulumi.Input[Sequence[pulumi.Input[str]]]]:
+        """
+        Tags associated with the configuration.
+        """
+        return pulumi.get(self, "tags")
+
+    @tags.setter
+    def tags(self, value: Optional[pulumi.Input[Sequence[pulumi.Input[str]]]]):
+        pulumi.set(self, "tags", value)
+
+
+@pulumi.input_type
+class _RedirectState:
+    def __init__(__self__, *,
+                 certificate_id: Optional[pulumi.Input[str]] = None,
+                 domain: Optional[pulumi.Input[str]] = None,
+                 forwarding_mode: Optional[pulumi.Input[str]] = None,
+                 forwarding_type: Optional[pulumi.Input[str]] = None,
+                 https_enabled: Optional[pulumi.Input[bool]] = None,
+                 https_forced: Optional[pulumi.Input[bool]] = None,
+                 last_updated: Optional[pulumi.Input[int]] = None,
+                 path: Optional[pulumi.Input[str]] = None,
+                 query_forwarding: Optional[pulumi.Input[bool]] = None,
+                 tags: Optional[pulumi.Input[Sequence[pulumi.Input[str]]]] = None,
+                 target: Optional[pulumi.Input[str]] = None):
+        """
+        Input properties used for looking up and filtering Redirect resources.
+        :param pulumi.Input[str] certificate_id: The certificate redirect id.
+        :param pulumi.Input[str] domain: The domain the redirect refers to.
+        :param pulumi.Input[str] forwarding_mode: How the target is interpreted:
+               * __all__       appends the entire incoming path to the target destination;
+               * __capture__   appends only the part of the incoming path corresponding to the wildcard (*);
+               * __none__      does not append any part of the incoming path.
+        :param pulumi.Input[str] forwarding_type: How the redirect is executed:
+               * __permanent__ (HTTP 301) indicates to search engines that they should remove the old page from
+               their database and replace it with the new target page (this is recommended for SEO);
+               * __temporary__ (HTTP 302) less common, indicates that search engines should keep the old domain or
+               page indexed as the redirect is only temporary (while both pages might appear in the
+               search results, a temporary redirect suggests to the search engine that it should
+               prefer the new target page);
+               * __masking__   preserves the redirected domain in the browser's address bar (this lets users see the
+               address they entered, even though the displayed content comes from a different web page).
+        :param pulumi.Input[bool] https_enabled: True if HTTPS is supported on the source domain by using Let's Encrypt certificates.
+        :param pulumi.Input[bool] https_forced: Forces redirect for users that try to visit HTTP domain to HTTPS instead.
+        :param pulumi.Input[int] last_updated: The Unix timestamp representing when the certificate was last signed.
+        :param pulumi.Input[str] path: The path on the domain to redirect from.
+        :param pulumi.Input[bool] query_forwarding: Enables the query string of a URL to be applied directly to the new target URL.
+        :param pulumi.Input[Sequence[pulumi.Input[str]]] tags: Tags associated with the configuration.
+        :param pulumi.Input[str] target: The URL to redirect to.
+        """
+        if certificate_id is not None:
+            pulumi.set(__self__, "certificate_id", certificate_id)
+        if domain is not None:
+            pulumi.set(__self__, "domain", domain)
+        if forwarding_mode is not None:
+            pulumi.set(__self__, "forwarding_mode", forwarding_mode)
+        if forwarding_type is not None:
+            pulumi.set(__self__, "forwarding_type", forwarding_type)
+        if https_enabled is not None:
+            pulumi.set(__self__, "https_enabled", https_enabled)
+        if https_forced is not None:
+            pulumi.set(__self__, "https_forced", https_forced)
+        if last_updated is not None:
+            pulumi.set(__self__, "last_updated", last_updated)
+        if path is not None:
+            pulumi.set(__self__, "path", path)
+        if query_forwarding is not None:
+            pulumi.set(__self__, "query_forwarding", query_forwarding)
+        if tags is not None:
+            pulumi.set(__self__, "tags", tags)
+        if target is not None:
+            pulumi.set(__self__, "target", target)
+
+    @property
+    @pulumi.getter(name="certificateId")
+    def certificate_id(self) -> Optional[pulumi.Input[str]]:
+        """
+        The certificate redirect id.
+        """
+        return pulumi.get(self, "certificate_id")
+
+    @certificate_id.setter
+    def certificate_id(self, value: Optional[pulumi.Input[str]]):
+        pulumi.set(self, "certificate_id", value)
+
+    @property
+    @pulumi.getter
+    def domain(self) -> Optional[pulumi.Input[str]]:
+        """
+        The domain the redirect refers to.
+        """
+        return pulumi.get(self, "domain")
+
+    @domain.setter
+    def domain(self, value: Optional[pulumi.Input[str]]):
+        pulumi.set(self, "domain", value)
+
+    @property
+    @pulumi.getter(name="forwardingMode")
+    def forwarding_mode(self) -> Optional[pulumi.Input[str]]:
+        """
+        How the target is interpreted:
+        * __all__       appends the entire incoming path to the target destination;
+        * __capture__   appends only the part of the incoming path corresponding to the wildcard (*);
+        * __none__      does not append any part of the incoming path.
+        """
+        return pulumi.get(self, "forwarding_mode")
+
+    @forwarding_mode.setter
+    def forwarding_mode(self, value: Optional[pulumi.Input[str]]):
+        pulumi.set(self, "forwarding_mode", value)
+
+    @property
+    @pulumi.getter(name="forwardingType")
+    def forwarding_type(self) -> Optional[pulumi.Input[str]]:
+        """
+        How the redirect is executed:
+        * __permanent__ (HTTP 301) indicates to search engines that they should remove the old page from
+        their database and replace it with the new target page (this is recommended for SEO);
+        * __temporary__ (HTTP 302) less common, indicates that search engines should keep the old domain or
+        page indexed as the redirect is only temporary (while both pages might appear in the
+        search results, a temporary redirect suggests to the search engine that it should
+        prefer the new target page);
+        * __masking__   preserves the redirected domain in the browser's address bar (this lets users see the
+        address they entered, even though the displayed content comes from a different web page).
+        """
+        return pulumi.get(self, "forwarding_type")
+
+    @forwarding_type.setter
+    def forwarding_type(self, value: Optional[pulumi.Input[str]]):
+        pulumi.set(self, "forwarding_type", value)
+
+    @property
+    @pulumi.getter(name="httpsEnabled")
+    def https_enabled(self) -> Optional[pulumi.Input[bool]]:
+        """
+        True if HTTPS is supported on the source domain by using Let's Encrypt certificates.
+        """
+        return pulumi.get(self, "https_enabled")
+
+    @https_enabled.setter
+    def https_enabled(self, value: Optional[pulumi.Input[bool]]):
+        pulumi.set(self, "https_enabled", value)
+
+    @property
+    @pulumi.getter(name="httpsForced")
+    def https_forced(self) -> Optional[pulumi.Input[bool]]:
+        """
+        Forces redirect for users that try to visit HTTP domain to HTTPS instead.
+        """
+        return pulumi.get(self, "https_forced")
+
+    @https_forced.setter
+    def https_forced(self, value: Optional[pulumi.Input[bool]]):
+        pulumi.set(self, "https_forced", value)
+
+    @property
+    @pulumi.getter(name="lastUpdated")
+    def last_updated(self) -> Optional[pulumi.Input[int]]:
+        """
+        The Unix timestamp representing when the certificate was last signed.
+        """
+        return pulumi.get(self, "last_updated")
+
+    @last_updated.setter
+    def last_updated(self, value: Optional[pulumi.Input[int]]):
+        pulumi.set(self, "last_updated", value)
+
+    @property
+    @pulumi.getter
+    def path(self) -> Optional[pulumi.Input[str]]:
+        """
+        The path on the domain to redirect from.
+        """
+        return pulumi.get(self, "path")
+
+    @path.setter
+    def path(self, value: Optional[pulumi.Input[str]]):
+        pulumi.set(self, "path", value)
+
+    @property
+    @pulumi.getter(name="queryForwarding")
+    def query_forwarding(self) -> Optional[pulumi.Input[bool]]:
+        """
+        Enables the query string of a URL to be applied directly to the new target URL.
+        """
+        return pulumi.get(self, "query_forwarding")
+
+    @query_forwarding.setter
+    def query_forwarding(self, value: Optional[pulumi.Input[bool]]):
+        pulumi.set(self, "query_forwarding", value)
+
+    @property
+    @pulumi.getter
+    def tags(self) -> Optional[pulumi.Input[Sequence[pulumi.Input[str]]]]:
+        """
+        Tags associated with the configuration.
+        """
+        return pulumi.get(self, "tags")
+
+    @tags.setter
+    def tags(self, value: Optional[pulumi.Input[Sequence[pulumi.Input[str]]]]):
+        pulumi.set(self, "tags", value)
+
+    @property
+    @pulumi.getter
+    def target(self) -> Optional[pulumi.Input[str]]:
+        """
+        The URL to redirect to.
+        """
+        return pulumi.get(self, "target")
+
+    @target.setter
+    def target(self, value: Optional[pulumi.Input[str]]):
+        pulumi.set(self, "target", value)
+
+
+class Redirect(pulumi.CustomResource):
+    @overload
+    def __init__(__self__,
+                 resource_name: str,
+                 opts: Optional[pulumi.ResourceOptions] = None,
+                 certificate_id: Optional[pulumi.Input[str]] = None,
+                 domain: Optional[pulumi.Input[str]] = None,
+                 forwarding_mode: Optional[pulumi.Input[str]] = None,
+                 forwarding_type: Optional[pulumi.Input[str]] = None,
+                 https_forced: Optional[pulumi.Input[bool]] = None,
+                 path: Optional[pulumi.Input[str]] = None,
+                 query_forwarding: Optional[pulumi.Input[bool]] = None,
+                 tags: Optional[pulumi.Input[Sequence[pulumi.Input[str]]]] = None,
+                 target: Optional[pulumi.Input[str]] = None,
+                 __props__=None):
+        """
+        Provides a NS1 Redirect resource. This can be used to create, modify, and delete redirects.
+
+        ## Example Usage
+
+        ```python
+        import pulumi
+        import pulumi_ns1 as ns1
+
+        example = ns1.Redirect("example",
+            domain="www.example.com",
+            path="/from/path",
+            target="https://url.com/target/path")
+        ```
+
+        ### Additional Examples
+
+        ```python
+        import pulumi
+        import pulumi_ns1 as ns1
+
+        example = ns1.RedirectCertificate("example", domain="www.example.com")
+        ```
+
+        ## NS1 Documentation
+
+        [Redirect Api Doc](https://ns1.com/api#redirect)
+
+        # ns1\\_redirect\\_certificate
+
+        Provides a NS1 Redirect Certificate resource. This can be used to create, modify, and delete redirect certificates.
+
+        ## NS1 Documentation
+
+        [Redirect Api Doc](https://ns1.com/api#redirect)
+
+        :param str resource_name: The name of the resource.
+        :param pulumi.ResourceOptions opts: Options for the resource.
+        :param pulumi.Input[str] certificate_id: The certificate redirect id.
+        :param pulumi.Input[str] domain: The domain the redirect refers to.
+        :param pulumi.Input[str] forwarding_mode: How the target is interpreted:
+               * __all__       appends the entire incoming path to the target destination;
+               * __capture__   appends only the part of the incoming path corresponding to the wildcard (*);
+               * __none__      does not append any part of the incoming path.
+        :param pulumi.Input[str] forwarding_type: How the redirect is executed:
+               * __permanent__ (HTTP 301) indicates to search engines that they should remove the old page from
+               their database and replace it with the new target page (this is recommended for SEO);
+               * __temporary__ (HTTP 302) less common, indicates that search engines should keep the old domain or
+               page indexed as the redirect is only temporary (while both pages might appear in the
+               search results, a temporary redirect suggests to the search engine that it should
+               prefer the new target page);
+               * __masking__   preserves the redirected domain in the browser's address bar (this lets users see the
+               address they entered, even though the displayed content comes from a different web page).
+        :param pulumi.Input[bool] https_forced: Forces redirect for users that try to visit HTTP domain to HTTPS instead.
+        :param pulumi.Input[str] path: The path on the domain to redirect from.
+        :param pulumi.Input[bool] query_forwarding: Enables the query string of a URL to be applied directly to the new target URL.
+        :param pulumi.Input[Sequence[pulumi.Input[str]]] tags: Tags associated with the configuration.
+        :param pulumi.Input[str] target: The URL to redirect to.
+        """
+        ...
+    @overload
+    def __init__(__self__,
+                 resource_name: str,
+                 args: RedirectArgs,
+                 opts: Optional[pulumi.ResourceOptions] = None):
+        """
+        Provides a NS1 Redirect resource. This can be used to create, modify, and delete redirects.
+
+        ## Example Usage
+
+        ```python
+        import pulumi
+        import pulumi_ns1 as ns1
+
+        example = ns1.Redirect("example",
+            domain="www.example.com",
+            path="/from/path",
+            target="https://url.com/target/path")
+        ```
+
+        ### Additional Examples
+
+        ```python
+        import pulumi
+        import pulumi_ns1 as ns1
+
+        example = ns1.RedirectCertificate("example", domain="www.example.com")
+        ```
+
+        ## NS1 Documentation
+
+        [Redirect Api Doc](https://ns1.com/api#redirect)
+
+        # ns1\\_redirect\\_certificate
+
+        Provides a NS1 Redirect Certificate resource. This can be used to create, modify, and delete redirect certificates.
+
+        ## NS1 Documentation
+
+        [Redirect Api Doc](https://ns1.com/api#redirect)
+
+        :param str resource_name: The name of the resource.
+        :param RedirectArgs args: The arguments to use to populate this resource's properties.
+        :param pulumi.ResourceOptions opts: Options for the resource.
+        """
+        ...
+    def __init__(__self__, resource_name: str, *args, **kwargs):
+        resource_args, opts = _utilities.get_resource_args_opts(RedirectArgs, pulumi.ResourceOptions, *args, **kwargs)
+        if resource_args is not None:
+            __self__._internal_init(resource_name, opts, **resource_args.__dict__)
+        else:
+            __self__._internal_init(resource_name, *args, **kwargs)
+
+    def _internal_init(__self__,
+                 resource_name: str,
+                 opts: Optional[pulumi.ResourceOptions] = None,
+                 certificate_id: Optional[pulumi.Input[str]] = None,
+                 domain: Optional[pulumi.Input[str]] = None,
+                 forwarding_mode: Optional[pulumi.Input[str]] = None,
+                 forwarding_type: Optional[pulumi.Input[str]] = None,
+                 https_forced: Optional[pulumi.Input[bool]] = None,
+                 path: Optional[pulumi.Input[str]] = None,
+                 query_forwarding: Optional[pulumi.Input[bool]] = None,
+                 tags: Optional[pulumi.Input[Sequence[pulumi.Input[str]]]] = None,
+                 target: Optional[pulumi.Input[str]] = None,
+                 __props__=None):
+        opts = pulumi.ResourceOptions.merge(_utilities.get_resource_opts_defaults(), opts)
+        if not isinstance(opts, pulumi.ResourceOptions):
+            raise TypeError('Expected resource options to be a ResourceOptions instance')
+        if opts.id is None:
+            if __props__ is not None:
+                raise TypeError('__props__ is only valid when passed in combination with a valid opts.id to get an existing resource')
+            __props__ = RedirectArgs.__new__(RedirectArgs)
+
+            __props__.__dict__["certificate_id"] = certificate_id
+            if domain is None and not opts.urn:
+                raise TypeError("Missing required property 'domain'")
+            __props__.__dict__["domain"] = domain
+            __props__.__dict__["forwarding_mode"] = forwarding_mode
+            __props__.__dict__["forwarding_type"] = forwarding_type
+            __props__.__dict__["https_forced"] = https_forced
+            if path is None and not opts.urn:
+                raise TypeError("Missing required property 'path'")
+            __props__.__dict__["path"] = path
+            __props__.__dict__["query_forwarding"] = query_forwarding
+            __props__.__dict__["tags"] = tags
+            if target is None and not opts.urn:
+                raise TypeError("Missing required property 'target'")
+            __props__.__dict__["target"] = target
+            __props__.__dict__["https_enabled"] = None
+            __props__.__dict__["last_updated"] = None
+        super(Redirect, __self__).__init__(
+            'ns1:index/redirect:Redirect',
+            resource_name,
+            __props__,
+            opts)
+
+    @staticmethod
+    def get(resource_name: str,
+            id: pulumi.Input[str],
+            opts: Optional[pulumi.ResourceOptions] = None,
+            certificate_id: Optional[pulumi.Input[str]] = None,
+            domain: Optional[pulumi.Input[str]] = None,
+            forwarding_mode: Optional[pulumi.Input[str]] = None,
+            forwarding_type: Optional[pulumi.Input[str]] = None,
+            https_enabled: Optional[pulumi.Input[bool]] = None,
+            https_forced: Optional[pulumi.Input[bool]] = None,
+            last_updated: Optional[pulumi.Input[int]] = None,
+            path: Optional[pulumi.Input[str]] = None,
+            query_forwarding: Optional[pulumi.Input[bool]] = None,
+            tags: Optional[pulumi.Input[Sequence[pulumi.Input[str]]]] = None,
+            target: Optional[pulumi.Input[str]] = None) -> 'Redirect':
+        """
+        Get an existing Redirect resource's state with the given name, id, and optional extra
+        properties used to qualify the lookup.
+
+        :param str resource_name: The unique name of the resulting resource.
+        :param pulumi.Input[str] id: The unique provider ID of the resource to lookup.
+        :param pulumi.ResourceOptions opts: Options for the resource.
+        :param pulumi.Input[str] certificate_id: The certificate redirect id.
+        :param pulumi.Input[str] domain: The domain the redirect refers to.
+        :param pulumi.Input[str] forwarding_mode: How the target is interpreted:
+               * __all__       appends the entire incoming path to the target destination;
+               * __capture__   appends only the part of the incoming path corresponding to the wildcard (*);
+               * __none__      does not append any part of the incoming path.
+        :param pulumi.Input[str] forwarding_type: How the redirect is executed:
+               * __permanent__ (HTTP 301) indicates to search engines that they should remove the old page from
+               their database and replace it with the new target page (this is recommended for SEO);
+               * __temporary__ (HTTP 302) less common, indicates that search engines should keep the old domain or
+               page indexed as the redirect is only temporary (while both pages might appear in the
+               search results, a temporary redirect suggests to the search engine that it should
+               prefer the new target page);
+               * __masking__   preserves the redirected domain in the browser's address bar (this lets users see the
+               address they entered, even though the displayed content comes from a different web page).
+        :param pulumi.Input[bool] https_enabled: True if HTTPS is supported on the source domain by using Let's Encrypt certificates.
+        :param pulumi.Input[bool] https_forced: Forces redirect for users that try to visit HTTP domain to HTTPS instead.
+        :param pulumi.Input[int] last_updated: The Unix timestamp representing when the certificate was last signed.
+        :param pulumi.Input[str] path: The path on the domain to redirect from.
+        :param pulumi.Input[bool] query_forwarding: Enables the query string of a URL to be applied directly to the new target URL.
+        :param pulumi.Input[Sequence[pulumi.Input[str]]] tags: Tags associated with the configuration.
+        :param pulumi.Input[str] target: The URL to redirect to.
+        """
+        opts = pulumi.ResourceOptions.merge(opts, pulumi.ResourceOptions(id=id))
+
+        __props__ = _RedirectState.__new__(_RedirectState)
+
+        __props__.__dict__["certificate_id"] = certificate_id
+        __props__.__dict__["domain"] = domain
+        __props__.__dict__["forwarding_mode"] = forwarding_mode
+        __props__.__dict__["forwarding_type"] = forwarding_type
+        __props__.__dict__["https_enabled"] = https_enabled
+        __props__.__dict__["https_forced"] = https_forced
+        __props__.__dict__["last_updated"] = last_updated
+        __props__.__dict__["path"] = path
+        __props__.__dict__["query_forwarding"] = query_forwarding
+        __props__.__dict__["tags"] = tags
+        __props__.__dict__["target"] = target
+        return Redirect(resource_name, opts=opts, __props__=__props__)
+
+    @property
+    @pulumi.getter(name="certificateId")
+    def certificate_id(self) -> pulumi.Output[str]:
+        """
+        The certificate redirect id.
+        """
+        return pulumi.get(self, "certificate_id")
+
+    @property
+    @pulumi.getter
+    def domain(self) -> pulumi.Output[str]:
+        """
+        The domain the redirect refers to.
+        """
+        return pulumi.get(self, "domain")
+
+    @property
+    @pulumi.getter(name="forwardingMode")
+    def forwarding_mode(self) -> pulumi.Output[Optional[str]]:
+        """
+        How the target is interpreted:
+        * __all__       appends the entire incoming path to the target destination;
+        * __capture__   appends only the part of the incoming path corresponding to the wildcard (*);
+        * __none__      does not append any part of the incoming path.
+        """
+        return pulumi.get(self, "forwarding_mode")
+
+    @property
+    @pulumi.getter(name="forwardingType")
+    def forwarding_type(self) -> pulumi.Output[Optional[str]]:
+        """
+        How the redirect is executed:
+        * __permanent__ (HTTP 301) indicates to search engines that they should remove the old page from
+        their database and replace it with the new target page (this is recommended for SEO);
+        * __temporary__ (HTTP 302) less common, indicates that search engines should keep the old domain or
+        page indexed as the redirect is only temporary (while both pages might appear in the
+        search results, a temporary redirect suggests to the search engine that it should
+        prefer the new target page);
+        * __masking__   preserves the redirected domain in the browser's address bar (this lets users see the
+        address they entered, even though the displayed content comes from a different web page).
+        """
+        return pulumi.get(self, "forwarding_type")
+
+    @property
+    @pulumi.getter(name="httpsEnabled")
+    def https_enabled(self) -> pulumi.Output[bool]:
+        """
+        True if HTTPS is supported on the source domain by using Let's Encrypt certificates.
+        """
+        return pulumi.get(self, "https_enabled")
+
+    @property
+    @pulumi.getter(name="httpsForced")
+    def https_forced(self) -> pulumi.Output[bool]:
+        """
+        Forces redirect for users that try to visit HTTP domain to HTTPS instead.
+        """
+        return pulumi.get(self, "https_forced")
+
+    @property
+    @pulumi.getter(name="lastUpdated")
+    def last_updated(self) -> pulumi.Output[int]:
+        """
+        The Unix timestamp representing when the certificate was last signed.
+        """
+        return pulumi.get(self, "last_updated")
+
+    @property
+    @pulumi.getter
+    def path(self) -> pulumi.Output[str]:
+        """
+        The path on the domain to redirect from.
+        """
+        return pulumi.get(self, "path")
+
+    @property
+    @pulumi.getter(name="queryForwarding")
+    def query_forwarding(self) -> pulumi.Output[Optional[bool]]:
+        """
+        Enables the query string of a URL to be applied directly to the new target URL.
+        """
+        return pulumi.get(self, "query_forwarding")
+
+    @property
+    @pulumi.getter
+    def tags(self) -> pulumi.Output[Optional[Sequence[str]]]:
+        """
+        Tags associated with the configuration.
+        """
+        return pulumi.get(self, "tags")
+
+    @property
+    @pulumi.getter
+    def target(self) -> pulumi.Output[str]:
+        """
+        The URL to redirect to.
+        """
+        return pulumi.get(self, "target")
+

pulumi_ns1/redirect_certificate.py

@@ -0,0 +1,231 @@
+# coding=utf-8
+# *** WARNING: this file was generated by the Pulumi Terraform Bridge (tfgen) Tool. ***
+# *** Do not edit by hand unless you're certain you know what you are doing! ***
+
+import copy
+import warnings
+import pulumi
+import pulumi.runtime
+from typing import Any, Mapping, Optional, Sequence, Union, overload
+from . import _utilities
+
+__all__ = ['RedirectCertificateArgs', 'RedirectCertificate']
+
+@pulumi.input_type
+class RedirectCertificateArgs:
+    def __init__(__self__, *,
+                 domain: pulumi.Input[str]):
+        """
+        The set of arguments for constructing a RedirectCertificate resource.
+        """
+        pulumi.set(__self__, "domain", domain)
+
+    @property
+    @pulumi.getter
+    def domain(self) -> pulumi.Input[str]:
+        return pulumi.get(self, "domain")
+
+    @domain.setter
+    def domain(self, value: pulumi.Input[str]):
+        pulumi.set(self, "domain", value)
+
+
+@pulumi.input_type
+class _RedirectCertificateState:
+    def __init__(__self__, *,
+                 certificate: Optional[pulumi.Input[str]] = None,
+                 domain: Optional[pulumi.Input[str]] = None,
+                 errors: Optional[pulumi.Input[str]] = None,
+                 last_updated: Optional[pulumi.Input[int]] = None,
+                 valid_from: Optional[pulumi.Input[int]] = None,
+                 valid_until: Optional[pulumi.Input[int]] = None):
+        """
+        Input properties used for looking up and filtering RedirectCertificate resources.
+        """
+        if certificate is not None:
+            pulumi.set(__self__, "certificate", certificate)
+        if domain is not None:
+            pulumi.set(__self__, "domain", domain)
+        if errors is not None:
+            pulumi.set(__self__, "errors", errors)
+        if last_updated is not None:
+            pulumi.set(__self__, "last_updated", last_updated)
+        if valid_from is not None:
+            pulumi.set(__self__, "valid_from", valid_from)
+        if valid_until is not None:
+            pulumi.set(__self__, "valid_until", valid_until)
+
+    @property
+    @pulumi.getter
+    def certificate(self) -> Optional[pulumi.Input[str]]:
+        return pulumi.get(self, "certificate")
+
+    @certificate.setter
+    def certificate(self, value: Optional[pulumi.Input[str]]):
+        pulumi.set(self, "certificate", value)
+
+    @property
+    @pulumi.getter
+    def domain(self) -> Optional[pulumi.Input[str]]:
+        return pulumi.get(self, "domain")
+
+    @domain.setter
+    def domain(self, value: Optional[pulumi.Input[str]]):
+        pulumi.set(self, "domain", value)
+
+    @property
+    @pulumi.getter
+    def errors(self) -> Optional[pulumi.Input[str]]:
+        return pulumi.get(self, "errors")
+
+    @errors.setter
+    def errors(self, value: Optional[pulumi.Input[str]]):
+        pulumi.set(self, "errors", value)
+
+    @property
+    @pulumi.getter(name="lastUpdated")
+    def last_updated(self) -> Optional[pulumi.Input[int]]:
+        return pulumi.get(self, "last_updated")
+
+    @last_updated.setter
+    def last_updated(self, value: Optional[pulumi.Input[int]]):
+        pulumi.set(self, "last_updated", value)
+
+    @property
+    @pulumi.getter(name="validFrom")
+    def valid_from(self) -> Optional[pulumi.Input[int]]:
+        return pulumi.get(self, "valid_from")
+
+    @valid_from.setter
+    def valid_from(self, value: Optional[pulumi.Input[int]]):
+        pulumi.set(self, "valid_from", value)
+
+    @property
+    @pulumi.getter(name="validUntil")
+    def valid_until(self) -> Optional[pulumi.Input[int]]:
+        return pulumi.get(self, "valid_until")
+
+    @valid_until.setter
+    def valid_until(self, value: Optional[pulumi.Input[int]]):
+        pulumi.set(self, "valid_until", value)
+
+
+class RedirectCertificate(pulumi.CustomResource):
+    @overload
+    def __init__(__self__,
+                 resource_name: str,
+                 opts: Optional[pulumi.ResourceOptions] = None,
+                 domain: Optional[pulumi.Input[str]] = None,
+                 __props__=None):
+        """
+        Create a RedirectCertificate resource with the given unique name, props, and options.
+        :param str resource_name: The name of the resource.
+        :param pulumi.ResourceOptions opts: Options for the resource.
+        """
+        ...
+    @overload
+    def __init__(__self__,
+                 resource_name: str,
+                 args: RedirectCertificateArgs,
+                 opts: Optional[pulumi.ResourceOptions] = None):
+        """
+        Create a RedirectCertificate resource with the given unique name, props, and options.
+        :param str resource_name: The name of the resource.
+        :param RedirectCertificateArgs args: The arguments to use to populate this resource's properties.
+        :param pulumi.ResourceOptions opts: Options for the resource.
+        """
+        ...
+    def __init__(__self__, resource_name: str, *args, **kwargs):
+        resource_args, opts = _utilities.get_resource_args_opts(RedirectCertificateArgs, pulumi.ResourceOptions, *args, **kwargs)
+        if resource_args is not None:
+            __self__._internal_init(resource_name, opts, **resource_args.__dict__)
+        else:
+            __self__._internal_init(resource_name, *args, **kwargs)
+
+    def _internal_init(__self__,
+                 resource_name: str,
+                 opts: Optional[pulumi.ResourceOptions] = None,
+                 domain: Optional[pulumi.Input[str]] = None,
+                 __props__=None):
+        opts = pulumi.ResourceOptions.merge(_utilities.get_resource_opts_defaults(), opts)
+        if not isinstance(opts, pulumi.ResourceOptions):
+            raise TypeError('Expected resource options to be a ResourceOptions instance')
+        if opts.id is None:
+            if __props__ is not None:
+                raise TypeError('__props__ is only valid when passed in combination with a valid opts.id to get an existing resource')
+            __props__ = RedirectCertificateArgs.__new__(RedirectCertificateArgs)
+
+            if domain is None and not opts.urn:
+                raise TypeError("Missing required property 'domain'")
+            __props__.__dict__["domain"] = domain
+            __props__.__dict__["certificate"] = None
+            __props__.__dict__["errors"] = None
+            __props__.__dict__["last_updated"] = None
+            __props__.__dict__["valid_from"] = None
+            __props__.__dict__["valid_until"] = None
+        super(RedirectCertificate, __self__).__init__(
+            'ns1:index/redirectCertificate:RedirectCertificate',
+            resource_name,
+            __props__,
+            opts)
+
+    @staticmethod
+    def get(resource_name: str,
+            id: pulumi.Input[str],
+            opts: Optional[pulumi.ResourceOptions] = None,
+            certificate: Optional[pulumi.Input[str]] = None,
+            domain: Optional[pulumi.Input[str]] = None,
+            errors: Optional[pulumi.Input[str]] = None,
+            last_updated: Optional[pulumi.Input[int]] = None,
+            valid_from: Optional[pulumi.Input[int]] = None,
+            valid_until: Optional[pulumi.Input[int]] = None) -> 'RedirectCertificate':
+        """
+        Get an existing RedirectCertificate resource's state with the given name, id, and optional extra
+        properties used to qualify the lookup.
+
+        :param str resource_name: The unique name of the resulting resource.
+        :param pulumi.Input[str] id: The unique provider ID of the resource to lookup.
+        :param pulumi.ResourceOptions opts: Options for the resource.
+        """
+        opts = pulumi.ResourceOptions.merge(opts, pulumi.ResourceOptions(id=id))
+
+        __props__ = _RedirectCertificateState.__new__(_RedirectCertificateState)
+
+        __props__.__dict__["certificate"] = certificate
+        __props__.__dict__["domain"] = domain
+        __props__.__dict__["errors"] = errors
+        __props__.__dict__["last_updated"] = last_updated
+        __props__.__dict__["valid_from"] = valid_from
+        __props__.__dict__["valid_until"] = valid_until
+        return RedirectCertificate(resource_name, opts=opts, __props__=__props__)
+
+    @property
+    @pulumi.getter
+    def certificate(self) -> pulumi.Output[str]:
+        return pulumi.get(self, "certificate")
+
+    @property
+    @pulumi.getter
+    def domain(self) -> pulumi.Output[str]:
+        return pulumi.get(self, "domain")
+
+    @property
+    @pulumi.getter
+    def errors(self) -> pulumi.Output[str]:
+        return pulumi.get(self, "errors")
+
+    @property
+    @pulumi.getter(name="lastUpdated")
+    def last_updated(self) -> pulumi.Output[int]:
+        return pulumi.get(self, "last_updated")
+
+    @property
+    @pulumi.getter(name="validFrom")
+    def valid_from(self) -> pulumi.Output[int]:
+        return pulumi.get(self, "valid_from")
+
+    @property
+    @pulumi.getter(name="validUntil")
+    def valid_until(self) -> pulumi.Output[int]:
+        return pulumi.get(self, "valid_until")
+

pulumi_ns1/team.py

@@ -198,13 +198,11 @@ class TeamArgs:
 
     @property
     @pulumi.getter(name="accountManagePlan")
+    @_utilities.deprecated("""obsolete, should no longer be used""")
     def account_manage_plan(self) -> Optional[pulumi.Input[bool]]:
         """
         No longer in use.
         """
-        warnings.warn("""obsolete, should no longer be used""", DeprecationWarning)
-        pulumi.log.warn("""account_manage_plan is deprecated: obsolete, should no longer be used""")
-
         return pulumi.get(self, "account_manage_plan")
 
     @account_manage_plan.setter
@@ -702,13 +700,11 @@ class _TeamState:
 
     @property
     @pulumi.getter(name="accountManagePlan")
+    @_utilities.deprecated("""obsolete, should no longer be used""")
     def account_manage_plan(self) -> Optional[pulumi.Input[bool]]:
         """
         No longer in use.
         """
-        warnings.warn("""obsolete, should no longer be used""", DeprecationWarning)
-        pulumi.log.warn("""account_manage_plan is deprecated: obsolete, should no longer be used""")
-
         return pulumi.get(self, "account_manage_plan")
 
     @account_manage_plan.setter
@@ -1452,13 +1448,11 @@ class Team(pulumi.CustomResource):
 
     @property
     @pulumi.getter(name="accountManagePlan")
+    @_utilities.deprecated("""obsolete, should no longer be used""")
     def account_manage_plan(self) -> pulumi.Output[Optional[bool]]:
         """
         No longer in use.
         """
-        warnings.warn("""obsolete, should no longer be used""", DeprecationWarning)
-        pulumi.log.warn("""account_manage_plan is deprecated: obsolete, should no longer be used""")
-
         return pulumi.get(self, "account_manage_plan")
 
     @property

pulumi_ns1/user.py

@@ -236,13 +236,11 @@ class UserArgs:
 
     @property
     @pulumi.getter(name="accountManagePlan")
+    @_utilities.deprecated("""obsolete, should no longer be used""")
     def account_manage_plan(self) -> Optional[pulumi.Input[bool]]:
         """
         No longer in use.
         """
-        warnings.warn("""obsolete, should no longer be used""", DeprecationWarning)
-        pulumi.log.warn("""account_manage_plan is deprecated: obsolete, should no longer be used""")
-
         return pulumi.get(self, "account_manage_plan")
 
     @account_manage_plan.setter
@@ -782,13 +780,11 @@ class _UserState:
 
     @property
     @pulumi.getter(name="accountManagePlan")
+    @_utilities.deprecated("""obsolete, should no longer be used""")
     def account_manage_plan(self) -> Optional[pulumi.Input[bool]]:
         """
         No longer in use.
         """
-        warnings.warn("""obsolete, should no longer be used""", DeprecationWarning)
-        pulumi.log.warn("""account_manage_plan is deprecated: obsolete, should no longer be used""")
-
         return pulumi.get(self, "account_manage_plan")
 
     @account_manage_plan.setter
@@ -1607,13 +1603,11 @@ class User(pulumi.CustomResource):
 
     @property
     @pulumi.getter(name="accountManagePlan")
+    @_utilities.deprecated("""obsolete, should no longer be used""")
     def account_manage_plan(self) -> pulumi.Output[Optional[bool]]:
         """
         No longer in use.
         """
-        warnings.warn("""obsolete, should no longer be used""", DeprecationWarning)
-        pulumi.log.warn("""account_manage_plan is deprecated: obsolete, should no longer be used""")
-
         return pulumi.get(self, "account_manage_plan")
 
     @property

{pulumi_ns1-3.3.0a1719035723.dist-info → pulumi_ns1-3.3.1.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: pulumi_ns1
-Version: 3.3.0a1719035723
+Version: 3.3.1
 Summary: A Pulumi package for creating and managing ns1 cloud resources.
 License: Apache-2.0
 Project-URL: Homepage, https://pulumi.io

{pulumi_ns1-3.3.0a1719035723.dist-info → pulumi_ns1-3.3.1.dist-info}/RECORD

@@ -1,8 +1,8 @@
-pulumi_ns1/__init__.py,sha256=wNUy5gN6yVX06kifppBkiBFuJrHs5rh3Dzq66Pm8i2o,3438
+pulumi_ns1/__init__.py,sha256=_t-RU0JWspVvqo3Sl3ADYZ1Lf7P6fHSGIt5iUaoeShU,3816
 pulumi_ns1/_inputs.py,sha256=8FSj_cd_yoTCKSpENO84hL6nUYMk5nV4TMPiVfmKCLE,38901
-pulumi_ns1/_utilities.py,sha256=b6gJn0IIeM1t6Q7EVjqw3yhuGyP-uENQhtL5yp7aHR8,9248
+pulumi_ns1/_utilities.py,sha256=zozFZPZGnJJ7MjOYHQPdH-l-EHcRcX5lh5TVi22oTCw,10446
 pulumi_ns1/account_whitelist.py,sha256=rTZ7XcM7jO4iB0g7Q4bC0WEY26ysnEY3qXG77q-QpDI,9054
-pulumi_ns1/api_key.py,sha256=hyXAMjyqNelH2b4Mk1rLv3fKTPPTil_RUUPUIVy2KLk,87262
+pulumi_ns1/api_key.py,sha256=9NwaW9IfTnuz4df-u8cZzFGyH4DnS3Qm_R8oYILncsk,86911
 pulumi_ns1/application.py,sha256=YAetD40s0hg6zULKu3u-e5Q8sVHm9J6vAYlhVv8Y0X8,16619
 pulumi_ns1/data_feed.py,sha256=1gg4udnlqVKsV2JHhe_BsZSSlO7m0s0fbbiARm0QAEc,12682
 pulumi_ns1/data_source.py,sha256=Qg0Dtd0OlxTymPvMqJJTQ0peSalQI_gxqGt5XjoAisI,11102
@@ -18,18 +18,20 @@ pulumi_ns1/notify_list.py,sha256=w4Z350jOCgGwAUKwgWTa502Xx_8EK4o_BsJj-HoXL2A,110
 pulumi_ns1/outputs.py,sha256=Ld_6Lm9hRElF10c_aIewKwbtmsXIJzlZXXI4OqUHt0o,46058
 pulumi_ns1/provider.py,sha256=5E3JbCjCD3ztCf3HFRYQ_c680oYir0a9h_Fy3nUtHe0,10590
 pulumi_ns1/pulsar_job.py,sha256=Gk12BJdVCy6QWEqt99Wf5RqvZXEIf8Oub5Qn0x3YfjM,17050
-pulumi_ns1/pulumi-plugin.json,sha256=cUGIv_qcG__tFRdXEQFoDvYkcN7bAO_Qgs7-pSZPBHk,79
+pulumi_ns1/pulumi-plugin.json,sha256=B97dzE2yC081t6mWnEEiBNZFSW-pTeGXtao3ZtGvTPE,62
 pulumi_ns1/py.typed,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
-pulumi_ns1/record.py,sha256=7W76cCpzqzdOvV10g3HDh_4l-YlVameA2rBmeZ9HXGE,45469
+pulumi_ns1/record.py,sha256=tLDSgL3gKh9b-CIk5rir2j97cDhrjsjzvvVzKOoAOFc,44902
+pulumi_ns1/redirect.py,sha256=KpClbfRDOD-dPpJc3enWi9JswvelRw59iiOlw0ZWFbM,32828
+pulumi_ns1/redirect_certificate.py,sha256=oEPHvmHoioIevrzNoyqGLpDAlDyjMeQqqsQYwRx-IGI,8886
 pulumi_ns1/subnet.py,sha256=9LN3o8gVwCgL4hC9wwFDzU4WPNXDxCOZE3MudBWPlq0,19239
-pulumi_ns1/team.py,sha256=W7zln_uUxGUhRLpwygcW0hmPwUAJmV9dtJXNgPmaFT0,81714
+pulumi_ns1/team.py,sha256=wCsNFL8Bt9j_e4xytJfq5WqgPaYWX-1MnsMoGA2HYEg,81363
 pulumi_ns1/tsigkey.py,sha256=HpbUG1x720Ix-BuA-qj5MIurFDVQ2JI_Y2b736cN97E,10038
-pulumi_ns1/user.py,sha256=ThbfFxGo-dF2HHOvECTA4Surd8vAJKTtPmy9RV8GwTg,89234
+pulumi_ns1/user.py,sha256=4Viq-wpyIC2_LTNA9FmxmeeOBELfkwQ2kH77pnGm3MU,88883
 pulumi_ns1/zone.py,sha256=easSfXfDqQhz6tNwc7SGCK5CdwTlq340VTByde69tqI,43790
 pulumi_ns1/config/__init__.py,sha256=cfY0smRZD3fDVc93ZIAxEl_IM2pynmXB52n3Ahzi030,285
 pulumi_ns1/config/__init__.pyi,sha256=gTM1utkGS4KH3on5zyhR_a6AtTg4_jVpEXyQeU7ZpJQ,865
 pulumi_ns1/config/vars.py,sha256=bQTOWrwMP1x58zYPNlK8g8CTAbOUMF3GyfcevML1frE,1674
-pulumi_ns1-3.3.0a1719035723.dist-info/METADATA,sha256=8xsqYthXHBtzDFlItu5HtlLNRKZF2m8_s2vQceH0cMA,3047
-pulumi_ns1-3.3.0a1719035723.dist-info/WHEEL,sha256=cpQTJ5IWu9CdaPViMhC9YzF8gZuS5-vlfoFihTBC86A,91
-pulumi_ns1-3.3.0a1719035723.dist-info/top_level.txt,sha256=Sndx9N4MHnSbjpwVT-_JZ8NZ7JzudJUIUQkU2-9GH9U,11
-pulumi_ns1-3.3.0a1719035723.dist-info/RECORD,,
+pulumi_ns1-3.3.1.dist-info/METADATA,sha256=2T8oCl86Cksgi6K70esNnAJpYKauhY5mWgtPn2NSKBs,3036
+pulumi_ns1-3.3.1.dist-info/WHEEL,sha256=y4mX-SOX4fYIkonsAGA5N0Oy-8_gI4FXw5HNI1xqvWg,91
+pulumi_ns1-3.3.1.dist-info/top_level.txt,sha256=Sndx9N4MHnSbjpwVT-_JZ8NZ7JzudJUIUQkU2-9GH9U,11
+pulumi_ns1-3.3.1.dist-info/RECORD,,

{pulumi_ns1-3.3.0a1719035723.dist-info → pulumi_ns1-3.3.1.dist-info}/WHEEL

@@ -1,5 +1,5 @@
 Wheel-Version: 1.0
-Generator: setuptools (70.1.0)
+Generator: setuptools (70.2.0)
 Root-Is-Purelib: true
 Tag: py3-none-any