Stigg

https://docs.stigg.io/
Admin
Stigg is a system that offers APIs and SDKs for integration into various applications, providing...
Tokens:589,184
Snippets:4,402
Trust Score:8
Update:1 month ago
Show doc for...
Tokens:
Raw
### stiggt init

Source: https://docs.stigg.io/api-and-sdks/ai-terminal

Runs the full setup process including authentication, writing MCP configurations, and installing skills. Can be run interactively or in headless mode.

```APIDOC
## stiggt init

### Description
Runs the full setup: authenticate, write MCP, and install skills. Interactive by default; add `--headless` to run without the TUI.

### Parameters
- **--headless** (flag) - Optional - Run without the interactive TUI.
- **--force-login** (flag) - Optional - Re-authenticate even if a valid session is cached.
- **--callback-port** (port) - Optional - Loopback port for the OAuth callback.
- **--account-id** (id) - Optional - Account ID for phase 2 setup.
- **--environment-id** (id) - Optional - Environment ID for phase 2 setup.
- **--api-key-id** (id) - Optional - API key ID for phase 2 setup.
- **-c, --client** (id) - Optional - Limit to specific client(s); repeatable.
- **--all** (flag) - Optional - Target every detected client.
- **--no-skills** (flag) - Optional - Skip installing skills.
- **--json** (flag) - Optional - Emit a single JSON object on stdout.
```

--------------------------------

### Install Stigg Go SDK

Source: https://docs.stigg.io/api-and-sdks/integration/backend/go

Use the go get command to add the Stigg SDK as a dependency to your project.

```shell
go get github.com/stiggio/api-client-go/v5
```

--------------------------------

### Provision Subscription SDK Examples

Source: https://docs.stigg.io/api-and-sdks/api-reference/rest/subscriptions-create

Examples for provisioning a subscription using the Stigg SDKs.

```javascript
import Stigg from '@stigg/typescript';

const client = new Stigg({
  apiKey: process.env['STIGG_API_KEY'], // This is the default and can be omitted
});

const response = await client.v1.subscriptions.provision({
  customerId: 'customerId',
  planId: 'planId',
});

console.log(response.data);
```

```python
import os
from stigg import Stigg
```

--------------------------------

### Preview Subscription Examples

Source: https://docs.stigg.io/api-and-sdks/api-reference/rest/subscriptions-preview

Examples demonstrating how to preview a subscription using different SDKs and the CLI.

```Python
client = Stigg(
    api_key=os.environ.get("STIGG_API_KEY"),  # This is the default and can be omitted
)
response = client.v1.subscriptions.preview(
    customer_id="customerId",
    plan_id="planId",
)
print(response.data)
```

```Go
package main

import (
	"context"
	"fmt"

	"github.com/stiggio/stigg-go"
	"github.com/stiggio/stigg-go/option"
)

func main() {
	client := stigg.NewClient(
		option.WithAPIKey("My API Key"),
	)
	response, err := client.V1.Subscriptions.Preview(context.TODO(), stigg.V1SubscriptionPreviewParams{
		CustomerID: "customerId",
		PlanID:     "planId",
	})
	if err != nil {
		panic(err.Error())
	}
	fmt.Printf("%+v\n", response.Data)
}
```

```Java
package io.stigg.example;

import io.stigg.client.StiggClient;
import io.stigg.client.okhttp.StiggOkHttpClient;
import io.stigg.models.v1.subscriptions.SubscriptionPreviewParams;
import io.stigg.models.v1.subscriptions.SubscriptionPreviewResponse;

public final class Main {
    private Main() {}

    public static void main(String[] args) {
        StiggClient client = StiggOkHttpClient.fromEnv();

        SubscriptionPreviewParams params = SubscriptionPreviewParams.builder()
            .customerId("customerId")
            .planId("planId")
            .build();
        SubscriptionPreviewResponse response = client.v1().subscriptions().preview(params);
    }
}
```

```Ruby
require "stigg"


stigg = Stigg::Client.new(api_key: "My API Key")


response = stigg.v1.subscriptions.preview(customer_id: "customerId",
plan_id: "planId")


puts(response)
```

```C#
using System;
using Stigg.Client;
using Stigg.Client.Models.V1.Subscriptions;

StiggClient client = new();

SubscriptionPreviewParams parameters = new()
{
    CustomerID = "customerId",
    PlanID = "planId",
};

var response = await client.V1.Subscriptions.Preview(parameters);

Console.WriteLine(response);
```

```CLI
stigg v1:subscriptions preview \
  --api-key 'My API Key' \
  --customer-id customerId \
  --plan-id planId
```

--------------------------------

### Install the React SDK

Source: https://docs.stigg.io/api-and-sdks/integration/frontend/react

Install the package using npm or yarn.

```shell
npm install @stigg/react-sdk
```

```Text
yarn add @stigg/react-sdk
```

--------------------------------

### Install dependencies

Source: https://docs.stigg.io/documentation/native-integrations/billing/zuora/import-products-from-zuora

Install the necessary project dependencies.

```bash
yarn install
```

--------------------------------

### Preview Subscription SDK Examples

Source: https://docs.stigg.io/api-and-sdks/api-reference/rest/subscriptions-preview

Examples for using the Stigg SDK to preview subscription pricing.

```javascript
import Stigg from '@stigg/typescript';

const client = new Stigg({
  apiKey: process.env['STIGG_API_KEY'], // This is the default and can be omitted
});

const response = await client.v1.subscriptions.preview({
  customerId: 'customerId',
  planId: 'planId',
});

console.log(response.data);
```

```python
import os
from stigg import Stigg
```

--------------------------------

### Create plan entitlements SDK examples

Source: https://docs.stigg.io/api-reference/plan-entitlements/create-plan-entitlements

Examples for creating plan entitlements using the Stigg SDKs.

```javascript
import Stigg from '@stigg/typescript';


const client = new Stigg({
  apiKey: process.env['STIGG_API_KEY'], // This is the default and can be omitted
});


const entitlement = await
client.v1.plans.entitlements.create('planId', {
  entitlements: [{ id: 'id', type: 'FEATURE' }],
});


console.log(entitlement.data);
```

```python
import os
from stigg import Stigg
```

--------------------------------

### Retrieve Subscription SDK Examples

Source: https://docs.stigg.io/api-reference/subscriptions/get-a-single-subscription-by-id

Examples for retrieving a subscription using the Stigg SDK in JavaScript and Python.

```javascript
import Stigg from '@stigg/typescript';

const client = new Stigg({
  apiKey: process.env['STIGG_API_KEY'], // This is the default and can be omitted
});

const subscription = await client.v1.subscriptions.retrieve('x');

console.log(subscription.data);
```

```python
import os
from stigg import Stigg
```

--------------------------------

### Get credit usage

Source: https://docs.stigg.io/guides/i-want-to/set-up-credits

Retrieve credit usage statistics for a customer over a specified time range.

```typescript
await stiggClient.getCreditUsage({
  customerId: 'customer-123',
  resourceId: 'resource-456',
  currencyId: 'currency-789',
  timeRange: 'LAST_MONTH'               // 'LAST_DAY' | 'LAST_WEEK' | 'LAST_MONTH' | 'LAST_YEAR'
});
```

--------------------------------

### Get Customer Result Example

Source: https://docs.stigg.io/api-and-sdks/integration/backend/customers

Example JSON response structure for retrieving customer data.

```json
{
  "id": "customer-demo-01",
  "name": "Test Name",
  "email": "john@example.com",
  "createdAt": "2022-09-20T09:59:22.324Z",
  "updatedAt": "2022-09-20T10:00:32.750Z",
  "hasPaymentMethod": false,
  "promotionalEntitlements": [],
  "metadata": {
    "lorem": "ipsum"
  }
}
```

--------------------------------

### Create Product with Stigg SDKs

Source: https://docs.stigg.io/api-reference/products/create-product

Examples of initializing the Stigg client and creating a product across multiple supported languages.

```JavaScript
const client = new Stigg({
              apiKey: process.env['STIGG_API_KEY'], // This is the default and can be omitted
            });


            const product = await client.v1.products.createProduct({ id: 'id',
            displayName: 'displayName' });


            console.log(product.data);
```

```Python
import os
from stigg import Stigg

client = Stigg(
    api_key=os.environ.get("STIGG_API_KEY"),  # This is the default and can be omitted
)
product = client.v1.products.create_product(
    id="id",
    display_name="displayName",
)
print(product.data)
```

```Go
package main

import (
	"context"
	"fmt"

	"github.com/stiggio/stigg-go"
	"github.com/stiggio/stigg-go/option"
)

func main() {
	client := stigg.NewClient(
		option.WithAPIKey("My API Key"),
	)
	product, err := client.V1.Products.NewProduct(context.TODO(), stigg.V1ProductNewProductParams{
		ID:          "id",
		DisplayName: "displayName",
	})
	if err != nil {
		panic(err.Error())
	}
	fmt.Printf("%+v\n", product.Data)
}
```

```Java
package io.stigg.example;

import io.stigg.client.StiggClient;
import io.stigg.client.okhttp.StiggOkHttpClient;
import io.stigg.models.v1.products.Product;
import io.stigg.models.v1.products.ProductCreateProductParams;

public final class Main {
    private Main() {}

    public static void main(String[] args) {
        StiggClient client = StiggOkHttpClient.fromEnv();

        ProductCreateProductParams params = ProductCreateProductParams.builder()
            .id("id")
            .displayName("displayName")
            .build();
        Product product = client.v1().products().createProduct(params);
    }
}
```

```Ruby
require "stigg"


stigg = Stigg::Client.new(api_key: "My API Key")


product = stigg.v1.products.create_product(id: "id", display_name:
"displayName")


puts(product)
```

```C#
using System;
using Stigg.Client;
using Stigg.Client.Models.V1.Products;

StiggClient client = new();

ProductCreateProductParams parameters = new()
{
    ID = "id",
    DisplayName = "displayName",
};

var product = await client.V1.Products.CreateProduct(parameters);

Console.WriteLine(product);
```

```CLI
stigg v1:products create-product \
  --api-key 'My API Key' \
  --id id \
  --display-name displayName
```

--------------------------------

### Get Assignments API Request

Source: https://docs.stigg.io/api-reference/governance-assignments/get-a-list-of-assignments

Example command-line usage for the assignment retrieval endpoint.

```bash
              --api-key 'My API Key' \
              --id id
```

--------------------------------

### List Plans SDK and CLI Examples

Source: https://docs.stigg.io/api-reference/plans/get-a-list-of-plans

Examples for retrieving a list of plans using different programming languages and the Stigg CLI.

```JavaScript
import Stigg from '@stigg/typescript';

const client = new Stigg({
  apiKey: process.env['STIGG_API_KEY'], // This is the default and can be omitted
});

// Automatically fetches more pages as needed.
for await (const planListResponse of client.v1.plans.list()) {
  console.log(planListResponse.id);
}
```

```Python
import os
from stigg import Stigg

client = Stigg(
    api_key=os.environ.get("STIGG_API_KEY"),  # This is the default and can be omitted
)
page = client.v1.plans.list()
page = page.data[0]
print(page.id)
```

```Go
package main

import (
	"context"
	"fmt"

	"github.com/stiggio/stigg-go"
	"github.com/stiggio/stigg-go/option"
)

func main() {
	client := stigg.NewClient(
		option.WithAPIKey("My API Key"),
	)
	page, err := client.V1.Plans.List(context.TODO(), stigg.V1PlanListParams{})
	if err != nil {
		panic(err.Error())
	}
	fmt.Printf("%+v\n", page)
}
```

```Java
package io.stigg.example;

import io.stigg.client.StiggClient;
import io.stigg.client.okhttp.StiggOkHttpClient;
import io.stigg.models.v1.plans.PlanListPage;
import io.stigg.models.v1.plans.PlanListParams;

public final class Main {
    private Main() {}

    public static void main(String[] args) {
        StiggClient client = StiggOkHttpClient.fromEnv();

        PlanListPage page = client.v1().plans().list();
    }
}
```

```Ruby
require "stigg"

stigg = Stigg::Client.new(api_key: "My API Key")

page = stigg.v1.plans.list

puts(page)
```

```C#
using System;
using Stigg.Client;
using Stigg.Client.Models.V1.Plans;

StiggClient client = new();

PlanListParams parameters = new();

var page = await client.V1.Plans.List(parameters);
await foreach (var item in page.Paginate())
{
    Console.WriteLine(item);
}
```

```CLI
stigg v1:plans list \
  --api-key 'My API Key'
```

--------------------------------

### Get Entitlements State Response

Source: https://docs.stigg.io/api-and-sdks/integration/backend/graphql

Example JSON response containing the list of entitlements and their associated feature metadata and usage status.

```json
{
  "data": {
    "entitlementsState": {
      "entitlements": [
      {
        "feature": {
          "refId": "feature-03-custom-domain",
          "displayName": "Custom domain",
          "featureUnits": null,
          "featureUnitsPlural": null,
          "featureType": "BOOLEAN",
          "meterType": "None",
          "description": null
        },
        "currentUsage": 0,
        "customerId": "96ed6019-031a-4c52-bc41-b8fa3b5d86c5",
        "usageLimit": null,
        "hasUnlimitedUsage": false,
        "usagePeriodAnchor": null,
        "usagePeriodStart": null,
        "usagePeriodEnd": null,
        "resetPeriod": null
      },
      {
        "feature": {
          "refId": "feature-04-analytics",
          "displayName": "Analytics",
          "featureUnits": null,
          "featureUnitsPlural": null,
          "featureType": "BOOLEAN",
          "meterType": "None",
          "description": null
        },
        "currentUsage": 0,
        "customerId": "96ed6019-031a-4c52-bc41-b8fa3b5d86c5",
        "usageLimit": null,
        "hasUnlimitedUsage": false,
        "usagePeriodAnchor": null,
        "usagePeriodStart": null,
        "usagePeriodEnd": null,
        "resetPeriod": null
      },
      {
        "feature": {
          "refId": "feature-01-templates",
          "displayName": "Templates",
          "featureUnits": "Template",
          "featureUnitsPlural": "Templates",
          "featureType": "NUMBER",
          "meterType": "Fluctuating",
          "description": null
        },
        "currentUsage": 3,
        "customerId": "96ed6019-031a-4c52-bc41-b8fa3b5d86c5",
        "usageLimit": 5,
        "hasUnlimitedUsage": false,
        "usagePeriodAnchor": null,
        "usagePeriodStart": null,
        "usagePeriodEnd": null,
        "resetPeriod": null
      },
      {
        "feature": {
          "refId": "feature-02-campaigns",
          "displayName": "Campaigns",
          "featureUnits": "Campaign",
          "featureUnitsPlural": "Campaigns",
          "featureType": "NUMBER",
          "meterType": "Incremental",
          "description": null
        },
        "currentUsage": 10,
        "customerId": "96ed6019-031a-4c52-bc41-b8fa3b5d86c5",
        "usageLimit": 12,
        "hasUnlimitedUsage": false,
        "usagePeriodAnchor": "2022-02-21T00:00:00.000Z",
        "usagePeriodStart": "2022-08-21T00:00:00.000Z",
        "usagePeriodEnd": "2022-09-21T00:00:00.000Z",
        "resetPeriod": "MONTH"
      }
      ],
      "accessDeniedReason": null
    }
  }
}
```

--------------------------------

### Get Plan GraphQL Query and Data

Source: https://docs.stigg.io/api-and-sdks/api-reference/queries/get-plan

The GraphQL query structure, required input variables, and an example response for retrieving plan details.

```graphql
query GetPlan($input: GetPackageByRefIdInput!) {
  getPlanByRefId(input: $input) {
    refId
    displayName
    description
    status
    pricingType
    versionNumber
    basePlan {
      refId
      displayName
    }
    product {
      refId
      displayName
    }
    prices {
      billingModel
      billingPeriod
      billingCadence
      price {
        amount
        currency
      }
      tiers {
        upTo
        unitPrice {
          amount
          currency
        }
      }
    }
    packageEntitlements {
      ... on PackageEntitlement {
        feature {
          refId
          displayName
          featureType
          featureUnits
        }
        hasUnlimitedUsage
        usageLimit
        resetPeriod
      }
    }
    compatibleAddons {
      refId
      displayName
      maxQuantity
    }
    defaultTrialConfig {
      duration
      units
    }
  }
}
```

```json
{
  "input": {
    "refId": "plan-pro"
  }
}
```

```json
{
  "data": {
    "getPlanByRefId": {
      "refId": "plan-pro",
      "displayName": "Pro Plan",
      "description": "For growing teams",
      "status": "PUBLISHED",
      "pricingType": "PAID",
      "versionNumber": 3,
      "basePlan": null,
      "product": {
        "refId": "product-main",
        "displayName": "Main Product"
      },
      "prices": [
        {
          "billingModel": "FLAT_FEE",
          "billingPeriod": "MONTHLY",
          "billingCadence": "RECURRING",
          "price": {
            "amount": 99,
            "currency": "USD"
          },
          "tiers": null
        },
        {
          "billingModel": "FLAT_FEE",
          "billingPeriod": "ANNUAL",
          "billingCadence": "RECURRING",
          "price": {
            "amount": 990,
            "currency": "USD"
          },
          "tiers": null
        }
      ],
      "packageEntitlements": [
        {
          "feature": {
            "refId": "feature-api-calls",
            "displayName": "API Calls",
            "featureType": "NUMBER",
            "featureUnits": "call"
          },
          "hasUnlimitedUsage": false,
          "usageLimit": 10000,
          "resetPeriod": "MONTH"
        },
        {
          "feature": {
            "refId": "feature-sso",
            "displayName": "Single Sign-On",
            "featureType": "BOOLEAN",
            "featureUnits": null
          },
          "hasUnlimitedUsage": false,
          "usageLimit": null,
          "resetPeriod": null
        }
      ],
      "compatibleAddons": [
        {
          "refId": "addon-seats",
          "displayName": "Extra Seats",
          "maxQuantity": 100
        }
      ],
      "defaultTrialConfig": {
        "duration": 14,
        "units": "DAYS"
      }
    }
  }
}
```

--------------------------------

### Link Customer Integration Examples

Source: https://docs.stigg.io/api-reference/customer-integrations/link-customer-integration

Examples demonstrating how to link a customer to an integration using different SDKs and the CLI.

```Python
client = Stigg(
    api_key=os.environ.get("STIGG_API_KEY"),  # This is the default and can be omitted
)

customer_integration_response =
client.v1.customers.integrations.link(
    path_id="x",
    body_id="id",
    synced_entity_id="syncedEntityId",
    vendor_identifier="AUTH0",
)

print(customer_integration_response.data)
```

```Go
package main

import (
	"context"
	"fmt"

	"github.com/stiggio/stigg-go"
	"github.com/stiggio/stigg-go/option"
)

func main() {
	client := stigg.NewClient(
		option.WithAPIKey("My API Key"),
	)
	customerIntegrationResponse, err := client.V1.Customers.Integrations.Link(
		context.TODO(),
		"x",
		stigg.V1CustomerIntegrationLinkParams{
			ID:               "id",
			SyncedEntityID:   "syncedEntityId",
			VendorIdentifier: stigg.V1CustomerIntegrationLinkParamsVendorIdentifierAuth0,
		},
	)
	if err != nil {
		panic(err.Error())
	}
	fmt.Printf("%+v\n", customerIntegrationResponse.Data)
}
```

```Java
package io.stigg.example;


import io.stigg.client.StiggClient;

import io.stigg.client.okhttp.StiggOkHttpClient;

import io.stigg.models.v1.customers.CustomerIntegrationResponse;

import
io.stigg.models.v1.customers.integrations.IntegrationLinkParams;


public final class Main {
    private Main() {}

    public static void main(String[] args) {
        StiggClient client = StiggOkHttpClient.fromEnv();

        IntegrationLinkParams params = IntegrationLinkParams.builder()
            .pathId("x")
            .bodyId("id")
            .syncedEntityId("syncedEntityId")
            .vendorIdentifier(IntegrationLinkParams.VendorIdentifier.AUTH0)
            .build();
        CustomerIntegrationResponse customerIntegrationResponse = client.v1().customers().integrations().link(params);
    }
}
```

```Ruby
require "stigg"


stigg = Stigg::Client.new(api_key: "My API Key")


customer_integration_response =
stigg.v1.customers.integrations.link(
  "x",
  body_id: "id",
  synced_entity_id: "syncedEntityId",
  vendor_identifier: :AUTH0
)


puts(customer_integration_response)
```

```C#
using System;

using Stigg.Client;

using Stigg.Client.Models.V1.Customers.Integrations;


StiggClient client = new();


IntegrationLinkParams parameters = new()

{
    ID = "x",
    IDValue = "id",
    SyncedEntityID = "syncedEntityId",
    VendorIdentifier = IntegrationLinkParamsVendorIdentifier.Auth0,
};


var customerIntegrationResponse = await
client.V1.Customers.Integrations.Link(parameters);


Console.WriteLine(customerIntegrationResponse);
```

```CLI
stigg v1:customers:integrations link \
  --api-key 'My API Key' \
  --id x \
  --id id \
  --synced-entity-id syncedEntityId \
  --vendor-identifier AUTH0
```

--------------------------------

### Get Automatic Recharge Configuration via SDKs and CLI

Source: https://docs.stigg.io/api-reference/auto-recharge/get-automatic-recharge-configuration

Examples for retrieving automatic recharge settings across various programming languages and the Stigg CLI.

```JavaScript
const client = new Stigg({
  apiKey: process.env['STIGG_API_KEY'], // This is the default and can be omitted
});

const response = await client.v1.credits.getAutoRecharge({
  currencyId: 'currencyId',
  customerId: 'customerId',
});

console.log(response.data);
```

```Python
import os
from stigg import Stigg

client = Stigg(
    api_key=os.environ.get("STIGG_API_KEY"),  # This is the default and can be omitted
)
response = client.v1.credits.get_auto_recharge(
    currency_id="currencyId",
    customer_id="customerId",
)
print(response.data)
```

```Go
package main

import (
	"context"
	"fmt"

	"github.com/stiggio/stigg-go"
	"github.com/stiggio/stigg-go/option"
)

func main() {
	client := stigg.NewClient(
		option.WithAPIKey("My API Key"),
	)
	response, err := client.V1.Credits.GetAutoRecharge(context.TODO(), stigg.V1CreditGetAutoRechargeParams{
		CurrencyID: "currencyId",
		CustomerID: "customerId",
	})
	if err != nil {
		panic(err.Error())
	}
	fmt.Printf("%+v\n", response.Data)
}
```

```Java
package io.stigg.example;

import io.stigg.client.StiggClient;
import io.stigg.client.okhttp.StiggOkHttpClient;
import io.stigg.models.v1.credits.CreditGetAutoRechargeParams;
import io.stigg.models.v1.credits.CreditGetAutoRechargeResponse;

public final class Main {
    private Main() {}

    public static void main(String[] args) {
        StiggClient client = StiggOkHttpClient.fromEnv();

        CreditGetAutoRechargeParams params = CreditGetAutoRechargeParams.builder()
            .currencyId("currencyId")
            .customerId("customerId")
            .build();
        CreditGetAutoRechargeResponse response = client.v1().credits().getAutoRecharge(params);
    }
}
```

```Ruby
require "stigg"


stigg = Stigg::Client.new(api_key: "My API Key")


response = stigg.v1.credits.get_auto_recharge(currency_id:
"currencyId", customer_id: "customerId")


puts(response)
```

```C#
using System;
using Stigg.Client;
using Stigg.Client.Models.V1.Credits;

StiggClient client = new();

CreditGetAutoRechargeParams parameters = new()
{
    CurrencyID = "currencyId",
    CustomerID = "customerId",
};

var response = await client.V1.Credits.GetAutoRecharge(parameters);

Console.WriteLine(response);
```

```CLI
stigg v1:credits get-auto-recharge \
  --api-key 'My API Key' \
  --currency-id currencyId \
  --customer-id customerId
```

--------------------------------

### Configure environment and credentials

Source: https://docs.stigg.io/documentation/native-integrations/billing/zuora/import-products-from-zuora

Setup the environment file and define required credentials and Zuora product IDs.

```bash
cp .env.example .env
```

```bash
X_API_KEY=your-stigg-api-server-key
ENVIRONMENT_ID=your-stigg-environment-id
ZUORA_PRODUCT_IDS=zuoraProductId1,zuoraProductId2
```

--------------------------------

### Get Addon GraphQL Query and Response

Source: https://docs.stigg.io/api-and-sdks/api-reference/queries/get-addon

Use this GraphQL query to fetch addon details. The variables and response examples illustrate the required input and expected output format.

```graphql
query GetAddon($input: GetPackageByRefIdInput!) {
  getAddonByRefId(input: $input) {
    refId
    displayName
    description
    status
    pricingType
    maxQuantity
    versionNumber
    product {
      refId
      displayName
    }
    prices {
      billingModel
      billingPeriod
      price {
        amount
        currency
      }
    }
    packageEntitlements {
      ... on PackageEntitlement {
        feature {
          refId
          displayName
          featureType
        }
        hasUnlimitedUsage
        usageLimit
      }
    }
    dependencies {
      refId
      displayName
    }
  }
}
```

```json
{
  "input": {
    "refId": "addon-extra-seats"
  }
}
```

```json
{
  "data": {
    "getAddonByRefId": {
      "refId": "addon-extra-seats",
      "displayName": "Extra Seats",
      "description": "Add more team members to your workspace",
      "status": "PUBLISHED",
      "pricingType": "PAID",
      "maxQuantity": 100,
      "versionNumber": 2,
      "product": {
        "refId": "product-main",
        "displayName": "Main Product"
      },
      "prices": [
        {
          "billingModel": "FLAT_FEE",
          "billingPeriod": "MONTHLY",
          "price": {
            "amount": 10,
            "currency": "USD"
          }
        }
      ],
      "packageEntitlements": [
        {
          "feature": {
            "refId": "feature-seats",
            "displayName": "Team Seats",
            "featureType": "NUMBER"
          },
          "hasUnlimitedUsage": false,
          "usageLimit": 1
        }
      ],
      "dependencies": []
    }
  }
}
```

--------------------------------

### Install Stigg CLI

Source: https://docs.stigg.io/api-and-sdks/cli

Install the CLI using Homebrew or Go. The Go installation requires version 1.22 or later.

```bash
brew tap stiggio/tools
brew install stigg
```

```bash
go install 'github.com/stiggio/stigg-cli/cmd/stigg@latest'
```

--------------------------------

### Create a Coupon

Source: https://docs.stigg.io/api-reference/coupons/create-coupon

Examples for creating a coupon using different SDKs and the CLI.

```Python
client = Stigg(
    api_key=os.environ.get("STIGG_API_KEY"),  # This is the default and can be omitted
)
coupon = client.v1.coupons.create(
    id="id",
    amounts_off=[{
        "amount": 0,
        "currency": "usd",
    }],
    description="description",
    duration_in_months=1,
    metadata={
        "foo": "string"
    },
    name="name",
    percent_off=1,
)
print(coupon.data)
```

```Go
package main

import (
	"context"
	"fmt"

	"github.com/stiggio/stigg-go"
	"github.com/stiggio/stigg-go/option"
)

func main() {
	client := stigg.NewClient(
		option.WithAPIKey("My API Key"),
	)
	coupon, err := client.V1.Coupons.New(context.TODO(), stigg.V1CouponNewParams{
		ID: "id",
		AmountsOff: []stigg.V1CouponNewParamsAmountsOff{{
			Amount:   0,
			Currency: "usd",
		}},
		Description:      stigg.String("description"),
		DurationInMonths: stigg.Int(1),
		Metadata: map[string]string{
			"foo": "string",
		},
		Name:       "name",
		PercentOff: stigg.Float(1),
	})
	if err != nil {
		panic(err.Error())
	}
	fmt.Printf("%+v\n", coupon.Data)
}
```

```Java
package io.stigg.example;

import io.stigg.client.StiggClient;
import io.stigg.client.okhttp.StiggOkHttpClient;
import io.stigg.core.JsonValue;
import io.stigg.models.v1.coupons.Coupon;
import io.stigg.models.v1.coupons.CouponCreateParams;

public final class Main {
    private Main() {}

    public static void main(String[] args) {
        StiggClient client = StiggOkHttpClient.fromEnv();

        CouponCreateParams params = CouponCreateParams.builder()
            .id("id")
            .addAmountsOff(CouponCreateParams.AmountsOff.builder()
                .amount(0.0)
                .currency(CouponCreateParams.AmountsOff.Currency.USD)
                .build())
            .description("description")
            .durationInMonths(1L)
            .metadata(CouponCreateParams.Metadata.builder()
                .putAdditionalProperty("foo", JsonValue.from("string"))
                .build())
            .name("name")
            .percentOff(1.0)
            .build();
        Coupon coupon = client.v1().coupons().create(params);
    }
}
```

```Ruby
require "stigg"

stigg = Stigg::Client.new(api_key: "My API Key")

coupon = stigg.v1.coupons.create(
  id: "id",
  amounts_off: [{amount: 0, currency: :usd}],
  description: "description",
  duration_in_months: 1,
  metadata: {foo: "string"},
  name: "name",
  percent_off: 1
)

puts(coupon)
```

```C#
using System;
using System.Collections.Generic;
using Stigg.Client;
using Stigg.Client.Models.V1.Coupons;

StiggClient client = new();

CouponCreateParams parameters = new()
{
    ID = "id",
    AmountsOff =
    [
        new()
        {
            Amount = 0,
            Currency = Currency.Usd,
        },
    ],
    Description = "description",
    DurationInMonths = 1,
    Metadata = new Dictionary<string, string>() { { "foo", "string" } },
    Name = "name",
    PercentOff = 1,
};

var coupon = await client.V1.Coupons.Create(parameters);

Console.WriteLine(coupon);
```

```CLI
stigg v1:coupons create \
  --api-key 'My API Key' \
  --id id \
  --amounts-off '{amount: 0, currency: usd}' \
  --description description \
  --duration-in-months 1 \
  --metadata '{foo: string}' \
  --name name \
  --percent-off 1
```

--------------------------------

### Create Addon Draft

Source: https://docs.stigg.io/api-reference/addons/create-addon-draft

Examples of creating an addon draft using different SDKs and the CLI.

```JavaScript
const addon = await client.v1.addons.createDraft('x');

console.log(addon.data);
```

```Python
import os
from stigg import Stigg

client = Stigg(
    api_key=os.environ.get("STIGG_API_KEY"),  # This is the default and can be omitted
)
addon = client.v1.addons.create_draft(
    id="x",
)
print(addon.data)
```

```Go
package main

import (
	"context"
	"fmt"

	"github.com/stiggio/stigg-go"
	"github.com/stiggio/stigg-go/option"
)

func main() {
	client := stigg.NewClient(
		option.WithAPIKey("My API Key"),
	)
	addon, err := client.V1.Addons.NewDraft(
		context.TODO(),
		"x",
		stigg.V1AddonNewDraftParams{},
	)
	if err != nil {
		panic(err.Error())
	}
	fmt.Printf("%+v\n", addon.Data)
}
```

```Java
package io.stigg.example;

import io.stigg.client.StiggClient;
import io.stigg.client.okhttp.StiggOkHttpClient;
import io.stigg.models.v1.addons.Addon;
import io.stigg.models.v1.addons.AddonCreateDraftParams;

public final class Main {
    private Main() {}

    public static void main(String[] args) {
        StiggClient client = StiggOkHttpClient.fromEnv();

        Addon addon = client.v1().addons().createDraft("x");
    }
}
```

```Ruby
require "stigg"

stigg = Stigg::Client.new(api_key: "My API Key")

addon = stigg.v1.addons.create_draft("x")

puts(addon)
```

```C#
using System;
using Stigg.Client;
using Stigg.Client.Models.V1.Addons;

StiggClient client = new();

AddonCreateDraftParams parameters = new() { ID = "x" };

var addon = await client.V1.Addons.CreateDraft(parameters);

Console.WriteLine(addon);
```

```CLI
stigg v1:addons create-draft \
  --api-key 'My API Key' \
  --id x
```

--------------------------------

### Provision a Subscription

Source: https://docs.stigg.io/api-and-sdks/api-reference/rest/subscriptions-create

Examples for provisioning a subscription across various programming languages and the CLI.

```Python
client = Stigg(
    api_key=os.environ.get("STIGG_API_KEY"),  # This is the default and can be omitted
)
response = client.v1.subscriptions.provision(
    customer_id="customerId",
    plan_id="planId",
)
print(response.data)
```

```Go
package main

import (
	"context"
	"fmt"

	"github.com/stiggio/stigg-go"
	"github.com/stiggio/stigg-go/option"
)

func main() {
	client := stigg.NewClient(
		option.WithAPIKey("My API Key"),
	)
	response, err := client.V1.Subscriptions.Provision(context.TODO(), stigg.V1SubscriptionProvisionParams{
		CustomerID: "customerId",
		PlanID:     "planId",
	})
	if err != nil {
		panic(err.Error())
	}
	fmt.Printf("%+v\n", response.Data)
}
```

```Java
package io.stigg.example;


import io.stigg.client.StiggClient;

import io.stigg.client.okhttp.StiggOkHttpClient;

import io.stigg.models.v1.subscriptions.SubscriptionProvisionParams;

import
io.stigg.models.v1.subscriptions.SubscriptionProvisionResponse;


public final class Main {
    private Main() {}

    public static void main(String[] args) {
        StiggClient client = StiggOkHttpClient.fromEnv();

        SubscriptionProvisionParams params = SubscriptionProvisionParams.builder()
            .customerId("customerId")
            .planId("planId")
            .build();
        SubscriptionProvisionResponse response = client.v1().subscriptions().provision(params);
    }
}
```

```Ruby
require "stigg"


stigg = Stigg::Client.new(api_key: "My API Key")


response = stigg.v1.subscriptions.provision(customer_id:
"customerId", plan_id: "planId")


puts(response)
```

```C#
using System;
using Stigg.Client;
using Stigg.Client.Models.V1.Subscriptions;

StiggClient client = new();

SubscriptionProvisionParams parameters = new()
{
    CustomerID = "customerId",
    PlanID = "planId",
};

var response = await client.V1.Subscriptions.Provision(parameters);

Console.WriteLine(response);
```

```CLI
stigg v1:subscriptions provision \
  --api-key 'My API Key' \
  --customer-id customerId \
  --plan-id planId
```

--------------------------------

### Create a Plan across multiple languages

Source: https://docs.stigg.io/api-reference/plans/create-plan

Examples of how to initialize the Stigg client and create a new plan using different SDKs and the CLI.

```JavaScript
const client = new Stigg({
  apiKey: process.env['STIGG_API_KEY'], // This is the default and can be omitted
});

const plan = await client.v1.plans.create({
  id: 'id',
  displayName: 'displayName',
  productId: 'productId',
});

console.log(plan.data);
```

```Python
import os
from stigg import Stigg

client = Stigg(
    api_key=os.environ.get("STIGG_API_KEY"),  # This is the default and can be omitted
)
plan = client.v1.plans.create(
    id="id",
    display_name="displayName",
    product_id="productId",
)
print(plan.data)
```

```Go
package main

import (
	"context"
	"fmt"

	"github.com/stiggio/stigg-go"
	"github.com/stiggio/stigg-go/option"
)

func main() {
	client := stigg.NewClient(
		option.WithAPIKey("My API Key"),
	)
	plan, err := client.V1.Plans.New(context.TODO(), stigg.V1PlanNewParams{
		ID:          "id",
		DisplayName: "displayName",
		ProductID:   "productId",
	})
	if err != nil {
		panic(err.Error())
	}
	fmt.Printf("%+v\n", plan.Data)
}
```

```Java
package io.stigg.example;

import io.stigg.client.StiggClient;
import io.stigg.client.okhttp.StiggOkHttpClient;
import io.stigg.models.v1.plans.Plan;
import io.stigg.models.v1.plans.PlanCreateParams;

public final class Main {
    private Main() {}

    public static void main(String[] args) {
        StiggClient client = StiggOkHttpClient.fromEnv();

        PlanCreateParams params = PlanCreateParams.builder()
            .id("id")
            .displayName("displayName")
            .productId("productId")
            .build();
        Plan plan = client.v1().plans().create(params);
    }
}
```

```Ruby
require "stigg"


stigg = Stigg::Client.new(api_key: "My API Key")


plan = stigg.v1.plans.create(id: "id", display_name: "displayName",
product_id: "productId")


puts(plan)
```

```C#
using System;
using Stigg.Client;
using Stigg.Client.Models.V1.Plans;

StiggClient client = new();

PlanCreateParams parameters = new()
{
    ID = "id",
    DisplayName = "displayName",
    ProductID = "productId",
};

var plan = await client.V1.Plans.Create(parameters);

Console.WriteLine(plan);
```

```CLI
stigg v1:plans create \
  --api-key 'My API Key' \
  --id id \
  --display-name displayName \
  --product-id productId
```

--------------------------------

### Install Stigg Node.js SDK

Source: https://docs.stigg.io/api-and-sdks/integration/backend/nodejs

Install the required package using npm.

```shell
npm install @stigg/node-server-sdk
```

--------------------------------

### Install Stigg JavaScript SDK

Source: https://docs.stigg.io/api-and-sdks/integration/frontend/javascript

Install the SDK as a dependency using npm.

```shell
npm install @stigg/js-client-sdk
```

--------------------------------

### Create Plan Draft

Source: https://docs.stigg.io/api-reference/plans/create-plan-draft

Examples for creating a plan draft using various SDKs and the CLI.

```JavaScript
const client = new Stigg({
  apiKey: process.env['STIGG_API_KEY'], // This is the default and can be omitted
});

const plan = await client.v1.plans.createDraft('x');

console.log(plan.data);
```

```Python
import os
from stigg import Stigg

client = Stigg(
    api_key=os.environ.get("STIGG_API_KEY"),  # This is the default and can be omitted
)
plan = client.v1.plans.create_draft(
    id="x",
)
print(plan.data)
```

```Go
package main

import (
	"context"
	"fmt"

	"github.com/stiggio/stigg-go"
	"github.com/stiggio/stigg-go/option"
)

func main() {
	client := stigg.NewClient(
		option.WithAPIKey("My API Key"),
	)
	plan, err := client.V1.Plans.NewDraft(
		context.TODO(),
		"x",
		stigg.V1PlanNewDraftParams{},
	)
	if err != nil {
		panic(err.Error())
	}
	fmt.Printf("%+v\n", plan.Data)
}
```

```Java
package io.stigg.example;

import io.stigg.client.StiggClient;
import io.stigg.client.okhttp.StiggOkHttpClient;
import io.stigg.models.v1.plans.Plan;
import io.stigg.models.v1.plans.PlanCreateDraftParams;

public final class Main {
    private Main() {}

    public static void main(String[] args) {
        StiggClient client = StiggOkHttpClient.fromEnv();

        Plan plan = client.v1().plans().createDraft("x");
    }
}
```

```Ruby
require "stigg"

stigg = Stigg::Client.new(api_key: "My API Key")

plan = stigg.v1.plans.create_draft("x")

puts(plan)
```

```C#
using System;
using Stigg.Client;
using Stigg.Client.Models.V1.Plans;

StiggClient client = new();

PlanCreateDraftParams parameters = new() { ID = "x" };

var plan = await client.V1.Plans.CreateDraft(parameters);

Console.WriteLine(plan);
```

```CLI
stigg v1:plans create-draft \
  --api-key 'My API Key' \
  --id x
```

--------------------------------

### Create Addon Entitlements

Source: https://docs.stigg.io/api-reference/addon-entitlements/create-addon-entitlements

Examples for creating addon entitlements using different SDKs and the CLI.

```Python
client = Stigg(
    api_key=os.environ.get("STIGG_API_KEY"),  # This is the default and can be omitted
)
entitlement = client.v1.addons.entitlements.create(
    addon_id="addonId",
    entitlements=[{
        "id": "id",
        "type": "FEATURE",
    }],
)
print(entitlement.data)
```

```Go
package main

import (
	"context"
	"fmt"

	"github.com/stiggio/stigg-go"
	"github.com/stiggio/stigg-go/option"
)

func main() {
	client := stigg.NewClient(
		option.WithAPIKey("My API Key"),
	)
	entitlement, err := client.V1.Addons.Entitlements.New(
		context.TODO(),
		"addonId",
		stigg.V1AddonEntitlementNewParams{
			Entitlements: []stigg.V1AddonEntitlementNewParamsEntitlementUnion{{
				OfFeature: &stigg.V1AddonEntitlementNewParamsEntitlementFeature{
					ID: "id",
				},
			}},
		},
	)
	if err != nil {
		panic(err.Error())
	}
	fmt.Printf("%+v\n", entitlement.Data)
}
```

```Java
package io.stigg.example;


import io.stigg.client.StiggClient;

import io.stigg.client.okhttp.StiggOkHttpClient;

import
io.stigg.models.v1.addons.entitlements.EntitlementCreateParams;

import
io.stigg.models.v1.addons.entitlements.EntitlementCreateResponse;


public final class Main {
    private Main() {}

    public static void main(String[] args) {
        StiggClient client = StiggOkHttpClient.fromEnv();

        EntitlementCreateParams params = EntitlementCreateParams.builder()
            .addonId("addonId")
            .addFeatureEntitlement("id")
            .build();
        EntitlementCreateResponse entitlement = client.v1().addons().entitlements().create(params);
    }
}
```

```Ruby
require "stigg"


stigg = Stigg::Client.new(api_key: "My API Key")


entitlement = stigg.v1.addons.entitlements.create("addonId",
entitlements: [{id: "id", type: :FEATURE}])


puts(entitlement)
```

```C#
using System;

using Stigg.Client;

using Stigg.Client.Models.V1.Addons.Entitlements;


StiggClient client = new();


EntitlementCreateParams parameters = new()

{
    AddonID = "addonId",
    Entitlements =
    [
        new Feature()
        {
            ID = "id",
            Behavior = Behavior.Increment,
            Description = "description",
            DisplayNameOverride = "displayNameOverride",
            EnumValues =
            [
                "string"
            ],
            HasSoftLimit = true,
            HasUnlimitedUsage = true,
            HiddenFromWidgets =
            [
                HiddenFromWidget.Paywall
            ],
            IsCustom = true,
            IsGranted = true,
            MonthlyResetPeriodConfiguration = new(
                AccordingTo.SubscriptionStart
            ),
            Order = 0,
            ResetPeriod = ResetPeriod.Year,
            UsageLimit = 0,
            WeeklyResetPeriodConfiguration = new(
                WeeklyResetPeriodConfigurationAccordingTo.SubscriptionStart
            ),
            YearlyResetPeriodConfiguration = new(
                YearlyResetPeriodConfigurationAccordingTo.SubscriptionStart
            ),
        },
    ],
};


var entitlement = await
client.V1.Addons.Entitlements.Create(parameters);


Console.WriteLine(entitlement);
```

```CLI
stigg v1:addons:entitlements create \
  --api-key 'My API Key' \
  --addon-id addonId \
  --entitlement '{id: id, type: FEATURE}'
```

--------------------------------

### Install dependencies

Source: https://docs.stigg.io/documentation/native-integrations/billing/zuora/import-zuora-catalog-into-stigg

Install the necessary project dependencies using either Yarn or npm.

```bash
yarn install
```

```bash
npm install
```

--------------------------------

### Install Stigg SDK

Source: https://docs.stigg.io/api-and-sdks/integration/backend/python

Install the Stigg API client package using pip.

```shell
pip install stigg-api-client-v2
```

--------------------------------

### API Request Example

Source: https://docs.stigg.io/api-and-sdks/api-reference/rest/entitlements-check

Example command line arguments for the entitlements check request.

```bash
--api-key 'My API Key' \
--id x
```
Tokens:
Raw