@propeller-commerce/propeller-sdk-v2 0.11.1

package/dist/cjs/util/getLocalized.d.ts

@@ -0,0 +1,17 @@
+import type { LocalizedString } from '../type/LocalizedString';
+/**
+ * Pick the value for `lang` out of a `LocalizedString[]`, falling back to
+ * `fallback` (if provided) and finally to the first entry's value.
+ *
+ * Replaces the per-class `getName('NL')` / `getDescription('NL')` etc. methods
+ * generated through v0.9.x. Use this with a single import and any localized
+ * field on any response:
+ *
+ *   import { getLocalized } from 'propeller-sdk-v2';
+ *
+ *   const name = getLocalized(product.names, 'EN', 'NL');
+ *   const desc = getLocalized(product.descriptions, locale);
+ *
+ * Returns `undefined` only when the input array is empty/missing.
+ */
+export declare function getLocalized(values: LocalizedString[] | undefined, lang: string, fallback?: string): string | undefined;

package/dist/cjs/util/getLocalized.js

@@ -0,0 +1,31 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.getLocalized = getLocalized;
+/**
+ * Pick the value for `lang` out of a `LocalizedString[]`, falling back to
+ * `fallback` (if provided) and finally to the first entry's value.
+ *
+ * Replaces the per-class `getName('NL')` / `getDescription('NL')` etc. methods
+ * generated through v0.9.x. Use this with a single import and any localized
+ * field on any response:
+ *
+ *   import { getLocalized } from 'propeller-sdk-v2';
+ *
+ *   const name = getLocalized(product.names, 'EN', 'NL');
+ *   const desc = getLocalized(product.descriptions, locale);
+ *
+ * Returns `undefined` only when the input array is empty/missing.
+ */
+function getLocalized(values, lang, fallback) {
+    if (!values || values.length === 0)
+        return undefined;
+    const direct = values.find((v) => v.language === lang)?.value;
+    if (direct !== undefined)
+        return direct;
+    if (fallback) {
+        const fb = values.find((v) => v.language === fallback)?.value;
+        if (fb !== undefined)
+            return fb;
+    }
+    return values[0]?.value;
+}

package/dist/cjs/util/index.d.ts

@@ -0,0 +1 @@
+export { getLocalized } from './getLocalized';

package/dist/cjs/util/index.js

@@ -0,0 +1,5 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.getLocalized = void 0;
+var getLocalized_1 = require("./getLocalized");
+Object.defineProperty(exports, "getLocalized", { enumerable: true, get: function () { return getLocalized_1.getLocalized; } });

package/dist/esm/client/GraphQLClient.js

@@ -0,0 +1,406 @@
+// Note: This client uses the built-in fetch API available in Node.js 18+.
+// For older runtimes, install a fetch polyfill.
+import { GraphQLOperationError } from './GraphQLOperationError.js';
+const DEFAULT_TOKEN_STORAGE_KEY = 'access_token';
+const DEFAULT_ORDER_EDITOR_MUTATIONS = [
+    'orderSetStatus',
+    'passwordResetLink',
+    'triggerQuoteSendRequest',
+    'triggerOrderSendConfirm',
+];
+function defaultAccessTokenProvider() {
+    if (typeof window !== 'undefined' && window.localStorage) {
+        return window.localStorage.getItem(DEFAULT_TOKEN_STORAGE_KEY) || undefined;
+    }
+    return undefined;
+}
+/**
+ * A GraphQL client for the Propeller eCommerce Platform.
+ *
+ * Features:
+ *   - Per-operation imports — services bring their own GraphQL documents.
+ *   - Secure proxy mode to keep API keys server-side.
+ *   - API key routing for order-editor mutations in direct mode.
+ *   - Configurable access token provider for SSR / custom storage.
+ *   - TypeScript support with full type safety.
+ *
+ * SECURITY: Use 'proxy' mode in production to keep API keys server-side.
+ */
+export class GraphQLClient {
+    /**
+     * @param config - Client configuration
+     */
+    constructor(config) {
+        this.queries = new Map();
+        this.mutations = new Map();
+        this.fragmentOverrides = new Map();
+        this.config = {
+            timeout: 30000,
+            securityMode: 'proxy',
+            ...config,
+        };
+        this.orderEditorMutationSet = new Set(this.config.orderEditorMutations ?? DEFAULT_ORDER_EDITOR_MUTATIONS);
+        this.warnOnInconsistentConfig();
+        this.debugLog('=== Initialization ===');
+    }
+    warnOnInconsistentConfig() {
+        if (this.config.securityMode === 'proxy') {
+            if (this.config.apiKey || this.config.orderEditorApiKey) {
+                // eslint-disable-next-line no-console
+                console.warn('[propeller-sdk-v2] securityMode is "proxy" but `apiKey` or `orderEditorApiKey` was supplied. ' +
+                    'These keys are ignored in proxy mode — keep them server-side, in your proxy function.');
+            }
+        }
+        else if (this.config.securityMode === 'direct') {
+            if (!this.config.apiKey) {
+                // eslint-disable-next-line no-console
+                console.warn('[propeller-sdk-v2] securityMode is "direct" but no `apiKey` was supplied. ' +
+                    'Requests will be sent without an API key header.');
+            }
+        }
+    }
+    debugLog(...args) {
+        if (this.config.debug) {
+            // eslint-disable-next-line no-console
+            console.log('[GraphQL Client]', ...args);
+        }
+    }
+    /**
+     * Register a GraphQL fragment by name. Fragments are inlined at build time
+     * into service operations; this registration is used by ad-hoc callers who
+     * compose documents themselves via `execute()`.
+     */
+    registerFragment(name, definition) {
+        this.fragmentOverrides.set(name, definition);
+    }
+    /** Register a custom query string under a name for use with `queryByName`. */
+    registerQuery(name, definition) {
+        this.queries.set(name, definition);
+    }
+    /** Register a custom mutation string under a name for use with `mutateByName`. */
+    registerMutation(name, definition) {
+        this.mutations.set(name, definition);
+    }
+    /** Look up a registered fragment by name. */
+    getFragment(name) {
+        return this.fragmentOverrides.get(name);
+    }
+    /** Look up a registered query by name. */
+    getQuery(name) {
+        return this.queries.get(name);
+    }
+    /** Look up a registered mutation by name. */
+    getMutation(name) {
+        return this.mutations.get(name);
+    }
+    /** Names of all registered fragments. */
+    getFragmentNames() {
+        return Array.from(this.fragmentOverrides.keys());
+    }
+    /** Names of all registered queries. */
+    getQueryNames() {
+        return Array.from(this.queries.keys());
+    }
+    /** Names of all registered mutations. */
+    getMutationNames() {
+        return Array.from(this.mutations.keys());
+    }
+    /** Configured default language tag (ISO 639-1), or undefined if not set. */
+    getDefaultLanguage() {
+        return this.config.defaultLanguage;
+    }
+    /**
+     * Determine which API key to use based on the operation (direct mode only).
+     */
+    getApiKey(operationName) {
+        if (this.config.securityMode === 'proxy') {
+            return undefined;
+        }
+        if (operationName && this.orderEditorMutationSet.has(operationName)) {
+            return this.config.orderEditorApiKey;
+        }
+        return this.config.apiKey;
+    }
+    /**
+     * Build request headers for a GraphQL operation.
+     */
+    async buildHeaders(operationName) {
+        const headers = {
+            'Content-Type': 'application/json',
+            ...this.config.headers,
+        };
+        if (this.config.securityMode === 'proxy') {
+            if (this.config.clientId) {
+                headers['X-Client-ID'] = this.config.clientId;
+            }
+            const provider = this.config.getAccessToken ?? defaultAccessTokenProvider;
+            const token = await provider();
+            if (token) {
+                headers['Authorization'] = `Bearer ${token}`;
+            }
+        }
+        else {
+            const apiKey = this.getApiKey(operationName);
+            if (apiKey) {
+                headers['apikey'] = `${apiKey}`;
+            }
+        }
+        return headers;
+    }
+    /**
+     * Get the appropriate endpoint for the current security mode.
+     */
+    getEndpoint() {
+        if (this.config.securityMode === 'proxy') {
+            return this.config.proxyEndpoint || this.config.endpoint;
+        }
+        return this.config.endpoint;
+    }
+    /**
+     * Extract an operation name from a GraphQL document.
+     *
+     * Strips leading `#` comments and whitespace, then matches the first
+     * `query NAME` or `mutation NAME` form. Returns undefined for anonymous
+     * operations like `query { ... }`.
+     */
+    extractOperationName(query) {
+        const stripped = query.replace(/^\s*(#[^\n]*\n)+/g, '').trimStart();
+        const match = stripped.match(/^(?:query|mutation)\s+(\w+)/);
+        return match ? match[1] : undefined;
+    }
+    /**
+     * Execute a GraphQL operation.
+     *
+     * Returns the raw `GraphQLResponse` (with `data` and/or `errors`). This is
+     * the low-level entry point; it does not throw on GraphQL errors so callers
+     * who want to inspect partial responses can do so. The higher-level
+     * `query()` / `mutate()` helpers and the `runOperation` helper used by
+     * services throw `GraphQLOperationError` when `errors` is non-empty.
+     */
+    async execute(operation) {
+        const { query, variables = {}, operationName, fetchOptions } = operation;
+        const actualOperationName = operationName || this.extractOperationName(query);
+        const headers = await this.buildHeaders(actualOperationName);
+        // The wire payload is `{query, variables, operationName}` only — DO NOT
+        // merge `fetchOptions` in. Transport-level hints (cache, tags) must not
+        // affect the request body, otherwise two callers passing different tags
+        // for the same logical operation would produce different cache entries.
+        const body = JSON.stringify({
+            query,
+            variables,
+            operationName: actualOperationName,
+        });
+        const controller = new AbortController();
+        const timeoutId = setTimeout(() => controller.abort(), this.config.timeout);
+        try {
+            const response = await fetch(this.getEndpoint(), {
+                method: 'POST',
+                headers,
+                body,
+                // Per-operation fetch hints. Extracted by named field (NOT spread) so
+                // a caller can't reach `method`/`body`/`headers`/`signal`.
+                cache: fetchOptions?.cache,
+                // `next` is a Next.js fetch extension, not in lib.dom RequestInit. The
+                // suppression is intentional — fail loud if lib.dom ever adds `next`.
+                // eslint-disable-next-line @typescript-eslint/ban-ts-comment
+                // @ts-expect-error — next is a host-framework hint, not standard fetch
+                next: fetchOptions?.next,
+                signal: controller.signal,
+            });
+            clearTimeout(timeoutId);
+            if (!response.ok) {
+                const bodyText = await response.text().catch(() => '');
+                const snippet = bodyText ? `: ${bodyText.slice(0, 500)}` : '';
+                throw new Error(`HTTP ${response.status} ${response.statusText}${snippet}`);
+            }
+            const result = await response.json();
+            return result;
+        }
+        catch (error) {
+            clearTimeout(timeoutId);
+            if (error instanceof Error) {
+                if (error.name === 'AbortError') {
+                    throw new Error(`GraphQL request timeout after ${this.config.timeout}ms`);
+                }
+                throw new Error(`GraphQL request failed: ${error.message}`);
+            }
+            throw error;
+        }
+    }
+    /**
+     * Execute a GraphQL query, throwing on errors and returning `data` directly.
+     */
+    async query(query, variables, operationName) {
+        const result = await this.execute({ query, variables, operationName });
+        if (result.errors && result.errors.length > 0) {
+            const hasData = result.data !== undefined && result.data !== null;
+            if (!hasData) {
+                throw new GraphQLOperationError(result.errors, operationName, variables, query);
+            }
+            this.debugLog(`Partial response for ${operationName ?? 'operation'} — returning data alongside ${result.errors.length} error(s)`);
+        }
+        return result.data;
+    }
+    /**
+     * Execute a GraphQL mutation, throwing on errors and returning `data` directly.
+     */
+    async mutate(mutation, variables, operationName) {
+        const result = await this.execute({ query: mutation, variables, operationName });
+        if (result.errors && result.errors.length > 0) {
+            const hasData = result.data !== undefined && result.data !== null;
+            if (!hasData) {
+                throw new GraphQLOperationError(result.errors, operationName, variables, mutation);
+            }
+            this.debugLog(`Partial response for ${operationName ?? 'operation'} — returning data alongside ${result.errors.length} error(s)`);
+        }
+        return result.data;
+    }
+    /**
+     * Execute a registered query by name.
+     * Only resolves queries registered via `registerQuery()` — bundled service
+     * operations are no longer preloaded into the client and should be invoked
+     * through the service factories (`productService(client).getProduct(...)`).
+     */
+    async queryByName(queryName, variables) {
+        const queryDefinition = this.queries.get(queryName);
+        if (!queryDefinition) {
+            throw new Error(`Query "${queryName}" not registered. ` +
+                `Use \`client.registerQuery('${queryName}', \`<query string>\`)\` before calling queryByName(), ` +
+                `or use the service factory instead.`);
+        }
+        return this.query(queryDefinition, variables, queryName);
+    }
+    /**
+     * Execute a registered mutation by name.
+     * Only resolves mutations registered via `registerMutation()` — see `queryByName`.
+     */
+    async mutateByName(mutationName, variables) {
+        const mutationDefinition = this.mutations.get(mutationName);
+        if (!mutationDefinition) {
+            throw new Error(`Mutation "${mutationName}" not registered. ` +
+                `Use \`client.registerMutation('${mutationName}', \`<mutation string>\`)\` before calling mutateByName(), ` +
+                `or use the service factory instead.`);
+        }
+        return this.mutate(mutationDefinition, variables, mutationName);
+    }
+    /**
+     * Update client configuration.
+     */
+    updateConfig(newConfig) {
+        this.config = { ...this.config, ...newConfig };
+        if (newConfig.orderEditorMutations) {
+            this.orderEditorMutationSet = new Set(newConfig.orderEditorMutations);
+        }
+    }
+    /**
+     * Get current client configuration (without sensitive data).
+     */
+    getConfig() {
+        const { apiKey, orderEditorApiKey, ...safeConfig } = this.config;
+        return safeConfig;
+    }
+    /** Get current security mode. */
+    getSecurityMode() {
+        return this.config.securityMode || 'proxy';
+    }
+    /** True iff the client is in secure proxy mode. */
+    isSecureMode() {
+        return this.config.securityMode === 'proxy';
+    }
+    /**
+     * Set access token for authentication.
+     *
+     * Writes to `localStorage['access_token']` in the browser. Only meaningful
+     * when using the default `getAccessToken` resolver — if a custom resolver
+     * is configured, this method does not affect what that resolver returns.
+     */
+    setAccessToken(token) {
+        if (this.config.getAccessToken) {
+            // eslint-disable-next-line no-console
+            console.warn('[propeller-sdk-v2] setAccessToken() was called but a custom `getAccessToken` ' +
+                'resolver is configured. This call writes localStorage["access_token"], which ' +
+                'your resolver does not read — the new token will NOT be used. Update your own ' +
+                'token store instead (the resolver is the source of truth).');
+        }
+        if (typeof window !== 'undefined' && window.localStorage) {
+            window.localStorage.setItem(DEFAULT_TOKEN_STORAGE_KEY, token);
+        }
+    }
+    /** Clear access token (logout). */
+    clearAccessToken() {
+        if (typeof window !== 'undefined' && window.localStorage) {
+            window.localStorage.removeItem(DEFAULT_TOKEN_STORAGE_KEY);
+        }
+    }
+    /**
+     * Get current access token using the configured provider.
+     * Returns undefined if no provider yields a token.
+     */
+    async getAccessToken() {
+        const provider = this.config.getAccessToken ?? defaultAccessTokenProvider;
+        return provider();
+    }
+    /** True iff the access-token resolver yields a non-empty token. */
+    async isAuthenticated() {
+        return !!(await this.getAccessToken());
+    }
+}
+/**
+ * Create a new GraphQL client instance. Preferred entry point in v0.10.0.
+ *
+ * Usage:
+ *   const client = createClient({ endpoint: '/api/graphql', defaultLanguage: 'NL' });
+ *   const productService = productServiceFactory(client);
+ *   const product = await productService.getProduct({ productId: 1 });
+ */
+export function createClient(config) {
+    return new GraphQLClient(config);
+}
+/**
+ * Emits a one-time deprecation warning per legacy entry point, per process.
+ * Keyed by function name so each distinct helper warns at most once.
+ */
+const _warnedLegacyInit = new Set();
+function warnDeprecatedInit(fnName, replacement) {
+    if (_warnedLegacyInit.has(fnName))
+        return;
+    _warnedLegacyInit.add(fnName);
+    // eslint-disable-next-line no-console
+    console.warn(`[propeller-sdk-v2] ${fnName}() is deprecated and will be removed in a future ` +
+        `release. Use ${replacement} instead.`);
+}
+/**
+ * @deprecated Use `createClient()` instead. Retained for v0.x compatibility;
+ * will be removed in a future release.
+ */
+export function createGraphQLClient(config) {
+    warnDeprecatedInit('createGraphQLClient', 'createClient()');
+    return new GraphQLClient(config);
+}
+let defaultClient = null;
+/**
+ * Initialize the default GraphQL client used by `getClient()`.
+ *
+ * @deprecated The global-singleton pattern is deprecated and will be removed
+ * in a future release. Create a client with `createClient()` and pass it
+ * explicitly to service factories instead.
+ */
+export function initializeClient(config) {
+    warnDeprecatedInit('initializeClient', 'createClient() with an explicitly-passed client');
+    defaultClient = createClient(config);
+}
+/**
+ * Get the default GraphQL client instance.
+ * @throws Error if client hasn't been initialized
+ *
+ * @deprecated The global-singleton pattern is deprecated and will be removed
+ * in a future release. Create a client with `createClient()` and pass it
+ * explicitly to service factories instead.
+ */
+export function getClient() {
+    warnDeprecatedInit('getClient', 'createClient() with an explicitly-passed client');
+    if (!defaultClient) {
+        throw new Error('GraphQL client not initialized. Call initializeClient() or createClient() first.');
+    }
+    return defaultClient;
+}

package/dist/esm/client/GraphQLOperationError.js

@@ -0,0 +1,13 @@
+export class GraphQLOperationError extends Error {
+    constructor(errors, operationName, variables, document) {
+        const summary = errors.map(e => e.message).join('; ');
+        const opLabel = operationName ? ` (${operationName})` : '';
+        super(`GraphQL operation failed${opLabel}: ${summary}`);
+        this.name = 'GraphQLOperationError';
+        this.errors = errors;
+        this.operationName = operationName;
+        this.variables = variables;
+        this.document = document;
+        Object.setPrototypeOf(this, GraphQLOperationError.prototype);
+    }
+}

package/dist/esm/client/index.js

@@ -0,0 +1,14 @@
+/**
+ * GraphQL Client for Propeller eCommerce Platform
+ * Exports the main GraphQL client class and related utilities.
+ *
+ * As of v0.10.0, `createClient()` is the preferred entry point.
+ * The class form (`new GraphQLClient(...)`) is preserved for backwards
+ * compatibility with code written against 0.9.x.
+ */
+export { GraphQLClient, createClient, createGraphQLClient, initializeClient, getClient, } from './GraphQLClient.js';
+export { GraphQLOperationError } from './GraphQLOperationError.js';
+/**
+ * @description Default export for the GraphQL client
+ */
+export { GraphQLClient as default } from './GraphQLClient.js';

package/dist/esm/enum/ALLOW_QUOTE_INVALIDATION.js

@@ -0,0 +1,11 @@
+/**
+ * @enum ALLOW_QUOTE_INVALIDATION
+ * Controls whether quotes can be invalidated within the tenant.
+ */
+export var ALLOW_QUOTE_INVALIDATION;
+(function (ALLOW_QUOTE_INVALIDATION) {
+    /** Quotes can be invalidated */
+    ALLOW_QUOTE_INVALIDATION["YES"] = "YES";
+    /** Quotes cannot be invalidated. */
+    ALLOW_QUOTE_INVALIDATION["NO"] = "NO";
+})(ALLOW_QUOTE_INVALIDATION || (ALLOW_QUOTE_INVALIDATION = {}));

package/dist/esm/enum/AddressType.js

@@ -0,0 +1,13 @@
+/**
+ * @enum AddressType
+ Types of addresses used in the system
+ */
+export var AddressType;
+(function (AddressType) {
+    /** Delivery address for shipping orders */
+    AddressType["delivery"] = "delivery";
+    /** Invoice/billing address for financial transactions */
+    AddressType["invoice"] = "invoice";
+    /** Home address of the customer */
+    AddressType["home"] = "home";
+})(AddressType || (AddressType = {}));

package/dist/esm/enum/AdminUserSortField.js

@@ -0,0 +1,11 @@
+/**
+ * @enum AdminUserSortField
+ Fields available for sorting admin users
+ */
+export var AdminUserSortField;
+(function (AdminUserSortField) {
+    /** Sort by creation date */
+    AdminUserSortField["CREATED_AT"] = "CREATED_AT";
+    /** Sort by last modification date */
+    AdminUserSortField["LAST_MODIFIED_AT"] = "LAST_MODIFIED_AT";
+})(AdminUserSortField || (AdminUserSortField = {}));

package/dist/esm/enum/AttributeAttributeDescriptionTermField.js

@@ -0,0 +1,11 @@
+/**
+ * @enum AttributeAttributeDescriptionTermField
+ * Available fields for searching attribute descriptions with full-text search
+ */
+export var AttributeAttributeDescriptionTermField;
+(function (AttributeAttributeDescriptionTermField) {
+    /** Search by attribute description name for easy browsing and discovery */
+    AttributeAttributeDescriptionTermField["NAME"] = "NAME";
+    /** Search by attribute description text for finding specific attribute descriptions */
+    AttributeAttributeDescriptionTermField["DESCRIPTION"] = "DESCRIPTION";
+})(AttributeAttributeDescriptionTermField || (AttributeAttributeDescriptionTermField = {}));

package/dist/esm/enum/AttributeDescriptionClass.js

@@ -0,0 +1,13 @@
+/**
+ * @enum AttributeDescriptionClass
+ Class enumeration for AttributeDescription categorization
+ */
+export var AttributeDescriptionClass;
+(function (AttributeDescriptionClass) {
+    AttributeDescriptionClass["PRODUCT"] = "PRODUCT";
+    AttributeDescriptionClass["CATEGORY"] = "CATEGORY";
+    AttributeDescriptionClass["CLUSTER"] = "CLUSTER";
+    AttributeDescriptionClass["CUSTOMER"] = "CUSTOMER";
+    AttributeDescriptionClass["CONTACT"] = "CONTACT";
+    AttributeDescriptionClass["COMPANY"] = "COMPANY";
+})(AttributeDescriptionClass || (AttributeDescriptionClass = {}));

package/dist/esm/enum/AttributeDescriptionFieldName.js

@@ -0,0 +1,26 @@
+/**
+ * @enum AttributeDescriptionFieldName
+ Fields available for AttributeDescription mapping
+ */
+export var AttributeDescriptionFieldName;
+(function (AttributeDescriptionFieldName) {
+    AttributeDescriptionFieldName["NAME"] = "NAME";
+    AttributeDescriptionFieldName["DESCRIPTION"] = "DESCRIPTION";
+    AttributeDescriptionFieldName["UNIT"] = "UNIT";
+    AttributeDescriptionFieldName["LANGUAGE"] = "LANGUAGE";
+    AttributeDescriptionFieldName["TYPE"] = "TYPE";
+    AttributeDescriptionFieldName["ATTRIBUTE_CLASS"] = "ATTRIBUTE_CLASS";
+    AttributeDescriptionFieldName["VALUESET_ID"] = "VALUESET_ID";
+    AttributeDescriptionFieldName["GROUP"] = "GROUP";
+    AttributeDescriptionFieldName["IS_SEARCHABLE"] = "IS_SEARCHABLE";
+    AttributeDescriptionFieldName["IS_PUBLIC"] = "IS_PUBLIC";
+    AttributeDescriptionFieldName["IS_SYSTEM"] = "IS_SYSTEM";
+    AttributeDescriptionFieldName["IS_HIDDEN"] = "IS_HIDDEN";
+    AttributeDescriptionFieldName["TEXT_VALUES"] = "TEXT_VALUES";
+    AttributeDescriptionFieldName["TEXT_VALUES_LANGUAGE"] = "TEXT_VALUES_LANGUAGE";
+    AttributeDescriptionFieldName["ENUM_VALUES"] = "ENUM_VALUES";
+    AttributeDescriptionFieldName["INT_VALUE"] = "INT_VALUE";
+    AttributeDescriptionFieldName["DECIMAL_VALUE"] = "DECIMAL_VALUE";
+    AttributeDescriptionFieldName["DATE_TIME_VALUE"] = "DATE_TIME_VALUE";
+    AttributeDescriptionFieldName["COLOR_VALUE"] = "COLOR_VALUE";
+})(AttributeDescriptionFieldName || (AttributeDescriptionFieldName = {}));

package/dist/esm/enum/AttributeDescriptionSortField.js

@@ -0,0 +1,10 @@
+/**
+ * @enum AttributeDescriptionSortField
+ Fields available for sorting AttributeDescription records
+ */
+export var AttributeDescriptionSortField;
+(function (AttributeDescriptionSortField) {
+    AttributeDescriptionSortField["NAME"] = "NAME";
+    AttributeDescriptionSortField["CREATED_AT"] = "CREATED_AT";
+    AttributeDescriptionSortField["LAST_MODIFIED_AT"] = "LAST_MODIFIED_AT";
+})(AttributeDescriptionSortField || (AttributeDescriptionSortField = {}));

package/dist/esm/enum/AttributeFieldName.js

@@ -0,0 +1,33 @@
+/**
+ * @enum AttributeFieldName
+ Enum for attribute field names used in Propeller eCommerce Platform
+ */
+export var AttributeFieldName;
+(function (AttributeFieldName) {
+    /** [Required][String] The ID of the AttributeDescription, required if attributeDescriptionName is not provided */
+    AttributeFieldName["ATTRIBUTE_DESCRIPTION_ID"] = "ATTRIBUTE_DESCRIPTION_ID";
+    /** [Required][String] The Name of the AttributeDescription, required if attributeDescriptionId is not provided */
+    AttributeFieldName["ATTRIBUTE_DESCRIPTION_NAME"] = "ATTRIBUTE_DESCRIPTION_NAME";
+    /** [Optional][String] Attribute value descriptions per language, required for TEXT type attributes */
+    AttributeFieldName["TEXT_VALUES"] = "TEXT_VALUES";
+    /** [Optional][String] Attribute value descriptions per language, required for TEXT type attributes */
+    AttributeFieldName["TEXT_VALUES_LANGUAGE"] = "TEXT_VALUES_LANGUAGE";
+    /** [Optional][Array] Attribute enum values, required for ENUM type attributes */
+    AttributeFieldName["ENUM_VALUES"] = "ENUM_VALUES";
+    /** [Optional][Integer] Attribute integer value, required for INTEGER type attributes */
+    AttributeFieldName["INT_VALUE"] = "INT_VALUE";
+    /** [Optional][Decimal] Attribute decimal value, required for DECIMAL type attributes */
+    AttributeFieldName["DECIMAL_VALUE"] = "DECIMAL_VALUE";
+    /** [Optional][DateTime] Attribute datetime value, required for DATETIME type attributes in ISO 8601 format 'YYYY-MM-DDThh:mm:ss.sssZ' (e.g., 2024-10-31T09:55:00.000Z) */
+    AttributeFieldName["DATE_TIME_VALUE"] = "DATE_TIME_VALUE";
+    /** [Optional][String] Attribute color value, required for COLOR type attributes */
+    AttributeFieldName["COLOR_VALUE"] = "COLOR_VALUE";
+    /** [Optional][Enum] The class the Attribute or AttributeDescription belongs to, must be one of the following: [products, clusters, categories, customers, contacts, companies] */
+    AttributeFieldName["ATTRIBUTE_CLASS"] = "ATTRIBUTE_CLASS";
+    /** The lookupKey to find the resource by, i.e. id or sourceId */
+    AttributeFieldName["LOOKUP_KEY"] = "LOOKUP_KEY";
+    /** The lookupValue to find the resource by, i.e. the id or the sourceId */
+    AttributeFieldName["LOOKUP_VALUE"] = "LOOKUP_VALUE";
+    /** The source of the lookupValue when the lookupKey is a sourceId */
+    AttributeFieldName["SOURCE"] = "SOURCE";
+})(AttributeFieldName || (AttributeFieldName = {}));

package/dist/esm/enum/AttributeType.js

@@ -0,0 +1,19 @@
+/**
+ * @enum AttributeType
+ Types of attributes supported in the system
+ */
+export var AttributeType;
+(function (AttributeType) {
+    /** Text/string attribute type */
+    AttributeType["TEXT"] = "TEXT";
+    /** Enumeration attribute type with predefined values */
+    AttributeType["ENUM"] = "ENUM";
+    /** Color attribute type for hex/rgb values */
+    AttributeType["COLOR"] = "COLOR";
+    /** Date and time attribute type */
+    AttributeType["DATETIME"] = "DATETIME";
+    /** Integer number attribute type */
+    AttributeType["INT"] = "INT";
+    /** Decimal/float number attribute type */
+    AttributeType["DECIMAL"] = "DECIMAL";
+})(AttributeType || (AttributeType = {}));

package/dist/esm/enum/Auto.js

@@ -0,0 +1,9 @@
+/**
+ * @enum Auto
+ Enumeration for Auto values
+ */
+export var Auto;
+(function (Auto) {
+    Auto["WEBP"] = "WEBP";
+    Auto["AVIF"] = "AVIF";
+})(Auto || (Auto = {}));