@pinelab/vendure-plugin-sendcloud 0.0.3

package/dist/vendure-plugin-sendcloud/src/api/sendcloud.resolver.js

@@ -0,0 +1,75 @@
+"use strict";
+var __decorate = (this && this.__decorate) || function (decorators, target, key, desc) {
+    var c = arguments.length, r = c < 3 ? target : desc === null ? desc = Object.getOwnPropertyDescriptor(target, key) : desc, d;
+    if (typeof Reflect === "object" && typeof Reflect.decorate === "function") r = Reflect.decorate(decorators, target, key, desc);
+    else for (var i = decorators.length - 1; i >= 0; i--) if (d = decorators[i]) r = (c < 3 ? d(r) : c > 3 ? d(target, key, r) : d(target, key)) || r;
+    return c > 3 && r && Object.defineProperty(target, key, r), r;
+};
+var __metadata = (this && this.__metadata) || function (k, v) {
+    if (typeof Reflect === "object" && typeof Reflect.metadata === "function") return Reflect.metadata(k, v);
+};
+var __param = (this && this.__param) || function (paramIndex, decorator) {
+    return function (target, key) { decorator(target, key, paramIndex); }
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.SendcloudResolver = exports.sendcloudPermission = void 0;
+const graphql_1 = require("@nestjs/graphql");
+const core_1 = require("@vendure/core");
+const sendcloud_service_1 = require("./sendcloud.service");
+exports.sendcloudPermission = new core_1.PermissionDefinition({
+    name: 'SetSendCloudConfig',
+    description: 'Allows setting SendCloud configuration',
+});
+let SendcloudResolver = class SendcloudResolver {
+    constructor(service, orderService) {
+        this.service = service;
+        this.orderService = orderService;
+    }
+    async sendToSendCloud(ctx, orderId) {
+        const order = await this.orderService.findOne(ctx, orderId);
+        if (!order) {
+            throw new Error(`No order with id ${orderId} exists`);
+        }
+        core_1.Logger.info(`Sync to Sendcloud mutation called by user ${ctx.activeUserId} for order ${orderId}`);
+        await this.service.createOrderInSendcloud(ctx, order);
+        return true;
+    }
+    async sendCloudConfig(ctx) {
+        return this.service.getConfig(ctx);
+    }
+    async updateSendCloudConfig(ctx, input) {
+        return this.service.upsertConfig(ctx, input);
+    }
+};
+__decorate([
+    (0, graphql_1.Mutation)(),
+    (0, core_1.Allow)(core_1.Permission.UpdateOrder),
+    __param(0, (0, core_1.Ctx)()),
+    __param(1, (0, graphql_1.Args)('orderId')),
+    __metadata("design:type", Function),
+    __metadata("design:paramtypes", [core_1.RequestContext, String]),
+    __metadata("design:returntype", Promise)
+], SendcloudResolver.prototype, "sendToSendCloud", null);
+__decorate([
+    (0, graphql_1.Query)(),
+    (0, core_1.Allow)(exports.sendcloudPermission.Permission),
+    __param(0, (0, core_1.Ctx)()),
+    __metadata("design:type", Function),
+    __metadata("design:paramtypes", [core_1.RequestContext]),
+    __metadata("design:returntype", Promise)
+], SendcloudResolver.prototype, "sendCloudConfig", null);
+__decorate([
+    (0, graphql_1.Mutation)(),
+    (0, core_1.Allow)(exports.sendcloudPermission.Permission),
+    __param(0, (0, core_1.Ctx)()),
+    __param(1, (0, graphql_1.Args)('input')),
+    __metadata("design:type", Function),
+    __metadata("design:paramtypes", [core_1.RequestContext, Object]),
+    __metadata("design:returntype", Promise)
+], SendcloudResolver.prototype, "updateSendCloudConfig", null);
+SendcloudResolver = __decorate([
+    (0, graphql_1.Resolver)(),
+    __metadata("design:paramtypes", [sendcloud_service_1.SendcloudService,
+        core_1.OrderService])
+], SendcloudResolver);
+exports.SendcloudResolver = SendcloudResolver;

package/dist/vendure-plugin-sendcloud/src/api/sendcloud.service.d.ts

@@ -0,0 +1,48 @@
+import { OnApplicationBootstrap, OnModuleInit } from '@nestjs/common';
+import { ModuleRef } from '@nestjs/core';
+import { ChannelService, EntityHydrator, EventBus, HistoryService, ID, JobQueueService, Order, OrderService, RequestContext, TransactionalConnection } from '@vendure/core';
+import { SendcloudConfigEntity } from './sendcloud-config.entity';
+import { SendcloudClient } from './sendcloud.client';
+import { Parcel } from './types/sendcloud-api.types';
+import { SendcloudParcelStatus, SendcloudPluginOptions } from './types/sendcloud.types';
+export declare class SendcloudService implements OnApplicationBootstrap, OnModuleInit {
+    private eventBus;
+    private connection;
+    private orderService;
+    private channelService;
+    private jobQueueService;
+    private moduleRef;
+    private options;
+    private entityHydrator;
+    private historyService;
+    private jobQueue;
+    constructor(eventBus: EventBus, connection: TransactionalConnection, orderService: OrderService, channelService: ChannelService, jobQueueService: JobQueueService, moduleRef: ModuleRef, options: SendcloudPluginOptions, entityHydrator: EntityHydrator, historyService: HistoryService);
+    onModuleInit(): Promise<void>;
+    onApplicationBootstrap(): void;
+    createOrderInSendcloud(userCtx: RequestContext, order: Order): Promise<Parcel | undefined>;
+    /**
+     * Update order by given orderCode, returns undefined if no action was taken
+     * Returns order if transition was successful
+     */
+    updateOrderStatus(ctx: RequestContext, sendcloudStatus: SendcloudParcelStatus, orderCode: string, trackingNumber: string): Promise<void>;
+    /**
+     * Fulfill and ship all items
+     */
+    shipAll(ctx: RequestContext, order: Order, trackingNumber: string): Promise<void>;
+    upsertConfig(ctx: RequestContext, config: {
+        secret: string;
+        publicKey: string;
+        defaultPhoneNr: string;
+    }): Promise<SendcloudConfigEntity>;
+    getConfig(ctx: RequestContext): Promise<SendcloudConfigEntity | null>;
+    getClient(ctx: RequestContext): Promise<{
+        client: SendcloudClient;
+        defaultPhoneNr?: string;
+    }>;
+    createContext(channelToken: string): Promise<RequestContext>;
+    /**
+     * Sync order to Sendcloud platform
+     */
+    private syncOrder;
+    logHistoryEntry(ctx: RequestContext, orderId: ID, error?: unknown): Promise<void>;
+}

package/dist/vendure-plugin-sendcloud/src/api/sendcloud.service.js

@@ -0,0 +1,245 @@
+"use strict";
+var __decorate = (this && this.__decorate) || function (decorators, target, key, desc) {
+    var c = arguments.length, r = c < 3 ? target : desc === null ? desc = Object.getOwnPropertyDescriptor(target, key) : desc, d;
+    if (typeof Reflect === "object" && typeof Reflect.decorate === "function") r = Reflect.decorate(decorators, target, key, desc);
+    else for (var i = decorators.length - 1; i >= 0; i--) if (d = decorators[i]) r = (c < 3 ? d(r) : c > 3 ? d(target, key, r) : d(target, key)) || r;
+    return c > 3 && r && Object.defineProperty(target, key, r), r;
+};
+var __metadata = (this && this.__metadata) || function (k, v) {
+    if (typeof Reflect === "object" && typeof Reflect.metadata === "function") return Reflect.metadata(k, v);
+};
+var __param = (this && this.__param) || function (paramIndex, decorator) {
+    return function (target, key) { decorator(target, key, paramIndex); }
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.SendcloudService = void 0;
+const common_1 = require("@nestjs/common");
+const core_1 = require("@nestjs/core");
+const core_2 = require("@vendure/core");
+const sendcloud_adapter_1 = require("./sendcloud.adapter");
+const constants_1 = require("./constants");
+const sendcloud_config_entity_1 = require("./sendcloud-config.entity");
+const sendcloud_client_1 = require("./sendcloud.client");
+const sendcloud_handler_1 = require("./sendcloud.handler");
+const src_1 = require("../../../util/src");
+let SendcloudService = class SendcloudService {
+    constructor(eventBus, connection, 
+    // private rawConnection: Connection,
+    orderService, channelService, jobQueueService, moduleRef, options, entityHydrator, historyService) {
+        this.eventBus = eventBus;
+        this.connection = connection;
+        this.orderService = orderService;
+        this.channelService = channelService;
+        this.jobQueueService = jobQueueService;
+        this.moduleRef = moduleRef;
+        this.options = options;
+        this.entityHydrator = entityHydrator;
+        this.historyService = historyService;
+    }
+    async onModuleInit() {
+        this.jobQueue = await this.jobQueueService.createQueue({
+            name: 'sendcloud',
+            process: async ({ data }) => {
+                const ctx = core_2.RequestContext.deserialize(data.ctx);
+                try {
+                    await this.syncOrder(ctx, data.orderCode);
+                }
+                catch (error) {
+                    core_2.Logger.warn(`Failed to sync order ${data.orderCode} for channel ${ctx.channel.token}: ${error}`, constants_1.loggerCtx);
+                    throw error;
+                }
+            },
+        });
+    }
+    onApplicationBootstrap() {
+        // Listen for Settled orders to sync to sendcloud
+        this.eventBus.ofType(core_2.OrderPlacedEvent).subscribe(async (event) => {
+            await this.jobQueue.add({
+                orderCode: event.order.code,
+                ctx: event.ctx.serialize(),
+            }, { retries: 20 });
+        });
+    }
+    async createOrderInSendcloud(userCtx, order) {
+        if (this.options.disabled) {
+            core_2.Logger.info(`Plugin is disabled, not syncing order ${order.code}`, constants_1.loggerCtx);
+            return;
+        }
+        const ctx = await this.createContext(userCtx.channel.token); // Recreate a ctx with the channel's default language
+        try {
+            await this.entityHydrator.hydrate(ctx, order, {
+                relations: [
+                    'customer',
+                    'lines.productVariant.product',
+                    'shippingLines.shippingMethod',
+                ],
+            });
+            const additionalParcelItems = [];
+            if (this.options.additionalParcelItemsFn) {
+                additionalParcelItems.push(...(await this.options.additionalParcelItemsFn(ctx, new core_2.Injector(this.moduleRef), order)));
+            }
+            const { client, defaultPhoneNr } = await this.getClient(ctx);
+            const parcelInput = (0, sendcloud_adapter_1.toParcelInput)(order, this.options, defaultPhoneNr);
+            parcelInput.parcel_items.unshift(...additionalParcelItems);
+            const parcel = await client.createParcel(parcelInput);
+            await this.logHistoryEntry(ctx, order.id);
+            return parcel;
+        }
+        catch (err) {
+            await this.logHistoryEntry(ctx, order.id, err);
+            throw err;
+        }
+    }
+    /**
+     * Update order by given orderCode, returns undefined if no action was taken
+     * Returns order if transition was successful
+     */
+    async updateOrderStatus(ctx, sendcloudStatus, orderCode, trackingNumber) {
+        let order = await this.connection
+            .getRepository(ctx, core_2.Order)
+            .findOne({ where: { code: orderCode }, relations: ['lines'] });
+        if (!order) {
+            core_2.Logger.warn(`Cannot update status from SendCloud: No order with code ${orderCode} found`, constants_1.loggerCtx);
+            throw Error(`Cannot update status from SendCloud: No order with code ${orderCode} found`);
+        }
+        if (order.state === sendcloudStatus.orderState) {
+            return core_2.Logger.info(`Not updating order with code ${orderCode}: Order already has state ${order.state}`, constants_1.loggerCtx);
+        }
+        if (sendcloudStatus.orderState === 'Shipped') {
+            await this.shipAll(ctx, order, trackingNumber);
+            return core_2.Logger.info(`Successfully update order ${orderCode} to ${sendcloudStatus.orderState}`, constants_1.loggerCtx);
+        }
+        order = await this.connection
+            .getRepository(ctx, core_2.Order)
+            .findOneOrFail({ where: { code: orderCode }, relations: ['lines'] }); // Refetch in case state was updated
+        if (sendcloudStatus.orderState === 'Delivered') {
+            //FIX ME
+            await (0, src_1.transitionToDelivered)(this.orderService, ctx, order, {
+                code: sendcloud_handler_1.sendcloudHandler.code,
+                arguments: [
+                    {
+                        name: 'trackingNumber',
+                        value: trackingNumber,
+                    },
+                ],
+            });
+            return core_2.Logger.info(`Successfully update order ${orderCode} to ${sendcloudStatus.orderState}`, constants_1.loggerCtx);
+        }
+        // Fall through, means unhandled state
+        core_2.Logger.info(`Not handling state ${sendcloudStatus.orderState}`, constants_1.loggerCtx);
+    }
+    /**
+     * Fulfill and ship all items
+     */
+    async shipAll(ctx, order, trackingNumber) {
+        await (0, src_1.transitionToShipped)(this.orderService, ctx, order, {
+            code: sendcloud_handler_1.sendcloudHandler.code,
+            arguments: [
+                {
+                    name: 'trackingNumber',
+                    value: trackingNumber,
+                },
+            ],
+        });
+    }
+    async upsertConfig(ctx, config) {
+        const repo = this.connection.getRepository(ctx, sendcloud_config_entity_1.SendcloudConfigEntity);
+        const existing = await repo.findOne({
+            where: { channelId: String(ctx.channelId) },
+        });
+        if (existing) {
+            await repo.update(existing.id, {
+                secret: config.secret,
+                publicKey: config.publicKey,
+                defaultPhoneNr: config.defaultPhoneNr,
+            });
+        }
+        else {
+            await repo.insert({
+                channelId: String(ctx.channelId),
+                secret: config.secret,
+                publicKey: config.publicKey,
+                defaultPhoneNr: config.defaultPhoneNr,
+            });
+        }
+        return repo.findOneOrFail({ where: { channelId: String(ctx.channelId) } });
+    }
+    async getConfig(ctx) {
+        return this.connection
+            .getRepository(ctx, sendcloud_config_entity_1.SendcloudConfigEntity)
+            .findOne({ where: { channelId: String(ctx.channelId) } });
+    }
+    async getClient(ctx) {
+        const config = await this.getConfig(ctx);
+        if (!config || !config?.secret || !config.publicKey) {
+            throw Error(`Incomplete config found for channel ${ctx.channel.token}`);
+        }
+        return {
+            client: new sendcloud_client_1.SendcloudClient(config.publicKey, config.secret),
+            defaultPhoneNr: config.defaultPhoneNr,
+        };
+    }
+    async createContext(channelToken) {
+        const channel = await this.channelService.getChannelFromToken(channelToken);
+        return new core_2.RequestContext({
+            apiType: 'admin',
+            isAuthorized: true,
+            authorizedAsOwnerOnly: false,
+            languageCode: channel.defaultLanguageCode,
+            channel,
+        });
+    }
+    /**
+     * Sync order to Sendcloud platform
+     */
+    async syncOrder(ctx, orderCode) {
+        const config = await this.getConfig(ctx);
+        if (!config?.secret || !config?.publicKey) {
+            return;
+        }
+        let order = await this.orderService.findOneByCode(ctx, orderCode, [
+            'shippingLines',
+            'shippingLines.shippingMethod',
+            'lines',
+        ]);
+        if (!order) {
+            return core_2.Logger.error(`No order found with code ${orderCode}. Can not sync this order.`, constants_1.loggerCtx);
+        }
+        const hasSendcloudHandler = order.shippingLines.find((line) => line.shippingMethod?.fulfillmentHandlerCode === sendcloud_handler_1.sendcloudHandler.code);
+        if (!hasSendcloudHandler) {
+            return core_2.Logger.info(`Order ${order.code} does not have SendCloud set as handler. Not syncing this order.`, constants_1.loggerCtx);
+        }
+        core_2.Logger.info(`Syncing order ${orderCode} for channel ${ctx.channel.token}`, constants_1.loggerCtx);
+        const result = await this.createOrderInSendcloud(ctx, order);
+        if (result) {
+            core_2.Logger.info(`Order ${order.code} synced to SendCloud: ${result.id}`, constants_1.loggerCtx);
+        }
+    }
+    async logHistoryEntry(ctx, orderId, error) {
+        let prettifiedError = error
+            ? JSON.parse(JSON.stringify(error, Object.getOwnPropertyNames(error)))
+            : undefined; // Make sure its serializable
+        await this.historyService.createHistoryEntryForOrder({
+            ctx,
+            orderId,
+            type: 'SENDCLOUD_NOTIFICATION',
+            data: {
+                name: 'SendCloud',
+                valid: !error,
+                error: prettifiedError,
+            },
+        }, false);
+    }
+};
+SendcloudService = __decorate([
+    (0, common_1.Injectable)(),
+    __param(6, (0, common_1.Inject)(constants_1.PLUGIN_OPTIONS)),
+    __metadata("design:paramtypes", [core_2.EventBus,
+        core_2.TransactionalConnection,
+        core_2.OrderService,
+        core_2.ChannelService,
+        core_2.JobQueueService,
+        core_1.ModuleRef, Object, core_2.EntityHydrator,
+        core_2.HistoryService])
+], SendcloudService);
+exports.SendcloudService = SendcloudService;

package/dist/vendure-plugin-sendcloud/src/api/types/sendcloud-api.types.d.ts

@@ -0,0 +1,82 @@
+export interface ParcelInput {
+    name: string;
+    company_name?: string;
+    address: string;
+    house_number: string;
+    city: string;
+    postal_code: string;
+    country: string;
+    telephone?: string;
+    request_label: boolean;
+    email?: string;
+    order_number?: string;
+    parcel_items: ParcelInputItem[];
+    weight: string;
+    shipping_method_checkout_name?: string;
+}
+export interface ParcelInputItem {
+    description: string;
+    quantity: number;
+    weight: string;
+    sku: string;
+    value: string;
+    hs_code?: string;
+    origin_country?: string;
+}
+export interface Parcel {
+    id: number;
+    name: string;
+    company_name: string;
+    address: string;
+    address_divided: AddressDivided;
+    city: string;
+    postal_code: string;
+    telephone: string;
+    email: string;
+    date_created: string;
+    date_updated: string;
+    date_announced: string;
+    tracking_number: string;
+    weight: string;
+    label: Label;
+    customs_declaration: CustomsDeclaration;
+    status: Status;
+    data: any[];
+    country: Country;
+    shipment: Shipment;
+    colli_tracking_number: string;
+    colli_uuid: string;
+    collo_nr: number;
+    collo_count: number;
+    awb_tracking_number: null;
+    box_number: null;
+    order_number?: string;
+}
+export interface AddressDivided {
+    street: string;
+    house_number: string;
+}
+export interface Country {
+    iso_3: string;
+    iso_2: string;
+    name: string;
+}
+export interface CustomsDeclaration {
+}
+export interface Label {
+    normal_printer: string[];
+    label_printer: string;
+}
+export interface Shipment {
+    id: number;
+    name: string;
+}
+export interface Status {
+    id: number;
+    message: string;
+}
+export interface IncomingWebhookBody {
+    action: 'parcel_status_changed' | string;
+    timestamp: number;
+    parcel?: Parcel;
+}

package/dist/vendure-plugin-sendcloud/src/api/types/sendcloud-api.types.js

@@ -0,0 +1,2 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });

package/dist/vendure-plugin-sendcloud/src/api/types/sendcloud.types.d.ts

@@ -0,0 +1,41 @@
+import { Injector, Order, OrderLine, RequestContext } from '@vendure/core';
+import { ParcelInputItem } from './sendcloud-api.types';
+export interface SendcloudParcelStatus {
+    id: number;
+    message: string;
+    /**
+     * Corresponding orderState for the sendcloud status
+     */
+    orderState?: 'Shipped' | 'Delivered' | 'Cancelled';
+}
+export declare const sendcloudStates: SendcloudParcelStatus[];
+export interface SendcloudPluginOptions {
+    /**
+     * Function to specify the weight of a parcelItem
+     * based on the given orderLine
+     */
+    weightFn?: CustomFieldFn<number>;
+    /**
+     * Function to specify the hsCode for a parcelItem
+     */
+    hsCodeFn?: CustomFieldFn<string>;
+    originCountryFn?: CustomFieldFn<string>;
+    /**
+     * You can send additional ParcelItems (rows) to SendCloud.
+     * For example if you want the couponCodes applied on an order
+     * also on your packaging slip in SendCloud
+     */
+    additionalParcelItemsFn?: AdditionalParcelInputFn;
+    /**
+     * Programatically disable the plugin. For example, when running in a test-env:
+     * @example
+     * disabled: !!process.env.TEST
+     */
+    disabled?: boolean;
+}
+export type AdditionalParcelInputFn = (ctx: RequestContext, injector: Injector, order: Order) => Promise<ParcelInputItem[]>;
+export type CustomFieldFn<T = string | number> = (
+/**
+ * OrderLine with line.productVariant and line.productVariant.product
+ */
+line: OrderLine) => T;

package/dist/vendure-plugin-sendcloud/src/api/types/sendcloud.types.js

@@ -0,0 +1,157 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.sendcloudStates = void 0;
+exports.sendcloudStates = [
+    {
+        id: 62989,
+        message: 'The package has been held at customs',
+    },
+    {
+        id: 6,
+        message: 'Not sorted',
+        orderState: 'Shipped',
+    },
+    {
+        id: 15,
+        message: 'Error collecting',
+    },
+    {
+        id: 62990,
+        message: 'The package is in the sorting centre',
+        orderState: 'Shipped',
+    },
+    {
+        id: 62991,
+        message: 'The package was refused by the recipient when delivered',
+    },
+    {
+        id: 62992,
+        message: 'The package was returned to the sender due to an issue',
+    },
+    {
+        id: 62993,
+        message: 'The delivery method was changed by the request of the recipient or due to other circumstances.',
+    },
+    {
+        id: 1002,
+        message: 'Announcement failed',
+    },
+    {
+        id: 1999,
+        message: 'Cancellation requested',
+    },
+    {
+        id: 62994,
+        message: 'The delivery date was changed by the request of the recipient or due to other.',
+    },
+    {
+        id: 62995,
+        message: 'The delivery address was changed by the request of the recipient or due to other circumstances.',
+    },
+    {
+        id: 62996,
+        message: 'For unusual cases: lost, damaged, destroyed, etc.',
+    },
+    {
+        id: 1998,
+        message: 'Cancelled upstream',
+        orderState: 'Cancelled',
+    },
+    {
+        id: 1000,
+        message: 'Ready to send',
+        orderState: 'Shipped',
+    },
+    {
+        id: 62997,
+        message: 'The address is incorrect and the carrier needs address correction from the sender or the recipient.',
+    },
+    {
+        id: 12,
+        message: 'Awaiting customer pickup',
+        orderState: 'Shipped',
+    },
+    {
+        id: 11,
+        message: 'Delivered',
+        orderState: 'Delivered',
+    },
+    {
+        id: 93,
+        message: 'Shipment collected by customer',
+        orderState: 'Delivered',
+    },
+    {
+        id: 91,
+        message: 'Parcel en route',
+        orderState: 'Shipped',
+    },
+    {
+        id: 80,
+        message: 'Unable to deliver',
+    },
+    {
+        id: 22,
+        message: 'Shipment picked up by driver',
+        orderState: 'Shipped',
+    },
+    {
+        id: 13,
+        message: 'Announced: not collected',
+    },
+    {
+        id: 8,
+        message: 'Delivery attempt failed',
+    },
+    {
+        id: 7,
+        message: 'Being sorted',
+        orderState: 'Shipped',
+    },
+    {
+        id: 5,
+        message: 'Sorted',
+        orderState: 'Shipped',
+    },
+    {
+        id: 4,
+        message: 'Delivery delayed',
+    },
+    {
+        id: 3,
+        message: 'En route to sorting center',
+        orderState: 'Shipped',
+    },
+    {
+        id: 1,
+        message: 'Announced',
+        orderState: 'Shipped',
+    },
+    {
+        id: 1337,
+        message: 'Unknown status - check carrier track & trace page for more insights',
+    },
+    {
+        id: 999,
+        message: 'No label',
+    },
+    {
+        id: 1001,
+        message: 'Being announced',
+        orderState: 'Shipped',
+    },
+    {
+        id: 2000,
+        message: 'Cancelled',
+        orderState: 'Cancelled',
+    },
+    {
+        id: 2001,
+        message: 'Submitting cancellation request',
+    },
+    {
+        id: 92,
+        message: 'Driver en route',
+        orderState: 'Shipped',
+    },
+];

package/dist/vendure-plugin-sendcloud/src/index.d.ts

@@ -0,0 +1,5 @@
+export * from './sendcloud.plugin';
+export * from './api/sendcloud.handler';
+export * from './api/additional-parcel-input-items';
+export * from './api/types/sendcloud.types';
+export * from './api/types/sendcloud-api.types';

package/dist/vendure-plugin-sendcloud/src/index.js

@@ -0,0 +1,21 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __exportStar = (this && this.__exportStar) || function(m, exports) {
+    for (var p in m) if (p !== "default" && !Object.prototype.hasOwnProperty.call(exports, p)) __createBinding(exports, m, p);
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+__exportStar(require("./sendcloud.plugin"), exports);
+__exportStar(require("./api/sendcloud.handler"), exports);
+__exportStar(require("./api/additional-parcel-input-items"), exports);
+__exportStar(require("./api/types/sendcloud.types"), exports);
+__exportStar(require("./api/types/sendcloud-api.types"), exports);

package/dist/vendure-plugin-sendcloud/src/sendcloud.plugin.d.ts

@@ -0,0 +1,7 @@
+import { AdminUiExtension } from '@vendure/ui-devkit/compiler';
+import { SendcloudPluginOptions } from './api/types/sendcloud.types';
+export declare class SendcloudPlugin {
+    private static options;
+    static init(options: SendcloudPluginOptions): typeof SendcloudPlugin;
+    static ui: AdminUiExtension;
+}