reference.md

Reference

client.get_company_plans()

🔌 Usage

from schematic import Schematic

client = Schematic(
    api_key="YOUR_API_KEY",
)
client.get_company_plans()

⚙️ Parameters

request_options: typing.Optional[RequestOptions] — Request-specific configuration.

accounts

client.accounts.list_api_keys(...)

🔌 Usage

from schematic import Schematic

client = Schematic(
    api_key="YOUR_API_KEY",
)
client.accounts.list_api_keys(
    require_environment=True,
)

⚙️ Parameters

require_environment: bool

environment_id: typing.Optional[str]

limit: typing.Optional[int] — Page limit (default 100)

offset: typing.Optional[int] — Page offset (default 0)

request_options: typing.Optional[RequestOptions] — Request-specific configuration.

client.accounts.create_api_key(...)

🔌 Usage

from schematic import Schematic

client = Schematic(
    api_key="YOUR_API_KEY",
)
client.accounts.create_api_key(
    name="name",
)

⚙️ Parameters

name: str

description: typing.Optional[str]

environment_id: typing.Optional[str]

request_options: typing.Optional[RequestOptions] — Request-specific configuration.

client.accounts.get_api_key(...)

🔌 Usage

from schematic import Schematic

client = Schematic(
    api_key="YOUR_API_KEY",
)
client.accounts.get_api_key(
    api_key_id="api_key_id",
)

⚙️ Parameters

api_key_id: str — api_key_id

request_options: typing.Optional[RequestOptions] — Request-specific configuration.

client.accounts.update_api_key(...)

🔌 Usage

from schematic import Schematic

client = Schematic(
    api_key="YOUR_API_KEY",
)
client.accounts.update_api_key(
    api_key_id="api_key_id",
)

⚙️ Parameters

api_key_id: str — api_key_id

description: typing.Optional[str]

name: typing.Optional[str]

request_options: typing.Optional[RequestOptions] — Request-specific configuration.

client.accounts.delete_api_key(...)

🔌 Usage

from schematic import Schematic

client = Schematic(
    api_key="YOUR_API_KEY",
)
client.accounts.delete_api_key(
    api_key_id="api_key_id",
)

⚙️ Parameters

api_key_id: str — api_key_id

request_options: typing.Optional[RequestOptions] — Request-specific configuration.

client.accounts.count_api_keys(...)

🔌 Usage

from schematic import Schematic

client = Schematic(
    api_key="YOUR_API_KEY",
)
client.accounts.count_api_keys(
    require_environment=True,
)

⚙️ Parameters

require_environment: bool

environment_id: typing.Optional[str]

limit: typing.Optional[int] — Page limit (default 100)

offset: typing.Optional[int] — Page offset (default 0)

request_options: typing.Optional[RequestOptions] — Request-specific configuration.

client.accounts.list_api_requests(...)

🔌 Usage

from schematic import Schematic

client = Schematic(
    api_key="YOUR_API_KEY",
)
client.accounts.list_api_requests()

⚙️ Parameters

q: typing.Optional[str]

request_type: typing.Optional[str]

environment_id: typing.Optional[str]

limit: typing.Optional[int] — Page limit (default 100)

offset: typing.Optional[int] — Page offset (default 0)

request_options: typing.Optional[RequestOptions] — Request-specific configuration.

client.accounts.get_api_request(...)

🔌 Usage

from schematic import Schematic

client = Schematic(
    api_key="YOUR_API_KEY",
)
client.accounts.get_api_request(
    api_request_id="api_request_id",
)

⚙️ Parameters

api_request_id: str — api_request_id

request_options: typing.Optional[RequestOptions] — Request-specific configuration.

client.accounts.count_api_requests(...)

🔌 Usage

from schematic import Schematic

client = Schematic(
    api_key="YOUR_API_KEY",
)
client.accounts.count_api_requests()

⚙️ Parameters

q: typing.Optional[str]

request_type: typing.Optional[str]

environment_id: typing.Optional[str]

limit: typing.Optional[int] — Page limit (default 100)

offset: typing.Optional[int] — Page offset (default 0)

request_options: typing.Optional[RequestOptions] — Request-specific configuration.

client.accounts.list_environments(...)

🔌 Usage

from schematic import Schematic

client = Schematic(
    api_key="YOUR_API_KEY",
)
client.accounts.list_environments()

⚙️ Parameters

ids: typing.Optional[typing.Union[str, typing.Sequence[str]]]

limit: typing.Optional[int] — Page limit (default 100)

offset: typing.Optional[int] — Page offset (default 0)

request_options: typing.Optional[RequestOptions] — Request-specific configuration.

client.accounts.create_environment(...)

🔌 Usage

from schematic import Schematic

client = Schematic(
    api_key="YOUR_API_KEY",
)
client.accounts.create_environment(
    environment_type="development",
    name="name",
)

⚙️ Parameters

environment_type: CreateEnvironmentRequestBodyEnvironmentType

name: str

request_options: typing.Optional[RequestOptions] — Request-specific configuration.

client.accounts.get_environment(...)

🔌 Usage

from schematic import Schematic

client = Schematic(
    api_key="YOUR_API_KEY",
)
client.accounts.get_environment(
    environment_id="environment_id",
)

⚙️ Parameters

environment_id: str — environment_id

request_options: typing.Optional[RequestOptions] — Request-specific configuration.

client.accounts.update_environment(...)

🔌 Usage

from schematic import Schematic

client = Schematic(
    api_key="YOUR_API_KEY",
)
client.accounts.update_environment(
    environment_id="environment_id",
)

⚙️ Parameters

environment_id: str — environment_id

environment_type: typing.Optional[UpdateEnvironmentRequestBodyEnvironmentType]

name: typing.Optional[str]

request_options: typing.Optional[RequestOptions] — Request-specific configuration.

client.accounts.delete_environment(...)

🔌 Usage

from schematic import Schematic

client = Schematic(
    api_key="YOUR_API_KEY",
)
client.accounts.delete_environment(
    environment_id="environment_id",
)

⚙️ Parameters

environment_id: str — environment_id

request_options: typing.Optional[RequestOptions] — Request-specific configuration.

features

client.features.count_audience_companies(...)

🔌 Usage

from schematic import (
    CreateOrUpdateConditionGroupRequestBody,
    CreateOrUpdateConditionRequestBody,
    Schematic,
)

client = Schematic(
    api_key="YOUR_API_KEY",
)
client.features.count_audience_companies(
    condition_groups=[
        CreateOrUpdateConditionGroupRequestBody(
            conditions=[
                CreateOrUpdateConditionRequestBody(
                    condition_type="company",
                    operator="eq",
                    resource_ids=["resource_ids"],
                )
            ],
        )
    ],
    conditions=[
        CreateOrUpdateConditionRequestBody(
            condition_type="company",
            operator="eq",
            resource_ids=["resource_ids"],
        )
    ],
)

⚙️ Parameters

condition_groups: typing.Sequence[CreateOrUpdateConditionGroupRequestBody]

conditions: typing.Sequence[CreateOrUpdateConditionRequestBody]

limit: typing.Optional[int] — Page limit (default 100)

offset: typing.Optional[int] — Page offset (default 0)

q: typing.Optional[str]

request_options: typing.Optional[RequestOptions] — Request-specific configuration.

client.features.count_audience_users(...)

🔌 Usage

from schematic import (
    CreateOrUpdateConditionGroupRequestBody,
    CreateOrUpdateConditionRequestBody,
    Schematic,
)

client = Schematic(
    api_key="YOUR_API_KEY",
)
client.features.count_audience_users(
    condition_groups=[
        CreateOrUpdateConditionGroupRequestBody(
            conditions=[
                CreateOrUpdateConditionRequestBody(
                    condition_type="company",
                    operator="eq",
                    resource_ids=["resource_ids"],
                )
            ],
        )
    ],
    conditions=[
        CreateOrUpdateConditionRequestBody(
            condition_type="company",
            operator="eq",
            resource_ids=["resource_ids"],
        )
    ],
)

⚙️ Parameters

condition_groups: typing.Sequence[CreateOrUpdateConditionGroupRequestBody]

conditions: typing.Sequence[CreateOrUpdateConditionRequestBody]

limit: typing.Optional[int] — Page limit (default 100)

offset: typing.Optional[int] — Page offset (default 0)

q: typing.Optional[str]

request_options: typing.Optional[RequestOptions] — Request-specific configuration.

client.features.list_audience_companies(...)

🔌 Usage

from schematic import (
    CreateOrUpdateConditionGroupRequestBody,
    CreateOrUpdateConditionRequestBody,
    Schematic,
)

client = Schematic(
    api_key="YOUR_API_KEY",
)
client.features.list_audience_companies(
    condition_groups=[
        CreateOrUpdateConditionGroupRequestBody(
            conditions=[
                CreateOrUpdateConditionRequestBody(
                    condition_type="company",
                    operator="eq",
                    resource_ids=["resource_ids"],
                )
            ],
        )
    ],
    conditions=[
        CreateOrUpdateConditionRequestBody(
            condition_type="company",
            operator="eq",
            resource_ids=["resource_ids"],
        )
    ],
)

⚙️ Parameters

condition_groups: typing.Sequence[CreateOrUpdateConditionGroupRequestBody]

conditions: typing.Sequence[CreateOrUpdateConditionRequestBody]

limit: typing.Optional[int] — Page limit (default 100)

offset: typing.Optional[int] — Page offset (default 0)

q: typing.Optional[str]

request_options: typing.Optional[RequestOptions] — Request-specific configuration.

client.features.list_audience_users(...)

🔌 Usage

from schematic import (
    CreateOrUpdateConditionGroupRequestBody,
    CreateOrUpdateConditionRequestBody,
    Schematic,
)

client = Schematic(
    api_key="YOUR_API_KEY",
)
client.features.list_audience_users(
    condition_groups=[
        CreateOrUpdateConditionGroupRequestBody(
            conditions=[
                CreateOrUpdateConditionRequestBody(
                    condition_type="company",
                    operator="eq",
                    resource_ids=["resource_ids"],
                )
            ],
        )
    ],
    conditions=[
        CreateOrUpdateConditionRequestBody(
            condition_type="company",
            operator="eq",
            resource_ids=["resource_ids"],
        )
    ],
)

⚙️ Parameters

condition_groups: typing.Sequence[CreateOrUpdateConditionGroupRequestBody]

conditions: typing.Sequence[CreateOrUpdateConditionRequestBody]

limit: typing.Optional[int] — Page limit (default 100)

offset: typing.Optional[int] — Page offset (default 0)

q: typing.Optional[str]

request_options: typing.Optional[RequestOptions] — Request-specific configuration.

client.features.list_features(...)

🔌 Usage

from schematic import Schematic

client = Schematic(
    api_key="YOUR_API_KEY",
)
client.features.list_features()

⚙️ Parameters

ids: typing.Optional[typing.Union[str, typing.Sequence[str]]]

q: typing.Optional[str]

without_company_override_for: typing.Optional[str] — Filter out features that already have a company override for the specified company ID

without_plan_entitlement_for: typing.Optional[str] — Filter out features that already have a plan entitlement for the specified plan ID

limit: typing.Optional[int] — Page limit (default 100)

offset: typing.Optional[int] — Page offset (default 0)

request_options: typing.Optional[RequestOptions] — Request-specific configuration.

client.features.create_feature(...)

🔌 Usage

from schematic import Schematic

client = Schematic(
    api_key="YOUR_API_KEY",
)
client.features.create_feature(
    description="description",
    feature_type="boolean",
    name="name",
)

⚙️ Parameters

description: str

feature_type: CreateFeatureRequestBodyFeatureType

name: str

event_subtype: typing.Optional[str]

flag: typing.Optional[CreateOrUpdateFlagRequestBody]

icon: typing.Optional[str]

lifecycle_phase: typing.Optional[str]

maintainer_id: typing.Optional[str]

trait_id: typing.Optional[str]

request_options: typing.Optional[RequestOptions] — Request-specific configuration.

client.features.get_feature(...)

🔌 Usage

from schematic import Schematic

client = Schematic(
    api_key="YOUR_API_KEY",
)
client.features.get_feature(
    feature_id="feature_id",
)

⚙️ Parameters

feature_id: str — feature_id

request_options: typing.Optional[RequestOptions] — Request-specific configuration.

client.features.update_feature(...)

🔌 Usage

from schematic import Schematic

client = Schematic(
    api_key="YOUR_API_KEY",
)
client.features.update_feature(
    feature_id="feature_id",
)

⚙️ Parameters

feature_id: str — feature_id

description: typing.Optional[str]

event_subtype: typing.Optional[str]

feature_type: typing.Optional[UpdateFeatureRequestBodyFeatureType]

flag: typing.Optional[CreateOrUpdateFlagRequestBody]

icon: typing.Optional[str]

lifecycle_phase: typing.Optional[str]

maintainer_id: typing.Optional[str]

name: typing.Optional[str]

trait_id: typing.Optional[str]

request_options: typing.Optional[RequestOptions] — Request-specific configuration.

client.features.delete_feature(...)

🔌 Usage

from schematic import Schematic

client = Schematic(
    api_key="YOUR_API_KEY",
)
client.features.delete_feature(
    feature_id="feature_id",
)

⚙️ Parameters

feature_id: str — feature_id

request_options: typing.Optional[RequestOptions] — Request-specific configuration.

client.features.count_features(...)

🔌 Usage

from schematic import Schematic

client = Schematic(
    api_key="YOUR_API_KEY",
)
client.features.count_features()

⚙️ Parameters

ids: typing.Optional[typing.Union[str, typing.Sequence[str]]]

q: typing.Optional[str]

without_company_override_for: typing.Optional[str] — Filter out features that already have a company override for the specified company ID

without_plan_entitlement_for: typing.Optional[str] — Filter out features that already have a plan entitlement for the specified plan ID

limit: typing.Optional[int] — Page limit (default 100)

offset: typing.Optional[int] — Page offset (default 0)

request_options: typing.Optional[RequestOptions] — Request-specific configuration.

client.features.list_flags(...)

🔌 Usage

from schematic import Schematic

client = Schematic(
    api_key="YOUR_API_KEY",
)
client.features.list_flags()

⚙️ Parameters

feature_id: typing.Optional[str]

ids: typing.Optional[typing.Union[str, typing.Sequence[str]]]

q: typing.Optional[str]

limit: typing.Optional[int] — Page limit (default 100)

offset: typing.Optional[int] — Page offset (default 0)

request_options: typing.Optional[RequestOptions] — Request-specific configuration.

client.features.create_flag(...)

🔌 Usage

from schematic import Schematic

client = Schematic(
    api_key="YOUR_API_KEY",
)
client.features.create_flag(
    default_value=True,
    description="description",
    flag_type="flag_type",
    key="key",
    name="name",
)

⚙️ Parameters

default_value: bool

description: str

flag_type: str

key: str

name: str

feature_id: typing.Optional[str]

maintainer_id: typing.Optional[str]

request_options: typing.Optional[RequestOptions] — Request-specific configuration.

client.features.get_flag(...)

🔌 Usage

from schematic import Schematic

client = Schematic(
    api_key="YOUR_API_KEY",
)
client.features.get_flag(
    flag_id="flag_id",
)

⚙️ Parameters

flag_id: str — flag_id

request_options: typing.Optional[RequestOptions] — Request-specific configuration.

client.features.update_flag(...)

🔌 Usage

from schematic import Schematic

client = Schematic(
    api_key="YOUR_API_KEY",
)
client.features.update_flag(
    flag_id="flag_id",
    default_value=True,
    description="description",
    flag_type="flag_type",
    key="key",
    name="name",
)

⚙️ Parameters

flag_id: str — flag_id

default_value: bool

description: str

flag_type: str

key: str

name: str

feature_id: typing.Optional[str]

maintainer_id: typing.Optional[str]

request_options: typing.Optional[RequestOptions] — Request-specific configuration.

client.features.delete_flag(...)

🔌 Usage

from schematic import Schematic

client = Schematic(
    api_key="YOUR_API_KEY",
)
client.features.delete_flag(
    flag_id="flag_id",
)

⚙️ Parameters

flag_id: str — flag_id

request_options: typing.Optional[RequestOptions] — Request-specific configuration.

client.features.update_flag_rules(...)

🔌 Usage

from schematic import (
    CreateOrUpdateConditionGroupRequestBody,
    CreateOrUpdateConditionRequestBody,
    CreateOrUpdateRuleRequestBody,
    Schematic,
)

client = Schematic(
    api_key="YOUR_API_KEY",
)
client.features.update_flag_rules(
    flag_id="flag_id",
    rules=[
        CreateOrUpdateRuleRequestBody(
            condition_groups=[
                CreateOrUpdateConditionGroupRequestBody(
                    conditions=[
                        CreateOrUpdateConditionRequestBody(
                            condition_type="company",
                            operator="eq",
                            resource_ids=["resource_ids"],
                        )
                    ],
                )
            ],
            conditions=[
                CreateOrUpdateConditionRequestBody(
                    condition_type="company",
                    operator="eq",
                    resource_ids=["resource_ids"],
                )
            ],
            name="name",
            priority=1,
            value=True,
        )
    ],
)

⚙️ Parameters

flag_id: str — flag_id

rules: typing.Sequence[CreateOrUpdateRuleRequestBody]

request_options: typing.Optional[RequestOptions] — Request-specific configuration.

client.features.check_flag(...)

🔌 Usage

from schematic import Schematic

client = Schematic(
    api_key="YOUR_API_KEY",
)
client.features.check_flag(
    key="key",
)

⚙️ Parameters

key: str — key

company: typing.Optional[typing.Dict[str, str]]

user: typing.Optional[typing.Dict[str, str]]

request_options: typing.Optional[RequestOptions] — Request-specific configuration.

client.features.check_flags(...)

🔌 Usage

from schematic import Schematic

client = Schematic(
    api_key="YOUR_API_KEY",
)
client.features.check_flags()

⚙️ Parameters

company: typing.Optional[typing.Dict[str, str]]

user: typing.Optional[typing.Dict[str, str]]

request_options: typing.Optional[RequestOptions] — Request-specific configuration.

client.features.count_flags(...)

🔌 Usage

from schematic import Schematic

client = Schematic(
    api_key="YOUR_API_KEY",
)
client.features.count_flags()

⚙️ Parameters

feature_id: typing.Optional[str]

ids: typing.Optional[typing.Union[str, typing.Sequence[str]]]

q: typing.Optional[str]

limit: typing.Optional[int] — Page limit (default 100)

offset: typing.Optional[int] — Page offset (default 0)

request_options: typing.Optional[RequestOptions] — Request-specific configuration.

billing

client.billing.upsert_billing_customer(...)

🔌 Usage

from schematic import Schematic

client = Schematic(
    api_key="YOUR_API_KEY",
)
client.billing.upsert_billing_customer(
    email="email",
    external_id="external_id",
    failed_to_import=True,
    meta={"key": "value"},
    name="name",
)

⚙️ Parameters

email: str

external_id: str

failed_to_import: bool

meta: typing.Dict[str, str]

name: str

company_id: typing.Optional[str]

request_options: typing.Optional[RequestOptions] — Request-specific configuration.

client.billing.list_customers(...)

🔌 Usage

from schematic import Schematic

client = Schematic(
    api_key="YOUR_API_KEY",
)
client.billing.list_customers()

⚙️ Parameters

name: typing.Optional[str]

failed_to_import: typing.Optional[bool]

q: typing.Optional[str]

limit: typing.Optional[int] — Page limit (default 100)

offset: typing.Optional[int] — Page offset (default 0)

request_options: typing.Optional[RequestOptions] — Request-specific configuration.

client.billing.count_customers(...)

🔌 Usage

from schematic import Schematic

client = Schematic(
    api_key="YOUR_API_KEY",
)
client.billing.count_customers()

⚙️ Parameters

name: typing.Optional[str]

failed_to_import: typing.Optional[bool]

q: typing.Optional[str]

limit: typing.Optional[int] — Page limit (default 100)

offset: typing.Optional[int] — Page offset (default 0)

request_options: typing.Optional[RequestOptions] — Request-specific configuration.

client.billing.list_invoices(...)

🔌 Usage

from schematic import Schematic

client = Schematic(
    api_key="YOUR_API_KEY",
)
client.billing.list_invoices(
    customer_external_id="customer_external_id",
)

⚙️ Parameters

customer_external_id: str

company_id: typing.Optional[str]

subscription_external_id: typing.Optional[str]

limit: typing.Optional[int] — Page limit (default 100)

offset: typing.Optional[int] — Page offset (default 0)

request_options: typing.Optional[RequestOptions] — Request-specific configuration.

client.billing.upsert_invoice(...)

🔌 Usage

from schematic import Schematic

client = Schematic(
    api_key="YOUR_API_KEY",
)
client.billing.upsert_invoice(
    amount_due=1,
    amount_paid=1,
    amount_remaining=1,
    collection_method="collection_method",
    currency="currency",
    customer_external_id="customer_external_id",
    external_id="external_id",
    subtotal=1,
)

⚙️ Parameters

amount_due: int

amount_paid: int

amount_remaining: int

collection_method: str

currency: str

customer_external_id: str

external_id: str

subtotal: int

due_date: typing.Optional[dt.datetime]

payment_method_external_id: typing.Optional[str]

subscription_external_id: typing.Optional[str]

request_options: typing.Optional[RequestOptions] — Request-specific configuration.

client.billing.list_payment_methods(...)

🔌 Usage

from schematic import Schematic

client = Schematic(
    api_key="YOUR_API_KEY",
)
client.billing.list_payment_methods(
    customer_external_id="customer_external_id",
)

⚙️ Parameters

customer_external_id: str

company_id: typing.Optional[str]

subscription_external_id: typing.Optional[str]

limit: typing.Optional[int] — Page limit (default 100)

offset: typing.Optional[int] — Page offset (default 0)

request_options: typing.Optional[RequestOptions] — Request-specific configuration.

client.billing.upsert_payment_method(...)

🔌 Usage

from schematic import Schematic

client = Schematic(
    api_key="YOUR_API_KEY",
)
client.billing.upsert_payment_method(
    customer_external_id="customer_external_id",
    external_id="external_id",
    payment_method_type="payment_method_type",
)

⚙️ Parameters

customer_external_id: str

external_id: str

payment_method_type: str

card_brand: typing.Optional[str]

card_exp_month: typing.Optional[int]

card_exp_year: typing.Optional[int]

card_last_4: typing.Optional[str]

subscription_external_id: typing.Optional[str]

request_options: typing.Optional[RequestOptions] — Request-specific configuration.

client.billing.upsert_billing_price(...)

🔌 Usage

from schematic import Schematic

client = Schematic(
    api_key="YOUR_API_KEY",
)
client.billing.upsert_billing_price(
    interval="interval",
    price=1,
    price_external_id="price_external_id",
    product_external_id="product_external_id",
)

⚙️ Parameters

interval: str

price: int

price_external_id: str

product_external_id: str

request_options: typing.Optional[RequestOptions] — Request-specific configuration.

client.billing.list_product_prices(...)

🔌 Usage

from schematic import Schematic

client = Schematic(
    api_key="YOUR_API_KEY",
)
client.billing.list_product_prices()

⚙️ Parameters

ids: typing.Optional[typing.Union[str, typing.Sequence[str]]]

name: typing.Optional[str]

q: typing.Optional[str]

limit: typing.Optional[int] — Page limit (default 100)

offset: typing.Optional[int] — Page offset (default 0)

request_options: typing.Optional[RequestOptions] — Request-specific configuration.

client.billing.upsert_billing_product(...)

🔌 Usage

from schematic import Schematic

client = Schematic(
    api_key="YOUR_API_KEY",
)
client.billing.upsert_billing_product(
    currency="currency",
    external_id="external_id",
    name="name",
    price=1.1,
    quantity=1,
)

⚙️ Parameters

currency: str

external_id: str

name: str

price: float

quantity: int

request_options: typing.Optional[RequestOptions] — Request-specific configuration.

client.billing.list_billing_products(...)

🔌 Usage

from schematic import Schematic

client = Schematic(
    api_key="YOUR_API_KEY",
)
client.billing.list_billing_products()

⚙️ Parameters

ids: typing.Optional[typing.Union[str, typing.Sequence[str]]]

name: typing.Optional[str]

q: typing.Optional[str]

limit: typing.Optional[int] — Page limit (default 100)

offset: typing.Optional[int] — Page offset (default 0)

request_options: typing.Optional[RequestOptions] — Request-specific configuration.

client.billing.count_billing_products(...)

🔌 Usage

from schematic import Schematic

client = Schematic(
    api_key="YOUR_API_KEY",
)
client.billing.count_billing_products()

⚙️ Parameters

ids: typing.Optional[typing.Union[str, typing.Sequence[str]]]

name: typing.Optional[str]

q: typing.Optional[str]

limit: typing.Optional[int] — Page limit (default 100)

offset: typing.Optional[int] — Page offset (default 0)

request_options: typing.Optional[RequestOptions] — Request-specific configuration.

client.billing.upsert_billing_subscription(...)

🔌 Usage

import datetime

from schematic import BillingProductPricing, Schematic

client = Schematic(
    api_key="YOUR_API_KEY",
)
client.billing.upsert_billing_subscription(
    customer_external_id="customer_external_id",
    expired_at=datetime.datetime.fromisoformat(
        "2024-01-15 09:30:00+00:00",
    ),
    product_external_ids=[
        BillingProductPricing(
            price=1,
            product_external_id="product_external_id",
        )
    ],
    subscription_external_id="subscription_external_id",
    total_price=1,
)

⚙️ Parameters

customer_external_id: str

expired_at: dt.datetime

product_external_ids: typing.Sequence[BillingProductPricing]

subscription_external_id: str

total_price: int

interval: typing.Optional[str]

metadata: typing.Optional[typing.Dict[str, typing.Optional[typing.Any]]]

status: typing.Optional[str]

request_options: typing.Optional[RequestOptions] — Request-specific configuration.

companies

client.companies.list_companies(...)

🔌 Usage

from schematic import Schematic

client = Schematic(
    api_key="YOUR_API_KEY",
)
client.companies.list_companies()

⚙️ Parameters

ids: typing.Optional[typing.Union[str, typing.Sequence[str]]]

plan_id: typing.Optional[str]

q: typing.Optional[str] — Search filter

without_feature_override_for: typing.Optional[str] — Filter out companies that already have a company override for the specified feature ID

without_plan: typing.Optional[bool] — Filter out companies that have a plan

limit: typing.Optional[int] — Page limit (default 100)

offset: typing.Optional[int] — Page offset (default 0)

request_options: typing.Optional[RequestOptions] — Request-specific configuration.

client.companies.upsert_company(...)

🔌 Usage

from schematic import Schematic

client = Schematic(
    api_key="YOUR_API_KEY",
)
client.companies.upsert_company(
    keys={"key": "value"},
)

⚙️ Parameters

keys: typing.Dict[str, str]

id: typing.Optional[str] — If you know the Schematic ID, you can use that here instead of keys

last_seen_at: typing.Optional[dt.datetime]

name: typing.Optional[str]

traits: typing.Optional[typing.Dict[str, typing.Optional[typing.Any]]] — A map of trait names to trait values

update_only: typing.Optional[bool]

request_options: typing.Optional[RequestOptions] — Request-specific configuration.

client.companies.get_company(...)

🔌 Usage

from schematic import Schematic

client = Schematic(
    api_key="YOUR_API_KEY",
)
client.companies.get_company(
    company_id="company_id",
)

⚙️ Parameters

company_id: str — company_id

request_options: typing.Optional[RequestOptions] — Request-specific configuration.

client.companies.delete_company(...)

🔌 Usage

from schematic import Schematic

client = Schematic(
    api_key="YOUR_API_KEY",
)
client.companies.delete_company(
    company_id="company_id",
)

⚙️ Parameters

company_id: str — company_id

request_options: typing.Optional[RequestOptions] — Request-specific configuration.

client.companies.count_companies(...)

🔌 Usage

from schematic import Schematic

client = Schematic(
    api_key="YOUR_API_KEY",
)
client.companies.count_companies()

⚙️ Parameters

ids: typing.Optional[typing.Union[str, typing.Sequence[str]]]

plan_id: typing.Optional[str]

q: typing.Optional[str] — Search filter

without_feature_override_for: typing.Optional[str] — Filter out companies that already have a company override for the specified feature ID

without_plan: typing.Optional[bool] — Filter out companies that have a plan

limit: typing.Optional[int] — Page limit (default 100)

offset: typing.Optional[int] — Page offset (default 0)

request_options: typing.Optional[RequestOptions] — Request-specific configuration.

client.companies.create_company(...)

🔌 Usage

from schematic import Schematic

client = Schematic(
    api_key="YOUR_API_KEY",
)
client.companies.create_company(
    keys={"key": "value"},
)

⚙️ Parameters

keys: typing.Dict[str, str]

id: typing.Optional[str] — If you know the Schematic ID, you can use that here instead of keys

last_seen_at: typing.Optional[dt.datetime]

name: typing.Optional[str]

traits: typing.Optional[typing.Dict[str, typing.Optional[typing.Any]]] — A map of trait names to trait values

update_only: typing.Optional[bool]

request_options: typing.Optional[RequestOptions] — Request-specific configuration.

client.companies.delete_company_by_keys(...)

🔌 Usage

from schematic import Schematic

client = Schematic(
    api_key="YOUR_API_KEY",
)
client.companies.delete_company_by_keys(
    keys={"key": "value"},
)

⚙️ Parameters

keys: typing.Dict[str, str]

request_options: typing.Optional[RequestOptions] — Request-specific configuration.

client.companies.lookup_company(...)

🔌 Usage

from schematic import Schematic

client = Schematic(
    api_key="YOUR_API_KEY",
)
client.companies.lookup_company(
    keys={"string": {"key": "value"}},
)

⚙️ Parameters

keys: typing.Dict[str, typing.Optional[typing.Any]] — Key/value pairs

request_options: typing.Optional[RequestOptions] — Request-specific configuration.

client.companies.get_active_deals(...)

🔌 Usage

from schematic import Schematic

client = Schematic(
    api_key="YOUR_API_KEY",
)
client.companies.get_active_deals(
    company_id="company_id",
    deal_stage="deal_stage",
)

⚙️ Parameters

company_id: str

deal_stage: str

limit: typing.Optional[int] — Page limit (default 100)

offset: typing.Optional[int] — Page offset (default 0)

request_options: typing.Optional[RequestOptions] — Request-specific configuration.

client.companies.list_company_memberships(...)

🔌 Usage

from schematic import Schematic

client = Schematic(
    api_key="YOUR_API_KEY",
)
client.companies.list_company_memberships()

⚙️ Parameters

company_id: typing.Optional[str]

user_id: typing.Optional[str]

limit: typing.Optional[int] — Page limit (default 100)

offset: typing.Optional[int] — Page offset (default 0)

request_options: typing.Optional[RequestOptions] — Request-specific configuration.

client.companies.get_or_create_company_membership(...)

🔌 Usage

from schematic import Schematic

client = Schematic(
    api_key="YOUR_API_KEY",
)
client.companies.get_or_create_company_membership(
    company_id="company_id",
    user_id="user_id",
)

⚙️ Parameters

company_id: str

user_id: str

request_options: typing.Optional[RequestOptions] — Request-specific configuration.

client.companies.delete_company_membership(...)

🔌 Usage

from schematic import Schematic

client = Schematic(
    api_key="YOUR_API_KEY",
)
client.companies.delete_company_membership(
    company_membership_id="company_membership_id",
)

⚙️ Parameters

company_membership_id: str — company_membership_id

request_options: typing.Optional[RequestOptions] — Request-specific configuration.

client.companies.get_active_company_subscription(...)

🔌 Usage

from schematic import Schematic

client = Schematic(
    api_key="YOUR_API_KEY",
)
client.companies.get_active_company_subscription(
    company_id="company_id",
)

⚙️ Parameters

company_id: str

limit: typing.Optional[int] — Page limit (default 100)

offset: typing.Optional[int] — Page offset (default 0)

request_options: typing.Optional[RequestOptions] — Request-specific configuration.

client.companies.upsert_company_trait(...)

🔌 Usage

from schematic import Schematic

client = Schematic(
    api_key="YOUR_API_KEY",
)
client.companies.upsert_company_trait(
    keys={"key": "value"},
    trait="trait",
)

⚙️ Parameters

keys: typing.Dict[str, str] — Key/value pairs too identify a company or user

trait: str — Name of the trait to update

incr: typing.Optional[int] — Amount to increment the trait by (positive or negative)

set_: typing.Optional[str] — Value to set the trait to

update_only: typing.Optional[bool] — Unless this is set, the company or user will be created if it does not already exist

request_options: typing.Optional[RequestOptions] — Request-specific configuration.

client.companies.list_entity_key_definitions(...)

🔌 Usage

from schematic import Schematic

client = Schematic(
    api_key="YOUR_API_KEY",
)
client.companies.list_entity_key_definitions()

⚙️ Parameters

entity_type: typing.Optional[ListEntityKeyDefinitionsRequestEntityType]

ids: typing.Optional[typing.Union[str, typing.Sequence[str]]]

q: typing.Optional[str]

limit: typing.Optional[int] — Page limit (default 100)

offset: typing.Optional[int] — Page offset (default 0)

request_options: typing.Optional[RequestOptions] — Request-specific configuration.

client.companies.count_entity_key_definitions(...)

🔌 Usage

from schematic import Schematic

client = Schematic(
    api_key="YOUR_API_KEY",
)
client.companies.count_entity_key_definitions()

⚙️ Parameters

entity_type: typing.Optional[CountEntityKeyDefinitionsRequestEntityType]

ids: typing.Optional[typing.Union[str, typing.Sequence[str]]]

q: typing.Optional[str]

limit: typing.Optional[int] — Page limit (default 100)

offset: typing.Optional[int] — Page offset (default 0)

request_options: typing.Optional[RequestOptions] — Request-specific configuration.

client.companies.list_entity_trait_definitions(...)

🔌 Usage

from schematic import Schematic

client = Schematic(
    api_key="YOUR_API_KEY",
)
client.companies.list_entity_trait_definitions()

⚙️ Parameters

entity_type: typing.Optional[ListEntityTraitDefinitionsRequestEntityType]

ids: typing.Optional[typing.Union[str, typing.Sequence[str]]]

trait_type: typing.Optional[ListEntityTraitDefinitionsRequestTraitType]

q: typing.Optional[str]

limit: typing.Optional[int] — Page limit (default 100)

offset: typing.Optional[int] — Page offset (default 0)

request_options: typing.Optional[RequestOptions] — Request-specific configuration.

client.companies.get_or_create_entity_trait_definition(...)

🔌 Usage

from schematic import Schematic

client = Schematic(
    api_key="YOUR_API_KEY",
)
client.companies.get_or_create_entity_trait_definition(
    entity_type="company",
    hierarchy=["hierarchy"],
    trait_type="boolean",
)

⚙️ Parameters

entity_type: CreateEntityTraitDefinitionRequestBodyEntityType

hierarchy: typing.Sequence[str]

trait_type: CreateEntityTraitDefinitionRequestBodyTraitType

display_name: typing.Optional[str]

request_options: typing.Optional[RequestOptions] — Request-specific configuration.

client.companies.get_entity_trait_definition(...)

🔌 Usage

from schematic import Schematic

client = Schematic(
    api_key="YOUR_API_KEY",
)
client.companies.get_entity_trait_definition(
    entity_trait_definition_id="entity_trait_definition_id",
)

⚙️ Parameters

entity_trait_definition_id: str — entity_trait_definition_id

request_options: typing.Optional[RequestOptions] — Request-specific configuration.

client.companies.update_entity_trait_definition(...)

🔌 Usage

from schematic import Schematic

client = Schematic(
    api_key="YOUR_API_KEY",
)
client.companies.update_entity_trait_definition(
    entity_trait_definition_id="entity_trait_definition_id",
    trait_type="boolean",
)

⚙️ Parameters

entity_trait_definition_id: str — entity_trait_definition_id

trait_type: UpdateEntityTraitDefinitionRequestBodyTraitType

display_name: typing.Optional[str]

request_options: typing.Optional[RequestOptions] — Request-specific configuration.

client.companies.count_entity_trait_definitions(...)

🔌 Usage

from schematic import Schematic

client = Schematic(
    api_key="YOUR_API_KEY",
)
client.companies.count_entity_trait_definitions()

⚙️ Parameters

entity_type: typing.Optional[CountEntityTraitDefinitionsRequestEntityType]

ids: typing.Optional[typing.Union[str, typing.Sequence[str]]]

trait_type: typing.Optional[CountEntityTraitDefinitionsRequestTraitType]

q: typing.Optional[str]

limit: typing.Optional[int] — Page limit (default 100)

offset: typing.Optional[int] — Page offset (default 0)

request_options: typing.Optional[RequestOptions] — Request-specific configuration.

client.companies.get_entity_trait_values(...)

🔌 Usage

from schematic import Schematic

client = Schematic(
    api_key="YOUR_API_KEY",
)
client.companies.get_entity_trait_values(
    definition_id="definition_id",
)

⚙️ Parameters

definition_id: str

q: typing.Optional[str]

limit: typing.Optional[int] — Page limit (default 100)

offset: typing.Optional[int] — Page offset (default 0)

request_options: typing.Optional[RequestOptions] — Request-specific configuration.

client.companies.upsert_user_trait(...)

🔌 Usage

from schematic import Schematic

client = Schematic(
    api_key="YOUR_API_KEY",
)
client.companies.upsert_user_trait(
    keys={"key": "value"},
    trait="trait",
)

⚙️ Parameters

keys: typing.Dict[str, str] — Key/value pairs too identify a company or user

trait: str — Name of the trait to update

incr: typing.Optional[int] — Amount to increment the trait by (positive or negative)

set_: typing.Optional[str] — Value to set the trait to

update_only: typing.Optional[bool] — Unless this is set, the company or user will be created if it does not already exist

request_options: typing.Optional[RequestOptions] — Request-specific configuration.

client.companies.list_users(...)

🔌 Usage

from schematic import Schematic

client = Schematic(
    api_key="YOUR_API_KEY",
)
client.companies.list_users()

⚙️ Parameters

company_id: typing.Optional[str]

ids: typing.Optional[typing.Union[str, typing.Sequence[str]]]

plan_id: typing.Optional[str]

q: typing.Optional[str] — Search filter

limit: typing.Optional[int] — Page limit (default 100)

offset: typing.Optional[int] — Page offset (default 0)

request_options: typing.Optional[RequestOptions] — Request-specific configuration.

client.companies.upsert_user(...)

🔌 Usage

from schematic import Schematic

client = Schematic(
    api_key="YOUR_API_KEY",
)
client.companies.upsert_user(
    company={"key": "value"},
    keys={"key": "value"},
)

⚙️ Parameters

company: typing.Dict[str, str] — Optionally specify company using key/value pairs

keys: typing.Dict[str, str]

company_id: typing.Optional[str] — Optionally specify company using Schematic company ID

id: typing.Optional[str] — If you know the Schematic ID, you can use that here instead of keys

last_seen_at: typing.Optional[dt.datetime]

name: typing.Optional[str]

traits: typing.Optional[typing.Dict[str, typing.Optional[typing.Any]]] — A map of trait names to trait values

update_only: typing.Optional[bool]

request_options: typing.Optional[RequestOptions] — Request-specific configuration.

client.companies.get_user(...)

🔌 Usage

from schematic import Schematic

client = Schematic(
    api_key="YOUR_API_KEY",
)
client.companies.get_user(
    user_id="user_id",
)

⚙️ Parameters

user_id: str — user_id

request_options: typing.Optional[RequestOptions] — Request-specific configuration.

client.companies.delete_user(...)

🔌 Usage

from schematic import Schematic

client = Schematic(
    api_key="YOUR_API_KEY",
)
client.companies.delete_user(
    user_id="user_id",
)

⚙️ Parameters

user_id: str — user_id

request_options: typing.Optional[RequestOptions] — Request-specific configuration.

client.companies.count_users(...)

🔌 Usage

from schematic import Schematic

client = Schematic(
    api_key="YOUR_API_KEY",
)
client.companies.count_users()

⚙️ Parameters

company_id: typing.Optional[str]

ids: typing.Optional[typing.Union[str, typing.Sequence[str]]]

plan_id: typing.Optional[str]

q: typing.Optional[str] — Search filter

limit: typing.Optional[int] — Page limit (default 100)

offset: typing.Optional[int] — Page offset (default 0)

request_options: typing.Optional[RequestOptions] — Request-specific configuration.

client.companies.create_user(...)

🔌 Usage

from schematic import Schematic

client = Schematic(
    api_key="YOUR_API_KEY",
)
client.companies.create_user(
    company={"key": "value"},
    keys={"key": "value"},
)

⚙️ Parameters

company: typing.Dict[str, str] — Optionally specify company using key/value pairs

keys: typing.Dict[str, str]

company_id: typing.Optional[str] — Optionally specify company using Schematic company ID

id: typing.Optional[str] — If you know the Schematic ID, you can use that here instead of keys

last_seen_at: typing.Optional[dt.datetime]

name: typing.Optional[str]

traits: typing.Optional[typing.Dict[str, typing.Optional[typing.Any]]] — A map of trait names to trait values

update_only: typing.Optional[bool]

request_options: typing.Optional[RequestOptions] — Request-specific configuration.

client.companies.delete_user_by_keys(...)

🔌 Usage

from schematic import Schematic

client = Schematic(
    api_key="YOUR_API_KEY",
)
client.companies.delete_user_by_keys(
    keys={"key": "value"},
)

⚙️ Parameters

keys: typing.Dict[str, str]

request_options: typing.Optional[RequestOptions] — Request-specific configuration.

client.companies.lookup_user(...)

🔌 Usage

from schematic import Schematic

client = Schematic(
    api_key="YOUR_API_KEY",
)
client.companies.lookup_user(
    keys={"string": {"key": "value"}},
)

⚙️ Parameters

keys: typing.Dict[str, typing.Optional[typing.Any]] — Key/value pairs

request_options: typing.Optional[RequestOptions] — Request-specific configuration.

entitlements

client.entitlements.list_company_overrides(...)

🔌 Usage

from schematic import Schematic

client = Schematic(
    api_key="YOUR_API_KEY",
)
client.entitlements.list_company_overrides()

⚙️ Parameters

company_id: typing.Optional[str]

company_ids: typing.Optional[typing.Union[str, typing.Sequence[str]]]

feature_id: typing.Optional[str]

feature_ids: typing.Optional[typing.Union[str, typing.Sequence[str]]]

ids: typing.Optional[typing.Union[str, typing.Sequence[str]]]

q: typing.Optional[str]

limit: typing.Optional[int] — Page limit (default 100)

offset: typing.Optional[int] — Page offset (default 0)

request_options: typing.Optional[RequestOptions] — Request-specific configuration.

client.entitlements.create_company_override(...)

🔌 Usage

from schematic import Schematic

client = Schematic(
    api_key="YOUR_API_KEY",
)
client.entitlements.create_company_override(
    company_id="company_id",
    feature_id="feature_id",
    value_type="boolean",
)

⚙️ Parameters

company_id: str

feature_id: str

value_type: CreateCompanyOverrideRequestBodyValueType

metric_period: typing.Optional[CreateCompanyOverrideRequestBodyMetricPeriod]

value_bool: typing.Optional[bool]

value_numeric: typing.Optional[int]

value_trait_id: typing.Optional[str]

request_options: typing.Optional[RequestOptions] — Request-specific configuration.

client.entitlements.get_company_override(...)

🔌 Usage

from schematic import Schematic

client = Schematic(
    api_key="YOUR_API_KEY",
)
client.entitlements.get_company_override(
    company_override_id="company_override_id",
)

⚙️ Parameters

company_override_id: str — company_override_id

request_options: typing.Optional[RequestOptions] — Request-specific configuration.

client.entitlements.update_company_override(...)

🔌 Usage

from schematic import Schematic

client = Schematic(
    api_key="YOUR_API_KEY",
)
client.entitlements.update_company_override(
    company_override_id="company_override_id",
    value_type="boolean",
)

⚙️ Parameters

company_override_id: str — company_override_id

value_type: UpdateCompanyOverrideRequestBodyValueType

metric_period: typing.Optional[UpdateCompanyOverrideRequestBodyMetricPeriod]

value_bool: typing.Optional[bool]

value_numeric: typing.Optional[int]

value_trait_id: typing.Optional[str]

request_options: typing.Optional[RequestOptions] — Request-specific configuration.

client.entitlements.delete_company_override(...)

🔌 Usage

from schematic import Schematic

client = Schematic(
    api_key="YOUR_API_KEY",
)
client.entitlements.delete_company_override(
    company_override_id="company_override_id",
)

⚙️ Parameters

company_override_id: str — company_override_id

request_options: typing.Optional[RequestOptions] — Request-specific configuration.

client.entitlements.count_company_overrides(...)

🔌 Usage

from schematic import Schematic

client = Schematic(
    api_key="YOUR_API_KEY",
)
client.entitlements.count_company_overrides()

⚙️ Parameters

company_id: typing.Optional[str]

company_ids: typing.Optional[typing.Union[str, typing.Sequence[str]]]

feature_id: typing.Optional[str]

feature_ids: typing.Optional[typing.Union[str, typing.Sequence[str]]]

ids: typing.Optional[typing.Union[str, typing.Sequence[str]]]

q: typing.Optional[str]

limit: typing.Optional[int] — Page limit (default 100)

offset: typing.Optional[int] — Page offset (default 0)

request_options: typing.Optional[RequestOptions] — Request-specific configuration.

client.entitlements.list_feature_companies(...)

🔌 Usage

from schematic import Schematic

client = Schematic(
    api_key="YOUR_API_KEY",
)
client.entitlements.list_feature_companies(
    feature_id="feature_id",
)

⚙️ Parameters

feature_id: str

q: typing.Optional[str]

limit: typing.Optional[int] — Page limit (default 100)

offset: typing.Optional[int] — Page offset (default 0)

request_options: typing.Optional[RequestOptions] — Request-specific configuration.

client.entitlements.count_feature_companies(...)

🔌 Usage

from schematic import Schematic

client = Schematic(
    api_key="YOUR_API_KEY",
)
client.entitlements.count_feature_companies(
    feature_id="feature_id",
)

⚙️ Parameters

feature_id: str

q: typing.Optional[str]

limit: typing.Optional[int] — Page limit (default 100)

offset: typing.Optional[int] — Page offset (default 0)

request_options: typing.Optional[RequestOptions] — Request-specific configuration.

client.entitlements.list_feature_usage(...)

🔌 Usage

from schematic import Schematic

client = Schematic(
    api_key="YOUR_API_KEY",
)
client.entitlements.list_feature_usage()

⚙️ Parameters

company_id: typing.Optional[str]

company_keys: typing.Optional[typing.Dict[str, str]]

feature_ids: typing.Optional[typing.Union[str, typing.Sequence[str]]]

q: typing.Optional[str]

limit: typing.Optional[int] — Page limit (default 100)

offset: typing.Optional[int] — Page offset (default 0)

request_options: typing.Optional[RequestOptions] — Request-specific configuration.

client.entitlements.count_feature_usage(...)

🔌 Usage

from schematic import Schematic

client = Schematic(
    api_key="YOUR_API_KEY",
)
client.entitlements.count_feature_usage()

⚙️ Parameters

company_id: typing.Optional[str]

company_keys: typing.Optional[typing.Dict[str, str]]

feature_ids: typing.Optional[typing.Union[str, typing.Sequence[str]]]

q: typing.Optional[str]

limit: typing.Optional[int] — Page limit (default 100)

offset: typing.Optional[int] — Page offset (default 0)

request_options: typing.Optional[RequestOptions] — Request-specific configuration.

client.entitlements.list_feature_users(...)

🔌 Usage

from schematic import Schematic

client = Schematic(
    api_key="YOUR_API_KEY",
)
client.entitlements.list_feature_users(
    feature_id="feature_id",
)

⚙️ Parameters

feature_id: str

q: typing.Optional[str]

limit: typing.Optional[int] — Page limit (default 100)

offset: typing.Optional[int] — Page offset (default 0)

request_options: typing.Optional[RequestOptions] — Request-specific configuration.

client.entitlements.count_feature_users(...)

🔌 Usage

from schematic import Schematic

client = Schematic(
    api_key="YOUR_API_KEY",
)
client.entitlements.count_feature_users(
    feature_id="feature_id",
)

⚙️ Parameters

feature_id: str

q: typing.Optional[str]

limit: typing.Optional[int] — Page limit (default 100)

offset: typing.Optional[int] — Page offset (default 0)

request_options: typing.Optional[RequestOptions] — Request-specific configuration.

client.entitlements.list_plan_entitlements(...)

🔌 Usage

from schematic import Schematic

client = Schematic(
    api_key="YOUR_API_KEY",
)
client.entitlements.list_plan_entitlements()

⚙️ Parameters

feature_id: typing.Optional[str]

feature_ids: typing.Optional[typing.Union[str, typing.Sequence[str]]]

ids: typing.Optional[typing.Union[str, typing.Sequence[str]]]

plan_id: typing.Optional[str]

plan_ids: typing.Optional[typing.Union[str, typing.Sequence[str]]]

q: typing.Optional[str]

limit: typing.Optional[int] — Page limit (default 100)

offset: typing.Optional[int] — Page offset (default 0)

request_options: typing.Optional[RequestOptions] — Request-specific configuration.

client.entitlements.create_plan_entitlement(...)

🔌 Usage

from schematic import Schematic

client = Schematic(
    api_key="YOUR_API_KEY",
)
client.entitlements.create_plan_entitlement(
    feature_id="feature_id",
    plan_id="plan_id",
    value_type="boolean",
)

⚙️ Parameters

feature_id: str

plan_id: str

value_type: CreatePlanEntitlementRequestBodyValueType

metric_period: typing.Optional[CreatePlanEntitlementRequestBodyMetricPeriod]

value_bool: typing.Optional[bool]

value_numeric: typing.Optional[int]

value_trait_id: typing.Optional[str]

request_options: typing.Optional[RequestOptions] — Request-specific configuration.

client.entitlements.get_plan_entitlement(...)

🔌 Usage

from schematic import Schematic

client = Schematic(
    api_key="YOUR_API_KEY",
)
client.entitlements.get_plan_entitlement(
    plan_entitlement_id="plan_entitlement_id",
)

⚙️ Parameters

plan_entitlement_id: str — plan_entitlement_id

request_options: typing.Optional[RequestOptions] — Request-specific configuration.

client.entitlements.update_plan_entitlement(...)

🔌 Usage

from schematic import Schematic

client = Schematic(
    api_key="YOUR_API_KEY",
)
client.entitlements.update_plan_entitlement(
    plan_entitlement_id="plan_entitlement_id",
    value_type="boolean",
)

⚙️ Parameters

plan_entitlement_id: str — plan_entitlement_id

value_type: UpdatePlanEntitlementRequestBodyValueType

metric_period: typing.Optional[UpdatePlanEntitlementRequestBodyMetricPeriod]

value_bool: typing.Optional[bool]

value_numeric: typing.Optional[int]

value_trait_id: typing.Optional[str]

request_options: typing.Optional[RequestOptions] — Request-specific configuration.

client.entitlements.delete_plan_entitlement(...)

🔌 Usage

from schematic import Schematic

client = Schematic(
    api_key="YOUR_API_KEY",
)
client.entitlements.delete_plan_entitlement(
    plan_entitlement_id="plan_entitlement_id",
)

⚙️ Parameters

plan_entitlement_id: str — plan_entitlement_id

request_options: typing.Optional[RequestOptions] — Request-specific configuration.

client.entitlements.count_plan_entitlements(...)

🔌 Usage

from schematic import Schematic

client = Schematic(
    api_key="YOUR_API_KEY",
)
client.entitlements.count_plan_entitlements()

⚙️ Parameters

feature_id: typing.Optional[str]

feature_ids: typing.Optional[typing.Union[str, typing.Sequence[str]]]

ids: typing.Optional[typing.Union[str, typing.Sequence[str]]]

plan_id: typing.Optional[str]

plan_ids: typing.Optional[typing.Union[str, typing.Sequence[str]]]

q: typing.Optional[str]

limit: typing.Optional[int] — Page limit (default 100)

offset: typing.Optional[int] — Page offset (default 0)

request_options: typing.Optional[RequestOptions] — Request-specific configuration.

client.entitlements.get_feature_usage_by_company(...)

🔌 Usage

from schematic import Schematic

client = Schematic(
    api_key="YOUR_API_KEY",
)
client.entitlements.get_feature_usage_by_company(
    keys={"string": {"key": "value"}},
)

⚙️ Parameters

keys: typing.Dict[str, typing.Optional[typing.Any]] — Key/value pairs

request_options: typing.Optional[RequestOptions] — Request-specific configuration.

components

client.components.list_components(...)

🔌 Usage

from schematic import Schematic

client = Schematic(
    api_key="YOUR_API_KEY",
)
client.components.list_components()

⚙️ Parameters

q: typing.Optional[str]

limit: typing.Optional[int] — Page limit (default 100)

offset: typing.Optional[int] — Page offset (default 0)

request_options: typing.Optional[RequestOptions] — Request-specific configuration.

client.components.create_component(...)

🔌 Usage

from schematic import Schematic

client = Schematic(
    api_key="YOUR_API_KEY",
)
client.components.create_component(
    entity_type="entitlement",
    name="name",
)

⚙️ Parameters

entity_type: CreateComponentRequestBodyEntityType

name: str

ast: typing.Optional[typing.Dict[str, float]]

request_options: typing.Optional[RequestOptions] — Request-specific configuration.

client.components.get_component(...)

🔌 Usage

from schematic import Schematic

client = Schematic(
    api_key="YOUR_API_KEY",
)
client.components.get_component(
    component_id="component_id",
)

⚙️ Parameters

component_id: str — component_id

request_options: typing.Optional[RequestOptions] — Request-specific configuration.

client.components.update_component(...)

🔌 Usage

from schematic import Schematic

client = Schematic(
    api_key="YOUR_API_KEY",
)
client.components.update_component(
    component_id="component_id",
)

⚙️ Parameters

component_id: str — component_id

ast: typing.Optional[typing.Dict[str, float]]

entity_type: typing.Optional[UpdateComponentRequestBodyEntityType]

name: typing.Optional[str]

state: typing.Optional[UpdateComponentRequestBodyState]

request_options: typing.Optional[RequestOptions] — Request-specific configuration.

client.components.delete_component(...)

🔌 Usage

from schematic import Schematic

client = Schematic(
    api_key="YOUR_API_KEY",
)
client.components.delete_component(
    component_id="component_id",
)

⚙️ Parameters

component_id: str — component_id

request_options: typing.Optional[RequestOptions] — Request-specific configuration.

client.components.count_components(...)

🔌 Usage

from schematic import Schematic

client = Schematic(
    api_key="YOUR_API_KEY",
)
client.components.count_components()

⚙️ Parameters

q: typing.Optional[str]

limit: typing.Optional[int] — Page limit (default 100)

offset: typing.Optional[int] — Page offset (default 0)

request_options: typing.Optional[RequestOptions] — Request-specific configuration.

client.components.preview_component_data(...)

🔌 Usage

from schematic import Schematic

client = Schematic(
    api_key="YOUR_API_KEY",
)
client.components.preview_component_data()

⚙️ Parameters

company_id: typing.Optional[str]

component_id: typing.Optional[str]

request_options: typing.Optional[RequestOptions] — Request-specific configuration.

crm

client.crm.upsert_deal_line_item_association(...)

🔌 Usage

from schematic import Schematic

client = Schematic(
    api_key="YOUR_API_KEY",
)
client.crm.upsert_deal_line_item_association(
    deal_external_id="deal_external_id",
    line_item_external_id="line_item_external_id",
)

⚙️ Parameters

deal_external_id: str

line_item_external_id: str

request_options: typing.Optional[RequestOptions] — Request-specific configuration.

client.crm.upsert_line_item(...)

🔌 Usage

from schematic import Schematic

client = Schematic(
    api_key="YOUR_API_KEY",
)
client.crm.upsert_line_item(
    amount="amount",
    interval="interval",
    line_item_external_id="line_item_external_id",
    product_external_id="product_external_id",
    quantity=1,
)

⚙️ Parameters

amount: str

interval: str

line_item_external_id: str

product_external_id: str

quantity: int

term_month: typing.Optional[int]

discount_percentage: typing.Optional[str]

total_discount: typing.Optional[str]

request_options: typing.Optional[RequestOptions] — Request-specific configuration.

client.crm.upsert_crm_deal(...)

🔌 Usage

from schematic import Schematic

client = Schematic(
    api_key="YOUR_API_KEY",
)
client.crm.upsert_crm_deal(
    crm_company_key="crm_company_key",
    crm_type="crm_type",
    deal_external_id="deal_external_id",
)

⚙️ Parameters

crm_company_key: str

crm_type: str

deal_external_id: str

arr: typing.Optional[str]

crm_company_id: typing.Optional[str]

crm_product_id: typing.Optional[str]

deal_name: typing.Optional[str]

deal_stage: typing.Optional[str]

mrr: typing.Optional[str]

request_options: typing.Optional[RequestOptions] — Request-specific configuration.

client.crm.list_crm_products(...)

🔌 Usage

from schematic import Schematic

client = Schematic(
    api_key="YOUR_API_KEY",
)
client.crm.list_crm_products()

⚙️ Parameters

ids: typing.Optional[typing.Union[str, typing.Sequence[str]]]

name: typing.Optional[str]

limit: typing.Optional[int] — Page limit (default 100)

offset: typing.Optional[int] — Page offset (default 0)

request_options: typing.Optional[RequestOptions] — Request-specific configuration.

client.crm.upsert_crm_product(...)

🔌 Usage

from schematic import Schematic

client = Schematic(
    api_key="YOUR_API_KEY",
)
client.crm.upsert_crm_product(
    currency="currency",
    description="description",
    external_id="external_id",
    interval="interval",
    name="name",
    price="price",
    quantity=1,
    sku="sku",
)

⚙️ Parameters

currency: str

description: str

external_id: str

interval: str

name: str

price: str

quantity: int

sku: str

request_options: typing.Optional[RequestOptions] — Request-specific configuration.

events

client.events.create_event_batch(...)

🔌 Usage

from schematic import CreateEventRequestBody, Schematic

client = Schematic(
    api_key="YOUR_API_KEY",
)
client.events.create_event_batch(
    events=[
        CreateEventRequestBody(
            event_type="identify",
        )
    ],
)

⚙️ Parameters

events: typing.Sequence[CreateEventRequestBody]

request_options: typing.Optional[RequestOptions] — Request-specific configuration.

client.events.get_event_summaries(...)

🔌 Usage

from schematic import Schematic

client = Schematic(
    api_key="YOUR_API_KEY",
)
client.events.get_event_summaries()

⚙️ Parameters

q: typing.Optional[str]

event_subtypes: typing.Optional[typing.Union[str, typing.Sequence[str]]]

limit: typing.Optional[int] — Page limit (default 100)

offset: typing.Optional[int] — Page offset (default 0)

request_options: typing.Optional[RequestOptions] — Request-specific configuration.

client.events.get_event_summary_by_subtype(...)

🔌 Usage

from schematic import Schematic

client = Schematic(
    api_key="YOUR_API_KEY",
)
client.events.get_event_summary_by_subtype(
    key="key",
)

⚙️ Parameters

key: str — key

request_options: typing.Optional[RequestOptions] — Request-specific configuration.

client.events.list_events(...)

🔌 Usage

from schematic import Schematic

client = Schematic(
    api_key="YOUR_API_KEY",
)
client.events.list_events()

⚙️ Parameters

company_id: typing.Optional[str]

event_subtype: typing.Optional[str]

event_types: typing.Optional[typing.Union[str, typing.Sequence[str]]]

flag_id: typing.Optional[str]

user_id: typing.Optional[str]

limit: typing.Optional[int] — Page limit (default 100)

offset: typing.Optional[int] — Page offset (default 0)

request_options: typing.Optional[RequestOptions] — Request-specific configuration.

client.events.create_event(...)

🔌 Usage

from schematic import Schematic

client = Schematic(
    api_key="YOUR_API_KEY",
)
client.events.create_event(
    event_type="identify",
)

⚙️ Parameters

event_type: CreateEventRequestBodyEventType — Either 'identify' or 'track'

body: typing.Optional[EventBody]

sent_at: typing.Optional[dt.datetime] — Optionally provide a timestamp at which the event was sent to Schematic

request_options: typing.Optional[RequestOptions] — Request-specific configuration.

client.events.get_event(...)

🔌 Usage

from schematic import Schematic

client = Schematic(
    api_key="YOUR_API_KEY",
)
client.events.get_event(
    event_id="event_id",
)

⚙️ Parameters

event_id: str — event_id

request_options: typing.Optional[RequestOptions] — Request-specific configuration.

client.events.list_metric_counts(...)

🔌 Usage

from schematic import Schematic

client = Schematic(
    api_key="YOUR_API_KEY",
)
client.events.list_metric_counts()

⚙️ Parameters

start_time: typing.Optional[dt.datetime]

end_time: typing.Optional[dt.datetime]

event_subtype: typing.Optional[str]

event_subtypes: typing.Optional[typing.Union[str, typing.Sequence[str]]]

company_id: typing.Optional[str]

company_ids: typing.Optional[typing.Union[str, typing.Sequence[str]]]

user_id: typing.Optional[str]

limit: typing.Optional[int] — Page limit (default 100)

offset: typing.Optional[int] — Page offset (default 0)

grouping: typing.Optional[str]

request_options: typing.Optional[RequestOptions] — Request-specific configuration.

client.events.get_segment_integration_status()

🔌 Usage

from schematic import Schematic

client = Schematic(
    api_key="YOUR_API_KEY",
)
client.events.get_segment_integration_status()

⚙️ Parameters

request_options: typing.Optional[RequestOptions] — Request-specific configuration.

plans

client.plans.get_audience(...)

🔌 Usage

from schematic import Schematic

client = Schematic(
    api_key="YOUR_API_KEY",
)
client.plans.get_audience(
    plan_audience_id="plan_audience_id",
)

⚙️ Parameters

plan_audience_id: str — plan_audience_id

request_options: typing.Optional[RequestOptions] — Request-specific configuration.

client.plans.update_audience(...)

🔌 Usage

from schematic import (
    CreateOrUpdateConditionGroupRequestBody,
    CreateOrUpdateConditionRequestBody,
    Schematic,
)

client = Schematic(
    api_key="YOUR_API_KEY",
)
client.plans.update_audience(
    plan_audience_id="plan_audience_id",
    condition_groups=[
        CreateOrUpdateConditionGroupRequestBody(
            conditions=[
                CreateOrUpdateConditionRequestBody(
                    condition_type="company",
                    operator="eq",
                    resource_ids=["resource_ids"],
                )
            ],
        )
    ],
    conditions=[
        CreateOrUpdateConditionRequestBody(
            condition_type="company",
            operator="eq",
            resource_ids=["resource_ids"],
        )
    ],
)

⚙️ Parameters

plan_audience_id: str — plan_audience_id

condition_groups: typing.Sequence[CreateOrUpdateConditionGroupRequestBody]

conditions: typing.Sequence[CreateOrUpdateConditionRequestBody]

request_options: typing.Optional[RequestOptions] — Request-specific configuration.

client.plans.delete_audience(...)

🔌 Usage

from schematic import Schematic

client = Schematic(
    api_key="YOUR_API_KEY",
)
client.plans.delete_audience(
    plan_audience_id="plan_audience_id",
)

⚙️ Parameters

plan_audience_id: str — plan_audience_id

request_options: typing.Optional[RequestOptions] — Request-specific configuration.

client.plans.list_plans(...)

🔌 Usage

from schematic import Schematic

client = Schematic(
    api_key="YOUR_API_KEY",
)
client.plans.list_plans()

⚙️ Parameters

company_id: typing.Optional[str]

ids: typing.Optional[typing.Union[str, typing.Sequence[str]]]

q: typing.Optional[str]

plan_type: typing.Optional[ListPlansRequestPlanType] — Filter by plan type

has_product_id: typing.Optional[bool] — Filter out plans that do not have a billing product ID

without_entitlement_for: typing.Optional[str] — Filter out plans that already have a plan entitlement for the specified feature ID

limit: typing.Optional[int] — Page limit (default 100)

offset: typing.Optional[int] — Page offset (default 0)

request_options: typing.Optional[RequestOptions] — Request-specific configuration.

client.plans.create_plan(...)

🔌 Usage

from schematic import Schematic

client = Schematic(
    api_key="YOUR_API_KEY",
)
client.plans.create_plan(
    description="description",
    name="name",
    plan_type="plan",
)

⚙️ Parameters

description: str

name: str

plan_type: CreatePlanRequestBodyPlanType

icon: typing.Optional[str]

request_options: typing.Optional[RequestOptions] — Request-specific configuration.

client.plans.get_plan(...)

🔌 Usage

from schematic import Schematic

client = Schematic(
    api_key="YOUR_API_KEY",
)
client.plans.get_plan(
    plan_id="plan_id",
)

⚙️ Parameters

plan_id: str — plan_id

request_options: typing.Optional[RequestOptions] — Request-specific configuration.

client.plans.update_plan(...)

🔌 Usage

from schematic import Schematic

client = Schematic(
    api_key="YOUR_API_KEY",
)
client.plans.update_plan(
    plan_id="plan_id",
    name="name",
)

⚙️ Parameters

plan_id: str — plan_id

name: str

description: typing.Optional[str]

icon: typing.Optional[str]

request_options: typing.Optional[RequestOptions] — Request-specific configuration.

client.plans.delete_plan(...)

🔌 Usage

from schematic import Schematic

client = Schematic(
    api_key="YOUR_API_KEY",
)
client.plans.delete_plan(
    plan_id="plan_id",
)

⚙️ Parameters

plan_id: str — plan_id

request_options: typing.Optional[RequestOptions] — Request-specific configuration.

client.plans.upsert_billing_product_plan(...)

🔌 Usage

from schematic import Schematic

client = Schematic(
    api_key="YOUR_API_KEY",
)
client.plans.upsert_billing_product_plan(
    plan_id="plan_id",
    billing_product_id="billing_product_id",
)

⚙️ Parameters

plan_id: str — plan_id

billing_product_id: str

monthly_price_id: typing.Optional[str]

yearly_price_id: typing.Optional[str]

request_options: typing.Optional[RequestOptions] — Request-specific configuration.

client.plans.count_plans(...)

🔌 Usage

from schematic import Schematic

client = Schematic(
    api_key="YOUR_API_KEY",
)
client.plans.count_plans()

⚙️ Parameters

company_id: typing.Optional[str]

ids: typing.Optional[typing.Union[str, typing.Sequence[str]]]

q: typing.Optional[str]

plan_type: typing.Optional[CountPlansRequestPlanType] — Filter by plan type

has_product_id: typing.Optional[bool] — Filter out plans that do not have a billing product ID

without_entitlement_for: typing.Optional[str] — Filter out plans that already have a plan entitlement for the specified feature ID

limit: typing.Optional[int] — Page limit (default 100)

offset: typing.Optional[int] — Page offset (default 0)

request_options: typing.Optional[RequestOptions] — Request-specific configuration.

plangroups

client.plangroups.get_plan_group()

🔌 Usage

from schematic import Schematic

client = Schematic(
    api_key="YOUR_API_KEY",
)
client.plangroups.get_plan_group()

⚙️ Parameters

request_options: typing.Optional[RequestOptions] — Request-specific configuration.

client.plangroups.create_plan_group(...)

🔌 Usage

from schematic import Schematic

client = Schematic(
    api_key="YOUR_API_KEY",
)
client.plangroups.create_plan_group(
    plan_ids=["plan_ids"],
)

⚙️ Parameters

plan_ids: typing.Sequence[str]

default_plan_id: typing.Optional[str]

request_options: typing.Optional[RequestOptions] — Request-specific configuration.

client.plangroups.update_plan_group(...)

🔌 Usage

from schematic import Schematic

client = Schematic(
    api_key="YOUR_API_KEY",
)
client.plangroups.update_plan_group(
    plan_group_id="plan_group_id",
    plan_ids=["plan_ids"],
)

⚙️ Parameters

plan_group_id: str — plan_group_id

plan_ids: typing.Sequence[str]

default_plan_id: typing.Optional[str]

request_options: typing.Optional[RequestOptions] — Request-specific configuration.

accesstokens

client.accesstokens.issue_temporary_access_token(...)

🔌 Usage

from schematic import Schematic

client = Schematic(
    api_key="YOUR_API_KEY",
)
client.accesstokens.issue_temporary_access_token(
    lookup={"key": "value"},
    resource_type="resource_type",
)

⚙️ Parameters

lookup: typing.Dict[str, str]

resource_type: str

request_options: typing.Optional[RequestOptions] — Request-specific configuration.

webhooks

client.webhooks.list_webhook_events(...)

🔌 Usage

from schematic import Schematic

client = Schematic(
    api_key="YOUR_API_KEY",
)
client.webhooks.list_webhook_events()

⚙️ Parameters

webhook_id: typing.Optional[str]

ids: typing.Optional[typing.Union[str, typing.Sequence[str]]]

q: typing.Optional[str]

limit: typing.Optional[int] — Page limit (default 100)

offset: typing.Optional[int] — Page offset (default 0)

request_options: typing.Optional[RequestOptions] — Request-specific configuration.

client.webhooks.get_webhook_event(...)

🔌 Usage

from schematic import Schematic

client = Schematic(
    api_key="YOUR_API_KEY",
)
client.webhooks.get_webhook_event(
    webhook_event_id="webhook_event_id",
)

⚙️ Parameters

webhook_event_id: str — webhook_event_id

request_options: typing.Optional[RequestOptions] — Request-specific configuration.

client.webhooks.count_webhook_events(...)

🔌 Usage

from schematic import Schematic

client = Schematic(
    api_key="YOUR_API_KEY",
)
client.webhooks.count_webhook_events()

⚙️ Parameters

webhook_id: typing.Optional[str]

ids: typing.Optional[typing.Union[str, typing.Sequence[str]]]

q: typing.Optional[str]

limit: typing.Optional[int] — Page limit (default 100)

offset: typing.Optional[int] — Page offset (default 0)

request_options: typing.Optional[RequestOptions] — Request-specific configuration.

client.webhooks.list_webhooks(...)

🔌 Usage

from schematic import Schematic

client = Schematic(
    api_key="YOUR_API_KEY",
)
client.webhooks.list_webhooks()

⚙️ Parameters

q: typing.Optional[str]

limit: typing.Optional[int] — Page limit (default 100)

offset: typing.Optional[int] — Page offset (default 0)

request_options: typing.Optional[RequestOptions] — Request-specific configuration.

client.webhooks.create_webhook(...)

🔌 Usage

from schematic import Schematic

client = Schematic(
    api_key="YOUR_API_KEY",
)
client.webhooks.create_webhook(
    name="name",
    request_types=["company.updated"],
    url="url",
)

⚙️ Parameters

name: str

request_types: typing.Sequence[CreateWebhookRequestBodyRequestTypesItem]

url: str

request_options: typing.Optional[RequestOptions] — Request-specific configuration.

client.webhooks.get_webhook(...)

🔌 Usage

from schematic import Schematic

client = Schematic(
    api_key="YOUR_API_KEY",
)
client.webhooks.get_webhook(
    webhook_id="webhook_id",
)

⚙️ Parameters

webhook_id: str — webhook_id

request_options: typing.Optional[RequestOptions] — Request-specific configuration.

client.webhooks.update_webhook(...)

🔌 Usage

from schematic import Schematic

client = Schematic(
    api_key="YOUR_API_KEY",
)
client.webhooks.update_webhook(
    webhook_id="webhook_id",
)

⚙️ Parameters

webhook_id: str — webhook_id

name: typing.Optional[str]

request_types: typing.Optional[typing.Sequence[UpdateWebhookRequestBodyRequestTypesItem]]

status: typing.Optional[UpdateWebhookRequestBodyStatus]

url: typing.Optional[str]

request_options: typing.Optional[RequestOptions] — Request-specific configuration.

client.webhooks.delete_webhook(...)

🔌 Usage

from schematic import Schematic

client = Schematic(
    api_key="YOUR_API_KEY",
)
client.webhooks.delete_webhook(
    webhook_id="webhook_id",
)

⚙️ Parameters

webhook_id: str — webhook_id

request_options: typing.Optional[RequestOptions] — Request-specific configuration.

client.webhooks.count_webhooks(...)

🔌 Usage

from schematic import Schematic

client = Schematic(
    api_key="YOUR_API_KEY",
)
client.webhooks.count_webhooks()

⚙️ Parameters

q: typing.Optional[str]

limit: typing.Optional[int] — Page limit (default 100)

offset: typing.Optional[int] — Page offset (default 0)

request_options: typing.Optional[RequestOptions] — Request-specific configuration.