import { Platform } from './models/Platform';
import { CustomerOrder } from './models/CustomerOrder';
import { OrderItem } from './models/OrderItem';
import { Payment } from './models/Payment';
import { PaymentAttempt } from './models/PaymentAttempt';
import { Shipment } from './models/Shipment';

export class TeaQLNotLoadedError extends Error {
    readonly details: Record<string, unknown>;

    constructor(
        readonly root: string,
        readonly accessPath: string,
        readonly breakPoint: string,
    ) {
        const suggestedFix = `select${breakPoint.charAt(0).toUpperCase()}${breakPoint.slice(1)}(...)`;
        const details = {
            error: 'TeaQLNotLoadedError',
            root,
            accessPath: accessPath.split('.'),
            breakPoint,
            missingPreload: [breakPoint],
            suggestedFix,
            severity: 'error',
            humanMessage: `访问 ${root}.${accessPath} 时缺少预加载。请在查询中加入 ${suggestedFix}`,
        };
        super(JSON.stringify(details));
        this.name = 'TeaQLNotLoadedError';
        this.details = details;
    }
}

function expressionPath(prefix: string, field: string): string {
    return prefix ? `${prefix}.${field}` : field;
}

export class ValueExpression<T> {
    constructor(
        private readonly value: T | null | undefined,
        private readonly present = true,
        private readonly notLoaded?: TeaQLNotLoadedError,
    ) {}

    static missing<T>(): ValueExpression<T> {
        return new ValueExpression<T>(undefined, false);
    }

    static notLoaded<T>(error: TeaQLNotLoadedError): ValueExpression<T> {
        return new ValueExpression<T>(undefined, false, error);
    }

    eval(): T | null | undefined {
        if (this.notLoaded) throw this.notLoaded;
        return this.present ? this.value : undefined;
    }

    isPresent(): boolean {
        if (this.notLoaded) throw this.notLoaded;
        return this.present;
    }

    orElse(fallback: T): T {
        const value = this.eval();
        return this.present && value != null ? value : fallback;
    }
}

export class PlatformExpression {
    constructor(
        private readonly value: Platform | null | undefined,
        private readonly root = 'Platform(null)',
        private readonly path = '',
        private readonly notLoaded?: TeaQLNotLoadedError,
    ) {}

    eval(): Platform | null | undefined {
        if (this.notLoaded) throw this.notLoaded;
        return this.value;
    }

    id(): ValueExpression<string> {
        if (this.notLoaded) return ValueExpression.notLoaded<string>(this.notLoaded);
        if (!this.value) return ValueExpression.missing<string>();
        const path = expressionPath(this.path, 'id');
        if (!this.value.isLoaded('id')) {
            return ValueExpression.notLoaded<string>(
                new TeaQLNotLoadedError(this.root, path, 'id'),
            );
        }
        return new ValueExpression<string>(this.value.id);
    }

    name(): ValueExpression<string> {
        if (this.notLoaded) return ValueExpression.notLoaded<string>(this.notLoaded);
        if (!this.value) return ValueExpression.missing<string>();
        const path = expressionPath(this.path, 'name');
        if (!this.value.isLoaded('name')) {
            return ValueExpression.notLoaded<string>(
                new TeaQLNotLoadedError(this.root, path, 'name'),
            );
        }
        return new ValueExpression<string>(this.value.name);
    }

    version(): ValueExpression<number> {
        if (this.notLoaded) return ValueExpression.notLoaded<number>(this.notLoaded);
        if (!this.value) return ValueExpression.missing<number>();
        const path = expressionPath(this.path, 'version');
        if (!this.value.isLoaded('version')) {
            return ValueExpression.notLoaded<number>(
                new TeaQLNotLoadedError(this.root, path, 'version'),
            );
        }
        return new ValueExpression<number>(this.value.version);
    }



    customerOrderList(): CustomerOrderListExpression {
        const path = expressionPath(this.path, 'customerOrderList');
        if (this.notLoaded) {
            return new CustomerOrderListExpression([], this.root, path, false, this.notLoaded);
        }
        if (!this.value) return CustomerOrderListExpression.missing(this.root, path);
        if (!this.value.isLoaded('customerOrderList')) {
            return new CustomerOrderListExpression([], this.root, path, false,
                new TeaQLNotLoadedError(this.root, path, 'customerOrderList'));
        }
        return new CustomerOrderListExpression(
            this.value.customerOrderList(), this.root, path,
        );
    }
}

export class CustomerOrderExpression {
    constructor(
        private readonly value: CustomerOrder | null | undefined,
        private readonly root = 'CustomerOrder(null)',
        private readonly path = '',
        private readonly notLoaded?: TeaQLNotLoadedError,
    ) {}

    eval(): CustomerOrder | null | undefined {
        if (this.notLoaded) throw this.notLoaded;
        return this.value;
    }

    id(): ValueExpression<string> {
        if (this.notLoaded) return ValueExpression.notLoaded<string>(this.notLoaded);
        if (!this.value) return ValueExpression.missing<string>();
        const path = expressionPath(this.path, 'id');
        if (!this.value.isLoaded('id')) {
            return ValueExpression.notLoaded<string>(
                new TeaQLNotLoadedError(this.root, path, 'id'),
            );
        }
        return new ValueExpression<string>(this.value.id);
    }

    orderNumber(): ValueExpression<string> {
        if (this.notLoaded) return ValueExpression.notLoaded<string>(this.notLoaded);
        if (!this.value) return ValueExpression.missing<string>();
        const path = expressionPath(this.path, 'orderNumber');
        if (!this.value.isLoaded('orderNumber')) {
            return ValueExpression.notLoaded<string>(
                new TeaQLNotLoadedError(this.root, path, 'orderNumber'),
            );
        }
        return new ValueExpression<string>(this.value.orderNumber);
    }

    description(): ValueExpression<string> {
        if (this.notLoaded) return ValueExpression.notLoaded<string>(this.notLoaded);
        if (!this.value) return ValueExpression.missing<string>();
        const path = expressionPath(this.path, 'description');
        if (!this.value.isLoaded('description')) {
            return ValueExpression.notLoaded<string>(
                new TeaQLNotLoadedError(this.root, path, 'description'),
            );
        }
        return new ValueExpression<string>(this.value.description);
    }

    version(): ValueExpression<number> {
        if (this.notLoaded) return ValueExpression.notLoaded<number>(this.notLoaded);
        if (!this.value) return ValueExpression.missing<number>();
        const path = expressionPath(this.path, 'version');
        if (!this.value.isLoaded('version')) {
            return ValueExpression.notLoaded<number>(
                new TeaQLNotLoadedError(this.root, path, 'version'),
            );
        }
        return new ValueExpression<number>(this.value.version);
    }

    platformId(): ValueExpression<string | number> {
        if (this.notLoaded) return ValueExpression.notLoaded<string | number>(this.notLoaded);
        if (!this.value) return ValueExpression.missing<string | number>();
        const path = expressionPath(this.path, 'platform');
        if (!this.value.isLoaded('platform')) {
            return ValueExpression.notLoaded<string | number>(
                new TeaQLNotLoadedError(this.root, path, 'platform'),
            );
        }
        const reference = this.value.platform;
        return new ValueExpression<string | number>(
            reference instanceof Platform
                ? reference.id : reference as string | number | undefined,
        );
    }

    platform(): PlatformExpression {
        const path = expressionPath(this.path, 'platform');
        if (this.notLoaded) {
            return new PlatformExpression(undefined, this.root, path, this.notLoaded);
        }
        if (!this.value) return new PlatformExpression(undefined, this.root, path);
        if (!this.value.isLoaded('platform')) {
            return new PlatformExpression(undefined, this.root, path,
                new TeaQLNotLoadedError(this.root, path, 'platform'));
        }
        const relation = this.value.platform;
        const target = relation == null
            ? undefined
            : relation instanceof Platform
                ? relation
                : Platform.fromRecord({ id: relation });
        return new PlatformExpression(target, this.root, path);
    }

    orderItemList(): OrderItemListExpression {
        const path = expressionPath(this.path, 'orderItemList');
        if (this.notLoaded) {
            return new OrderItemListExpression([], this.root, path, false, this.notLoaded);
        }
        if (!this.value) return OrderItemListExpression.missing(this.root, path);
        if (!this.value.isLoaded('orderItemList')) {
            return new OrderItemListExpression([], this.root, path, false,
                new TeaQLNotLoadedError(this.root, path, 'orderItemList'));
        }
        return new OrderItemListExpression(
            this.value.orderItemList(), this.root, path,
        );
    }

    paymentList(): PaymentListExpression {
        const path = expressionPath(this.path, 'paymentList');
        if (this.notLoaded) {
            return new PaymentListExpression([], this.root, path, false, this.notLoaded);
        }
        if (!this.value) return PaymentListExpression.missing(this.root, path);
        if (!this.value.isLoaded('paymentList')) {
            return new PaymentListExpression([], this.root, path, false,
                new TeaQLNotLoadedError(this.root, path, 'paymentList'));
        }
        return new PaymentListExpression(
            this.value.paymentList(), this.root, path,
        );
    }

    shipmentList(): ShipmentListExpression {
        const path = expressionPath(this.path, 'shipmentList');
        if (this.notLoaded) {
            return new ShipmentListExpression([], this.root, path, false, this.notLoaded);
        }
        if (!this.value) return ShipmentListExpression.missing(this.root, path);
        if (!this.value.isLoaded('shipmentList')) {
            return new ShipmentListExpression([], this.root, path, false,
                new TeaQLNotLoadedError(this.root, path, 'shipmentList'));
        }
        return new ShipmentListExpression(
            this.value.shipmentList(), this.root, path,
        );
    }
}

export class OrderItemExpression {
    constructor(
        private readonly value: OrderItem | null | undefined,
        private readonly root = 'OrderItem(null)',
        private readonly path = '',
        private readonly notLoaded?: TeaQLNotLoadedError,
    ) {}

    eval(): OrderItem | null | undefined {
        if (this.notLoaded) throw this.notLoaded;
        return this.value;
    }

    id(): ValueExpression<string> {
        if (this.notLoaded) return ValueExpression.notLoaded<string>(this.notLoaded);
        if (!this.value) return ValueExpression.missing<string>();
        const path = expressionPath(this.path, 'id');
        if (!this.value.isLoaded('id')) {
            return ValueExpression.notLoaded<string>(
                new TeaQLNotLoadedError(this.root, path, 'id'),
            );
        }
        return new ValueExpression<string>(this.value.id);
    }

    name(): ValueExpression<string> {
        if (this.notLoaded) return ValueExpression.notLoaded<string>(this.notLoaded);
        if (!this.value) return ValueExpression.missing<string>();
        const path = expressionPath(this.path, 'name');
        if (!this.value.isLoaded('name')) {
            return ValueExpression.notLoaded<string>(
                new TeaQLNotLoadedError(this.root, path, 'name'),
            );
        }
        return new ValueExpression<string>(this.value.name);
    }

    version(): ValueExpression<number> {
        if (this.notLoaded) return ValueExpression.notLoaded<number>(this.notLoaded);
        if (!this.value) return ValueExpression.missing<number>();
        const path = expressionPath(this.path, 'version');
        if (!this.value.isLoaded('version')) {
            return ValueExpression.notLoaded<number>(
                new TeaQLNotLoadedError(this.root, path, 'version'),
            );
        }
        return new ValueExpression<number>(this.value.version);
    }

    customerOrderId(): ValueExpression<string | number> {
        if (this.notLoaded) return ValueExpression.notLoaded<string | number>(this.notLoaded);
        if (!this.value) return ValueExpression.missing<string | number>();
        const path = expressionPath(this.path, 'customerOrder');
        if (!this.value.isLoaded('customerOrder')) {
            return ValueExpression.notLoaded<string | number>(
                new TeaQLNotLoadedError(this.root, path, 'customerOrder'),
            );
        }
        const reference = this.value.customerOrder;
        return new ValueExpression<string | number>(
            reference instanceof CustomerOrder
                ? reference.id : reference as string | number | undefined,
        );
    }

    customerOrder(): CustomerOrderExpression {
        const path = expressionPath(this.path, 'customerOrder');
        if (this.notLoaded) {
            return new CustomerOrderExpression(undefined, this.root, path, this.notLoaded);
        }
        if (!this.value) return new CustomerOrderExpression(undefined, this.root, path);
        if (!this.value.isLoaded('customerOrder')) {
            return new CustomerOrderExpression(undefined, this.root, path,
                new TeaQLNotLoadedError(this.root, path, 'customerOrder'));
        }
        const relation = this.value.customerOrder;
        const target = relation == null
            ? undefined
            : relation instanceof CustomerOrder
                ? relation
                : CustomerOrder.fromRecord({ id: relation });
        return new CustomerOrderExpression(target, this.root, path);
    }

}

export class PaymentExpression {
    constructor(
        private readonly value: Payment | null | undefined,
        private readonly root = 'Payment(null)',
        private readonly path = '',
        private readonly notLoaded?: TeaQLNotLoadedError,
    ) {}

    eval(): Payment | null | undefined {
        if (this.notLoaded) throw this.notLoaded;
        return this.value;
    }

    id(): ValueExpression<string> {
        if (this.notLoaded) return ValueExpression.notLoaded<string>(this.notLoaded);
        if (!this.value) return ValueExpression.missing<string>();
        const path = expressionPath(this.path, 'id');
        if (!this.value.isLoaded('id')) {
            return ValueExpression.notLoaded<string>(
                new TeaQLNotLoadedError(this.root, path, 'id'),
            );
        }
        return new ValueExpression<string>(this.value.id);
    }

    referenceCode(): ValueExpression<string> {
        if (this.notLoaded) return ValueExpression.notLoaded<string>(this.notLoaded);
        if (!this.value) return ValueExpression.missing<string>();
        const path = expressionPath(this.path, 'referenceCode');
        if (!this.value.isLoaded('referenceCode')) {
            return ValueExpression.notLoaded<string>(
                new TeaQLNotLoadedError(this.root, path, 'referenceCode'),
            );
        }
        return new ValueExpression<string>(this.value.referenceCode);
    }

    version(): ValueExpression<number> {
        if (this.notLoaded) return ValueExpression.notLoaded<number>(this.notLoaded);
        if (!this.value) return ValueExpression.missing<number>();
        const path = expressionPath(this.path, 'version');
        if (!this.value.isLoaded('version')) {
            return ValueExpression.notLoaded<number>(
                new TeaQLNotLoadedError(this.root, path, 'version'),
            );
        }
        return new ValueExpression<number>(this.value.version);
    }

    customerOrderId(): ValueExpression<string | number> {
        if (this.notLoaded) return ValueExpression.notLoaded<string | number>(this.notLoaded);
        if (!this.value) return ValueExpression.missing<string | number>();
        const path = expressionPath(this.path, 'customerOrder');
        if (!this.value.isLoaded('customerOrder')) {
            return ValueExpression.notLoaded<string | number>(
                new TeaQLNotLoadedError(this.root, path, 'customerOrder'),
            );
        }
        const reference = this.value.customerOrder;
        return new ValueExpression<string | number>(
            reference instanceof CustomerOrder
                ? reference.id : reference as string | number | undefined,
        );
    }

    customerOrder(): CustomerOrderExpression {
        const path = expressionPath(this.path, 'customerOrder');
        if (this.notLoaded) {
            return new CustomerOrderExpression(undefined, this.root, path, this.notLoaded);
        }
        if (!this.value) return new CustomerOrderExpression(undefined, this.root, path);
        if (!this.value.isLoaded('customerOrder')) {
            return new CustomerOrderExpression(undefined, this.root, path,
                new TeaQLNotLoadedError(this.root, path, 'customerOrder'));
        }
        const relation = this.value.customerOrder;
        const target = relation == null
            ? undefined
            : relation instanceof CustomerOrder
                ? relation
                : CustomerOrder.fromRecord({ id: relation });
        return new CustomerOrderExpression(target, this.root, path);
    }

    paymentAttemptList(): PaymentAttemptListExpression {
        const path = expressionPath(this.path, 'paymentAttemptList');
        if (this.notLoaded) {
            return new PaymentAttemptListExpression([], this.root, path, false, this.notLoaded);
        }
        if (!this.value) return PaymentAttemptListExpression.missing(this.root, path);
        if (!this.value.isLoaded('paymentAttemptList')) {
            return new PaymentAttemptListExpression([], this.root, path, false,
                new TeaQLNotLoadedError(this.root, path, 'paymentAttemptList'));
        }
        return new PaymentAttemptListExpression(
            this.value.paymentAttemptList(), this.root, path,
        );
    }
}

export class PaymentAttemptExpression {
    constructor(
        private readonly value: PaymentAttempt | null | undefined,
        private readonly root = 'PaymentAttempt(null)',
        private readonly path = '',
        private readonly notLoaded?: TeaQLNotLoadedError,
    ) {}

    eval(): PaymentAttempt | null | undefined {
        if (this.notLoaded) throw this.notLoaded;
        return this.value;
    }

    id(): ValueExpression<string> {
        if (this.notLoaded) return ValueExpression.notLoaded<string>(this.notLoaded);
        if (!this.value) return ValueExpression.missing<string>();
        const path = expressionPath(this.path, 'id');
        if (!this.value.isLoaded('id')) {
            return ValueExpression.notLoaded<string>(
                new TeaQLNotLoadedError(this.root, path, 'id'),
            );
        }
        return new ValueExpression<string>(this.value.id);
    }

    referenceCode(): ValueExpression<string> {
        if (this.notLoaded) return ValueExpression.notLoaded<string>(this.notLoaded);
        if (!this.value) return ValueExpression.missing<string>();
        const path = expressionPath(this.path, 'referenceCode');
        if (!this.value.isLoaded('referenceCode')) {
            return ValueExpression.notLoaded<string>(
                new TeaQLNotLoadedError(this.root, path, 'referenceCode'),
            );
        }
        return new ValueExpression<string>(this.value.referenceCode);
    }

    version(): ValueExpression<number> {
        if (this.notLoaded) return ValueExpression.notLoaded<number>(this.notLoaded);
        if (!this.value) return ValueExpression.missing<number>();
        const path = expressionPath(this.path, 'version');
        if (!this.value.isLoaded('version')) {
            return ValueExpression.notLoaded<number>(
                new TeaQLNotLoadedError(this.root, path, 'version'),
            );
        }
        return new ValueExpression<number>(this.value.version);
    }

    paymentId(): ValueExpression<string | number> {
        if (this.notLoaded) return ValueExpression.notLoaded<string | number>(this.notLoaded);
        if (!this.value) return ValueExpression.missing<string | number>();
        const path = expressionPath(this.path, 'payment');
        if (!this.value.isLoaded('payment')) {
            return ValueExpression.notLoaded<string | number>(
                new TeaQLNotLoadedError(this.root, path, 'payment'),
            );
        }
        const reference = this.value.payment;
        return new ValueExpression<string | number>(
            reference instanceof Payment
                ? reference.id : reference as string | number | undefined,
        );
    }

    payment(): PaymentExpression {
        const path = expressionPath(this.path, 'payment');
        if (this.notLoaded) {
            return new PaymentExpression(undefined, this.root, path, this.notLoaded);
        }
        if (!this.value) return new PaymentExpression(undefined, this.root, path);
        if (!this.value.isLoaded('payment')) {
            return new PaymentExpression(undefined, this.root, path,
                new TeaQLNotLoadedError(this.root, path, 'payment'));
        }
        const relation = this.value.payment;
        const target = relation == null
            ? undefined
            : relation instanceof Payment
                ? relation
                : Payment.fromRecord({ id: relation });
        return new PaymentExpression(target, this.root, path);
    }

}

export class ShipmentExpression {
    constructor(
        private readonly value: Shipment | null | undefined,
        private readonly root = 'Shipment(null)',
        private readonly path = '',
        private readonly notLoaded?: TeaQLNotLoadedError,
    ) {}

    eval(): Shipment | null | undefined {
        if (this.notLoaded) throw this.notLoaded;
        return this.value;
    }

    id(): ValueExpression<string> {
        if (this.notLoaded) return ValueExpression.notLoaded<string>(this.notLoaded);
        if (!this.value) return ValueExpression.missing<string>();
        const path = expressionPath(this.path, 'id');
        if (!this.value.isLoaded('id')) {
            return ValueExpression.notLoaded<string>(
                new TeaQLNotLoadedError(this.root, path, 'id'),
            );
        }
        return new ValueExpression<string>(this.value.id);
    }

    referenceCode(): ValueExpression<string> {
        if (this.notLoaded) return ValueExpression.notLoaded<string>(this.notLoaded);
        if (!this.value) return ValueExpression.missing<string>();
        const path = expressionPath(this.path, 'referenceCode');
        if (!this.value.isLoaded('referenceCode')) {
            return ValueExpression.notLoaded<string>(
                new TeaQLNotLoadedError(this.root, path, 'referenceCode'),
            );
        }
        return new ValueExpression<string>(this.value.referenceCode);
    }

    version(): ValueExpression<number> {
        if (this.notLoaded) return ValueExpression.notLoaded<number>(this.notLoaded);
        if (!this.value) return ValueExpression.missing<number>();
        const path = expressionPath(this.path, 'version');
        if (!this.value.isLoaded('version')) {
            return ValueExpression.notLoaded<number>(
                new TeaQLNotLoadedError(this.root, path, 'version'),
            );
        }
        return new ValueExpression<number>(this.value.version);
    }

    customerOrderId(): ValueExpression<string | number> {
        if (this.notLoaded) return ValueExpression.notLoaded<string | number>(this.notLoaded);
        if (!this.value) return ValueExpression.missing<string | number>();
        const path = expressionPath(this.path, 'customerOrder');
        if (!this.value.isLoaded('customerOrder')) {
            return ValueExpression.notLoaded<string | number>(
                new TeaQLNotLoadedError(this.root, path, 'customerOrder'),
            );
        }
        const reference = this.value.customerOrder;
        return new ValueExpression<string | number>(
            reference instanceof CustomerOrder
                ? reference.id : reference as string | number | undefined,
        );
    }

    customerOrder(): CustomerOrderExpression {
        const path = expressionPath(this.path, 'customerOrder');
        if (this.notLoaded) {
            return new CustomerOrderExpression(undefined, this.root, path, this.notLoaded);
        }
        if (!this.value) return new CustomerOrderExpression(undefined, this.root, path);
        if (!this.value.isLoaded('customerOrder')) {
            return new CustomerOrderExpression(undefined, this.root, path,
                new TeaQLNotLoadedError(this.root, path, 'customerOrder'));
        }
        const relation = this.value.customerOrder;
        const target = relation == null
            ? undefined
            : relation instanceof CustomerOrder
                ? relation
                : CustomerOrder.fromRecord({ id: relation });
        return new CustomerOrderExpression(target, this.root, path);
    }

}

export class PlatformListExpression {
    constructor(
        private readonly items: readonly Platform[],
        private readonly root = 'Platform(null)',
        private readonly path = '',
        private readonly present = true,
        private readonly notLoaded?: TeaQLNotLoadedError,
    ) {}

    static missing(root?: string, path = ''): PlatformListExpression {
        return new PlatformListExpression([], root, path, false);
    }

    size(): ValueExpression<number> {
        if (this.notLoaded) return ValueExpression.notLoaded<number>(this.notLoaded);
        return this.present
            ? new ValueExpression<number>(this.items.length)
            : ValueExpression.missing<number>();
    }

    first(): PlatformExpression {
        return this.get(0);
    }

    get(index: number): PlatformExpression {
        const itemPath = expressionPath(this.path, `get(${index})`);
        if (this.notLoaded) {
            return new PlatformExpression(undefined, this.root, itemPath, this.notLoaded);
        }
        return !this.present || index < 0 || index >= this.items.length
            ? new PlatformExpression(undefined, this.root, itemPath)
            : new PlatformExpression(this.items[index], this.root, itemPath);
    }
}

export class CustomerOrderListExpression {
    constructor(
        private readonly items: readonly CustomerOrder[],
        private readonly root = 'CustomerOrder(null)',
        private readonly path = '',
        private readonly present = true,
        private readonly notLoaded?: TeaQLNotLoadedError,
    ) {}

    static missing(root?: string, path = ''): CustomerOrderListExpression {
        return new CustomerOrderListExpression([], root, path, false);
    }

    size(): ValueExpression<number> {
        if (this.notLoaded) return ValueExpression.notLoaded<number>(this.notLoaded);
        return this.present
            ? new ValueExpression<number>(this.items.length)
            : ValueExpression.missing<number>();
    }

    first(): CustomerOrderExpression {
        return this.get(0);
    }

    get(index: number): CustomerOrderExpression {
        const itemPath = expressionPath(this.path, `get(${index})`);
        if (this.notLoaded) {
            return new CustomerOrderExpression(undefined, this.root, itemPath, this.notLoaded);
        }
        return !this.present || index < 0 || index >= this.items.length
            ? new CustomerOrderExpression(undefined, this.root, itemPath)
            : new CustomerOrderExpression(this.items[index], this.root, itemPath);
    }
}

export class OrderItemListExpression {
    constructor(
        private readonly items: readonly OrderItem[],
        private readonly root = 'OrderItem(null)',
        private readonly path = '',
        private readonly present = true,
        private readonly notLoaded?: TeaQLNotLoadedError,
    ) {}

    static missing(root?: string, path = ''): OrderItemListExpression {
        return new OrderItemListExpression([], root, path, false);
    }

    size(): ValueExpression<number> {
        if (this.notLoaded) return ValueExpression.notLoaded<number>(this.notLoaded);
        return this.present
            ? new ValueExpression<number>(this.items.length)
            : ValueExpression.missing<number>();
    }

    first(): OrderItemExpression {
        return this.get(0);
    }

    get(index: number): OrderItemExpression {
        const itemPath = expressionPath(this.path, `get(${index})`);
        if (this.notLoaded) {
            return new OrderItemExpression(undefined, this.root, itemPath, this.notLoaded);
        }
        return !this.present || index < 0 || index >= this.items.length
            ? new OrderItemExpression(undefined, this.root, itemPath)
            : new OrderItemExpression(this.items[index], this.root, itemPath);
    }
}

export class PaymentListExpression {
    constructor(
        private readonly items: readonly Payment[],
        private readonly root = 'Payment(null)',
        private readonly path = '',
        private readonly present = true,
        private readonly notLoaded?: TeaQLNotLoadedError,
    ) {}

    static missing(root?: string, path = ''): PaymentListExpression {
        return new PaymentListExpression([], root, path, false);
    }

    size(): ValueExpression<number> {
        if (this.notLoaded) return ValueExpression.notLoaded<number>(this.notLoaded);
        return this.present
            ? new ValueExpression<number>(this.items.length)
            : ValueExpression.missing<number>();
    }

    first(): PaymentExpression {
        return this.get(0);
    }

    get(index: number): PaymentExpression {
        const itemPath = expressionPath(this.path, `get(${index})`);
        if (this.notLoaded) {
            return new PaymentExpression(undefined, this.root, itemPath, this.notLoaded);
        }
        return !this.present || index < 0 || index >= this.items.length
            ? new PaymentExpression(undefined, this.root, itemPath)
            : new PaymentExpression(this.items[index], this.root, itemPath);
    }
}

export class PaymentAttemptListExpression {
    constructor(
        private readonly items: readonly PaymentAttempt[],
        private readonly root = 'PaymentAttempt(null)',
        private readonly path = '',
        private readonly present = true,
        private readonly notLoaded?: TeaQLNotLoadedError,
    ) {}

    static missing(root?: string, path = ''): PaymentAttemptListExpression {
        return new PaymentAttemptListExpression([], root, path, false);
    }

    size(): ValueExpression<number> {
        if (this.notLoaded) return ValueExpression.notLoaded<number>(this.notLoaded);
        return this.present
            ? new ValueExpression<number>(this.items.length)
            : ValueExpression.missing<number>();
    }

    first(): PaymentAttemptExpression {
        return this.get(0);
    }

    get(index: number): PaymentAttemptExpression {
        const itemPath = expressionPath(this.path, `get(${index})`);
        if (this.notLoaded) {
            return new PaymentAttemptExpression(undefined, this.root, itemPath, this.notLoaded);
        }
        return !this.present || index < 0 || index >= this.items.length
            ? new PaymentAttemptExpression(undefined, this.root, itemPath)
            : new PaymentAttemptExpression(this.items[index], this.root, itemPath);
    }
}

export class ShipmentListExpression {
    constructor(
        private readonly items: readonly Shipment[],
        private readonly root = 'Shipment(null)',
        private readonly path = '',
        private readonly present = true,
        private readonly notLoaded?: TeaQLNotLoadedError,
    ) {}

    static missing(root?: string, path = ''): ShipmentListExpression {
        return new ShipmentListExpression([], root, path, false);
    }

    size(): ValueExpression<number> {
        if (this.notLoaded) return ValueExpression.notLoaded<number>(this.notLoaded);
        return this.present
            ? new ValueExpression<number>(this.items.length)
            : ValueExpression.missing<number>();
    }

    first(): ShipmentExpression {
        return this.get(0);
    }

    get(index: number): ShipmentExpression {
        const itemPath = expressionPath(this.path, `get(${index})`);
        if (this.notLoaded) {
            return new ShipmentExpression(undefined, this.root, itemPath, this.notLoaded);
        }
        return !this.present || index < 0 || index >= this.items.length
            ? new ShipmentExpression(undefined, this.root, itemPath)
            : new ShipmentExpression(this.items[index], this.root, itemPath);
    }
}

export class E {
    static platform(
        value: Platform | null | undefined,
    ): PlatformExpression {
        return new PlatformExpression(
            value, `Platform(id=${value?.id ?? 'null'})`,
        );
    }

    static customerOrder(
        value: CustomerOrder | null | undefined,
    ): CustomerOrderExpression {
        return new CustomerOrderExpression(
            value, `CustomerOrder(id=${value?.id ?? 'null'})`,
        );
    }

    static orderItem(
        value: OrderItem | null | undefined,
    ): OrderItemExpression {
        return new OrderItemExpression(
            value, `OrderItem(id=${value?.id ?? 'null'})`,
        );
    }

    static payment(
        value: Payment | null | undefined,
    ): PaymentExpression {
        return new PaymentExpression(
            value, `Payment(id=${value?.id ?? 'null'})`,
        );
    }

    static paymentAttempt(
        value: PaymentAttempt | null | undefined,
    ): PaymentAttemptExpression {
        return new PaymentAttemptExpression(
            value, `PaymentAttempt(id=${value?.id ?? 'null'})`,
        );
    }

    static shipment(
        value: Shipment | null | undefined,
    ): ShipmentExpression {
        return new ShipmentExpression(
            value, `Shipment(id=${value?.id ?? 'null'})`,
        );
    }
}