polarity-integration-utils 0.1.0 → 2.0.8

package/dist/polarity-integration-utils.d.ts

@@ -0,0 +1,852 @@
+import Bottleneck from 'bottleneck';
+
+/**
+ * API error for REST requests
+ *
+ * @public
+ */
+export declare class ApiRequestError extends IntegrationError {
+    constructor(message: string, properties?: IntegrationErrorProperties);
+}
+
+/**
+ * Thrown by generateAccessToken method if there is a failure to fetch a token
+ *
+ * @public
+ */
+export declare class AuthRequestError extends IntegrationError {
+    constructor(message: string, properties?: IntegrationErrorProperties);
+}
+
+/**
+ * @public
+ */
+export declare type ConfigRequestProxyOptions = {
+    ca?: undefined | string;
+    cert?: undefined | string;
+    key?: undefined | string;
+    passphrase?: undefined | string;
+    rejectUnauthorized?: undefined | boolean;
+    proxy?: undefined | string;
+    json?: undefined | boolean;
+};
+
+/**
+ * User options object passed into the integration's `doLookup` method.
+ *
+ * @example
+ * Example of the user options object passed into `doLookup`
+ * ```js
+ * function doLookup(entities, options, cb){
+ *   // options here is of type DoLookupUserOptions
+ * }
+ * ```
+ *
+ * @example
+ * As an example, if your integration has a user option with a `key` value of
+ * `apiKey` within its `config.json`, the user options object passed into the `doLookup` method would look like:
+ * ```json
+ * {
+ *   "apiKey": "XXXXXXXXXX"
+ * }
+ * ```
+ * @public
+ */
+export declare type DoLookupUserOptions = {
+    [key: string]: PossibleUserOptionValue;
+};
+
+/**
+ * @public
+ */
+export declare type DropdownUserOptionValue = {
+    display: string;
+    value: string;
+};
+
+/**
+ * Represents a Polarity Entity object which is passed to an integration's
+ * doLookup method.
+ *
+ * @public
+ */
+export declare type Entity = {
+    value: string;
+    types: EntityType[];
+    type: EntityType;
+    requestContext: {
+        requestType: 'onDemand';
+        isUserInitiated: boolean;
+    };
+    longitude: number;
+    latitude: number;
+    isURL: boolean;
+    isSHA512: boolean;
+    isSHA256: boolean;
+    isSHA1: boolean;
+    isPrivateIP: boolean;
+    isMD5: boolean;
+    isIPv6: boolean;
+    isIPv4: boolean;
+    isIP: boolean;
+    isHex: boolean;
+    isHash: boolean;
+    isHTMLTag: boolean;
+    isEmail: boolean;
+    isDomain: boolean;
+    hashType: string;
+    displayValue: string;
+    channels: string[];
+    IPType: string;
+};
+
+/**
+ * Entity Types including custom types
+ * @public
+ */
+export declare type EntityType = StandardEntityType | '*' | 'custom' | `custom.${string}`;
+
+/**
+ * @public
+ */
+declare interface Error_2 {
+    name: string;
+    message: string;
+    stack?: string;
+    code?: number | string;
+}
+export { Error_2 as Error }
+
+/**
+ * @public
+ */
+export declare type ErrorMeta = {
+    [otherMetadata: string]: unknown;
+};
+
+/**
+ * return the logger object set via the {@link setLogger} method.
+ *
+ * @example
+ * Example of using the integration's logging object:
+ * ```js
+ * const { getLogger } = require('polarity-integration-utils/logger');
+ *
+ * const logger = getLogger();
+ * logger.trace('this is a trace message');
+ * ```
+ *
+ * @public
+ * @returns the integration's logger object
+ */
+export declare const getLogger: () => Logger;
+
+export declare type HttpMethod = 'GET' | 'POST' | 'PUT' | 'PATCH' | 'DELETE' | 'HEAD' | 'OPTIONS';
+
+/**
+ * @public
+ */
+export declare type HttpRequestOptions = {
+    /**
+     * The URL to make the request to.
+     */
+    url?: string;
+    /**
+     * The HTTP method to use for the request.
+     *
+     * @defaultValue 'GET'
+     */
+    method?: HttpMethod;
+    /**
+     *  If true, sets body to JSON representation of value and adds Content-type: application/json header.
+     *  Additionally, parses the response body as JSON.
+     *
+     *  @defaultValue true
+     */
+    json?: boolean;
+    /**
+     * An object containing the headers to include in the request.
+     * @example
+     * Here is an example of setting the "X-Api-Key" `headers` property:
+     * ```
+     * {
+     *   headers: {
+     *     'X-Api-Key': '1234567890'
+     *   }
+     * }
+     * ```
+     */
+    headers?: object;
+    /**
+     * An object containing querystring parameters to include in the request.
+     * @example
+     * Here is an example of setting the `qs` property:
+     * ```
+     * {
+     *   qs: {
+     *     search: 'foo'
+     *   }
+     * }
+     * ```
+     */
+    qs?: object;
+    /**
+     * When passed an object or a querystring, this sets body to a querystring representation of value,
+     * and adds Content-type: application/x-www-form-urlencoded header.
+     */
+    form?: object;
+    /**
+     * The body of the request.
+     */
+    body?: object;
+    /**
+     * The authentication options to use for the request
+     */
+    auth?: {
+        username: string;
+        password: string;
+        sendImmediately?: boolean;
+    } | {
+        bearer: string;
+        sendImmediately?: boolean;
+    };
+    [key: string]: unknown;
+} & ({
+    entity: Entity;
+    entities?: never;
+    requestId?: never;
+} | {
+    entities: Entity[];
+    entity?: never;
+    requestId?: never;
+} | {
+    requestId: string | unknown;
+    entity?: never;
+    entities?: never;
+} | {
+    entity?: never;
+    entities?: never;
+    requestId?: never;
+});
+
+/**
+ * @public
+ */
+export declare type HttpRequestResponse = {
+    /**
+     * The HTTP status code of the response.
+     */
+    statusCode: number;
+    request: {
+        uri: unknown;
+        method: string;
+        headers: unknown;
+        [key: string]: unknown;
+    };
+    /**
+     * The body of the response.
+     */
+    body: unknown;
+    /**
+     * The response headers
+     */
+    headers: unknown;
+    /**
+     * The error object if an error occurred during the request.
+     */
+    error?: ApiRequestError | NetworkError | RetryRequestError;
+    /**
+     * The entity that the request was made for. The `entity` property matches the
+     * `entity` property set on the {@link HttpRequestOptions} object associated with this HttpRequestResponse.
+     */
+    entity?: Entity;
+    /**
+     * An array of entities that the request was made for.  The `entities` property
+     * matches the `entities` property set on the {@link HttpRequestOptions} object associated
+     * with this HttpRequestResponse.
+     */
+    entities?: Entity[];
+    /**
+     * A custom request id that can be used to identify the request.  The `requestId` matches
+     * the `requestId` property set on the {@link HttpRequestOptions} object.
+     */
+    requestId?: string | unknown;
+    [key: string]: unknown;
+};
+
+/**
+ * @public
+ */
+export declare class IntegrationError extends Error {
+    /**
+     *  a short, human-readable summary of the problem that SHOULD NOT change from occurrence to occurrence of
+     *  the problem except for purposes of localization.
+     */
+    readonly title: string;
+    /**
+     * a human-readable explanation specific to this occurrence of the problem. Like title, this field’s value can be
+     * localized
+     */
+    readonly detail: string;
+    /**
+     * a meta object containing non-standard meta-information about the error.
+     */
+    readonly meta: ErrorMeta;
+    /**
+     * The HTTP status code applicable to this error, expressed as a string value.
+     */
+    readonly status: string;
+    /**
+     *  an application-specific error code, expressed as a string value.
+     */
+    readonly code: string;
+    /**
+     * The `cause` property is used to specify the `cause` of the error.  Typically,
+     * this property is used to pass through a related Error instance.
+     */
+    readonly cause: Error_2;
+    /**
+     * Additional details related to the error that may help the user troubleshoot the issue.  If set by the user
+     * via the Error constructor, the user provided value will override any automated help message set by the
+     * Error class.
+     */
+    readonly help: string;
+    /**
+     * Relevant for integration errors involving a network call, the `requestOptions` property
+     * details the request options that resulted in the specified error.  The `requestOptions` property will automatically
+     * have sensitive authentication headers stripped.
+     */
+    readonly requestOptions?: HttpRequestOptions;
+    /**
+     * Construct a new IntegrationError object.
+     * @param message - A string description of the error which is used as the `detail` property on the
+     * serialized error.
+     * @param properties - Optional properties for the error.
+     */
+    constructor(message: string, properties?: IntegrationErrorProperties);
+    /**
+     * Serializes the error's properties into a POJO.  The order of the
+     * properties is preserved when serialized.
+     * @returns JSON representation of the error
+     */
+    toJSON(): SerializedIntegrationError;
+}
+
+/**
+ * @public
+ */
+export declare interface IntegrationErrorProperties {
+    /**
+     *  a short, human-readable summary of the problem that SHOULD NOT change from occurrence to occurrence of
+     *  the problem except for purposes of localization.  If omitted, the title will default to the type
+     *  of error (e.g., IntegrationError, or ApiRequestError)
+     */
+    title?: string;
+    /**
+     * Additional details related to the error that may help the user troubleshoot the issue.  If set by the user
+     * via the Error constructor, the user provided value will override any automated help message set by the
+     * Error class.
+     */
+    help?: string;
+    /**
+     * The `cause` property is used to specify the `cause` of the error.  Typically,
+     * this property is used to pass through a related Error instance.
+     */
+    cause?: Error_2;
+    /**
+     * The HTTP status code applicable to this error, expressed as a string value.
+     */
+    status?: string;
+    /**
+     *  an application-specific error code, expressed as a string value.
+     */
+    code?: string;
+    /**
+     * Relevant for integration errors involving a network call, the `requestOptions` property
+     * details the request options that resulted in the specified error.  The `requestOptions` property will automatically
+     * have sensitive authentication headers stripped.
+     * By default, the following paths are sanitized:
+     *
+     * - auth.password
+     * - auth.bearer
+     * - body.password
+     * - form.client_secret
+     * - headers.authorization
+     * - headers.x-api-key
+     *
+     * Additional paths can be sanitized by using the `requestOptionsToSanitize` property.
+     */
+    requestOptions?: HttpRequestOptions;
+    /**
+     * List of paths in JSON dot notation to sanitize in the requestOptions object
+     */
+    requestOptionsToSanitize?: string[];
+    /**
+     * Any additional properties which will be appended to the Error's meta property
+     */
+    meta?: MetaObject;
+}
+
+/**
+ * @public
+ */
+export declare type IsApiErrorFunction = (response: HttpRequestResponse, requestOptions: HttpRequestOptions, userOptions: DoLookupUserOptions) => IsApiErrorResult;
+
+/**
+ * @public
+ */
+export declare type IsApiErrorResult = {
+    /**
+     * Indicates whether the response is an API error.
+     */
+    isApiError: boolean;
+    /**
+     * Optional message providing additional information about the API error.  The
+     * returned `message` will be used as the `message` property on the {@link ApiRequestError} object
+     * thrown by the request.
+     */
+    message?: string;
+};
+
+/**
+ * Thrown when the polarity-integration-utils library is used incorrectly.  For example,
+ * if a method is called with incorrect or missing parameters, or a required initialization
+ * method is not called.  This Error class should not be used directly by integrations.
+ *
+ * @public
+ */
+export declare class LibraryUsageError extends IntegrationError {
+    constructor(message: string, properties?: IntegrationErrorProperties);
+}
+
+/**
+ * @public
+ */
+export declare type Logger = {
+    child?(arg: unknown): Logger;
+    info(...args: unknown[]): void;
+    debug(...args: unknown[]): void;
+    trace(...args: unknown[]): void;
+    warn(...args: unknown[]): void;
+    error(...args: unknown[]): void;
+    fatal(...args: unknown[]): void;
+};
+
+/**
+ * @public
+ */
+export declare type MetaObject = {
+    [key: string]: unknown;
+};
+
+/**
+ * Generic network error for REST requests.
+ * https://betterstack.com/community/guides/scaling-nodejs/nodejs-errors/#4-econnrefused
+ *
+ * @public
+ */
+export declare class NetworkError extends IntegrationError {
+    constructor(message: string, properties?: IntegrationErrorProperties);
+}
+
+/**
+ * @public
+ * @param error - Error instance to parse into a plain old javascript object
+ */
+export declare const parseErrorToReadableJson: (error: Error_2) => any;
+
+/**
+ * A utility class for making HTTP requests
+ * @public
+ */
+export declare class PolarityRequest {
+    private bottleneckLimiter;
+    /**
+     * Instance of a Bunyan logger
+     */
+    private logger;
+    private internalThrottlingOptions;
+    /**
+     * postman-request library request object with default values set.  Used internally for
+     * making HTTP requests directly via the postman-request library
+     */
+    private readonly requestWithDefaults;
+    readonly roundedSuccessStatusCodes: number[];
+    /**
+     * One or more HTTP response properties specified using JSON dot notation.  If the
+     * specified path exists within the `body` property of the HTTP Response, an
+     * ApiRequestError will be thrown.
+     *
+     * By default, this value is an empty array and response properties are not used to
+     * detect errors.
+     * @defaultValue []
+     */
+    readonly httpResponseErrorProperties: string[];
+    /**
+     * One or more HTTP response properties specified using JSON dot notation that
+     * point to an error message that should be displayed to the user in the event
+     * of an API error.
+     *
+     * The property should be a string value.  If the property does not exist or is not
+     * a string value, a default error message will be used instead.
+     */
+    readonly httpResponseErrorMessageProperties: string[];
+    /**
+     * Optional method that can be implemented to determine if an API error
+     * was encountered after an HTTP request is made.
+     *
+     * If the `isApiError` method is implemented
+     * the property `roundedSuccessStatusCodes` and `httpResponseErrorProperties` are not
+     * used to determine API errors.
+     *
+     * @returns An object indicating whether an API error was encountered and an optional message.
+     */
+    readonly isApiError: IsApiErrorFunction;
+    /**
+     * An array of JSON dot notation paths to omit from the request options when logging.
+     *
+     * This property can be used to sanitize sensitive request properties that should not
+     * appear in logging.
+     *
+     * Note that the `requestOptions` object is automatically sanitized to remove properties that
+     * typically contain sensitive API key and passwords.  For a list of properties that are
+     * automatically sanitized, see the {@link sanitizeRequestOptions} method.
+     */
+    readonly requestOptionsToSanitize: string[];
+    userOptions: DoLookupUserOptions;
+    /**
+     * Optional middleware method for modifying {@link HttpRequestOptions} before a request is made
+     * via the {@link PolarityRequest.run} method or {@link PolarityRequest.runInParallel} method.
+     * The returned `requestOptions` object will be used for the request.  This method is passed
+     * a copy of the original `requestOptions` object so it can be modified without side effects.
+     *
+     * This method is typically used for adding authentication (e.g., auth headers, or basic auth) to every request.
+     * It can also be used to add headers that are required on every request or conditionally add headers based
+     * on the passed in `userOptions`.
+     *
+     * This method can be set as part of the {@link PolarityRequestOptions} when creating a new instance of the
+     * {@link PolarityRequest} class or can be set after the fact.
+     *
+     * @param requestOptions - A copy of the request options used for the request.  This object can be modified
+     * without side effects.
+     * @param userOptions - The user options passed into the `doLookup` method.
+     * @returns The modified request options to use for the request.
+     */
+    preprocessRequestOptions: PreprocessRequestOptions;
+    /**
+     * Optional middleware method for modifying the {@link HttpRequestResponse} after a successful request.
+     * The passed in {@link HttpRequestResponse} object is not a copy but can be safely modified without
+     * side effects.  The returned `HttpRequestResponse` object will be used for the response.
+     *
+     * @param response - The HTTP response from the request.
+     * @param requestOptions - The request options used for the request.
+     * @param userOptions - The user options passed into the `doLookup` method.
+     */
+    postprocessRequestSuccess: PostprocessRequestSuccess;
+    /**
+     * Method that can be implemented to post-process the HTTP response after a failed request.
+     * This method is typically used to inspect the error thrown and either alter the error
+     * object (e.g., to change the error message property to something more specific), to ignore
+     * the error (by not rethrowing it), or to take a specific action based on the error (e.g.,
+     * in the case of a RetryRequestError you may want to retry the request or return a special
+     * payload to the integration front end).
+     *
+     * @param error - The error thrown during the request.
+     * @param requestOptions - The request options used for the request.
+     * @param userOptions - The user options passed into the `doLookup` method.
+     */
+    postprocessRequestFailure: PostprocessRequestFailure;
+    get throttlingOptions(): Bottleneck.ConstructorOptions;
+    set throttlingOptions(throttlingOptions: Bottleneck.ConstructorOptions);
+    constructor(options?: PolarityRequestOptions);
+    private configFieldIsValid;
+    /**
+     * Makes a single HTTP request and returns the response or throws an error
+     *
+     * @param requestOptions - request options used to make the HTTP request
+     * @returns The HTTP response
+     */
+    run(requestOptions: HttpRequestOptions): Promise<HttpRequestResponse> | never;
+    /**
+     * Checks whether the HTTP response is an API error and throws an ApiRequestError if it is.
+     *
+     * @param httpResponse - The HTTP response from the Postman request.
+     * @param requestOptions - The options used for the request.
+     *
+     * @throws {@link ApiRequestError}
+         * Throws an error if the response indicates an API error.
+         */
+     private maybeThrowApiRequestError;
+     /**
+      * Returns true if the `httpStatusCode` is not one of the rounded HTTP status codes
+      * specified in the PolarityRequest `roundedSuccessStatusCodes` property.
+      *
+      * @param httpStatusCode - A numeric HTTP Status Code
+      * @returns true if the provided `httpStatusCode` is an error code
+      */
+     private isHttpStatusCodeError;
+     /**
+      * Returns true indicating that the API returned an error  if the `httpBody` contains
+      * one of the paths specified by the PolarityRequest `httpResponseErrorProperties`
+      * property.
+      *
+      * @param httpBody - body property from the HttpRequestResponse
+      * @returns `true` if the httpBody property contains properties specified in `httpResponseErrorProperties`
+      */
+     private hasHttpResponseErrorProperty;
+     /**
+      * Returns an error message based on the `httpResponseErrorMessageProperties` first.  If no
+      * message is found, it then uses the `httpResponseErrorProperties` to attempt to find
+      * a suitable error message.  If no message is still found, the `defaultMessage` is returned.
+      *
+      * @param httpBody - JSON Object returned by an HTTP Request
+      * @param defaultMessage - A default error message to use if no specific error messages are found
+      * @returns An error message
+      */
+     private getErrorMessageFromHttpResponse;
+     /**
+      * Given a list of `properties` which are strings representing JSON dot notation, this
+      * method returns the first string property found at the given JSON path
+      * in the given `object`.
+      *
+      * @param object - An object to find properties in
+      * @param properties - a list of JSON dot notation properties to look for within `object`
+      * @returns A string value of the property found within the given object or undefined if no value is found
+      */
+     private maybeGetStringPropertyValue;
+     /**
+      * Runs multiple requests in parallel with a limit on the maximum number of concurrent requests.
+      *
+      * When running multiple request at once it is often useful to be able to tie a specific request
+      * back to the entity the request is for.  To support this, the `HttpRequestOptions` object accepts
+      * an optional `entity` property which can be assigned to the Entity the request is being made for.
+      * The `HttpRequestResponse` object returned by this method will include the same `entity` property
+      * making it easy to match the response to the entity.
+      *
+      * Alternatively, for requests that are made for multiple entities at once (e.g., a query that can
+      * search multiple entities at a time), the `HttpRequestOptions` object also has an `entities`
+      * property which accept an array of entity objects.  Similar to the `entity`, the
+      * `entities` property will be set on the `HttpRequestResponse` object.
+      *
+      * Finally, if you are looking to pass through a custom request id you can do that using the
+      * `requestId` property.
+      *
+      * @param options - An array of request options for running requests in parallel.
+      * @returns A promise that resolves to an array of responses.  If the `returnErrors` property is set to `true`
+      * then the response objects will have their `error` property set to the thrown error.
+      */
+     runInParallel(options: RunInParallelOptions): Promise<HttpRequestResponse[]>;
+    }
+
+    /**
+     * @public
+     */
+    export declare interface PolarityRequestOptions {
+        defaults?: ConfigRequestProxyOptions;
+        isApiError?: IsApiErrorFunction;
+        roundedSuccessStatusCodes?: number[];
+        httpResponseErrorProperties?: string[];
+        httpResponseErrorMessageProperties?: string[];
+        requestOptionsToSanitize?: string[];
+        preprocessRequestOptions?: PreprocessRequestOptions;
+        postprocessRequestSuccess?: PostprocessRequestSuccess;
+        postprocessRequestFailure?: PostprocessRequestFailure;
+        throttlingOptions?: Bottleneck.ConstructorOptions;
+    }
+
+    /**
+     * @public
+     */
+    export declare type PossibleUserOptionValue = undefined | string | number | boolean | DropdownUserOptionValue | DropdownUserOptionValue[];
+
+    /**
+     * @public
+     */
+    export declare type PostprocessRequestFailure = (error: Error, requestOptions: HttpRequestOptions, userOptions: DoLookupUserOptions) => Promise<unknown> | never;
+
+    /**
+     * Optional middleware method for modifying the {@link HttpRequestResponse} after a successful request.
+     * The passed in {@link HttpRequestResponse} object is not a copy but can be safely modified without
+     * side effects.  The returned `HttpRequestResponse` object will be used for the response.
+     *
+     * @public
+     */
+    export declare type PostprocessRequestSuccess = (response: HttpRequestResponse, requestOptions: HttpRequestOptions, userOptions: DoLookupUserOptions) => Promise<HttpRequestResponse> | never;
+
+    /**
+     * Optional middleware method for modifying {@link HttpRequestOptions} before a request is made
+     * via the {@link PolarityRequest.run} method or {@link PolarityRequest.runInParallel} method.
+     * The returned `requestOptions` object will be used for the request.  This method is passed
+     * a copy of the original `requestOptions` object so it can be modified without side effects.
+     *
+     * This method is typically used for adding authentication (e.g., auth headers, or basic auth) to every request.  It can also
+     * be used to add headers that are required on every request or conditionally add headers based
+     * on the passed in `userOptions`.
+     *
+     * @public
+     */
+    export declare type PreprocessRequestOptions = (requestOptions: HttpRequestOptions, userOptions: DoLookupUserOptions) => Promise<HttpRequestOptions> | never | undefined;
+
+    /**
+     * Thrown by authenticated request method for any HTTP status codes where we want to allow
+     * the user to retry their lookup.
+     *
+     * @public
+     */
+    export declare class RetryRequestError extends IntegrationError {
+        constructor(message: string, properties?: IntegrationErrorProperties);
+    }
+
+    /**
+     * @public
+     */
+    export declare type RunInParallelOptions = {
+        /**
+         * Array of HttpRequestOptions that will be run in parallel as specified by
+         * the `maxConcurrentRequests` property.
+         */
+        allRequestOptions: HttpRequestOptions[];
+        /**
+         * Maximum number of requests to run in parallel
+         *
+         * @defaultValue 5
+         */
+        maxConcurrentRequests?: number;
+        /**
+         * If true, any errors thrown during the request will be returned in the response object on the `error` property
+         * of the returned `HttpRequestResponse` object.  If false, any errors thrown will be thrown and should be handled by
+         *
+         *
+         * @defaultValue false
+         */
+        returnErrors?: boolean;
+    };
+
+    /**
+     * Sanitizes the request options by removing sensitive information
+     * from the provided request options object.
+     *
+     * Default sanitized paths are:
+     *
+     * - auth.password
+     * - auth.bearer
+     * - body.password
+     * - form.client_secret
+     * - headers.authorization
+     * - headers.x-api-key
+     *
+     * @param requestOptions - request options to sanitize
+     * @param additionalPathsToSanitize - array of additional paths to sanitize in addition to the
+     * default paths.
+     */
+    export declare function sanitizeRequestOptions(requestOptions: HttpRequestOptions, additionalPathsToSanitize?: string[]): HttpRequestOptions;
+
+    /**
+     * @public
+     */
+    export declare interface SerializedIntegrationError {
+        /**
+         *  a short, human-readable summary of the problem that SHOULD NOT change from occurrence to occurrence of
+         *  the problem except for purposes of localization.  If omitted, the title will default to the type
+         *  of error (e.g., IntegrationError, or ApiRequestError)
+         */
+        title: string;
+        /**
+         * The name data property of IntegrationError.prototype is shared by all Error instances.
+         * It represents the name for the type of error. For IntegrationError.prototype.name,
+         * the initial value is "IntegrationError".
+         */
+        name: string;
+        /**
+         * a human-readable explanation specific to this occurrence of the problem. Like title, this field’s value can be
+         * localized
+         */
+        detail: string;
+        /**
+         * An optional HTTP status code applicable to this error, expressed as a string value.
+         */
+        status?: string;
+        /**
+         * Additional details related to the error that may help the user troubleshoot the issue.  If set by the user
+         * via the Error constructor, the user provided value will override any automated help message set by the
+         * Error class.
+         */
+        help?: string;
+        /**
+         * An optional StackTrace of the error
+         */
+        stack?: string;
+        /**
+         *  An optional application-specific error code, expressed as a string value.
+         */
+        code?: number | string;
+        /**
+         * The `cause` property is used to specify the `cause` of the error.  Typically,
+         * this property is used to pass through a related Error instance.
+         */
+        cause?: Error_2;
+        /**
+         * Relevant for integration errors involving a network call, the `requestOptions` property
+         * details the request options that resulted in the specified error.  The `requestOptions` property will automatically
+         * have sensitive authentication headers stripped.
+         */
+        requestOptions?: HttpRequestOptions;
+        /**
+         * an optional  meta object containing non-standard meta-information about the error.
+         */
+        meta?: ErrorMeta;
+    }
+
+    /**
+     * Set the logger object used by the integration.
+     *
+     * @example
+     * Example of setting the logger within the integration's startup method:
+     * ```js
+     * const { setLogger } = require('polarity-integration-utils/logger');
+     *
+     * function startup(logger){
+     *   setLogger(logger);
+     * }
+     * ```
+     *
+     * You can now use {@link getLogger} to get the logger object anywhere within your integration codebase.
+     *
+     * @public
+     * @param logger - the integration logger object passed into the `startup` method
+     */
+    export declare const setLogger: (logger: Logger) => void;
+
+    /**
+     * List of supported entity type values
+     * @public
+     */
+    export declare type StandardEntityType = 'IP' | 'IPv4' | 'IPv4CIDR' | 'IPv6' | 'MAC' | 'MD5' | 'SHA1' | 'SHA256' | 'cve' | 'domain' | 'email' | 'hash' | 'string' | 'url';
+
+    /**
+     * @public
+     */
+    export declare type ValidateOptionsUserOption = {
+        integration_id?: string;
+        key: string;
+        value: PossibleUserOptionValue;
+        user_can_edit?: boolean;
+        admin_only?: boolean;
+    };
+
+    /**
+     * @public
+     */
+    export declare type ValidateOptionsUserOptions = {
+        [key: string]: ValidateOptionsUserOption;
+    };
+
+    /**
+     * @public
+     */
+    export declare type ValidationError = {
+        key: string;
+        message: string;
+    };
+
+    export { }