@viu/emporix-sdk 2.21.0 → 2.23.0

package/dist/category.d.ts

@@ -44,6 +44,61 @@ type ClassificationMixin = {
      */
     sourceCategoryId?: string;
 };
+type BulkAssignmentResponse = Array<{
+    /**
+     * ID of generated document.
+     */
+    assignmentId?: string;
+    /**
+     * ID of the product.
+     */
+    productId?: string;
+    /**
+     * Index of the item in the array.
+     */
+    index?: number;
+    /**
+     * HTTP status' code.
+     */
+    code?: number;
+    /**
+     * HTTP status.
+     */
+    status?: string;
+    /**
+     * Error message which is present only when creation of the assignment failed.
+     */
+    message?: string;
+}>;
+type AssignmentIdResponse = {
+    /**
+     * ID of generated document.
+     */
+    id?: string;
+};
+type BulkAssignmentRequest = Array<{
+    ref: {
+        /**
+         * Assignment reference unique identifier, for example product ID.
+         */
+        id: string;
+        /**
+         * Assignment reference type, for example 'product'.
+         */
+        type: 'PRODUCT';
+    };
+}>;
+type BulkAssignmentUpsertRequest = Array<{
+    ref: {
+        /**
+         * Assignment reference unique identifier, for example product ID.
+         */
+        id: string;
+    };
+}>;
+type AssignmentRequest = {
+    ref: Reference;
+};
 /**
  * Definition of category
  */
@@ -122,6 +177,163 @@ type Category$1 = {
     metadata: MetadataResponse;
     media: Array<Media>;
 };
+/**
+ * Definition od category assignment
+ */
+type CategoryAssignment$1 = {
+    /**
+     * Assignment unique identifier generated when the assignment is created.
+     */
+    id?: string;
+    /**
+     * Assignment category identifier.
+     */
+    categoryId?: string;
+    ref?: CategoryAssignmentRefQueryDocument & unknown;
+};
+/**
+ * Localized category description in a form of a map of translations.
+ */
+type CategoryAssignmentRefQueryDocument = {
+    /**
+     * Assignment reference unique identifier, for example product ID.
+     */
+    id: string;
+    /**
+     * Assignment reference type, for example 'product'.
+     */
+    type: 'PRODUCT';
+    /**
+     * Assignment reference localized name.
+     */
+    localizedName: {
+        [key: string]: string;
+    };
+};
+type CategoryCreateRequest = {
+    /**
+     * Custom category identifier. If not provided, it is automatically generated
+     */
+    id?: string;
+    /**
+     * Category type, by default it is `STANDARD`.
+     */
+    type?: 'CLASSIFICATION' | 'STANDARD';
+    /**
+     * Localized category name in a form of a map of translations.
+     */
+    localizedName: {
+        [key: string]: string;
+    };
+    /**
+     * Localized category description in a form of a map of translations.
+     */
+    localizedDescription?: {
+        [key: string]: string;
+    };
+    /**
+     * Unique identifier of the parent category. No parentId in the body indicates that this is a root category.
+     */
+    parentId?: string | null;
+    /**
+     * Provides localized category name or code without diacritics for the URL.
+     */
+    localizedSlug?: {
+        [key: string]: string;
+    };
+    /**
+     * List of external category numbers (ECNs) unique for every category.
+     */
+    ecn?: Array<string> | null;
+    /**
+     * Unique category identifier, defined by the tenant. Required for category of type `CLASSIFICATION`.
+     */
+    code?: string | null;
+    /**
+     * Category validity.
+     */
+    validity?: {
+        [key: string]: string;
+    };
+    /**
+     * Category position, set in relation to the categories on the same level (sharing the same parent) in the tree.
+     */
+    position?: number | null;
+    /**
+     * Flag indicating whether the category has been published or not.
+     */
+    published: boolean;
+    /**
+     * List of classification mixins defined by this category.
+     */
+    ownClassificationMixins?: Array<OwnClassificationMixin>;
+    /**
+     * Custom category attributes that need to be included directly in the mixins object.
+     */
+    mixins?: {
+        [key: string]: unknown;
+    };
+    metadata?: MetadataCreate;
+};
+type CategoryIdResponse = {
+    /**
+     * ID of generated document.
+     */
+    id?: string;
+};
+type CategoryPartialUpdateRequest = {
+    /**
+     * Localized category name in a form of a map of translations.
+     */
+    localizedName?: {
+        [key: string]: string;
+    };
+    /**
+     * Localized category description in a form of a map of translations.
+     */
+    localizedDescription?: {
+        [key: string]: string;
+    };
+    /**
+     * Unique identifier of the parent category. No parentId in the body indicates that this is a root category.
+     */
+    parentId?: string | null;
+    /**
+     * Provides localized category name or code without diacritics for the URL.
+     */
+    localizedSlug?: {
+        [key: string]: string;
+    };
+    /**
+     * List of external category numbers (ECNs) unique for every category.
+     */
+    ecn?: Array<string> | null;
+    /**
+     * Unique category identifier, defined by the tenant.
+     */
+    code?: string | null;
+    /**
+     * Category validity.
+     */
+    validity?: {
+        [key: string]: string;
+    };
+    /**
+     * Category position, set in relation to the categories on the same level (sharing the same parent) in the tree.
+     */
+    position?: number | null;
+    /**
+     * Flag indicating whether the category has been published or not.
+     */
+    published?: boolean | null;
+    /**
+     * Custom category attributes that need to be included directly in the mixins object.
+     */
+    mixins?: {
+        [key: string]: unknown;
+    };
+    metadata: MetadataUpdate;
+};
 /**
  * Definition of category tree
  */
@@ -180,6 +392,59 @@ type CategoryTree = {
      */
     subcategories?: Array<CategoryTree>;
 };
+type CategoryUpdateRequest = {
+    /**
+     * Localized category name in a form of a map of translations.
+     */
+    localizedName: {
+        [key: string]: string;
+    };
+    /**
+     * Localized category description in a form of a map of translations.
+     */
+    localizedDescription?: {
+        [key: string]: string;
+    };
+    /**
+     * Unique identifier of the parent category. No parentId in the body indicates that this is a root category.
+     */
+    parentId?: string | null;
+    /**
+     * Provides localized category name or code without diacritics for the URL.
+     */
+    localizedSlug?: {
+        [key: string]: string;
+    };
+    /**
+     * List of external category numbers (ECNs) unique for every category.
+     */
+    ecn?: Array<string> | null;
+    /**
+     * Unique category identifier, defined by the tenant. Required for category of type `CLASSIFICATION`.
+     */
+    code?: string | null;
+    /**
+     * Category validity.
+     */
+    validity?: {
+        [key: string]: string;
+    };
+    /**
+     * Category position, set in relation to the categories on the same level (sharing the same parent) in the tree.
+     */
+    position?: number | null;
+    /**
+     * Flag indicating whether the category has been published or not.
+     */
+    published: boolean;
+    /**
+     * Custom category attributes that need to be included directly in the mixins object.
+     */
+    mixins?: {
+        [key: string]: unknown;
+    };
+    metadata?: MetadataUpdate;
+};
 type Media = {
     /**
      * Unique identifier of media.
@@ -268,6 +533,25 @@ type MetadataResponse = {
      */
     modifiedAt?: string;
 } & MetadataUpdate;
+type CategoryTreeSearchRequest = {
+    /**
+     * List of category IDs. If provided, the response returns only the category trees that include at least one of the specified categories.
+     */
+    categoryIds: Array<string>;
+};
+/**
+ * Assignment reference.
+ */
+type Reference = {
+    /**
+     * Assignment reference unique identifier, for example product ID.
+     */
+    id: string;
+    /**
+     * Assignment reference type, for example 'product'.
+     */
+    type: 'PRODUCT';
+};
 type Validity = {
     /**
      * Date and time from which the category is valid compliant with the ISO 8601 standard.
@@ -283,6 +567,28 @@ type Validity = {
 type Category = Category$1;
 /** The category tree as returned by the Category service. */
 type CategoryNode = CategoryTree;
+/** Body for creating a category (`POST /categories`). */
+type CategoryCreateInput = CategoryCreateRequest;
+/** Body for a full category replace (`PUT /categories/{id}`). */
+type CategoryUpdateInput = CategoryUpdateRequest;
+/** Body for a partial category update (`PATCH /categories/{id}`). */
+type CategoryPatchInput = CategoryPartialUpdateRequest;
+/** Id envelope returned when a category is created. */
+type CategoryCreated = CategoryIdResponse;
+/** Body for searching category trees (`POST /category-trees/search`). */
+type CategoryTreeSearchInput = CategoryTreeSearchRequest;
+/** A category assignment (a resource reference bound to a category). */
+type CategoryAssignment = CategoryAssignment$1;
+/** Body for assigning a single resource to a category. */
+type CategoryAssignmentInput = AssignmentRequest;
+/** Body for bulk-assigning resources to a category. */
+type CategoryAssignmentBulkInput = BulkAssignmentRequest;
+/** Body for bulk-upserting assignment references (`ref.id` only). */
+type CategoryAssignmentRefBulkInput = BulkAssignmentUpsertRequest;
+/** Multi-status result of a bulk assignment operation. */
+type CategoryAssignmentBulkResult = BulkAssignmentResponse;
+/** Id envelope returned when an assignment is created. */
+type CategoryAssignmentCreated = AssignmentIdResponse;
 /** Category reads. Default auth: anonymous. */
 declare class CategoryService {
     private readonly ctx;
@@ -350,6 +656,107 @@ declare class CategoryService {
     searchByIds(ids: string[], options?: {
         chunkSize?: number;
     }, auth?: AuthContext): Promise<Category[]>;
+    /** Lists a category's ancestor categories (breadcrumb-up). Default auth: anonymous. */
+    parents(categoryId: string, auth?: AuthContext): Promise<Category[]>;
+    /**
+     * Lists a category's direct child categories via the dedicated
+     * `…/subcategories` endpoint. (The older `subcategories()` reads `/assignments`
+     * and is kept for backward compatibility.) Default auth: anonymous.
+     */
+    childCategories(categoryId: string, auth?: AuthContext): Promise<Category[]>;
+    /** Retrieves one category tree by its root category id. Default auth: anonymous. */
+    getTree(categoryId: string, auth?: AuthContext): Promise<CategoryNode>;
+    /**
+     * Creates a category (`POST /categories`). Default auth: service.
+     * `options.publish` sets the `publish` query flag (needs the
+     * `category.category_publish` scope).
+     */
+    create(input: CategoryCreateInput, options?: {
+        publish?: boolean;
+    }, auth?: AuthContext): Promise<CategoryCreated>;
+    /**
+     * Full-replaces a category (`PUT /categories/{categoryId}`). This is an
+     * upsert: with a caller-supplied id it may create (201, returns the id) or
+     * update an existing one (204, returns nothing). Default auth: service.
+     */
+    update(categoryId: string, input: CategoryUpdateInput, options?: {
+        publish?: boolean;
+    }, auth?: AuthContext): Promise<CategoryCreated | void>;
+    /**
+     * Partially updates a category (`PATCH /categories/{categoryId}`). Default
+     * auth: service. `options.publish` sets the `publish` query flag.
+     */
+    patch(categoryId: string, input: CategoryPatchInput, options?: {
+        publish?: boolean;
+    }, auth?: AuthContext): Promise<void>;
+    /** Deletes a category (`DELETE /categories/{categoryId}`). Default auth: service. */
+    delete(categoryId: string, auth?: AuthContext): Promise<void>;
+    /**
+     * Searches categories via `POST /categories/search`. Same query capability
+     * as {@link search} (`compoundLogicalQuery: false` — Category rejects `or()`
+     * filters); the POST body avoids URL-length limits for large `q` filters.
+     * `params.showRoots` / `params.showUnpublished` are POST-only flags. Default
+     * auth: anonymous.
+     */
+    searchByQuery(query: QueryFor<"CATEGORY">, params?: {
+        pageNumber?: number;
+        pageSize?: number;
+        sort?: string;
+        showRoots?: boolean;
+        showUnpublished?: boolean;
+    }, auth?: AuthContext): Promise<PaginatedItems<Category>>;
+    /**
+     * Searches category trees via `POST /category-trees/search` — returns the
+     * trees that include at least one of the given `categoryIds`. Default auth:
+     * anonymous.
+     */
+    searchTrees(input: CategoryTreeSearchInput, options?: {
+        showUnpublished?: boolean;
+    }, auth?: AuthContext): Promise<CategoryNode[]>;
+    /**
+     * Category ↔ resource assignments. Writes default to service auth. The
+     * assignment `ref.type` is `'PRODUCT'` (per the API); category hierarchy is
+     * managed via `parentId` on the category, not via assignments.
+     */
+    readonly assignments: {
+        /** One page of a category's assignments. Default auth: anonymous. */
+        list: (categoryId: string, params?: {
+            pageNumber?: number;
+            pageSize?: number;
+            sort?: string;
+            expandSupercategoriesIds?: boolean;
+            showUnpublished?: boolean;
+        }, auth?: AuthContext) => Promise<CategoryAssignment[]>;
+        /** Assigns a single resource to a category (`POST …/assignments`). Default auth: service. */
+        create: (categoryId: string, input: CategoryAssignmentInput, auth?: AuthContext) => Promise<CategoryAssignmentCreated>;
+        /** Bulk-assigns resources to a category (`POST …/assignments/bulk`). Default auth: service. */
+        bulkCreate: (categoryId: string, input: CategoryAssignmentBulkInput, auth?: AuthContext) => Promise<CategoryAssignmentBulkResult>;
+        /** Removes one assignment by id (`DELETE …/assignments/{assignmentId}`). Default auth: service. */
+        remove: (categoryId: string, assignmentId: string, auth?: AuthContext) => Promise<void>;
+        /** Removes all of a category's assignments (`DELETE …/assignments`). Default auth: service. */
+        removeAll: (categoryId: string, options?: {
+            assignmentType?: "PRODUCT";
+        }, auth?: AuthContext) => Promise<void>;
+        /** Upserts an assignment by reference id — no body (`PUT …/assignments/references/{referenceId}`). Default auth: service. */
+        upsertByReference: (categoryId: string, referenceId: string, auth?: AuthContext) => Promise<CategoryAssignmentCreated>;
+        /** Removes an assignment by reference id (`DELETE …/assignments/references/{referenceId}`). Default auth: service. */
+        removeByReference: (categoryId: string, referenceId: string, auth?: AuthContext) => Promise<void>;
+        /** Bulk-upserts assignment references (`PUT …/assignments/references/bulk`). Default auth: service. */
+        bulkUpsertByReference: (categoryId: string, input: CategoryAssignmentRefBulkInput, auth?: AuthContext) => Promise<CategoryAssignmentBulkResult>;
+        /**
+         * Lists every category assigned to the given reference id — tenant-wide
+         * (`GET /assignments/references/{referenceId}`). Default auth: anonymous.
+         */
+        listCategoriesByReference: (referenceId: string, params?: {
+            pageNumber?: number;
+            pageSize?: number;
+            sort?: string;
+            showUnpublished?: boolean;
+            expandSupercategoriesIds?: boolean;
+        }, auth?: AuthContext) => Promise<Category[]>;
+        /** Removes all assignments to a given reference id — tenant-wide (`DELETE /assignments/references/{referenceId}`). Default auth: service. */
+        removeAllByReference: (referenceId: string, auth?: AuthContext) => Promise<void>;
+    };
 }
 
-export { type Category, type CategoryNode, CategoryService };
+export { type Category, type CategoryAssignment, type CategoryAssignmentBulkInput, type CategoryAssignmentBulkResult, type CategoryAssignmentCreated, type CategoryAssignmentInput, type CategoryAssignmentRefBulkInput, type CategoryCreateInput, type CategoryCreated, type CategoryNode, type CategoryPatchInput, CategoryService, type CategoryTreeSearchInput, type CategoryUpdateInput };

package/dist/category.js

@@ -1,4 +1,4 @@
-export { CategoryService } from './chunk-ZNLHLFQM.js';
+export { CategoryService } from './chunk-HWVFF6B2.js';
 import './chunk-GWJ2U2CP.js';
 import './chunk-S5HEIQDK.js';
 //# sourceMappingURL=category.js.map

package/dist/{chunk-HD5RBCM6.js → chunk-27NLS646.js}

@@ -48,8 +48,16 @@ var ContactsService = class {
       auth
     });
   }
+  /** Fetches a single contact assignment by id. */
+  async get(contactAssignmentId, auth) {
+    return this.ctx.http.request({
+      method: "GET",
+      path: `${this.base()}/${contactAssignmentId}`,
+      auth
+    });
+  }
 };
 
 export { ContactsService };
-//# sourceMappingURL=chunk-HD5RBCM6.js.map
-//# sourceMappingURL=chunk-HD5RBCM6.js.map
+//# sourceMappingURL=chunk-27NLS646.js.map
+//# sourceMappingURL=chunk-27NLS646.js.map

package/dist/chunk-27NLS646.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../src/services/contacts.ts"],"names":[],"mappings":";AAeO,IAAM,kBAAN,MAAsB;AAAA,EAE3B,YAA6B,GAAA,EAAoB;AAApB,IAAA,IAAA,CAAA,GAAA,GAAA,GAAA;AAAA,EAAqB;AAAA,EAArB,GAAA;AAAA,EAD7B,OAAgB,OAAA,GAAU,qBAAA;AAAA,EAGlB,IAAA,GAAe;AACrB,IAAA,OAAO,CAAA,qBAAA,EAAwB,IAAA,CAAK,GAAA,CAAI,MAAM,CAAA,oBAAA,CAAA;AAAA,EAChD;AAAA;AAAA,EAGA,MAAM,cAAA,CAAe,aAAA,EAAuB,IAAA,EAAiD;AAC3F,IAAA,OAAO,IAAA,CAAK,GAAA,CAAI,IAAA,CAAK,OAAA,CAA6B;AAAA,MAChD,MAAA,EAAQ,KAAA;AAAA,MACR,IAAA,EAAM,KAAK,IAAA,EAAK;AAAA,MAChB,KAAA,EAAO,EAAE,aAAA,EAAc;AAAA,MACvB;AAAA,KACD,CAAA;AAAA,EACH;AAAA;AAAA,EAGA,MAAM,MAAA,CAAO,KAAA,EAAgC,IAAA,EAA4C;AACvF,IAAA,OAAO,IAAA,CAAK,GAAA,CAAI,IAAA,CAAK,OAAA,CAAwB;AAAA,MAC3C,MAAA,EAAQ,MAAA;AAAA,MACR,IAAA,EAAM,KAAK,IAAA,EAAK;AAAA,MAChB,IAAA;AAAA,MACA,IAAA,EAAM;AAAA,KACP,CAAA;AAAA,EACH;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA,EAQA,MAAM,MAAA,CACJ,mBAAA,EACA,KAAA,EACA,IAAA,EAC4B;AAC5B,IAAA,OAAO,IAAA,CAAK,GAAA,CAAI,IAAA,CAAK,OAAA,CAA2B;AAAA,MAC9C,MAAA,EAAQ,KAAA;AAAA,MACR,MAAM,CAAA,EAAG,IAAA,CAAK,IAAA,EAAM,IAAI,mBAAmB,CAAA,CAAA;AAAA,MAC3C,IAAA;AAAA,MACA,IAAA,EAAM;AAAA,KACP,CAAA;AAAA,EACH;AAAA;AAAA,EAGA,MAAM,QAAA,CAAS,mBAAA,EAA6B,IAAA,EAAkC;AAC5E,IAAA,MAAM,IAAA,CAAK,GAAA,CAAI,IAAA,CAAK,OAAA,CAAc;AAAA,MAChC,MAAA,EAAQ,QAAA;AAAA,MACR,MAAM,CAAA,EAAG,IAAA,CAAK,IAAA,EAAM,IAAI,mBAAmB,CAAA,CAAA;AAAA,MAC3C;AAAA,KACD,CAAA;AAAA,EACH;AAAA;AAAA,EAGA,MAAM,GAAA,CAAI,mBAAA,EAA6B,IAAA,EAA+C;AACpF,IAAA,OAAO,IAAA,CAAK,GAAA,CAAI,IAAA,CAAK,OAAA,CAA2B;AAAA,MAC9C,MAAA,EAAQ,KAAA;AAAA,MACR,MAAM,CAAA,EAAG,IAAA,CAAK,IAAA,EAAM,IAAI,mBAAmB,CAAA,CAAA;AAAA,MAC3C;AAAA,KACD,CAAA;AAAA,EACH;AACF","file":"chunk-27NLS646.js","sourcesContent":["import type { ClientContext } from \"../core/context\";\nimport type { AuthContext } from \"../core/auth\";\nimport type {\n  ContactAssignment,\n  ContactAssignmentCreate,\n  ContactAssignmentUpdate,\n} from \"../generated/customer-management\";\n\n/**\n * Manages contact assignments linking customers to legal entities.\n *\n * `listForCompany` requires `customermanagement.contactassignment_read`;\n * `assign`/`update`/`unassign` require `_manage`. The query param\n * `legalEntityId` scopes the list to one company.\n */\nexport class ContactsService {\n  static readonly channel = \"customer-management\" as const;\n  constructor(private readonly ctx: ClientContext) {}\n\n  private base(): string {\n    return `/customer-management/${this.ctx.tenant}/contact-assignments`;\n  }\n\n  /** Lists contact assignments for one legal entity. */\n  async listForCompany(legalEntityId: string, auth: AuthContext): Promise<ContactAssignment[]> {\n    return this.ctx.http.request<ContactAssignment[]>({\n      method: \"GET\",\n      path: this.base(),\n      query: { legalEntityId },\n      auth,\n    });\n  }\n\n  /** Creates a contact assignment. */\n  async assign(input: ContactAssignmentCreate, auth: AuthContext): Promise<{ id: string }> {\n    return this.ctx.http.request<{ id: string }>({\n      method: \"POST\",\n      path: this.base(),\n      auth,\n      body: input,\n    });\n  }\n\n  /**\n   * Updates a contact assignment via `PUT …/contact-assignments/{id}` (upsert /\n   * full replace). The live API rejects `PATCH` on this path with 405; send the\n   * complete entity, as the server replaces the resource. The body stays typed\n   * as a partial of `ContactAssignmentUpdate` for backward compatibility.\n   */\n  async update(\n    contactAssignmentId: string,\n    patch: Partial<ContactAssignmentUpdate>,\n    auth: AuthContext,\n  ): Promise<ContactAssignment> {\n    return this.ctx.http.request<ContactAssignment>({\n      method: \"PUT\",\n      path: `${this.base()}/${contactAssignmentId}`,\n      auth,\n      body: patch,\n    });\n  }\n\n  /** Deletes a contact assignment. */\n  async unassign(contactAssignmentId: string, auth: AuthContext): Promise<void> {\n    await this.ctx.http.request<void>({\n      method: \"DELETE\",\n      path: `${this.base()}/${contactAssignmentId}`,\n      auth,\n    });\n  }\n\n  /** Fetches a single contact assignment by id. */\n  async get(contactAssignmentId: string, auth: AuthContext): Promise<ContactAssignment> {\n    return this.ctx.http.request<ContactAssignment>({\n      method: \"GET\",\n      path: `${this.base()}/${contactAssignmentId}`,\n      auth,\n    });\n  }\n}\n"]}

package/dist/{chunk-PYLWZZC4.js → chunk-6PJFOX3A.js}

@@ -246,6 +246,7 @@ var DefaultTokenProvider = class {
 
 // src/services/payment.ts
 var ANON = auth.anonymous();
+var SERVICE = auth.service();
 var PaymentGatewayService = class {
   constructor(ctx) {
     this.ctx = ctx;
@@ -273,8 +274,131 @@ var PaymentGatewayService = class {
       body: input
     });
   }
+  /** Retrieves a single frontend payment mode by id. Defaults to anonymous (no scope required). */
+  async getMode(id, authCtx = ANON) {
+    return this.ctx.http.request({
+      method: "GET",
+      path: `/payment-gateway/${this.ctx.tenant}/paymentmodes/frontend/${id}`,
+      auth: authCtx
+    });
+  }
+  /** Initializes a payment from the frontend. Defaults to anonymous (no scope required). */
+  async initialize(input, authCtx = ANON) {
+    return this.ctx.http.request({
+      method: "POST",
+      path: `/payment-gateway/${this.ctx.tenant}/payment/frontend/initialize`,
+      auth: authCtx,
+      body: input
+    });
+  }
+  /**
+   * Payment-mode **configuration** (`/paymentmodes/config`) — the admin view.
+   * For the storefront view use {@link listPaymentModes} / {@link getMode}.
+   * Defaults to service auth.
+   */
+  modes = {
+    /** Lists all configured payment modes. The endpoint takes no query parameters. */
+    list: async (authCtx = SERVICE) => this.ctx.http.request({
+      method: "GET",
+      path: `/payment-gateway/${this.ctx.tenant}/paymentmodes/config`,
+      auth: authCtx
+    }),
+    /** Retrieves one payment-mode configuration by id. */
+    get: async (id, authCtx = SERVICE) => this.ctx.http.request({
+      method: "GET",
+      path: `/payment-gateway/${this.ctx.tenant}/paymentmodes/config/${id}`,
+      auth: authCtx
+    }),
+    /** Creates a payment-mode configuration. Responds 200 with the created mode. */
+    create: async (input, authCtx = SERVICE) => this.ctx.http.request({
+      method: "POST",
+      path: `/payment-gateway/${this.ctx.tenant}/paymentmodes/config`,
+      body: input,
+      auth: authCtx
+    }),
+    /** Updates a payment-mode configuration (PUT). Responds 200 with the updated mode. */
+    update: async (id, input, authCtx = SERVICE) => this.ctx.http.request({
+      method: "PUT",
+      path: `/payment-gateway/${this.ctx.tenant}/paymentmodes/config/${id}`,
+      body: input,
+      auth: authCtx
+    }),
+    /** Deletes a payment-mode configuration. */
+    delete: async (id, authCtx = SERVICE) => {
+      await this.ctx.http.request({
+        method: "DELETE",
+        path: `/payment-gateway/${this.ctx.tenant}/paymentmodes/config/${id}`,
+        auth: authCtx
+      });
+    }
+  };
+  /**
+   * Backend transaction lifecycle and reads. `authorize` creates the transaction
+   * that `capture`/`refund`/`cancel` then act on. Business failures are reported
+   * in the response body (`successful: false`), not as HTTP errors — always check
+   * `successful`. Defaults to service auth.
+   */
+  transactions = {
+    /** One page of payment transactions. */
+    list: async (params = {}, authCtx = SERVICE) => {
+      const query = {
+        ...params.pageNumber === void 0 ? {} : { pageNumber: params.pageNumber },
+        ...params.pageSize === void 0 ? {} : { pageSize: params.pageSize },
+        ...params.sort === void 0 ? {} : { sort: params.sort }
+      };
+      return this.ctx.http.request({
+        method: "GET",
+        path: `/payment-gateway/${this.ctx.tenant}/transactions`,
+        ...Object.keys(query).length > 0 ? { query } : {},
+        auth: authCtx
+      });
+    },
+    /** Retrieves one payment transaction by id. */
+    get: async (transactionId, authCtx = SERVICE) => this.ctx.http.request({
+      method: "GET",
+      path: `/payment-gateway/${this.ctx.tenant}/transactions/${transactionId}`,
+      auth: authCtx
+    }),
+    /**
+     * Authorizes a payment as a backend caller (`POST /payment/authorize`). The
+     * storefront equivalent is {@link PaymentGatewayService.authorize}, which
+     * targets `/payment/frontend/authorize` with a customer token.
+     */
+    authorize: async (input, authCtx = SERVICE) => this.ctx.http.request({
+      method: "POST",
+      path: `/payment-gateway/${this.ctx.tenant}/payment/authorize`,
+      body: input,
+      auth: authCtx
+    }),
+    /**
+     * Captures an authorized payment. Omit `input` to capture the full
+     * authorized amount. Returns the provider's `captureId` on success.
+     */
+    capture: async (transactionId, input, authCtx = SERVICE) => this.ctx.http.request({
+      method: "POST",
+      path: `/payment-gateway/${this.ctx.tenant}/payment/${transactionId}/capture`,
+      ...input === void 0 ? {} : { body: input },
+      auth: authCtx
+    }),
+    /**
+     * Refunds a captured payment. Omit `input` to refund the full captured
+     * amount; pass `captureId` when several captures exist for the payment.
+     */
+    refund: async (transactionId, input, authCtx = SERVICE) => this.ctx.http.request({
+      method: "POST",
+      path: `/payment-gateway/${this.ctx.tenant}/payment/${transactionId}/refund`,
+      ...input === void 0 ? {} : { body: input },
+      auth: authCtx
+    }),
+    /** Cancels an authorized payment. Takes no body. */
+    cancel: async (transactionId, authCtx = SERVICE) => this.ctx.http.request({
+      method: "POST",
+      path: `/payment-gateway/${this.ctx.tenant}/payment/${transactionId}/cancel`,
+      auth: authCtx
+    })
+  };
 };
 
 export { CustomerRefreshRegistry, DefaultTokenProvider, PaymentGatewayService, auth, resolveToken };
-//# sourceMappingURL=chunk-PYLWZZC4.js.map
-//# sourceMappingURL=chunk-PYLWZZC4.js.map
+//# sourceMappingURL=chunk-6PJFOX3A.js.map
+//# sourceMappingURL=chunk-6PJFOX3A.js.map