@sentry/react-native 5.3.0 → 5.4.0

package/ts3.8/dist/js/NativeRNSentry.d.ts

@@ -0,0 +1,80 @@
+import type { Package } from '@sentry/types';
+import type { TurboModule } from 'react-native';
+import type { UnsafeObject } from 'react-native/Libraries/Types/CodegenTypes';
+export interface Spec extends TurboModule {
+    addBreadcrumb(breadcrumb: UnsafeObject): void;
+    captureEnvelope(bytes: number[], options: {
+        store: boolean;
+    }): Promise<boolean>;
+    captureScreenshot(): Promise<NativeScreenshot[] | undefined | null>;
+    clearBreadcrumbs(): void;
+    crash(): void;
+    closeNativeSdk(): Promise<void>;
+    disableNativeFramesTracking(): void;
+    fetchNativeRelease(): Promise<NativeReleaseResponse>;
+    fetchNativeSdkInfo(): Promise<Package>;
+    fetchNativeDeviceContexts(): Promise<NativeDeviceContextsResponse>;
+    fetchNativeAppStart(): Promise<NativeAppStartResponse | null>;
+    fetchNativeFrames(): Promise<NativeFramesResponse | null>;
+    initNativeSdk(options: UnsafeObject): Promise<boolean>;
+    setUser(defaultUserKeys: UnsafeObject | null, otherUserKeys: UnsafeObject | null): void;
+    setContext(key: string, value: UnsafeObject | null): void;
+    setExtra(key: string, value: string): void;
+    setTag(key: string, value: string): void;
+    enableNativeFramesTracking(): void;
+    fetchModules(): Promise<string | undefined | null>;
+    fetchViewHierarchy(): Promise<number[] | undefined | null>;
+}
+export declare type NativeAppStartResponse = {
+    isColdStart: boolean;
+    appStartTime: number;
+    didFetchAppStart: boolean;
+};
+export declare type NativeFramesResponse = {
+    totalFrames: number;
+    slowFrames: number;
+    frozenFrames: number;
+};
+export declare type NativeReleaseResponse = {
+    build: string;
+    id: string;
+    version: string;
+};
+/**
+ * This type describes serialized scope from sentry-cocoa. (This is not used for Android)
+ * https://github.com/getsentry/sentry-cocoa/blob/master/Sources/Sentry/SentryScope.m
+ */
+export declare type NativeDeviceContextsResponse = {
+    [key: string]: unknown;
+    tags?: Record<string, string>;
+    extra?: Record<string, unknown>;
+    context?: Record<string, Record<string, unknown>>;
+    user?: {
+        userId?: string;
+        email?: string;
+        username?: string;
+        ipAddress?: string;
+        segment?: string;
+        data?: Record<string, unknown>;
+    };
+    dist?: string;
+    environment?: string;
+    fingerprint?: string[];
+    level?: string;
+    breadcrumbs?: {
+        level?: string;
+        timestamp?: string;
+        category?: string;
+        type?: string;
+        message?: string;
+        data?: Record<string, unknown>;
+    }[];
+};
+export declare type NativeScreenshot = {
+    data: number[];
+    contentType: string;
+    filename: string;
+};
+declare const _default: Spec;
+export default _default;
+//# sourceMappingURL=NativeRNSentry.d.ts.map

package/ts3.8/dist/js/breadcrumb.d.ts

@@ -0,0 +1,11 @@
+import type { Breadcrumb, SeverityLevel } from '@sentry/types';
+export declare const DEFAULT_BREADCRUMB_LEVEL: SeverityLevel;
+declare type BreadcrumbCandidate = {
+    [K in keyof Partial<Breadcrumb>]: unknown;
+};
+/**
+ * Convert plain object to a valid Breadcrumb
+ */
+export declare function breadcrumbFromObject(candidate: BreadcrumbCandidate): Breadcrumb;
+export {};
+//# sourceMappingURL=breadcrumb.d.ts.map

package/ts3.8/dist/js/client.d.ts

@@ -0,0 +1,59 @@
+import { BaseClient } from '@sentry/core';
+import type { Envelope, Event, EventHint, SeverityLevel, UserFeedback } from '@sentry/types';
+import type { ReactNativeClientOptions } from './options';
+/**
+ * The Sentry React Native SDK Client.
+ *
+ * @see ReactNativeClientOptions for documentation on configuration options.
+ * @see SentryClient for usage documentation.
+ */
+export declare class ReactNativeClient extends BaseClient<ReactNativeClientOptions> {
+    private _outcomesBuffer;
+    /**
+     * Creates a new React Native SDK instance.
+     * @param options Configuration options for this SDK.
+     */
+    constructor(options: ReactNativeClientOptions);
+    /**
+     * @inheritDoc
+     */
+    eventFromException(exception: unknown, hint?: EventHint): PromiseLike<Event>;
+    /**
+     * @inheritDoc
+     */
+    eventFromMessage(message: string, level?: SeverityLevel, hint?: EventHint): PromiseLike<Event>;
+    /**
+     * If native client is available it will trigger a native crash.
+     * Use this only for testing purposes.
+     */
+    nativeCrash(): void;
+    /**
+     * @inheritDoc
+     */
+    close(): PromiseLike<boolean>;
+    /**
+     * Sends user feedback to Sentry.
+     */
+    captureUserFeedback(feedback: UserFeedback): void;
+    /**
+     * Sets up the integrations
+     */
+    setupIntegrations(): void;
+    /**
+     * @inheritdoc
+     */
+    protected _sendEnvelope(envelope: Envelope): void;
+    /**
+     * Starts native client with dsn and options
+     */
+    private _initNativeSdk;
+    /**
+     * If the user is in development mode, and the native nagger is enabled then it will show an alert.
+     */
+    private _showCannotConnectDialog;
+    /**
+     * Attaches a client report from outcomes to the envelope.
+     */
+    private _attachClientReportTo;
+}
+//# sourceMappingURL=client.d.ts.map

package/ts3.8/dist/js/index.d.ts

@@ -0,0 +1,13 @@
+export { Breadcrumb, Request, SdkInfo, Event, Exception, StackFrame, Stacktrace, Thread, User, UserFeedback, } from '@sentry/types';
+export { addGlobalEventProcessor, addBreadcrumb, captureException, captureEvent, captureMessage, getHubFromCarrier, getCurrentHub, Hub, Scope, setContext, setExtra, setExtras, setTag, setTags, setUser, startTransaction, } from '@sentry/core';
+export { Integrations as BrowserIntegrations, ErrorBoundary, withErrorBoundary, createReduxEnhancer, Profiler, useProfiler, withProfiler, } from '@sentry/react';
+export { lastEventId } from '@sentry/browser';
+import * as Integrations from './integrations';
+import { SDK_NAME, SDK_VERSION } from './version';
+export { ReactNativeOptions } from './options';
+export { ReactNativeClient } from './client';
+export { init, wrap, setDist, setRelease, nativeCrash, flush, close, captureUserFeedback, withScope, configureScope, } from './sdk';
+export { TouchEventBoundary, withTouchEventBoundary } from './touchevents';
+export { ReactNativeTracing, ReactNavigationV4Instrumentation, ReactNavigationV5Instrumentation, ReactNavigationInstrumentation, ReactNativeNavigationInstrumentation, RoutingInstrumentation, ReactNavigationTransactionContext, sentryTraceGesture, } from './tracing';
+export { Integrations, SDK_NAME, SDK_VERSION };
+//# sourceMappingURL=index.d.ts.map

package/ts3.8/dist/js/integrations/debugsymbolicator.d.ts

@@ -0,0 +1,49 @@
+import type { Integration } from '@sentry/types';
+/**
+ * React Native Error
+ */
+export declare type ReactNativeError = Error & {
+    framesToPop?: number;
+    jsEngine?: string;
+    preventSymbolication?: boolean;
+    componentStack?: string;
+};
+/** Tries to symbolicate the JS stack trace on the device. */
+export declare class DebugSymbolicator implements Integration {
+    /**
+     * @inheritDoc
+     */
+    static id: string;
+    /**
+     * @inheritDoc
+     */
+    name: string;
+    /**
+     * @inheritDoc
+     */
+    setupOnce(): void;
+    /**
+     * Symbolicates the stack on the device talking to local dev server.
+     * Mutates the passed event.
+     */
+    private _symbolicate;
+    /**
+     * Converts ReactNativeFrames to frames in the Sentry format
+     * @param frames ReactNativeFrame[]
+     */
+    private _convertReactNativeFramesToSentryFrames;
+    /**
+     * Replaces the frames in the exception of a error.
+     * @param event Event
+     * @param frames StackFrame[]
+     */
+    private _replaceFramesInEvent;
+    /**
+     * This tries to add source context for in_app Frames
+     *
+     * @param frame StackFrame
+     * @param getDevServer function from RN to get DevServer URL
+     */
+    private _addSourceContext;
+}
+//# sourceMappingURL=debugsymbolicator.d.ts.map

package/ts3.8/dist/js/integrations/devicecontext.d.ts

@@ -0,0 +1,17 @@
+import type { EventProcessor, Hub, Integration } from '@sentry/types';
+/** Load device context from native. */
+export declare class DeviceContext implements Integration {
+    /**
+     * @inheritDoc
+     */
+    static id: string;
+    /**
+     * @inheritDoc
+     */
+    name: string;
+    /**
+     * @inheritDoc
+     */
+    setupOnce(addGlobalEventProcessor: (callback: EventProcessor) => void, getCurrentHub: () => Hub): void;
+}
+//# sourceMappingURL=devicecontext.d.ts.map

package/ts3.8/dist/js/integrations/eventorigin.d.ts

@@ -0,0 +1,17 @@
+import type { EventProcessor, Integration } from '@sentry/types';
+/** Default EventOrigin instrumentation */
+export declare class EventOrigin implements Integration {
+    /**
+     * @inheritDoc
+     */
+    static id: string;
+    /**
+     * @inheritDoc
+     */
+    name: string;
+    /**
+     * @inheritDoc
+     */
+    setupOnce(addGlobalEventProcessor: (e: EventProcessor) => void): void;
+}
+//# sourceMappingURL=eventorigin.d.ts.map

package/ts3.8/dist/js/integrations/factory.d.ts

@@ -0,0 +1,7 @@
+import type { Integration } from '@sentry/types';
+/**
+ * Creates an integration out of the provided name and setup function.
+ * @hidden
+ */
+export declare function createIntegration(name: Integration['name'], setupOnce?: Integration['setupOnce']): Integration;
+//# sourceMappingURL=factory.d.ts.map

package/ts3.8/dist/js/integrations/index.d.ts

@@ -0,0 +1,9 @@
+export { DebugSymbolicator } from './debugsymbolicator';
+export { DeviceContext } from './devicecontext';
+export { ReactNativeErrorHandlers } from './reactnativeerrorhandlers';
+export { Release } from './release';
+export { EventOrigin } from './eventorigin';
+export { SdkInfo } from './sdkinfo';
+export { ReactNativeInfo } from './reactnativeinfo';
+export { ModulesLoader } from './modulesloader';
+//# sourceMappingURL=index.d.ts.map

package/ts3.8/dist/js/integrations/modulesloader.d.ts

@@ -0,0 +1,17 @@
+import type { EventProcessor, Integration } from '@sentry/types';
+/** Loads runtime JS modules from prepared file. */
+export declare class ModulesLoader implements Integration {
+    /**
+     * @inheritDoc
+     */
+    static id: string;
+    /**
+     * @inheritDoc
+     */
+    name: string;
+    /**
+     * @inheritDoc
+     */
+    setupOnce(addGlobalEventProcessor: (e: EventProcessor) => void): void;
+}
+//# sourceMappingURL=modulesloader.d.ts.map

package/ts3.8/dist/js/integrations/reactnativeerrorhandlers.d.ts

@@ -0,0 +1,54 @@
+import type { Integration } from '@sentry/types';
+/** ReactNativeErrorHandlers Options */
+interface ReactNativeErrorHandlersOptions {
+    onerror: boolean;
+    onunhandledrejection: boolean;
+    patchGlobalPromise: boolean;
+}
+/** ReactNativeErrorHandlers Integration */
+export declare class ReactNativeErrorHandlers implements Integration {
+    /**
+     * @inheritDoc
+     */
+    static id: string;
+    /**
+     * @inheritDoc
+     */
+    name: string;
+    /** ReactNativeOptions */
+    private readonly _options;
+    /** Constructor */
+    constructor(options?: Partial<ReactNativeErrorHandlersOptions>);
+    /**
+     * @inheritDoc
+     */
+    setupOnce(): void;
+    /**
+     * Handle Promises
+     */
+    private _handleUnhandledRejections;
+    /**
+     * Polyfill the global promise instance with one we can be sure that we can attach the tracking to.
+     *
+     * In newer RN versions >=0.63, the global promise is not the same reference as the one imported from the promise library.
+     * This is due to a version mismatch between promise versions.
+     * Originally we tried a solution where we would have you put a package resolution to ensure the promise instances match. However,
+     * - Using a package resolution requires the you to manually troubleshoot.
+     * - The package resolution fix no longer works with 0.67 on iOS Hermes.
+     */
+    private _polyfillPromise;
+    /**
+     * Attach the unhandled rejection handler
+     */
+    private _attachUnhandledRejectionHandler;
+    /**
+     * Checks if the promise is the same one or not, if not it will warn the user
+     */
+    private _checkPromiseAndWarn;
+    /**
+     * Handle errors
+     */
+    private _handleOnError;
+}
+export {};
+//# sourceMappingURL=reactnativeerrorhandlers.d.ts.map

package/ts3.8/dist/js/integrations/reactnativeinfo.d.ts

@@ -0,0 +1,23 @@
+import type { Context, EventProcessor, Integration } from '@sentry/types';
+export interface ReactNativeContext extends Context {
+    js_engine?: string;
+    turbo_module: boolean;
+    fabric: boolean;
+    component_stack?: string;
+}
+/** Loads React Native context at runtime */
+export declare class ReactNativeInfo implements Integration {
+    /**
+     * @inheritDoc
+     */
+    static id: string;
+    /**
+     * @inheritDoc
+     */
+    name: string;
+    /**
+     * @inheritDoc
+     */
+    setupOnce(addGlobalEventProcessor: (callback: EventProcessor) => void): void;
+}
+//# sourceMappingURL=reactnativeinfo.d.ts.map

package/ts3.8/dist/js/integrations/release.d.ts

@@ -0,0 +1,17 @@
+import type { Integration } from '@sentry/types';
+/** Release integration responsible to load release from file. */
+export declare class Release implements Integration {
+    /**
+     * @inheritDoc
+     */
+    static id: string;
+    /**
+     * @inheritDoc
+     */
+    name: string;
+    /**
+     * @inheritDoc
+     */
+    setupOnce(): void;
+}
+//# sourceMappingURL=release.d.ts.map

package/ts3.8/dist/js/integrations/rewriteframes.d.ts

@@ -0,0 +1,8 @@
+import { RewriteFrames } from '@sentry/integrations';
+/**
+ * Creates React Native default rewrite frames integration
+ * which appends app:// to the beginning of the filename
+ * and removes file://, 'address at' prefixes and CodePush postfix.
+ */
+export declare function createReactNativeRewriteFrames(): RewriteFrames;
+//# sourceMappingURL=rewriteframes.d.ts.map

package/ts3.8/dist/js/integrations/screenshot.d.ts

@@ -0,0 +1,23 @@
+import type { EventHint, Integration } from '@sentry/types';
+/** Adds screenshots to error events */
+export declare class Screenshot implements Integration {
+    /**
+     * @inheritDoc
+     */
+    static id: string;
+    /**
+     * @inheritDoc
+     */
+    name: string;
+    /**
+     * If enabled attaches a screenshot to the event hint.
+     */
+    static attachScreenshotToEventHint(hint: EventHint, { attachScreenshot }: {
+        attachScreenshot?: boolean;
+    }): PromiseLike<EventHint>;
+    /**
+     * @inheritDoc
+     */
+    setupOnce(): void;
+}
+//# sourceMappingURL=screenshot.d.ts.map

package/ts3.8/dist/js/integrations/sdkinfo.d.ts

@@ -0,0 +1,21 @@
+import type { EventProcessor, Integration, SdkInfo as SdkInfoType } from '@sentry/types';
+declare type DefaultSdkInfo = Pick<Required<SdkInfoType>, 'name' | 'packages' | 'version'>;
+export declare const defaultSdkInfo: DefaultSdkInfo;
+/** Default SdkInfo instrumentation */
+export declare class SdkInfo implements Integration {
+    /**
+     * @inheritDoc
+     */
+    static id: string;
+    /**
+     * @inheritDoc
+     */
+    name: string;
+    private _nativeSdkInfo;
+    /**
+     * @inheritDoc
+     */
+    setupOnce(addGlobalEventProcessor: (e: EventProcessor) => void): void;
+}
+export {};
+//# sourceMappingURL=sdkinfo.d.ts.map

package/ts3.8/dist/js/integrations/viewhierarchy.d.ts

@@ -0,0 +1,20 @@
+import type { EventProcessor, Integration } from '@sentry/types';
+/** Adds ViewHierarchy to error events */
+export declare class ViewHierarchy implements Integration {
+    /**
+     * @inheritDoc
+     */
+    static id: string;
+    private static _fileName;
+    private static _contentType;
+    private static _attachmentType;
+    /**
+     * @inheritDoc
+     */
+    name: string;
+    /**
+     * @inheritDoc
+     */
+    setupOnce(addGlobalEventProcessor: (e: EventProcessor) => void): void;
+}
+//# sourceMappingURL=viewhierarchy.d.ts.map

package/ts3.8/dist/js/measurements.d.ts

@@ -0,0 +1,13 @@
+import type { Hub, Transaction } from '@sentry/core';
+import type { CustomSamplingContext, TransactionContext } from '@sentry/types';
+export declare const APP_START_WARM = "app_start_warm";
+export declare const APP_START_COLD = "app_start_cold";
+export declare const STALL_COUNT = "stall_count";
+export declare const STALL_TOTAL_TIME = "stall_total_time";
+export declare const STALL_LONGEST_TIME = "stall_longest_time";
+/**
+ * Adds React Native's extensions. Needs to be called before any transactions are created.
+ */
+export declare function _addTracingExtensions(): void;
+export declare type StartTransactionFunction = (this: Hub, transactionContext: TransactionContext, customSamplingContext?: CustomSamplingContext) => Transaction;
+//# sourceMappingURL=measurements.d.ts.map

package/ts3.8/dist/js/misc.d.ts

@@ -0,0 +1,9 @@
+import type { EnvelopeItem } from '@sentry/types';
+declare type EnvelopeItemPayload = EnvelopeItem[1];
+/**
+ * Extracts the hard crash information from the event exceptions.
+ * No exceptions or undefined handled are not hard crashes.
+ */
+export declare function isHardCrash(payload: EnvelopeItemPayload): boolean;
+export {};
+//# sourceMappingURL=misc.d.ts.map

package/ts3.8/dist/js/options.d.ts

@@ -0,0 +1,152 @@
+import type { BrowserTransportOptions } from '@sentry/browser/types/transports/types';
+import type { ProfilerProps } from '@sentry/react/types/profiler';
+import type { ClientOptions, Options } from '@sentry/types';
+import type { CaptureContext } from '@sentry/types/types/scope';
+import type { TouchEventBoundaryProps } from './touchevents';
+export interface BaseReactNativeOptions {
+    /**
+     * Enables native transport + device info + offline caching.
+     * Be careful, disabling this also breaks automatic release setting.
+     * This means you have to manage setting the release yourself.
+     * Defaults to `true`.
+     */
+    enableNative?: boolean;
+    /**
+     * Enables native crashHandling. This only works if `enableNative` is `true`.
+     * Defaults to `true`.
+     */
+    enableNativeCrashHandling?: boolean;
+    /**
+     * Initializes the native SDK on init.
+     * Set this to `false` if you have an existing native SDK and don't want to re-initialize.
+     *
+     * NOTE: Be careful and only use this if you know what you are doing.
+     * If you use this flag, make sure a native SDK is running before the JS Engine initializes or events might not be captured.
+     * Also, make sure the DSN on both the React Native side and the native side are the same one.
+     * We strongly recommend checking the documentation if you need to use this.
+     *
+     * @default true
+     */
+    autoInitializeNativeSdk?: boolean;
+    /** Should the native nagger alert be shown or not. */
+    enableNativeNagger?: boolean;
+    /** Should sessions be tracked to Sentry Health or not. */
+    enableAutoSessionTracking?: boolean;
+    /** The interval to end a session if the App goes to the background. */
+    sessionTrackingIntervalMillis?: number;
+    /** Enable scope sync from Java to NDK on Android */
+    enableNdkScopeSync?: boolean;
+    /** When enabled, all the threads are automatically attached to all logged events on Android */
+    attachThreads?: boolean;
+    /**
+     *  When enabled, certain personally identifiable information (PII) is added by active integrations.
+     *
+     * @default false
+     */
+    sendDefaultPii?: boolean;
+    /**
+     * Callback that is called after the RN SDK on the JS Layer has made contact with the Native Layer.
+     */
+    onReady?: (response: {
+        /** `true` if the native SDK has been initialized, `false` otherwise.  */
+        didCallNativeInit: boolean;
+    }) => void;
+    /** Enable auto performance tracking by default. Renamed from `enableAutoPerformanceTracking` in v5. */
+    enableAutoPerformanceTracing?: boolean;
+    /**
+     * Enables Out of Memory Tracking for iOS and macCatalyst.
+     * See the following link for more information and possible restrictions:
+     * https://docs.sentry.io/platforms/apple/guides/ios/configuration/out-of-memory/
+     *
+     * Renamed from `enableOutOfMemoryTracking` in v5.
+     *
+     * @default true
+     */
+    enableWatchdogTerminationTracking?: boolean;
+    /**
+     * Set data to the inital scope
+     * @deprecated Use `Sentry.configureScope(...)`
+     */
+    initialScope?: CaptureContext;
+    /**
+     * When enabled, Sentry will overwrite the global Promise instance to ensure that unhandled rejections are correctly tracked.
+     * If you run into issues with Promise polyfills such as `core-js`, make sure you polyfill after Sentry is initialized.
+     * Read more at https://docs.sentry.io/platforms/react-native/troubleshooting/#unhandled-promise-rejections
+     *
+     * When disabled, this option will not disable unhandled rejection tracking. Set `onunhandledrejection: false` on the `ReactNativeErrorHandlers` integration instead.
+     *
+     * @default true
+     */
+    patchGlobalPromise?: boolean;
+    /**
+     * The max cache items for capping the number of envelopes.
+     *
+     * @default 30
+     */
+    maxCacheItems?: number;
+    /**
+     * When enabled, the SDK tracks when the application stops responding for a specific amount of
+     * time defined by the `appHangTimeoutInterval` option.
+     *
+     * iOS only
+     *
+     * @default true
+     */
+    enableAppHangTracking?: boolean;
+    /**
+     * The minimum amount of time an app should be unresponsive to be classified as an App Hanging.
+     * The actual amount may be a little longer.
+     * Avoid using values lower than 100ms, which may cause a lot of app hangs events being transmitted.
+     * Value should be in seconds.
+     *
+     * iOS only
+     *
+     * @default 2
+     */
+    appHangTimeoutInterval?: number;
+    /**
+     * The max queue size for capping the number of envelopes waiting to be sent by Transport.
+     */
+    maxQueueSize?: number;
+    /**
+     * When enabled and a user experiences an error, Sentry provides the ability to take a screenshot and include it as an attachment.
+     *
+     * @default false
+     */
+    attachScreenshot?: boolean;
+    /**
+     * When enabled Sentry includes the current view hierarchy in the error attachments.
+     *
+     * @default false
+     */
+    attachViewHierarchy?: boolean;
+    /**
+     * When enabled, Sentry will capture failed XHR/Fetch requests. This option also enabled HTTP Errors on iOS.
+     * [Sentry Android Gradle Plugin](https://docs.sentry.io/platforms/android/configuration/integrations/okhttp/)
+     * is needed to capture HTTP Errors on Android.
+     *
+     * @default false
+     */
+    enableCaptureFailedRequests?: boolean;
+}
+export interface ReactNativeTransportOptions extends BrowserTransportOptions {
+    /**
+     * @deprecated use `maxQueueSize` in the root of the SDK options.
+     */
+    bufferSize?: number;
+}
+/**
+ * Configuration options for the Sentry ReactNative SDK.
+ * @see ReactNativeFrontend for more information.
+ */
+export interface ReactNativeOptions extends Options<ReactNativeTransportOptions>, BaseReactNativeOptions {
+}
+export interface ReactNativeClientOptions extends ClientOptions<ReactNativeTransportOptions>, BaseReactNativeOptions {
+}
+export interface ReactNativeWrapperOptions {
+    /** Props for the root React profiler */
+    profilerProps?: ProfilerProps;
+    /** Props for the root touch event boundary */
+    touchEventBoundaryProps?: TouchEventBoundaryProps;
+}
+//# sourceMappingURL=options.d.ts.map