@neurodyn/ai-try-on 0.1.2 → 0.2.0

package/dist/ai-try-on.js

@@ -1,4 +1,4 @@
-import { AiTryOnDialog, PRODUCT_TYPES, isProductType } from "@neurodyn/react-ai-try-on";
+import { AiTryOnDialog, PRODUCT_TYPES } from "@neurodyn/react-ai-try-on";
 import { createElement } from "react";
 import { createRoot } from "react-dom/client";
 const DIALOG_ROOT_ID_PREFIX = 'neurodyn-ai-try-on-dialog-root';
@@ -43,54 +43,177 @@ class AiTryOnDialogRenderer {
         }));
     }
 }
-const AI_TRY_ON_TRIGGER_ATTRIBUTE = 'data-neurodyn-ai-try-on-dialog';
-const AI_TRY_ON_TRIGGER_SELECTOR = `[${AI_TRY_ON_TRIGGER_ATTRIBUTE}]`;
-const AI_TRY_ON_LANGUAGE_ATTRIBUTE = 'data-neurodyn-ai-try-on-language';
-const AI_TRY_ON_PRODUCT_IMAGE_SRC_ATTRIBUTE = 'data-neurodyn-ai-try-on-product-image-src';
-const AI_TRY_ON_PRODUCT_NAME_ATTRIBUTE = 'data-neurodyn-ai-try-on-product-name';
-const AI_TRY_ON_PRODUCT_PRICE_ATTRIBUTE = 'data-neurodyn-ai-try-on-product-price';
-const AI_TRY_ON_PRODUCT_URL_ATTRIBUTE = 'data-neurodyn-ai-try-on-product-url';
-const AI_TRY_ON_PRODUCT_TYPE_ATTRIBUTE = 'data-neurodyn-ai-try-on-product-type';
-const AI_TRY_ON_API_KEY_ATTRIBUTE = 'data-neurodyn-ai-try-on-api-key';
-function readTriggerProps(trigger, props = {}) {
+function contract_attribute(name, parser, details) {
+    return {
+        kind: 'attribute',
+        name,
+        parse: parser.parse,
+        values: parser.values,
+        ...details
+    };
+}
+function optionOnly(reason) {
     return {
-        language: void 0 !== props.language ? props.language : readLanguageAttribute(trigger, AI_TRY_ON_LANGUAGE_ATTRIBUTE),
-        productImageSrc: void 0 !== props.productImageSrc ? props.productImageSrc : readRequiredAttribute(trigger, AI_TRY_ON_PRODUCT_IMAGE_SRC_ATTRIBUTE),
-        productName: void 0 !== props.productName ? props.productName : readRequiredAttribute(trigger, AI_TRY_ON_PRODUCT_NAME_ATTRIBUTE),
-        productPrice: void 0 !== props.productPrice ? normalizeOptionalValue(props.productPrice) : readOptionalAttribute(trigger, AI_TRY_ON_PRODUCT_PRICE_ATTRIBUTE),
-        productUrl: void 0 !== props.productUrl ? props.productUrl : readOptionalAttribute(trigger, AI_TRY_ON_PRODUCT_URL_ATTRIBUTE),
-        productType: readProductType(void 0 !== props.productType ? props.productType : trigger.getAttribute(AI_TRY_ON_PRODUCT_TYPE_ATTRIBUTE)),
-        apiKey: normalizeApiKey(void 0 !== props.apiKey ? props.apiKey : trigger.getAttribute(AI_TRY_ON_API_KEY_ATTRIBUTE))
+        kind: 'option',
+        reason
     };
 }
-function readProductType(value) {
-    if (!isProductType(value)) {
-        const received = 'string' == typeof value && value.length > 0 ? ` "${value}"` : '';
-        throw new Error(`AI try-on product type from ${AI_TRY_ON_PRODUCT_TYPE_ATTRIBUTE} must be one of: ${PRODUCT_TYPES.join(', ')}; received${received || ' no value'}`);
+function defineTriggerContract() {
+    return (contract)=>contract;
+}
+function contract_attributeEntries(contract) {
+    return Object.entries(contract.fields).filter((entry)=>'attribute' === entry[1].kind);
+}
+function attributeName(contract, key) {
+    const field = contract.fields[key];
+    return `${contract.prefix}${field.name}`;
+}
+function triggerSelector(contract) {
+    return `[${contract.markers[0].name}]`;
+}
+function readRawAttribute(trigger, name, legacyNames = []) {
+    const value = trigger.getAttribute(name);
+    if (0 === legacyNames.length || value?.trim()) return value;
+    for (const legacyName of legacyNames){
+        const legacyValue = trigger.getAttribute(legacyName);
+        if (legacyValue?.trim()) return legacyValue;
     }
     return value;
 }
-function readLanguageAttribute(trigger, name) {
-    const value = trigger.getAttribute(name);
-    return 'en' === value || 'ru' === value ? value : void 0;
+function readTriggerAttributes(trigger, contract, options = {}) {
+    const values = {};
+    for (const [key, field] of contract_attributeEntries(contract)){
+        const name = `${contract.prefix}${field.name}`;
+        const option = options[key];
+        if (void 0 !== option) {
+            values[key] = field.normalizesOptions ? field.parse(option, {
+                attribute: name
+            }) : option;
+            continue;
+        }
+        values[key] = field.parse(readRawAttribute(trigger, name, field.legacyNames), {
+            attribute: name
+        });
+    }
+    return values;
 }
-function readOptionalAttribute(trigger, name) {
-    const value = trigger.getAttribute(name);
-    return normalizeOptionalValue(value);
+function trimmedText() {
+    return {
+        parse: (raw)=>raw?.trim() || void 0
+    };
 }
-function normalizeApiKey(value) {
-    const apiKey = value?.trim();
-    return apiKey || void 0;
+function requiredText(missing) {
+    return {
+        parse: (raw, { attribute })=>{
+            const value = raw?.trim();
+            if (!value) throw missing(attribute);
+            return value;
+        }
+    };
 }
-function normalizeOptionalValue(value) {
-    const normalized = value?.trim();
-    return normalized || void 0;
+function oneOf(values) {
+    return {
+        parse: (raw)=>values.includes(raw ?? '') ? raw : void 0,
+        values
+    };
 }
-function readRequiredAttribute(trigger, name) {
-    const value = readOptionalAttribute(trigger, name);
-    if (!value) throw new Error(`AI try-on dialog trigger is missing ${name}`);
-    return value;
+function custom(parse, values) {
+    return {
+        parse,
+        values
+    };
+}
+function listOf() {
+    return (values)=>values;
+}
+const AI_TRY_ON_PRODUCT_TYPES = listOf()([
+    'full-body',
+    'upper-body',
+    'lower-body',
+    'footwear',
+    'headwear',
+    'eyewear',
+    'neck',
+    'wrist',
+    'bag',
+    'waist'
+]);
+const AI_TRY_ON_LANGUAGES = listOf()([
+    'en',
+    'ru'
+]);
+function isProductType(value) {
+    return 'string' == typeof value && AI_TRY_ON_PRODUCT_TYPES.includes(value);
+}
+const EXTERNAL_ONLY = 'External integrations only, such as the Shopify block.';
+const aiTryOnContract = defineTriggerContract()({
+    prefix: 'data-neurodyn-ai-try-on-',
+    markers: [
+        {
+            name: 'data-neurodyn-ai-try-on-dialog',
+            description: 'Marks a dialog trigger for the embed build.'
+        }
+    ],
+    fields: {
+        productType: contract_attribute('product-type', custom((value, { attribute })=>{
+            if (!isProductType(value)) {
+                const received = 'string' == typeof value && value.length > 0 ? ` "${value}"` : '';
+                throw new Error(`AI try-on product type from ${attribute} must be one of: ${AI_TRY_ON_PRODUCT_TYPES.join(', ')}; received${received || ' no value'}`);
+            }
+            return value;
+        }, AI_TRY_ON_PRODUCT_TYPES), {
+            required: true,
+            normalizesOptions: true,
+            description: 'Product category.'
+        }),
+        productName: contract_attribute('product-name', requiredText((name)=>new Error(`AI try-on dialog trigger is missing ${name}`)), {
+            required: true,
+            description: 'Product name shown in the dialog.'
+        }),
+        productImageSrc: contract_attribute('product-image-src', requiredText((name)=>new Error(`AI try-on dialog trigger is missing ${name}`)), {
+            required: true,
+            description: 'Product image URL.'
+        }),
+        productPrice: contract_attribute('product-price', trimmedText(), {
+            required: false,
+            normalizesOptions: true,
+            description: 'Already-formatted product price.'
+        }),
+        productUrl: contract_attribute('product-url', trimmedText(), {
+            required: false,
+            description: 'Product page URL opened from the result.'
+        }),
+        language: contract_attribute('language', oneOf(AI_TRY_ON_LANGUAGES), {
+            required: false,
+            defaultValue: 'Browser language',
+            description: 'UI language override.'
+        }),
+        apiKey: contract_attribute('api-key', trimmedText(), {
+            required: true,
+            normalizesOptions: true,
+            description: 'Public API key.'
+        }),
+        open: optionOnly('The embed build owns the open state.'),
+        defaultOpen: optionOnly('The embed build owns the open state.'),
+        onOpenChange: optionOnly('The embed build owns the open state.'),
+        externalGeneration: optionOnly(EXTERNAL_ONLY),
+        externalActivation: optionOnly(EXTERNAL_ONLY),
+        externalClient: optionOnly(EXTERNAL_ONLY),
+        externalAddToCart: optionOnly(EXTERNAL_ONLY)
+    }
+});
+function readTriggerProps(trigger, props = {}) {
+    return readTriggerAttributes(trigger, aiTryOnContract, props);
 }
+const AI_TRY_ON_TRIGGER_ATTRIBUTE = aiTryOnContract.markers["0"].name;
+const AI_TRY_ON_TRIGGER_SELECTOR = triggerSelector(aiTryOnContract);
+const AI_TRY_ON_LANGUAGE_ATTRIBUTE = attributeName(aiTryOnContract, 'language');
+const AI_TRY_ON_PRODUCT_IMAGE_SRC_ATTRIBUTE = attributeName(aiTryOnContract, 'productImageSrc');
+const AI_TRY_ON_PRODUCT_NAME_ATTRIBUTE = attributeName(aiTryOnContract, 'productName');
+const AI_TRY_ON_PRODUCT_PRICE_ATTRIBUTE = attributeName(aiTryOnContract, 'productPrice');
+const AI_TRY_ON_PRODUCT_URL_ATTRIBUTE = attributeName(aiTryOnContract, 'productUrl');
+const AI_TRY_ON_PRODUCT_TYPE_ATTRIBUTE = attributeName(aiTryOnContract, 'productType');
+attributeName(aiTryOnContract, 'apiKey');
 class src_AiTryOnDialog {
     destroyed = false;
     props;

package/dist/contract.d.ts

@@ -0,0 +1,154 @@
+import type { AiTryOnDialog } from '@neurodyn/react-ai-try-on';
+import type { ComponentProps } from 'react';
+
+export declare const AI_TRY_ON_EMBED_SCRIPT_URL = "https://cdn.neurodyn.ai/@neurodyn/ai-try-on/dist/ai-try-on.embed.min.js";
+
+export declare const AI_TRY_ON_LANGUAGES: readonly ["en", "ru"];
+
+export declare const AI_TRY_ON_PRODUCT_TYPES: readonly ["full-body", "upper-body", "lower-body", "footwear", "headwear", "eyewear", "neck", "wrist", "bag", "waist"];
+
+/** The eyewear trigger the docs show as an example. */
+export declare const AI_TRY_ON_TRIGGER_EXAMPLE: {
+    readonly productType: "eyewear";
+    readonly productName: "Sample Glasses";
+    readonly productImageSrc: "https://example.com/products/glasses.jpg";
+    readonly apiKey: "...";
+};
+
+export declare const aiTryOnContract: TriggerContract<AiTryOnTriggerDialogProps, {
+readonly productType: TriggerAttribute<"full-body" | "upper-body" | "lower-body" | "footwear" | "headwear" | "eyewear" | "neck" | "wrist" | "bag" | "waist">;
+readonly productName: TriggerAttribute<string>;
+readonly productImageSrc: TriggerAttribute<string>;
+readonly productPrice: TriggerAttribute<string | undefined>;
+readonly productUrl: TriggerAttribute<string | undefined>;
+readonly language: TriggerAttribute<"en" | "ru" | undefined>;
+readonly apiKey: TriggerAttribute<string | undefined>;
+readonly open: OptionOnly;
+readonly defaultOpen: OptionOnly;
+readonly onOpenChange: OptionOnly;
+readonly externalGeneration: OptionOnly;
+readonly externalActivation: OptionOnly;
+readonly externalClient: OptionOnly;
+readonly externalAddToCart: OptionOnly;
+}>;
+
+/**
+ * The React dialog's props in ordinary mode, which is what the trigger
+ * renders. External mode (the Shopify block) has a contract of its own.
+ */
+export declare interface AiTryOnTriggerDialogProps extends Extract<ComponentProps<typeof AiTryOnDialog>, {
+    externalGeneration?: never;
+}> {
+}
+
+export declare type AiTryOnTriggerRow = TriggerSnippetRow<keyof AiTryOnTriggerValues>;
+
+export declare type AiTryOnTriggerValues = TriggerSnippetValues<typeof aiTryOnContract.fields>;
+
+/** What the reader hands a parser besides the raw value. */
+declare interface AttributeParseContext {
+    /** Full attribute name, e.g. `data-neurodyn-room-viewer-api-key`. */
+    attribute: string
+}
+
+/**
+ * Whether an attribute must be set: always, never, or only while another
+ * attribute holds one of the listed values (`src` while `type` is `wallart`).
+ * `when` names a field of the same contract.
+ */
+declare type AttributeRequirement
+= | boolean
+| { readonly when: string, readonly is: readonly string[] }
+
+/** A copy-paste trigger button with the given attributes, in contract order and escaped. */
+export declare function buildAiTryOnTrigger(values: AiTryOnTriggerValues, options: TriggerSnippetOptions): string;
+
+/** The tag that loads the self-initializing embed build from `src`. */
+export declare function buildEmbedScript(src: string): string;
+
+/**
+ * The rows describing a trigger built from the same values, for the table
+ * beside the snippet; `extra` adds attributes the snippet leaves out.
+ */
+export declare function describeAiTryOnTrigger(values: AiTryOnTriggerValues, extra?: readonly (keyof AiTryOnTriggerValues)[]): AiTryOnTriggerRow[];
+
+/** A widget option that has no attribute: callbacks, controlled state, sessions. */
+declare interface OptionOnly {
+    readonly kind: 'option'
+    /** Why the option is programmatic only. */
+    readonly reason: string
+}
+
+/** What an attribute's parser produces. */
+declare type ParsedAttributeValue<Field> = Field extends TriggerAttribute<infer Value> ? Value : never
+
+/** A widget option a merchant can set with a `data-*` attribute on the trigger. */
+declare interface TriggerAttribute<Value> {
+    readonly kind: 'attribute'
+    /** Attribute name without the widget prefix, e.g. `api-key`. */
+    readonly name: string
+    readonly parse: (raw: string | null, context: AttributeParseContext) => Value
+    /** The accepted values, listed in the docs. */
+    readonly values?: readonly string[]
+    /** What the docs and the cabinets' snippets ask for; the reader does not enforce it. */
+    readonly required: AttributeRequirement
+    /** The default as Markdown for the docs, e.g. `` `cm` `` or `User locale`. */
+    readonly defaultValue?: string
+    /** One or two sentences for the docs; accepted values are appended from `values`. */
+    readonly description: string
+    /** Full attribute names read, in order, while the primary one is absent or blank. */
+    readonly legacyNames?: readonly string[]
+    /** Runs an explicitly passed programmatic option through `parse` as well. */
+    readonly normalizesOptions?: boolean
+}
+
+/** Keys of the fields that are attributes. */
+declare type TriggerAttributeKey<Fields> = {
+    [Key in keyof Fields]: Fields[Key] extends TriggerAttribute<any> ? Key : never
+}[keyof Fields] & string
+
+declare interface TriggerContract<Options, Fields extends TriggerFields<Options> = TriggerFields<Options>> {
+    /** Prefix shared by the widget's option attributes, e.g. `data-neurodyn-room-viewer-`. */
+    readonly prefix: string
+    /** The first marker is the one snippets use. */
+    readonly markers: readonly [TriggerMarker, ...TriggerMarker[]]
+    readonly fields: Fields
+}
+
+/**
+ * One entry per widget option, none optional: an option added to the widget's
+ * props without an entry here fails type-checking until it is given an
+ * attribute or marked option-only.
+ */
+declare type TriggerFields<Options> = {
+    readonly [Key in keyof Options]-?: TriggerAttribute<Options[Key] | undefined> | OptionOnly
+}
+
+/** A marker attribute that selects trigger elements, e.g. `data-neurodyn-room-viewer-dialog`. */
+declare interface TriggerMarker {
+    readonly name: string
+    readonly description: string
+}
+
+export declare interface TriggerSnippetOptions {
+    /** The button text. */
+    label: string
+}
+
+/** One attribute of a snippet, for the table next to it. */
+declare interface TriggerSnippetRow<Key extends string> {
+    /** The field key, or `null` for the marker attribute. */
+    key: Key | null
+    attribute: string
+    required: boolean
+}
+
+/**
+ * Values for a copy-paste trigger: only the contract's attributes, each typed
+ * as its option. Placeholders such as `PUBLIC_WIDGET_KEY` fit string options.
+ */
+declare type TriggerSnippetValues<Fields> = {
+    [Key in TriggerAttributeKey<Fields>]?: Exclude<ParsedAttributeValue<Fields[Key]>, undefined | null>
+}
+
+export { }

package/dist/contract.js

@@ -0,0 +1,195 @@
+function contract_attribute(name, parser, details) {
+    return {
+        kind: 'attribute',
+        name,
+        parse: parser.parse,
+        values: parser.values,
+        ...details
+    };
+}
+function optionOnly(reason) {
+    return {
+        kind: 'option',
+        reason
+    };
+}
+function defineTriggerContract() {
+    return (contract)=>contract;
+}
+function contract_attributeEntries(contract) {
+    return Object.entries(contract.fields).filter((entry)=>'attribute' === entry[1].kind);
+}
+function escapeHtml(value) {
+    return value.replaceAll('&', '&amp;').replaceAll('"', '&quot;').replaceAll('<', '&lt;').replaceAll('>', '&gt;');
+}
+function isAttributeRequired(requirement, values) {
+    if ('boolean' == typeof requirement) return requirement;
+    const current = values[requirement.when];
+    return null != current && requirement.is.includes(String(current));
+}
+function snippetEntries(contract, values) {
+    return contract_attributeEntries(contract).flatMap(([key, field])=>{
+        const value = values[key];
+        return null == value ? [] : [
+            {
+                key,
+                field,
+                value
+            }
+        ];
+    });
+}
+function snippet_buildTriggerSnippet(contract, values, { label }) {
+    const lines = [
+        '<button',
+        '  type="button"',
+        `  ${contract.markers[0].name}`
+    ];
+    for (const { field, value } of snippetEntries(contract, values))lines.push(`  ${contract.prefix}${field.name}="${escapeHtml(String(value))}"`);
+    lines.push('>', `  ${escapeHtml(label)}`, '</button>');
+    return lines.join('\n');
+}
+function describeTriggerSnippet(contract, values, extra = []) {
+    const present = snippetEntries(contract, values);
+    const presentKeys = new Set(present.map(({ key })=>key));
+    const fields = contract.fields;
+    const row = (key, field)=>({
+            key,
+            attribute: `${contract.prefix}${field.name}`,
+            required: isAttributeRequired(field.required, values)
+        });
+    return [
+        {
+            key: null,
+            attribute: contract.markers[0].name,
+            required: true
+        },
+        ...present.map(({ key, field })=>row(key, field)),
+        ...extra.filter((key)=>!presentKeys.has(key)).map((key)=>row(key, fields[key]))
+    ];
+}
+function snippet_buildEmbedScript(src) {
+    return `<script defer src="${escapeHtml(src)}"></script>`;
+}
+function trimmedText() {
+    return {
+        parse: (raw)=>raw?.trim() || void 0
+    };
+}
+function requiredText(missing) {
+    return {
+        parse: (raw, { attribute })=>{
+            const value = raw?.trim();
+            if (!value) throw missing(attribute);
+            return value;
+        }
+    };
+}
+function oneOf(values) {
+    return {
+        parse: (raw)=>values.includes(raw ?? '') ? raw : void 0,
+        values
+    };
+}
+function custom(parse, values) {
+    return {
+        parse,
+        values
+    };
+}
+function listOf() {
+    return (values)=>values;
+}
+const AI_TRY_ON_PRODUCT_TYPES = listOf()([
+    'full-body',
+    'upper-body',
+    'lower-body',
+    'footwear',
+    'headwear',
+    'eyewear',
+    'neck',
+    'wrist',
+    'bag',
+    'waist'
+]);
+const AI_TRY_ON_LANGUAGES = listOf()([
+    'en',
+    'ru'
+]);
+const AI_TRY_ON_EMBED_SCRIPT_URL = 'https://cdn.neurodyn.ai/@neurodyn/ai-try-on/dist/ai-try-on.embed.min.js';
+function isProductType(value) {
+    return 'string' == typeof value && AI_TRY_ON_PRODUCT_TYPES.includes(value);
+}
+const EXTERNAL_ONLY = 'External integrations only, such as the Shopify block.';
+const aiTryOnContract = defineTriggerContract()({
+    prefix: 'data-neurodyn-ai-try-on-',
+    markers: [
+        {
+            name: 'data-neurodyn-ai-try-on-dialog',
+            description: 'Marks a dialog trigger for the embed build.'
+        }
+    ],
+    fields: {
+        productType: contract_attribute('product-type', custom((value, { attribute })=>{
+            if (!isProductType(value)) {
+                const received = 'string' == typeof value && value.length > 0 ? ` "${value}"` : '';
+                throw new Error(`AI try-on product type from ${attribute} must be one of: ${AI_TRY_ON_PRODUCT_TYPES.join(', ')}; received${received || ' no value'}`);
+            }
+            return value;
+        }, AI_TRY_ON_PRODUCT_TYPES), {
+            required: true,
+            normalizesOptions: true,
+            description: 'Product category.'
+        }),
+        productName: contract_attribute('product-name', requiredText((name)=>new Error(`AI try-on dialog trigger is missing ${name}`)), {
+            required: true,
+            description: 'Product name shown in the dialog.'
+        }),
+        productImageSrc: contract_attribute('product-image-src', requiredText((name)=>new Error(`AI try-on dialog trigger is missing ${name}`)), {
+            required: true,
+            description: 'Product image URL.'
+        }),
+        productPrice: contract_attribute('product-price', trimmedText(), {
+            required: false,
+            normalizesOptions: true,
+            description: 'Already-formatted product price.'
+        }),
+        productUrl: contract_attribute('product-url', trimmedText(), {
+            required: false,
+            description: 'Product page URL opened from the result.'
+        }),
+        language: contract_attribute('language', oneOf(AI_TRY_ON_LANGUAGES), {
+            required: false,
+            defaultValue: 'Browser language',
+            description: 'UI language override.'
+        }),
+        apiKey: contract_attribute('api-key', trimmedText(), {
+            required: true,
+            normalizesOptions: true,
+            description: 'Public API key.'
+        }),
+        open: optionOnly('The embed build owns the open state.'),
+        defaultOpen: optionOnly('The embed build owns the open state.'),
+        onOpenChange: optionOnly('The embed build owns the open state.'),
+        externalGeneration: optionOnly(EXTERNAL_ONLY),
+        externalActivation: optionOnly(EXTERNAL_ONLY),
+        externalClient: optionOnly(EXTERNAL_ONLY),
+        externalAddToCart: optionOnly(EXTERNAL_ONLY)
+    }
+});
+const AI_TRY_ON_TRIGGER_EXAMPLE = {
+    productType: 'eyewear',
+    productName: 'Sample Glasses',
+    productImageSrc: 'https://example.com/products/glasses.jpg',
+    apiKey: '...'
+};
+function buildAiTryOnTrigger(values, options) {
+    return snippet_buildTriggerSnippet(aiTryOnContract, values, options);
+}
+function describeAiTryOnTrigger(values, extra = []) {
+    return describeTriggerSnippet(aiTryOnContract, values, extra);
+}
+function contract_buildEmbedScript(src) {
+    return snippet_buildEmbedScript(src);
+}
+export { AI_TRY_ON_EMBED_SCRIPT_URL, AI_TRY_ON_LANGUAGES, AI_TRY_ON_PRODUCT_TYPES, AI_TRY_ON_TRIGGER_EXAMPLE, aiTryOnContract, buildAiTryOnTrigger, contract_buildEmbedScript as buildEmbedScript, describeAiTryOnTrigger };

package/dist/index.d.ts

@@ -1,22 +1,22 @@
 import { PRODUCT_TYPES } from '@neurodyn/react-ai-try-on';
 import { ProductType } from '@neurodyn/react-ai-try-on';
 
-export declare const AI_TRY_ON_LANGUAGE_ATTRIBUTE = "data-neurodyn-ai-try-on-language";
+export declare const AI_TRY_ON_LANGUAGE_ATTRIBUTE: string;
 
-export declare const AI_TRY_ON_PRODUCT_IMAGE_SRC_ATTRIBUTE = "data-neurodyn-ai-try-on-product-image-src";
+export declare const AI_TRY_ON_PRODUCT_IMAGE_SRC_ATTRIBUTE: string;
 
-export declare const AI_TRY_ON_PRODUCT_NAME_ATTRIBUTE = "data-neurodyn-ai-try-on-product-name";
+export declare const AI_TRY_ON_PRODUCT_NAME_ATTRIBUTE: string;
 
-export declare const AI_TRY_ON_PRODUCT_PRICE_ATTRIBUTE = "data-neurodyn-ai-try-on-product-price";
+export declare const AI_TRY_ON_PRODUCT_PRICE_ATTRIBUTE: string;
 
 /** Canonical Product Type driving per-type generation. */
-export declare const AI_TRY_ON_PRODUCT_TYPE_ATTRIBUTE = "data-neurodyn-ai-try-on-product-type";
+export declare const AI_TRY_ON_PRODUCT_TYPE_ATTRIBUTE: string;
 
-export declare const AI_TRY_ON_PRODUCT_URL_ATTRIBUTE = "data-neurodyn-ai-try-on-product-url";
+export declare const AI_TRY_ON_PRODUCT_URL_ATTRIBUTE: string;
 
-export declare const AI_TRY_ON_TRIGGER_ATTRIBUTE = "data-neurodyn-ai-try-on-dialog";
+export declare const AI_TRY_ON_TRIGGER_ATTRIBUTE: string;
 
-export declare const AI_TRY_ON_TRIGGER_SELECTOR = "[data-neurodyn-ai-try-on-dialog]";
+export declare const AI_TRY_ON_TRIGGER_SELECTOR: string;
 
 export declare class AiTryOnDialog {
     private destroyed;