Variable ProductlerDBConst

Type declaration

• addOnProducts: {
      getAddOnProducts: ((__namedParameters) => Promise<string[]>);
      setAddOnProducts: ((__namedParameters) => Promise<void>);
  }

  • getAddOnProducts: ((__namedParameters) => Promise<string[]>)

    • • (__namedParameters): Promise<string[]>

      • Parameters

        • __namedParameters: {
              bundleId?: number;
              productId?: string;
          }

          • Optional bundleId?: number

          • Optional productId?: string

        Returns Promise<string[]>

  • setAddOnProducts: ((__namedParameters) => Promise<void>)

    • • (__namedParameters): Promise<void>

      • Parameters

        • __namedParameters: {
              addOnProductIds: string[];
              bundleId?: number;
              productId?: string;
          }

          • addOnProductIds: string[]

          • Optional bundleId?: number

          • Optional productId?: string

        Returns Promise<void>

• bundles: {
      deleteBundle: ((__namedParameters) => Promise<void>);
      getBundle: ((__namedParameters) => Promise<BundleDefinition | undefined>);
      getBundleComponentList: ((__namedParameters) => Promise<{
          isOptional?: boolean;
          name: string;
          quantity: number;
      }[]>);
      getBundleEligibleProducts: ((__namedParameters) => Promise<BundleEligibleProduct[]>);
      getBundleLocationSpecific: ((__namedParameters) => Promise<BundleLocationSpecific | undefined>);
      getBundleVariants: ((__namedParameters) => Promise<{
          bundleOptions: {
              name: string;
              values: string[];
          }[];
          bundleVariants: BundleVariant[];
          componentList: {
              isOptional?: boolean;
              name: string;
              quantity: number;
          }[];
          propNames: string[];
          relevantPropNames: string[];
      }>);
      getBundles: ((__namedParameters?) => Promise<{
          bundles: BundleDefinition[];
          count: number;
      }>);
      getBundlesLocationSpecific: ((__namedParameters) => Promise<{
          bundles: BundleLocationSpecific[];
          count: number;
      }>);
      getLocationsForBundle: ((__namedParameters) => Promise<DbBundleLocation[]>);
      updateBundleComponents: ((__namedParameters) => Promise<void>);
      updateBundleInventory: ((__namedParameters) => Promise<void>);
      upsertBundle: ((__namedParameters) => Promise<BundleDefinition>);
      upsertBundleLocation: ((__namedParameters) => Promise<DbBundleLocation>);
      upsertLocationsForBundle: ((__namedParameters) => Promise<DbBundleLocation[]>);
  }

  • deleteBundle: ((__namedParameters) => Promise<void>)

    • • (__namedParameters): Promise<void>

      • Parameters

        • __namedParameters: {
              id: number;
          }

          • id: number

        Returns Promise<void>

  • getBundle: ((__namedParameters) => Promise<BundleDefinition | undefined>)

    • • (__namedParameters): Promise<BundleDefinition | undefined>

      • Parameters

        • __namedParameters: {
              handle?: string;
              id?: number;
              parentProductId?: string;
              sku?: string;
          }

          • Optional handle?: string

          • Optional id?: number

          • Optional parentProductId?: string

          • Optional sku?: string

        Returns Promise<BundleDefinition | undefined>

  • getBundleComponentList: ((__namedParameters) => Promise<{
        isOptional?: boolean;
        name: string;
        quantity: number;
    }[]>)

    • • (__namedParameters): Promise<{
            isOptional?: boolean;
            name: string;
            quantity: number;
        }[]>

      • Parameters

        • __namedParameters: {
              bundle: BundleDefinition;
          }

          • bundle: BundleDefinition

        Returns Promise<{
            isOptional?: boolean;
            name: string;
            quantity: number;
        }[]>

  • getBundleEligibleProducts: ((__namedParameters) => Promise<BundleEligibleProduct[]>)

    • • (__namedParameters): Promise<BundleEligibleProduct[]>

      • Returns all products that are tagged with the bundle eligibility tag for a given bundle and match one of the required component product types.

        Parameters

        • __namedParameters: {
              bundle: Pick<BundleLocationSpecific, "sku" | "components">;
              storeDomainId: number;
          }

          • bundle: Pick<BundleLocationSpecific, "sku" | "components">

          • storeDomainId: number

        Returns Promise<BundleEligibleProduct[]>

  • getBundleLocationSpecific: ((__namedParameters) => Promise<BundleLocationSpecific | undefined>)

    • • (__namedParameters): Promise<BundleLocationSpecific | undefined>

      • Parameters

        • __namedParameters: {
              available?: boolean;
              handle?: string;
              id?: number;
              parentProductId?: string;
              sku?: string;
              storeDomainId: number;
          }

          • Optional available?: boolean

          • Optional handle?: string

          • Optional id?: number

          • Optional parentProductId?: string

          • Optional sku?: string

          • storeDomainId: number

        Returns Promise<BundleLocationSpecific | undefined>

  • getBundleVariants: ((__namedParameters) => Promise<{
        bundleOptions: {
            name: string;
            values: string[];
        }[];
        bundleVariants: BundleVariant[];
        componentList: {
            isOptional?: boolean;
            name: string;
            quantity: number;
        }[];
        propNames: string[];
        relevantPropNames: string[];
    }>)

    • • (__namedParameters): Promise<{
            bundleOptions: {
                name: string;
                values: string[];
            }[];
            bundleVariants: BundleVariant[];
            componentList: {
                isOptional?: boolean;
                name: string;
                quantity: number;
            }[];
            propNames: string[];
            relevantPropNames: string[];
        }>

      • Parameters

        • __namedParameters: {
              bundle: Pick<BundleLocationSpecific, "id" | "name" | "productTypeId" | "available" | "sku" | "discountAmount" | "components">;
              overrideDiscountAmount?: number;
              storeDomainId: number;
          }

          • bundle: Pick<BundleLocationSpecific, "id" | "name" | "productTypeId" | "available" | "sku" | "discountAmount" | "components">

          • Optional overrideDiscountAmount?: number

          • storeDomainId: number

        Returns Promise<{
            bundleOptions: {
                name: string;
                values: string[];
            }[];
            bundleVariants: BundleVariant[];
            componentList: {
                isOptional?: boolean;
                name: string;
                quantity: number;
            }[];
            propNames: string[];
            relevantPropNames: string[];
        }>

  • getBundles: ((__namedParameters?) => Promise<{
        bundles: BundleDefinition[];
        count: number;
    }>)

    • • (__namedParameters?): Promise<{
            bundles: BundleDefinition[];
            count: number;
        }>

      • Parameters

        • __namedParameters: BundlesQuery & DbSearchParams<{
              createdAt: Date;
              discountAmount: number;
              discountType: "percent";
              handle: null | string;
              id: number;
              name: string;
              parentProductId: null | string;
              productMaterialId: null | number;
              productTypeId: null | number;
              sku: string;
              updatedAt: Date;
          }> = {}

        Returns Promise<{
            bundles: BundleDefinition[];
            count: number;
        }>

  • getBundlesLocationSpecific: ((__namedParameters) => Promise<{
        bundles: BundleLocationSpecific[];
        count: number;
    }>)

    • • (__namedParameters): Promise<{
            bundles: BundleLocationSpecific[];
            count: number;
        }>

      • Parameters

        • __namedParameters: {
              available?: boolean;
              shopifyProductIds?: string[];
              storeDomainId: number;
          } & BundlesQuery & DbSearchParams<{
              algoliaObjectId: null | string;
              available: boolean;
              bundleId: number;
              createdAt: Date;
              firstAvailableAt: null | Date;
              id: number;
              inventory: number;
              shopifyProductId: null | string;
              storeDomainId: number;
              updatedAt: Date;
          }>

        Returns Promise<{
            bundles: BundleLocationSpecific[];
            count: number;
        }>

  • getLocationsForBundle: ((__namedParameters) => Promise<DbBundleLocation[]>)

    • • (__namedParameters): Promise<DbBundleLocation[]>

      • Parameters

        • __namedParameters: {
              bundleId: number;
          }

          • bundleId: number

        Returns Promise<DbBundleLocation[]>

  • updateBundleComponents: ((__namedParameters) => Promise<void>)

    • • (__namedParameters): Promise<void>

      • Parameters

        • __namedParameters: {
              bundleId: number;
              components: BundleComponentPayload[];
              transaction?: MySqlTransaction<PlanetscaleQueryResultHKT, PlanetScalePreparedQueryHKT, __module, ExtractTablesWithRelations<__module>>;
          }

          • bundleId: number

          • components: BundleComponentPayload[]

          • Optional transaction?: MySqlTransaction<PlanetscaleQueryResultHKT, PlanetScalePreparedQueryHKT, __module, ExtractTablesWithRelations<__module>>

        Returns Promise<void>

  • updateBundleInventory: ((__namedParameters) => Promise<void>)

    • • (__namedParameters): Promise<void>

      • Parameters

        • __namedParameters: {
              bundleId: number;
              inventory: number;
              storeDomainId: number;
          }

          • bundleId: number

          • inventory: number

          • storeDomainId: number

        Returns Promise<void>

  • upsertBundle: ((__namedParameters) => Promise<BundleDefinition>)

    • • (__namedParameters): Promise<BundleDefinition>

      • Parameters

        • __namedParameters: {
              components?: BundleComponentPayload[];
              discount?: number;
              eligibleProductIds?: string[];
              handle?: null | string;
              id?: number;
              locations?: {
                  algoliaObjectId?: string;
                  available?: boolean;
                  shopifyProductId?: string;
                  storeDomainId: number;
              }[];
              name?: string;
              parentProductId?: null | string;
              productMaterialId?: null | number;
              productTagIds?: number[];
              productTypeId?: null | number;
              sku?: string;
          }

          • Optional components?: BundleComponentPayload[]

          • Optional discount?: number

          • Optional eligibleProductIds?: string[]

          • Optional handle?: null | string

          • Optional id?: number

          • Optional locations?: {
                algoliaObjectId?: string;
                available?: boolean;
                shopifyProductId?: string;
                storeDomainId: number;
            }[]

          • Optional name?: string

          • Optional parentProductId?: null | string

          • Optional productMaterialId?: null | number

          • Optional productTagIds?: number[]

          • Optional productTypeId?: null | number

          • Optional sku?: string

        Returns Promise<BundleDefinition>

  • upsertBundleLocation: ((__namedParameters) => Promise<DbBundleLocation>)

    • • (__namedParameters): Promise<DbBundleLocation>

      • Parameters

        • __namedParameters: {
              algoliaObjectId?: string;
              available?: boolean;
              bundleId: number;
              shopifyProductId?: string;
              storeDomainId: number;
          }

          • Optional algoliaObjectId?: string

          • Optional available?: boolean

          • bundleId: number

          • Optional shopifyProductId?: string

          • storeDomainId: number

        Returns Promise<DbBundleLocation>

  • upsertLocationsForBundle: ((__namedParameters) => Promise<DbBundleLocation[]>)

    • • (__namedParameters): Promise<DbBundleLocation[]>

      • Parameters

        • __namedParameters: {
              bundleId: number;
              locations: {
                  algoliaObjectId?: string;
                  available?: boolean;
                  shopifyProductId?: string;
                  storeDomainId: number;
              }[];
              transaction?: MySqlTransaction<PlanetscaleQueryResultHKT, PlanetScalePreparedQueryHKT, __module, ExtractTablesWithRelations<__module>>;
          }

          • bundleId: number

          • locations: {
                algoliaObjectId?: string;
                available?: boolean;
                shopifyProductId?: string;
                storeDomainId: number;
            }[]

          • Optional transaction?: MySqlTransaction<PlanetscaleQueryResultHKT, PlanetScalePreparedQueryHKT, __module, ExtractTablesWithRelations<__module>>

        Returns Promise<DbBundleLocation[]>

• collections: {
      deleteCollection: ((__namedParameters) => Promise<void>);
      getCollection: ((__namedParameters) => Promise<Collection | undefined>);
      getCollectionItems: ((__namedParameters?) => Promise<CollectionItem[]>);
      getCollectionLocationSpecific: ((__namedParameters) => Promise<undefined | CollectionLocationSpecific>);
      getCollectionLocations: ((__namedParameters?) => Promise<CollectionLocation[]>);
      getCollectionRules: ((__namedParameters?) => Promise<CollectionRule[]>);
      getCollections: ((__namedParameters?) => Promise<{
          collections: Collection[];
          count: number;
      }>);
      getCollectionsByItemId: ((__namedParameters) => Promise<{
          collectionsByBundleId: {
              [k: string]: T;
          };
          collectionsByProductId: {
              [k: string]: T;
          };
      }>);
      getCollectionsFromItems: ((__namedParameters) => Promise<{
          handle: string;
          id: number;
          name: string;
      }[]>);
      getCollectionsLocationSpecific: ((__namedParameters) => Promise<{
          collections: CollectionLocationSpecific[];
          count: number;
      }>);
      refreshAllCollectionItems: (() => Promise<void>);
      refreshItemsForCollection: ((collectionId) => Promise<void>);
      updateCollectionItems: ((__namedParameters) => Promise<void>);
      upsertCollection: ((__namedParameters) => Promise<Collection>);
  }

  • deleteCollection: ((__namedParameters) => Promise<void>)

    • • (__namedParameters): Promise<void>

      • Parameters

        • __namedParameters: {
              id: number;
          }

          • id: number

        Returns Promise<void>

  • getCollection: ((__namedParameters) => Promise<Collection | undefined>)

    • • (__namedParameters): Promise<Collection | undefined>

      • Parameters

        • __namedParameters: {
              handle?: string;
              id?: number;
          }

          • Optional handle?: string

          • Optional id?: number

        Returns Promise<Collection | undefined>

  • getCollectionItems: ((__namedParameters?) => Promise<CollectionItem[]>)

    • • (__namedParameters?): Promise<CollectionItem[]>

      • Parameters

        • __namedParameters: {
              collectionIds?: number[];
          } = {}

          • Optional collectionIds?: number[]

        Returns Promise<CollectionItem[]>

  • getCollectionLocationSpecific: ((__namedParameters) => Promise<undefined | CollectionLocationSpecific>)

    • • (__namedParameters): Promise<undefined | CollectionLocationSpecific>

      • Parameters

        • __namedParameters: {
              handle?: string;
              id?: number;
              storeDomainId: number;
          }

          • Optional handle?: string

          • Optional id?: number

          • storeDomainId: number

        Returns Promise<undefined | CollectionLocationSpecific>

  • getCollectionLocations: ((__namedParameters?) => Promise<CollectionLocation[]>)

    • • (__namedParameters?): Promise<CollectionLocation[]>

      • Parameters

        • __namedParameters: {
              collectionIds?: number[];
              storeDomainId?: number;
          } = {}

          • Optional collectionIds?: number[]

          • Optional storeDomainId?: number

        Returns Promise<CollectionLocation[]>

  • getCollectionRules: ((__namedParameters?) => Promise<CollectionRule[]>)

    • • (__namedParameters?): Promise<CollectionRule[]>

      • Parameters

        • __namedParameters: {
              collectionIds?: number[];
          } = {}

          • Optional collectionIds?: number[]

        Returns Promise<CollectionRule[]>

  • getCollections: ((__namedParameters?) => Promise<{
        collections: Collection[];
        count: number;
    }>)

    • • (__namedParameters?): Promise<{
            collections: Collection[];
            count: number;
        }>

      • Parameters

        • __namedParameters: CollectionsQuery & DbSearchParams<{
              createdAt: Date;
              disjunctive: boolean;
              handle: string;
              hidden: boolean;
              id: number;
              manualOrder: boolean;
              name: string;
              updatedAt: Date;
          }> = {}

        Returns Promise<{
            collections: Collection[];
            count: number;
        }>

  • getCollectionsByItemId: ((__namedParameters) => Promise<{
        collectionsByBundleId: {
            [k: string]: T;
        };
        collectionsByProductId: {
            [k: string]: T;
        };
    }>)

    • • (__namedParameters): Promise<{
            collectionsByBundleId: {
                [k: string]: T;
            };
            collectionsByProductId: {
                [k: string]: T;
            };
        }>

      • Parameters

        • __namedParameters: {
              storeDomainId: number;
          }

          • storeDomainId: number

        Returns Promise<{
            collectionsByBundleId: {
                [k: string]: T;
            };
            collectionsByProductId: {
                [k: string]: T;
            };
        }>

  • getCollectionsFromItems: ((__namedParameters) => Promise<{
        handle: string;
        id: number;
        name: string;
    }[]>)

    • • (__namedParameters): Promise<{
            handle: string;
            id: number;
            name: string;
        }[]>

      • Parameters

        • __namedParameters: {
              available?: boolean;
              bundleIds?: number[];
              productIds?: string[];
              shopifyProductIds?: string[];
              storeDomainId: number;
          }

          • Optional available?: boolean

          • Optional bundleIds?: number[]

          • Optional productIds?: string[]

          • Optional shopifyProductIds?: string[]

          • storeDomainId: number

        Returns Promise<{
            handle: string;
            id: number;
            name: string;
        }[]>

  • getCollectionsLocationSpecific: ((__namedParameters) => Promise<{
        collections: CollectionLocationSpecific[];
        count: number;
    }>)

    • • (__namedParameters): Promise<{
            collections: CollectionLocationSpecific[];
            count: number;
        }>

      • Parameters

        • __namedParameters: {
              available?: boolean;
              storeDomainId: number;
          } & CollectionsQuery & DbSearchParams<{
              available: boolean;
              collectionId: number;
              createdAt: Date;
              id: number;
              storeDomainId: number;
              updatedAt: Date;
          }>

        Returns Promise<{
            collections: CollectionLocationSpecific[];
            count: number;
        }>

  • refreshAllCollectionItems: (() => Promise<void>)

    • • (): Promise<void>

      • Intended to be a CRON job.

        Returns Promise<void>

  • refreshItemsForCollection: ((collectionId) => Promise<void>)

    • • (collectionId): Promise<void>

      • Parameters

        • collectionId: number

        Returns Promise<void>

  • updateCollectionItems: ((__namedParameters) => Promise<void>)

    • • (__namedParameters): Promise<void>

      • Parameters

        • __namedParameters: {
              collectionId: number;
              items: Pick<OrderedProductQueryItemResult, "productId" | "productVariantId" | "bundleId" | "pinned">[];
              transaction?: MySqlTransaction<PlanetscaleQueryResultHKT, PlanetScalePreparedQueryHKT, __module, ExtractTablesWithRelations<__module>>;
          }

          • collectionId: number

          • items: Pick<OrderedProductQueryItemResult, "productId" | "productVariantId" | "bundleId" | "pinned">[]

          • Optional transaction?: MySqlTransaction<PlanetscaleQueryResultHKT, PlanetScalePreparedQueryHKT, __module, ExtractTablesWithRelations<__module>>

        Returns Promise<void>

  • upsertCollection: ((__namedParameters) => Promise<Collection>)

    • • (__namedParameters): Promise<Collection>

      • Parameters

        • __namedParameters: {
              disjunctive?: boolean;
              handle: string;
              hidden?: boolean;
              id?: number;
              items?: Pick<OrderedProductQueryItemResult, "productId" | "productVariantId" | "bundleId" | "position" | "pinned">[];
              locations?: {
                  available: boolean;
                  storeDomainId: number;
              }[];
              manualOrder?: boolean;
              name: string;
              rules?: ProductQueryRule<ProductQueryRuleTarget>[];
          }

          • Optional disjunctive?: boolean

          • handle: string

          • Optional hidden?: boolean

          • Optional id?: number

          • Optional items?: Pick<OrderedProductQueryItemResult, "productId" | "productVariantId" | "bundleId" | "position" | "pinned">[]

          • Optional locations?: {
                available: boolean;
                storeDomainId: number;
            }[]

          • Optional manualOrder?: boolean

          • name: string

          • Optional rules?: ProductQueryRule<ProductQueryRuleTarget>[]

        Returns Promise<Collection>

• crossSellProducts: {
      getCrossSellProducts: ((__namedParameters?) => Promise<Record<string, string[]>>);
      setCrossSellProductsForProduct: ((__namedParameters) => Promise<void>);
  }

  • getCrossSellProducts: ((__namedParameters?) => Promise<Record<string, string[]>>)

    • • (__namedParameters?): Promise<Record<string, string[]>>

      • For a given array of product IDs, returns a map of cross-sell product IDs per input ID.

        Parameters

        • __namedParameters: {
              productIds?: string[];
          } = {}

          • Optional productIds?: string[]

        Returns Promise<Record<string, string[]>>

  • setCrossSellProductsForProduct: ((__namedParameters) => Promise<void>)

    • • (__namedParameters): Promise<void>

      • Sets the list of cross-sell products for a given product ID.

        Parameters

        • __namedParameters: {
              crossSellProductIds: string[];
              productId: string;
          }

          • crossSellProductIds: string[]

          • productId: string

        Returns Promise<void>

• locations: {
      getLocation: ((__namedParameters) => Promise<Location | undefined>);
      getLocations: ((__namedParameters?) => Promise<{
          count: number;
          locations: Location[];
      }>);
      upsertLocation: ((__namedParameters) => Promise<Location>);
  }

  • getLocation: ((__namedParameters) => Promise<Location | undefined>)

    • • (__namedParameters): Promise<Location | undefined>

      • Parameters

        • __namedParameters: {
              id?: string | number;
              name?: string;
              storeDomainId?: number;
          }

          • Optional id?: string | number

          • Optional name?: string

          • Optional storeDomainId?: number

        Returns Promise<Location | undefined>

  • getLocations: ((__namedParameters?) => Promise<{
        count: number;
        locations: Location[];
    }>)

    • • (__namedParameters?): Promise<{
            count: number;
            locations: Location[];
        }>

      • Parameters

        • __namedParameters: {
              active?: boolean;
              filter?: string;
              isOnline?: boolean;
              legacy?: boolean;
              storeDomainId?: number;
          } & DbSearchParams<{
              active: boolean;
              address1: null | string;
              address2: null | string;
              bopisSlackChannel: null | string;
              city: null | string;
              country: string;
              countryCode: string;
              countryName: string;
              createdAt: Date;
              id: string;
              isOnline: boolean;
              legacy: boolean;
              name: string;
              netsuiteLocationId: null | string;
              phone: null | string;
              province: null | string;
              provinceCode: null | string;
              storeDomainId: null | number;
              updatedAt: Date;
              zip: null | string;
          }> = {}

        Returns Promise<{
            count: number;
            locations: Location[];
        }>

  • upsertLocation: ((__namedParameters) => Promise<Location>)

    • • (__namedParameters): Promise<Location>

      • Parameters

        • __namedParameters: {
              active?: boolean;
              address1?: string;
              address2?: string;
              bopisSlackChannel?: null | string;
              city?: string;
              country?: string;
              countryCode?: string;
              countryName?: string;
              id: string;
              isOnline?: boolean;
              legacy?: boolean;
              name?: string;
              netsuiteLocationId?: string;
              phone?: string;
              province?: string;
              provinceCode?: string;
              storeDomainId?: number;
              zip?: string;
          }

          • Optional active?: boolean

          • Optional address1?: string

          • Optional address2?: string

          • Optional bopisSlackChannel?: null | string

          • Optional city?: string

          • Optional country?: string

          • Optional countryCode?: string

          • Optional countryName?: string

          • id: string

          • Optional isOnline?: boolean

          • Optional legacy?: boolean

          • Optional name?: string

          • Optional netsuiteLocationId?: string

          • Optional phone?: string

          • Optional province?: string

          • Optional provinceCode?: string

          • Optional storeDomainId?: number

          • Optional zip?: string

        Returns Promise<Location>

• netsuiteInventoryItemProperties: {
      getNetsuiteInventoryItemProperties: (() => Promise<NetsuiteInventoryItemProperty[]>);
      upsertNetsuiteInventoryItemProperty: ((__namedParameters) => Promise<NetsuiteInventoryItemProperty>);
  }

  • getNetsuiteInventoryItemProperties: (() => Promise<NetsuiteInventoryItemProperty[]>)

    • • (): Promise<NetsuiteInventoryItemProperty[]>

      • Returns Promise<NetsuiteInventoryItemProperty[]>

  • upsertNetsuiteInventoryItemProperty: ((__namedParameters) => Promise<NetsuiteInventoryItemProperty>)

    • • (__namedParameters): Promise<NetsuiteInventoryItemProperty>

      • Parameters

        • __namedParameters: {
              displayName?: string;
              id?: number;
              isOption?: boolean;
              keyName?: string;
              netsuiteFieldId?: string;
              netsuiteFieldType?: NetsuiteInventoryItemFieldType;
          }

          • Optional displayName?: string

          • Optional id?: number

          • Optional isOption?: boolean

          • Optional keyName?: string

          • Optional netsuiteFieldId?: string

          • Optional netsuiteFieldType?: NetsuiteInventoryItemFieldType

        Returns Promise<NetsuiteInventoryItemProperty>

• productLocations: {
      disableLocationsForProduct: ((__namedParameters) => Promise<void>);
      getProductLocation: ((__namedParameters) => Promise<DbProductLocation | undefined>);
      getProductLocations: ((__namedParameters?) => Promise<DbProductLocation[]>);
      recalculateInventory: ((__namedParameters) => Promise<void>);
      upsertLocationsForProduct: ((__namedParameters) => Promise<void>);
      upsertProductLocation: ((__namedParameters) => Promise<DbProductLocation>);
  }

  • disableLocationsForProduct: ((__namedParameters) => Promise<void>)

    • • (__namedParameters): Promise<void>

      • Parameters

        • __namedParameters: {
              productId: string;
          }

          • productId: string

        Returns Promise<void>

  • getProductLocation: ((__namedParameters) => Promise<DbProductLocation | undefined>)

    • • (__namedParameters): Promise<DbProductLocation | undefined>

      • Parameters

        • __namedParameters: {
              productId: string;
              storeDomainId: number;
          }

          • productId: string

          • storeDomainId: number

        Returns Promise<DbProductLocation | undefined>

  • getProductLocations: ((__namedParameters?) => Promise<DbProductLocation[]>)

    • • (__namedParameters?): Promise<DbProductLocation[]>

      • Parameters

        • __namedParameters: {
              productIds?: string[];
              storeDomainId?: number;
          } = {}

          • Optional productIds?: string[]

          • Optional storeDomainId?: number

        Returns Promise<DbProductLocation[]>

  • recalculateInventory: ((__namedParameters) => Promise<void>)

    • • (__namedParameters): Promise<void>

      • Parameters

        • __namedParameters: {
              productId?: string;
              productVariantId?: string;
              sku?: string;
              storeDomainId: number;
          }

          • Optional productId?: string

          • Optional productVariantId?: string

          • Optional sku?: string

          • storeDomainId: number

        Returns Promise<void>

  • upsertLocationsForProduct: ((__namedParameters) => Promise<void>)

    • • (__namedParameters): Promise<void>

      • Parameters

        • __namedParameters: {
              locations: {
                  algoliaObjectId?: string;
                  shopifyProductId?: string;
                  statusId?: number;
                  storeDomainId: number;
              }[];
              productId: string;
          }

          • locations: {
                algoliaObjectId?: string;
                shopifyProductId?: string;
                statusId?: number;
                storeDomainId: number;
            }[]

          • productId: string

        Returns Promise<void>

  • upsertProductLocation: ((__namedParameters) => Promise<DbProductLocation>)

    • • (__namedParameters): Promise<DbProductLocation>

      • Parameters

        • __namedParameters: {
              algoliaObjectId?: string;
              firstAvailableAt?: Date;
              inventory?: number;
              productId: string;
              shopifyProductId?: string;
              statusId?: number;
              storeDomainId: number;
          }

          • Optional algoliaObjectId?: string

          • Optional firstAvailableAt?: Date

          • Optional inventory?: number

          • productId: string

          • Optional shopifyProductId?: string

          • Optional statusId?: number

          • storeDomainId: number

        Returns Promise<DbProductLocation>

• productMaterials: {
      deleteProductMaterial: ((__namedParameters) => Promise<void>);
      getProductMaterial: ((__namedParameters) => Promise<ProductMaterial | undefined>);
      getProductMaterials: ((__namedParameters?) => Promise<{
          count: number;
          productMaterials: ProductMaterial[];
      }>);
      upsertProductMaterial: ((__namedParameters) => Promise<ProductMaterial>);
  }

  • deleteProductMaterial: ((__namedParameters) => Promise<void>)

    • • (__namedParameters): Promise<void>

      • Parameters

        • __namedParameters: {
              id: number;
          }

          • id: number

        Returns Promise<void>

  • getProductMaterial: ((__namedParameters) => Promise<ProductMaterial | undefined>)

    • • (__namedParameters): Promise<ProductMaterial | undefined>

      • Parameters

        • __namedParameters: {
              id?: number;
              name?: string;
          }

          • Optional id?: number

          • Optional name?: string

        Returns Promise<ProductMaterial | undefined>

  • getProductMaterials: ((__namedParameters?) => Promise<{
        count: number;
        productMaterials: ProductMaterial[];
    }>)

    • • (__namedParameters?): Promise<{
            count: number;
            productMaterials: ProductMaterial[];
        }>

      • Parameters

        • __namedParameters: {
              filter?: string;
              ids?: number[];
              names?: string[];
          } & DbSearchParams<{
              createdAt: Date;
              id: number;
              internalNotes: null | string;
              name: string;
              updatedAt: Date;
          }> = {}

        Returns Promise<{
            count: number;
            productMaterials: ProductMaterial[];
        }>

  • upsertProductMaterial: ((__namedParameters) => Promise<ProductMaterial>)

    • • (__namedParameters): Promise<ProductMaterial>

      • Parameters

        • __namedParameters: {
              id?: number;
              internalNotes?: null | string;
              name?: string;
          }

          • Optional id?: number

          • Optional internalNotes?: null | string

          • Optional name?: string

        Returns Promise<ProductMaterial>

• productOptionValues: {
      getProductOptionValue: ((__namedParameters) => Promise<DbProductOptionValue | undefined>);
      getProductOptionValues: ((__namedParameters?) => Promise<{
          count: number;
          productOptionValues: DbProductOptionValue[];
      }>);
      upsertProductOptionValue: ((__namedParameters) => Promise<DbProductOptionValue>);
  }

  • getProductOptionValue: ((__namedParameters) => Promise<DbProductOptionValue | undefined>)

    • • (__namedParameters): Promise<DbProductOptionValue | undefined>

      • Parameters

        • __namedParameters: {
              id?: number;
              productOptionId?: number;
              value?: string;
          }

          • Optional id?: number

          • Optional productOptionId?: number

          • Optional value?: string

        Returns Promise<DbProductOptionValue | undefined>

  • getProductOptionValues: ((__namedParameters?) => Promise<{
        count: number;
        productOptionValues: DbProductOptionValue[];
    }>)

    • • (__namedParameters?): Promise<{
            count: number;
            productOptionValues: DbProductOptionValue[];
        }>

      • Parameters

        • __namedParameters: {
              displayValues?: string[];
              filter?: string;
              ids?: number[];
              productOptionIds?: number[];
              values?: string[];
          } & DbSearchParams<{
              createdAt: Date;
              displayValue: string;
              id: number;
              position: null | number;
              productOptionId: number;
              updatedAt: Date;
              value: string;
          }> = {}

        Returns Promise<{
            count: number;
            productOptionValues: DbProductOptionValue[];
        }>

  • upsertProductOptionValue: ((__namedParameters) => Promise<DbProductOptionValue>)

    • • (__namedParameters): Promise<DbProductOptionValue>

      • Parameters

        • __namedParameters: {
              displayValue?: string;
              id?: number;
              position?: number;
              productOptionId?: number;
              value?: string;
          }

          • Optional displayValue?: string

          • Optional id?: number

          • Optional position?: number

          • Optional productOptionId?: number

          • Optional value?: string

        Returns Promise<DbProductOptionValue>

• productOptions: {
      getProductOption: ((__namedParameters) => Promise<FormattedDbProductOption | undefined>);
      getProductOptions: ((__namedParameters?) => Promise<{
          count: number;
          productOptions: FormattedDbProductOption[];
      }>);
      updateOptionsForProduct: ((__namedParameters) => Promise<void>);
      upsertProductOption: ((__namedParameters) => Promise<FormattedDbProductOption>);
  }

  • getProductOption: ((__namedParameters) => Promise<FormattedDbProductOption | undefined>)

    • • (__namedParameters): Promise<FormattedDbProductOption | undefined>

      • Parameters

        • __namedParameters: {
              id?: number;
              name?: string;
          }

          • Optional id?: number

          • Optional name?: string

        Returns Promise<FormattedDbProductOption | undefined>

  • getProductOptions: ((__namedParameters?) => Promise<{
        count: number;
        productOptions: FormattedDbProductOption[];
    }>)

    • • (__namedParameters?): Promise<{
            count: number;
            productOptions: FormattedDbProductOption[];
        }>

      • Parameters

        • __namedParameters: {
              filter?: string;
              ids?: number[];
              names?: string[];
              productIds?: string[];
          } & DbSearchParams<{
              createdAt: Date;
              id: number;
              name: string;
              netsuiteInventoryItemPropertyId: number;
              position: number;
              updatedAt: Date;
          }> = {}

        Returns Promise<{
            count: number;
            productOptions: FormattedDbProductOption[];
        }>

  • updateOptionsForProduct: ((__namedParameters) => Promise<void>)

    • • (__namedParameters): Promise<void>

      • Parameters

        • __namedParameters: {
              productId: string;
              productOptionIds: number[];
          }

          • productId: string

          • productOptionIds: number[]

        Returns Promise<void>

  • upsertProductOption: ((__namedParameters) => Promise<FormattedDbProductOption>)

    • • (__namedParameters): Promise<FormattedDbProductOption>

      • Parameters

        • __namedParameters: {
              id?: number;
              name?: string;
              netsuiteInventoryItemPropertyId?: number;
              position?: number;
          }

          • Optional id?: number

          • Optional name?: string

          • Optional netsuiteInventoryItemPropertyId?: number

          • Optional position?: number

        Returns Promise<FormattedDbProductOption>

• productQueryRules: {
      getItemsFromRules: ((__namedParameters) => Promise<OrderedProductQueryItemResult[]>);
      getQueryItemId: ((item) => string);
  }

  • getItemsFromRules: ((__namedParameters) => Promise<OrderedProductQueryItemResult[]>)

    • • (__namedParameters): Promise<OrderedProductQueryItemResult[]>

      • Parameters

        • __namedParameters: {
              disjunctive?: boolean;
              existingItems?: OrderedProductQueryItemResult[];
              rules: ProductQueryRule<ProductQueryRuleTarget>[];
          }

          • Optional disjunctive?: boolean

          • Optional existingItems?: OrderedProductQueryItemResult[]

          • rules: ProductQueryRule<ProductQueryRuleTarget>[]

        Returns Promise<OrderedProductQueryItemResult[]>

  • getQueryItemId: ((item) => string)

    • • (item): string

      • Parameters

        • item: ProductQueryItemResult

        Returns string

• productStatuses: {
      getProductStatuses: (() => Promise<{
          count: number;
          productStatuses: DbProductStatus[];
      }>);
      statusInShopify: ((statusQuery) => boolean);
      upsertProductStatus: ((__namedParameters) => Promise<DbProductStatus>);
  }

  • getProductStatuses: (() => Promise<{
        count: number;
        productStatuses: DbProductStatus[];
    }>)

    • • (): Promise<{
            count: number;
            productStatuses: DbProductStatus[];
        }>

      • Returns Promise<{
            count: number;
            productStatuses: DbProductStatus[];
        }>

  • statusInShopify: ((statusQuery) => boolean)

    • • (statusQuery): boolean

      • Parameters

        • statusQuery: string | number

        Returns boolean

  • upsertProductStatus: ((__namedParameters) => Promise<DbProductStatus>)

    • • (__namedParameters): Promise<DbProductStatus>

      • Parameters

        • __namedParameters: {
              description?: string;
              id?: number;
              name?: string;
          }

          • Optional description?: string

          • Optional id?: number

          • Optional name?: string

        Returns Promise<DbProductStatus>

• productTags: {
      addTagToProducts: ((__namedParameters) => Promise<void>);
      deleteProductTag: ((__namedParameters) => Promise<void>);
      getProductTag: ((__namedParameters) => Promise<ProductTagWithRules | undefined>);
      getProductTags: ((__namedParameters?) => Promise<{
          count: number;
          productTags: ProductTagWithRules[];
      }>);
      getProductTagsForBundles: ((__namedParameters?) => Promise<Record<string, {
          id: number;
          name: string;
      }[]>>);
      getProductTagsForProducts: ((__namedParameters?) => Promise<Record<string, {
          id: number;
          name: string;
      }[]>>);
      refreshAllAutomaticTags: (() => Promise<{
          itemsAffected: {
              bundleId: null | number;
              id: string;
              productId: null | string;
              productVariantId: null | string;
          }[];
      }>);
      refreshAutomaticTag: ((__namedParameters) => Promise<{
          itemsAffected: ProductQueryItemResult[];
      }>);
      updateTagsForBundle: ((__namedParameters) => Promise<void>);
      updateTagsForProduct: ((__namedParameters) => Promise<void>);
      upsertProductTag: ((__namedParameters) => Promise<ProductTagWithRules>);
  }

  • addTagToProducts: ((__namedParameters) => Promise<void>)

    • • (__namedParameters): Promise<void>

      • Parameters

        • __namedParameters: {
              productIds: string[];
              productTagId: number;
          }

          • productIds: string[]

          • productTagId: number

        Returns Promise<void>

  • deleteProductTag: ((__namedParameters) => Promise<void>)

    • • (__namedParameters): Promise<void>

      • Parameters

        • __namedParameters: {
              id: number;
          }

          • id: number

        Returns Promise<void>

  • getProductTag: ((__namedParameters) => Promise<ProductTagWithRules | undefined>)

    • • (__namedParameters): Promise<ProductTagWithRules | undefined>

      • Parameters

        • __namedParameters: {
              id?: number;
              name?: string;
          }

          • Optional id?: number

          • Optional name?: string

        Returns Promise<ProductTagWithRules | undefined>

  • getProductTags: ((__namedParameters?) => Promise<{
        count: number;
        productTags: ProductTagWithRules[];
    }>)

    • • (__namedParameters?): Promise<{
            count: number;
            productTags: ProductTagWithRules[];
        }>

      • Parameters

        • __namedParameters: {
              filter?: string;
              ids?: number[];
              names?: string[];
          } & DbSearchParams<{
              createdAt: Date;
              disjunctive: boolean;
              id: number;
              internalNotes: null | string;
              name: string;
              updatedAt: Date;
          }> = {}

        Returns Promise<{
            count: number;
            productTags: ProductTagWithRules[];
        }>

  • getProductTagsForBundles: ((__namedParameters?) => Promise<Record<string, {
        id: number;
        name: string;
    }[]>>)

    • • (__namedParameters?): Promise<Record<string, {
            id: number;
            name: string;
        }[]>>

      • Parameters

        • __namedParameters: {
              bundleIds?: number[];
          } = {}

          • Optional bundleIds?: number[]

        Returns Promise<Record<string, {
            id: number;
            name: string;
        }[]>>

  • getProductTagsForProducts: ((__namedParameters?) => Promise<Record<string, {
        id: number;
        name: string;
    }[]>>)

    • • (__namedParameters?): Promise<Record<string, {
            id: number;
            name: string;
        }[]>>

      • Parameters

        • __namedParameters: {
              productIds?: string[];
          } = {}

          • Optional productIds?: string[]

        Returns Promise<Record<string, {
            id: number;
            name: string;
        }[]>>

  • refreshAllAutomaticTags: (() => Promise<{
        itemsAffected: {
            bundleId: null | number;
            id: string;
            productId: null | string;
            productVariantId: null | string;
        }[];
    }>)

    • • (): Promise<{
            itemsAffected: {
                bundleId: null | number;
                id: string;
                productId: null | string;
                productVariantId: null | string;
            }[];
        }>

      • Returns Promise<{
            itemsAffected: {
                bundleId: null | number;
                id: string;
                productId: null | string;
                productVariantId: null | string;
            }[];
        }>

  • refreshAutomaticTag: ((__namedParameters) => Promise<{
        itemsAffected: ProductQueryItemResult[];
    }>)

    • • (__namedParameters): Promise<{
            itemsAffected: ProductQueryItemResult[];
        }>

      • Parameters

        • __namedParameters: {
              allBundles?: {
                  id: number;
              }[];
              allProductVariants?: {
                  id: string;
              }[];
              allProducts?: {
                  id: string;
              }[];
              productTagId: number;
              transaction?: MySqlTransaction<PlanetscaleQueryResultHKT, PlanetScalePreparedQueryHKT, __module, ExtractTablesWithRelations<__module>>;
          }

          • Optional allBundles?: {
                id: number;
            }[]

          • Optional allProductVariants?: {
                id: string;
            }[]

          • Optional allProducts?: {
                id: string;
            }[]

          • productTagId: number

          • Optional transaction?: MySqlTransaction<PlanetscaleQueryResultHKT, PlanetScalePreparedQueryHKT, __module, ExtractTablesWithRelations<__module>>

        Returns Promise<{
            itemsAffected: ProductQueryItemResult[];
        }>

  • updateTagsForBundle: ((__namedParameters) => Promise<void>)

    • • (__namedParameters): Promise<void>

      • Parameters

        • __namedParameters: {
              bundleId: number;
              productTagIds: number[];
              transaction?: MySqlTransaction<PlanetscaleQueryResultHKT, PlanetScalePreparedQueryHKT, __module, ExtractTablesWithRelations<__module>>;
          }

          • bundleId: number

          • productTagIds: number[]

          • Optional transaction?: MySqlTransaction<PlanetscaleQueryResultHKT, PlanetScalePreparedQueryHKT, __module, ExtractTablesWithRelations<__module>>

        Returns Promise<void>

  • updateTagsForProduct: ((__namedParameters) => Promise<void>)

    • • (__namedParameters): Promise<void>

      • Parameters

        • __namedParameters: {
              productId: string;
              productTagIds: number[];
              transaction?: MySqlTransaction<PlanetscaleQueryResultHKT, PlanetScalePreparedQueryHKT, __module, ExtractTablesWithRelations<__module>>;
          }

          • productId: string

          • productTagIds: number[]

          • Optional transaction?: MySqlTransaction<PlanetscaleQueryResultHKT, PlanetScalePreparedQueryHKT, __module, ExtractTablesWithRelations<__module>>

        Returns Promise<void>

  • upsertProductTag: ((__namedParameters) => Promise<ProductTagWithRules>)

    • • (__namedParameters): Promise<ProductTagWithRules>

      • Parameters

        • __namedParameters: {
              disjunctive?: boolean;
              id?: number;
              internalNotes?: null | string;
              name?: string;
              rules?: {
                  relation: ProductQueryRuleRelation;
                  target: ProductQueryRuleTarget;
                  value: string;
              }[];
          }

          • Optional disjunctive?: boolean

          • Optional id?: number

          • Optional internalNotes?: null | string

          • Optional name?: string

          • Optional rules?: {
                relation: ProductQueryRuleRelation;
                target: ProductQueryRuleTarget;
                value: string;
            }[]

        Returns Promise<ProductTagWithRules>

• productTypes: {
      deleteProductType: ((__namedParameters) => Promise<void>);
      getProductType: ((__namedParameters) => Promise<ProductType | undefined>);
      getProductTypes: ((__namedParameters?) => Promise<{
          count: number;
          productTypes: ProductType[];
      }>);
      upsertProductType: ((__namedParameters) => Promise<ProductType>);
  }

  • deleteProductType: ((__namedParameters) => Promise<void>)

    • • (__namedParameters): Promise<void>

      • Parameters

        • __namedParameters: {
              id: number;
          }

          • id: number

        Returns Promise<void>

  • getProductType: ((__namedParameters) => Promise<ProductType | undefined>)

    • • (__namedParameters): Promise<ProductType | undefined>

      • Parameters

        • __namedParameters: {
              id?: number;
              name?: string;
          }

          • Optional id?: number

          • Optional name?: string

        Returns Promise<ProductType | undefined>

  • getProductTypes: ((__namedParameters?) => Promise<{
        count: number;
        productTypes: ProductType[];
    }>)

    • • (__namedParameters?): Promise<{
            count: number;
            productTypes: ProductType[];
        }>

      • Parameters

        • __namedParameters: {
              filter?: string;
              ids?: number[];
              names?: string[];
          } & DbSearchParams<{
              createdAt: Date;
              id: number;
              internalNotes: null | string;
              name: string;
              updatedAt: Date;
          }> = {}

        Returns Promise<{
            count: number;
            productTypes: ProductType[];
        }>

  • upsertProductType: ((__namedParameters) => Promise<ProductType>)

    • • (__namedParameters): Promise<ProductType>

      • Parameters

        • __namedParameters: {
              id?: number;
              internalNotes?: null | string;
              name?: string;
          }

          • Optional id?: number

          • Optional internalNotes?: null | string

          • Optional name?: string

        Returns Promise<ProductType>

• productVariantLocations: {
      disableLocationsForProductVariant: ((__namedParameters) => Promise<void>);
      getProductVariantLocation: ((__namedParameters) => Promise<DbProductVariantLocation | undefined>);
      getProductVariantLocations: ((__namedParameters?) => Promise<DbProductVariantLocation[]>);
      updateBackInStockDate: ((__namedParameters) => Promise<void>);
      updateInventory: ((__namedParameters) => Promise<void>);
      upsertProductVariantLocation: ((__namedParameters) => Promise<{
          algoliaObjectId: null | string;
          compareAtPrice: null | string;
          createdAt: Date;
          id: number;
          inventory: number;
          nextInDcAt: null | Date;
          price: string;
          productVariantId: string;
          shopifyInventoryItemId: null | string;
          shopifyVariantId: null | string;
          statusId: number;
          storeDomainId: number;
          updatedAt: Date;
      }>);
      upsertProductVariantLocations: ((updates) => Promise<void>);
  }

  • disableLocationsForProductVariant: ((__namedParameters) => Promise<void>)

    • • (__namedParameters): Promise<void>

      • Parameters

        • __namedParameters: {
              productVariantId: string;
          }

          • productVariantId: string

        Returns Promise<void>

  • getProductVariantLocation: ((__namedParameters) => Promise<DbProductVariantLocation | undefined>)

    • • (__namedParameters): Promise<DbProductVariantLocation | undefined>

      • Parameters

        • __namedParameters: {
              productVariantId: string;
              storeDomainId: number;
          }

          • productVariantId: string

          • storeDomainId: number

        Returns Promise<DbProductVariantLocation | undefined>

  • getProductVariantLocations: ((__namedParameters?) => Promise<DbProductVariantLocation[]>)

    • • (__namedParameters?): Promise<DbProductVariantLocation[]>

      • Parameters

        • __namedParameters: {
              productVariantIds?: string[];
              storeDomainId?: number;
          } = {}

          • Optional productVariantIds?: string[]

          • Optional storeDomainId?: number

        Returns Promise<DbProductVariantLocation[]>

  • updateBackInStockDate: ((__namedParameters) => Promise<void>)

    • • (__namedParameters): Promise<void>

      • Parameters

        • __namedParameters: {
              estimatedDate: null | Date;
              productVariantId?: string;
              sku?: string;
              storeDomainId: number;
          }

          • estimatedDate: null | Date

          • Optional productVariantId?: string

          • Optional sku?: string

          • storeDomainId: number

        Returns Promise<void>

  • updateInventory: ((__namedParameters) => Promise<void>)

    • • (__namedParameters): Promise<void>

      • Updates inventory for a product variant location and then recalculates the inventory for the product

        Parameters

        • __namedParameters: {
              inventory: number;
              productVariantId?: string;
              sku?: string;
              storeDomainId: number;
          }

          • inventory: number

          • Optional productVariantId?: string

          • Optional sku?: string

          • storeDomainId: number

        Returns Promise<void>

  • upsertProductVariantLocation: ((__namedParameters) => Promise<{
        algoliaObjectId: null | string;
        compareAtPrice: null | string;
        createdAt: Date;
        id: number;
        inventory: number;
        nextInDcAt: null | Date;
        price: string;
        productVariantId: string;
        shopifyInventoryItemId: null | string;
        shopifyVariantId: null | string;
        statusId: number;
        storeDomainId: number;
        updatedAt: Date;
    }>)

    • • (__namedParameters): Promise<{
            algoliaObjectId: null | string;
            compareAtPrice: null | string;
            createdAt: Date;
            id: number;
            inventory: number;
            nextInDcAt: null | Date;
            price: string;
            productVariantId: string;
            shopifyInventoryItemId: null | string;
            shopifyVariantId: null | string;
            statusId: number;
            storeDomainId: number;
            updatedAt: Date;
        }>

      • Upsert product variant location ProductVariantId or SKU is required price is required for a new record

        Parameters

        • __namedParameters: ProductVariantLocationUpdate

        Returns Promise<{
            algoliaObjectId: null | string;
            compareAtPrice: null | string;
            createdAt: Date;
            id: number;
            inventory: number;
            nextInDcAt: null | Date;
            price: string;
            productVariantId: string;
            shopifyInventoryItemId: null | string;
            shopifyVariantId: null | string;
            statusId: number;
            storeDomainId: number;
            updatedAt: Date;
        }>

  • upsertProductVariantLocations: ((updates) => Promise<void>)

    • • (updates): Promise<void>

      • Parameters

        • updates: ProductVariantLocationUpdate[]

        Returns Promise<void>

• productVariants: {
      getProductVariant: ((__namedParameters) => Promise<DbProductVariant | undefined>);
      getProductVariantLocationSpecific: ((__namedParameters) => Promise<ProductVariantLocationSpecific | undefined>);
      getProductVariants: ((__namedParameters?) => Promise<{
          count: number;
          productVariants: DbProductVariant[];
      }>);
      getProductVariantsLocationSpecific: ((__namedParameters) => Promise<{
          count: number;
          productVariants: ProductVariantLocationSpecific[];
      }>);
      getProductVariantsWithLocations: ((__namedParameters) => Promise<{
          count: number;
          productVariantsWithLocations: ProductVariantWithLocations[];
      }>);
      manuallyUpdateParentProductForVariant: ((__namedParameters) => Promise<void>);
      upsertProductVariant: ((__namedParameters) => Promise<{
          color: null | string;
          countryOfOrigin: null | string;
          createdAt: Date;
          density: null | string;
          displayName: string;
          fabric: null | string;
          htsCode: null | string;
          id: string;
          isManual: boolean;
          itemClass: null | string;
          needsReview: boolean;
          netsuiteProductType: null | string;
          netsuiteRecordType: string;
          productId: string;
          program: null | string;
          scent: null | string;
          size: null | string;
          sku: string;
          style: null | string;
          taxCode: null | string;
          upc: null | string;
          updatedAt: Date;
          weightLb: null | string;
      }>);
  }

  • getProductVariant: ((__namedParameters) => Promise<DbProductVariant | undefined>)

    • • (__namedParameters): Promise<DbProductVariant | undefined>

      • Parameters

        • __namedParameters: {
              id?: string;
              sku?: string;
          }

          • Optional id?: string

          • Optional sku?: string

        Returns Promise<DbProductVariant | undefined>

  • getProductVariantLocationSpecific: ((__namedParameters) => Promise<ProductVariantLocationSpecific | undefined>)

    • • (__namedParameters): Promise<ProductVariantLocationSpecific | undefined>

      • Parameters

        • __namedParameters: {
              id?: string;
              shopifyVariantId?: string;
              sku?: string;
              statusId?: number;
              storeDomainId: number;
          }

          • Optional id?: string

          • Optional shopifyVariantId?: string

          • Optional sku?: string

          • Optional statusId?: number

          • storeDomainId: number

        Returns Promise<ProductVariantLocationSpecific | undefined>

  • getProductVariants: ((__namedParameters?) => Promise<{
        count: number;
        productVariants: DbProductVariant[];
    }>)

    • • (__namedParameters?): Promise<{
            count: number;
            productVariants: DbProductVariant[];
        }>

      • Parameters

        • __namedParameters: ProductVariantsQuery & DbSearchParams<{
              color: null | string;
              countryOfOrigin: null | string;
              createdAt: Date;
              density: null | string;
              displayName: string;
              fabric: null | string;
              htsCode: null | string;
              id: string;
              isManual: boolean;
              itemClass: null | string;
              needsReview: boolean;
              netsuiteProductType: null | string;
              netsuiteRecordType: string;
              productId: string;
              program: null | string;
              scent: null | string;
              size: null | string;
              sku: string;
              style: null | string;
              taxCode: null | string;
              upc: null | string;
              updatedAt: Date;
              weightLb: null | string;
          }> = {}

        Returns Promise<{
            count: number;
            productVariants: DbProductVariant[];
        }>

  • getProductVariantsLocationSpecific: ((__namedParameters) => Promise<{
        count: number;
        productVariants: ProductVariantLocationSpecific[];
    }>)

    • • (__namedParameters): Promise<{
            count: number;
            productVariants: ProductVariantLocationSpecific[];
        }>

      • Parameters

        • __namedParameters: {
              hasBisDate?: boolean;
              shopifyVariantIds?: string[];
              statusIds?: number[];
              storeDomainId: number;
          } & ProductVariantsQuery & DbSearchParams<{
              algoliaObjectId: null | string;
              compareAtPrice: null | string;
              createdAt: Date;
              id: number;
              inventory: number;
              nextInDcAt: null | Date;
              price: string;
              productVariantId: string;
              shopifyInventoryItemId: null | string;
              shopifyVariantId: null | string;
              statusId: number;
              storeDomainId: number;
              updatedAt: Date;
          }>

        Returns Promise<{
            count: number;
            productVariants: ProductVariantLocationSpecific[];
        }>

  • getProductVariantsWithLocations: ((__namedParameters) => Promise<{
        count: number;
        productVariantsWithLocations: ProductVariantWithLocations[];
    }>)

    • • (__namedParameters): Promise<{
            count: number;
            productVariantsWithLocations: ProductVariantWithLocations[];
        }>

      • Parameters

        • __namedParameters: {
              direction?: "asc" | "desc";
              filter?: string;
              hasBisDate?: boolean;
              ids?: string[];
              isManual?: boolean;
              limit?: number;
              needsReview?: boolean;
              page?: number;
              productIds?: string[];
              skus?: string[];
              sort?: "id" | "createdAt" | "updatedAt" | "productId" | "displayName" | "netsuiteRecordType" | "isManual" | "sku" | "upc" | "htsCode" | "color" | "size" | "itemClass" | "netsuiteProductType" | "style" | "density" | "scent" | "taxCode" | "program" | "fabric" | "countryOfOrigin" | "weightLb" | "needsReview";
              statusIds?: number[];
              storeDomainId?: number;
          }

          • Optional direction?: "asc" | "desc"

          • Optional filter?: string

          • Optional hasBisDate?: boolean

          • Optional ids?: string[]

          • Optional isManual?: boolean

          • Optional limit?: number

          • Optional needsReview?: boolean

          • Optional page?: number

          • Optional productIds?: string[]

          • Optional skus?: string[]

          • Optional sort?: "id" | "createdAt" | "updatedAt" | "productId" | "displayName" | "netsuiteRecordType" | "isManual" | "sku" | "upc" | "htsCode" | "color" | "size" | "itemClass" | "netsuiteProductType" | "style" | "density" | "scent" | "taxCode" | "program" | "fabric" | "countryOfOrigin" | "weightLb" | "needsReview"

          • Optional statusIds?: number[]

          • Optional storeDomainId?: number

        Returns Promise<{
            count: number;
            productVariantsWithLocations: ProductVariantWithLocations[];
        }>

  • manuallyUpdateParentProductForVariant: ((__namedParameters) => Promise<void>)

    • • (__namedParameters): Promise<void>

      • Parameters

        • __namedParameters: {
              productId: string;
              productVariantId: string;
          }

          • productId: string

          • productVariantId: string

        Returns Promise<void>

  • upsertProductVariant: ((__namedParameters) => Promise<{
        color: null | string;
        countryOfOrigin: null | string;
        createdAt: Date;
        density: null | string;
        displayName: string;
        fabric: null | string;
        htsCode: null | string;
        id: string;
        isManual: boolean;
        itemClass: null | string;
        needsReview: boolean;
        netsuiteProductType: null | string;
        netsuiteRecordType: string;
        productId: string;
        program: null | string;
        scent: null | string;
        size: null | string;
        sku: string;
        style: null | string;
        taxCode: null | string;
        upc: null | string;
        updatedAt: Date;
        weightLb: null | string;
    }>)

    • • (__namedParameters): Promise<{
            color: null | string;
            countryOfOrigin: null | string;
            createdAt: Date;
            density: null | string;
            displayName: string;
            fabric: null | string;
            htsCode: null | string;
            id: string;
            isManual: boolean;
            itemClass: null | string;
            needsReview: boolean;
            netsuiteProductType: null | string;
            netsuiteRecordType: string;
            productId: string;
            program: null | string;
            scent: null | string;
            size: null | string;
            sku: string;
            style: null | string;
            taxCode: null | string;
            upc: null | string;
            updatedAt: Date;
            weightLb: null | string;
        }>

      • Parameters

        • __namedParameters: {
              color?: string;
              countryOfOrigin?: string;
              density?: string;
              displayName?: string;
              fabric?: string;
              htsCode?: string;
              id?: string;
              isManual?: boolean;
              itemClass?: string;
              needsReview?: boolean;
              netsuiteProductType?: string;
              netsuiteRecordType?: NetsuiteRecordType;
              productId?: string;
              program?: string;
              scent?: string;
              size?: string;
              sku?: string;
              style?: string;
              taxCode?: string;
              upc?: string;
              weightLb?: string;
          }

          • Optional color?: string

          • Optional countryOfOrigin?: string

          • Optional density?: string

          • Optional displayName?: string

          • Optional fabric?: string

          • Optional htsCode?: string

          • Optional id?: string

          • Optional isManual?: boolean

          • Optional itemClass?: string

          • Optional needsReview?: boolean

          • Optional netsuiteProductType?: string

          • Optional netsuiteRecordType?: NetsuiteRecordType

          • Optional productId?: string

          • Optional program?: string

          • Optional scent?: string

          • Optional size?: string

          • Optional sku?: string

          • Optional style?: string

          • Optional taxCode?: string

          • Optional upc?: string

          • Optional weightLb?: string

        Returns Promise<{
            color: null | string;
            countryOfOrigin: null | string;
            createdAt: Date;
            density: null | string;
            displayName: string;
            fabric: null | string;
            htsCode: null | string;
            id: string;
            isManual: boolean;
            itemClass: null | string;
            needsReview: boolean;
            netsuiteProductType: null | string;
            netsuiteRecordType: string;
            productId: string;
            program: null | string;
            scent: null | string;
            size: null | string;
            sku: string;
            style: null | string;
            taxCode: null | string;
            upc: null | string;
            updatedAt: Date;
            weightLb: null | string;
        }>

• products: {
      bulkAddProductTags: ((__namedParameters) => Promise<void>);
      bulkRemoveProductTags: ((__namedParameters) => Promise<void>);
      bulkUpdateProductMaterials: ((__namedParameters) => Promise<void>);
      bulkUpdateProductTypes: ((__namedParameters) => Promise<void>);
      getAlgoliaProductObjectId: ((__namedParameters) => Promise<undefined | string>);
      getProduct: ((__namedParameters) => Promise<DbProduct | undefined>);
      getProductLocationSpecific: ((__namedParameters) => Promise<ProductLocationSpecific | undefined>);
      getProducts: ((__namedParameters?) => Promise<{
          count: number;
          products: DbProduct[];
      }>);
      getProductsLocationSpecific: ((__namedParameters) => Promise<{
          count: number;
          products: ProductLocationSpecific[];
      }>);
      getProductsWithLocations: ((__namedParameters) => Promise<{
          count: number;
          productsWithLocations: ProductWithLocations[];
      }>);
      manuallyCreateProduct: ((__namedParameters) => Promise<{
          handle: string;
          id: string;
          name: string;
      }>);
      upsertProduct: ((__namedParameters) => Promise<{
          createdAt: Date;
          displayName: string;
          handle: null | string;
          id: string;
          isManual: boolean;
          lastReviewedAt: null | Date;
          name: string;
          netsuiteRecordType: string;
          productMaterialId: null | number;
          productTypeId: null | number;
          updatedAt: Date;
      }>);
  }

  • bulkAddProductTags: ((__namedParameters) => Promise<void>)

    • • (__namedParameters): Promise<void>

      • Parameters

        • __namedParameters: {
              productIds: string[];
              productTagIds: number[];
          }

          • productIds: string[]

          • productTagIds: number[]

        Returns Promise<void>

  • bulkRemoveProductTags: ((__namedParameters) => Promise<void>)

    • • (__namedParameters): Promise<void>

      • Parameters

        • __namedParameters: {
              productIds: string[];
              productTagIds: number[];
          }

          • productIds: string[]

          • productTagIds: number[]

        Returns Promise<void>

  • bulkUpdateProductMaterials: ((__namedParameters) => Promise<void>)

    • • (__namedParameters): Promise<void>

      • Parameters

        • __namedParameters: {
              productIds: string[];
              productMaterialId: number;
          }

          • productIds: string[]

          • productMaterialId: number

        Returns Promise<void>

  • bulkUpdateProductTypes: ((__namedParameters) => Promise<void>)

    • • (__namedParameters): Promise<void>

      • Parameters

        • __namedParameters: {
              productIds: string[];
              productTypeId: number;
          }

          • productIds: string[]

          • productTypeId: number

        Returns Promise<void>

  • getAlgoliaProductObjectId: ((__namedParameters) => Promise<undefined | string>)

    • • (__namedParameters): Promise<undefined | string>

      • Always uses the default store domain and the production environment.

        Parameters

        • __namedParameters: {
              bundleId?: number;
              bundleSku?: string;
              handle?: string;
              productId?: string;
          }

          • Optional bundleId?: number

          • Optional bundleSku?: string

          • Optional handle?: string

          • Optional productId?: string

        Returns Promise<undefined | string>

  • getProduct: ((__namedParameters) => Promise<DbProduct | undefined>)

    • • (__namedParameters): Promise<DbProduct | undefined>

      • Parameters

        • __namedParameters: {
              handle?: string;
              id?: string;
          }

          • Optional handle?: string

          • Optional id?: string

        Returns Promise<DbProduct | undefined>

  • getProductLocationSpecific: ((__namedParameters) => Promise<ProductLocationSpecific | undefined>)

    • • (__namedParameters): Promise<ProductLocationSpecific | undefined>

      • Parameters

        • __namedParameters: {
              handle?: string;
              id?: string;
              shopifyProductId?: string;
              statusId?: number;
              storeDomainId: number;
          }

          • Optional handle?: string

          • Optional id?: string

          • Optional shopifyProductId?: string

          • Optional statusId?: number

          • storeDomainId: number

        Returns Promise<ProductLocationSpecific | undefined>

  • getProducts: ((__namedParameters?) => Promise<{
        count: number;
        products: DbProduct[];
    }>)

    • • (__namedParameters?): Promise<{
            count: number;
            products: DbProduct[];
        }>

      • Parameters

        • __namedParameters: ProductsQuery & DbSearchParams<{
              createdAt: Date;
              displayName: string;
              handle: null | string;
              id: string;
              isManual: boolean;
              lastReviewedAt: null | Date;
              name: string;
              netsuiteRecordType: string;
              productMaterialId: null | number;
              productTypeId: null | number;
              updatedAt: Date;
          }> = {}

        Returns Promise<{
            count: number;
            products: DbProduct[];
        }>

  • getProductsLocationSpecific: ((__namedParameters) => Promise<{
        count: number;
        products: ProductLocationSpecific[];
    }>)

    • • (__namedParameters): Promise<{
            count: number;
            products: ProductLocationSpecific[];
        }>

      • Parameters

        • __namedParameters: {
              shopifyProductIds?: string[];
              statusIds?: number[];
              storeDomainId: number | number[];
          } & ProductsQuery & DbSearchParams<{
              algoliaObjectId: null | string;
              createdAt: Date;
              firstAvailableAt: null | Date;
              id: number;
              inventory: number;
              productId: string;
              shopifyProductId: null | string;
              statusId: number;
              storeDomainId: number;
              updatedAt: Date;
          }>

        Returns Promise<{
            count: number;
            products: ProductLocationSpecific[];
        }>

  • getProductsWithLocations: ((__namedParameters) => Promise<{
        count: number;
        productsWithLocations: ProductWithLocations[];
    }>)

    • • (__namedParameters): Promise<{
            count: number;
            productsWithLocations: ProductWithLocations[];
        }>

      • Parameters

        • __namedParameters: {
              direction?: "asc" | "desc";
              filter?: string;
              handles?: string[];
              ids?: string[];
              isManual?: boolean;
              limit?: number;
              page?: number;
              productMaterialIds?: number[];
              productTagIds?: number[];
              productTypeIds?: number[];
              sort?: "id" | "name" | "createdAt" | "updatedAt" | "productTypeId" | "displayName" | "handle" | "productMaterialId" | "netsuiteRecordType" | "isManual" | "lastReviewedAt";
              statusIds?: number[];
              storeDomainId?: number;
          }

          • Optional direction?: "asc" | "desc"

          • Optional filter?: string

          • Optional handles?: string[]

          • Optional ids?: string[]

          • Optional isManual?: boolean

          • Optional limit?: number

          • Optional page?: number

          • Optional productMaterialIds?: number[]

          • Optional productTagIds?: number[]

          • Optional productTypeIds?: number[]

          • Optional sort?: "id" | "name" | "createdAt" | "updatedAt" | "productTypeId" | "displayName" | "handle" | "productMaterialId" | "netsuiteRecordType" | "isManual" | "lastReviewedAt"

          • Optional statusIds?: number[]

          • Optional storeDomainId?: number

        Returns Promise<{
            count: number;
            productsWithLocations: ProductWithLocations[];
        }>

  • manuallyCreateProduct: ((__namedParameters) => Promise<{
        handle: string;
        id: string;
        name: string;
    }>)

    • • (__namedParameters): Promise<{
            handle: string;
            id: string;
            name: string;
        }>

      • Parameters

        • __namedParameters: {
              handle?: string;
              name: string;
          }

          • Optional handle?: string

          • name: string

        Returns Promise<{
            handle: string;
            id: string;
            name: string;
        }>

  • upsertProduct: ((__namedParameters) => Promise<{
        createdAt: Date;
        displayName: string;
        handle: null | string;
        id: string;
        isManual: boolean;
        lastReviewedAt: null | Date;
        name: string;
        netsuiteRecordType: string;
        productMaterialId: null | number;
        productTypeId: null | number;
        updatedAt: Date;
    }>)

    • • (__namedParameters): Promise<{
            createdAt: Date;
            displayName: string;
            handle: null | string;
            id: string;
            isManual: boolean;
            lastReviewedAt: null | Date;
            name: string;
            netsuiteRecordType: string;
            productMaterialId: null | number;
            productTypeId: null | number;
            updatedAt: Date;
        }>

      • Parameters

        • __namedParameters: {
              displayName?: string;
              handle?: string;
              id?: string;
              isManual?: boolean;
              lastReviewedAt?: Date;
              name?: string;
              netsuiteRecordType?: NetsuiteRecordType;
              productMaterialId?: null | number;
              productTypeId?: null | number;
          }

          • Optional displayName?: string

          • Optional handle?: string

          • Optional id?: string

          • Optional isManual?: boolean

          • Optional lastReviewedAt?: Date

          • Optional name?: string

          • Optional netsuiteRecordType?: NetsuiteRecordType

          • Optional productMaterialId?: null | number

          • Optional productTypeId?: null | number

        Returns Promise<{
            createdAt: Date;
            displayName: string;
            handle: null | string;
            id: string;
            isManual: boolean;
            lastReviewedAt: null | Date;
            name: string;
            netsuiteRecordType: string;
            productMaterialId: null | number;
            productTypeId: null | number;
            updatedAt: Date;
        }>