@gnwebsoft/ui 3.0.1 → 3.0.2

package/dist/utils/index.d.ts

@@ -1,10 +1,10 @@
 import { PostModel, ApiResponse, ListResponse, ValidationErrors } from '../types/index.js';
 import { PickerValidDate } from '@mui/x-date-pickers';
 import { useLocalizationContext } from '@mui/x-date-pickers/internals';
-import { FieldValues, UseFormSetError } from 'react-hook-form';
+import * as react_hook_form from 'react-hook-form';
+import { FieldValues, UseFormSetError, Control, DeepPartialSkipArrayKey, Path, PathValue } from 'react-hook-form';
 import { z } from 'zod';
 import '@mui/x-data-grid';
-import '../AsyncSelectPayload-Cz4bgak0.js';
 
 declare class api {
     static filter<T, TFilter>(url: string, postModel: PostModel<TFilter>): Promise<ApiResponse<ListResponse<T>>>;
@@ -28,18 +28,173 @@ declare class api2 {
     static upload<T>(url: string, formData: FormData): Promise<ApiResponse<T>>;
 }
 
+/**
+ * Recursively flattens an object into a flat structure with dot-notation keys.
+ *
+ * This utility function takes a nested object and converts it into a flat object
+ * where nested properties are represented using dot notation. It handles both
+ * nested objects and arrays, preserving all levels of the original structure
+ * as separate keys in the result.
+ *
+ * @example
+ * Basic object flattening:
+ * ```tsx
+ * const nested = {
+ *   user: {
+ *     name: 'John',
+ *     address: {
+ *       city: 'New York',
+ *       zip: '10001'
+ *     }
+ *   }
+ * };
+ *
+ * const flattened = flattenObjectKeys(nested);
+ * // Result:
+ * // {
+ * //   'user': { name: 'John', address: { city: 'New York', zip: '10001' } },
+ * //   'user.name': 'John',
+ * //   'user.address': { city: 'New York', zip: '10001' },
+ * //   'user.address.city': 'New York',
+ * //   'user.address.zip': '10001'
+ * // }
+ * ```
+ *
+ * @example
+ * Array handling:
+ * ```tsx
+ * const withArrays = {
+ *   items: [
+ *     { id: 1, name: 'Item 1' },
+ *     { id: 2, name: 'Item 2' }
+ *   ]
+ * };
+ *
+ * const flattened = flattenObjectKeys(withArrays);
+ * // Result includes:
+ * // {
+ * //   'items': [...],
+ * //   'items.0': { id: 1, name: 'Item 1' },
+ * //   'items.0.id': 1,
+ * //   'items.0.name': 'Item 1',
+ * //   'items.1': { id: 2, name: 'Item 2' },
+ * //   'items.1.id': 2,
+ * //   'items.1.name': 'Item 2'
+ * // }
+ * ```
+ *
+ * @param obj - The object to flatten
+ * @param prefix - Internal parameter for building key paths (used in recursion)
+ * @returns A flat object with dot-notation keys representing the original structure
+ *
+ * @public
+ */
 declare const flattenObjectKeys: (obj: any, prefix?: string) => {
     [x: string]: any;
 };
 
 declare function getTimezone<TDate extends PickerValidDate>(adapter: ReturnType<typeof useLocalizationContext>, value: TDate): string | null;
 
-type HandleServerErrorsType<TFieldValues extends FieldValues = FieldValues> = {
+/**
+ * Configuration options for the handleServerErrors function.
+ *
+ * @template TFieldValues - The form values type
+ *
+ * @public
+ */
+interface HandleServerErrorsType<TFieldValues extends FieldValues = FieldValues> {
+    /**
+     * Server validation errors object containing field-specific error messages
+     * @example { email: 'Email is already taken', password: ['Too short', 'Must contain numbers'] }
+     */
     errors?: ValidationErrors;
+    /**
+     * The setError function from react-hook-form for setting field errors
+     */
     setError: UseFormSetError<TFieldValues>;
-};
+}
+/**
+ * Processes server validation errors and applies them to react-hook-form fields.
+ *
+ * This utility function takes validation errors from a server response and automatically
+ * applies them to the corresponding form fields using react-hook-form's setError function.
+ * It supports various error formats including strings, arrays of strings, and boolean flags.
+ *
+ * The function uses object flattening to handle nested error structures and ensures
+ * that only valid field paths are processed.
+ *
+ * @example
+ * Basic usage with server response:
+ * ```tsx
+ * const { setError } = useForm();
+ *
+ * try {
+ *   await submitForm(data);
+ * } catch (error) {
+ *   handleServerErrors({
+ *     errors: error.response.data.errors,
+ *     setError
+ *   });
+ * }
+ * ```
+ *
+ * @example
+ * With different error formats:
+ * ```tsx
+ * const serverErrors = {
+ *   email: 'Email is already taken',
+ *   password: ['Too short', 'Must contain numbers'],
+ *   terms: true // Boolean flag indicating invalid
+ * };
+ *
+ * handleServerErrors({ errors: serverErrors, setError });
+ * // Results in:
+ * // - email field shows: "Email is already taken"
+ * // - password field shows: "Too short Must contain numbers"
+ * // - terms field shows: "Field is not valid."
+ * ```
+ *
+ * @template TFieldValues - The form values type
+ *
+ * @param args - Configuration object containing errors and setError function
+ *
+ * @public
+ */
 declare const handleServerErrors: <TFieldValues extends FieldValues = FieldValues>(args: HandleServerErrorsType<TFieldValues>) => void;
 
+/**
+ * Type-safe property existence checker that acts as a type guard.
+ *
+ * Checks if a given property exists on an object and narrows the TypeScript type
+ * to include that property. This is useful for safely accessing properties on
+ * objects of unknown structure while maintaining type safety.
+ *
+ * @template X - The type of the object being checked
+ * @template Y - The type of the property key (extends PropertyKey)
+ *
+ * @param obj - The object to check for the property
+ * @param prop - The property key to check for existence
+ *
+ * @returns A type predicate indicating whether the property exists on the object.
+ *          If true, the object type is narrowed to include the specified property.
+ *
+ * @example
+ * ```typescript
+ * const data: unknown = { name: "John", age: 30 };
+ *
+ * if (propertyExists(data, "name")) {
+ *   // TypeScript now knows data has a 'name' property
+ *   console.log(data.name); // Type-safe access
+ * }
+ *
+ * // Check for nested property existence
+ * if (propertyExists(obj, "user") && propertyExists(obj.user, "id")) {
+ *   console.log(obj.user.id); // Safe nested access
+ * }
+ * ```
+ *
+ * @since 2.18.45
+ */
 declare function propertyExists<X, Y extends PropertyKey>(obj: X, prop: Y): obj is X & Record<Y, unknown>;
 
 declare function readValueAsDate<TDate extends PickerValidDate>(adapter: ReturnType<typeof useLocalizationContext>, value: string | null | TDate): TDate | null;
@@ -47,12 +202,165 @@ declare function readValueAsDate<TDate extends PickerValidDate>(adapter: ReturnT
 declare const removeLeadingTrailingSlashes: (route: string) => string;
 
 declare const schemaTools: {
-    date: ({ message }: {
+    date: ({ message }?: {
         message?: string;
-    }) => z.ZodEffects<z.ZodEffects<z.ZodEffects<z.ZodString, string | null, string>, string | null, string>, string | null, string>;
+    }) => z.ZodPipe<z.ZodCoercedString<unknown>, z.ZodTransform<string | null, string>>;
     nullableDate: ({ message }?: {
-        message?: string | null;
-    }) => z.ZodEffects<z.ZodEffects<z.ZodEffects<z.ZodString, string | null, string>, string | null, string>, string | null, string>;
+        message?: string;
+    }) => z.ZodPipe<z.ZodPipe<z.ZodCoercedString<unknown>, z.ZodTransform<string | null, string>>, z.ZodTransform<string | null, string | null>>;
+    dateRange: ({ message }?: {
+        message?: string;
+    }) => z.ZodObject<{
+        start: z.ZodCoercedDate<unknown>;
+        end: z.ZodCoercedDate<unknown>;
+    }, z.core.$strip>;
+    requiredString: ({ message, min, max }?: {
+        message?: string;
+        min?: number;
+        max?: number;
+    }) => z.ZodString;
+    email: ({ message }?: {
+        message?: string;
+    }) => z.ZodString;
+    url: ({ message }?: {
+        message?: string;
+    }) => z.ZodString;
+    phone: ({ message }?: {
+        message?: string;
+    }) => z.ZodString;
+    alphanumeric: ({ message }?: {
+        message?: string;
+    }) => z.ZodString;
+    slug: ({ message }?: {
+        message?: string;
+    }) => z.ZodString;
+    positiveNumber: ({ message, min, max }?: {
+        message?: string;
+        min?: number;
+        max?: number;
+    }) => z.ZodNumber;
+    nonNegativeNumber: ({ message, max }?: {
+        message?: string;
+        max?: number;
+    }) => z.ZodNumber;
+    integer: ({ message, min, max }?: {
+        message?: string;
+        min?: number;
+        max?: number;
+    }) => z.ZodNumber;
+    percentage: ({ message }?: {
+        message?: string;
+    }) => z.ZodNumber;
+    nonEmptyArray: <T>(schema: z.ZodSchema<T>, { message }?: {
+        message?: string;
+    }) => z.ZodArray<z.ZodType<T, unknown, z.core.$ZodTypeInternals<T, unknown>>>;
+    uniqueArray: <T>(schema: z.ZodSchema<T>, { message }?: {
+        message?: string;
+    }) => z.ZodArray<z.ZodType<T, unknown, z.core.$ZodTypeInternals<T, unknown>>>;
+    requiredBoolean: ({ message }?: {
+        message?: string;
+    }) => z.ZodBoolean;
+    nonEmptyObject: <T extends Record<string, unknown>>(schema: z.ZodSchema<T>, { message }?: {
+        message?: string;
+    }) => z.ZodType<T, unknown, z.core.$ZodTypeInternals<T, unknown>>;
+    fileSize: ({ maxSize, message }: {
+        maxSize: number;
+        message?: string;
+    }) => z.ZodCustom<File, File>;
+    fileType: ({ allowedTypes, message }: {
+        allowedTypes: string[];
+        message?: string;
+    }) => z.ZodCustom<File, File>;
+    conditional: <T, U>(condition: (data: T) => boolean, trueSchema: z.ZodSchema<U>, falseSchema: z.ZodSchema<U>) => z.ZodUnion<readonly [z.ZodType<U, unknown, z.core.$ZodTypeInternals<U, unknown>>, z.ZodType<U, unknown, z.core.$ZodTypeInternals<U, unknown>>]>;
+    transform: {
+        toLowerCase: z.ZodPipe<z.ZodString, z.ZodTransform<string, string>>;
+        toUpperCase: z.ZodPipe<z.ZodString, z.ZodTransform<string, string>>;
+        trim: z.ZodPipe<z.ZodString, z.ZodTransform<string, string>>;
+        toNumber: z.ZodPipe<z.ZodString, z.ZodTransform<number, string>>;
+        toBoolean: z.ZodPipe<z.ZodString, z.ZodTransform<boolean, string>>;
+        parseJson: <T>(schema: z.ZodSchema<T>) => z.ZodPipe<z.ZodString, z.ZodTransform<Awaited<T>, string>>;
+    };
+};
+
+/**
+ * Core watch functions for React Hook Form
+ * These are the primary building blocks for form watching
+ */
+/**
+ * Utility type to ensure array elements are all Path<T>
+ */
+type PathArray<T extends FieldValues> = ReadonlyArray<Path<T>>;
+/**
+ * Hook to watch entire form - returns all form values
+ */
+declare const useWatchForm: <TFieldValues extends FieldValues>(control: Control<TFieldValues>) => DeepPartialSkipArrayKey<TFieldValues>;
+/**
+ * Hook to watch single field by path - supports any nested path
+ */
+declare const useWatchField: <TFieldValues extends FieldValues, TName extends Path<TFieldValues>>(control: Control<TFieldValues>, name: TName) => PathValue<TFieldValues, TName>;
+/**
+ * Hook to watch multiple fields by paths - returns array of values
+ */
+declare const useWatchFields: <TFieldValues extends FieldValues, TNames extends ReadonlyArray<Path<TFieldValues>>>(control: Control<TFieldValues>, names: TNames) => Array<PathValue<TFieldValues, TNames[number]>>;
+
+/**
+ * Utility watch functions for React Hook Form
+ * Enhanced functionality for specific use cases
+ */
+/**
+ * Watch field with transformation/selector
+ */
+declare const useWatchTransform: <TFieldValues extends FieldValues, TName extends Path<TFieldValues>, TOutput>(control: Control<TFieldValues>, name: TName, transform: (value: PathValue<TFieldValues, TName>) => TOutput) => TOutput;
+/**
+ * Watch field with default fallback value
+ */
+declare const useWatchDefault: <TFieldValues extends FieldValues, TName extends Path<TFieldValues>>(control: Control<TFieldValues>, name: TName, defaultValue: PathValue<TFieldValues, TName>) => PathValue<TFieldValues, TName>;
+/**
+ * Watch field as boolean with guaranteed boolean return
+ */
+declare const useWatchBoolean: <TFieldValues extends FieldValues, TName extends Path<TFieldValues>>(control: Control<TFieldValues>, name: TName, defaultValue?: boolean) => boolean;
+/**
+ * Watch multiple fields and return an object with field paths as keys
+ */
+declare const useWatchBatch: <TFieldValues extends FieldValues, TFields extends ReadonlyArray<Path<TFieldValues>>>(control: Control<TFieldValues>, fields: TFields) => { [K in TFields[number]]: PathValue<TFieldValues, K>; };
+/**
+ * Watch field conditionally based on boolean flag
+ */
+declare const useWatchConditional: <TFieldValues extends FieldValues, TName extends Path<TFieldValues>>(control: Control<TFieldValues>, name: TName, shouldWatch: boolean, fallback?: PathValue<TFieldValues, TName>) => PathValue<TFieldValues, TName> | undefined;
+/**
+ * Watch field with debounced updates
+ */
+declare const useWatchDebounced: <TFieldValues extends FieldValues, TName extends Path<TFieldValues>>(control: Control<TFieldValues>, name: TName, delay?: number) => PathValue<TFieldValues, TName>;
+/**
+ * Watch field with memoized selector function
+ */
+declare const useWatchSelector: <TFieldValues extends FieldValues, TName extends Path<TFieldValues>, TOutput>(control: Control<TFieldValues>, name: TName, selector: (value: PathValue<TFieldValues, TName>) => TOutput, deps?: React.DependencyList) => TOutput;
+
+/**
+ * Organized utilities by use case
+ * Provides a convenient object-based API for all watch functions
+ */
+declare const typedWatch: {
+    /** Watch entire form */
+    readonly form: <TFieldValues extends react_hook_form.FieldValues>(control: react_hook_form.Control<TFieldValues>) => react_hook_form.DeepPartialSkipArrayKey<TFieldValues>;
+    /** Watch single field */
+    readonly field: <TFieldValues extends react_hook_form.FieldValues, TName extends react_hook_form.Path<TFieldValues>>(control: react_hook_form.Control<TFieldValues>, name: TName) => react_hook_form.PathValue<TFieldValues, TName>;
+    /** Watch multiple fields */
+    readonly fields: <TFieldValues extends react_hook_form.FieldValues, TNames extends ReadonlyArray<react_hook_form.Path<TFieldValues>>>(control: react_hook_form.Control<TFieldValues>, names: TNames) => Array<react_hook_form.PathValue<TFieldValues, TNames[number]>>;
+    /** Watch with transformation */
+    readonly transform: <TFieldValues extends react_hook_form.FieldValues, TName extends react_hook_form.Path<TFieldValues>, TOutput>(control: react_hook_form.Control<TFieldValues>, name: TName, transform: (value: react_hook_form.PathValue<TFieldValues, TName>) => TOutput) => TOutput;
+    /** Watch with default value */
+    readonly withDefault: <TFieldValues extends react_hook_form.FieldValues, TName extends react_hook_form.Path<TFieldValues>>(control: react_hook_form.Control<TFieldValues>, name: TName, defaultValue: react_hook_form.PathValue<TFieldValues, TName>) => react_hook_form.PathValue<TFieldValues, TName>;
+    /** Watch as boolean */
+    readonly boolean: <TFieldValues extends react_hook_form.FieldValues, TName extends react_hook_form.Path<TFieldValues>>(control: react_hook_form.Control<TFieldValues>, name: TName, defaultValue?: boolean) => boolean;
+    /** Watch multiple with custom keys */
+    readonly batch: <TFieldValues extends react_hook_form.FieldValues, TFields extends ReadonlyArray<react_hook_form.Path<TFieldValues>>>(control: react_hook_form.Control<TFieldValues>, fields: TFields) => { [K in TFields[number]]: react_hook_form.PathValue<TFieldValues, K>; };
+    /** Watch conditionally */
+    readonly conditional: <TFieldValues extends react_hook_form.FieldValues, TName extends react_hook_form.Path<TFieldValues>>(control: react_hook_form.Control<TFieldValues>, name: TName, shouldWatch: boolean, fallback?: react_hook_form.PathValue<TFieldValues, TName>) => react_hook_form.PathValue<TFieldValues, TName> | undefined;
+    /** Watch with debouncing */
+    readonly debounced: <TFieldValues extends react_hook_form.FieldValues, TName extends react_hook_form.Path<TFieldValues>>(control: react_hook_form.Control<TFieldValues>, name: TName, delay?: number) => react_hook_form.PathValue<TFieldValues, TName>;
+    /** Watch with selector */
+    readonly selector: <TFieldValues extends react_hook_form.FieldValues, TName extends react_hook_form.Path<TFieldValues>, TOutput>(control: react_hook_form.Control<TFieldValues>, name: TName, selector: (value: react_hook_form.PathValue<TFieldValues, TName>) => TOutput, deps?: React.DependencyList) => TOutput;
 };
 
-export { api, api2, flattenObjectKeys, getTimezone, handleServerErrors, propertyExists, readValueAsDate, removeLeadingTrailingSlashes, schemaTools };
+export { type PathArray, api, api2, flattenObjectKeys, getTimezone, handleServerErrors, propertyExists, readValueAsDate, removeLeadingTrailingSlashes, schemaTools, typedWatch, useWatchBatch, useWatchBoolean, useWatchConditional, useWatchDebounced, useWatchDefault, useWatchField, useWatchFields, useWatchForm, useWatchSelector, useWatchTransform };

package/dist/utils/index.js

@@ -1,22 +1,45 @@
-"use strict";Object.defineProperty(exports, "__esModule", {value: true});
-
-
-
-
-
-
-
-
-
-var _chunkI7EIUZKKjs = require('../chunk-I7EIUZKK.js');
-
-
-
-
-
-
-
-
-
-
-exports.api = _chunkI7EIUZKKjs.api; exports.api2 = _chunkI7EIUZKKjs.api2; exports.flattenObjectKeys = _chunkI7EIUZKKjs.flattenObjectKeys; exports.getTimezone = _chunkI7EIUZKKjs.getTimezone; exports.handleServerErrors = _chunkI7EIUZKKjs.handleServerErrors; exports.propertyExists = _chunkI7EIUZKKjs.propertyExists; exports.readValueAsDate = _chunkI7EIUZKKjs.readValueAsDate; exports.removeLeadingTrailingSlashes = _chunkI7EIUZKKjs.removeLeadingTrailingSlashes; exports.schemaTools = _chunkI7EIUZKKjs.schemaTools;
+import {
+  api,
+  api2,
+  flattenObjectKeys,
+  getTimezone,
+  handleServerErrors,
+  propertyExists,
+  readValueAsDate,
+  removeLeadingTrailingSlashes,
+  schemaTools,
+  typedWatch,
+  useWatchBatch,
+  useWatchBoolean,
+  useWatchConditional,
+  useWatchDebounced,
+  useWatchDefault,
+  useWatchField,
+  useWatchFields,
+  useWatchForm,
+  useWatchSelector,
+  useWatchTransform
+} from "../chunk-4H3AFH7A.js";
+export {
+  api,
+  api2,
+  flattenObjectKeys,
+  getTimezone,
+  handleServerErrors,
+  propertyExists,
+  readValueAsDate,
+  removeLeadingTrailingSlashes,
+  schemaTools,
+  typedWatch,
+  useWatchBatch,
+  useWatchBoolean,
+  useWatchConditional,
+  useWatchDebounced,
+  useWatchDefault,
+  useWatchField,
+  useWatchFields,
+  useWatchForm,
+  useWatchSelector,
+  useWatchTransform
+};
+//# sourceMappingURL=data:application/json;base64,ewogICJ2ZXJzaW9uIjogMywKICAic291cmNlcyI6IFtdLAogICJzb3VyY2VzQ29udGVudCI6IFtdLAogICJtYXBwaW5ncyI6ICIiLAogICJuYW1lcyI6IFtdCn0K

package/dist/wrappers/index.cjs

@@ -0,0 +1,54 @@
+"use strict";Object.defineProperty(exports, "__esModule", {value: true});
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+var _chunkOT7COE7Rcjs = require('../chunk-OT7COE7R.cjs');
+require('../chunk-R2YK4LTT.cjs');
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+exports.AsyncMultiSelect2 = _chunkOT7COE7Rcjs.AsyncMultiSelect2; exports.CheckboxElement = _chunkOT7COE7Rcjs.CheckboxElement; exports.CheckboxGroup = _chunkOT7COE7Rcjs.CheckboxGroup; exports.DatePickerElement = _chunkOT7COE7Rcjs.DatePickerElement; exports.DatePickerElementCore = _chunkOT7COE7Rcjs.DatePickerElementCore; exports.EnhancedTextFieldElement = _chunkOT7COE7Rcjs.EnhancedTextFieldElement; exports.PasswordElement = _chunkOT7COE7Rcjs.PasswordElement_default; exports.RadioButtonGroup = _chunkOT7COE7Rcjs.RadioButtonGroup_default; exports.SelectCascadeElement = _chunkOT7COE7Rcjs.SelectCascadeElement_default; exports.SelectElement = _chunkOT7COE7Rcjs.SelectElement_default; exports.SelectMultiElement = _chunkOT7COE7Rcjs.SelectMultiElement_default; exports.TextFieldElement = _chunkOT7COE7Rcjs.TextFieldElement_default; exports.TimePickerElement = _chunkOT7COE7Rcjs.TimePickerElement_default; exports.createDateInputTransform = _chunkOT7COE7Rcjs.createDateInputTransform; exports.createDateOutputTransform = _chunkOT7COE7Rcjs.createDateOutputTransform; exports.createDefaultDatePickerConfig = _chunkOT7COE7Rcjs.createDefaultDatePickerConfig; exports.createStableKey = _chunkOT7COE7Rcjs.createStableKey; exports.extractErrorMessage = _chunkOT7COE7Rcjs.extractErrorMessage; exports.isParsableDateString = _chunkOT7COE7Rcjs.isParsableDateString; exports.isValidDate = _chunkOT7COE7Rcjs.isValidDate; exports.readDatePickerValueAsDate = _chunkOT7COE7Rcjs.readDatePickerValueAsDate; exports.useDatePickerStyles = _chunkOT7COE7Rcjs.useDatePickerStyles; exports.useDatePickerValidation = _chunkOT7COE7Rcjs.useDatePickerValidation; exports.useDatePickerValue = _chunkOT7COE7Rcjs.useDatePickerValue;
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJzb3VyY2VzIjpbImQ6XFxQcm9qZWN0c1xcZ253ZWItbW9ub3JlcG9cXHBhY2thZ2VzXFx1aVxcZGlzdFxcd3JhcHBlcnNcXGluZGV4LmNqcyJdLCJuYW1lcyI6W10sIm1hcHBpbmdzIjoiQUFBQTtBQUNFO0FBQ0E7QUFDQTtBQUNBO0FBQ0E7QUFDQTtBQUNBO0FBQ0E7QUFDQTtBQUNBO0FBQ0E7QUFDQTtBQUNBO0FBQ0E7QUFDQTtBQUNBO0FBQ0E7QUFDQTtBQUNBO0FBQ0E7QUFDQTtBQUNBO0FBQ0E7QUFDQTtBQUNGLHlEQUE4QjtBQUM5QixpQ0FBOEI7QUFDOUI7QUFDRTtBQUNBO0FBQ0E7QUFDQTtBQUNBO0FBQ0E7QUFDQTtBQUNBO0FBQ0E7QUFDQTtBQUNBO0FBQ0E7QUFDQTtBQUNBO0FBQ0E7QUFDQTtBQUNBO0FBQ0E7QUFDQTtBQUNBO0FBQ0E7QUFDQTtBQUNBO0FBQ0E7QUFDRixtcURBQUMiLCJmaWxlIjoiRDpcXFByb2plY3RzXFxnbndlYi1tb25vcmVwb1xccGFja2FnZXNcXHVpXFxkaXN0XFx3cmFwcGVyc1xcaW5kZXguY2pzIn0=