@epcc-sdk/rule-promotions 0.0.1

package/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) Elastic Path Software Inc
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

package/README.md

@@ -0,0 +1,244 @@
+# @epcc-sdk/rule-promotions SDK
+
+Below you’ll find instructions on how to install, set up, and use the client, along with a list of available operations.
+
+## Features
+
+- type-safe response data and errors
+- response data validation and transformation
+- access to the original request and response
+- granular request and response customization options
+- minimal learning curve thanks to extending the underlying technology
+
+---
+
+## Installation
+
+```bash
+npm install @epcc-sdk/rule-promotions
+# or
+pnpm install @epcc-sdk/rule-promotions
+# or
+yarn add @epcc-sdk/rule-promotions
+```
+
+---
+
+## Client Usage
+
+
+Clients are responsible for sending the actual HTTP requests.
+
+The Fetch client is built as a thin wrapper on top of Fetch API, extending its functionality. If you're already familiar with Fetch, configuring your client will feel like working directly with Fetch API.
+
+You can configure the client in two ways:
+
+- Configuring the internal `client` instance directly
+- Using the `createClient` function
+
+**When using the operation function to make requests, by default the global client will be used unless another is provided.**
+
+
+### 1. Configure the internal `client` instance directly
+
+This is the simpler approach. You can call the setConfig() method at the beginning of your application or anytime you need to update the client configuration. You can pass any Fetch API configuration option to setConfig(), and even your own Fetch implementation.
+
+```ts
+import { client } from "@epcc-sdk/rule-promotions";
+
+client.setConfig({
+// set default base url for requests
+baseUrl: 'https://euwest.api.elasticpath.com',
+
+// set default headers for requests
+headers: {
+Authorization: 'Bearer YOUR_AUTH_TOKEN',
+},
+});
+```
+
+The disadvantage of this approach is that your code may call the client instance before it's configured for the first time. Depending on your use case, you might need to use the second approach.
+
+### 2. Using the `createClient` function
+
+This is useful when you want to use a different instance of the client for different parts of your application or when you want to use different configurations for different parts of your application.
+
+```ts
+import { createClient } from "@epcc-sdk/rule-promotions";
+
+// Create the client with your API base URL.
+const client = createClient({
+    // set default base url for requests
+    baseUrl: "https://euwest.api.elasticpath.com",
+    /**
+    * Set default headers only for requests made by this client.
+    */
+    headers: {
+        "Custom-Header": 'My Value',
+    },
+});
+```
+
+You can also pass this instance to any SDK function through the client option. This will override the default instance from `import { client } from "@epcc-sdk/rule-promotions>".
+
+```ts
+const response = await getRulePromotions({
+    client: myClient,
+});
+```
+
+### Direct configuration
+
+Alternatively, you can pass the client configuration options to each SDK function. This is useful if you don't want to create a client instance for one-off use cases.
+
+```ts
+const response = await getRulePromotions({
+    baseUrl: 'https://example.com', // <-- override default configuration
+});
+```
+
+## Interceptors (Middleware)
+
+Interceptors (middleware) can be used to modify requests before they're sent or responses before they're returned to your application. They can be added with use and removed with eject. Below is an example request interceptor
+
+```ts
+import { client } from "@epcc-sdk/rule-promotions";
+
+// Supports async functions
+client.interceptors.request.use(async (request) => {
+    // do something
+    return request;
+});
+
+client.interceptors.request.eject((request) => {
+    // do something
+    return request;
+});
+
+```
+
+and an example response interceptor
+
+```ts
+import { client } from "@epcc-sdk/rule-promotions";
+
+client.interceptors.response.use((response) => {
+    // do something
+    return response;
+});
+
+client.interceptors.response.eject((response) => {
+    // do something
+    return response;
+});
+```
+
+> **_Tip:_** To eject, you must provide a reference to the function that was passed to use().
+
+## Authentication
+
+We are working to provide helpers to handle auth easier for you but for now using an interceptor is the easiest method.
+
+```ts
+import { client } from "@epcc-sdk/rule-promotions";
+
+client.interceptors.request.use((request, options) => {
+  request.headers.set('Authorization', 'Bearer MY_TOKEN');
+  return request;
+});
+```
+
+## Build URL
+
+If you need to access the compiled URL, you can use the buildUrl() method. It's loosely typed by default to accept almost any value; in practice, you will want to pass a type hint.
+
+```ts
+type FooData = {
+  path: {
+    fooId: number;
+  };
+  query?: {
+    bar?: string;
+  };
+  url: '/foo/{fooId}';
+};
+
+const url = client.buildUrl<FooData>({
+  path: {
+    fooId: 1,
+  },
+  query: {
+    bar: 'baz',
+  },
+  url: '/foo/{fooId}',
+});
+console.log(url); // prints '/foo/1?bar=baz'
+```
+
+
+---
+
+
+
+
+
+## Operation Usage
+The following examples demonstrate how to use the operation function to make requests.
+
+```ts
+import { getRulePromotions } from "@epcc-sdk/rule-promotions";
+
+const product = await getRulePromotions({
+  // client: localClient, // optional if you have a client instance you want to use otherwise the global client will be used
+  path: {
+    ...
+  },
+  query: {
+    ...
+  },
+});
+```
+
+---
+
+
+
+## Available Operations
+
+
+
+- **`getRulePromotions`** (`GET /v2/rule-promotions`)
+
+- **`createRulePromotion`** (`POST /v2/rule-promotions`)
+
+- **`deleteRulePromotion`** (`DELETE /v2/rule-promotions/{promotionID}`)
+
+- **`getRulePromotionById`** (`GET /v2/rule-promotions/{promotionID}`)
+
+- **`updateRulePromotion`** (`PUT /v2/rule-promotions/{promotionID}`)
+
+- **`deleteRulePromotionCodes`** (`DELETE /v2/rule-promotions/{promotionID}/codes`)
+
+- **`getRulePromotionCodes`** (`GET /v2/rule-promotions/{promotionID}/codes`)
+
+- **`createRulePromotionCodes`** (`POST /v2/rule-promotions/{promotionID}/codes`)
+
+- **`deleteSingleRulePromotionCode`** (`DELETE /v2/rule-promotions/{promotionID}/codes/{codeID}`)
+
+- **`getV2RulePromotionsByUuidJobs`** (`GET /v2/rule-promotions/{uuid}/jobs`)
+
+- **`postV2RulePromotionsByUuidJobs`** (`POST /v2/rule-promotions/{uuid}/jobs`)
+
+- **`getV2RulePromotionsByUuidJobsByJobUuidFile`** (`GET /v2/rule-promotions/{uuid}/jobs/{job-uuid}/file`)
+
+- **`postV2RulePromotionsByUuidJobsByJobUuidCancel`** (`POST /v2/rule-promotions/{uuid}/jobs/{job-uuid}/cancel`)
+
+- **`anonymizeRulePromotionUsages`** (`POST /v2/rule-promotions/usages/anonymize`)
+
+- **`getRulePromotionUsages`** (`GET /v2/rule-promotions/{promotionID}/usages`)
+
+- **`getRulePromotionCodeUsages`** (`GET /v2/rule-promotions/{promotionID}/codes/{code}/usages`)
+
+
+
+---

package/dist/client/index.d.ts

@@ -0,0 +1,2 @@
+export * from "./types.gen";
+export * from "./sdk.gen";

package/dist/client/index.js

@@ -0,0 +1,3 @@
+// This file is auto-generated by @hey-api/openapi-ts
+export * from "./types.gen";
+export * from "./sdk.gen";

package/dist/client/sdk.gen.d.ts

@@ -0,0 +1,263 @@
+import { type Options } from "@hey-api/client-fetch";
+import type { GetRulePromotionsData, CreateRulePromotionData, DeleteRulePromotionData, GetRulePromotionByIdData, UpdateRulePromotionData, DeleteRulePromotionCodesData, GetRulePromotionCodesData, CreateRulePromotionCodesData, CreateRulePromotionCodesError, DeleteSingleRulePromotionCodeData, GetV2RulePromotionsByUuidJobsData, PostV2RulePromotionsByUuidJobsData, GetV2RulePromotionsByUuidJobsByJobUuidFileData, PostV2RulePromotionsByUuidJobsByJobUuidCancelData, AnonymizeRulePromotionUsagesData, GetRulePromotionUsagesData, GetRulePromotionCodeUsagesData } from "./types.gen";
+export declare const client: import("@hey-api/client-fetch").Client<Request, Response, unknown, import("@hey-api/client-fetch").RequestOptions<boolean, string>>;
+/**
+ * Get Rule Promotions
+ * Retrieves a list of rule-based promotions, including information such as discount type, eligibility criteria,
+ * and configuration details. This endpoint supports filtering to refine results based on specific promotion attributes.
+ *
+ * Use query parameters to filter promotions by:
+ * - **Code** – Retrieve a specific promotion by its code.
+ * - **Promotion name** – Search for promotions by name.
+ * - **Activation status** – Filter by whether a promotion is active or not.
+ * - **Stackability** – Identify promotions that can or cannot be combined with others.
+ * - **Start and end dates** – Retrieve promotions based on their validity periods.
+ *
+ */
+export declare const getRulePromotions: <ThrowOnError extends boolean = false>(options: Options<GetRulePromotionsData, ThrowOnError>) => import("@hey-api/client-fetch").RequestResult<import("./types.gen").RulePromotionResponse[], unknown, ThrowOnError>;
+/**
+ * Create a Rule Promotion
+ * Creates a new rule-based promotion, allowing flexible discount strategies based on cart or item conditions.
+ * Promotions can apply fixed or percentage-based discounts, apply automatically or via codes, and have eligibility rules
+ * based on product attributes, cart total, SKU conditions, custom attributes, and more.
+ *
+ * This endpoint supports a variety of promotion types, such as:
+ * - **Cart-wide discounts**
+ * - **Item-specific discounts**
+ * - **Shipping discounts**
+ * - **Combinations thereof**
+ *
+ * :::note
+ *
+ * The minimum item discount amount is zero, both for amounts and percentages
+ *
+ * :::
+ *
+ * Please refer to the **OpenAPI examples** section on this page for detailed request payloads illustrating different
+ * promotion structures, including cart discounts, item discounts, and rule-based conditions.
+ *
+ */
+export declare const createRulePromotion: <ThrowOnError extends boolean = false>(options: Options<CreateRulePromotionData, ThrowOnError>) => import("@hey-api/client-fetch").RequestResult<import("./types.gen").RulePromotionResponse, unknown, ThrowOnError>;
+/**
+ * Delete a Rule Promotion
+ * Deletes an existing Rule Promotion identified by its promotion ID.
+ *
+ * - This action **permanently removes** the promotion and cannot be undone.
+ * - If the promotion is active, please ensure that its removal does not impact ongoing campaigns.
+ *
+ * A successful request returns a `204 No Content` response, indicating that the promotion has been deleted.
+ *
+ */
+export declare const deleteRulePromotion: <ThrowOnError extends boolean = false>(options: Options<DeleteRulePromotionData, ThrowOnError>) => import("@hey-api/client-fetch").RequestResult<void, unknown, ThrowOnError>;
+/**
+ * Get a Rule Promotion by ID
+ * Retrieves a single Rule Promotion by the promotion ID. Responses include promotion specifications such as discount type, eligibility criteria, and configuration details.
+ *
+ */
+export declare const getRulePromotionById: <ThrowOnError extends boolean = false>(options: Options<GetRulePromotionByIdData, ThrowOnError>) => import("@hey-api/client-fetch").RequestResult<import("./types.gen").RulePromotionResponse, unknown, ThrowOnError>;
+/**
+ * Update a Rule Promotion
+ * Updates an existing Rule Promotion specified by its promotion ID. This includes both **semantic and syntactic validation** to ensure correctness. For example, the start date must be earlier than the end date.
+ *
+ * Editable fields include:
+ * - `name`
+ * - `description`
+ * - `enabled`
+ * - `start`
+ * - `end`
+ * - `automatic`
+ * - `stackable`
+ * - `override_stacking`
+ * - `rule_set`
+ *
+ * Please refer to the **OpenAPI examples** section on this page for sample update requests.
+ *
+ */
+export declare const updateRulePromotion: <ThrowOnError extends boolean = false>(options: Options<UpdateRulePromotionData, ThrowOnError>) => import("@hey-api/client-fetch").RequestResult<import("./types.gen").RulePromotionResponse, unknown, ThrowOnError>;
+/**
+ * Delete Rule Promotion Codes
+ * Deletes one or more promotion codes from a specific rule promotion.
+ *
+ * - Supports **bulk deletion**, allowing multiple codes to be removed in a single request.
+ * - Removes promotion codes permanently, making them unavailable for future use.
+ * - If a code has already been redeemed, it will be removed from the system but may still reflect in historical transactions.
+ *
+ * A successful request returns a `204 No Content` response, indicating the specified promotion codes have been deleted.
+ *
+ */
+export declare const deleteRulePromotionCodes: <ThrowOnError extends boolean = false>(options: Options<DeleteRulePromotionCodesData, ThrowOnError>) => import("@hey-api/client-fetch").RequestResult<void, unknown, ThrowOnError>;
+/**
+ * Get Rule Promotion Codes
+ * Retrieves the list of promotion codes associated with a specific Rule Promotion.
+ *
+ * - Returns all codes generated for the given promotion ID, including details on usage limits and redemption status.
+ * - Supports both automatically generated and manually created promotion codes.
+ * - Can be used to verify whether a promotion code is still valid or has reached its usage limit.
+ *
+ */
+export declare const getRulePromotionCodes: <ThrowOnError extends boolean = false>(options: Options<GetRulePromotionCodesData, ThrowOnError>) => import("@hey-api/client-fetch").RequestResult<import("./types.gen").GetPromotionCodesResponse, unknown, ThrowOnError>;
+/**
+ * Create Rule Promotion Codes
+ * Creates new promotion codes for a specific rule promotion, allowing customers to redeem discounts based on predefined conditions.
+ *
+ * - Supports  bulk creation of multiple promotion codes in a single request.
+ * - Each code can have individual usage limits.
+ * - Can optionally assign codes to specific users to enforce targeted promotions.
+ * - The promotion codes are case-insensitive.
+ *
+ * :::note
+ *
+ * Regarding first time shopper limitations:
+ * - Orders without payment transactions do not count as completed purchases.
+ * - Canceling or refunding an order does not reinstate first-time shopper status.
+ * - A first-time shopper coupon code cannot have limited uses or be assigned to specific users, meaning the code cannot be restricted by the number of times it can be used or tied to a specific customer ID.
+ *
+ * :::
+ *
+ * A successful request returns a `201 Created` response with details of the generated promotion codes.
+ *
+ * ### Duplicate Codes
+ * Duplicate promotion codes **are supported across different promotions** in the store, regardless of their statuses and validity dates. However, **duplicate codes cannot be created within the same promotion**.
+ * This means that shoppers can apply a single coupon code to trigger multiple promotions if those promotions share common coupon codes.
+ *
+ * Codes that share the same name can serve different purposes.  For example, one code may have `per_application` with a limited number of uses, while another identical code can have `per_checkout` with unlimited use.
+ *
+ * **Duplicate Code Handling:**
+ * - If a duplicate code is detected **within the same promotion**, the request will return a `422 Duplicate code` error.
+ * - When creating duplicate codes, a message appears with the successful response indicating the duplication.
+ *
+ *
+ * Please refer to the **OpenAPI examples** section on this page for sample request structures.
+ *
+ */
+export declare const createRulePromotionCodes: <ThrowOnError extends boolean = false>(options: Options<CreateRulePromotionCodesData, ThrowOnError>) => import("@hey-api/client-fetch").RequestResult<import("./types.gen").CreatePromotionCodesResponse, CreateRulePromotionCodesError, ThrowOnError>;
+/**
+ * Delete A Single Rule Promotion Code
+ * Deletes a single promotion code from a specific rule promotion.
+ *
+ * - Permanently removes the specified promotion code, making it unavailable for future use.
+ * - Can be used to **revoke a specific code** without affecting other codes under the same promotion.
+ * - If the code has already been redeemed, it will still be removed from the system but may still reflect in historical transactions.
+ *
+ * A successful request returns a `204 No Content` response, indicating the specified promotion code has been deleted.
+ *
+ */
+export declare const deleteSingleRulePromotionCode: <ThrowOnError extends boolean = false>(options: Options<DeleteSingleRulePromotionCodeData, ThrowOnError>) => import("@hey-api/client-fetch").RequestResult<void, unknown, ThrowOnError>;
+/**
+ * Get Rule Promotion Jobs
+ * Retrieves a list of jobs associated with a specific rule promotion. Each job represents an asynchronous operation such as promotion code generation or export.
+ *
+ * The response includes details such as:
+ * - **Job type** (`code_generate` or `code_export`)
+ * - **Job status** (`pending`, `processing`, `completed`, `failed`, `cancelling`, or `cancelled`)
+ * - **Parameters used** (such as number of codes generated)
+ * - **Results** (such as number of codes successfully generated or deleted)
+ *
+ * ### Filtering
+ * You can filter jobs by:
+ * - **Job Type** (`eq(job_type, code_export)`)
+ * - **Status** (`eq(status, complete)`)
+ *
+ */
+export declare const getV2RulePromotionsByUuidJobs: <ThrowOnError extends boolean = false>(options: Options<GetV2RulePromotionsByUuidJobsData, ThrowOnError>) => import("@hey-api/client-fetch").RequestResult<{
+    data?: Array<import("./types.gen").PromotionJob>;
+}, unknown, ThrowOnError>;
+/**
+ * Create a Rule Promotion Job
+ * Creates an asynchronous job for a specific Rule Promotion. Jobs are used to generate or export promotion codes in bulk.
+ *
+ * The following job types are supported:
+ * - **`code_generate`**: Generates a batch of unique promotion codes.
+ * - **`code_export`**: Exports all existing promotion codes as a downloadable CSV file.
+ *
+ * Job processing occurs asynchronously. The job request is queued, and its status must be checked separately.
+ *
+ * ### Job Processing Status
+ * Jobs can have the following statuses:
+ * - `pending`: Job is in the queue, waiting to be processed.
+ * - `processing`: Job is actively being processed.
+ * - `completed`: Job completed successfully.
+ * - `failed`: Job encountered an error and did not complete.
+ * - `cancelling`: Cancellation in progress (for long-running jobs).
+ * - `cancelled`: Job was successfully cancelled.
+ *
+ * Please refer to the **OpenAPI examples** section on this page for sample job creation requests.
+ *
+ */
+export declare const postV2RulePromotionsByUuidJobs: <ThrowOnError extends boolean = false>(options: Options<PostV2RulePromotionsByUuidJobsData, ThrowOnError>) => import("@hey-api/client-fetch").RequestResult<{
+    data?: import("./types.gen").PromotionJob;
+}, {
+    errors?: Array<{
+        status?: string;
+        title?: string;
+        detail?: string;
+    }>;
+}, ThrowOnError>;
+/**
+ * Get Rule Promotion Code Exported File
+ * Retrieves the exported promotion codes for a rule promotion job in a CSV format.
+ *
+ * - The file contains the generated codes along with relevant metadata.
+ * - This endpoint is applicable only for jobs of type `code_export`.
+ * - The job must be in a `completed` state before the file can be retrieved.
+ *
+ */
+export declare const getV2RulePromotionsByUuidJobsByJobUuidFile: <ThrowOnError extends boolean = false>(options: Options<GetV2RulePromotionsByUuidJobsByJobUuidFileData, ThrowOnError>) => import("@hey-api/client-fetch").RequestResult<{
+    href?: string;
+}, unknown, ThrowOnError>;
+/**
+ * Cancel a Rule Promotion Job
+ * Cancels an asynchronous job for a rule promotion if its status is `pending` or `processing`.
+ *
+ * - Only jobs that have not yet completed can be canceled.
+ * - Once canceled, no further processing occurs, and partially completed results may be deleted.
+ *
+ */
+export declare const postV2RulePromotionsByUuidJobsByJobUuidCancel: <ThrowOnError extends boolean = false>(options: Options<PostV2RulePromotionsByUuidJobsByJobUuidCancelData, ThrowOnError>) => import("@hey-api/client-fetch").RequestResult<unknown, {
+    errors?: Array<{
+        status?: string;
+        title?: string;
+        detail?: string;
+    }>;
+}, ThrowOnError>;
+/**
+ * Anonymize Rule Promotion Usages
+ * Anonymizes user-related data in Rule Promotion usage records.
+ * This operation is typically used for GDPR compliance or privacy-related requests.
+ *
+ * - This process replaces identifiable user data with anonymized placeholders.
+ * - Affects all recorded promotion usages where customer data is stored.
+ * - Does not impact historical transaction records or applied discounts.
+ *
+ * A successful request returns a `200 OK` response with the anonymized usage records.
+ *
+ */
+export declare const anonymizeRulePromotionUsages: <ThrowOnError extends boolean = false>(options: Options<AnonymizeRulePromotionUsagesData, ThrowOnError>) => import("@hey-api/client-fetch").RequestResult<{
+    data?: Array<import("./types.gen").RulePromotionUsage>;
+}, import("./types.gen").ResponseError, ThrowOnError>;
+/**
+ * Get Rule Promotion Usages
+ * Retrieves a list of usage records for a specific Rule Promotion.
+ *
+ * - Provides details about when and how a promotion was used.
+ * - Can be filtered and paginated to refine results.
+ * - Useful for analyzing promotion effectiveness and customer engagement.
+ *
+ */
+export declare const getRulePromotionUsages: <ThrowOnError extends boolean = false>(options: Options<GetRulePromotionUsagesData, ThrowOnError>) => import("@hey-api/client-fetch").RequestResult<{
+    data?: Array<import("./types.gen").RulePromotionUsage>;
+    meta?: import("./types.gen").ResponsePaginationMeta;
+}, import("./types.gen").ResponseError, ThrowOnError>;
+/**
+ * Get Rule Promotion Code Usages
+ * Retrieves a list of usage records for a specific Rule Promotion code.
+ *
+ * - Provides insights into how many times a specific code was used.
+ * - Can be filtered and paginated to refine results.
+ * - Useful for tracking the performance of individual promotion codes.
+ *
+ */
+export declare const getRulePromotionCodeUsages: <ThrowOnError extends boolean = false>(options: Options<GetRulePromotionCodeUsagesData, ThrowOnError>) => import("@hey-api/client-fetch").RequestResult<{
+    data?: Array<import("./types.gen").RulePromotionUsage>;
+    meta?: import("./types.gen").ResponsePaginationMeta;
+}, import("./types.gen").ResponseError, ThrowOnError>;